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