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