1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * nzxt-kraken2.c - hwmon driver for NZXT Kraken X42/X52/X62/X72 coolers
4  *
5  * The device asynchronously sends HID reports (with id 0x04) twice a second to
6  * communicate current fan speed, pump speed and coolant temperature.  The
7  * device does not respond to Get_Report requests for this status report.
8  *
9  * Copyright 2019-2021  Jonas Malaco <jonas@protocubo.io>
10  */
11 
12 #include <asm/unaligned.h>
13 #include <linux/hid.h>
14 #include <linux/hwmon.h>
15 #include <linux/jiffies.h>
16 #include <linux/module.h>
17 
18 #define STATUS_REPORT_ID	0x04
19 #define STATUS_VALIDITY		2 /* seconds; equivalent to 4 missed updates */
20 
21 static const char *const kraken2_temp_label[] = {
22 	"Coolant",
23 };
24 
25 static const char *const kraken2_fan_label[] = {
26 	"Fan",
27 	"Pump",
28 };
29 
30 struct kraken2_priv_data {
31 	struct hid_device *hid_dev;
32 	struct device *hwmon_dev;
33 	s32 temp_input[1];
34 	u16 fan_input[2];
35 	unsigned long updated; /* jiffies */
36 };
37 
kraken2_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)38 static umode_t kraken2_is_visible(const void *data,
39 				  enum hwmon_sensor_types type,
40 				  u32 attr, int channel)
41 {
42 	return 0444;
43 }
44 
kraken2_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)45 static int kraken2_read(struct device *dev, enum hwmon_sensor_types type,
46 			u32 attr, int channel, long *val)
47 {
48 	struct kraken2_priv_data *priv = dev_get_drvdata(dev);
49 
50 	if (time_after(jiffies, priv->updated + STATUS_VALIDITY * HZ))
51 		return -ENODATA;
52 
53 	switch (type) {
54 	case hwmon_temp:
55 		*val = priv->temp_input[channel];
56 		break;
57 	case hwmon_fan:
58 		*val = priv->fan_input[channel];
59 		break;
60 	default:
61 		return -EOPNOTSUPP; /* unreachable */
62 	}
63 
64 	return 0;
65 }
66 
kraken2_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)67 static int kraken2_read_string(struct device *dev, enum hwmon_sensor_types type,
68 			       u32 attr, int channel, const char **str)
69 {
70 	switch (type) {
71 	case hwmon_temp:
72 		*str = kraken2_temp_label[channel];
73 		break;
74 	case hwmon_fan:
75 		*str = kraken2_fan_label[channel];
76 		break;
77 	default:
78 		return -EOPNOTSUPP; /* unreachable */
79 	}
80 	return 0;
81 }
82 
83 static const struct hwmon_ops kraken2_hwmon_ops = {
84 	.is_visible = kraken2_is_visible,
85 	.read = kraken2_read,
86 	.read_string = kraken2_read_string,
87 };
88 
89 static const struct hwmon_channel_info *kraken2_info[] = {
90 	HWMON_CHANNEL_INFO(temp,
91 			   HWMON_T_INPUT | HWMON_T_LABEL),
92 	HWMON_CHANNEL_INFO(fan,
93 			   HWMON_F_INPUT | HWMON_F_LABEL,
94 			   HWMON_F_INPUT | HWMON_F_LABEL),
95 	NULL
96 };
97 
98 static const struct hwmon_chip_info kraken2_chip_info = {
99 	.ops = &kraken2_hwmon_ops,
100 	.info = kraken2_info,
101 };
102 
kraken2_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)103 static int kraken2_raw_event(struct hid_device *hdev,
104 			     struct hid_report *report, u8 *data, int size)
105 {
106 	struct kraken2_priv_data *priv;
107 
108 	if (size < 7 || report->id != STATUS_REPORT_ID)
109 		return 0;
110 
111 	priv = hid_get_drvdata(hdev);
112 
113 	/*
114 	 * The fractional byte of the coolant temperature has been observed to
115 	 * be in the interval [1,9], but some of these steps are also
116 	 * consistently skipped for certain integer parts.
117 	 *
118 	 * For the lack of a better idea, assume that the resolution is 0.1°C,
119 	 * and that the missing steps are artifacts of how the firmware
120 	 * processes the raw sensor data.
121 	 */
122 	priv->temp_input[0] = data[1] * 1000 + data[2] * 100;
123 
124 	priv->fan_input[0] = get_unaligned_be16(data + 3);
125 	priv->fan_input[1] = get_unaligned_be16(data + 5);
126 
127 	priv->updated = jiffies;
128 
129 	return 0;
130 }
131 
kraken2_probe(struct hid_device * hdev,const struct hid_device_id * id)132 static int kraken2_probe(struct hid_device *hdev,
133 			 const struct hid_device_id *id)
134 {
135 	struct kraken2_priv_data *priv;
136 	int ret;
137 
138 	priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
139 	if (!priv)
140 		return -ENOMEM;
141 
142 	priv->hid_dev = hdev;
143 	hid_set_drvdata(hdev, priv);
144 
145 	/*
146 	 * Initialize ->updated to STATUS_VALIDITY seconds in the past, making
147 	 * the initial empty data invalid for kraken2_read without the need for
148 	 * a special case there.
149 	 */
150 	priv->updated = jiffies - STATUS_VALIDITY * HZ;
151 
152 	ret = hid_parse(hdev);
153 	if (ret) {
154 		hid_err(hdev, "hid parse failed with %d\n", ret);
155 		return ret;
156 	}
157 
158 	/*
159 	 * Enable hidraw so existing user-space tools can continue to work.
160 	 */
161 	ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
162 	if (ret) {
163 		hid_err(hdev, "hid hw start failed with %d\n", ret);
164 		goto fail_and_stop;
165 	}
166 
167 	ret = hid_hw_open(hdev);
168 	if (ret) {
169 		hid_err(hdev, "hid hw open failed with %d\n", ret);
170 		goto fail_and_close;
171 	}
172 
173 	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "kraken2",
174 							  priv, &kraken2_chip_info,
175 							  NULL);
176 	if (IS_ERR(priv->hwmon_dev)) {
177 		ret = PTR_ERR(priv->hwmon_dev);
178 		hid_err(hdev, "hwmon registration failed with %d\n", ret);
179 		goto fail_and_close;
180 	}
181 
182 	return 0;
183 
184 fail_and_close:
185 	hid_hw_close(hdev);
186 fail_and_stop:
187 	hid_hw_stop(hdev);
188 	return ret;
189 }
190 
kraken2_remove(struct hid_device * hdev)191 static void kraken2_remove(struct hid_device *hdev)
192 {
193 	struct kraken2_priv_data *priv = hid_get_drvdata(hdev);
194 
195 	hwmon_device_unregister(priv->hwmon_dev);
196 
197 	hid_hw_close(hdev);
198 	hid_hw_stop(hdev);
199 }
200 
201 static const struct hid_device_id kraken2_table[] = {
202 	{ HID_USB_DEVICE(0x1e71, 0x170e) }, /* NZXT Kraken X42/X52/X62/X72 */
203 	{ }
204 };
205 
206 MODULE_DEVICE_TABLE(hid, kraken2_table);
207 
208 static struct hid_driver kraken2_driver = {
209 	.name = "nzxt-kraken2",
210 	.id_table = kraken2_table,
211 	.probe = kraken2_probe,
212 	.remove = kraken2_remove,
213 	.raw_event = kraken2_raw_event,
214 };
215 
kraken2_init(void)216 static int __init kraken2_init(void)
217 {
218 	return hid_register_driver(&kraken2_driver);
219 }
220 
kraken2_exit(void)221 static void __exit kraken2_exit(void)
222 {
223 	hid_unregister_driver(&kraken2_driver);
224 }
225 
226 /*
227  * When compiled into the kernel, initialize after the hid bus.
228  */
229 late_initcall(kraken2_init);
230 module_exit(kraken2_exit);
231 
232 MODULE_LICENSE("GPL");
233 MODULE_AUTHOR("Jonas Malaco <jonas@protocubo.io>");
234 MODULE_DESCRIPTION("Hwmon driver for NZXT Kraken X42/X52/X62/X72 coolers");
235