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