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, Aquaero, Aquastream Ultimate) 5 * 6 * Aquacomputer devices send HID reports (with ID 0x01) every second to report 7 * sensor values, except for devices that communicate through the 8 * legacy way (currently, Poweradjust 3). 9 * 10 * Copyright 2021 Aleksa Savic <savicaleksa83@gmail.com> 11 * Copyright 2022 Jack Doan <me@jackdoan.com> 12 */ 13 14 #include <linux/crc16.h> 15 #include <linux/debugfs.h> 16 #include <linux/hid.h> 17 #include <linux/hwmon.h> 18 #include <linux/jiffies.h> 19 #include <linux/module.h> 20 #include <linux/mutex.h> 21 #include <linux/seq_file.h> 22 #include <asm/unaligned.h> 23 24 #define USB_VENDOR_ID_AQUACOMPUTER 0x0c70 25 #define USB_PRODUCT_ID_AQUAERO 0xf001 26 #define USB_PRODUCT_ID_FARBWERK 0xf00a 27 #define USB_PRODUCT_ID_QUADRO 0xf00d 28 #define USB_PRODUCT_ID_D5NEXT 0xf00e 29 #define USB_PRODUCT_ID_FARBWERK360 0xf010 30 #define USB_PRODUCT_ID_OCTO 0xf011 31 #define USB_PRODUCT_ID_HIGHFLOWNEXT 0xf012 32 #define USB_PRODUCT_ID_AQUASTREAMULT 0xf00b 33 #define USB_PRODUCT_ID_POWERADJUST3 0xf0bd 34 35 enum kinds { 36 d5next, farbwerk, farbwerk360, octo, quadro, 37 highflownext, aquaero, poweradjust3, aquastreamult 38 }; 39 40 static const char *const aqc_device_names[] = { 41 [d5next] = "d5next", 42 [farbwerk] = "farbwerk", 43 [farbwerk360] = "farbwerk360", 44 [octo] = "octo", 45 [quadro] = "quadro", 46 [highflownext] = "highflownext", 47 [aquaero] = "aquaero", 48 [aquastreamult] = "aquastreamultimate", 49 [poweradjust3] = "poweradjust3" 50 }; 51 52 #define DRIVER_NAME "aquacomputer_d5next" 53 54 #define STATUS_REPORT_ID 0x01 55 #define STATUS_UPDATE_INTERVAL (2 * HZ) /* In seconds */ 56 #define SERIAL_PART_OFFSET 2 57 58 #define CTRL_REPORT_ID 0x03 59 #define AQUAERO_CTRL_REPORT_ID 0x0b 60 61 /* The HID report that the official software always sends 62 * after writing values, currently same for all devices 63 */ 64 #define SECONDARY_CTRL_REPORT_ID 0x02 65 #define SECONDARY_CTRL_REPORT_SIZE 0x0B 66 67 static u8 secondary_ctrl_report[] = { 68 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x34, 0xC6 69 }; 70 71 /* Secondary HID report values for Aquaero */ 72 #define AQUAERO_SECONDARY_CTRL_REPORT_ID 0x06 73 #define AQUAERO_SECONDARY_CTRL_REPORT_SIZE 0x07 74 75 static u8 aquaero_secondary_ctrl_report[] = { 76 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 77 }; 78 79 /* Report IDs for legacy devices */ 80 #define POWERADJUST3_STATUS_REPORT_ID 0x03 81 82 /* Data types for reading and writing control reports */ 83 #define AQC_8 0 84 #define AQC_BE16 1 85 86 /* Info, sensor sizes and offsets for most Aquacomputer devices */ 87 #define AQC_SERIAL_START 0x3 88 #define AQC_FIRMWARE_VERSION 0xD 89 90 #define AQC_SENSOR_SIZE 0x02 91 #define AQC_TEMP_SENSOR_DISCONNECTED 0x7FFF 92 #define AQC_FAN_PERCENT_OFFSET 0x00 93 #define AQC_FAN_VOLTAGE_OFFSET 0x02 94 #define AQC_FAN_CURRENT_OFFSET 0x04 95 #define AQC_FAN_POWER_OFFSET 0x06 96 #define AQC_FAN_SPEED_OFFSET 0x08 97 98 /* Specs of the Aquaero fan controllers */ 99 #define AQUAERO_SERIAL_START 0x07 100 #define AQUAERO_FIRMWARE_VERSION 0x0B 101 #define AQUAERO_NUM_FANS 4 102 #define AQUAERO_NUM_SENSORS 8 103 #define AQUAERO_NUM_VIRTUAL_SENSORS 8 104 #define AQUAERO_NUM_CALC_VIRTUAL_SENSORS 4 105 #define AQUAERO_NUM_FLOW_SENSORS 2 106 #define AQUAERO_CTRL_REPORT_SIZE 0xa93 107 #define AQUAERO_CTRL_PRESET_ID 0x5c 108 #define AQUAERO_CTRL_PRESET_SIZE 0x02 109 #define AQUAERO_CTRL_PRESET_START 0x55c 110 111 /* Sensor report offsets for Aquaero fan controllers */ 112 #define AQUAERO_SENSOR_START 0x65 113 #define AQUAERO_VIRTUAL_SENSOR_START 0x85 114 #define AQUAERO_CALC_VIRTUAL_SENSOR_START 0x95 115 #define AQUAERO_FLOW_SENSORS_START 0xF9 116 #define AQUAERO_FAN_VOLTAGE_OFFSET 0x04 117 #define AQUAERO_FAN_CURRENT_OFFSET 0x06 118 #define AQUAERO_FAN_POWER_OFFSET 0x08 119 #define AQUAERO_FAN_SPEED_OFFSET 0x00 120 static u16 aquaero_sensor_fan_offsets[] = { 0x167, 0x173, 0x17f, 0x18B }; 121 122 /* Control report offsets for the Aquaero fan controllers */ 123 #define AQUAERO_TEMP_CTRL_OFFSET 0xdb 124 #define AQUAERO_FAN_CTRL_MIN_PWR_OFFSET 0x04 125 #define AQUAERO_FAN_CTRL_MAX_PWR_OFFSET 0x06 126 #define AQUAERO_FAN_CTRL_SRC_OFFSET 0x10 127 static u16 aquaero_ctrl_fan_offsets[] = { 0x20c, 0x220, 0x234, 0x248 }; 128 129 /* Specs of the D5 Next pump */ 130 #define D5NEXT_NUM_FANS 2 131 #define D5NEXT_NUM_SENSORS 1 132 #define D5NEXT_NUM_VIRTUAL_SENSORS 8 133 #define D5NEXT_CTRL_REPORT_SIZE 0x329 134 135 /* Sensor report offsets for the D5 Next pump */ 136 #define D5NEXT_POWER_CYCLES 0x18 137 #define D5NEXT_COOLANT_TEMP 0x57 138 #define D5NEXT_PUMP_OFFSET 0x6c 139 #define D5NEXT_FAN_OFFSET 0x5f 140 #define D5NEXT_5V_VOLTAGE 0x39 141 #define D5NEXT_12V_VOLTAGE 0x37 142 #define D5NEXT_VIRTUAL_SENSORS_START 0x3f 143 static u16 d5next_sensor_fan_offsets[] = { D5NEXT_PUMP_OFFSET, D5NEXT_FAN_OFFSET }; 144 145 /* Control report offsets for the D5 Next pump */ 146 #define D5NEXT_TEMP_CTRL_OFFSET 0x2D /* Temperature sensor offsets location */ 147 static u16 d5next_ctrl_fan_offsets[] = { 0x97, 0x42 }; /* Pump and fan speed (from 0-100%) */ 148 149 /* Specs of the Aquastream Ultimate pump */ 150 /* Pump does not follow the standard structure, so only consider the fan */ 151 #define AQUASTREAMULT_NUM_FANS 1 152 #define AQUASTREAMULT_NUM_SENSORS 2 153 154 /* Sensor report offsets for the Aquastream Ultimate pump */ 155 #define AQUASTREAMULT_SENSOR_START 0x2D 156 #define AQUASTREAMULT_PUMP_OFFSET 0x51 157 #define AQUASTREAMULT_PUMP_VOLTAGE 0x3D 158 #define AQUASTREAMULT_PUMP_CURRENT 0x53 159 #define AQUASTREAMULT_PUMP_POWER 0x55 160 #define AQUASTREAMULT_FAN_OFFSET 0x41 161 #define AQUASTREAMULT_PRESSURE_OFFSET 0x57 162 #define AQUASTREAMULT_FLOW_SENSOR_OFFSET 0x37 163 #define AQUASTREAMULT_FAN_VOLTAGE_OFFSET 0x02 164 #define AQUASTREAMULT_FAN_CURRENT_OFFSET 0x00 165 #define AQUASTREAMULT_FAN_POWER_OFFSET 0x04 166 #define AQUASTREAMULT_FAN_SPEED_OFFSET 0x06 167 static u16 aquastreamult_sensor_fan_offsets[] = { AQUASTREAMULT_FAN_OFFSET }; 168 169 /* Spec and sensor report offset for the Farbwerk RGB controller */ 170 #define FARBWERK_NUM_SENSORS 4 171 #define FARBWERK_SENSOR_START 0x2f 172 173 /* Specs of the Farbwerk 360 RGB controller */ 174 #define FARBWERK360_NUM_SENSORS 4 175 #define FARBWERK360_NUM_VIRTUAL_SENSORS 16 176 #define FARBWERK360_CTRL_REPORT_SIZE 0x682 177 178 /* Sensor report offsets for the Farbwerk 360 */ 179 #define FARBWERK360_SENSOR_START 0x32 180 #define FARBWERK360_VIRTUAL_SENSORS_START 0x3a 181 182 /* Control report offsets for the Farbwerk 360 */ 183 #define FARBWERK360_TEMP_CTRL_OFFSET 0x8 184 185 /* Specs of the Octo fan controller */ 186 #define OCTO_NUM_FANS 8 187 #define OCTO_NUM_SENSORS 4 188 #define OCTO_NUM_VIRTUAL_SENSORS 16 189 #define OCTO_CTRL_REPORT_SIZE 0x65F 190 191 /* Sensor report offsets for the Octo */ 192 #define OCTO_POWER_CYCLES 0x18 193 #define OCTO_SENSOR_START 0x3D 194 #define OCTO_VIRTUAL_SENSORS_START 0x45 195 static u16 octo_sensor_fan_offsets[] = { 0x7D, 0x8A, 0x97, 0xA4, 0xB1, 0xBE, 0xCB, 0xD8 }; 196 197 /* Control report offsets for the Octo */ 198 #define OCTO_TEMP_CTRL_OFFSET 0xA 199 /* Fan speed offsets (0-100%) */ 200 static u16 octo_ctrl_fan_offsets[] = { 0x5B, 0xB0, 0x105, 0x15A, 0x1AF, 0x204, 0x259, 0x2AE }; 201 202 /* Specs of Quadro fan controller */ 203 #define QUADRO_NUM_FANS 4 204 #define QUADRO_NUM_SENSORS 4 205 #define QUADRO_NUM_VIRTUAL_SENSORS 16 206 #define QUADRO_NUM_FLOW_SENSORS 1 207 #define QUADRO_CTRL_REPORT_SIZE 0x3c1 208 209 /* Sensor report offsets for the Quadro */ 210 #define QUADRO_POWER_CYCLES 0x18 211 #define QUADRO_SENSOR_START 0x34 212 #define QUADRO_VIRTUAL_SENSORS_START 0x3c 213 #define QUADRO_FLOW_SENSOR_OFFSET 0x6e 214 static u16 quadro_sensor_fan_offsets[] = { 0x70, 0x7D, 0x8A, 0x97 }; 215 216 /* Control report offsets for the Quadro */ 217 #define QUADRO_TEMP_CTRL_OFFSET 0xA 218 #define QUADRO_FLOW_PULSES_CTRL_OFFSET 0x6 219 static u16 quadro_ctrl_fan_offsets[] = { 0x37, 0x8c, 0xe1, 0x136 }; /* Fan speed offsets (0-100%) */ 220 221 /* Specs of High Flow Next flow sensor */ 222 #define HIGHFLOWNEXT_NUM_SENSORS 2 223 #define HIGHFLOWNEXT_NUM_FLOW_SENSORS 1 224 225 /* Sensor report offsets for the High Flow Next */ 226 #define HIGHFLOWNEXT_SENSOR_START 85 227 #define HIGHFLOWNEXT_FLOW 81 228 #define HIGHFLOWNEXT_WATER_QUALITY 89 229 #define HIGHFLOWNEXT_POWER 91 230 #define HIGHFLOWNEXT_CONDUCTIVITY 95 231 #define HIGHFLOWNEXT_5V_VOLTAGE 97 232 #define HIGHFLOWNEXT_5V_VOLTAGE_USB 99 233 234 /* Specs of the Poweradjust 3 */ 235 #define POWERADJUST3_NUM_SENSORS 1 236 #define POWERADJUST3_SENSOR_REPORT_SIZE 0x32 237 238 /* Sensor report offsets for the Poweradjust 3 */ 239 #define POWERADJUST3_SENSOR_START 0x03 240 241 /* Labels for D5 Next */ 242 static const char *const label_d5next_temp[] = { 243 "Coolant temp" 244 }; 245 246 static const char *const label_d5next_speeds[] = { 247 "Pump speed", 248 "Fan speed" 249 }; 250 251 static const char *const label_d5next_power[] = { 252 "Pump power", 253 "Fan power" 254 }; 255 256 static const char *const label_d5next_voltages[] = { 257 "Pump voltage", 258 "Fan voltage", 259 "+5V voltage", 260 "+12V voltage" 261 }; 262 263 static const char *const label_d5next_current[] = { 264 "Pump current", 265 "Fan current" 266 }; 267 268 /* Labels for Aquaero, Farbwerk, Farbwerk 360 and Octo and Quadro temperature sensors */ 269 static const char *const label_temp_sensors[] = { 270 "Sensor 1", 271 "Sensor 2", 272 "Sensor 3", 273 "Sensor 4", 274 "Sensor 5", 275 "Sensor 6", 276 "Sensor 7", 277 "Sensor 8" 278 }; 279 280 static const char *const label_virtual_temp_sensors[] = { 281 "Virtual sensor 1", 282 "Virtual sensor 2", 283 "Virtual sensor 3", 284 "Virtual sensor 4", 285 "Virtual sensor 5", 286 "Virtual sensor 6", 287 "Virtual sensor 7", 288 "Virtual sensor 8", 289 "Virtual sensor 9", 290 "Virtual sensor 10", 291 "Virtual sensor 11", 292 "Virtual sensor 12", 293 "Virtual sensor 13", 294 "Virtual sensor 14", 295 "Virtual sensor 15", 296 "Virtual sensor 16", 297 }; 298 299 static const char *const label_aquaero_calc_temp_sensors[] = { 300 "Calc. virtual sensor 1", 301 "Calc. virtual sensor 2", 302 "Calc. virtual sensor 3", 303 "Calc. virtual sensor 4" 304 }; 305 306 /* Labels for Octo and Quadro (except speed) */ 307 static const char *const label_fan_speed[] = { 308 "Fan 1 speed", 309 "Fan 2 speed", 310 "Fan 3 speed", 311 "Fan 4 speed", 312 "Fan 5 speed", 313 "Fan 6 speed", 314 "Fan 7 speed", 315 "Fan 8 speed" 316 }; 317 318 static const char *const label_fan_power[] = { 319 "Fan 1 power", 320 "Fan 2 power", 321 "Fan 3 power", 322 "Fan 4 power", 323 "Fan 5 power", 324 "Fan 6 power", 325 "Fan 7 power", 326 "Fan 8 power" 327 }; 328 329 static const char *const label_fan_voltage[] = { 330 "Fan 1 voltage", 331 "Fan 2 voltage", 332 "Fan 3 voltage", 333 "Fan 4 voltage", 334 "Fan 5 voltage", 335 "Fan 6 voltage", 336 "Fan 7 voltage", 337 "Fan 8 voltage" 338 }; 339 340 static const char *const label_fan_current[] = { 341 "Fan 1 current", 342 "Fan 2 current", 343 "Fan 3 current", 344 "Fan 4 current", 345 "Fan 5 current", 346 "Fan 6 current", 347 "Fan 7 current", 348 "Fan 8 current" 349 }; 350 351 /* Labels for Quadro fan speeds */ 352 static const char *const label_quadro_speeds[] = { 353 "Fan 1 speed", 354 "Fan 2 speed", 355 "Fan 3 speed", 356 "Fan 4 speed", 357 "Flow speed [dL/h]" 358 }; 359 360 /* Labels for Aquaero fan speeds */ 361 static const char *const label_aquaero_speeds[] = { 362 "Fan 1 speed", 363 "Fan 2 speed", 364 "Fan 3 speed", 365 "Fan 4 speed", 366 "Flow sensor 1 [dL/h]", 367 "Flow sensor 2 [dL/h]" 368 }; 369 370 /* Labels for High Flow Next */ 371 static const char *const label_highflownext_temp_sensors[] = { 372 "Coolant temp", 373 "External sensor" 374 }; 375 376 static const char *const label_highflownext_fan_speed[] = { 377 "Flow [dL/h]", 378 "Water quality [%]", 379 "Conductivity [nS/cm]", 380 }; 381 382 static const char *const label_highflownext_power[] = { 383 "Dissipated power", 384 }; 385 386 static const char *const label_highflownext_voltage[] = { 387 "+5V voltage", 388 "+5V USB voltage" 389 }; 390 391 /* Labels for Aquastream Ultimate */ 392 static const char *const label_aquastreamult_temp[] = { 393 "Coolant temp", 394 "External temp" 395 }; 396 397 static const char *const label_aquastreamult_speeds[] = { 398 "Fan speed", 399 "Pump speed", 400 "Pressure [mbar]", 401 "Flow speed [dL/h]" 402 }; 403 404 static const char *const label_aquastreamult_power[] = { 405 "Fan power", 406 "Pump power" 407 }; 408 409 static const char *const label_aquastreamult_voltages[] = { 410 "Fan voltage", 411 "Pump voltage" 412 }; 413 414 static const char *const label_aquastreamult_current[] = { 415 "Fan current", 416 "Pump current" 417 }; 418 419 /* Labels for Poweradjust 3 */ 420 static const char *const label_poweradjust3_temp_sensors[] = { 421 "External sensor" 422 }; 423 424 struct aqc_fan_structure_offsets { 425 u8 voltage; 426 u8 curr; 427 u8 power; 428 u8 speed; 429 }; 430 431 /* Fan structure offsets for Aquaero */ 432 static struct aqc_fan_structure_offsets aqc_aquaero_fan_structure = { 433 .voltage = AQUAERO_FAN_VOLTAGE_OFFSET, 434 .curr = AQUAERO_FAN_CURRENT_OFFSET, 435 .power = AQUAERO_FAN_POWER_OFFSET, 436 .speed = AQUAERO_FAN_SPEED_OFFSET 437 }; 438 439 /* Fan structure offsets for Aquastream Ultimate */ 440 static struct aqc_fan_structure_offsets aqc_aquastreamult_fan_structure = { 441 .voltage = AQUASTREAMULT_FAN_VOLTAGE_OFFSET, 442 .curr = AQUASTREAMULT_FAN_CURRENT_OFFSET, 443 .power = AQUASTREAMULT_FAN_POWER_OFFSET, 444 .speed = AQUASTREAMULT_FAN_SPEED_OFFSET 445 }; 446 447 /* Fan structure offsets for all devices except those above */ 448 static struct aqc_fan_structure_offsets aqc_general_fan_structure = { 449 .voltage = AQC_FAN_VOLTAGE_OFFSET, 450 .curr = AQC_FAN_CURRENT_OFFSET, 451 .power = AQC_FAN_POWER_OFFSET, 452 .speed = AQC_FAN_SPEED_OFFSET 453 }; 454 455 struct aqc_data { 456 struct hid_device *hdev; 457 struct device *hwmon_dev; 458 struct dentry *debugfs; 459 struct mutex mutex; /* Used for locking access when reading and writing PWM values */ 460 enum kinds kind; 461 const char *name; 462 463 int status_report_id; /* Used for legacy devices, report is stored in buffer */ 464 int ctrl_report_id; 465 int secondary_ctrl_report_id; 466 int secondary_ctrl_report_size; 467 u8 *secondary_ctrl_report; 468 469 int buffer_size; 470 u8 *buffer; 471 int checksum_start; 472 int checksum_length; 473 int checksum_offset; 474 475 int num_fans; 476 u16 *fan_sensor_offsets; 477 u16 *fan_ctrl_offsets; 478 int num_temp_sensors; 479 int temp_sensor_start_offset; 480 int num_virtual_temp_sensors; 481 int virtual_temp_sensor_start_offset; 482 int num_calc_virt_temp_sensors; 483 int calc_virt_temp_sensor_start_offset; 484 u16 temp_ctrl_offset; 485 u16 power_cycle_count_offset; 486 int num_flow_sensors; 487 u8 flow_sensors_start_offset; 488 u8 flow_pulses_ctrl_offset; 489 struct aqc_fan_structure_offsets *fan_structure; 490 491 /* General info, same across all devices */ 492 u8 serial_number_start_offset; 493 u32 serial_number[2]; 494 u8 firmware_version_offset; 495 u16 firmware_version; 496 497 /* How many times the device was powered on, if available */ 498 u32 power_cycles; 499 500 /* Sensor values */ 501 s32 temp_input[20]; /* Max 4 physical and 16 virtual or 8 physical and 12 virtual */ 502 u16 speed_input[8]; 503 u32 power_input[8]; 504 u16 voltage_input[8]; 505 u16 current_input[8]; 506 507 /* Label values */ 508 const char *const *temp_label; 509 const char *const *virtual_temp_label; 510 const char *const *calc_virt_temp_label; /* For Aquaero */ 511 const char *const *speed_label; 512 const char *const *power_label; 513 const char *const *voltage_label; 514 const char *const *current_label; 515 516 unsigned long updated; 517 }; 518 519 /* Converts from centi-percent */ 520 static int aqc_percent_to_pwm(u16 val) 521 { 522 return DIV_ROUND_CLOSEST(val * 255, 100 * 100); 523 } 524 525 /* Converts to centi-percent */ 526 static int aqc_pwm_to_percent(long val) 527 { 528 if (val < 0 || val > 255) 529 return -EINVAL; 530 531 return DIV_ROUND_CLOSEST(val * 100 * 100, 255); 532 } 533 534 /* Expects the mutex to be locked */ 535 static int aqc_get_ctrl_data(struct aqc_data *priv) 536 { 537 int ret; 538 539 memset(priv->buffer, 0x00, priv->buffer_size); 540 ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size, 541 HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 542 if (ret < 0) 543 ret = -ENODATA; 544 545 return ret; 546 } 547 548 /* Expects the mutex to be locked */ 549 static int aqc_send_ctrl_data(struct aqc_data *priv) 550 { 551 int ret; 552 u16 checksum; 553 554 /* Checksum is not needed for Aquaero */ 555 if (priv->kind != aquaero) { 556 /* Init and xorout value for CRC-16/USB is 0xffff */ 557 checksum = crc16(0xffff, priv->buffer + priv->checksum_start, 558 priv->checksum_length); 559 checksum ^= 0xffff; 560 561 /* Place the new checksum at the end of the report */ 562 put_unaligned_be16(checksum, priv->buffer + priv->checksum_offset); 563 } 564 565 /* Send the patched up report back to the device */ 566 ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size, 567 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 568 if (ret < 0) 569 return ret; 570 571 /* The official software sends this report after every change, so do it here as well */ 572 ret = hid_hw_raw_request(priv->hdev, priv->secondary_ctrl_report_id, 573 priv->secondary_ctrl_report, priv->secondary_ctrl_report_size, 574 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 575 return ret; 576 } 577 578 /* Refreshes the control buffer and stores value at offset in val */ 579 static int aqc_get_ctrl_val(struct aqc_data *priv, int offset, long *val, int type) 580 { 581 int ret; 582 583 mutex_lock(&priv->mutex); 584 585 ret = aqc_get_ctrl_data(priv); 586 if (ret < 0) 587 goto unlock_and_return; 588 589 switch (type) { 590 case AQC_BE16: 591 *val = (s16)get_unaligned_be16(priv->buffer + offset); 592 break; 593 case AQC_8: 594 *val = priv->buffer[offset]; 595 break; 596 default: 597 ret = -EINVAL; 598 } 599 600 unlock_and_return: 601 mutex_unlock(&priv->mutex); 602 return ret; 603 } 604 605 static int aqc_set_ctrl_vals(struct aqc_data *priv, int *offsets, long *vals, int *types, int len) 606 { 607 int ret, i; 608 609 mutex_lock(&priv->mutex); 610 611 ret = aqc_get_ctrl_data(priv); 612 if (ret < 0) 613 goto unlock_and_return; 614 615 for (i = 0; i < len; i++) { 616 switch (types[i]) { 617 case AQC_BE16: 618 put_unaligned_be16((s16)vals[i], priv->buffer + offsets[i]); 619 break; 620 case AQC_8: 621 priv->buffer[offsets[i]] = (u8)vals[i]; 622 break; 623 default: 624 ret = -EINVAL; 625 } 626 } 627 628 if (ret < 0) 629 goto unlock_and_return; 630 631 ret = aqc_send_ctrl_data(priv); 632 633 unlock_and_return: 634 mutex_unlock(&priv->mutex); 635 return ret; 636 } 637 638 static int aqc_set_ctrl_val(struct aqc_data *priv, int offset, long val, int type) 639 { 640 return aqc_set_ctrl_vals(priv, &offset, &val, &type, 1); 641 } 642 643 static umode_t aqc_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel) 644 { 645 const struct aqc_data *priv = data; 646 647 switch (type) { 648 case hwmon_temp: 649 if (channel < priv->num_temp_sensors) { 650 switch (attr) { 651 case hwmon_temp_label: 652 case hwmon_temp_input: 653 return 0444; 654 case hwmon_temp_offset: 655 if (priv->temp_ctrl_offset != 0) 656 return 0644; 657 break; 658 default: 659 break; 660 } 661 } 662 663 if (channel < 664 priv->num_temp_sensors + priv->num_virtual_temp_sensors + 665 priv->num_calc_virt_temp_sensors) 666 switch (attr) { 667 case hwmon_temp_label: 668 case hwmon_temp_input: 669 return 0444; 670 default: 671 break; 672 } 673 break; 674 case hwmon_pwm: 675 if (priv->fan_ctrl_offsets && channel < priv->num_fans) { 676 switch (attr) { 677 case hwmon_pwm_input: 678 return 0644; 679 default: 680 break; 681 } 682 } 683 break; 684 case hwmon_fan: 685 switch (attr) { 686 case hwmon_fan_input: 687 case hwmon_fan_label: 688 switch (priv->kind) { 689 case aquastreamult: 690 /* 691 * Special case to support pump RPM, fan RPM, 692 * pressure and flow sensor 693 */ 694 if (channel < 4) 695 return 0444; 696 break; 697 case highflownext: 698 /* Special case to support flow sensor, water quality 699 * and conductivity 700 */ 701 if (channel < 3) 702 return 0444; 703 break; 704 case aquaero: 705 case quadro: 706 /* Special case to support flow sensors */ 707 if (channel < priv->num_fans + priv->num_flow_sensors) 708 return 0444; 709 break; 710 default: 711 if (channel < priv->num_fans) 712 return 0444; 713 break; 714 } 715 break; 716 case hwmon_fan_pulses: 717 /* Special case for Quadro flow sensor */ 718 if (priv->kind == quadro && channel == priv->num_fans) 719 return 0644; 720 break; 721 default: 722 break; 723 } 724 break; 725 case hwmon_power: 726 switch (priv->kind) { 727 case aquastreamult: 728 /* Special case to support pump and fan power */ 729 if (channel < 2) 730 return 0444; 731 break; 732 case highflownext: 733 /* Special case to support one power sensor */ 734 if (channel == 0) 735 return 0444; 736 break; 737 default: 738 if (channel < priv->num_fans) 739 return 0444; 740 break; 741 } 742 break; 743 case hwmon_curr: 744 switch (priv->kind) { 745 case aquastreamult: 746 /* Special case to support pump and fan current */ 747 if (channel < 2) 748 return 0444; 749 break; 750 default: 751 if (channel < priv->num_fans) 752 return 0444; 753 break; 754 } 755 break; 756 case hwmon_in: 757 switch (priv->kind) { 758 case d5next: 759 /* Special case to support +5V and +12V voltage sensors */ 760 if (channel < priv->num_fans + 2) 761 return 0444; 762 break; 763 case aquastreamult: 764 case highflownext: 765 /* Special case to support two voltage sensors */ 766 if (channel < 2) 767 return 0444; 768 break; 769 default: 770 if (channel < priv->num_fans) 771 return 0444; 772 break; 773 } 774 break; 775 default: 776 break; 777 } 778 779 return 0; 780 } 781 782 /* Read device sensors by manually requesting the sensor report (legacy way) */ 783 static int aqc_legacy_read(struct aqc_data *priv) 784 { 785 int ret, i, sensor_value; 786 787 mutex_lock(&priv->mutex); 788 789 memset(priv->buffer, 0x00, priv->buffer_size); 790 ret = hid_hw_raw_request(priv->hdev, priv->status_report_id, priv->buffer, 791 priv->buffer_size, HID_FEATURE_REPORT, HID_REQ_GET_REPORT); 792 if (ret < 0) 793 goto unlock_and_return; 794 795 /* Temperature sensor readings */ 796 for (i = 0; i < priv->num_temp_sensors; i++) { 797 sensor_value = get_unaligned_le16(priv->buffer + priv->temp_sensor_start_offset + 798 i * AQC_SENSOR_SIZE); 799 priv->temp_input[i] = sensor_value * 10; 800 } 801 802 priv->updated = jiffies; 803 804 unlock_and_return: 805 mutex_unlock(&priv->mutex); 806 return ret; 807 } 808 809 static int aqc_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, 810 int channel, long *val) 811 { 812 int ret; 813 struct aqc_data *priv = dev_get_drvdata(dev); 814 815 if (time_after(jiffies, priv->updated + STATUS_UPDATE_INTERVAL)) { 816 if (priv->status_report_id != 0) { 817 /* Legacy devices require manual reads */ 818 ret = aqc_legacy_read(priv); 819 if (ret < 0) 820 return -ENODATA; 821 } else { 822 return -ENODATA; 823 } 824 } 825 826 switch (type) { 827 case hwmon_temp: 828 switch (attr) { 829 case hwmon_temp_input: 830 if (priv->temp_input[channel] == -ENODATA) 831 return -ENODATA; 832 833 *val = priv->temp_input[channel]; 834 break; 835 case hwmon_temp_offset: 836 ret = 837 aqc_get_ctrl_val(priv, priv->temp_ctrl_offset + 838 channel * AQC_SENSOR_SIZE, val, AQC_BE16); 839 if (ret < 0) 840 return ret; 841 842 *val *= 10; 843 break; 844 default: 845 break; 846 } 847 break; 848 case hwmon_fan: 849 switch (attr) { 850 case hwmon_fan_input: 851 *val = priv->speed_input[channel]; 852 break; 853 case hwmon_fan_pulses: 854 ret = aqc_get_ctrl_val(priv, priv->flow_pulses_ctrl_offset, 855 val, AQC_BE16); 856 if (ret < 0) 857 return ret; 858 break; 859 default: 860 break; 861 } 862 break; 863 case hwmon_power: 864 *val = priv->power_input[channel]; 865 break; 866 case hwmon_pwm: 867 switch (priv->kind) { 868 case aquaero: 869 ret = aqc_get_ctrl_val(priv, 870 AQUAERO_CTRL_PRESET_START + channel * AQUAERO_CTRL_PRESET_SIZE, 871 val, AQC_BE16); 872 if (ret < 0) 873 return ret; 874 *val = aqc_percent_to_pwm(*val); 875 break; 876 default: 877 ret = aqc_get_ctrl_val(priv, priv->fan_ctrl_offsets[channel], 878 val, AQC_BE16); 879 if (ret < 0) 880 return ret; 881 882 *val = aqc_percent_to_pwm(ret); 883 break; 884 } 885 break; 886 case hwmon_in: 887 *val = priv->voltage_input[channel]; 888 break; 889 case hwmon_curr: 890 *val = priv->current_input[channel]; 891 break; 892 default: 893 return -EOPNOTSUPP; 894 } 895 896 return 0; 897 } 898 899 static int aqc_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr, 900 int channel, const char **str) 901 { 902 struct aqc_data *priv = dev_get_drvdata(dev); 903 904 /* Number of sensors that are not calculated */ 905 int num_non_calc_sensors = priv->num_temp_sensors + priv->num_virtual_temp_sensors; 906 907 switch (type) { 908 case hwmon_temp: 909 if (channel < priv->num_temp_sensors) { 910 *str = priv->temp_label[channel]; 911 } else { 912 if (priv->kind == aquaero && channel >= num_non_calc_sensors) 913 *str = 914 priv->calc_virt_temp_label[channel - num_non_calc_sensors]; 915 else 916 *str = priv->virtual_temp_label[channel - priv->num_temp_sensors]; 917 } 918 break; 919 case hwmon_fan: 920 *str = priv->speed_label[channel]; 921 break; 922 case hwmon_power: 923 *str = priv->power_label[channel]; 924 break; 925 case hwmon_in: 926 *str = priv->voltage_label[channel]; 927 break; 928 case hwmon_curr: 929 *str = priv->current_label[channel]; 930 break; 931 default: 932 return -EOPNOTSUPP; 933 } 934 935 return 0; 936 } 937 938 static int aqc_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel, 939 long val) 940 { 941 int ret, pwm_value; 942 /* Arrays for setting multiple values at once in the control report */ 943 int ctrl_values_offsets[4]; 944 long ctrl_values[4]; 945 int ctrl_values_types[4]; 946 struct aqc_data *priv = dev_get_drvdata(dev); 947 948 switch (type) { 949 case hwmon_temp: 950 switch (attr) { 951 case hwmon_temp_offset: 952 /* Limit temp offset to +/- 15K as in the official software */ 953 val = clamp_val(val, -15000, 15000) / 10; 954 ret = 955 aqc_set_ctrl_val(priv, priv->temp_ctrl_offset + 956 channel * AQC_SENSOR_SIZE, val, AQC_BE16); 957 if (ret < 0) 958 return ret; 959 break; 960 default: 961 return -EOPNOTSUPP; 962 } 963 break; 964 case hwmon_fan: 965 switch (attr) { 966 case hwmon_fan_pulses: 967 val = clamp_val(val, 10, 1000); 968 ret = aqc_set_ctrl_val(priv, priv->flow_pulses_ctrl_offset, 969 val, AQC_BE16); 970 if (ret < 0) 971 return ret; 972 break; 973 default: 974 break; 975 } 976 break; 977 case hwmon_pwm: 978 switch (attr) { 979 case hwmon_pwm_input: 980 pwm_value = aqc_pwm_to_percent(val); 981 if (pwm_value < 0) 982 return pwm_value; 983 984 switch (priv->kind) { 985 case aquaero: 986 /* Write pwm value to preset corresponding to the channel */ 987 ctrl_values_offsets[0] = AQUAERO_CTRL_PRESET_START + 988 channel * AQUAERO_CTRL_PRESET_SIZE; 989 ctrl_values[0] = pwm_value; 990 ctrl_values_types[0] = AQC_BE16; 991 992 /* Write preset number in fan control source */ 993 ctrl_values_offsets[1] = priv->fan_ctrl_offsets[channel] + 994 AQUAERO_FAN_CTRL_SRC_OFFSET; 995 ctrl_values[1] = AQUAERO_CTRL_PRESET_ID + channel; 996 ctrl_values_types[1] = AQC_BE16; 997 998 /* Set minimum power to 0 to allow the fan to turn off */ 999 ctrl_values_offsets[2] = priv->fan_ctrl_offsets[channel] + 1000 AQUAERO_FAN_CTRL_MIN_PWR_OFFSET; 1001 ctrl_values[2] = 0; 1002 ctrl_values_types[2] = AQC_BE16; 1003 1004 /* Set maximum power to 255 to allow the fan to reach max speed */ 1005 ctrl_values_offsets[3] = priv->fan_ctrl_offsets[channel] + 1006 AQUAERO_FAN_CTRL_MAX_PWR_OFFSET; 1007 ctrl_values[3] = aqc_pwm_to_percent(255); 1008 ctrl_values_types[3] = AQC_BE16; 1009 1010 ret = aqc_set_ctrl_vals(priv, ctrl_values_offsets, ctrl_values, 1011 ctrl_values_types, 4); 1012 if (ret < 0) 1013 return ret; 1014 break; 1015 default: 1016 ret = aqc_set_ctrl_val(priv, priv->fan_ctrl_offsets[channel], 1017 pwm_value, AQC_BE16); 1018 if (ret < 0) 1019 return ret; 1020 break; 1021 } 1022 break; 1023 default: 1024 break; 1025 } 1026 break; 1027 default: 1028 return -EOPNOTSUPP; 1029 } 1030 1031 return 0; 1032 } 1033 1034 static const struct hwmon_ops aqc_hwmon_ops = { 1035 .is_visible = aqc_is_visible, 1036 .read = aqc_read, 1037 .read_string = aqc_read_string, 1038 .write = aqc_write 1039 }; 1040 1041 static const struct hwmon_channel_info * const aqc_info[] = { 1042 HWMON_CHANNEL_INFO(temp, 1043 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1044 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1045 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1046 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1047 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1048 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1049 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1050 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET, 1051 HWMON_T_INPUT | HWMON_T_LABEL, 1052 HWMON_T_INPUT | HWMON_T_LABEL, 1053 HWMON_T_INPUT | HWMON_T_LABEL, 1054 HWMON_T_INPUT | HWMON_T_LABEL, 1055 HWMON_T_INPUT | HWMON_T_LABEL, 1056 HWMON_T_INPUT | HWMON_T_LABEL, 1057 HWMON_T_INPUT | HWMON_T_LABEL, 1058 HWMON_T_INPUT | HWMON_T_LABEL, 1059 HWMON_T_INPUT | HWMON_T_LABEL, 1060 HWMON_T_INPUT | HWMON_T_LABEL, 1061 HWMON_T_INPUT | HWMON_T_LABEL, 1062 HWMON_T_INPUT | HWMON_T_LABEL), 1063 HWMON_CHANNEL_INFO(fan, 1064 HWMON_F_INPUT | HWMON_F_LABEL, 1065 HWMON_F_INPUT | HWMON_F_LABEL, 1066 HWMON_F_INPUT | HWMON_F_LABEL, 1067 HWMON_F_INPUT | HWMON_F_LABEL, 1068 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_PULSES, 1069 HWMON_F_INPUT | HWMON_F_LABEL, 1070 HWMON_F_INPUT | HWMON_F_LABEL, 1071 HWMON_F_INPUT | HWMON_F_LABEL), 1072 HWMON_CHANNEL_INFO(power, 1073 HWMON_P_INPUT | HWMON_P_LABEL, 1074 HWMON_P_INPUT | HWMON_P_LABEL, 1075 HWMON_P_INPUT | HWMON_P_LABEL, 1076 HWMON_P_INPUT | HWMON_P_LABEL, 1077 HWMON_P_INPUT | HWMON_P_LABEL, 1078 HWMON_P_INPUT | HWMON_P_LABEL, 1079 HWMON_P_INPUT | HWMON_P_LABEL, 1080 HWMON_P_INPUT | HWMON_P_LABEL), 1081 HWMON_CHANNEL_INFO(pwm, 1082 HWMON_PWM_INPUT, 1083 HWMON_PWM_INPUT, 1084 HWMON_PWM_INPUT, 1085 HWMON_PWM_INPUT, 1086 HWMON_PWM_INPUT, 1087 HWMON_PWM_INPUT, 1088 HWMON_PWM_INPUT, 1089 HWMON_PWM_INPUT), 1090 HWMON_CHANNEL_INFO(in, 1091 HWMON_I_INPUT | HWMON_I_LABEL, 1092 HWMON_I_INPUT | HWMON_I_LABEL, 1093 HWMON_I_INPUT | HWMON_I_LABEL, 1094 HWMON_I_INPUT | HWMON_I_LABEL, 1095 HWMON_I_INPUT | HWMON_I_LABEL, 1096 HWMON_I_INPUT | HWMON_I_LABEL, 1097 HWMON_I_INPUT | HWMON_I_LABEL, 1098 HWMON_I_INPUT | HWMON_I_LABEL), 1099 HWMON_CHANNEL_INFO(curr, 1100 HWMON_C_INPUT | HWMON_C_LABEL, 1101 HWMON_C_INPUT | HWMON_C_LABEL, 1102 HWMON_C_INPUT | HWMON_C_LABEL, 1103 HWMON_C_INPUT | HWMON_C_LABEL, 1104 HWMON_C_INPUT | HWMON_C_LABEL, 1105 HWMON_C_INPUT | HWMON_C_LABEL, 1106 HWMON_C_INPUT | HWMON_C_LABEL, 1107 HWMON_C_INPUT | HWMON_C_LABEL), 1108 NULL 1109 }; 1110 1111 static const struct hwmon_chip_info aqc_chip_info = { 1112 .ops = &aqc_hwmon_ops, 1113 .info = aqc_info, 1114 }; 1115 1116 static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) 1117 { 1118 int i, j, sensor_value; 1119 struct aqc_data *priv; 1120 1121 if (report->id != STATUS_REPORT_ID) 1122 return 0; 1123 1124 priv = hid_get_drvdata(hdev); 1125 1126 /* Info provided with every report */ 1127 priv->serial_number[0] = get_unaligned_be16(data + priv->serial_number_start_offset); 1128 priv->serial_number[1] = get_unaligned_be16(data + priv->serial_number_start_offset + 1129 SERIAL_PART_OFFSET); 1130 priv->firmware_version = get_unaligned_be16(data + priv->firmware_version_offset); 1131 1132 /* Physical temperature sensor readings */ 1133 for (i = 0; i < priv->num_temp_sensors; i++) { 1134 sensor_value = get_unaligned_be16(data + 1135 priv->temp_sensor_start_offset + 1136 i * AQC_SENSOR_SIZE); 1137 if (sensor_value == AQC_TEMP_SENSOR_DISCONNECTED) 1138 priv->temp_input[i] = -ENODATA; 1139 else 1140 priv->temp_input[i] = sensor_value * 10; 1141 } 1142 1143 /* Virtual temperature sensor readings */ 1144 for (j = 0; j < priv->num_virtual_temp_sensors; j++) { 1145 sensor_value = get_unaligned_be16(data + 1146 priv->virtual_temp_sensor_start_offset + 1147 j * AQC_SENSOR_SIZE); 1148 if (sensor_value == AQC_TEMP_SENSOR_DISCONNECTED) 1149 priv->temp_input[i] = -ENODATA; 1150 else 1151 priv->temp_input[i] = sensor_value * 10; 1152 i++; 1153 } 1154 1155 /* Fan speed and related readings */ 1156 for (i = 0; i < priv->num_fans; i++) { 1157 priv->speed_input[i] = 1158 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 1159 priv->fan_structure->speed); 1160 priv->power_input[i] = 1161 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 1162 priv->fan_structure->power) * 10000; 1163 priv->voltage_input[i] = 1164 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 1165 priv->fan_structure->voltage) * 10; 1166 priv->current_input[i] = 1167 get_unaligned_be16(data + priv->fan_sensor_offsets[i] + 1168 priv->fan_structure->curr); 1169 } 1170 1171 /* Flow sensor readings */ 1172 for (j = 0; j < priv->num_flow_sensors; j++) { 1173 priv->speed_input[i] = get_unaligned_be16(data + priv->flow_sensors_start_offset + 1174 j * AQC_SENSOR_SIZE); 1175 i++; 1176 } 1177 1178 if (priv->power_cycle_count_offset != 0) 1179 priv->power_cycles = get_unaligned_be32(data + priv->power_cycle_count_offset); 1180 1181 /* Special-case sensor readings */ 1182 switch (priv->kind) { 1183 case aquaero: 1184 /* Read calculated virtual temp sensors */ 1185 i = priv->num_temp_sensors + priv->num_virtual_temp_sensors; 1186 for (j = 0; j < priv->num_calc_virt_temp_sensors; j++) { 1187 sensor_value = get_unaligned_be16(data + 1188 priv->calc_virt_temp_sensor_start_offset + 1189 j * AQC_SENSOR_SIZE); 1190 if (sensor_value == AQC_TEMP_SENSOR_DISCONNECTED) 1191 priv->temp_input[i] = -ENODATA; 1192 else 1193 priv->temp_input[i] = sensor_value * 10; 1194 i++; 1195 } 1196 break; 1197 case aquastreamult: 1198 priv->speed_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_OFFSET); 1199 priv->speed_input[2] = get_unaligned_be16(data + AQUASTREAMULT_PRESSURE_OFFSET); 1200 priv->speed_input[3] = get_unaligned_be16(data + AQUASTREAMULT_FLOW_SENSOR_OFFSET); 1201 1202 priv->power_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_POWER) * 10000; 1203 1204 priv->voltage_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_VOLTAGE) * 10; 1205 1206 priv->current_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_CURRENT); 1207 break; 1208 case d5next: 1209 priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10; 1210 priv->voltage_input[3] = get_unaligned_be16(data + D5NEXT_12V_VOLTAGE) * 10; 1211 break; 1212 case highflownext: 1213 /* If external temp sensor is not connected, its power reading is also N/A */ 1214 if (priv->temp_input[1] == -ENODATA) 1215 priv->power_input[0] = -ENODATA; 1216 else 1217 priv->power_input[0] = 1218 get_unaligned_be16(data + HIGHFLOWNEXT_POWER) * 1000000; 1219 1220 priv->voltage_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE) * 10; 1221 priv->voltage_input[1] = 1222 get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE_USB) * 10; 1223 1224 priv->speed_input[1] = get_unaligned_be16(data + HIGHFLOWNEXT_WATER_QUALITY); 1225 priv->speed_input[2] = get_unaligned_be16(data + HIGHFLOWNEXT_CONDUCTIVITY); 1226 break; 1227 default: 1228 break; 1229 } 1230 1231 priv->updated = jiffies; 1232 1233 return 0; 1234 } 1235 1236 #ifdef CONFIG_DEBUG_FS 1237 1238 static int serial_number_show(struct seq_file *seqf, void *unused) 1239 { 1240 struct aqc_data *priv = seqf->private; 1241 1242 seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]); 1243 1244 return 0; 1245 } 1246 DEFINE_SHOW_ATTRIBUTE(serial_number); 1247 1248 static int firmware_version_show(struct seq_file *seqf, void *unused) 1249 { 1250 struct aqc_data *priv = seqf->private; 1251 1252 seq_printf(seqf, "%u\n", priv->firmware_version); 1253 1254 return 0; 1255 } 1256 DEFINE_SHOW_ATTRIBUTE(firmware_version); 1257 1258 static int power_cycles_show(struct seq_file *seqf, void *unused) 1259 { 1260 struct aqc_data *priv = seqf->private; 1261 1262 seq_printf(seqf, "%u\n", priv->power_cycles); 1263 1264 return 0; 1265 } 1266 DEFINE_SHOW_ATTRIBUTE(power_cycles); 1267 1268 static void aqc_debugfs_init(struct aqc_data *priv) 1269 { 1270 char name[64]; 1271 1272 scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name, 1273 dev_name(&priv->hdev->dev)); 1274 1275 priv->debugfs = debugfs_create_dir(name, NULL); 1276 1277 if (priv->serial_number_start_offset != 0) 1278 debugfs_create_file("serial_number", 0444, priv->debugfs, priv, 1279 &serial_number_fops); 1280 if (priv->firmware_version_offset != 0) 1281 debugfs_create_file("firmware_version", 0444, priv->debugfs, priv, 1282 &firmware_version_fops); 1283 if (priv->power_cycle_count_offset != 0) 1284 debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops); 1285 } 1286 1287 #else 1288 1289 static void aqc_debugfs_init(struct aqc_data *priv) 1290 { 1291 } 1292 1293 #endif 1294 1295 static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id) 1296 { 1297 struct aqc_data *priv; 1298 int ret; 1299 1300 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL); 1301 if (!priv) 1302 return -ENOMEM; 1303 1304 priv->hdev = hdev; 1305 hid_set_drvdata(hdev, priv); 1306 1307 priv->updated = jiffies - STATUS_UPDATE_INTERVAL; 1308 1309 ret = hid_parse(hdev); 1310 if (ret) 1311 return ret; 1312 1313 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW); 1314 if (ret) 1315 return ret; 1316 1317 ret = hid_hw_open(hdev); 1318 if (ret) 1319 goto fail_and_stop; 1320 1321 switch (hdev->product) { 1322 case USB_PRODUCT_ID_AQUAERO: 1323 /* 1324 * Aquaero presents itself as three HID devices under the same product ID: 1325 * "aquaero keyboard/mouse", "aquaero System Control" and "aquaero Device", 1326 * which is the one we want to communicate with. Unlike most other Aquacomputer 1327 * devices, Aquaero does not return meaningful data when explicitly requested 1328 * using GET_FEATURE_REPORT. 1329 * 1330 * The difference between "aquaero Device" and the other two is in the collections 1331 * they present. The two other devices have the type of the second element in 1332 * their respective collections set to 1, while the real device has it set to 0. 1333 */ 1334 if (hdev->collection[1].type != 0) { 1335 ret = -ENODEV; 1336 goto fail_and_close; 1337 } 1338 1339 priv->kind = aquaero; 1340 1341 priv->num_fans = AQUAERO_NUM_FANS; 1342 priv->fan_sensor_offsets = aquaero_sensor_fan_offsets; 1343 priv->fan_ctrl_offsets = aquaero_ctrl_fan_offsets; 1344 1345 priv->num_temp_sensors = AQUAERO_NUM_SENSORS; 1346 priv->temp_sensor_start_offset = AQUAERO_SENSOR_START; 1347 priv->num_virtual_temp_sensors = AQUAERO_NUM_VIRTUAL_SENSORS; 1348 priv->virtual_temp_sensor_start_offset = AQUAERO_VIRTUAL_SENSOR_START; 1349 priv->num_calc_virt_temp_sensors = AQUAERO_NUM_CALC_VIRTUAL_SENSORS; 1350 priv->calc_virt_temp_sensor_start_offset = AQUAERO_CALC_VIRTUAL_SENSOR_START; 1351 priv->num_flow_sensors = AQUAERO_NUM_FLOW_SENSORS; 1352 priv->flow_sensors_start_offset = AQUAERO_FLOW_SENSORS_START; 1353 1354 priv->buffer_size = AQUAERO_CTRL_REPORT_SIZE; 1355 priv->temp_ctrl_offset = AQUAERO_TEMP_CTRL_OFFSET; 1356 1357 priv->temp_label = label_temp_sensors; 1358 priv->virtual_temp_label = label_virtual_temp_sensors; 1359 priv->calc_virt_temp_label = label_aquaero_calc_temp_sensors; 1360 priv->speed_label = label_aquaero_speeds; 1361 priv->power_label = label_fan_power; 1362 priv->voltage_label = label_fan_voltage; 1363 priv->current_label = label_fan_current; 1364 break; 1365 case USB_PRODUCT_ID_D5NEXT: 1366 priv->kind = d5next; 1367 1368 priv->num_fans = D5NEXT_NUM_FANS; 1369 priv->fan_sensor_offsets = d5next_sensor_fan_offsets; 1370 priv->fan_ctrl_offsets = d5next_ctrl_fan_offsets; 1371 1372 priv->num_temp_sensors = D5NEXT_NUM_SENSORS; 1373 priv->temp_sensor_start_offset = D5NEXT_COOLANT_TEMP; 1374 priv->num_virtual_temp_sensors = D5NEXT_NUM_VIRTUAL_SENSORS; 1375 priv->virtual_temp_sensor_start_offset = D5NEXT_VIRTUAL_SENSORS_START; 1376 priv->temp_ctrl_offset = D5NEXT_TEMP_CTRL_OFFSET; 1377 1378 priv->buffer_size = D5NEXT_CTRL_REPORT_SIZE; 1379 1380 priv->power_cycle_count_offset = D5NEXT_POWER_CYCLES; 1381 1382 priv->temp_label = label_d5next_temp; 1383 priv->virtual_temp_label = label_virtual_temp_sensors; 1384 priv->speed_label = label_d5next_speeds; 1385 priv->power_label = label_d5next_power; 1386 priv->voltage_label = label_d5next_voltages; 1387 priv->current_label = label_d5next_current; 1388 break; 1389 case USB_PRODUCT_ID_FARBWERK: 1390 priv->kind = farbwerk; 1391 1392 priv->num_fans = 0; 1393 1394 priv->num_temp_sensors = FARBWERK_NUM_SENSORS; 1395 priv->temp_sensor_start_offset = FARBWERK_SENSOR_START; 1396 1397 priv->temp_label = label_temp_sensors; 1398 break; 1399 case USB_PRODUCT_ID_FARBWERK360: 1400 priv->kind = farbwerk360; 1401 1402 priv->num_fans = 0; 1403 1404 priv->num_temp_sensors = FARBWERK360_NUM_SENSORS; 1405 priv->temp_sensor_start_offset = FARBWERK360_SENSOR_START; 1406 priv->num_virtual_temp_sensors = FARBWERK360_NUM_VIRTUAL_SENSORS; 1407 priv->virtual_temp_sensor_start_offset = FARBWERK360_VIRTUAL_SENSORS_START; 1408 priv->temp_ctrl_offset = FARBWERK360_TEMP_CTRL_OFFSET; 1409 1410 priv->buffer_size = FARBWERK360_CTRL_REPORT_SIZE; 1411 1412 priv->temp_label = label_temp_sensors; 1413 priv->virtual_temp_label = label_virtual_temp_sensors; 1414 break; 1415 case USB_PRODUCT_ID_OCTO: 1416 priv->kind = octo; 1417 1418 priv->num_fans = OCTO_NUM_FANS; 1419 priv->fan_sensor_offsets = octo_sensor_fan_offsets; 1420 priv->fan_ctrl_offsets = octo_ctrl_fan_offsets; 1421 1422 priv->num_temp_sensors = OCTO_NUM_SENSORS; 1423 priv->temp_sensor_start_offset = OCTO_SENSOR_START; 1424 priv->num_virtual_temp_sensors = OCTO_NUM_VIRTUAL_SENSORS; 1425 priv->virtual_temp_sensor_start_offset = OCTO_VIRTUAL_SENSORS_START; 1426 priv->temp_ctrl_offset = OCTO_TEMP_CTRL_OFFSET; 1427 1428 priv->buffer_size = OCTO_CTRL_REPORT_SIZE; 1429 1430 priv->power_cycle_count_offset = OCTO_POWER_CYCLES; 1431 1432 priv->temp_label = label_temp_sensors; 1433 priv->virtual_temp_label = label_virtual_temp_sensors; 1434 priv->speed_label = label_fan_speed; 1435 priv->power_label = label_fan_power; 1436 priv->voltage_label = label_fan_voltage; 1437 priv->current_label = label_fan_current; 1438 break; 1439 case USB_PRODUCT_ID_QUADRO: 1440 priv->kind = quadro; 1441 1442 priv->num_fans = QUADRO_NUM_FANS; 1443 priv->fan_sensor_offsets = quadro_sensor_fan_offsets; 1444 priv->fan_ctrl_offsets = quadro_ctrl_fan_offsets; 1445 1446 priv->num_temp_sensors = QUADRO_NUM_SENSORS; 1447 priv->temp_sensor_start_offset = QUADRO_SENSOR_START; 1448 priv->num_virtual_temp_sensors = QUADRO_NUM_VIRTUAL_SENSORS; 1449 priv->virtual_temp_sensor_start_offset = QUADRO_VIRTUAL_SENSORS_START; 1450 priv->num_flow_sensors = QUADRO_NUM_FLOW_SENSORS; 1451 priv->flow_sensors_start_offset = QUADRO_FLOW_SENSOR_OFFSET; 1452 1453 priv->temp_ctrl_offset = QUADRO_TEMP_CTRL_OFFSET; 1454 1455 priv->buffer_size = QUADRO_CTRL_REPORT_SIZE; 1456 1457 priv->flow_pulses_ctrl_offset = QUADRO_FLOW_PULSES_CTRL_OFFSET; 1458 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES; 1459 1460 priv->temp_label = label_temp_sensors; 1461 priv->virtual_temp_label = label_virtual_temp_sensors; 1462 priv->speed_label = label_quadro_speeds; 1463 priv->power_label = label_fan_power; 1464 priv->voltage_label = label_fan_voltage; 1465 priv->current_label = label_fan_current; 1466 break; 1467 case USB_PRODUCT_ID_HIGHFLOWNEXT: 1468 priv->kind = highflownext; 1469 1470 priv->num_fans = 0; 1471 1472 priv->num_temp_sensors = HIGHFLOWNEXT_NUM_SENSORS; 1473 priv->temp_sensor_start_offset = HIGHFLOWNEXT_SENSOR_START; 1474 priv->num_flow_sensors = HIGHFLOWNEXT_NUM_FLOW_SENSORS; 1475 priv->flow_sensors_start_offset = HIGHFLOWNEXT_FLOW; 1476 1477 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES; 1478 1479 priv->temp_label = label_highflownext_temp_sensors; 1480 priv->speed_label = label_highflownext_fan_speed; 1481 priv->power_label = label_highflownext_power; 1482 priv->voltage_label = label_highflownext_voltage; 1483 break; 1484 case USB_PRODUCT_ID_AQUASTREAMULT: 1485 priv->kind = aquastreamult; 1486 1487 priv->num_fans = AQUASTREAMULT_NUM_FANS; 1488 priv->fan_sensor_offsets = aquastreamult_sensor_fan_offsets; 1489 1490 priv->num_temp_sensors = AQUASTREAMULT_NUM_SENSORS; 1491 priv->temp_sensor_start_offset = AQUASTREAMULT_SENSOR_START; 1492 1493 priv->temp_label = label_aquastreamult_temp; 1494 priv->speed_label = label_aquastreamult_speeds; 1495 priv->power_label = label_aquastreamult_power; 1496 priv->voltage_label = label_aquastreamult_voltages; 1497 priv->current_label = label_aquastreamult_current; 1498 break; 1499 case USB_PRODUCT_ID_POWERADJUST3: 1500 priv->kind = poweradjust3; 1501 1502 priv->num_fans = 0; 1503 1504 priv->num_temp_sensors = POWERADJUST3_NUM_SENSORS; 1505 priv->temp_sensor_start_offset = POWERADJUST3_SENSOR_START; 1506 priv->buffer_size = POWERADJUST3_SENSOR_REPORT_SIZE; 1507 1508 priv->temp_label = label_poweradjust3_temp_sensors; 1509 break; 1510 default: 1511 break; 1512 } 1513 1514 switch (priv->kind) { 1515 case aquaero: 1516 priv->serial_number_start_offset = AQUAERO_SERIAL_START; 1517 priv->firmware_version_offset = AQUAERO_FIRMWARE_VERSION; 1518 1519 priv->fan_structure = &aqc_aquaero_fan_structure; 1520 1521 priv->ctrl_report_id = AQUAERO_CTRL_REPORT_ID; 1522 priv->secondary_ctrl_report_id = AQUAERO_SECONDARY_CTRL_REPORT_ID; 1523 priv->secondary_ctrl_report_size = AQUAERO_SECONDARY_CTRL_REPORT_SIZE; 1524 priv->secondary_ctrl_report = aquaero_secondary_ctrl_report; 1525 break; 1526 case poweradjust3: 1527 priv->status_report_id = POWERADJUST3_STATUS_REPORT_ID; 1528 break; 1529 default: 1530 priv->serial_number_start_offset = AQC_SERIAL_START; 1531 priv->firmware_version_offset = AQC_FIRMWARE_VERSION; 1532 1533 priv->ctrl_report_id = CTRL_REPORT_ID; 1534 priv->secondary_ctrl_report_id = SECONDARY_CTRL_REPORT_ID; 1535 priv->secondary_ctrl_report_size = SECONDARY_CTRL_REPORT_SIZE; 1536 priv->secondary_ctrl_report = secondary_ctrl_report; 1537 1538 if (priv->kind == aquastreamult) 1539 priv->fan_structure = &aqc_aquastreamult_fan_structure; 1540 else 1541 priv->fan_structure = &aqc_general_fan_structure; 1542 break; 1543 } 1544 1545 if (priv->buffer_size != 0) { 1546 priv->checksum_start = 0x01; 1547 priv->checksum_length = priv->buffer_size - 3; 1548 priv->checksum_offset = priv->buffer_size - 2; 1549 } 1550 1551 priv->name = aqc_device_names[priv->kind]; 1552 1553 priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL); 1554 if (!priv->buffer) { 1555 ret = -ENOMEM; 1556 goto fail_and_close; 1557 } 1558 1559 mutex_init(&priv->mutex); 1560 1561 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv, 1562 &aqc_chip_info, NULL); 1563 1564 if (IS_ERR(priv->hwmon_dev)) { 1565 ret = PTR_ERR(priv->hwmon_dev); 1566 goto fail_and_close; 1567 } 1568 1569 aqc_debugfs_init(priv); 1570 1571 return 0; 1572 1573 fail_and_close: 1574 hid_hw_close(hdev); 1575 fail_and_stop: 1576 hid_hw_stop(hdev); 1577 return ret; 1578 } 1579 1580 static void aqc_remove(struct hid_device *hdev) 1581 { 1582 struct aqc_data *priv = hid_get_drvdata(hdev); 1583 1584 debugfs_remove_recursive(priv->debugfs); 1585 hwmon_device_unregister(priv->hwmon_dev); 1586 1587 hid_hw_close(hdev); 1588 hid_hw_stop(hdev); 1589 } 1590 1591 static const struct hid_device_id aqc_table[] = { 1592 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUAERO) }, 1593 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) }, 1594 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) }, 1595 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) }, 1596 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) }, 1597 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_QUADRO) }, 1598 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOWNEXT) }, 1599 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMULT) }, 1600 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_POWERADJUST3) }, 1601 { } 1602 }; 1603 1604 MODULE_DEVICE_TABLE(hid, aqc_table); 1605 1606 static struct hid_driver aqc_driver = { 1607 .name = DRIVER_NAME, 1608 .id_table = aqc_table, 1609 .probe = aqc_probe, 1610 .remove = aqc_remove, 1611 .raw_event = aqc_raw_event, 1612 }; 1613 1614 static int __init aqc_init(void) 1615 { 1616 return hid_register_driver(&aqc_driver); 1617 } 1618 1619 static void __exit aqc_exit(void) 1620 { 1621 hid_unregister_driver(&aqc_driver); 1622 } 1623 1624 /* Request to initialize after the HID bus to ensure it's not being loaded before */ 1625 late_initcall(aqc_init); 1626 module_exit(aqc_exit); 1627 1628 MODULE_LICENSE("GPL"); 1629 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>"); 1630 MODULE_AUTHOR("Jack Doan <me@jackdoan.com>"); 1631 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices"); 1632