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