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