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