projects/linux·blob master · refs

1037 lines · 33.4 KiB

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