aquacomputer_d5next.c 53.9 KB
Newer Older
1 2
// SPDX-License-Identifier: GPL-2.0+
/*
3
 * hwmon driver for Aquacomputer devices (D5 Next, Farbwerk, Farbwerk 360, Octo,
4 5
 * Quadro, High Flow Next, Aquaero, Aquastream Ultimate, Leakshield,
 * 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 19 20
#include <linux/hid.h>
#include <linux/hwmon.h>
#include <linux/jiffies.h>
21
#include <linux/ktime.h>
22
#include <linux/module.h>
23
#include <linux/mutex.h>
24
#include <linux/seq_file.h>
25
#include <asm/unaligned.h>
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 32
#define USB_PRODUCT_ID_D5NEXT		0xf00e
#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 42
enum kinds {
	d5next, farbwerk, farbwerk360, octo, quadro,
43
	highflownext, aquaero, poweradjust3, aquastreamult,
44
	aquastreamxt, leakshield, highflow
45
};
46

47 48
static const char *const aqc_device_names[] = {
	[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 59
	[poweradjust3] = "poweradjust3",
	[highflow] = "highflow" /* Covers MPS Flow devices */
60
};
61

62 63 64 65
#define DRIVER_NAME			"aquacomputer_d5next"

#define STATUS_REPORT_ID		0x01
#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 72
#define CTRL_REPORT_DELAY		200	/* ms */

73 74 75 76 77 78 79 80 81 82
/* The HID report that the official software always sends
 * after writing values, currently same for all devices
 */
#define SECONDARY_CTRL_REPORT_ID	0x02
#define SECONDARY_CTRL_REPORT_SIZE	0x0B

static u8 secondary_ctrl_report[] = {
	0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x34, 0xC6
};

83 84 85 86 87 88 89 90
/* Secondary HID report values for Aquaero */
#define AQUAERO_SECONDARY_CTRL_REPORT_ID	0x06
#define AQUAERO_SECONDARY_CTRL_REPORT_SIZE	0x07

static u8 aquaero_secondary_ctrl_report[] = {
	0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00
};

91
/* Report IDs for legacy devices */
92 93
#define AQUASTREAMXT_STATUS_REPORT_ID	0x04

94 95
#define POWERADJUST3_STATUS_REPORT_ID	0x03

96 97
#define HIGHFLOW_STATUS_REPORT_ID	0x02

98 99 100 101
/* Data types for reading and writing control reports */
#define AQC_8		0
#define AQC_BE16	1

102
/* Info, sensor sizes and offsets for most Aquacomputer devices */
103 104 105
#define AQC_SERIAL_START		0x3
#define AQC_FIRMWARE_VERSION		0xD

106
#define AQC_SENSOR_SIZE			0x02
107
#define AQC_SENSOR_NA			0x7FFF
108 109 110 111 112
#define AQC_FAN_PERCENT_OFFSET		0x00
#define AQC_FAN_VOLTAGE_OFFSET		0x02
#define AQC_FAN_CURRENT_OFFSET		0x04
#define AQC_FAN_POWER_OFFSET		0x06
#define AQC_FAN_SPEED_OFFSET		0x08
113

114 115 116 117 118 119
/* Specs of the Aquaero fan controllers */
#define AQUAERO_SERIAL_START			0x07
#define AQUAERO_FIRMWARE_VERSION		0x0B
#define AQUAERO_NUM_FANS			4
#define AQUAERO_NUM_SENSORS			8
#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 124 125
#define AQUAERO_CTRL_PRESET_ID			0x5c
#define AQUAERO_CTRL_PRESET_SIZE		0x02
#define AQUAERO_CTRL_PRESET_START		0x55c
126 127 128 129

/* Sensor report offsets for Aquaero fan controllers */
#define AQUAERO_SENSOR_START			0x65
#define AQUAERO_VIRTUAL_SENSOR_START		0x85
130
#define AQUAERO_CALC_VIRTUAL_SENSOR_START	0x95
131 132 133 134 135 136 137
#define AQUAERO_FLOW_SENSORS_START		0xF9
#define AQUAERO_FAN_VOLTAGE_OFFSET		0x04
#define AQUAERO_FAN_CURRENT_OFFSET		0x06
#define AQUAERO_FAN_POWER_OFFSET		0x08
#define AQUAERO_FAN_SPEED_OFFSET		0x00
static u16 aquaero_sensor_fan_offsets[] = { 0x167, 0x173, 0x17f, 0x18B };

138 139
/* Control report offsets for the Aquaero fan controllers */
#define AQUAERO_TEMP_CTRL_OFFSET	0xdb
140 141 142 143
#define AQUAERO_FAN_CTRL_MIN_PWR_OFFSET	0x04
#define AQUAERO_FAN_CTRL_MAX_PWR_OFFSET	0x06
#define AQUAERO_FAN_CTRL_SRC_OFFSET	0x10
static u16 aquaero_ctrl_fan_offsets[] = { 0x20c, 0x220, 0x234, 0x248 };
144

145
/* Specs of the D5 Next pump */
146 147
#define D5NEXT_NUM_FANS			2
#define D5NEXT_NUM_SENSORS		1
148
#define D5NEXT_NUM_VIRTUAL_SENSORS	8
149 150 151 152 153
#define D5NEXT_CTRL_REPORT_SIZE		0x329

/* Sensor report offsets for the D5 Next pump */
#define D5NEXT_POWER_CYCLES		0x18
#define D5NEXT_COOLANT_TEMP		0x57
154 155 156
#define D5NEXT_PUMP_OFFSET		0x6c
#define D5NEXT_FAN_OFFSET		0x5f
#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 162 163
/* Control report offsets for the D5 Next pump */
#define D5NEXT_TEMP_CTRL_OFFSET		0x2D	/* Temperature sensor offsets location */
static u16 d5next_ctrl_fan_offsets[] = { 0x97, 0x42 };	/* Pump and fan speed (from 0-100%) */
164

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
/* Specs of the Aquastream Ultimate pump */
/* Pump does not follow the standard structure, so only consider the fan */
#define AQUASTREAMULT_NUM_FANS		1
#define AQUASTREAMULT_NUM_SENSORS	2

/* Sensor report offsets for the Aquastream Ultimate pump */
#define AQUASTREAMULT_SENSOR_START		0x2D
#define AQUASTREAMULT_PUMP_OFFSET		0x51
#define AQUASTREAMULT_PUMP_VOLTAGE		0x3D
#define AQUASTREAMULT_PUMP_CURRENT		0x53
#define AQUASTREAMULT_PUMP_POWER		0x55
#define AQUASTREAMULT_FAN_OFFSET		0x41
#define AQUASTREAMULT_PRESSURE_OFFSET		0x57
#define AQUASTREAMULT_FLOW_SENSOR_OFFSET	0x37
#define AQUASTREAMULT_FAN_VOLTAGE_OFFSET	0x02
#define AQUASTREAMULT_FAN_CURRENT_OFFSET	0x00
#define AQUASTREAMULT_FAN_POWER_OFFSET		0x04
#define AQUASTREAMULT_FAN_SPEED_OFFSET		0x06
static u16 aquastreamult_sensor_fan_offsets[] = { AQUASTREAMULT_FAN_OFFSET };

185
/* Spec and sensor report offset for the Farbwerk RGB controller */
186 187 188
#define FARBWERK_NUM_SENSORS		4
#define FARBWERK_SENSOR_START		0x2f

189
/* Specs of the Farbwerk 360 RGB controller */
190 191
#define FARBWERK360_NUM_SENSORS			4
#define FARBWERK360_NUM_VIRTUAL_SENSORS		16
192
#define FARBWERK360_CTRL_REPORT_SIZE		0x682
193 194 195 196 197 198

/* Sensor report offsets for the Farbwerk 360 */
#define FARBWERK360_SENSOR_START		0x32
#define FARBWERK360_VIRTUAL_SENSORS_START	0x3a

/* Control report offsets for the Farbwerk 360 */
199
#define FARBWERK360_TEMP_CTRL_OFFSET		0x8
200

201
/* Specs of the Octo fan controller */
202 203
#define OCTO_NUM_FANS			8
#define OCTO_NUM_SENSORS		4
204
#define OCTO_NUM_VIRTUAL_SENSORS	16
205
#define OCTO_CTRL_REPORT_SIZE		0x65F
206 207 208 209 210

/* Sensor report offsets for the Octo */
#define OCTO_POWER_CYCLES		0x18
#define OCTO_SENSOR_START		0x3D
#define OCTO_VIRTUAL_SENSORS_START	0x45
211
static u16 octo_sensor_fan_offsets[] = { 0x7D, 0x8A, 0x97, 0xA4, 0xB1, 0xBE, 0xCB, 0xD8 };
212

213 214 215
/* Control report offsets for the Octo */
#define OCTO_TEMP_CTRL_OFFSET		0xA
/* Fan speed offsets (0-100%) */
216 217
static u16 octo_ctrl_fan_offsets[] = { 0x5B, 0xB0, 0x105, 0x15A, 0x1AF, 0x204, 0x259, 0x2AE };

218
/* Specs of Quadro fan controller */
219 220
#define QUADRO_NUM_FANS			4
#define QUADRO_NUM_SENSORS		4
221
#define QUADRO_NUM_VIRTUAL_SENSORS	16
222
#define QUADRO_NUM_FLOW_SENSORS		1
223
#define QUADRO_CTRL_REPORT_SIZE		0x3c1
224 225 226 227 228

