aquacomputer_d5next.c

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