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