/* Sensor report offsets for the Quadro */
#define QUADRO_POWER_CYCLES		0x18
#define QUADRO_SENSOR_START		0x34
#define QUADRO_VIRTUAL_SENSORS_START	0x3c
229
#define QUADRO_FLOW_SENSOR_OFFSET	0x6e
230
static u16 quadro_sensor_fan_offsets[] = { 0x70, 0x7D, 0x8A, 0x97 };
231

232 233
/* Control report offsets for the Quadro */
#define QUADRO_TEMP_CTRL_OFFSET		0xA
234
#define QUADRO_FLOW_PULSES_CTRL_OFFSET	0x6
235
static u16 quadro_ctrl_fan_offsets[] = { 0x37, 0x8c, 0xe1, 0x136 }; /* Fan speed offsets (0-100%) */
236

237
/* Specs of High Flow Next flow sensor */
238
#define HIGHFLOWNEXT_NUM_SENSORS	2
239
#define HIGHFLOWNEXT_NUM_FLOW_SENSORS	1
240 241

/* Sensor report offsets for the High Flow Next */
242 243 244 245 246 247 248 249
#define HIGHFLOWNEXT_SENSOR_START	85
#define HIGHFLOWNEXT_FLOW		81
#define HIGHFLOWNEXT_WATER_QUALITY	89
#define HIGHFLOWNEXT_POWER		91
#define HIGHFLOWNEXT_CONDUCTIVITY	95
#define HIGHFLOWNEXT_5V_VOLTAGE		97
#define HIGHFLOWNEXT_5V_VOLTAGE_USB	99

250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
/* Specs of the Leakshield */
#define LEAKSHIELD_NUM_SENSORS		2

/* Sensor report offsets for Leakshield */
#define LEAKSHIELD_PRESSURE_ADJUSTED	285
#define LEAKSHIELD_TEMPERATURE_1	265
#define LEAKSHIELD_TEMPERATURE_2	287
#define LEAKSHIELD_PRESSURE_MIN		291
#define LEAKSHIELD_PRESSURE_TARGET	293
#define LEAKSHIELD_PRESSURE_MAX		295
#define LEAKSHIELD_PUMP_RPM_IN		101
#define LEAKSHIELD_FLOW_IN		111
#define LEAKSHIELD_RESERVOIR_VOLUME	313
#define LEAKSHIELD_RESERVOIR_FILLED	311

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
/* Specs of the Aquastream XT pump */
#define AQUASTREAMXT_SERIAL_START		0x3a
#define AQUASTREAMXT_FIRMWARE_VERSION		0x32
#define AQUASTREAMXT_NUM_FANS			2
#define AQUASTREAMXT_NUM_SENSORS		3
#define AQUASTREAMXT_FAN_STOPPED		0x4
#define AQUASTREAMXT_PUMP_CONVERSION_CONST	45000000
#define AQUASTREAMXT_FAN_CONVERSION_CONST	5646000
#define AQUASTREAMXT_SENSOR_REPORT_SIZE		0x42

/* Sensor report offsets and info for Aquastream XT */
#define AQUASTREAMXT_SENSOR_START		0xd
#define AQUASTREAMXT_FAN_VOLTAGE_OFFSET		0x7
#define AQUASTREAMXT_FAN_STATUS_OFFSET		0x1d
#define AQUASTREAMXT_PUMP_VOLTAGE_OFFSET	0x9
#define AQUASTREAMXT_PUMP_CURR_OFFSET		0xb
static u16 aquastreamxt_sensor_fan_offsets[] = { 0x13, 0x1b };

283 284 285 286 287 288 289
/* Specs of the Poweradjust 3 */
#define POWERADJUST3_NUM_SENSORS	1
#define POWERADJUST3_SENSOR_REPORT_SIZE	0x32

/* Sensor report offsets for the Poweradjust 3 */
#define POWERADJUST3_SENSOR_START	0x03

290 291 292 293 294 295 296 297 298 299 300
/* Specs of the High Flow USB */
#define HIGHFLOW_NUM_SENSORS		2
#define HIGHFLOW_NUM_FLOW_SENSORS	1
#define HIGHFLOW_SENSOR_REPORT_SIZE	0x76

/* Sensor report offsets for the High Flow USB */
#define HIGHFLOW_FIRMWARE_VERSION	0x3
#define HIGHFLOW_SERIAL_START		0x9
#define HIGHFLOW_FLOW_SENSOR_OFFSET	0x23
#define HIGHFLOW_SENSOR_START		0x2b

301
/* Labels for D5 Next */
302 303 304
static const char *const label_d5next_temp[] = {
	"Coolant temp"
};
305

306 307 308 309
static const char *const label_d5next_speeds[] = {
	"Pump speed",
	"Fan speed"
};
310

311 312 313
static const char *const label_d5next_power[] = {
	"Pump power",
	"Fan power"
314 315
};

316 317 318
static const char *const label_d5next_voltages[] = {
	"Pump voltage",
	"Fan voltage",
319 320
	"+5V voltage",
	"+12V voltage"
321 322
};

323 324 325
static const char *const label_d5next_current[] = {
	"Pump current",
	"Fan current"
326 327
};

328
/* Labels for Aquaero, Farbwerk, Farbwerk 360 and Octo and Quadro temperature sensors */
329 330 331 332
static const char *const label_temp_sensors[] = {
	"Sensor 1",
	"Sensor 2",
	"Sensor 3",
333 334 335 336 337
	"Sensor 4",
	"Sensor 5",
	"Sensor 6",
	"Sensor 7",
	"Sensor 8"
338 339
};

340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358
static const char *const label_virtual_temp_sensors[] = {
	"Virtual sensor 1",
	"Virtual sensor 2",
	"Virtual sensor 3",
	"Virtual sensor 4",
	"Virtual sensor 5",
	"Virtual sensor 6",
	"Virtual sensor 7",
	"Virtual sensor 8",
	"Virtual sensor 9",
	"Virtual sensor 10",
	"Virtual sensor 11",
	"Virtual sensor 12",
	"Virtual sensor 13",
	"Virtual sensor 14",
	"Virtual sensor 15",
	"Virtual sensor 16",
};

359 360 361 362 363 364 365
static const char *const label_aquaero_calc_temp_sensors[] = {
	"Calc. virtual sensor 1",
	"Calc. virtual sensor 2",
	"Calc. virtual sensor 3",
	"Calc. virtual sensor 4"
};

366
/* Labels for Octo and Quadro (except speed) */
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
static const char *const label_fan_speed[] = {
	"Fan 1 speed",
	"Fan 2 speed",
	"Fan 3 speed",
	"Fan 4 speed",
	"Fan 5 speed",
	"Fan 6 speed",
	"Fan 7 speed",
	"Fan 8 speed"
};

static const char *const label_fan_power[] = {
	"Fan 1 power",
	"Fan 2 power",
	"Fan 3 power",
	"Fan 4 power",
	"Fan 5 power",
	"Fan 6 power",
	"Fan 7 power",
	"Fan 8 power"
};

static const char *const label_fan_voltage[] = {
	"Fan 1 voltage",
	"Fan 2 voltage",
	"Fan 3 voltage",
	"Fan 4 voltage",
	"Fan 5 voltage",
	"Fan 6 voltage",
	"Fan 7 voltage",
	"Fan 8 voltage"
};

static const char *const label_fan_current[] = {
	"Fan 1 current",
	"Fan 2 current",
	"Fan 3 current",
	"Fan 4 current",
	"Fan 5 current",
	"Fan 6 current",
	"Fan 7 current",
	"Fan 8 current"
};

411 412 413 414 415 416 417 418 419
/* Labels for Quadro fan speeds */
static const char *const label_quadro_speeds[] = {
	"Fan 1 speed",
	"Fan 2 speed",
	"Fan 3 speed",
	"Fan 4 speed",
	"Flow speed [dL/h]"
};

420 421 422 423 424 425 426 427 428 429
/* Labels for Aquaero fan speeds */
static const char *const label_aquaero_speeds[] = {
	"Fan 1 speed",
	"Fan 2 speed",
	"Fan 3 speed",
	"Fan 4 speed",
	"Flow sensor 1 [dL/h]",
	"Flow sensor 2 [dL/h]"
};

430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
/* Labels for High Flow Next */
static const char *const label_highflownext_temp_sensors[] = {
	"Coolant temp",
	"External sensor"
};

static const char *const label_highflownext_fan_speed[] = {
	"Flow [dL/h]",
	"Water quality [%]",
	"Conductivity [nS/cm]",
};

static const char *const label_highflownext_power[] = {
	"Dissipated power",
};

static const char *const label_highflownext_voltage[] = {
	"+5V voltage",
	"+5V USB voltage"
};

451 452 453 454 455 456 457 458 459 460 461 462 463 464
/* Labels for Leakshield */
static const char *const label_leakshield_temp_sensors[] = {
	"Temperature 1",
	"Temperature 2"
};

static const char *const label_leakshield_fan_speed[] = {
	"Pressure [ubar]",
	"User-Provided Pump Speed",
	"User-Provided Flow [dL/h]",
	"Reservoir Volume [ml]",
	"Reservoir Filled [ml]",
};

