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 #ifdef CONFIG_DEBUG_FS
1481 static int serial_number_show(struct seq_file *seqf, void *unused)
1483 struct aqc_data *priv = seqf->private;
1485 seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]);
1489 DEFINE_SHOW_ATTRIBUTE(serial_number);
1491 static int firmware_version_show(struct seq_file *seqf, void *unused)
1493 struct aqc_data *priv = seqf->private;
1495 seq_printf(seqf, "%u\n", priv->firmware_version);
1499 DEFINE_SHOW_ATTRIBUTE(firmware_version);
1501 static int power_cycles_show(struct seq_file *seqf, void *unused)
1503 struct aqc_data *priv = seqf->private;
1505 seq_printf(seqf, "%u\n", priv->power_cycles);
1509 DEFINE_SHOW_ATTRIBUTE(power_cycles);
1511 static void aqc_debugfs_init(struct aqc_data *priv)
1515 scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name,
1516 dev_name(&priv->hdev->dev));
1518 priv->debugfs = debugfs_create_dir(name, NULL);
1520 if (priv->serial_number_start_offset != 0)
1521 debugfs_create_file("serial_number", 0444, priv->debugfs, priv,
1522 &serial_number_fops);
1523 if (priv->firmware_version_offset != 0)
1524 debugfs_create_file("firmware_version", 0444, priv->debugfs, priv,
1525 &firmware_version_fops);
1526 if (priv->power_cycle_count_offset != 0)
1527 debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops);
1532 static void aqc_debugfs_init(struct aqc_data *priv)
1538 static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id)
1540 struct aqc_data *priv;
1543 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
1548 hid_set_drvdata(hdev, priv);
1550 priv->updated = jiffies - STATUS_UPDATE_INTERVAL;
1552 ret = hid_parse(hdev);
1556 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1560 ret = hid_hw_open(hdev);
1564 switch (hdev->product) {
1565 case USB_PRODUCT_ID_AQUAERO:
1567 * Aquaero presents itself as three HID devices under the same product ID:
1568 * "aquaero keyboard/mouse", "aquaero System Control" and "aquaero Device",
1569 * which is the one we want to communicate with. Unlike most other Aquacomputer
1570 * devices, Aquaero does not return meaningful data when explicitly requested
1571 * using GET_FEATURE_REPORT.
1573 * The difference between "aquaero Device" and the other two is in the collections
1574 * they present. The two other devices have the type of the second element in
1575 * their respective collections set to 1, while the real device has it set to 0.
1577 if (hdev->collection[1].type != 0) {
1579 goto fail_and_close;
1582 priv->kind = aquaero;
1584 priv->num_fans = AQUAERO_NUM_FANS;
1585 priv->fan_sensor_offsets = aquaero_sensor_fan_offsets;
1586 priv->fan_ctrl_offsets = aquaero_ctrl_fan_offsets;
1588 priv->num_temp_sensors = AQUAERO_NUM_SENSORS;
1589 priv->temp_sensor_start_offset = AQUAERO_SENSOR_START;
1590 priv->num_virtual_temp_sensors = AQUAERO_NUM_VIRTUAL_SENSORS;
1591 priv->virtual_temp_sensor_start_offset = AQUAERO_VIRTUAL_SENSOR_START;
1592 priv->num_calc_virt_temp_sensors = AQUAERO_NUM_CALC_VIRTUAL_SENSORS;
1593 priv->calc_virt_temp_sensor_start_offset = AQUAERO_CALC_VIRTUAL_SENSOR_START;
1594 priv->num_flow_sensors = AQUAERO_NUM_FLOW_SENSORS;
1595 priv->flow_sensors_start_offset = AQUAERO_FLOW_SENSORS_START;
1597 priv->buffer_size = AQUAERO_CTRL_REPORT_SIZE;
1598 priv->temp_ctrl_offset = AQUAERO_TEMP_CTRL_OFFSET;
1599 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1601 priv->temp_label = label_temp_sensors;
1602 priv->virtual_temp_label = label_virtual_temp_sensors;
1603 priv->calc_virt_temp_label = label_aquaero_calc_temp_sensors;
1604 priv->speed_label = label_aquaero_speeds;
1605 priv->power_label = label_fan_power;
1606 priv->voltage_label = label_fan_voltage;
1607 priv->current_label = label_fan_current;
1609 case USB_PRODUCT_ID_D5NEXT:
1610 priv->kind = d5next;
1612 priv->num_fans = D5NEXT_NUM_FANS;
1613 priv->fan_sensor_offsets = d5next_sensor_fan_offsets;
1614 priv->fan_ctrl_offsets = d5next_ctrl_fan_offsets;
1616 priv->num_temp_sensors = D5NEXT_NUM_SENSORS;
1617 priv->temp_sensor_start_offset = D5NEXT_COOLANT_TEMP;
1618 priv->num_virtual_temp_sensors = D5NEXT_NUM_VIRTUAL_SENSORS;
1619 priv->virtual_temp_sensor_start_offset = D5NEXT_VIRTUAL_SENSORS_START;
1620 priv->temp_ctrl_offset = D5NEXT_TEMP_CTRL_OFFSET;
1622 priv->buffer_size = D5NEXT_CTRL_REPORT_SIZE;
1623 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1625 priv->power_cycle_count_offset = D5NEXT_POWER_CYCLES;
1627 priv->temp_label = label_d5next_temp;
1628 priv->virtual_temp_label = label_virtual_temp_sensors;
1629 priv->speed_label = label_d5next_speeds;
1630 priv->power_label = label_d5next_power;
1631 priv->voltage_label = label_d5next_voltages;
1632 priv->current_label = label_d5next_current;
1634 case USB_PRODUCT_ID_FARBWERK:
1635 priv->kind = farbwerk;
1639 priv->num_temp_sensors = FARBWERK_NUM_SENSORS;
1640 priv->temp_sensor_start_offset = FARBWERK_SENSOR_START;
1642 priv->temp_label = label_temp_sensors;
1644 case USB_PRODUCT_ID_FARBWERK360:
1645 priv->kind = farbwerk360;
1649 priv->num_temp_sensors = FARBWERK360_NUM_SENSORS;
1650 priv->temp_sensor_start_offset = FARBWERK360_SENSOR_START;
1651 priv->num_virtual_temp_sensors = FARBWERK360_NUM_VIRTUAL_SENSORS;
1652 priv->virtual_temp_sensor_start_offset = FARBWERK360_VIRTUAL_SENSORS_START;
1653 priv->temp_ctrl_offset = FARBWERK360_TEMP_CTRL_OFFSET;
1655 priv->buffer_size = FARBWERK360_CTRL_REPORT_SIZE;
1657 priv->temp_label = label_temp_sensors;
1658 priv->virtual_temp_label = label_virtual_temp_sensors;
1660 case USB_PRODUCT_ID_OCTO:
1663 priv->num_fans = OCTO_NUM_FANS;
1664 priv->fan_sensor_offsets = octo_sensor_fan_offsets;
1665 priv->fan_ctrl_offsets = octo_ctrl_fan_offsets;
1667 priv->num_temp_sensors = OCTO_NUM_SENSORS;
1668 priv->temp_sensor_start_offset = OCTO_SENSOR_START;
1669 priv->num_virtual_temp_sensors = OCTO_NUM_VIRTUAL_SENSORS;
1670 priv->virtual_temp_sensor_start_offset = OCTO_VIRTUAL_SENSORS_START;
1671 priv->temp_ctrl_offset = OCTO_TEMP_CTRL_OFFSET;
1673 priv->buffer_size = OCTO_CTRL_REPORT_SIZE;
1674 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1676 priv->power_cycle_count_offset = OCTO_POWER_CYCLES;
1678 priv->temp_label = label_temp_sensors;
1679 priv->virtual_temp_label = label_virtual_temp_sensors;
1680 priv->speed_label = label_fan_speed;
1681 priv->power_label = label_fan_power;
1682 priv->voltage_label = label_fan_voltage;
1683 priv->current_label = label_fan_current;
1685 case USB_PRODUCT_ID_QUADRO:
1686 priv->kind = quadro;
1688 priv->num_fans = QUADRO_NUM_FANS;
1689 priv->fan_sensor_offsets = quadro_sensor_fan_offsets;
1690 priv->fan_ctrl_offsets = quadro_ctrl_fan_offsets;
1692 priv->num_temp_sensors = QUADRO_NUM_SENSORS;
1693 priv->temp_sensor_start_offset = QUADRO_SENSOR_START;
1694 priv->num_virtual_temp_sensors = QUADRO_NUM_VIRTUAL_SENSORS;
1695 priv->virtual_temp_sensor_start_offset = QUADRO_VIRTUAL_SENSORS_START;
1696 priv->num_flow_sensors = QUADRO_NUM_FLOW_SENSORS;
1697 priv->flow_sensors_start_offset = QUADRO_FLOW_SENSOR_OFFSET;
1699 priv->temp_ctrl_offset = QUADRO_TEMP_CTRL_OFFSET;
1701 priv->buffer_size = QUADRO_CTRL_REPORT_SIZE;
1702 priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1704 priv->flow_pulses_ctrl_offset = QUADRO_FLOW_PULSES_CTRL_OFFSET;
1705 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;
1707 priv->temp_label = label_temp_sensors;
1708 priv->virtual_temp_label = label_virtual_temp_sensors;
1709 priv->speed_label = label_quadro_speeds;
1710 priv->power_label = label_fan_power;
1711 priv->voltage_label = label_fan_voltage;
1712 priv->current_label = label_fan_current;
1714 case USB_PRODUCT_ID_HIGHFLOWNEXT:
1715 priv->kind = highflownext;
1719 priv->num_temp_sensors = HIGHFLOWNEXT_NUM_SENSORS;
1720 priv->temp_sensor_start_offset = HIGHFLOWNEXT_SENSOR_START;
1721 priv->num_flow_sensors = HIGHFLOWNEXT_NUM_FLOW_SENSORS;
1722 priv->flow_sensors_start_offset = HIGHFLOWNEXT_FLOW;
1724 priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;
1726 priv->temp_label = label_highflownext_temp_sensors;
1727 priv->speed_label = label_highflownext_fan_speed;
1728 priv->power_label = label_highflownext_power;
1729 priv->voltage_label = label_highflownext_voltage;
1731 case USB_PRODUCT_ID_LEAKSHIELD:
1733 * Choose the right Leakshield device, because
1734 * the other one acts as a keyboard
1736 if (hdev->type != 2) {
1738 goto fail_and_close;
1741 priv->kind = leakshield;
1744 priv->num_temp_sensors = LEAKSHIELD_NUM_SENSORS;
1745 priv->temp_sensor_start_offset = LEAKSHIELD_TEMPERATURE_1;
1747 priv->temp_label = label_leakshield_temp_sensors;
1748 priv->speed_label = label_leakshield_fan_speed;
1750 case USB_PRODUCT_ID_AQUASTREAMXT:
1751 priv->kind = aquastreamxt;
1753 priv->num_fans = AQUASTREAMXT_NUM_FANS;
1754 priv->fan_sensor_offsets = aquastreamxt_sensor_fan_offsets;
1756 priv->num_temp_sensors = AQUASTREAMXT_NUM_SENSORS;
1757 priv->temp_sensor_start_offset = AQUASTREAMXT_SENSOR_START;
1758 priv->buffer_size = AQUASTREAMXT_SENSOR_REPORT_SIZE;
1760 priv->temp_label = label_aquastreamxt_temp_sensors;
1761 priv->speed_label = label_d5next_speeds;
1762 priv->voltage_label = label_d5next_voltages;
1763 priv->current_label = label_d5next_current;
1765 case USB_PRODUCT_ID_AQUASTREAMULT:
1766 priv->kind = aquastreamult;
1768 priv->num_fans = AQUASTREAMULT_NUM_FANS;
1769 priv->fan_sensor_offsets = aquastreamult_sensor_fan_offsets;
1771 priv->num_temp_sensors = AQUASTREAMULT_NUM_SENSORS;
1772 priv->temp_sensor_start_offset = AQUASTREAMULT_SENSOR_START;
1774 priv->temp_label = label_aquastreamult_temp;
1775 priv->speed_label = label_aquastreamult_speeds;
1776 priv->power_label = label_aquastreamult_power;
1777 priv->voltage_label = label_aquastreamult_voltages;
1778 priv->current_label = label_aquastreamult_current;
1780 case USB_PRODUCT_ID_POWERADJUST3:
1781 priv->kind = poweradjust3;
1785 priv->num_temp_sensors = POWERADJUST3_NUM_SENSORS;
1786 priv->temp_sensor_start_offset = POWERADJUST3_SENSOR_START;
1787 priv->buffer_size = POWERADJUST3_SENSOR_REPORT_SIZE;
1789 priv->temp_label = label_poweradjust3_temp_sensors;
1791 case USB_PRODUCT_ID_HIGHFLOW:
1792 priv->kind = highflow;
1796 priv->num_temp_sensors = HIGHFLOW_NUM_SENSORS;
1797 priv->temp_sensor_start_offset = HIGHFLOW_SENSOR_START;
1798 priv->num_flow_sensors = HIGHFLOW_NUM_FLOW_SENSORS;
1799 priv->flow_sensors_start_offset = HIGHFLOW_FLOW_SENSOR_OFFSET;
1800 priv->buffer_size = HIGHFLOW_SENSOR_REPORT_SIZE;
1802 priv->temp_label = label_highflow_temp;
1803 priv->speed_label = label_highflow_speeds;
1809 switch (priv->kind) {
1811 priv->serial_number_start_offset = AQUAERO_SERIAL_START;
1812 priv->firmware_version_offset = AQUAERO_FIRMWARE_VERSION;
1814 priv->fan_structure = &aqc_aquaero_fan_structure;
1816 priv->ctrl_report_id = AQUAERO_CTRL_REPORT_ID;
1817 priv->secondary_ctrl_report_id = AQUAERO_SECONDARY_CTRL_REPORT_ID;
1818 priv->secondary_ctrl_report_size = AQUAERO_SECONDARY_CTRL_REPORT_SIZE;
1819 priv->secondary_ctrl_report = aquaero_secondary_ctrl_report;
1822 priv->status_report_id = POWERADJUST3_STATUS_REPORT_ID;
1825 priv->serial_number_start_offset = AQUASTREAMXT_SERIAL_START;
1826 priv->firmware_version_offset = AQUASTREAMXT_FIRMWARE_VERSION;
1828 priv->status_report_id = AQUASTREAMXT_STATUS_REPORT_ID;
1831 priv->serial_number_start_offset = HIGHFLOW_SERIAL_START;
1832 priv->firmware_version_offset = HIGHFLOW_FIRMWARE_VERSION;
1834 priv->status_report_id = HIGHFLOW_STATUS_REPORT_ID;
1837 priv->serial_number_start_offset = AQC_SERIAL_START;
1838 priv->firmware_version_offset = AQC_FIRMWARE_VERSION;
1840 priv->ctrl_report_id = CTRL_REPORT_ID;
1841 priv->secondary_ctrl_report_id = SECONDARY_CTRL_REPORT_ID;
1842 priv->secondary_ctrl_report_size = SECONDARY_CTRL_REPORT_SIZE;
1843 priv->secondary_ctrl_report = secondary_ctrl_report;
1845 if (priv->kind == aquastreamult)
1846 priv->fan_structure = &aqc_aquastreamult_fan_structure;
1848 priv->fan_structure = &aqc_general_fan_structure;
1852 if (priv->buffer_size != 0) {
1853 priv->checksum_start = 0x01;
1854 priv->checksum_length = priv->buffer_size - 3;
1855 priv->checksum_offset = priv->buffer_size - 2;
1858 priv->name = aqc_device_names[priv->kind];
1860 priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL);
1861 if (!priv->buffer) {
1863 goto fail_and_close;
1866 mutex_init(&priv->mutex);
1868 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv,
1869 &aqc_chip_info, NULL);
1871 if (IS_ERR(priv->hwmon_dev)) {
1872 ret = PTR_ERR(priv->hwmon_dev);
1873 goto fail_and_close;
1876 aqc_debugfs_init(priv);
1887 static void aqc_remove(struct hid_device *hdev)
1889 struct aqc_data *priv = hid_get_drvdata(hdev);
1891 debugfs_remove_recursive(priv->debugfs);
1892 hwmon_device_unregister(priv->hwmon_dev);
1898 static const struct hid_device_id aqc_table[] = {
1899 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUAERO) },
1900 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) },
1901 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) },
1902 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) },
1903 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) },
1904 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_QUADRO) },
1905 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOWNEXT) },
1906 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_LEAKSHIELD) },
1907 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMXT) },
1908 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMULT) },
1909 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_POWERADJUST3) },
1910 { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOW) },
1914 MODULE_DEVICE_TABLE(hid, aqc_table);
1916 static struct hid_driver aqc_driver = {
1917 .name = DRIVER_NAME,
1918 .id_table = aqc_table,
1920 .remove = aqc_remove,
1921 .raw_event = aqc_raw_event,
1924 static int __init aqc_init(void)
1926 return hid_register_driver(&aqc_driver);
1929 static void __exit aqc_exit(void)
1931 hid_unregister_driver(&aqc_driver);
1934 /* Request to initialize after the HID bus to ensure it's not being loaded before */
1935 late_initcall(aqc_init);
1936 module_exit(aqc_exit);
1938 MODULE_LICENSE("GPL");
1939 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
1940 MODULE_AUTHOR("Jack Doan <me@jackdoan.com>");
1941 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices");