Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * hwmon driver for NZXT Kraken X53/X63/X73 and Z53/Z63/Z73 all in one coolers.
4 * X53 and Z53 in code refer to all models in their respective series (shortened
5 * for brevity).
6 *
7 * Copyright 2021 Jonas Malaco <jonas@protocubo.io>
8 * Copyright 2022 Aleksa Savic <savicaleksa83@gmail.com>
9 */
10
11#include <linux/debugfs.h>
12#include <linux/hid.h>
13#include <linux/hwmon.h>
14#include <linux/hwmon-sysfs.h>
15#include <linux/jiffies.h>
16#include <linux/module.h>
17#include <linux/mutex.h>
18#include <linux/spinlock.h>
19#include <linux/wait.h>
20#include <asm/unaligned.h>
21
22#define USB_VENDOR_ID_NZXT 0x1e71
23#define USB_PRODUCT_ID_X53 0x2007
24#define USB_PRODUCT_ID_X53_SECOND 0x2014
25#define USB_PRODUCT_ID_Z53 0x3008
26
27enum kinds { X53, Z53 } __packed;
28enum pwm_enable { off, manual, curve } __packed;
29
30static const char *const kraken3_device_names[] = {
31 [X53] = "x53",
32 [Z53] = "z53",
33};
34
35#define DRIVER_NAME "nzxt_kraken3"
36#define STATUS_REPORT_ID 0x75
37#define FIRMWARE_REPORT_ID 0x11
38#define STATUS_VALIDITY 2000 /* In ms, equivalent to period of four status reports */
39#define CUSTOM_CURVE_POINTS 40 /* For temps from 20C to 59C (critical temp) */
40#define PUMP_DUTY_MIN 20 /* In percent */
41
42/* Sensor report offsets for Kraken X53 and Z53 */
43#define TEMP_SENSOR_START_OFFSET 15
44#define TEMP_SENSOR_END_OFFSET 16
45#define PUMP_SPEED_OFFSET 17
46#define PUMP_DUTY_OFFSET 19
47
48/* Firmware version report offset for Kraken X53 and Z53 */
49#define FIRMWARE_VERSION_OFFSET 17
50
51/* Sensor report offsets for Kraken Z53 */
52#define Z53_FAN_SPEED_OFFSET 23
53#define Z53_FAN_DUTY_OFFSET 25
54
55/* Report offsets for control commands for Kraken X53 and Z53 */
56#define SET_DUTY_ID_OFFSET 1
57
58/* Control commands and their lengths for Kraken X53 and Z53 */
59
60/* Last byte sets the report interval at 0.5s */
61static const u8 set_interval_cmd[] = { 0x70, 0x02, 0x01, 0xB8, 1 };
62static const u8 finish_init_cmd[] = { 0x70, 0x01 };
63static const u8 __maybe_unused get_fw_version_cmd[] = { 0x10, 0x01 };
64static const u8 set_pump_duty_cmd_header[] = { 0x72, 0x00, 0x00, 0x00 };
65static const u8 z53_get_status_cmd[] = { 0x74, 0x01 };
66
67#define SET_INTERVAL_CMD_LENGTH 5
68#define FINISH_INIT_CMD_LENGTH 2
69#define GET_FW_VERSION_CMD_LENGTH 2
70#define MAX_REPORT_LENGTH 64
71#define MIN_REPORT_LENGTH 20
72#define SET_CURVE_DUTY_CMD_HEADER_LENGTH 4
73/* 4 byte header and 40 duty offsets */
74#define SET_CURVE_DUTY_CMD_LENGTH (4 + 40)
75#define Z53_GET_STATUS_CMD_LENGTH 2
76
77static const char *const kraken3_temp_label[] = {
78 "Coolant temp",
79};
80
81static const char *const kraken3_fan_label[] = {
82 "Pump speed",
83 "Fan speed"
84};
85
86struct kraken3_channel_info {
87 enum pwm_enable mode;
88
89 /* Both values are PWM */
90 u16 reported_duty;
91 u16 fixed_duty; /* Manually set fixed duty */
92
93 u8 pwm_points[CUSTOM_CURVE_POINTS];
94};
95
96struct kraken3_data {
97 struct hid_device *hdev;
98 struct device *hwmon_dev;
99 struct dentry *debugfs;
100 struct mutex buffer_lock; /* For locking access to buffer */
101 struct mutex z53_status_request_lock;
102 struct completion fw_version_processed;
103 /*
104 * For X53 devices, tracks whether an initial (one) sensor report was received to
105 * make fancontrol not bail outright. For Z53 devices, whether a status report
106 * was processed after requesting one.
107 */
108 struct completion status_report_processed;
109 /* For locking the above completion */
110 spinlock_t status_completion_lock;
111
112 u8 *buffer;
113 struct kraken3_channel_info channel_info[2]; /* Pump and fan */
114 bool is_device_faulty;
115
116 /* Sensor values */
117 s32 temp_input[1];
118 u16 fan_input[2];
119
120 enum kinds kind;
121 u8 firmware_version[3];
122
123 unsigned long updated; /* jiffies */
124};
125
126static umode_t kraken3_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
127 int channel)
128{
129 const struct kraken3_data *priv = data;
130
131 switch (type) {
132 case hwmon_temp:
133 if (channel < 1)
134 return 0444;
135 break;
136 case hwmon_fan:
137 switch (priv->kind) {
138 case X53:
139 /* Just the pump */
140 if (channel < 1)
141 return 0444;
142 break;
143 case Z53:
144 /* Pump and fan */
145 if (channel < 2)
146 return 0444;
147 break;
148 default:
149 break;
150 }
151 break;
152 case hwmon_pwm:
153 switch (attr) {
154 case hwmon_pwm_enable:
155 case hwmon_pwm_input:
156 switch (priv->kind) {
157 case X53:
158 /* Just the pump */
159 if (channel < 1)
160 return 0644;
161 break;
162 case Z53:
163 /* Pump and fan */
164 if (channel < 2)
165 return 0644;
166 break;
167 default:
168 break;
169 }
170 break;
171 default:
172 break;
173 }
174 break;
175 default:
176 break;
177 }
178
179 return 0;
180}
181
182/*
183 * Writes the command to the device with the rest of the report (up to 64 bytes) filled
184 * with zeroes.
185 */
186static int kraken3_write_expanded(struct kraken3_data *priv, const u8 *cmd, int cmd_length)
187{
188 int ret;
189
190 mutex_lock(&priv->buffer_lock);
191
192 memcpy_and_pad(priv->buffer, MAX_REPORT_LENGTH, cmd, cmd_length, 0x00);
193 ret = hid_hw_output_report(priv->hdev, priv->buffer, MAX_REPORT_LENGTH);
194
195 mutex_unlock(&priv->buffer_lock);
196 return ret;
197}
198
199static int kraken3_percent_to_pwm(long val)
200{
201 return DIV_ROUND_CLOSEST(val * 255, 100);
202}
203
204static int kraken3_pwm_to_percent(long val, int channel)
205{
206 int percent_value;
207
208 if (val < 0 || val > 255)
209 return -EINVAL;
210
211 percent_value = DIV_ROUND_CLOSEST(val * 100, 255);
212
213 /* Bring up pump duty to min value if needed */
214 if (channel == 0 && percent_value < PUMP_DUTY_MIN)
215 percent_value = PUMP_DUTY_MIN;
216
217 return percent_value;
218}
219
220static int kraken3_read_x53(struct kraken3_data *priv)
221{
222 int ret;
223
224 if (completion_done(&priv->status_report_processed))
225 /*
226 * We're here because data is stale. This means that sensor reports haven't
227 * been received for some time in kraken3_raw_event(). On X-series sensor data
228 * can't be manually requested, so return an error.
229 */
230 return -ENODATA;
231
232 /*
233 * Data needs to be read, but a sensor report wasn't yet received. It's usually
234 * fancontrol that requests data this early and it exits if it reads an error code.
235 * So, wait for the first report to be parsed (but up to STATUS_VALIDITY).
236 * This does not concern the Z series devices, because they send a sensor report
237 * only when requested.
238 */
239 ret = wait_for_completion_interruptible_timeout(&priv->status_report_processed,
240 msecs_to_jiffies(STATUS_VALIDITY));
241 if (ret == 0)
242 return -ETIMEDOUT;
243 else if (ret < 0)
244 return ret;
245
246 /* The first sensor report was parsed on time and reading can continue */
247 return 0;
248}
249
250static int kraken3_read_z53(struct kraken3_data *priv)
251{
252 int ret = mutex_lock_interruptible(&priv->z53_status_request_lock);
253
254 if (ret < 0)
255 return ret;
256
257 if (!time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {
258 /* Data is up to date */
259 goto unlock_and_return;
260 }
261
262 /*
263 * Disable interrupts for a moment to safely reinit the completion,
264 * as hidraw calls could have allowed one or more readers to complete.
265 */
266 spin_lock_bh(&priv->status_completion_lock);
267 reinit_completion(&priv->status_report_processed);
268 spin_unlock_bh(&priv->status_completion_lock);
269
270 /* Send command for getting status */
271 ret = kraken3_write_expanded(priv, z53_get_status_cmd, Z53_GET_STATUS_CMD_LENGTH);
272 if (ret < 0)
273 goto unlock_and_return;
274
275 /* Wait for completion from kraken3_raw_event() */
276 ret = wait_for_completion_interruptible_timeout(&priv->status_report_processed,
277 msecs_to_jiffies(STATUS_VALIDITY));
278 if (ret == 0)
279 ret = -ETIMEDOUT;
280
281unlock_and_return:
282 mutex_unlock(&priv->z53_status_request_lock);
283 if (ret < 0)
284 return ret;
285
286 return 0;
287}
288
289static int kraken3_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
290 long *val)
291{
292 struct kraken3_data *priv = dev_get_drvdata(dev);
293 int ret;
294
295 if (time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {
296 if (priv->kind == X53)
297 ret = kraken3_read_x53(priv);
298 else
299 ret = kraken3_read_z53(priv);
300
301 if (ret < 0)
302 return ret;
303
304 if (priv->is_device_faulty)
305 return -ENODATA;
306 }
307
308 switch (type) {
309 case hwmon_temp:
310 *val = priv->temp_input[channel];
311 break;
312 case hwmon_fan:
313 *val = priv->fan_input[channel];
314 break;
315 case hwmon_pwm:
316 switch (attr) {
317 case hwmon_pwm_enable:
318 *val = priv->channel_info[channel].mode;
319 break;
320 case hwmon_pwm_input:
321 *val = priv->channel_info[channel].reported_duty;
322 break;
323 default:
324 return -EOPNOTSUPP;
325 }
326 break;
327 default:
328 return -EOPNOTSUPP;
329 }
330
331 return 0;
332}
333
334static int kraken3_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
335 int channel, const char **str)
336{
337 switch (type) {
338 case hwmon_temp:
339 *str = kraken3_temp_label[channel];
340 break;
341 case hwmon_fan:
342 *str = kraken3_fan_label[channel];
343 break;
344 default:
345 return -EOPNOTSUPP;
346 }
347
348 return 0;
349}
350
351/* Writes custom curve to device */
352static int kraken3_write_curve(struct kraken3_data *priv, u8 *curve_array, int channel)
353{
354 u8 fixed_duty_cmd[SET_CURVE_DUTY_CMD_LENGTH];
355 int ret;
356
357 /* Copy command header */
358 memcpy(fixed_duty_cmd, set_pump_duty_cmd_header, SET_CURVE_DUTY_CMD_HEADER_LENGTH);
359
360 /* Set the correct ID for writing pump/fan duty (0x01 or 0x02, respectively) */
361 fixed_duty_cmd[SET_DUTY_ID_OFFSET] = channel + 1;
362
363 /* Copy curve to command */
364 memcpy(fixed_duty_cmd + SET_CURVE_DUTY_CMD_HEADER_LENGTH, curve_array, CUSTOM_CURVE_POINTS);
365
366 ret = kraken3_write_expanded(priv, fixed_duty_cmd, SET_CURVE_DUTY_CMD_LENGTH);
367 return ret;
368}
369
370static int kraken3_write_fixed_duty(struct kraken3_data *priv, long val, int channel)
371{
372 u8 fixed_curve_points[CUSTOM_CURVE_POINTS];
373 int ret, percent_val, i;
374
375 percent_val = kraken3_pwm_to_percent(val, channel);
376 if (percent_val < 0)
377 return percent_val;
378
379 /*
380 * The devices can only control the duty through a curve.
381 * Since we're setting a fixed duty here, fill the whole curve
382 * (ranging from 20C to 59C) with the same duty, except for
383 * the last point, the critical temperature, where it's maxed
384 * out for safety.
385 */
386
387 /* Fill the custom curve with the fixed value we're setting */
388 for (i = 0; i < CUSTOM_CURVE_POINTS - 1; i++)
389 fixed_curve_points[i] = percent_val;
390
391 /* Force duty to 100% at critical temp */
392 fixed_curve_points[CUSTOM_CURVE_POINTS - 1] = 100;
393
394 /* Write the fixed duty curve to the device */
395 ret = kraken3_write_curve(priv, fixed_curve_points, channel);
396 return ret;
397}
398
399static int kraken3_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
400 long val)
401{
402 struct kraken3_data *priv = dev_get_drvdata(dev);
403 int ret;
404
405 switch (type) {
406 case hwmon_pwm:
407 switch (attr) {
408 case hwmon_pwm_input:
409 /* Remember the last set fixed duty for channel */
410 priv->channel_info[channel].fixed_duty = val;
411
412 if (priv->channel_info[channel].mode == manual) {
413 ret = kraken3_write_fixed_duty(priv, val, channel);
414 if (ret < 0)
415 return ret;
416
417 /*
418 * Lock onto this value and report it until next interrupt status
419 * report is received, so userspace tools can continue to work.
420 */
421 priv->channel_info[channel].reported_duty = val;
422 }
423 break;
424 case hwmon_pwm_enable:
425 if (val < 0 || val > 2)
426 return -EINVAL;
427
428 switch (val) {
429 case 0:
430 /* Set channel to 100%, direct duty value */
431 ret = kraken3_write_fixed_duty(priv, 255, channel);
432 if (ret < 0)
433 return ret;
434
435 /* We don't control anything anymore */
436 priv->channel_info[channel].mode = off;
437 break;
438 case 1:
439 /* Apply the last known direct duty value */
440 ret =
441 kraken3_write_fixed_duty(priv,
442 priv->channel_info[channel].fixed_duty,
443 channel);
444 if (ret < 0)
445 return ret;
446
447 priv->channel_info[channel].mode = manual;
448 break;
449 case 2:
450 /* Apply the curve and note as enabled */
451 ret =
452 kraken3_write_curve(priv,
453 priv->channel_info[channel].pwm_points,
454 channel);
455 if (ret < 0)
456 return ret;
457
458 priv->channel_info[channel].mode = curve;
459 break;
460 default:
461 break;
462 }
463 break;
464 default:
465 return -EOPNOTSUPP;
466 }
467 break;
468 default:
469 return -EOPNOTSUPP;
470 }
471
472 return 0;
473}
474
475static ssize_t kraken3_fan_curve_pwm_store(struct device *dev, struct device_attribute *attr,
476 const char *buf, size_t count)
477{
478 struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
479 struct kraken3_data *priv = dev_get_drvdata(dev);
480 long val;
481 int ret;
482
483 if (kstrtol(buf, 10, &val) < 0)
484 return -EINVAL;
485
486 val = kraken3_pwm_to_percent(val, dev_attr->nr);
487 if (val < 0)
488 return val;
489
490 priv->channel_info[dev_attr->nr].pwm_points[dev_attr->index] = val;
491
492 if (priv->channel_info[dev_attr->nr].mode == curve) {
493 /* Apply the curve */
494 ret =
495 kraken3_write_curve(priv,
496 priv->channel_info[dev_attr->nr].pwm_points, dev_attr->nr);
497 if (ret < 0)
498 return ret;
499 }
500
501 return count;
502}
503
504static umode_t kraken3_curve_props_are_visible(struct kobject *kobj, struct attribute *attr,
505 int index)
506{
507 struct device *dev = kobj_to_dev(kobj);
508 struct kraken3_data *priv = dev_get_drvdata(dev);
509
510 /* Only Z53 has the fan curve */
511 if (index >= CUSTOM_CURVE_POINTS && priv->kind != Z53)
512 return 0;
513
514 return attr->mode;
515}
516
517/* Custom pump curve from 20C to 59C (critical temp) */
518static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point1_pwm, kraken3_fan_curve_pwm, 0, 0);
519static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point2_pwm, kraken3_fan_curve_pwm, 0, 1);
520static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point3_pwm, kraken3_fan_curve_pwm, 0, 2);
521static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point4_pwm, kraken3_fan_curve_pwm, 0, 3);
522static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point5_pwm, kraken3_fan_curve_pwm, 0, 4);
523static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point6_pwm, kraken3_fan_curve_pwm, 0, 5);
524static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point7_pwm, kraken3_fan_curve_pwm, 0, 6);
525static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point8_pwm, kraken3_fan_curve_pwm, 0, 7);
526static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point9_pwm, kraken3_fan_curve_pwm, 0, 8);
527static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point10_pwm, kraken3_fan_curve_pwm, 0, 9);
528static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point11_pwm, kraken3_fan_curve_pwm, 0, 10);
529static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point12_pwm, kraken3_fan_curve_pwm, 0, 11);
530static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point13_pwm, kraken3_fan_curve_pwm, 0, 12);
531static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point14_pwm, kraken3_fan_curve_pwm, 0, 13);
532static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point15_pwm, kraken3_fan_curve_pwm, 0, 14);
533static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point16_pwm, kraken3_fan_curve_pwm, 0, 15);
534static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point17_pwm, kraken3_fan_curve_pwm, 0, 16);
535static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point18_pwm, kraken3_fan_curve_pwm, 0, 17);
536static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point19_pwm, kraken3_fan_curve_pwm, 0, 18);
537static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point20_pwm, kraken3_fan_curve_pwm, 0, 19);
538static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point21_pwm, kraken3_fan_curve_pwm, 0, 20);
539static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point22_pwm, kraken3_fan_curve_pwm, 0, 21);
540static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point23_pwm, kraken3_fan_curve_pwm, 0, 22);
541static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point24_pwm, kraken3_fan_curve_pwm, 0, 23);
542static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point25_pwm, kraken3_fan_curve_pwm, 0, 24);
543static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point26_pwm, kraken3_fan_curve_pwm, 0, 25);
544static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point27_pwm, kraken3_fan_curve_pwm, 0, 26);
545static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point28_pwm, kraken3_fan_curve_pwm, 0, 27);
546static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point29_pwm, kraken3_fan_curve_pwm, 0, 28);
547static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point30_pwm, kraken3_fan_curve_pwm, 0, 29);
548static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point31_pwm, kraken3_fan_curve_pwm, 0, 30);
549static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point32_pwm, kraken3_fan_curve_pwm, 0, 31);
550static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point33_pwm, kraken3_fan_curve_pwm, 0, 32);
551static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point34_pwm, kraken3_fan_curve_pwm, 0, 33);
552static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point35_pwm, kraken3_fan_curve_pwm, 0, 34);
553static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point36_pwm, kraken3_fan_curve_pwm, 0, 35);
554static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point37_pwm, kraken3_fan_curve_pwm, 0, 36);
555static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point38_pwm, kraken3_fan_curve_pwm, 0, 37);
556static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point39_pwm, kraken3_fan_curve_pwm, 0, 38);
557static SENSOR_DEVICE_ATTR_2_WO(temp1_auto_point40_pwm, kraken3_fan_curve_pwm, 0, 39);
558
559/* Custom fan curve from 20C to 59C (critical temp) */
560static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point1_pwm, kraken3_fan_curve_pwm, 1, 0);
561static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point2_pwm, kraken3_fan_curve_pwm, 1, 1);
562static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point3_pwm, kraken3_fan_curve_pwm, 1, 2);
563static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point4_pwm, kraken3_fan_curve_pwm, 1, 3);
564static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point5_pwm, kraken3_fan_curve_pwm, 1, 4);
565static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point6_pwm, kraken3_fan_curve_pwm, 1, 5);
566static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point7_pwm, kraken3_fan_curve_pwm, 1, 6);
567static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point8_pwm, kraken3_fan_curve_pwm, 1, 7);
568static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point9_pwm, kraken3_fan_curve_pwm, 1, 8);
569static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point10_pwm, kraken3_fan_curve_pwm, 1, 9);
570static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point11_pwm, kraken3_fan_curve_pwm, 1, 10);
571static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point12_pwm, kraken3_fan_curve_pwm, 1, 11);
572static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point13_pwm, kraken3_fan_curve_pwm, 1, 12);
573static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point14_pwm, kraken3_fan_curve_pwm, 1, 13);
574static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point15_pwm, kraken3_fan_curve_pwm, 1, 14);
575static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point16_pwm, kraken3_fan_curve_pwm, 1, 15);
576static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point17_pwm, kraken3_fan_curve_pwm, 1, 16);
577static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point18_pwm, kraken3_fan_curve_pwm, 1, 17);
578static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point19_pwm, kraken3_fan_curve_pwm, 1, 18);
579static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point20_pwm, kraken3_fan_curve_pwm, 1, 19);
580static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point21_pwm, kraken3_fan_curve_pwm, 1, 20);
581static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point22_pwm, kraken3_fan_curve_pwm, 1, 21);
582static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point23_pwm, kraken3_fan_curve_pwm, 1, 22);
583static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point24_pwm, kraken3_fan_curve_pwm, 1, 23);
584static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point25_pwm, kraken3_fan_curve_pwm, 1, 24);
585static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point26_pwm, kraken3_fan_curve_pwm, 1, 25);
586static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point27_pwm, kraken3_fan_curve_pwm, 1, 26);
587static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point28_pwm, kraken3_fan_curve_pwm, 1, 27);
588static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point29_pwm, kraken3_fan_curve_pwm, 1, 28);
589static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point30_pwm, kraken3_fan_curve_pwm, 1, 29);
590static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point31_pwm, kraken3_fan_curve_pwm, 1, 30);
591static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point32_pwm, kraken3_fan_curve_pwm, 1, 31);
592static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point33_pwm, kraken3_fan_curve_pwm, 1, 32);
593static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point34_pwm, kraken3_fan_curve_pwm, 1, 33);
594static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point35_pwm, kraken3_fan_curve_pwm, 1, 34);
595static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point36_pwm, kraken3_fan_curve_pwm, 1, 35);
596static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point37_pwm, kraken3_fan_curve_pwm, 1, 36);
597static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point38_pwm, kraken3_fan_curve_pwm, 1, 37);
598static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point39_pwm, kraken3_fan_curve_pwm, 1, 38);
599static SENSOR_DEVICE_ATTR_2_WO(temp2_auto_point40_pwm, kraken3_fan_curve_pwm, 1, 39);
600
601static struct attribute *kraken3_curve_attrs[] = {
602 /* Pump control curve */
603 &sensor_dev_attr_temp1_auto_point1_pwm.dev_attr.attr,
604 &sensor_dev_attr_temp1_auto_point2_pwm.dev_attr.attr,
605 &sensor_dev_attr_temp1_auto_point3_pwm.dev_attr.attr,
606 &sensor_dev_attr_temp1_auto_point4_pwm.dev_attr.attr,
607 &sensor_dev_attr_temp1_auto_point5_pwm.dev_attr.attr,
608 &sensor_dev_attr_temp1_auto_point6_pwm.dev_attr.attr,
609 &sensor_dev_attr_temp1_auto_point7_pwm.dev_attr.attr,
610 &sensor_dev_attr_temp1_auto_point8_pwm.dev_attr.attr,
611 &sensor_dev_attr_temp1_auto_point9_pwm.dev_attr.attr,
612 &sensor_dev_attr_temp1_auto_point10_pwm.dev_attr.attr,
613 &sensor_dev_attr_temp1_auto_point11_pwm.dev_attr.attr,
614 &sensor_dev_attr_temp1_auto_point12_pwm.dev_attr.attr,
615 &sensor_dev_attr_temp1_auto_point13_pwm.dev_attr.attr,
616 &sensor_dev_attr_temp1_auto_point14_pwm.dev_attr.attr,
617 &sensor_dev_attr_temp1_auto_point15_pwm.dev_attr.attr,
618 &sensor_dev_attr_temp1_auto_point16_pwm.dev_attr.attr,
619 &sensor_dev_attr_temp1_auto_point17_pwm.dev_attr.attr,
620 &sensor_dev_attr_temp1_auto_point18_pwm.dev_attr.attr,
621 &sensor_dev_attr_temp1_auto_point19_pwm.dev_attr.attr,
622 &sensor_dev_attr_temp1_auto_point20_pwm.dev_attr.attr,
623 &sensor_dev_attr_temp1_auto_point21_pwm.dev_attr.attr,
624 &sensor_dev_attr_temp1_auto_point22_pwm.dev_attr.attr,
625 &sensor_dev_attr_temp1_auto_point23_pwm.dev_attr.attr,
626 &sensor_dev_attr_temp1_auto_point24_pwm.dev_attr.attr,
627 &sensor_dev_attr_temp1_auto_point25_pwm.dev_attr.attr,
628 &sensor_dev_attr_temp1_auto_point26_pwm.dev_attr.attr,
629 &sensor_dev_attr_temp1_auto_point27_pwm.dev_attr.attr,
630 &sensor_dev_attr_temp1_auto_point28_pwm.dev_attr.attr,
631 &sensor_dev_attr_temp1_auto_point29_pwm.dev_attr.attr,
632 &sensor_dev_attr_temp1_auto_point30_pwm.dev_attr.attr,
633 &sensor_dev_attr_temp1_auto_point31_pwm.dev_attr.attr,
634 &sensor_dev_attr_temp1_auto_point32_pwm.dev_attr.attr,
635 &sensor_dev_attr_temp1_auto_point33_pwm.dev_attr.attr,
636 &sensor_dev_attr_temp1_auto_point34_pwm.dev_attr.attr,
637 &sensor_dev_attr_temp1_auto_point35_pwm.dev_attr.attr,
638 &sensor_dev_attr_temp1_auto_point36_pwm.dev_attr.attr,
639 &sensor_dev_attr_temp1_auto_point37_pwm.dev_attr.attr,
640 &sensor_dev_attr_temp1_auto_point38_pwm.dev_attr.attr,
641 &sensor_dev_attr_temp1_auto_point39_pwm.dev_attr.attr,
642 &sensor_dev_attr_temp1_auto_point40_pwm.dev_attr.attr,
643 /* Fan control curve (Z53 only) */
644 &sensor_dev_attr_temp2_auto_point1_pwm.dev_attr.attr,
645 &sensor_dev_attr_temp2_auto_point2_pwm.dev_attr.attr,
646 &sensor_dev_attr_temp2_auto_point3_pwm.dev_attr.attr,
647 &sensor_dev_attr_temp2_auto_point4_pwm.dev_attr.attr,
648 &sensor_dev_attr_temp2_auto_point5_pwm.dev_attr.attr,
649 &sensor_dev_attr_temp2_auto_point6_pwm.dev_attr.attr,
650 &sensor_dev_attr_temp2_auto_point7_pwm.dev_attr.attr,
651 &sensor_dev_attr_temp2_auto_point8_pwm.dev_attr.attr,
652 &sensor_dev_attr_temp2_auto_point9_pwm.dev_attr.attr,
653 &sensor_dev_attr_temp2_auto_point10_pwm.dev_attr.attr,
654 &sensor_dev_attr_temp2_auto_point11_pwm.dev_attr.attr,
655 &sensor_dev_attr_temp2_auto_point12_pwm.dev_attr.attr,
656 &sensor_dev_attr_temp2_auto_point13_pwm.dev_attr.attr,
657 &sensor_dev_attr_temp2_auto_point14_pwm.dev_attr.attr,
658 &sensor_dev_attr_temp2_auto_point15_pwm.dev_attr.attr,
659 &sensor_dev_attr_temp2_auto_point16_pwm.dev_attr.attr,
660 &sensor_dev_attr_temp2_auto_point17_pwm.dev_attr.attr,
661 &sensor_dev_attr_temp2_auto_point18_pwm.dev_attr.attr,
662 &sensor_dev_attr_temp2_auto_point19_pwm.dev_attr.attr,
663 &sensor_dev_attr_temp2_auto_point20_pwm.dev_attr.attr,
664 &sensor_dev_attr_temp2_auto_point21_pwm.dev_attr.attr,
665 &sensor_dev_attr_temp2_auto_point22_pwm.dev_attr.attr,
666 &sensor_dev_attr_temp2_auto_point23_pwm.dev_attr.attr,
667 &sensor_dev_attr_temp2_auto_point24_pwm.dev_attr.attr,
668 &sensor_dev_attr_temp2_auto_point25_pwm.dev_attr.attr,
669 &sensor_dev_attr_temp2_auto_point26_pwm.dev_attr.attr,
670 &sensor_dev_attr_temp2_auto_point27_pwm.dev_attr.attr,
671 &sensor_dev_attr_temp2_auto_point28_pwm.dev_attr.attr,
672 &sensor_dev_attr_temp2_auto_point29_pwm.dev_attr.attr,
673 &sensor_dev_attr_temp2_auto_point30_pwm.dev_attr.attr,
674 &sensor_dev_attr_temp2_auto_point31_pwm.dev_attr.attr,
675 &sensor_dev_attr_temp2_auto_point32_pwm.dev_attr.attr,
676 &sensor_dev_attr_temp2_auto_point33_pwm.dev_attr.attr,
677 &sensor_dev_attr_temp2_auto_point34_pwm.dev_attr.attr,
678 &sensor_dev_attr_temp2_auto_point35_pwm.dev_attr.attr,
679 &sensor_dev_attr_temp2_auto_point36_pwm.dev_attr.attr,
680 &sensor_dev_attr_temp2_auto_point37_pwm.dev_attr.attr,
681 &sensor_dev_attr_temp2_auto_point38_pwm.dev_attr.attr,
682 &sensor_dev_attr_temp2_auto_point39_pwm.dev_attr.attr,
683 &sensor_dev_attr_temp2_auto_point40_pwm.dev_attr.attr,
684 NULL
685};
686
687static const struct attribute_group kraken3_curves_group = {
688 .attrs = kraken3_curve_attrs,
689 .is_visible = kraken3_curve_props_are_visible
690};
691
692static const struct attribute_group *kraken3_groups[] = {
693 &kraken3_curves_group,
694 NULL
695};
696
697static const struct hwmon_ops kraken3_hwmon_ops = {
698 .is_visible = kraken3_is_visible,
699 .read = kraken3_read,
700 .read_string = kraken3_read_string,
701 .write = kraken3_write
702};
703
704static const struct hwmon_channel_info *kraken3_info[] = {
705 HWMON_CHANNEL_INFO(temp,
706 HWMON_T_INPUT | HWMON_T_LABEL),
707 HWMON_CHANNEL_INFO(fan,
708 HWMON_F_INPUT | HWMON_F_LABEL,
709 HWMON_F_INPUT | HWMON_F_LABEL,
710 HWMON_F_INPUT | HWMON_F_LABEL,
711 HWMON_F_INPUT | HWMON_F_LABEL),
712 HWMON_CHANNEL_INFO(pwm,
713 HWMON_PWM_INPUT | HWMON_PWM_ENABLE,
714 HWMON_PWM_INPUT | HWMON_PWM_ENABLE),
715 NULL
716};
717
718static const struct hwmon_chip_info kraken3_chip_info = {
719 .ops = &kraken3_hwmon_ops,
720 .info = kraken3_info,
721};
722
723static int kraken3_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)
724{
725 struct kraken3_data *priv = hid_get_drvdata(hdev);
726 int i;
727
728 if (size < MIN_REPORT_LENGTH)
729 return 0;
730
731 if (report->id == FIRMWARE_REPORT_ID) {
732 /* Read firmware version */
733 for (i = 0; i < 3; i++)
734 priv->firmware_version[i] = data[FIRMWARE_VERSION_OFFSET + i];
735
736 if (!completion_done(&priv->fw_version_processed))
737 complete_all(&priv->fw_version_processed);
738
739 return 0;
740 }
741
742 if (report->id != STATUS_REPORT_ID)
743 return 0;
744
745 if (data[TEMP_SENSOR_START_OFFSET] == 0xff && data[TEMP_SENSOR_END_OFFSET] == 0xff) {
746 hid_err_once(hdev,
747 "firmware or device is possibly damaged (is SATA power connected?), not parsing reports\n");
748
749 /*
750 * Mark first X-series device report as received,
751 * as well as all for Z-series, if faulty.
752 */
753 spin_lock(&priv->status_completion_lock);
754 if (priv->kind != X53 || !completion_done(&priv->status_report_processed)) {
755 priv->is_device_faulty = true;
756 complete_all(&priv->status_report_processed);
757 }
758 spin_unlock(&priv->status_completion_lock);
759
760 return 0;
761 }
762
763 /* Received normal data */
764 priv->is_device_faulty = false;
765
766 /* Temperature and fan sensor readings */
767 priv->temp_input[0] =
768 data[TEMP_SENSOR_START_OFFSET] * 1000 + data[TEMP_SENSOR_END_OFFSET] * 100;
769
770 priv->fan_input[0] = get_unaligned_le16(data + PUMP_SPEED_OFFSET);
771 priv->channel_info[0].reported_duty = kraken3_percent_to_pwm(data[PUMP_DUTY_OFFSET]);
772
773 spin_lock(&priv->status_completion_lock);
774 if (priv->kind == X53 && !completion_done(&priv->status_report_processed)) {
775 /* Mark first X-series device report as received */
776 complete_all(&priv->status_report_processed);
777 } else if (priv->kind == Z53) {
778 /* Additional readings for Z53 */
779 priv->fan_input[1] = get_unaligned_le16(data + Z53_FAN_SPEED_OFFSET);
780 priv->channel_info[1].reported_duty =
781 kraken3_percent_to_pwm(data[Z53_FAN_DUTY_OFFSET]);
782
783 if (!completion_done(&priv->status_report_processed))
784 complete_all(&priv->status_report_processed);
785 }
786 spin_unlock(&priv->status_completion_lock);
787
788 priv->updated = jiffies;
789
790 return 0;
791}
792
793static int kraken3_init_device(struct hid_device *hdev)
794{
795 struct kraken3_data *priv = hid_get_drvdata(hdev);
796 int ret;
797
798 /* Set the polling interval */
799 ret = kraken3_write_expanded(priv, set_interval_cmd, SET_INTERVAL_CMD_LENGTH);
800 if (ret < 0)
801 return ret;
802
803 /* Finalize the init process */
804 ret = kraken3_write_expanded(priv, finish_init_cmd, FINISH_INIT_CMD_LENGTH);
805 if (ret < 0)
806 return ret;
807
808 return 0;
809}
810
811static int kraken3_get_fw_ver(struct hid_device *hdev)
812{
813 struct kraken3_data *priv = hid_get_drvdata(hdev);
814 int ret;
815
816 ret = kraken3_write_expanded(priv, get_fw_version_cmd, GET_FW_VERSION_CMD_LENGTH);
817 if (ret < 0)
818 return ret;
819
820 ret = wait_for_completion_interruptible_timeout(&priv->fw_version_processed,
821 msecs_to_jiffies(STATUS_VALIDITY));
822 if (ret == 0)
823 return -ETIMEDOUT;
824 else if (ret < 0)
825 return ret;
826
827 return 0;
828}
829
830static int __maybe_unused kraken3_reset_resume(struct hid_device *hdev)
831{
832 int ret;
833
834 ret = kraken3_init_device(hdev);
835 if (ret)
836 hid_err(hdev, "req init (reset_resume) failed with %d\n", ret);
837
838 return ret;
839}
840
841static int firmware_version_show(struct seq_file *seqf, void *unused)
842{
843 struct kraken3_data *priv = seqf->private;
844
845 seq_printf(seqf, "%u.%u.%u\n", priv->firmware_version[0], priv->firmware_version[1],
846 priv->firmware_version[2]);
847
848 return 0;
849}
850DEFINE_SHOW_ATTRIBUTE(firmware_version);
851
852static void kraken3_debugfs_init(struct kraken3_data *priv)
853{
854 char name[64];
855
856 if (!priv->firmware_version[0])
857 return; /* Nothing to display in debugfs */
858
859 scnprintf(name, sizeof(name), "%s_%s-%s", DRIVER_NAME, kraken3_device_names[priv->kind],
860 dev_name(&priv->hdev->dev));
861
862 priv->debugfs = debugfs_create_dir(name, NULL);
863 debugfs_create_file("firmware_version", 0444, priv->debugfs, priv, &firmware_version_fops);
864}
865
866static int kraken3_probe(struct hid_device *hdev, const struct hid_device_id *id)
867{
868 struct kraken3_data *priv;
869 int ret;
870
871 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
872 if (!priv)
873 return -ENOMEM;
874
875 priv->hdev = hdev;
876 hid_set_drvdata(hdev, priv);
877
878 /*
879 * Initialize ->updated to STATUS_VALIDITY seconds in the past, making
880 * the initial empty data invalid for kraken3_read without the need for
881 * a special case there.
882 */
883 priv->updated = jiffies - msecs_to_jiffies(STATUS_VALIDITY);
884
885 ret = hid_parse(hdev);
886 if (ret) {
887 hid_err(hdev, "hid parse failed with %d\n", ret);
888 return ret;
889 }
890
891 /* Enable hidraw so existing user-space tools can continue to work */
892 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
893 if (ret) {
894 hid_err(hdev, "hid hw start failed with %d\n", ret);
895 return ret;
896 }
897
898 ret = hid_hw_open(hdev);
899 if (ret) {
900 hid_err(hdev, "hid hw open failed with %d\n", ret);
901 goto fail_and_stop;
902 }
903
904 switch (hdev->product) {
905 case USB_PRODUCT_ID_X53:
906 case USB_PRODUCT_ID_X53_SECOND:
907 priv->kind = X53;
908 break;
909 case USB_PRODUCT_ID_Z53:
910 priv->kind = Z53;
911 break;
912 default:
913 break;
914 }
915
916 priv->buffer = devm_kzalloc(&hdev->dev, MAX_REPORT_LENGTH, GFP_KERNEL);
917 if (!priv->buffer) {
918 ret = -ENOMEM;
919 goto fail_and_close;
920 }
921
922 mutex_init(&priv->buffer_lock);
923 mutex_init(&priv->z53_status_request_lock);
924 init_completion(&priv->fw_version_processed);
925 init_completion(&priv->status_report_processed);
926 spin_lock_init(&priv->status_completion_lock);
927
928 hid_device_io_start(hdev);
929 ret = kraken3_init_device(hdev);
930 if (ret < 0) {
931 hid_err(hdev, "device init failed with %d\n", ret);
932 goto fail_and_close;
933 }
934
935 ret = kraken3_get_fw_ver(hdev);
936 if (ret < 0)
937 hid_warn(hdev, "fw version request failed with %d\n", ret);
938
939 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev,
940 kraken3_device_names[priv->kind], priv,
941 &kraken3_chip_info, kraken3_groups);
942 if (IS_ERR(priv->hwmon_dev)) {
943 ret = PTR_ERR(priv->hwmon_dev);
944 hid_err(hdev, "hwmon registration failed with %d\n", ret);
945 goto fail_and_close;
946 }
947
948 kraken3_debugfs_init(priv);
949
950 return 0;
951
952fail_and_close:
953 hid_hw_close(hdev);
954fail_and_stop:
955 hid_hw_stop(hdev);
956 return ret;
957}
958
959static void kraken3_remove(struct hid_device *hdev)
960{
961 struct kraken3_data *priv = hid_get_drvdata(hdev);
962
963 debugfs_remove_recursive(priv->debugfs);
964 hwmon_device_unregister(priv->hwmon_dev);
965
966 hid_hw_close(hdev);
967 hid_hw_stop(hdev);
968}
969
970static const struct hid_device_id kraken3_table[] = {
971 /* NZXT Kraken X53/X63/X73 have two possible product IDs */
972 { HID_USB_DEVICE(USB_VENDOR_ID_NZXT, USB_PRODUCT_ID_X53) },
973 { HID_USB_DEVICE(USB_VENDOR_ID_NZXT, USB_PRODUCT_ID_X53_SECOND) },
974 { HID_USB_DEVICE(USB_VENDOR_ID_NZXT, USB_PRODUCT_ID_Z53) },
975 { }
976};
977
978MODULE_DEVICE_TABLE(hid, kraken3_table);
979
980static struct hid_driver kraken3_driver = {
981 .name = DRIVER_NAME,
982 .id_table = kraken3_table,
983 .probe = kraken3_probe,
984 .remove = kraken3_remove,
985 .raw_event = kraken3_raw_event,
986#ifdef CONFIG_PM
987 .reset_resume = kraken3_reset_resume,
988#endif
989};
990
991static int __init kraken3_init(void)
992{
993 return hid_register_driver(&kraken3_driver);
994}
995
996static void __exit kraken3_exit(void)
997{
998 hid_unregister_driver(&kraken3_driver);
999}
1000
1001/* When compiled into the kernel, initialize after the HID bus */
1002late_initcall(kraken3_init);
1003module_exit(kraken3_exit);
1004
1005MODULE_LICENSE("GPL");
1006MODULE_AUTHOR("Jonas Malaco <jonas@protocubo.io>");
1007MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
1008MODULE_DESCRIPTION("Hwmon driver for NZXT Kraken X53/X63/X73, Z53/Z63/Z73 coolers");