465 466 467 468 469 470 471
/* Labels for Aquastream XT */
static const char *const label_aquastreamxt_temp_sensors[] = {
	"Fan IC temp",
	"External sensor",
	"Coolant temp"
};

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
/* Labels for Aquastream Ultimate */
static const char *const label_aquastreamult_temp[] = {
	"Coolant temp",
	"External temp"
};

static const char *const label_aquastreamult_speeds[] = {
	"Fan speed",
	"Pump speed",
	"Pressure [mbar]",
	"Flow speed [dL/h]"
};

static const char *const label_aquastreamult_power[] = {
	"Fan power",
	"Pump power"
};

static const char *const label_aquastreamult_voltages[] = {
	"Fan voltage",
	"Pump voltage"
};

static const char *const label_aquastreamult_current[] = {
	"Fan current",
	"Pump current"
};

500 501 502 503 504
/* Labels for Poweradjust 3 */
static const char *const label_poweradjust3_temp_sensors[] = {
	"External sensor"
};

505 506 507 508 509 510 511 512 513 514
/* Labels for Highflow */
static const char *const label_highflow_temp[] = {
	"External temp",
	"Internal temp"
};

static const char *const label_highflow_speeds[] = {
	"Flow speed [dL/h]"
};

515 516 517 518 519 520 521
struct aqc_fan_structure_offsets {
	u8 voltage;
	u8 curr;
	u8 power;
	u8 speed;
};

522 523 524 525 526 527 528 529
/* Fan structure offsets for Aquaero */
static struct aqc_fan_structure_offsets aqc_aquaero_fan_structure = {
	.voltage = AQUAERO_FAN_VOLTAGE_OFFSET,
	.curr = AQUAERO_FAN_CURRENT_OFFSET,
	.power = AQUAERO_FAN_POWER_OFFSET,
	.speed = AQUAERO_FAN_SPEED_OFFSET
};

530 531 532 533 534 535 536 537 538
/* Fan structure offsets for Aquastream Ultimate */
static struct aqc_fan_structure_offsets aqc_aquastreamult_fan_structure = {
	.voltage = AQUASTREAMULT_FAN_VOLTAGE_OFFSET,
	.curr = AQUASTREAMULT_FAN_CURRENT_OFFSET,
	.power = AQUASTREAMULT_FAN_POWER_OFFSET,
	.speed = AQUASTREAMULT_FAN_SPEED_OFFSET
};

/* Fan structure offsets for all devices except those above */
539 540 541 542 543 544 545
static struct aqc_fan_structure_offsets aqc_general_fan_structure = {
	.voltage = AQC_FAN_VOLTAGE_OFFSET,
	.curr = AQC_FAN_CURRENT_OFFSET,
	.power = AQC_FAN_POWER_OFFSET,
	.speed = AQC_FAN_SPEED_OFFSET
};

546
struct aqc_data {
547 548 549
	struct hid_device *hdev;
	struct device *hwmon_dev;
	struct dentry *debugfs;
550
	struct mutex mutex;	/* Used for locking access when reading and writing PWM values */
551 552 553
	enum kinds kind;
	const char *name;

554
	int status_report_id;	/* Used for legacy devices, report is stored in buffer */
555 556 557 558
	int ctrl_report_id;
	int secondary_ctrl_report_id;
	int secondary_ctrl_report_size;
	u8 *secondary_ctrl_report;
559

560 561 562
	ktime_t last_ctrl_report_op;
	int ctrl_report_delay;	/* Delay between two ctrl report operations, in ms */

563 564 565 566 567 568
	int buffer_size;
	u8 *buffer;
	int checksum_start;
	int checksum_length;
	int checksum_offset;

569
	int num_fans;
570
	u16 *fan_sensor_offsets;
571 572 573
	u16 *fan_ctrl_offsets;
	int num_temp_sensors;
	int temp_sensor_start_offset;
574 575
	int num_virtual_temp_sensors;
	int virtual_temp_sensor_start_offset;
576 577
	int num_calc_virt_temp_sensors;
	int calc_virt_temp_sensor_start_offset;
578
	u16 temp_ctrl_offset;
579
	u16 power_cycle_count_offset;
580 581
	int num_flow_sensors;
	u8 flow_sensors_start_offset;
582
	u8 flow_pulses_ctrl_offset;
583
	struct aqc_fan_structure_offsets *fan_structure;
584

585
	/* General info, same across all devices */
586
	u8 serial_number_start_offset;
587
	u32 serial_number[2];
588
	u8 firmware_version_offset;
589 590
	u16 firmware_version;

591
	/* How many times the device was powered on, if available */
592 593 594
	u32 power_cycles;

	/* Sensor values */
595
	s32 temp_input[20];	/* Max 4 physical and 16 virtual or 8 physical and 12 virtual */
596 597 598 599
	s32 speed_input[8];
	u32 speed_input_min[1];
	u32 speed_input_target[1];
	u32 speed_input_max[1];
600 601 602 603 604 605
	u32 power_input[8];
	u16 voltage_input[8];
	u16 current_input[8];

	/* Label values */
	const char *const *temp_label;
606
	const char *const *virtual_temp_label;
607
	const char *const *calc_virt_temp_label;	/* For Aquaero */
608 609 610 611
	const char *const *speed_label;
	const char *const *power_label;
	const char *const *voltage_label;
	const char *const *current_label;
612

613 614 615
	unsigned long updated;
};

616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
/* Converts from centi-percent */
static int aqc_percent_to_pwm(u16 val)
{
	return DIV_ROUND_CLOSEST(val * 255, 100 * 100);
}

/* Converts to centi-percent */
static int aqc_pwm_to_percent(long val)
{
	if (val < 0 || val > 255)
		return -EINVAL;

	return DIV_ROUND_CLOSEST(val * 100 * 100, 255);
}

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
/* Converts raw value for Aquastream XT pump speed to RPM */
static int aqc_aquastreamxt_convert_pump_rpm(u16 val)
{
	if (val > 0)
		return DIV_ROUND_CLOSEST(AQUASTREAMXT_PUMP_CONVERSION_CONST, val);
	return 0;
}

/* Converts raw value for Aquastream XT fan speed to RPM */
static int aqc_aquastreamxt_convert_fan_rpm(u16 val)
{
	if (val > 0)
		return DIV_ROUND_CLOSEST(AQUASTREAMXT_FAN_CONVERSION_CONST, val);
	return 0;
}

647 648 649 650 651 652 653 654 655 656 657 658 659 660
static void aqc_delay_ctrl_report(struct aqc_data *priv)
{
	/*
	 * If previous read or write is too close to this one, delay the current operation
	 * to give the device enough time to process the previous one.
	 */
	if (priv->ctrl_report_delay) {
		s64 delta = ktime_ms_delta(ktime_get(), priv->last_ctrl_report_op);

		if (delta < priv->ctrl_report_delay)
			msleep(priv->ctrl_report_delay - delta);
	}
}

661 662 663 664 665
/* Expects the mutex to be locked */
static int aqc_get_ctrl_data(struct aqc_data *priv)
{
	int ret;

666 667
	aqc_delay_ctrl_report(priv);

668
	memset(priv->buffer, 0x00, priv->buffer_size);
669
	ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size,
670 671 672 673
				 HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
	if (ret < 0)
		ret = -ENODATA;

674 675
	priv->last_ctrl_report_op = ktime_get();

676 677 678 679 680 681 682 683 684
	return ret;
}

