1 // SPDX-License-Identifier: GPL-2.0+
3 * hwmon driver for Aquacomputer devices (D5 Next, Farbwerk, Farbwerk 360, Octo,
4 * Quadro, High Flow Next, Aquaero, Aquastream Ultimate, Leakshield,
5 * High Flow USB/MPS Flow family)
7 * Aquacomputer devices send HID reports (with ID 0x01) every second to report
8 * sensor values, except for devices that communicate through the
9 * legacy way (currently, Poweradjust 3 and High Flow USB/MPS Flow family).
11 * Copyright 2021 Aleksa Savic <savicaleksa83@gmail.com>
12 * Copyright 2022 Jack Doan <me@jackdoan.com>
15 #include <linux/crc16.h>
16 #include <linux/debugfs.h>
17 #include <linux/delay.h>
18 #include <linux/hid.h>
19 #include <linux/hwmon.h>
20 #include <linux/jiffies.h>
21 #include <linux/ktime.h>
22 #include <linux/module.h>
23 #include <linux/mutex.h>
24 #include <linux/seq_file.h>
25 #include <asm/unaligned.h>
27 #define USB_VENDOR_ID_AQUACOMPUTER 0x0c70
28 #define USB_PRODUCT_ID_AQUAERO 0xf001
29 #define USB_PRODUCT_ID_FARBWERK 0xf00a
30 #define USB_PRODUCT_ID_QUADRO 0xf00d
31 #define USB_PRODUCT_ID_D5NEXT 0xf00e
32 #define USB_PRODUCT_ID_FARBWERK360 0xf010
33 #define USB_PRODUCT_ID_OCTO 0xf011
34 #define USB_PRODUCT_ID_HIGHFLOWNEXT 0xf012
35 #define USB_PRODUCT_ID_LEAKSHIELD 0xf014
36 #define USB_PRODUCT_ID_AQUASTREAMXT 0xf0b6
37 #define USB_PRODUCT_ID_AQUASTREAMULT 0xf00b
38 #define USB_PRODUCT_ID_POWERADJUST3 0xf0bd
39 #define USB_PRODUCT_ID_HIGHFLOW 0xf003
42 d5next, farbwerk, farbwerk360, octo, quadro,
43 highflownext, aquaero, poweradjust3, aquastreamult,
44 aquastreamxt, leakshield, highflow
47 static const char *const aqc_device_names[] = {
49 [farbwerk] = "farbwerk",
50 [farbwerk360] = "farbwerk360",
53 [highflownext] = "highflownext",
54 [leakshield] = "leakshield",
55 [aquastreamxt] = "aquastreamxt",
56 [aquaero] = "aquaero",
57 [aquastreamult] = "aquastreamultimate",
58 [poweradjust3] = "poweradjust3",
59 [highflow] = "highflow" /* Covers MPS Flow devices */
62 #define DRIVER_NAME "aquacomputer_d5next"
64 #define STATUS_REPORT_ID 0x01
65 #define STATUS_UPDATE_INTERVAL (2 * HZ) /* In seconds */
66 #define SERIAL_PART_OFFSET 2
68 #define CTRL_REPORT_ID 0x03
69 #define AQUAERO_CTRL_REPORT_ID 0x0b
71 #define CTRL_REPORT_DELAY 200 /* ms */
73 /* The HID report that the official software always sends
74 * after writing values, currently same for all devices
76 #define SECONDARY_CTRL_REPORT_ID 0x02
77 #define SECONDARY_CTRL_REPORT_SIZE 0x0B
79 static u8 secondary_ctrl_report[] = {
80 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x34, 0xC6
83 /* Secondary HID report values for Aquaero */
84 #define AQUAERO_SECONDARY_CTRL_REPORT_ID 0x06
85 #define AQUAERO_SECONDARY_CTRL_REPORT_SIZE 0x07
87 static u8 aquaero_secondary_ctrl_report[] = {
88 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
91 /* Report IDs for legacy devices */
92 #define AQUASTREAMXT_STATUS_REPORT_ID 0x04
94 #define POWERADJUST3_STATUS_REPORT_ID 0x03
96 #define HIGHFLOW_STATUS_REPORT_ID 0x02
98 /* Data types for reading and writing control reports */
102 /* Info, sensor sizes and offsets for most Aquacomputer devices */
103 #define AQC_SERIAL_START 0x3
104 #define AQC_FIRMWARE_VERSION 0xD
106 #define AQC_SENSOR_SIZE 0x02
107 #define AQC_SENSOR_NA 0x7FFF
108 #define AQC_FAN_PERCENT_OFFSET 0x00
109 #define AQC_FAN_VOLTAGE_OFFSET 0x02
110 #define AQC_FAN_CURRENT_OFFSET 0x04
111 #define AQC_FAN_POWER_OFFSET 0x06
112 #define AQC_FAN_SPEED_OFFSET 0x08
114 /* Specs of the Aquaero fan controllers */
115 #define AQUAERO_SERIAL_START 0x07
116 #define AQUAERO_FIRMWARE_VERSION 0x0B
117 #define AQUAERO_NUM_FANS 4
118 #define AQUAERO_NUM_SENSORS 8
119 #define AQUAERO_NUM_VIRTUAL_SENSORS 8
120 #define AQUAERO_NUM_CALC_VIRTUAL_SENSORS 4
121 #define AQUAERO_NUM_FLOW_SENSORS 2
122 #define AQUAERO_CTRL_REPORT_SIZE 0xa93
123 #define AQUAERO_CTRL_PRESET_ID 0x5c
124 #define AQUAERO_CTRL_PRESET_SIZE 0x02
125 #define AQUAERO_CTRL_PRESET_START 0x55c
127 /* Sensor report offsets for Aquaero fan controllers */
128 #define AQUAERO_SENSOR_START 0x65
129 #define AQUAERO_VIRTUAL_SENSOR_START 0x85
130 #define AQUAERO_CALC_VIRTUAL_SENSOR_START 0x95
131 #define AQUAERO_FLOW_SENSORS_START 0xF9
132 #define AQUAERO_FAN_VOLTAGE_OFFSET 0x04
133 #define AQUAERO_FAN_CURRENT_OFFSET 0x06
134 #define AQUAERO_FAN_POWER_OFFSET 0x08
135 #define AQUAERO_FAN_SPEED_OFFSET 0x00
136 static u16 aquaero_sensor_fan_offsets[] = { 0x167, 0x173, 0x17f, 0x18B };
138 /* Control report offsets for the Aquaero fan controllers */
139 #define AQUAERO_TEMP_CTRL_OFFSET 0xdb
140 #define AQUAERO_FAN_CTRL_MIN_PWR_OFFSET 0x04
141 #define AQUAERO_FAN_CTRL_MAX_PWR_OFFSET 0x06
142 #define AQUAERO_FAN_CTRL_SRC_OFFSET 0x10
143 static u16 aquaero_ctrl_fan_offsets[] = { 0x20c, 0x220, 0x234, 0x248 };
145 /* Specs of the D5 Next pump */
146 #define D5NEXT_NUM_FANS 2
147 #define D5NEXT_NUM_SENSORS 1
148 #define D5NEXT_NUM_VIRTUAL_SENSORS 8
149 #define D5NEXT_CTRL_REPORT_SIZE 0x329
151 /* Sensor report offsets for the D5 Next pump */
152 #define D5NEXT_POWER_CYCLES 0x18
153 #define D5NEXT_COOLANT_TEMP 0x57
154 #define D5NEXT_PUMP_OFFSET 0x6c
155 #define D5NEXT_FAN_OFFSET 0x5f
156 #define D5NEXT_5V_VOLTAGE 0x39
157 #define D5NEXT_12V_VOLTAGE 0x37
158 #define D5NEXT_VIRTUAL_SENSORS_START 0x3f
159 static u16 d5next_sensor_fan_offsets[] = { D5NEXT_PUMP_OFFSET, D5NEXT_FAN_OFFSET };
161 /* Control report offsets for the D5 Next pump */
162 #define D5NEXT_TEMP_CTRL_OFFSET 0x2D /* Temperature sensor offsets location */
163 static u16 d5next_ctrl_fan_offsets[] = { 0x97, 0x42 }; /* Pump and fan speed (from 0-100%) */
165 /* Specs of the Aquastream Ultimate pump */
166 /* Pump does not follow the standard structure, so only consider the fan */
167 #define AQUASTREAMULT_NUM_FANS 1
168 #define AQUASTREAMULT_NUM_SENSORS 2
170 /* Sensor report offsets for the Aquastream Ultimate pump */
171 #define AQUASTREAMULT_SENSOR_START 0x2D
172 #define AQUASTREAMULT_PUMP_OFFSET 0x51
173 #define AQUASTREAMULT_PUMP_VOLTAGE 0x3D
174 #define AQUASTREAMULT_PUMP_CURRENT 0x53
175 #define AQUASTREAMULT_PUMP_POWER 0x55
176 #define AQUASTREAMULT_FAN_OFFSET 0x41
177 #define AQUASTREAMULT_PRESSURE_OFFSET 0x57
178 #define AQUASTREAMULT_FLOW_SENSOR_OFFSET 0x37
179 #define AQUASTREAMULT_FAN_VOLTAGE_OFFSET 0x02
180 #define AQUASTREAMULT_FAN_CURRENT_OFFSET 0x00
181 #define AQUASTREAMULT_FAN_POWER_OFFSET 0x04
182 #define AQUASTREAMULT_FAN_SPEED_OFFSET 0x06
183 static u16 aquastreamult_sensor_fan_offsets[] = { AQUASTREAMULT_FAN_OFFSET };
185 /* Spec and sensor report offset for the Farbwerk RGB controller */
186 #define FARBWERK_NUM_SENSORS 4
187 #define FARBWERK_SENSOR_START 0x2f
189 /* Specs of the Farbwerk 360 RGB controller */
190 #define FARBWERK360_NUM_SENSORS 4
191 #define FARBWERK360_NUM_VIRTUAL_SENSORS 16
192 #define FARBWERK360_CTRL_REPORT_SIZE 0x682
194 /* Sensor report offsets for the Farbwerk 360 */
195 #define FARBWERK360_SENSOR_START 0x32
196 #define FARBWERK360_VIRTUAL_SENSORS_START 0x3a
198 /* Control report offsets for the Farbwerk 360 */
199 #define FARBWERK360_TEMP_CTRL_OFFSET 0x8
201 /* Specs of the Octo fan controller */
202 #define OCTO_NUM_FANS 8
203 #define OCTO_NUM_SENSORS 4
204 #define OCTO_NUM_VIRTUAL_SENSORS 16
205 #define OCTO_CTRL_REPORT_SIZE 0x65F
207 /* Sensor report offsets for the Octo */
208 #define OCTO_POWER_CYCLES 0x18
209 #define OCTO_SENSOR_START 0x3D
210 #define OCTO_VIRTUAL_SENSORS_START 0x45
211 static u16 octo_sensor_fan_offsets[] = { 0x7D, 0x8A, 0x97, 0xA4, 0xB1, 0xBE, 0xCB, 0xD8 };
213 /* Control report offsets for the Octo */
214 #define OCTO_TEMP_CTRL_OFFSET 0xA
215 /* Fan speed offsets (0-100%) */
216 static u16 octo_ctrl_fan_offsets[] = { 0x5B, 0xB0, 0x105, 0x15A, 0x1AF, 0x204, 0x259, 0x2AE };
218 /* Specs of Quadro fan controller */
219 #define QUADRO_NUM_FANS 4
220 #define QUADRO_NUM_SENSORS 4
221 #define QUADRO_NUM_VIRTUAL_SENSORS 16
222 #define QUADRO_NUM_FLOW_SENSORS 1
223 #define QUADRO_CTRL_REPORT_SIZE 0x3c1
225 /* Sensor report offsets for the Quadro */
226 #define QUADRO_POWER_CYCLES 0x18
227 #define QUADRO_SENSOR_START 0x34
228 #define QUADRO_VIRTUAL_SENSORS_START 0x3c
229 #define QUADRO_FLOW_SENSOR_OFFSET 0x6e
230 static u16 quadro_sensor_fan_offsets[] = { 0x70, 0x7D, 0x8A, 0x97 };
232 /* Control report offsets for the Quadro */
233 #define QUADRO_TEMP_CTRL_OFFSET 0xA
234 #define QUADRO_FLOW_PULSES_CTRL_OFFSET 0x6
235 static u16 quadro_ctrl_fan_offsets[] = { 0x37, 0x8c, 0xe1, 0x136 }; /* Fan speed offsets (0-100%) */
237 /* Specs of High Flow Next flow sensor */
238 #define HIGHFLOWNEXT_NUM_SENSORS 2
239 #define HIGHFLOWNEXT_NUM_FLOW_SENSORS 1
241 /* Sensor report offsets for the High Flow Next */
242 #define HIGHFLOWNEXT_SENSOR_START 85
243 #define HIGHFLOWNEXT_FLOW 81
244 #define HIGHFLOWNEXT_WATER_QUALITY 89
245 #define HIGHFLOWNEXT_POWER 91
246 #define HIGHFLOWNEXT_CONDUCTIVITY 95
247 #define HIGHFLOWNEXT_5V_VOLTAGE 97
248 #define HIGHFLOWNEXT_5V_VOLTAGE_USB 99
250 /* Specs of the Leakshield */
251 #define LEAKSHIELD_NUM_SENSORS 2
253 /* Sensor report offsets for Leakshield */
254 #define LEAKSHIELD_PRESSURE_ADJUSTED 285
255 #define LEAKSHIELD_TEMPERATURE_1 265
256 #define LEAKSHIELD_TEMPERATURE_2 287
257 #define LEAKSHIELD_PRESSURE_MIN 291
258 #define LEAKSHIELD_PRESSURE_TARGET 293
259 #define LEAKSHIELD_PRESSURE_MAX 295
260 #define LEAKSHIELD_PUMP_RPM_IN 101
261 #define LEAKSHIELD_FLOW_IN 111
262 #define LEAKSHIELD_RESERVOIR_VOLUME 313
263 #define LEAKSHIELD_RESERVOIR_FILLED 311
265 /* Specs of the Aquastream XT pump */
266 #define AQUASTREAMXT_SERIAL_START 0x3a
267 #define AQUASTREAMXT_FIRMWARE_VERSION 0x32
268 #define AQUASTREAMXT_NUM_FANS 2
269 #define AQUASTREAMXT_NUM_SENSORS 3
270 #define AQUASTREAMXT_FAN_STOPPED 0x4
271 #define AQUASTREAMXT_PUMP_CONVERSION_CONST 45000000
272 #define AQUASTREAMXT_FAN_CONVERSION_CONST 5646000
273 #define AQUASTREAMXT_SENSOR_REPORT_SIZE 0x42
275 /* Sensor report offsets and info for Aquastream XT */
276 #define AQUASTREAMXT_SENSOR_START 0xd
277 #define AQUASTREAMXT_FAN_VOLTAGE_OFFSET 0x7
278 #define AQUASTREAMXT_FAN_STATUS_OFFSET 0x1d
279 #define AQUASTREAMXT_PUMP_VOLTAGE_OFFSET 0x9
280 #define AQUASTREAMXT_PUMP_CURR_OFFSET 0xb
281 static u16 aquastreamxt_sensor_fan_offsets[] = { 0x13, 0x1b };
283 /* Specs of the Poweradjust 3 */
284 #define POWERADJUST3_NUM_SENSORS 1
285 #define POWERADJUST3_SENSOR_REPORT_SIZE 0x32
287 /* Sensor report offsets for the Poweradjust 3 */
288 #define POWERADJUST3_SENSOR_START 0x03
290 /* Specs of the High Flow USB */
291 #define HIGHFLOW_NUM_SENSORS 2
292 #define HIGHFLOW_NUM_FLOW_SENSORS 1
293 #define HIGHFLOW_SENSOR_REPORT_SIZE 0x76
295 /* Sensor report offsets for the High Flow USB */
296 #define HIGHFLOW_FIRMWARE_VERSION 0x3
297 #define HIGHFLOW_SERIAL_START 0x9
298 #define HIGHFLOW_FLOW_SENSOR_OFFSET 0x23
299 #define HIGHFLOW_SENSOR_START 0x2b
301 /* Labels for D5 Next */
302 static const char *const label_d5next_temp[] = {
306 static const char *const label_d5next_speeds[] = {
311 static const char *const label_d5next_power[] = {
316 static const char *const label_d5next_voltages[] = {
323 static const char *const label_d5next_current[] = {
328 /* Labels for Aquaero, Farbwerk, Farbwerk 360 and Octo and Quadro temperature sensors */
329 static const char *const label_temp_sensors[] = {
340 static const char *const label_virtual_temp_sensors[] = {
359 static const char *const label_aquaero_calc_temp_sensors[] = {
360 "Calc. virtual sensor 1",
361 "Calc. virtual sensor 2",
362 "Calc. virtual sensor 3",
363 "Calc. virtual sensor 4"
366 /* Labels for Octo and Quadro (except speed) */
367 static const char *const label_fan_speed[] = {
378 static const char *const label_fan_power[] = {
389 static const char *const label_fan_voltage[] = {
400 static const char *const label_fan_current[] = {
411 /* Labels for Quadro fan speeds */
412 static const char *const label_quadro_speeds[] = {
420 /* Labels for Aquaero fan speeds */
421 static const char *const label_aquaero_speeds[] = {
426 "Flow sensor 1 [dL/h]",
427 "Flow sensor 2 [dL/h]"
430 /* Labels for High Flow Next */
431 static const char *const label_highflownext_temp_sensors[] = {
436 static const char *const label_highflownext_fan_speed[] = {
439 "Conductivity [nS/cm]",
442 static const char *const label_highflownext_power[] = {
446 static const char *const label_highflownext_voltage[] = {
451 /* Labels for Leakshield */
452 static const char *const label_leakshield_temp_sensors[] = {
457 static const char *const label_leakshield_fan_speed[] = {
459 "User-Provided Pump Speed",
460 "User-Provided Flow [dL/h]",
461 "Reservoir Volume [ml]",
462 "Reservoir Filled [ml]",
465 /* Labels for Aquastream XT */
466 static const char *const label_aquastreamxt_temp_sensors[] = {
472 /* Labels for Aquastream Ultimate */
473 static const char *const label_aquastreamult_temp[] = {
478 static const char *const label_aquastreamult_speeds[] = {
485 static const char *const label_aquastreamult_power[] = {
490 static const char *const label_aquastreamult_voltages[] = {
495 static const char *const label_aquastreamult_current[] = {
500 /* Labels for Poweradjust 3 */
501 static const char *const label_poweradjust3_temp_sensors[] = {
505 /* Labels for Highflow */
506 static const char *const label_highflow_temp[] = {
511 static const char *const label_highflow_speeds[] = {
515 struct aqc_fan_structure_offsets {
522 /* Fan structure offsets for Aquaero */
523 static struct aqc_fan_structure_offsets aqc_aquaero_fan_structure = {
524 .voltage = AQUAERO_FAN_VOLTAGE_OFFSET,
525 .curr = AQUAERO_FAN_CURRENT_OFFSET,
526 .power = AQUAERO_FAN_POWER_OFFSET,
527 .speed = AQUAERO_FAN_SPEED_OFFSET
530 /* Fan structure offsets for Aquastream Ultimate */
531 static struct aqc_fan_structure_offsets aqc_aquastreamult_fan_structure = {
532 .voltage = AQUASTREAMULT_FAN_VOLTAGE_OFFSET,
533 .curr = AQUASTREAMULT_FAN_CURRENT_OFFSET,
534 .power = AQUASTREAMULT_FAN_POWER_OFFSET,
535 .speed = AQUASTREAMULT_FAN_SPEED_OFFSET
538 /* Fan structure offsets for all devices except those above */
539 static struct aqc_fan_structure_offsets aqc_general_fan_structure = {
540 .voltage = AQC_FAN_VOLTAGE_OFFSET,
541 .curr = AQC_FAN_CURRENT_OFFSET,
542 .power = AQC_FAN_POWER_OFFSET,
543 .speed = AQC_FAN_SPEED_OFFSET
547 struct hid_device *hdev;
548 struct device *hwmon_dev;
549 struct dentry *debugfs;
550 struct mutex mutex; /* Used for locking access when reading and writing PWM values */
554 int status_report_id; /* Used for legacy devices, report is stored in buffer */
556 int secondary_ctrl_report_id;
557 int secondary_ctrl_report_size;
558 u8 *secondary_ctrl_report;
560 ktime_t last_ctrl_report_op;
561 int ctrl_report_delay; /* Delay between two ctrl report operations, in ms */
570 u16 *fan_sensor_offsets;
571 u16 *fan_ctrl_offsets;
572 int num_temp_sensors;
573 int temp_sensor_start_offset;
574 int num_virtual_temp_sensors;
575 int virtual_temp_sensor_start_offset;
576 int num_calc_virt_temp_sensors;
577 int calc_virt_temp_sensor_start_offset;
578 u16 temp_ctrl_offset;
579 u16 power_cycle_count_offset;
580 int num_flow_sensors;
581 u8 flow_sensors_start_offset;
582 u8 flow_pulses_ctrl_offset;
583 struct aqc_fan_structure_offsets *fan_structure;
585 /* General info, same across all devices */
586 u8 serial_number_start_offset;
587 u32 serial_number[2];
588 u8 firmware_version_offset;
589 u16 firmware_version;
591 /* How many times the device was powered on, if available */
595 s32 temp_input[20]; /* Max 4 physical and 16 virtual or 8 physical and 12 virtual */
597 u32 speed_input_min[1];
598 u32 speed_input_target[1];
599 u32 speed_input_max[1];
601 u16 voltage_input[8];
602 u16 current_input[8];
605 const char *const *temp_label;
606 const char *const *virtual_temp_label;
607 const char *const *calc_virt_temp_label; /* For Aquaero */
608 const char *const *speed_label;
609 const char *const *power_label;
610 const char *const *voltage_label;
611 const char *const *current_label;
613 unsigned long updated;
616 /* Converts from centi-percent */
617 static int aqc_percent_to_pwm(u16 val)
619 return DIV_ROUND_CLOSEST(val * 255, 100 * 100);
622 /* Converts to centi-percent */
623 static int aqc_pwm_to_percent(long val)
625 if (val < 0 || val > 255)
628 return DIV_ROUND_CLOSEST(val * 100 * 100, 255);
631 /* Converts raw value for Aquastream XT pump speed to RPM */
632 static int aqc_aquastreamxt_convert_pump_rpm(u16 val)
635 return DIV_ROUND_CLOSEST(AQUASTREAMXT_PUMP_CONVERSION_CONST, val);
639 /* Converts raw value for Aquastream XT fan speed to RPM */
640 static int aqc_aquastreamxt_convert_fan_rpm(u16 val)
643 return DIV_ROUND_CLOSEST(AQUASTREAMXT_FAN_CONVERSION_CONST, val);
647 static void aqc_delay_ctrl_report(struct aqc_data *priv)
650 * If previous read or write is too close to this one, delay the current operation
651 * to give the device enough time to process the previous one.
653 if (priv->ctrl_report_delay) {
654 s64 delta = ktime_ms_delta(ktime_get(), priv->last_ctrl_report_op);
656 if (delta < priv->ctrl_report_delay)
657 msleep(priv->ctrl_report_delay - delta);
661 /* Expects the mutex to be locked */
662 static int aqc_get_ctrl_data(struct aqc_data *priv)
666 aqc_delay_ctrl_report(priv);
668 memset(priv->buffer, 0x00, priv->buffer_size);
669 ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size,
670 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
674 priv->last_ctrl_report_op = ktime_get();
679 /* Expects the mutex to be locked */
680 static int aqc_send_ctrl_data(struct aqc_data *priv)
685 aqc_delay_ctrl_report(priv);
687 /* Checksum is not needed for Aquaero */
688 if (priv->kind != aquaero) {
689 /* Init and xorout value for CRC-16/USB is 0xffff */
690 checksum = crc16(0xffff, priv->buffer + priv->checksum_start,
691 priv->checksum_length);
694 /* Place the new checksum at the end of the report */
695 put_unaligned_be16(checksum, priv->buffer + priv->checksum_offset);
698 /* Send the patched up report back to the device */
699 ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size,
700 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
702 goto record_access_and_ret;
704 /* The official software sends this report after every change, so do it here as well */
705 ret = hid_hw_raw_request(priv->hdev, priv->secondary_ctrl_report_id,
706 priv->secondary_ctrl_report, priv->secondary_ctrl_report_size,
707 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
709 record_access_and_ret:
710 priv->last_ctrl_report_op = ktime_get();
715 /* Refreshes the control buffer and stores value at offset in val */
716 static int aqc_get_ctrl_val(struct aqc_data *priv, int offset, long *val, int type)
720 mutex_lock(&priv->mutex);
722 ret = aqc_get_ctrl_data(priv);
724 goto unlock_and_return;
728 *val = (s16)get_unaligned_be16(priv->buffer + offset);
731 *val = priv->buffer[offset];
738 mutex_unlock(&priv->mutex);
742 static int aqc_set_ctrl_vals(struct aqc_data *priv, int *offsets, long *vals, int *types, int len)
746 mutex_lock(&priv->mutex);
748 ret = aqc_get_ctrl_data(priv);
750 goto unlock_and_return;
752 for (i = 0; i < len; i++) {
755 put_unaligned_be16((s16)vals[i], priv->buffer + offsets[i]);
758 priv->buffer[offsets[i]] = (u8)vals[i];
766 goto unlock_and_return;
768 ret = aqc_send_ctrl_data(priv);
771 mutex_unlock(&priv->mutex);
775 static int aqc_set_ctrl_val(struct aqc_data *priv, int offset, long val, int type)
777 return aqc_set_ctrl_vals(priv, &offset, &val, &type, 1);
780 static umode_t aqc_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel)
782 const struct aqc_data *priv = data;
786 if (channel < priv->num_temp_sensors) {
788 case hwmon_temp_label:
789 case hwmon_temp_input:
791 case hwmon_temp_offset:
792 if (priv->temp_ctrl_offset != 0)
801 priv->num_temp_sensors + priv->num_virtual_temp_sensors +
802 priv->num_calc_virt_temp_sensors)
804 case hwmon_temp_label:
805 case hwmon_temp_input:
812 if (priv->fan_ctrl_offsets && channel < priv->num_fans) {
814 case hwmon_pwm_input:
823 case hwmon_fan_input:
824 case hwmon_fan_label:
825 switch (priv->kind) {
828 * Special case to support pump RPM, fan RPM,
829 * pressure and flow sensor
835 /* Special case to support flow sensor, water quality
842 /* Special case for Leakshield sensors */
849 /* Special case to support flow sensors */
850 if (channel < priv->num_fans + priv->num_flow_sensors)
854 if (channel < priv->num_fans)
859 case hwmon_fan_pulses:
860 /* Special case for Quadro flow sensor */
861 if (priv->kind == quadro && channel == priv->num_fans)
866 case hwmon_fan_target:
867 /* Special case for Leakshield pressure sensor */
868 if (priv->kind == leakshield && channel == 0)
876 switch (priv->kind) {
878 /* Special case to support pump and fan power */
883 /* Special case to support one power sensor */
890 if (channel < priv->num_fans)
896 switch (priv->kind) {
898 /* Special case to support pump and fan current */
903 /* Special case to support pump current */
908 if (channel < priv->num_fans)
914 switch (priv->kind) {
916 /* Special case to support +5V and +12V voltage sensors */
917 if (channel < priv->num_fans + 2)
922 /* Special case to support two voltage sensors */
927 if (channel < priv->num_fans)
939 /* Read device sensors by manually requesting the sensor report (legacy way) */
940 static int aqc_legacy_read(struct aqc_data *priv)
942 int ret, i, sensor_value;
944 mutex_lock(&priv->mutex);
946 memset(priv->buffer, 0x00, priv->buffer_size);
947 ret = hid_hw_raw_request(priv->hdev, priv->status_report_id, priv->buffer,
948 priv->buffer_size, HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
950 goto unlock_and_return;
952 /* Temperature sensor readings */
953 for (i = 0; i < priv->num_temp_sensors; i++) {
954 sensor_value = get_unaligned_le16(priv->buffer + priv->temp_sensor_start_offset +
955 i * AQC_SENSOR_SIZE);
956 if (sensor_value == AQC_SENSOR_NA)
957 priv->temp_input[i] = -ENODATA;
959 priv->temp_input[i] = sensor_value * 10;
962 /* Special-case sensor readings */
963 switch (priv->kind) {
965 /* Info provided with every report */
966 priv->serial_number[0] = get_unaligned_le16(priv->buffer +
967 priv->serial_number_start_offset);
968 priv->firmware_version =
969 get_unaligned_le16(priv->buffer + priv->firmware_version_offset);
971 /* Read pump speed in RPM */
972 sensor_value = get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[0]);
973 priv->speed_input[0] = aqc_aquastreamxt_convert_pump_rpm(sensor_value);
975 /* Read fan speed in RPM, if available */
976 sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_STATUS_OFFSET);
977 if (sensor_value == AQUASTREAMXT_FAN_STOPPED) {
978 priv->speed_input[1] = 0;
981 get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[1]);
982 priv->speed_input[1] = aqc_aquastreamxt_convert_fan_rpm(sensor_value);
985 /* Calculation derived from linear regression */
986 sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_CURR_OFFSET);
987 priv->current_input[0] = DIV_ROUND_CLOSEST(sensor_value * 176, 100) - 52;
989 sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_VOLTAGE_OFFSET);
990 priv->voltage_input[0] = DIV_ROUND_CLOSEST(sensor_value * 1000, 61);
992 sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_VOLTAGE_OFFSET);
993 priv->voltage_input[1] = DIV_ROUND_CLOSEST(sensor_value * 1000, 63);
996 /* Info provided with every report */
997 priv->serial_number[0] = get_unaligned_le16(priv->buffer +
998 priv->serial_number_start_offset);
999 priv->firmware_version =
1000 get_unaligned_le16(priv->buffer + priv->firmware_version_offset);
1002 /* Read flow speed */
1003 priv->speed_input[0] = get_unaligned_le16(priv->buffer +
1004 priv->flow_sensors_start_offset);
1010 priv->updated = jiffies;
1013 mutex_unlock(&priv->mutex);
1017 static int aqc_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1018 int channel, long *val)
1021 struct aqc_data *priv = dev_get_drvdata(dev);
1023 if (time_after(jiffies, priv->updated + STATUS_UPDATE_INTERVAL)) {
1024 if (priv->status_report_id != 0) {
1025 /* Legacy devices require manual reads */
1026 ret = aqc_legacy_read(priv);
1037 case hwmon_temp_input:
1038 if (priv->temp_input[channel] == -ENODATA)
1041 *val = priv->temp_input[channel];
1043 case hwmon_temp_offset:
1045 aqc_get_ctrl_val(priv, priv->temp_ctrl_offset +
1046 channel * AQC_SENSOR_SIZE, val, AQC_BE16);
1058 case hwmon_fan_input:
1059 if (priv->speed_input[channel] == -ENODATA)
1062 *val = priv->speed_input[channel];
1065 *val = priv->speed_input_min[channel];
1068 *val = priv->speed_input_max[channel];
1070 case hwmon_fan_target:
1071 *val = priv->speed_input_target[channel];
1073 case hwmon_fan_pulses:
1074 ret = aqc_get_ctrl_val(priv, priv->flow_pulses_ctrl_offset,
1084 *val = priv->power_input[channel];
1087 switch (priv->kind) {
1089 ret = aqc_get_ctrl_val(priv,
1090 AQUAERO_CTRL_PRESET_START + channel * AQUAERO_CTRL_PRESET_SIZE,
1094 *val = aqc_percent_to_pwm(*val);
1097 ret = aqc_get_ctrl_val(priv, priv->fan_ctrl_offsets[channel],
1102 *val = aqc_percent_to_pwm(*val);
1107 *val = priv->voltage_input[channel];
1110 *val = priv->current_input[channel];
1119 static int aqc_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
1120 int channel, const char **str)
1122 struct aqc_data *priv = dev_get_drvdata(dev);
1124 /* Number of sensors that are not calculated */
1125 int num_non_calc_sensors = priv->num_temp_sensors + priv->num_virtual_temp_sensors;
1129 if (channel < priv->num_temp_sensors) {
1130 *str = priv->temp_label[channel];
1132 if (priv->kind == aquaero && channel >= num_non_calc_sensors)
1134 priv->calc_virt_temp_label[channel - num_non_calc_sensors];
1136 *str = priv->virtual_temp_label[channel - priv->num_temp_sensors];
1140 *str = priv->speed_label[channel];
1143 *str = priv->power_label[channel];
1146 *str = priv->voltage_label[channel];
1149 *str = priv->current_label[channel];
1158 static int aqc_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
1162 /* Arrays for setting multiple values at once in the control report */
1163 int ctrl_values_offsets[4];
1164 long ctrl_values[4];
1165 int ctrl_values_types[4];
1166 struct aqc_data *priv = dev_get_drvdata(dev);
1171 case hwmon_temp_offset:
1172 /* Limit temp offset to +/- 15K as in the official software */
1173 val = clamp_val(val, -15000, 15000) / 10;
1175 aqc_set_ctrl_val(priv, priv->temp_ctrl_offset +
1176 channel * AQC_SENSOR_SIZE, val, AQC_BE16);
1186 case hwmon_fan_pulses:
1187 val = clamp_val(val, 10, 1000);
1188 ret = aqc_set_ctrl_val(priv, priv->flow_pulses_ctrl_offset,
1199 case hwmon_pwm_input:
1200 pwm_value = aqc_pwm_to_percent(val);
1204 switch (priv->kind) {
1206 /* Write pwm value to preset corresponding to the channel */
1207 ctrl_values_offsets[0] = AQUAERO_CTRL_PRESET_START +
1208 channel * AQUAERO_CTRL_PRESET_SIZE;
1209 ctrl_values[0] = pwm_value;
1210 ctrl_values_types[0] = AQC_BE16;
1212 /* Write preset number in fan control source */
1213 ctrl_values_offsets[1] = priv->fan_ctrl_offsets[channel] +
1214 AQUAERO_FAN_CTRL_SRC_OFFSET;
1215 ctrl_values[1] = AQUAERO_CTRL_PRESET_ID + channel;
1216 ctrl_values_types[1] = AQC_BE16;
1218 /* Set minimum power to 0 to allow the fan to turn off */
1219 ctrl_values_offsets[2] = priv->fan_ctrl_offsets[channel] +
1220 AQUAERO_FAN_CTRL_MIN_PWR_OFFSET;
1222 ctrl_values_types[2] = AQC_BE16;
1224 /* Set maximum power to 255 to allow the fan to reach max speed */
1225 ctrl_values_offsets[3] = priv->fan_ctrl_offsets[channel] +
1226 AQUAERO_FAN_CTRL_MAX_PWR_OFFSET;
1227 ctrl_values[3] = aqc_pwm_to_percent(255);
1228 ctrl_values_types[3] = AQC_BE16;
1230 ret = aqc_set_ctrl_vals(priv, ctrl_values_offsets, ctrl_values,
1231 ctrl_values_types, 4);
1236 ret = aqc_set_ctrl_val(priv, priv->fan_ctrl_offsets[channel],
1237 pwm_value, AQC_BE16);
1254 static const struct hwmon_ops aqc_hwmon_ops = {
1255 .is_visible = aqc_is_visible,
1257 .read_string = aqc_read_string,
1261 static const struct hwmon_channel_info * const aqc_info[] = {
1262 HWMON_CHANNEL_INFO(temp,
1263 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1264 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1265 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1266 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1267 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1268 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1269 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1270 HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1271 HWMON_T_INPUT | HWMON_T_LABEL,
1272 HWMON_T_INPUT | HWMON_T_LABEL,
1273 HWMON_T_INPUT | HWMON_T_LABEL,
1274 HWMON_T_INPUT | HWMON_T_LABEL,
1275 HWMON_T_INPUT | HWMON_T_LABEL,
1276 HWMON_T_INPUT | HWMON_T_LABEL,
1277 HWMON_T_INPUT | HWMON_T_LABEL,
1278 HWMON_T_INPUT | HWMON_T_LABEL,
1279 HWMON_T_INPUT | HWMON_T_LABEL,
1280 HWMON_T_INPUT | HWMON_T_LABEL,
1281 HWMON_T_INPUT | HWMON_T_LABEL,
1282 HWMON_T_INPUT | HWMON_T_LABEL),
1283 HWMON_CHANNEL_INFO(fan,
1284 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MIN | HWMON_F_MAX |
1286 HWMON_F_INPUT | HWMON_F_LABEL,
1287 HWMON_F_INPUT | HWMON_F_LABEL,
1288 HWMON_F_INPUT | HWMON_F_LABEL,
1289 HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_PULSES,
1290 HWMON_F_INPUT | HWMON_F_LABEL,
1291 HWMON_F_INPUT | HWMON_F_LABEL,
1292 HWMON_F_INPUT | HWMON_F_LABEL),
1293 HWMON_CHANNEL_INFO(power,
1294 HWMON_P_INPUT | HWMON_P_LABEL,
1295 HWMON_P_INPUT | HWMON_P_LABEL,
1296 HWMON_P_INPUT | HWMON_P_LABEL,
1297 HWMON_P_INPUT | HWMON_P_LABEL,
1298 HWMON_P_INPUT | HWMON_P_LABEL,
1299 HWMON_P_INPUT | HWMON_P_LABEL,
1300 HWMON_P_INPUT | HWMON_P_LABEL,
1301 HWMON_P_INPUT | HWMON_P_LABEL),
1302 HWMON_CHANNEL_INFO(pwm,
1311 HWMON_CHANNEL_INFO(in,
1312 HWMON_I_INPUT | HWMON_I_LABEL,
1313 HWMON_I_INPUT | HWMON_I_LABEL,
1314 HWMON_I_INPUT | HWMON_I_LABEL,
1315 HWMON_I_INPUT | HWMON_I_LABEL,
1316 HWMON_I_INPUT | HWMON_I_LABEL,
1317 HWMON_I_INPUT | HWMON_I_LABEL,
1318 HWMON_I_INPUT | HWMON_I_LABEL,
1319 HWMON_I_INPUT | HWMON_I_LABEL),
1320 HWMON_CHANNEL_INFO(curr,
1321 HWMON_C_INPUT | HWMON_C_LABEL,
1322 HWMON_C_INPUT | HWMON_C_LABEL,
1323 HWMON_C_INPUT | HWMON_C_LABEL,
1324 HWMON_C_INPUT | HWMON_C_LABEL,
1325 HWMON_C_INPUT | HWMON_C_LABEL,
1326 HWMON_C_INPUT | HWMON_C_LABEL,
1327 HWMON_C_INPUT | HWMON_C_LABEL,
1328 HWMON_C_INPUT | HWMON_C_LABEL),
1332 static const struct hwmon_chip_info aqc_chip_info = {
1333 .ops = &aqc_hwmon_ops,
1337 static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)
1339 int i, j, sensor_value;
1340 struct aqc_data *priv;
1342 if (report->id != STATUS_REPORT_ID)
1345 priv = hid_get_drvdata(hdev);
1347 /* Info provided with every report */
1348 priv->serial_number[0] = get_unaligned_be16(data + priv->serial_number_start_offset);
1349 priv->serial_number[1] = get_unaligned_be16(data + priv->serial_number_start_offset +
1350 SERIAL_PART_OFFSET);
1351 priv->firmware_version = get_unaligned_be16(data + priv->firmware_version_offset);
1353 /* Physical temperature sensor readings */
1354 for (i = 0; i < priv->num_temp_sensors; i++) {
1355 sensor_value = get_unaligned_be16(data +
1356 priv->temp_sensor_start_offset +
1357 i * AQC_SENSOR_SIZE);
1358 if (sensor_value == AQC_SENSOR_NA)
1359 priv->temp_input[i] = -ENODATA;
1361 priv->temp_input[i] = sensor_value * 10;
1364 /* Virtual temperature sensor readings */
1365 for (j = 0; j < priv->num_virtual_temp_sensors; j++) {
1366 sensor_value = get_unaligned_be16(data +
1367 priv->virtual_temp_sensor_start_offset +
1368 j * AQC_SENSOR_SIZE);
1369 if (sensor_value == AQC_SENSOR_NA)
1370 priv->temp_input[i] = -ENODATA;
1372 priv->temp_input[i] = sensor_value * 10;
1376 /* Fan speed and related readings */
1377 for (i = 0; i < priv->num_fans; i++) {
1378 priv->speed_input[i] =
1379 get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1380 priv->fan_structure->speed);
1381 priv->power_input[i] =
1382 get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1383 priv->fan_structure->power) * 10000;
1384 priv->voltage_input[i] =
1385 get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1386 priv->fan_structure->voltage) * 10;
1387 priv->current_input[i] =
1388 get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1389 priv->fan_structure->curr);
1392 /* Flow sensor readings */
1393 for (j = 0; j < priv->num_flow_sensors; j++) {
1394 priv->speed_input[i] = get_unaligned_be16(data + priv->flow_sensors_start_offset +
1395 j * AQC_SENSOR_SIZE);
1399 if (priv->power_cycle_count_offset != 0)
1400 priv->power_cycles = get_unaligned_be32(data + priv->power_cycle_count_offset);
1402 /* Special-case sensor readings */
1403 switch (priv->kind) {
1405 /* Read calculated virtual temp sensors */
1406 i = priv->num_temp_sensors + priv->num_virtual_temp_sensors;
1407 for (j = 0; j < priv->num_calc_virt_temp_sensors; j++) {
1408 sensor_value = get_unaligned_be16(data +
1409 priv->calc_virt_temp_sensor_start_offset +
1410 j * AQC_SENSOR_SIZE);
1411 if (sensor_value == AQC_SENSOR_NA)
1412 priv->temp_input[i] = -ENODATA;
1414 priv->temp_input[i] = sensor_value * 10;
1419 priv->speed_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_OFFSET);
1420 priv->speed_input[2] = get_unaligned_be16(data + AQUASTREAMULT_PRESSURE_OFFSET);
1421 priv->speed_input[3] = get_unaligned_be16(data + AQUASTREAMULT_FLOW_SENSOR_OFFSET);
1423 priv->power_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_POWER) * 10000;
1425 priv->voltage_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_VOLTAGE) * 10;
1427 priv->current_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_CURRENT);
1430 priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10;
1431 priv->voltage_input[3] = get_unaligned_be16(data + D5NEXT_12V_VOLTAGE) * 10;
1434 /* If external temp sensor is not connected, its power reading is also N/A */
1435 if (priv->temp_input[1] == -ENODATA)
1436 priv->power_input[0] = -ENODATA;
1438 priv->power_input[0] =
1439 get_unaligned_be16(data + HIGHFLOWNEXT_POWER) * 1000000;
1441 priv->voltage_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE) * 10;
1442 priv->voltage_input[1] =
1443 get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE_USB) * 10;
1445 priv->speed_input[1] = get_unaligned_be16(data + HIGHFLOWNEXT_WATER_QUALITY);
1446 priv->speed_input[2] = get_unaligned_be16(data + HIGHFLOWNEXT_CONDUCTIVITY);
1449 priv->speed_input[0] =
1450 ((s16)get_unaligned_be16(data + LEAKSHIELD_PRESSURE_ADJUSTED)) * 100;
1451 priv->speed_input_min[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MIN) * 100;
1452 priv->speed_input_target[0] =
1453 get_unaligned_be16(data + LEAKSHIELD_PRESSURE_TARGET) * 100;
1454 priv->speed_input_max[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MAX) * 100;
1456 priv->speed_input[1] = get_unaligned_be16(data + LEAKSHIELD_PUMP_RPM_IN);
1457 if (priv->speed_input[1] == AQC_SENSOR_NA)
1458 priv->speed_input[1] = -ENODATA;
1460 priv->speed_input[2] = get_unaligned_be16(data + LEAKSHIELD_FLOW_IN);
1461 if (priv->speed_input[2] == AQC_SENSOR_NA)
1462 priv->speed_input[2] = -ENODATA;
1464 priv->speed_input[3] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_VOLUME);
1465 priv->speed_input[4] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_FILLED);
1467 /* Second temp sensor is not positioned after the first one, read it here */
1468 priv->temp_input[1] = get_unaligned_be16(data + LEAKSHIELD_TEMPERATURE_2) * 10;
1474 priv->updated = jiffies;
1479 static int serial_number_show(struct seq_file *seqf, void *unused)
1481 struct aqc_data *priv = seqf->private;
1483 seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]);
1487 DEFINE_SHOW_ATTRIBUTE(serial_number);
1489 static int firmware_version_show(struct seq_file *seqf, void *unused)
1491 struct aqc_data *priv = seqf->private;
1493 seq_printf(seqf, "%u\n", priv->firmware_version);
1497 DEFINE_SHOW_ATTRIBUTE(firmware_version);
1499 static int power_cycles_show(struct seq_file *seqf, void *unused)
1501 struct aqc_data *priv = seqf->private;
1503 seq_printf(seqf, "%u\n", priv->power_cycles);
1507 DEFINE_SHOW_ATTRIBUTE(power_cycles);
1509 static void aqc_debugfs_init(struct aqc_data *priv)
1513 scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name,
1514 dev_name(&priv->hdev->dev));
1516 priv->debugfs = debugfs_create_dir(name, NULL);
1518 if (priv->serial_number_start_offset != 0)
1519 debugfs_create_file("serial_number", 0444, priv->debugfs, priv,
1520 &serial_number_fops);
1521 if (priv->firmware_version_offset != 0)
1522 debugfs_create_file("firmware_version", 0444, priv->debugfs, priv,
1523 &firmware_version_fops);
1524 if (priv->power_cycle_count_offset != 0)
1525 debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops);
1528 static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id)
1530 struct aqc_data *priv;
1533 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
1538 hid_set_drvdata(hdev, priv);
1540 priv->updated = jiffies - STATUS_UPDATE_INTERVAL;
1542 ret = hid_parse(hdev);
1546 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1550 ret = hid_hw_open(hdev);
1554 switch (hdev->product) {
1555 case USB_PRODUCT_ID_AQUAERO:
1557 * Aquaero presents itself as three HID devices under the same product ID:
1558 * "aquaero keyboard/mouse", "aquaero System Control" and "aquaero Device",
1559 * which is the one we want to communicate with. Unlike most other Aquacomputer
1560 * devices, Aquaero does not return meaningful data when explicitly requested
1561 * using GET_FEATURE_REPORT.
1563 * The difference between "aquaero Device" and the other two is in the collections
1564 * they present. The two other devices have the type of the second element in
1565 * their respective collections set to 1, while the real device has it set to 0.
1567 if (hdev->collection[1].type != 0) {
1569 goto fail_and_close;
1572 priv->kind = aquaero;
1574 priv->num_fans = AQUAERO_NUM_FANS;
1575 priv->fan_sensor_offsets = aquaero_sensor_fan_offsets;
1576 priv->fan_ctrl_offsets = aquaero_ctrl_fan_offsets;
1578 priv->num_temp_sensors = AQUAERO_NUM_SENSORS;
1579 priv->temp_sensor_start_offset = AQUAERO_SENSOR_START;
1580 priv->num_virtual_temp_sensors = AQUAERO_NUM_VIRTUAL_SENSORS;
1581 priv->virtual_temp_sensor_start_offset = AQUAERO_VIRTUAL_SENSOR_START;
1582 priv->num_calc_virt_temp_sensors = AQUAERO_NUM_CALC_VIRTUAL_SENSORS;
1583 priv->calc_virt_temp_sensor_start_offset = AQUAERO_CALC_VIRTUAL_SENSOR_START;
1584 priv->num_flow_sensors = AQUAERO_NUM_FLOW_SENSORS;
1585 priv->flow_sensors_start_offset = AQUAERO_FLOW_SENSORS_START;
1587 priv->buffer_size = AQUAERO_CTRL_REPORT_SIZE;
1588 priv->temp_ctrl_offset = AQUAERO_TEMP_CTRL_OFFSET;
1589 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1591 priv->temp_label = label_temp_sensors;
1592 priv->virtual_temp_label = label_virtual_temp_sensors;
1593 priv->calc_virt_temp_label = label_aquaero_calc_temp_sensors;
1594 priv->speed_label = label_aquaero_speeds;
1595 priv->power_label = label_fan_power;
1596 priv->voltage_label = label_fan_voltage;
1597 priv->current_label = label_fan_current;
1599 case USB_PRODUCT_ID_D5NEXT:
1600 priv->kind = d5next;
1602 priv->num_fans = D5NEXT_NUM_FANS;
1603 priv->fan_sensor_offsets = d5next_sensor_fan_offsets;
1604 priv->fan_ctrl_offsets = d5next_ctrl_fan_offsets;
1606 priv->num_temp_sensors = D5NEXT_NUM_SENSORS;
1607 priv->temp_sensor_start_offset = D5NEXT_COOLANT_TEMP;
1608 priv->num_virtual_temp_sensors = D5NEXT_NUM_VIRTUAL_SENSORS;
1609 priv->virtual_temp_sensor_start_offset = D5NEXT_VIRTUAL_SENSORS_START;
1610 priv->temp_ctrl_offset = D5NEXT_TEMP_CTRL_OFFSET;
1612 priv->buffer_size = D5NEXT_CTRL_REPORT_SIZE;
1613 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1615 priv->power_cycle_count_offset = D5NEXT_POWER_CYCLES;
1617 priv->temp_label = label_d5next_temp;
1618 priv->virtual_temp_label = label_virtual_temp_sensors;
1619 priv->speed_label = label_d5next_speeds;
1620 priv->power_label = label_d5next_power;
1621 priv->voltage_label = label_d5next_voltages;
1622 priv->current_label = label_d5next_current;
1624 case USB_PRODUCT_ID_FARBWERK:
1625 priv->kind = farbwerk;
1629 priv->num_temp_sensors = FARBWERK_NUM_SENSORS;
1630 priv->temp_sensor_start_offset = FARBWERK_SENSOR_START;
1632 priv->temp_label = label_temp_sensors;
1634 case USB_PRODUCT_ID_FARBWERK360:
1635 priv->kind = farbwerk360;
1639 priv->num_temp_sensors = FARBWERK360_NUM_SENSORS;
1640 priv->temp_sensor_start_offset = FARBWERK360_SENSOR_START;
1641 priv->num_virtual_temp_sensors = FARBWERK360_NUM_VIRTUAL_SENSORS;
1642 priv->virtual_temp_sensor_start_offset = FARBWERK360_VIRTUAL_SENSORS_START;
1643 priv->temp_ctrl_offset = FARBWERK360_TEMP_CTRL_OFFSET;
1645 priv->buffer_size = FARBWERK360_CTRL_REPORT_SIZE;
1647 priv->temp_label = label_temp_sensors;
1648 priv->virtual_temp_label = label_virtual_temp_sensors;
1650 case USB_PRODUCT_ID_OCTO:
1653 priv->num_fans = OCTO_NUM_FANS;
1654 priv->fan_sensor_offsets = octo_sensor_fan_offsets;
1655 priv->fan_ctrl_offsets = octo_ctrl_fan_offsets;
1657 priv->num_temp_sensors = OCTO_NUM_SENSORS;
1658 priv->temp_sensor_start_offset = OCTO_SENSOR_START;
1659 priv->num_virtual_temp_sensors = OCTO_NUM_VIRTUAL_SENSORS;
1660 priv->virtual_temp_sensor_start_offset = OCTO_VIRTUAL_SENSORS_START;
1661 priv->temp_ctrl_offset = OCTO_TEMP_CTRL_OFFSET;
1663 priv->buffer_size = OCTO_CTRL_REPORT_SIZE;
1664 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1666 priv->power_cycle_count_offset = OCTO_POWER_CYCLES;
1668 priv->temp_label = label_temp_sensors;
1669 priv->virtual_temp_label = label_virtual_temp_sensors;
1670 priv->speed_label = label_fan_speed;
1671 priv->power_label = label_fan_power;
1672 priv->voltage_label = label_fan_voltage;
1673 priv->current_label = label_fan_current;
1675 case USB_PRODUCT_ID_QUADRO:
1676 priv->kind = quadro;
1678 priv->num_fans = QUADRO_NUM_FANS;
1679 priv->fan_sensor_offsets = quadro_sensor_fan_offsets;
1680 priv->fan_ctrl_offsets = quadro_ctrl_fan_offsets;
1682 priv->num_temp_sensors = QUADRO_NUM_SENSORS;
1683 priv->temp_sensor_start_offset = QUADRO_SENSOR_START;
1684 priv->num_virtual_temp_sensors = QUADRO_NUM_VIRTUAL_SENSORS;
1685 priv->virtual_temp_sensor_start_offset = QUADRO_VIRTUAL_SENSORS_START;
1686 priv->num_flow_sensors = QUADRO_NUM_FLOW_SENSORS;
1687 priv->flow_sensors_start_offset = QUADRO_FLOW_SENSOR_OFFSET;
1689 priv->temp_ctrl_offset = QUADRO_TEMP_CTRL_OFFSET;
1691 priv->buffer_size = QUADRO_CTRL_REPORT_SIZE;
1692 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1694 priv->flow_pulses_ctrl_offset = QUADRO_FLOW_PULSES_CTRL_OFFSET;
1695 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;
1697 priv->temp_label = label_temp_sensors;
1698 priv->virtual_temp_label = label_virtual_temp_sensors;
1699 priv->speed_label = label_quadro_speeds;
1700 priv->power_label = label_fan_power;
1701 priv->voltage_label = label_fan_voltage;
1702 priv->current_label = label_fan_current;
1704 case USB_PRODUCT_ID_HIGHFLOWNEXT:
1705 priv->kind = highflownext;
1709 priv->num_temp_sensors = HIGHFLOWNEXT_NUM_SENSORS;
1710 priv->temp_sensor_start_offset = HIGHFLOWNEXT_SENSOR_START;
1711 priv->num_flow_sensors = HIGHFLOWNEXT_NUM_FLOW_SENSORS;
1712 priv->flow_sensors_start_offset = HIGHFLOWNEXT_FLOW;
1714 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;
1716 priv->temp_label = label_highflownext_temp_sensors;
1717 priv->speed_label = label_highflownext_fan_speed;
1718 priv->power_label = label_highflownext_power;
1719 priv->voltage_label = label_highflownext_voltage;
1721 case USB_PRODUCT_ID_LEAKSHIELD:
1723 * Choose the right Leakshield device, because
1724 * the other one acts as a keyboard
1726 if (hdev->type != 2) {
1728 goto fail_and_close;
1731 priv->kind = leakshield;
1734 priv->num_temp_sensors = LEAKSHIELD_NUM_SENSORS;
1735 priv->temp_sensor_start_offset = LEAKSHIELD_TEMPERATURE_1;
1737 priv->temp_label = label_leakshield_temp_sensors;
1738 priv->speed_label = label_leakshield_fan_speed;
1740 case USB_PRODUCT_ID_AQUASTREAMXT:
1741 priv->kind = aquastreamxt;
1743 priv->num_fans = AQUASTREAMXT_NUM_FANS;
1744 priv->fan_sensor_offsets = aquastreamxt_sensor_fan_offsets;
1746 priv->num_temp_sensors = AQUASTREAMXT_NUM_SENSORS;
1747 priv->temp_sensor_start_offset = AQUASTREAMXT_SENSOR_START;
1748 priv->buffer_size = AQUASTREAMXT_SENSOR_REPORT_SIZE;
1750 priv->temp_label = label_aquastreamxt_temp_sensors;
1751 priv->speed_label = label_d5next_speeds;
1752 priv->voltage_label = label_d5next_voltages;
1753 priv->current_label = label_d5next_current;
1755 case USB_PRODUCT_ID_AQUASTREAMULT:
1756 priv->kind = aquastreamult;
1758 priv->num_fans = AQUASTREAMULT_NUM_FANS;
1759 priv->fan_sensor_offsets = aquastreamult_sensor_fan_offsets;
1761 priv->num_temp_sensors = AQUASTREAMULT_NUM_SENSORS;
1762 priv->temp_sensor_start_offset = AQUASTREAMULT_SENSOR_START;
1764 priv->temp_label = label_aquastreamult_temp;
1765 priv->speed_label = label_aquastreamult_speeds;
1766 priv->power_label = label_aquastreamult_power;
1767 priv->voltage_label = label_aquastreamult_voltages;
1768 priv->current_label = label_aquastreamult_current;
1770 case USB_PRODUCT_ID_POWERADJUST3:
1771 priv->kind = poweradjust3;
1775 priv->num_temp_sensors = POWERADJUST3_NUM_SENSORS;
1776 priv->temp_sensor_start_offset = POWERADJUST3_SENSOR_START;
1777 priv->buffer_size = POWERADJUST3_SENSOR_REPORT_SIZE;
1779 priv->temp_label = label_poweradjust3_temp_sensors;
1781 case USB_PRODUCT_ID_HIGHFLOW:
1782 priv->kind = highflow;
1786 priv->num_temp_sensors = HIGHFLOW_NUM_SENSORS;
1787 priv->temp_sensor_start_offset = HIGHFLOW_SENSOR_START;
1788 priv->num_flow_sensors = HIGHFLOW_NUM_FLOW_SENSORS;
1789 priv->flow_sensors_start_offset = HIGHFLOW_FLOW_SENSOR_OFFSET;
1790 priv->buffer_size = HIGHFLOW_SENSOR_REPORT_SIZE;
1792 priv->temp_label = label_highflow_temp;
1793 priv->speed_label = label_highflow_speeds;
1799 switch (priv->kind) {
1801 priv->serial_number_start_offset = AQUAERO_SERIAL_START;
1802 priv->firmware_version_offset = AQUAERO_FIRMWARE_VERSION;
1804 priv->fan_structure = &aqc_aquaero_fan_structure;
1806 priv->ctrl_report_id = AQUAERO_CTRL_REPORT_ID;
1807 priv->secondary_ctrl_report_id = AQUAERO_SECONDARY_CTRL_REPORT_ID;
1808 priv->secondary_ctrl_report_size = AQUAERO_SECONDARY_CTRL_REPORT_SIZE;
1809 priv->secondary_ctrl_report = aquaero_secondary_ctrl_report;
1812 priv->status_report_id = POWERADJUST3_STATUS_REPORT_ID;
1815 priv->serial_number_start_offset = AQUASTREAMXT_SERIAL_START;
1816 priv->firmware_version_offset = AQUASTREAMXT_FIRMWARE_VERSION;
1818 priv->status_report_id = AQUASTREAMXT_STATUS_REPORT_ID;
1821 priv->serial_number_start_offset = HIGHFLOW_SERIAL_START;
1822 priv->firmware_version_offset = HIGHFLOW_FIRMWARE_VERSION;
1824 priv->status_report_id = HIGHFLOW_STATUS_REPORT_ID;
1827 priv->serial_number_start_offset = AQC_SERIAL_START;
1828 priv->firmware_version_offset = AQC_FIRMWARE_VERSION;
1830 priv->ctrl_report_id = CTRL_REPORT_ID;
1831 priv->secondary_ctrl_report_id = SECONDARY_CTRL_REPORT_ID;
1832 priv->secondary_ctrl_report_size = SECONDARY_CTRL_REPORT_SIZE;
1833 priv->secondary_ctrl_report = secondary_ctrl_report;
1835 if (priv->kind == aquastreamult)
1836 priv->fan_structure = &aqc_aquastreamult_fan_structure;
1838 priv->fan_structure = &aqc_general_fan_structure;
1842 if (priv->buffer_size != 0) {
1843 priv->checksum_start = 0x01;
1844 priv->checksum_length = priv->buffer_size - 3;
1845 priv->checksum_offset = priv->buffer_size - 2;
1848 priv->name = aqc_device_names[priv->kind];
1850 priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL);
1851 if (!priv->buffer) {
1853 goto fail_and_close;
1856 mutex_init(&priv->mutex);
1858 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv,
1859 &aqc_chip_info, NULL);
1861 if (IS_ERR(priv->hwmon_dev)) {
1862 ret = PTR_ERR(priv->hwmon_dev);
1863 goto fail_and_close;
1866 aqc_debugfs_init(priv);
1877 static void aqc_remove(struct hid_device *hdev)
1879 struct aqc_data *priv = hid_get_drvdata(hdev);
1881 debugfs_remove_recursive(priv->debugfs);
1882 hwmon_device_unregister(priv->hwmon_dev);
1888 static const struct hid_device_id aqc_table[] = {
1889 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUAERO) },
1890 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) },
1891 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) },
1892 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) },
1893 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) },
1894 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_QUADRO) },
1895 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOWNEXT) },
1896 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_LEAKSHIELD) },
1897 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMXT) },
1898 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMULT) },
1899 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_POWERADJUST3) },
1900 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOW) },
1904 MODULE_DEVICE_TABLE(hid, aqc_table);
1906 static struct hid_driver aqc_driver = {
1907 .name = DRIVER_NAME,
1908 .id_table = aqc_table,
1910 .remove = aqc_remove,
1911 .raw_event = aqc_raw_event,
1914 static int __init aqc_init(void)
1916 return hid_register_driver(&aqc_driver);
1919 static void __exit aqc_exit(void)
1921 hid_unregister_driver(&aqc_driver);
1924 /* Request to initialize after the HID bus to ensure it's not being loaded before */
1925 late_initcall(aqc_init);
1926 module_exit(aqc_exit);
1928 MODULE_LICENSE("GPL");
1929 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
1930 MODULE_AUTHOR("Jack Doan <me@jackdoan.com>");
1931 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices");