drivers/hwmon/aquacomputer_d5next.c

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