/* Expects the mutex to be locked */
static int aqc_send_ctrl_data(struct aqc_data *priv)
{
	int ret;
	u16 checksum;

685 686
	aqc_delay_ctrl_report(priv);

687 688 689 690 691 692
	/* Checksum is not needed for Aquaero */
	if (priv->kind != aquaero) {
		/* Init and xorout value for CRC-16/USB is 0xffff */
		checksum = crc16(0xffff, priv->buffer + priv->checksum_start,
				 priv->checksum_length);
		checksum ^= 0xffff;
693

694 695 696
		/* Place the new checksum at the end of the report */
		put_unaligned_be16(checksum, priv->buffer + priv->checksum_offset);
	}
697 698

	/* Send the patched up report back to the device */
699
	ret = hid_hw_raw_request(priv->hdev, priv->ctrl_report_id, priv->buffer, priv->buffer_size,
700 701
				 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
	if (ret < 0)
702
		goto record_access_and_ret;
703 704

	/* The official software sends this report after every change, so do it here as well */
705 706 707
	ret = hid_hw_raw_request(priv->hdev, priv->secondary_ctrl_report_id,
				 priv->secondary_ctrl_report, priv->secondary_ctrl_report_size,
				 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
708 709 710 711

record_access_and_ret:
	priv->last_ctrl_report_op = ktime_get();

712 713 714
	return ret;
}

715
/* Refreshes the control buffer and stores value at offset in val */
716
static int aqc_get_ctrl_val(struct aqc_data *priv, int offset, long *val, int type)
717 718 719 720 721 722 723 724 725
{
	int ret;

	mutex_lock(&priv->mutex);

	ret = aqc_get_ctrl_data(priv);
	if (ret < 0)
		goto unlock_and_return;

726 727 728 729 730 731 732 733 734 735
	switch (type) {
	case AQC_BE16:
		*val = (s16)get_unaligned_be16(priv->buffer + offset);
		break;
	case AQC_8:
		*val = priv->buffer[offset];
		break;
	default:
		ret = -EINVAL;
	}
736 737 738 739 740 741

unlock_and_return:
	mutex_unlock(&priv->mutex);
	return ret;
}

742
static int aqc_set_ctrl_vals(struct aqc_data *priv, int *offsets, long *vals, int *types, int len)
743
{
744
	int ret, i;
745 746 747 748 749 750 751

	mutex_lock(&priv->mutex);

	ret = aqc_get_ctrl_data(priv);
	if (ret < 0)
		goto unlock_and_return;

752 753 754 755 756 757 758 759 760 761 762
	for (i = 0; i < len; i++) {
		switch (types[i]) {
		case AQC_BE16:
			put_unaligned_be16((s16)vals[i], priv->buffer + offsets[i]);
			break;
		case AQC_8:
			priv->buffer[offsets[i]] = (u8)vals[i];
			break;
		default:
			ret = -EINVAL;
		}
763 764 765 766
	}

	if (ret < 0)
		goto unlock_and_return;
767 768 769 770 771 772 773 774

	ret = aqc_send_ctrl_data(priv);

unlock_and_return:
	mutex_unlock(&priv->mutex);
	return ret;
}

775 776 777 778 779
static int aqc_set_ctrl_val(struct aqc_data *priv, int offset, long val, int type)
{
	return aqc_set_ctrl_vals(priv, &offset, &val, &type, 1);
}

780
static umode_t aqc_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel)
781
{
782 783 784 785
	const struct aqc_data *priv = data;

	switch (type) {
	case hwmon_temp:
786 787 788 789 790 791 792 793 794 795 796 797 798 799
		if (channel < priv->num_temp_sensors) {
			switch (attr) {
			case hwmon_temp_label:
			case hwmon_temp_input:
				return 0444;
			case hwmon_temp_offset:
				if (priv->temp_ctrl_offset != 0)
					return 0644;
				break;
			default:
				break;
			}
		}

800 801 802
		if (channel <
		    priv->num_temp_sensors + priv->num_virtual_temp_sensors +
		    priv->num_calc_virt_temp_sensors)
803 804 805 806 807 808 809
			switch (attr) {
			case hwmon_temp_label:
			case hwmon_temp_input:
				return 0444;
			default:
				break;
			}
810
		break;
811
	case hwmon_pwm:
812
		if (priv->fan_ctrl_offsets && channel < priv->num_fans) {
813 814 815 816 817 818 819 820
			switch (attr) {
			case hwmon_pwm_input:
				return 0644;
			default:
				break;
			}
		}
		break;
821
	case hwmon_fan:
822 823 824 825
		switch (attr) {
		case hwmon_fan_input:
		case hwmon_fan_label:
			switch (priv->kind) {
826 827 828 829 830 831 832 833
			case aquastreamult:
				/*
				 * Special case to support pump RPM, fan RPM,
				 * pressure and flow sensor
				 */
				if (channel < 4)
					return 0444;
				break;
834 835 836 837 838 839 840
			case highflownext:
				/* Special case to support flow sensor, water quality
				 * and conductivity
				 */
				if (channel < 3)
					return 0444;
				break;
841 842 843 844 845
			case leakshield:
				/* Special case for Leakshield sensors */
				if (channel < 5)
					return 0444;
				break;
846
			case aquaero:
847
			case quadro:
848
			case highflow:
849 850
				/* Special case to support flow sensors */
				if (channel < priv->num_fans + priv->num_flow_sensors)
851 852 853 854 855 856 857
					return 0444;
				break;
			default:
				if (channel < priv->num_fans)
					return 0444;
				break;
			}
858
			break;
859 860 861 862
		case hwmon_fan_pulses:
			/* Special case for Quadro flow sensor */
			if (priv->kind == quadro && channel == priv->num_fans)
				return 0644;
863
			break;
864 865 866 867 868 869 870
		case hwmon_fan_min:
		case hwmon_fan_max:
		case hwmon_fan_target:
			/* Special case for Leakshield pressure sensor */
			if (priv->kind == leakshield && channel == 0)
				return 0444;
			break;
871 872 873 874
		default:
			break;
		}
		break;
875
	case hwmon_power:
876
		switch (priv->kind) {
877 878 879 880 881
		case aquastreamult:
			/* Special case to support pump and fan power */
			if (channel < 2)
				return 0444;
			break;
882 883 884 885 886
		case highflownext:
			/* Special case to support one power sensor */
			if (channel == 0)
				return 0444;
			break;
887 888
		case aquastreamxt:
			break;
889 890 891 892 893 894
		default:
			if (channel < priv->num_fans)
				return 0444;
			break;
		}
		break;
895
	case hwmon_curr:
896 897 898 899 900 901
		switch (priv->kind) {
		case aquastreamult:
			/* Special case to support pump and fan current */
			if (channel < 2)
				return 0444;
			break;
902 903 904 905 906
		case aquastreamxt:
			/* Special case to support pump current */
			if (channel == 0)
				return 0444;
			break;
907 908 909 910 911
		default:
			if (channel < priv->num_fans)
				return 0444;
			break;
		}
912 913 914 915
		break;
	case hwmon_in:
		switch (priv->kind) {
		case d5next:
916 917
			/* Special case to support +5V and +12V voltage sensors */
			if (channel < priv->num_fans + 2)
918 919
				return 0444;
			break;
920
		case aquastreamult:
921 922 923 924 925
		case highflownext:
			/* Special case to support two voltage sensors */
			if (channel < 2)
				return 0444;
			break;
926
		default:
927 928
			if (channel < priv->num_fans)
				return 0444;
929 930 931 932 933 934 935 936
			break;
		}
		break;
	default:
		break;
	}

	return 0;
937 938
}

939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
/* Read device sensors by manually requesting the sensor report (legacy way) */
static int aqc_legacy_read(struct aqc_data *priv)
{
	int ret, i, sensor_value;

	mutex_lock(&priv->mutex);

	memset(priv->buffer, 0x00, priv->buffer_size);
	ret = hid_hw_raw_request(priv->hdev, priv->status_report_id, priv->buffer,
				 priv->buffer_size, HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
	if (ret < 0)
		goto unlock_and_return;

	/* Temperature sensor readings */
	for (i = 0; i < priv->num_temp_sensors; i++) {
		sensor_value = get_unaligned_le16(priv->buffer + priv->temp_sensor_start_offset +
						  i * AQC_SENSOR_SIZE);
956 957 958 959
		if (sensor_value == AQC_SENSOR_NA)
			priv->temp_input[i] = -ENODATA;
		else
			priv->temp_input[i] = sensor_value * 10;
960 961
	}

962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
	/* Special-case sensor readings */
	switch (priv->kind) {
	case aquastreamxt:
		/* Info provided with every report */
		priv->serial_number[0] = get_unaligned_le16(priv->buffer +
							    priv->serial_number_start_offset);
		priv->firmware_version =
			get_unaligned_le16(priv->buffer + priv->firmware_version_offset);

		/* Read pump speed in RPM */
		sensor_value = get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[0]);
		priv->speed_input[0] = aqc_aquastreamxt_convert_pump_rpm(sensor_value);

		/* Read fan speed in RPM, if available */
		sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_STATUS_OFFSET);
		if (sensor_value == AQUASTREAMXT_FAN_STOPPED) {
			priv->speed_input[1] = 0;
		} else {
			sensor_value =
				get_unaligned_le16(priv->buffer + priv->fan_sensor_offsets[1]);
			priv->speed_input[1] = aqc_aquastreamxt_convert_fan_rpm(sensor_value);
		}

		/* Calculation derived from linear regression */
		sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_CURR_OFFSET);
		priv->current_input[0] = DIV_ROUND_CLOSEST(sensor_value * 176, 100) - 52;

		sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_PUMP_VOLTAGE_OFFSET);
		priv->voltage_input[0] = DIV_ROUND_CLOSEST(sensor_value * 1000, 61);

		sensor_value = get_unaligned_le16(priv->buffer + AQUASTREAMXT_FAN_VOLTAGE_OFFSET);
		priv->voltage_input[1] = DIV_ROUND_CLOSEST(sensor_value * 1000, 63);
		break;
995 996 997 998 999 1000 1001 1002 1003 1004 1005
	case highflow:
		/* Info provided with every report */
		priv->serial_number[0] = get_unaligned_le16(priv->buffer +
							    priv->serial_number_start_offset);
		priv->firmware_version =
		    get_unaligned_le16(priv->buffer + priv->firmware_version_offset);

		/* Read flow speed */
		priv->speed_input[0] = get_unaligned_le16(priv->buffer +
							  priv->flow_sensors_start_offset);
		break;
1006 1007 1008 1009
	default:
		break;
	}

1010 1011 1012 1013 1014 1015 1016
	priv->updated = jiffies;

unlock_and_return:
	mutex_unlock(&priv->mutex);
	return ret;
}

1017 1018
static int aqc_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
		    int channel, long *val)
1019
{
1020
	int ret;
1021
	struct aqc_data *priv = dev_get_drvdata(dev);
1022

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
	if (time_after(jiffies, priv->updated + STATUS_UPDATE_INTERVAL)) {
		if (priv->status_report_id != 0) {
			/* Legacy devices require manual reads */
			ret = aqc_legacy_read(priv);
			if (ret < 0)
				return -ENODATA;
		} else {
			return -ENODATA;
		}
	}
1033 1034 1035

	switch (type) {
	case hwmon_temp:
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
		switch (attr) {
		case hwmon_temp_input:
			if (priv->temp_input[channel] == -ENODATA)
				return -ENODATA;

			*val = priv->temp_input[channel];
			break;
		case hwmon_temp_offset:
			ret =
			    aqc_get_ctrl_val(priv, priv->temp_ctrl_offset +
1046
					     channel * AQC_SENSOR_SIZE, val, AQC_BE16);
1047 1048
			if (ret < 0)
				return ret;
1049

1050 1051 1052 1053 1054
			*val *= 10;
			break;
		default:
			break;
		}
1055 1056
		break;
	case hwmon_fan:
1057 1058
		switch (attr) {
		case hwmon_fan_input:
1059 1060 1061
			if (priv->speed_input[channel] == -ENODATA)
				return -ENODATA;

1062 1063
			*val = priv->speed_input[channel];
			break;
1064 1065 1066 1067 1068 1069 1070 1071 1072
		case hwmon_fan_min:
			*val = priv->speed_input_min[channel];
			break;
		case hwmon_fan_max:
			*val = priv->speed_input_max[channel];
			break;
		case hwmon_fan_target:
			*val = priv->speed_input_target[channel];
			break;
1073
		case hwmon_fan_pulses:
1074 1075
			ret = aqc_get_ctrl_val(priv, priv->flow_pulses_ctrl_offset,
					       val, AQC_BE16);
1076 1077 1078 1079 1080 1081
			if (ret < 0)
				return ret;
			break;
		default:
			break;
		}
1082 1083 1084 1085
		break;
	case hwmon_power:
		*val = priv->power_input[channel];
		break;
1086
	case hwmon_pwm:
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
		switch (priv->kind) {
		case aquaero:
			ret = aqc_get_ctrl_val(priv,
				AQUAERO_CTRL_PRESET_START + channel * AQUAERO_CTRL_PRESET_SIZE,
				val, AQC_BE16);
			if (ret < 0)
				return ret;
			*val = aqc_percent_to_pwm(*val);
			break;
		default:
1097 1098
			ret = aqc_get_ctrl_val(priv, priv->fan_ctrl_offsets[channel],
					       val, AQC_BE16);
1099 1100 1101
			if (ret < 0)
				return ret;

1102
			*val = aqc_percent_to_pwm(*val);
1103
			break;
1104 1105
		}
		break;
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	case hwmon_in:
		*val = priv->voltage_input[channel];
		break;
	case hwmon_curr:
		*val = priv->current_input[channel];
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

1119 1120
static int aqc_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
			   int channel, const char **str)
1121
{
1122 1123
	struct aqc_data *priv = dev_get_drvdata(dev);

1124 1125 1126
	/* Number of sensors that are not calculated */
	int num_non_calc_sensors = priv->num_temp_sensors + priv->num_virtual_temp_sensors;

1127 1128
	switch (type) {
	case hwmon_temp:
1129
		if (channel < priv->num_temp_sensors) {
1130
			*str = priv->temp_label[channel];
1131 1132 1133 1134 1135 1136 1137
		} else {
			if (priv->kind == aquaero && channel >= num_non_calc_sensors)
				*str =
				    priv->calc_virt_temp_label[channel - num_non_calc_sensors];
			else
				*str = priv->virtual_temp_label[channel - priv->num_temp_sensors];
		}
1138 1139
		break;
	case hwmon_fan:
1140
		*str = priv->speed_label[channel];
1141 1142
		break;
	case hwmon_power:
1143
		*str = priv->power_label[channel];
1144 1145
		break;
	case hwmon_in:
1146
		*str = priv->voltage_label[channel];
1147 1148
		break;
	case hwmon_curr:
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
		*str = priv->current_label[channel];
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

static int aqc_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
		     long val)
{
	int ret, pwm_value;
1162 1163 1164 1165
	/* Arrays for setting multiple values at once in the control report */
	int ctrl_values_offsets[4];
	long ctrl_values[4];
	int ctrl_values_types[4];
1166 1167 1168
	struct aqc_data *priv = dev_get_drvdata(dev);

	switch (type) {
1169 1170 1171 1172 1173 1174 1175
	case hwmon_temp:
		switch (attr) {
		case hwmon_temp_offset:
			/* Limit temp offset to +/- 15K as in the official software */
			val = clamp_val(val, -15000, 15000) / 10;
			ret =
			    aqc_set_ctrl_val(priv, priv->temp_ctrl_offset +
1176
					     channel * AQC_SENSOR_SIZE, val, AQC_BE16);
1177 1178 1179 1180 1181 1182 1183
			if (ret < 0)
				return ret;
			break;
		default:
			return -EOPNOTSUPP;
		}
		break;
1184 1185 1186 1187
	case hwmon_fan:
		switch (attr) {
		case hwmon_fan_pulses:
			val = clamp_val(val, 10, 1000);
1188 1189
			ret = aqc_set_ctrl_val(priv, priv->flow_pulses_ctrl_offset,
					       val, AQC_BE16);
1190 1191 1192 1193 1194 1195 1196
			if (ret < 0)
				return ret;
			break;
		default:
			break;
		}
		break;
1197 1198 1199
	case hwmon_pwm:
		switch (attr) {
		case hwmon_pwm_input:
1200 1201 1202
			pwm_value = aqc_pwm_to_percent(val);
			if (pwm_value < 0)
				return pwm_value;
1203

1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
			switch (priv->kind) {
			case aquaero:
				/* Write pwm value to preset corresponding to the channel */
				ctrl_values_offsets[0] = AQUAERO_CTRL_PRESET_START +
				    channel * AQUAERO_CTRL_PRESET_SIZE;
				ctrl_values[0] = pwm_value;
				ctrl_values_types[0] = AQC_BE16;

				/* Write preset number in fan control source */
				ctrl_values_offsets[1] = priv->fan_ctrl_offsets[channel] +
				    AQUAERO_FAN_CTRL_SRC_OFFSET;
				ctrl_values[1] = AQUAERO_CTRL_PRESET_ID + channel;
				ctrl_values_types[1] = AQC_BE16;

				/* Set minimum power to 0 to allow the fan to turn off */
				ctrl_values_offsets[2] = priv->fan_ctrl_offsets[channel] +
				    AQUAERO_FAN_CTRL_MIN_PWR_OFFSET;
				ctrl_values[2] = 0;
				ctrl_values_types[2] = AQC_BE16;

				/* Set maximum power to 255 to allow the fan to reach max speed */
				ctrl_values_offsets[3] = priv->fan_ctrl_offsets[channel] +
				    AQUAERO_FAN_CTRL_MAX_PWR_OFFSET;
				ctrl_values[3] = aqc_pwm_to_percent(255);
				ctrl_values_types[3] = AQC_BE16;

				ret = aqc_set_ctrl_vals(priv, ctrl_values_offsets, ctrl_values,
							ctrl_values_types, 4);
				if (ret < 0)
					return ret;
				break;
			default:
1236
				ret = aqc_set_ctrl_val(priv, priv->fan_ctrl_offsets[channel],
1237
						       pwm_value, AQC_BE16);
1238 1239
				if (ret < 0)
					return ret;
1240
				break;
1241
			}
1242 1243 1244 1245
			break;
		default:
			break;
		}
1246 1247 1248 1249 1250 1251 1252 1253
		break;
	default:
		return -EOPNOTSUPP;
	}

	return 0;
}

1254 1255 1256 1257
static const struct hwmon_ops aqc_hwmon_ops = {
	.is_visible = aqc_is_visible,
	.read = aqc_read,
	.read_string = aqc_read_string,
1258
	.write = aqc_write
1259 1260
};

1261
static const struct hwmon_channel_info * const aqc_info[] = {
1262
	HWMON_CHANNEL_INFO(temp,
1263 1264 1265 1266
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1267 1268 1269 1270
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
			   HWMON_T_INPUT | HWMON_T_LABEL | HWMON_T_OFFSET,
1271 1272 1273 1274 1275 1276 1277 1278
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
1279 1280 1281 1282 1283
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL,
			   HWMON_T_INPUT | HWMON_T_LABEL),
	HWMON_CHANNEL_INFO(fan,
1284 1285
			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_MIN | HWMON_F_MAX |
			   HWMON_F_TARGET,
1286 1287 1288
			   HWMON_F_INPUT | HWMON_F_LABEL,
			   HWMON_F_INPUT | HWMON_F_LABEL,
			   HWMON_F_INPUT | HWMON_F_LABEL,
1289
			   HWMON_F_INPUT | HWMON_F_LABEL | HWMON_F_PULSES,
1290
			   HWMON_F_INPUT | HWMON_F_LABEL,
1291 1292 1293
			   HWMON_F_INPUT | HWMON_F_LABEL,
			   HWMON_F_INPUT | HWMON_F_LABEL),
	HWMON_CHANNEL_INFO(power,
1294 1295 1296 1297 1298 1299
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL,
1300 1301
			   HWMON_P_INPUT | HWMON_P_LABEL,
			   HWMON_P_INPUT | HWMON_P_LABEL),
1302 1303 1304 1305 1306 1307 1308 1309 1310
	HWMON_CHANNEL_INFO(pwm,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT,
			   HWMON_PWM_INPUT),
1311
	HWMON_CHANNEL_INFO(in,
1312 1313 1314 1315 1316
			   HWMON_I_INPUT | HWMON_I_LABEL,
			   HWMON_I_INPUT | HWMON_I_LABEL,
			   HWMON_I_INPUT | HWMON_I_LABEL,
			   HWMON_I_INPUT | HWMON_I_LABEL,
			   HWMON_I_INPUT | HWMON_I_LABEL,
1317 1318
			   HWMON_I_INPUT | HWMON_I_LABEL,
			   HWMON_I_INPUT | HWMON_I_LABEL,
1319
			   HWMON_I_INPUT | HWMON_I_LABEL),
1320
	HWMON_CHANNEL_INFO(curr,
1321 1322 1323 1324 1325 1326
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL,
1327 1328
			   HWMON_C_INPUT | HWMON_C_LABEL,
			   HWMON_C_INPUT | HWMON_C_LABEL),
1329 1330 1331
	NULL
};

1332 1333 1334
static const struct hwmon_chip_info aqc_chip_info = {
	.ops = &aqc_hwmon_ops,
	.info = aqc_info,
1335 1336
};

1337
static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)
1338
{
1339
	int i, j, sensor_value;
1340
	struct aqc_data *priv;
1341

1342
	if (report->id != STATUS_REPORT_ID)
1343 1344 1345 1346 1347
		return 0;

	priv = hid_get_drvdata(hdev);

	/* Info provided with every report */
1348 1349 1350 1351
	priv->serial_number[0] = get_unaligned_be16(data + priv->serial_number_start_offset);
	priv->serial_number[1] = get_unaligned_be16(data + priv->serial_number_start_offset +
						    SERIAL_PART_OFFSET);
	priv->firmware_version = get_unaligned_be16(data + priv->firmware_version_offset);
1352

1353
	/* Physical temperature sensor readings */
1354 1355 1356
	for (i = 0; i < priv->num_temp_sensors; i++) {
		sensor_value = get_unaligned_be16(data +
						  priv->temp_sensor_start_offset +
1357
						  i * AQC_SENSOR_SIZE);
1358
		if (sensor_value == AQC_SENSOR_NA)
1359 1360 1361 1362
			priv->temp_input[i] = -ENODATA;
		else
			priv->temp_input[i] = sensor_value * 10;
	}
1363

1364 1365 1366 1367
	/* Virtual temperature sensor readings */
	for (j = 0; j < priv->num_virtual_temp_sensors; j++) {
		sensor_value = get_unaligned_be16(data +
						  priv->virtual_temp_sensor_start_offset +
1368
						  j * AQC_SENSOR_SIZE);
1369
		if (sensor_value == AQC_SENSOR_NA)
1370 1371 1372 1373 1374 1375
			priv->temp_input[i] = -ENODATA;
		else
			priv->temp_input[i] = sensor_value * 10;
		i++;
	}

1376 1377 1378
	/* Fan speed and related readings */
	for (i = 0; i < priv->num_fans; i++) {
		priv->speed_input[i] =
1379 1380
		    get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
				       priv->fan_structure->speed);
1381 1382
		priv->power_input[i] =
		    get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1383
				       priv->fan_structure->power) * 10000;
1384 1385
		priv->voltage_input[i] =
		    get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
1386
				       priv->fan_structure->voltage) * 10;
1387
		priv->current_input[i] =
1388 1389
		    get_unaligned_be16(data + priv->fan_sensor_offsets[i] +
				       priv->fan_structure->curr);
1390
	}
1391

1392 1393 1394 1395 1396 1397 1398
	/* Flow sensor readings */
	for (j = 0; j < priv->num_flow_sensors; j++) {
		priv->speed_input[i] = get_unaligned_be16(data + priv->flow_sensors_start_offset +
							  j * AQC_SENSOR_SIZE);
		i++;
	}

1399 1400
	if (priv->power_cycle_count_offset != 0)
		priv->power_cycles = get_unaligned_be32(data + priv->power_cycle_count_offset);
1401

1402 1403
	/* Special-case sensor readings */
	switch (priv->kind) {
1404 1405 1406 1407 1408 1409 1410
	case aquaero:
		/* Read calculated virtual temp sensors */
		i = priv->num_temp_sensors + priv->num_virtual_temp_sensors;
		for (j = 0; j < priv->num_calc_virt_temp_sensors; j++) {
			sensor_value = get_unaligned_be16(data +
					priv->calc_virt_temp_sensor_start_offset +
					j * AQC_SENSOR_SIZE);
1411
			if (sensor_value == AQC_SENSOR_NA)
1412 1413 1414 1415 1416 1417
				priv->temp_input[i] = -ENODATA;
			else
				priv->temp_input[i] = sensor_value * 10;
			i++;
		}
		break;
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
	case aquastreamult:
		priv->speed_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_OFFSET);
		priv->speed_input[2] = get_unaligned_be16(data + AQUASTREAMULT_PRESSURE_OFFSET);
		priv->speed_input[3] = get_unaligned_be16(data + AQUASTREAMULT_FLOW_SENSOR_OFFSET);

		priv->power_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_POWER) * 10000;

		priv->voltage_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_VOLTAGE) * 10;

		priv->current_input[1] = get_unaligned_be16(data + AQUASTREAMULT_PUMP_CURRENT);
		break;
1429
	case d5next:
1430
		priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10;
1431
		priv->voltage_input[3] = get_unaligned_be16(data + D5NEXT_12V_VOLTAGE) * 10;
1432
		break;
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
	case highflownext:
		/* If external temp sensor is not connected, its power reading is also N/A */
		if (priv->temp_input[1] == -ENODATA)
			priv->power_input[0] = -ENODATA;
		else
			priv->power_input[0] =
			    get_unaligned_be16(data + HIGHFLOWNEXT_POWER) * 1000000;

		priv->voltage_input[0] = get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE) * 10;
		priv->voltage_input[1] =
		    get_unaligned_be16(data + HIGHFLOWNEXT_5V_VOLTAGE_USB) * 10;

		priv->speed_input[1] = get_unaligned_be16(data + HIGHFLOWNEXT_WATER_QUALITY);
		priv->speed_input[2] = get_unaligned_be16(data + HIGHFLOWNEXT_CONDUCTIVITY);
		break;
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
	case leakshield:
		priv->speed_input[0] =
		    ((s16)get_unaligned_be16(data + LEAKSHIELD_PRESSURE_ADJUSTED)) * 100;
		priv->speed_input_min[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MIN) * 100;
		priv->speed_input_target[0] =
		    get_unaligned_be16(data + LEAKSHIELD_PRESSURE_TARGET) * 100;
		priv->speed_input_max[0] = get_unaligned_be16(data + LEAKSHIELD_PRESSURE_MAX) * 100;

		priv->speed_input[1] = get_unaligned_be16(data + LEAKSHIELD_PUMP_RPM_IN);
		if (priv->speed_input[1] == AQC_SENSOR_NA)
			priv->speed_input[1] = -ENODATA;

		priv->speed_input[2] = get_unaligned_be16(data + LEAKSHIELD_FLOW_IN);
		if (priv->speed_input[2] == AQC_SENSOR_NA)
			priv->speed_input[2] = -ENODATA;

		priv->speed_input[3] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_VOLUME);
		priv->speed_input[4] = get_unaligned_be16(data + LEAKSHIELD_RESERVOIR_FILLED);

		/* Second temp sensor is not positioned after the first one, read it here */
		priv->temp_input[1] = get_unaligned_be16(data + LEAKSHIELD_TEMPERATURE_2) * 10;
		break;
1470 1471 1472
	default:
		break;
	}
1473 1474 1475 1476 1477 1478 1479 1480

	priv->updated = jiffies;

	return 0;
}

static int serial_number_show(struct seq_file *seqf, void *unused)
{
1481
	struct aqc_data *priv = seqf->private;
1482 1483 1484 1485 1486 1487 1488 1489 1490

	seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(serial_number);

static int firmware_version_show(struct seq_file *seqf, void *unused)
{
1491
	struct aqc_data *priv = seqf->private;
1492 1493 1494 1495 1496 1497 1498 1499 1500

	seq_printf(seqf, "%u\n", priv->firmware_version);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(firmware_version);

static int power_cycles_show(struct seq_file *seqf, void *unused)
{
1501
	struct aqc_data *priv = seqf->private;
1502 1503 1504 1505 1506 1507 1508

	seq_printf(seqf, "%u\n", priv->power_cycles);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(power_cycles);

1509
static void aqc_debugfs_init(struct aqc_data *priv)
1510
{
1511
	char name[64];
1512

1513 1514
	scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name,
		  dev_name(&priv->hdev->dev));
1515 1516

	priv->debugfs = debugfs_create_dir(name, NULL);
1517

1518 1519 1520 1521 1522 1523
	if (priv->serial_number_start_offset != 0)
		debugfs_create_file("serial_number", 0444, priv->debugfs, priv,
				    &serial_number_fops);
	if (priv->firmware_version_offset != 0)
		debugfs_create_file("firmware_version", 0444, priv->debugfs, priv,
				    &firmware_version_fops);
1524
	if (priv->power_cycle_count_offset != 0)
1525
		debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops);
1526 1527
}

1528
static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id)
1529
{
1530
	struct aqc_data *priv;
1531 1532 1533 1534 1535 1536 1537 1538 1539
	int ret;

	priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->hdev = hdev;
	hid_set_drvdata(hdev, priv);

1540
	priv->updated = jiffies - STATUS_UPDATE_INTERVAL;
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553

	ret = hid_parse(hdev);
	if (ret)
		return ret;

	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
	if (ret)
		return ret;

	ret = hid_hw_open(hdev);
	if (ret)
		goto fail_and_stop;

1554
	switch (hdev->product) {
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
	case USB_PRODUCT_ID_AQUAERO:
		/*
		 * Aquaero presents itself as three HID devices under the same product ID:
		 * "aquaero keyboard/mouse", "aquaero System Control" and "aquaero Device",
		 * which is the one we want to communicate with. Unlike most other Aquacomputer
		 * devices, Aquaero does not return meaningful data when explicitly requested
		 * using GET_FEATURE_REPORT.
		 *
		 * The difference between "aquaero Device" and the other two is in the collections
		 * they present. The two other devices have the type of the second element in
		 * their respective collections set to 1, while the real device has it set to 0.
		 */
		if (hdev->collection[1].type != 0) {
			ret = -ENODEV;
			goto fail_and_close;
		}

		priv->kind = aquaero;

		priv->num_fans = AQUAERO_NUM_FANS;
		priv->fan_sensor_offsets = aquaero_sensor_fan_offsets;
1576
		priv->fan_ctrl_offsets = aquaero_ctrl_fan_offsets;
1577 1578 1579 1580 1581

		priv->num_temp_sensors = AQUAERO_NUM_SENSORS;
		priv->temp_sensor_start_offset = AQUAERO_SENSOR_START;
		priv->num_virtual_temp_sensors = AQUAERO_NUM_VIRTUAL_SENSORS;
		priv->virtual_temp_sensor_start_offset = AQUAERO_VIRTUAL_SENSOR_START;
1582 1583
		priv->num_calc_virt_temp_sensors = AQUAERO_NUM_CALC_VIRTUAL_SENSORS;
		priv->calc_virt_temp_sensor_start_offset = AQUAERO_CALC_VIRTUAL_SENSOR_START;
1584 1585 1586
		priv->num_flow_sensors = AQUAERO_NUM_FLOW_SENSORS;
		priv->flow_sensors_start_offset = AQUAERO_FLOW_SENSORS_START;

1587
		priv->buffer_size = AQUAERO_CTRL_REPORT_SIZE;
1588
		priv->temp_ctrl_offset = AQUAERO_TEMP_CTRL_OFFSET;
1589
		priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1590

1591 1592
		priv->temp_label = label_temp_sensors;
		priv->virtual_temp_label = label_virtual_temp_sensors;
1593
		priv->calc_virt_temp_label = label_aquaero_calc_temp_sensors;
1594 1595 1596 1597 1598
		priv->speed_label = label_aquaero_speeds;
		priv->power_label = label_fan_power;
		priv->voltage_label = label_fan_voltage;
		priv->current_label = label_fan_current;
		break;
1599 1600
	case USB_PRODUCT_ID_D5NEXT:
		priv->kind = d5next;
1601

1602 1603
		priv->num_fans = D5NEXT_NUM_FANS;
		priv->fan_sensor_offsets = d5next_sensor_fan_offsets;
1604
		priv->fan_ctrl_offsets = d5next_ctrl_fan_offsets;
1605

1606 1607
		priv->num_temp_sensors = D5NEXT_NUM_SENSORS;
		priv->temp_sensor_start_offset = D5NEXT_COOLANT_TEMP;
1608 1609
		priv->num_virtual_temp_sensors = D5NEXT_NUM_VIRTUAL_SENSORS;
		priv->virtual_temp_sensor_start_offset = D5NEXT_VIRTUAL_SENSORS_START;
1610
		priv->temp_ctrl_offset = D5NEXT_TEMP_CTRL_OFFSET;
1611

1612
		priv->buffer_size = D5NEXT_CTRL_REPORT_SIZE;
1613
		priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1614 1615 1616

		priv->power_cycle_count_offset = D5NEXT_POWER_CYCLES;

1617
		priv->temp_label = label_d5next_temp;
1618
		priv->virtual_temp_label = label_virtual_temp_sensors;
1619 1620 1621 1622
		priv->speed_label = label_d5next_speeds;
		priv->power_label = label_d5next_power;
		priv->voltage_label = label_d5next_voltages;
		priv->current_label = label_d5next_current;
1623
		break;
1624 1625 1626
	case USB_PRODUCT_ID_FARBWERK:
		priv->kind = farbwerk;

1627
		priv->num_fans = 0;
1628

1629 1630
		priv->num_temp_sensors = FARBWERK_NUM_SENSORS;
		priv->temp_sensor_start_offset = FARBWERK_SENSOR_START;
1631

1632 1633
		priv->temp_label = label_temp_sensors;
		break;
1634 1635
	case USB_PRODUCT_ID_FARBWERK360:
		priv->kind = farbwerk360;
1636

1637
		priv->num_fans = 0;
1638

1639 1640
		priv->num_temp_sensors = FARBWERK360_NUM_SENSORS;
		priv->temp_sensor_start_offset = FARBWERK360_SENSOR_START;
1641 1642
		priv->num_virtual_temp_sensors = FARBWERK360_NUM_VIRTUAL_SENSORS;
		priv->virtual_temp_sensor_start_offset = FARBWERK360_VIRTUAL_SENSORS_START;
1643
		priv->temp_ctrl_offset = FARBWERK360_TEMP_CTRL_OFFSET;
1644 1645 1646

		priv->buffer_size = FARBWERK360_CTRL_REPORT_SIZE;

1647
		priv->temp_label = label_temp_sensors;
1648
		priv->virtual_temp_label = label_virtual_temp_sensors;
1649 1650 1651
		break;
	case USB_PRODUCT_ID_OCTO:
		priv->kind = octo;
1652 1653 1654 1655

		priv->num_fans = OCTO_NUM_FANS;
		priv->fan_sensor_offsets = octo_sensor_fan_offsets;
		priv->fan_ctrl_offsets = octo_ctrl_fan_offsets;
1656

1657 1658
		priv->num_temp_sensors = OCTO_NUM_SENSORS;
		priv->temp_sensor_start_offset = OCTO_SENSOR_START;
1659 1660
		priv->num_virtual_temp_sensors = OCTO_NUM_VIRTUAL_SENSORS;
		priv->virtual_temp_sensor_start_offset = OCTO_VIRTUAL_SENSORS_START;
1661
		priv->temp_ctrl_offset = OCTO_TEMP_CTRL_OFFSET;
1662

1663
		priv->buffer_size = OCTO_CTRL_REPORT_SIZE;
1664
		priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1665 1666 1667

		priv->power_cycle_count_offset = OCTO_POWER_CYCLES;

1668
		priv->temp_label = label_temp_sensors;
1669
		priv->virtual_temp_label = label_virtual_temp_sensors;
1670 1671 1672 1673
		priv->speed_label = label_fan_speed;
		priv->power_label = label_fan_power;
		priv->voltage_label = label_fan_voltage;
		priv->current_label = label_fan_current;
1674
		break;
1675 1676 1677 1678 1679 1680
	case USB_PRODUCT_ID_QUADRO:
		priv->kind = quadro;

		priv->num_fans = QUADRO_NUM_FANS;
		priv->fan_sensor_offsets = quadro_sensor_fan_offsets;
		priv->fan_ctrl_offsets = quadro_ctrl_fan_offsets;
1681

1682 1683
		priv->num_temp_sensors = QUADRO_NUM_SENSORS;
		priv->temp_sensor_start_offset = QUADRO_SENSOR_START;
1684 1685
		priv->num_virtual_temp_sensors = QUADRO_NUM_VIRTUAL_SENSORS;
		priv->virtual_temp_sensor_start_offset = QUADRO_VIRTUAL_SENSORS_START;
1686 1687 1688
		priv->num_flow_sensors = QUADRO_NUM_FLOW_SENSORS;
		priv->flow_sensors_start_offset = QUADRO_FLOW_SENSOR_OFFSET;

1689 1690
		priv->temp_ctrl_offset = QUADRO_TEMP_CTRL_OFFSET;

1691
		priv->buffer_size = QUADRO_CTRL_REPORT_SIZE;
1692
		priv->ctrl_report_delay = CTRL_REPORT_DELAY;
1693

1694
		priv->flow_pulses_ctrl_offset = QUADRO_FLOW_PULSES_CTRL_OFFSET;
1695
		priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;
1696 1697

		priv->temp_label = label_temp_sensors;
1698
		priv->virtual_temp_label = label_virtual_temp_sensors;
1699 1700 1701 1702 1703
		priv->speed_label = label_quadro_speeds;
		priv->power_label = label_fan_power;
		priv->voltage_label = label_fan_voltage;
		priv->current_label = label_fan_current;
		break;
1704 1705 1706 1707
	case USB_PRODUCT_ID_HIGHFLOWNEXT:
		priv->kind = highflownext;

		priv->num_fans = 0;
1708

1709 1710
		priv->num_temp_sensors = HIGHFLOWNEXT_NUM_SENSORS;
		priv->temp_sensor_start_offset = HIGHFLOWNEXT_SENSOR_START;
1711 1712
		priv->num_flow_sensors = HIGHFLOWNEXT_NUM_FLOW_SENSORS;
		priv->flow_sensors_start_offset = HIGHFLOWNEXT_FLOW;
1713

1714 1715 1716 1717 1718 1719 1720
		priv->power_cycle_count_offset = QUADRO_POWER_CYCLES;

		priv->temp_label = label_highflownext_temp_sensors;
		priv->speed_label = label_highflownext_fan_speed;
		priv->power_label = label_highflownext_power;
		priv->voltage_label = label_highflownext_voltage;
		break;
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
	case USB_PRODUCT_ID_LEAKSHIELD:
		/*
		 * Choose the right Leakshield device, because
		 * the other one acts as a keyboard
		 */
		if (hdev->type != 2) {
			ret = -ENODEV;
			goto fail_and_close;
		}

		priv->kind = leakshield;

		priv->num_fans = 0;
		priv->num_temp_sensors = LEAKSHIELD_NUM_SENSORS;
		priv->temp_sensor_start_offset = LEAKSHIELD_TEMPERATURE_1;

		priv->temp_label = label_leakshield_temp_sensors;
		priv->speed_label = label_leakshield_fan_speed;
		break;
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
	case USB_PRODUCT_ID_AQUASTREAMXT:
		priv->kind = aquastreamxt;

		priv->num_fans = AQUASTREAMXT_NUM_FANS;
		priv->fan_sensor_offsets = aquastreamxt_sensor_fan_offsets;

		priv->num_temp_sensors = AQUASTREAMXT_NUM_SENSORS;
		priv->temp_sensor_start_offset = AQUASTREAMXT_SENSOR_START;
		priv->buffer_size = AQUASTREAMXT_SENSOR_REPORT_SIZE;

		priv->temp_label = label_aquastreamxt_temp_sensors;
		priv->speed_label = label_d5next_speeds;
		priv->voltage_label = label_d5next_voltages;
		priv->current_label = label_d5next_current;
		break;
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	case USB_PRODUCT_ID_AQUASTREAMULT:
		priv->kind = aquastreamult;

		priv->num_fans = AQUASTREAMULT_NUM_FANS;
		priv->fan_sensor_offsets = aquastreamult_sensor_fan_offsets;

		priv->num_temp_sensors = AQUASTREAMULT_NUM_SENSORS;
		priv->temp_sensor_start_offset = AQUASTREAMULT_SENSOR_START;

		priv->temp_label = label_aquastreamult_temp;
		priv->speed_label = label_aquastreamult_speeds;
		priv->power_label = label_aquastreamult_power;
		priv->voltage_label = label_aquastreamult_voltages;
		priv->current_label = label_aquastreamult_current;
		break;
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
	case USB_PRODUCT_ID_POWERADJUST3:
		priv->kind = poweradjust3;

		priv->num_fans = 0;

		priv->num_temp_sensors = POWERADJUST3_NUM_SENSORS;
		priv->temp_sensor_start_offset = POWERADJUST3_SENSOR_START;
		priv->buffer_size = POWERADJUST3_SENSOR_REPORT_SIZE;

		priv->temp_label = label_poweradjust3_temp_sensors;
		break;
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
	case USB_PRODUCT_ID_HIGHFLOW:
		priv->kind = highflow;

		priv->num_fans = 0;

		priv->num_temp_sensors = HIGHFLOW_NUM_SENSORS;
		priv->temp_sensor_start_offset = HIGHFLOW_SENSOR_START;
		priv->num_flow_sensors = HIGHFLOW_NUM_FLOW_SENSORS;
		priv->flow_sensors_start_offset = HIGHFLOW_FLOW_SENSOR_OFFSET;
		priv->buffer_size = HIGHFLOW_SENSOR_REPORT_SIZE;

		priv->temp_label = label_highflow_temp;
		priv->speed_label = label_highflow_speeds;
		break;
1795 1796 1797 1798
	default:
		break;
	}

1799 1800 1801 1802 1803 1804
	switch (priv->kind) {
	case aquaero:
		priv->serial_number_start_offset = AQUAERO_SERIAL_START;
		priv->firmware_version_offset = AQUAERO_FIRMWARE_VERSION;

		priv->fan_structure = &aqc_aquaero_fan_structure;
1805 1806 1807 1808 1809

		priv->ctrl_report_id = AQUAERO_CTRL_REPORT_ID;
		priv->secondary_ctrl_report_id = AQUAERO_SECONDARY_CTRL_REPORT_ID;
		priv->secondary_ctrl_report_size = AQUAERO_SECONDARY_CTRL_REPORT_SIZE;
		priv->secondary_ctrl_report = aquaero_secondary_ctrl_report;
1810
		break;
1811 1812 1813
	case poweradjust3:
		priv->status_report_id = POWERADJUST3_STATUS_REPORT_ID;
		break;
1814 1815 1816 1817 1818 1819
	case aquastreamxt:
		priv->serial_number_start_offset = AQUASTREAMXT_SERIAL_START;
		priv->firmware_version_offset = AQUASTREAMXT_FIRMWARE_VERSION;

		priv->status_report_id = AQUASTREAMXT_STATUS_REPORT_ID;
		break;
1820 1821 1822 1823 1824 1825
	case highflow:
		priv->serial_number_start_offset = HIGHFLOW_SERIAL_START;
		priv->firmware_version_offset = HIGHFLOW_FIRMWARE_VERSION;

		priv->status_report_id = HIGHFLOW_STATUS_REPORT_ID;
		break;
1826 1827 1828
	default:
		priv->serial_number_start_offset = AQC_SERIAL_START;
		priv->firmware_version_offset = AQC_FIRMWARE_VERSION;
1829

1830 1831 1832 1833 1834
		priv->ctrl_report_id = CTRL_REPORT_ID;
		priv->secondary_ctrl_report_id = SECONDARY_CTRL_REPORT_ID;
		priv->secondary_ctrl_report_size = SECONDARY_CTRL_REPORT_SIZE;
		priv->secondary_ctrl_report = secondary_ctrl_report;

1835 1836 1837 1838
		if (priv->kind == aquastreamult)
			priv->fan_structure = &aqc_aquastreamult_fan_structure;
		else
			priv->fan_structure = &aqc_general_fan_structure;
1839 1840
		break;
	}
1841

1842 1843 1844 1845 1846 1847
	if (priv->buffer_size != 0) {
		priv->checksum_start = 0x01;
		priv->checksum_length = priv->buffer_size - 3;
		priv->checksum_offset = priv->buffer_size - 2;
	}

1848 1849
	priv->name = aqc_device_names[priv->kind];

1850
	priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL);
1851 1852 1853 1854
	if (!priv->buffer) {
		ret = -ENOMEM;
		goto fail_and_close;
	}
1855 1856 1857

	mutex_init(&priv->mutex);

1858 1859
	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv,
							  &aqc_chip_info, NULL);
1860 1861 1862 1863 1864 1865

	if (IS_ERR(priv->hwmon_dev)) {
		ret = PTR_ERR(priv->hwmon_dev);
		goto fail_and_close;
	}

1866
	aqc_debugfs_init(priv);
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876

	return 0;

fail_and_close:
	hid_hw_close(hdev);
fail_and_stop:
	hid_hw_stop(hdev);
	return ret;
}

1877
static void aqc_remove(struct hid_device *hdev)
1878
{
1879
	struct aqc_data *priv = hid_get_drvdata(hdev);
1880 1881 1882 1883 1884 1885 1886 1887

	debugfs_remove_recursive(priv->debugfs);
	hwmon_device_unregister(priv->hwmon_dev);

	hid_hw_close(hdev);
	hid_hw_stop(hdev);
}

1888
static const struct hid_device_id aqc_table[] = {
1889
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUAERO) },
1890
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) },
1891
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) },
1892
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) },
1893
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) },
1894
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_QUADRO) },
1895
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOWNEXT) },
1896
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_LEAKSHIELD) },
1897
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMXT) },
1898
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_AQUASTREAMULT) },
1899
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_POWERADJUST3) },
1900
	{ HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_HIGHFLOW) },
1901
	{ }
1902 1903
};

1904
MODULE_DEVICE_TABLE(hid, aqc_table);
1905

1906
static struct hid_driver aqc_driver = {
1907
	.name = DRIVER_NAME,
1908 1909 1910 1911
	.id_table = aqc_table,
	.probe = aqc_probe,
	.remove = aqc_remove,
	.raw_event = aqc_raw_event,
1912 1913
};

1914
static int __init aqc_init(void)
1915
{
1916
	return hid_register_driver(&aqc_driver);
1917 1918
}

1919
static void __exit aqc_exit(void)
1920
{
1921
	hid_unregister_driver(&aqc_driver);
1922 1923 1924
}

/* Request to initialize after the HID bus to ensure it's not being loaded before */
1925 1926
late_initcall(aqc_init);
module_exit(aqc_exit);
1927 1928 1929

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
1930
MODULE_AUTHOR("Jack Doan <me@jackdoan.com>");
1931
MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices");