1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * hwmon driver for Asus ROG Ryujin II 360 AIO cooler.
4 *
5 * Copyright 2024 Aleksa Savic <savicaleksa83@gmail.com>
6 */
7
8 #include <linux/debugfs.h>
9 #include <linux/hid.h>
10 #include <linux/hwmon.h>
11 #include <linux/jiffies.h>
12 #include <linux/module.h>
13 #include <linux/spinlock.h>
14 #include <linux/unaligned.h>
15
16 #define DRIVER_NAME "asus_rog_ryujin"
17
18 #define USB_VENDOR_ID_ASUS_ROG 0x0b05
19 #define USB_PRODUCT_ID_RYUJIN_AIO 0x1988 /* ASUS ROG RYUJIN II 360 */
20
21 #define STATUS_VALIDITY 1500 /* ms */
22 #define MAX_REPORT_LENGTH 65
23
24 /* Cooler status report offsets */
25 #define RYUJIN_TEMP_SENSOR_1 3
26 #define RYUJIN_TEMP_SENSOR_2 4
27 #define RYUJIN_PUMP_SPEED 5
28 #define RYUJIN_INTERNAL_FAN_SPEED 7
29
30 /* Cooler duty report offsets */
31 #define RYUJIN_PUMP_DUTY 4
32 #define RYUJIN_INTERNAL_FAN_DUTY 5
33
34 /* Controller status (speeds) report offsets */
35 #define RYUJIN_CONTROLLER_SPEED_1 5
36 #define RYUJIN_CONTROLLER_SPEED_2 7
37 #define RYUJIN_CONTROLLER_SPEED_3 9
38 #define RYUJIN_CONTROLLER_SPEED_4 3
39
40 /* Controller duty report offsets */
41 #define RYUJIN_CONTROLLER_DUTY 4
42
43 /* Control commands and their inner offsets */
44 #define RYUJIN_CMD_PREFIX 0xEC
45
46 static const u8 get_cooler_status_cmd[] = { RYUJIN_CMD_PREFIX, 0x99 };
47 static const u8 get_cooler_duty_cmd[] = { RYUJIN_CMD_PREFIX, 0x9A };
48 static const u8 get_controller_speed_cmd[] = { RYUJIN_CMD_PREFIX, 0xA0 };
49 static const u8 get_controller_duty_cmd[] = { RYUJIN_CMD_PREFIX, 0xA1 };
50
51 #define RYUJIN_SET_COOLER_PUMP_DUTY_OFFSET 3
52 #define RYUJIN_SET_COOLER_FAN_DUTY_OFFSET 4
53 static const u8 set_cooler_duty_cmd[] = { RYUJIN_CMD_PREFIX, 0x1A, 0x00, 0x00, 0x00 };
54
55 #define RYUJIN_SET_CONTROLLER_FAN_DUTY_OFFSET 4
56 static const u8 set_controller_duty_cmd[] = { RYUJIN_CMD_PREFIX, 0x21, 0x00, 0x00, 0x00 };
57
58 /* Command lengths */
59 #define GET_CMD_LENGTH 2 /* Same length for all get commands */
60 #define SET_CMD_LENGTH 5 /* Same length for all set commands */
61
62 /* Command response headers */
63 #define RYUJIN_GET_COOLER_STATUS_CMD_RESPONSE 0x19
64 #define RYUJIN_GET_COOLER_DUTY_CMD_RESPONSE 0x1A
65 #define RYUJIN_GET_CONTROLLER_SPEED_CMD_RESPONSE 0x20
66 #define RYUJIN_GET_CONTROLLER_DUTY_CMD_RESPONSE 0x21
67
68 static const char *const rog_ryujin_temp_label[] = {
69 "Coolant temp"
70 };
71
72 static const char *const rog_ryujin_speed_label[] = {
73 "Pump speed",
74 "Internal fan speed",
75 "Controller fan 1 speed",
76 "Controller fan 2 speed",
77 "Controller fan 3 speed",
78 "Controller fan 4 speed",
79 };
80
81 struct rog_ryujin_data {
82 struct hid_device *hdev;
83 struct device *hwmon_dev;
84 /* For locking access to buffer */
85 struct mutex buffer_lock;
86 /* For queueing multiple readers */
87 struct mutex status_report_request_mutex;
88 /* For reinitializing the completions below */
89 spinlock_t status_report_request_lock;
90 struct completion cooler_status_received;
91 struct completion controller_status_received;
92 struct completion cooler_duty_received;
93 struct completion controller_duty_received;
94 struct completion cooler_duty_set;
95 struct completion controller_duty_set;
96
97 /* Sensor data */
98 s32 temp_input[1];
99 u16 speed_input[6]; /* Pump, internal fan and four controller fan speeds in RPM */
100 u8 duty_input[3]; /* Pump, internal fan and controller fan duty in PWM */
101
102 u8 *buffer;
103 unsigned long updated; /* jiffies */
104 };
105
rog_ryujin_percent_to_pwm(u16 val)106 static int rog_ryujin_percent_to_pwm(u16 val)
107 {
108 return DIV_ROUND_CLOSEST(val * 255, 100);
109 }
110
rog_ryujin_pwm_to_percent(long val)111 static int rog_ryujin_pwm_to_percent(long val)
112 {
113 return DIV_ROUND_CLOSEST(val * 100, 255);
114 }
115
rog_ryujin_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)116 static umode_t rog_ryujin_is_visible(const void *data,
117 enum hwmon_sensor_types type, u32 attr, int channel)
118 {
119 switch (type) {
120 case hwmon_temp:
121 switch (attr) {
122 case hwmon_temp_label:
123 case hwmon_temp_input:
124 return 0444;
125 default:
126 break;
127 }
128 break;
129 case hwmon_fan:
130 switch (attr) {
131 case hwmon_fan_label:
132 case hwmon_fan_input:
133 return 0444;
134 default:
135 break;
136 }
137 break;
138 case hwmon_pwm:
139 switch (attr) {
140 case hwmon_pwm_input:
141 return 0644;
142 default:
143 break;
144 }
145 break;
146 default:
147 break;
148 }
149
150 return 0;
151 }
152
153 /* Writes the command to the device with the rest of the report filled with zeroes */
rog_ryujin_write_expanded(struct rog_ryujin_data * priv,const u8 * cmd,int cmd_length)154 static int rog_ryujin_write_expanded(struct rog_ryujin_data *priv, const u8 *cmd, int cmd_length)
155 {
156 int ret;
157
158 mutex_lock(&priv->buffer_lock);
159
160 memcpy_and_pad(priv->buffer, MAX_REPORT_LENGTH, cmd, cmd_length, 0x00);
161 ret = hid_hw_output_report(priv->hdev, priv->buffer, MAX_REPORT_LENGTH);
162
163 mutex_unlock(&priv->buffer_lock);
164 return ret;
165 }
166
167 /* Assumes priv->status_report_request_mutex is locked */
rog_ryujin_execute_cmd(struct rog_ryujin_data * priv,const u8 * cmd,int cmd_length,struct completion * status_completion)168 static int rog_ryujin_execute_cmd(struct rog_ryujin_data *priv, const u8 *cmd, int cmd_length,
169 struct completion *status_completion)
170 {
171 int ret;
172
173 /*
174 * Disable raw event parsing for a moment to safely reinitialize the
175 * completion. Reinit is done because hidraw could have triggered
176 * the raw event parsing and marked the passed in completion as done.
177 */
178 spin_lock_bh(&priv->status_report_request_lock);
179 reinit_completion(status_completion);
180 spin_unlock_bh(&priv->status_report_request_lock);
181
182 /* Send command for getting data */
183 ret = rog_ryujin_write_expanded(priv, cmd, cmd_length);
184 if (ret < 0)
185 return ret;
186
187 ret = wait_for_completion_interruptible_timeout(status_completion,
188 msecs_to_jiffies(STATUS_VALIDITY));
189 if (ret == 0)
190 return -ETIMEDOUT;
191 else if (ret < 0)
192 return ret;
193
194 return 0;
195 }
196
rog_ryujin_get_status(struct rog_ryujin_data * priv)197 static int rog_ryujin_get_status(struct rog_ryujin_data *priv)
198 {
199 int ret = mutex_lock_interruptible(&priv->status_report_request_mutex);
200
201 if (ret < 0)
202 return ret;
203
204 if (!time_after(jiffies, priv->updated + msecs_to_jiffies(STATUS_VALIDITY))) {
205 /* Data is up to date */
206 goto unlock_and_return;
207 }
208
209 /* Retrieve cooler status */
210 ret =
211 rog_ryujin_execute_cmd(priv, get_cooler_status_cmd, GET_CMD_LENGTH,
212 &priv->cooler_status_received);
213 if (ret < 0)
214 goto unlock_and_return;
215
216 /* Retrieve controller status (speeds) */
217 ret =
218 rog_ryujin_execute_cmd(priv, get_controller_speed_cmd, GET_CMD_LENGTH,
219 &priv->controller_status_received);
220 if (ret < 0)
221 goto unlock_and_return;
222
223 /* Retrieve cooler duty */
224 ret =
225 rog_ryujin_execute_cmd(priv, get_cooler_duty_cmd, GET_CMD_LENGTH,
226 &priv->cooler_duty_received);
227 if (ret < 0)
228 goto unlock_and_return;
229
230 /* Retrieve controller duty */
231 ret =
232 rog_ryujin_execute_cmd(priv, get_controller_duty_cmd, GET_CMD_LENGTH,
233 &priv->controller_duty_received);
234 if (ret < 0)
235 goto unlock_and_return;
236
237 priv->updated = jiffies;
238
239 unlock_and_return:
240 mutex_unlock(&priv->status_report_request_mutex);
241 if (ret < 0)
242 return ret;
243
244 return 0;
245 }
246
rog_ryujin_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)247 static int rog_ryujin_read(struct device *dev, enum hwmon_sensor_types type,
248 u32 attr, int channel, long *val)
249 {
250 struct rog_ryujin_data *priv = dev_get_drvdata(dev);
251 int ret = rog_ryujin_get_status(priv);
252
253 if (ret < 0)
254 return ret;
255
256 switch (type) {
257 case hwmon_temp:
258 *val = priv->temp_input[channel];
259 break;
260 case hwmon_fan:
261 *val = priv->speed_input[channel];
262 break;
263 case hwmon_pwm:
264 switch (attr) {
265 case hwmon_pwm_input:
266 *val = priv->duty_input[channel];
267 break;
268 default:
269 return -EOPNOTSUPP;
270 }
271 break;
272 default:
273 return -EOPNOTSUPP; /* unreachable */
274 }
275
276 return 0;
277 }
278
rog_ryujin_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)279 static int rog_ryujin_read_string(struct device *dev, enum hwmon_sensor_types type,
280 u32 attr, int channel, const char **str)
281 {
282 switch (type) {
283 case hwmon_temp:
284 *str = rog_ryujin_temp_label[channel];
285 break;
286 case hwmon_fan:
287 *str = rog_ryujin_speed_label[channel];
288 break;
289 default:
290 return -EOPNOTSUPP; /* unreachable */
291 }
292
293 return 0;
294 }
295
rog_ryujin_write_fixed_duty(struct rog_ryujin_data * priv,int channel,int val)296 static int rog_ryujin_write_fixed_duty(struct rog_ryujin_data *priv, int channel, int val)
297 {
298 u8 set_cmd[SET_CMD_LENGTH];
299 int ret;
300
301 if (channel < 2) {
302 /*
303 * Retrieve cooler duty since both pump and internal fan are set
304 * together, then write back with one of them modified.
305 */
306 ret = mutex_lock_interruptible(&priv->status_report_request_mutex);
307 if (ret < 0)
308 return ret;
309 ret =
310 rog_ryujin_execute_cmd(priv, get_cooler_duty_cmd, GET_CMD_LENGTH,
311 &priv->cooler_duty_received);
312 if (ret < 0)
313 goto unlock_and_return;
314
315 memcpy(set_cmd, set_cooler_duty_cmd, SET_CMD_LENGTH);
316
317 /* Cooler duties are set as 0-100% */
318 val = rog_ryujin_pwm_to_percent(val);
319
320 if (channel == 0) {
321 /* Cooler pump duty */
322 set_cmd[RYUJIN_SET_COOLER_PUMP_DUTY_OFFSET] = val;
323 set_cmd[RYUJIN_SET_COOLER_FAN_DUTY_OFFSET] =
324 rog_ryujin_pwm_to_percent(priv->duty_input[1]);
325 } else if (channel == 1) {
326 /* Cooler internal fan duty */
327 set_cmd[RYUJIN_SET_COOLER_PUMP_DUTY_OFFSET] =
328 rog_ryujin_pwm_to_percent(priv->duty_input[0]);
329 set_cmd[RYUJIN_SET_COOLER_FAN_DUTY_OFFSET] = val;
330 }
331
332 ret = rog_ryujin_execute_cmd(priv, set_cmd, SET_CMD_LENGTH, &priv->cooler_duty_set);
333 unlock_and_return:
334 mutex_unlock(&priv->status_report_request_mutex);
335 if (ret < 0)
336 return ret;
337 } else {
338 /*
339 * Controller fan duty (channel == 2). No need to retrieve current
340 * duty, so just send the command.
341 */
342 memcpy(set_cmd, set_controller_duty_cmd, SET_CMD_LENGTH);
343 set_cmd[RYUJIN_SET_CONTROLLER_FAN_DUTY_OFFSET] = val;
344
345 ret =
346 rog_ryujin_execute_cmd(priv, set_cmd, SET_CMD_LENGTH,
347 &priv->controller_duty_set);
348 if (ret < 0)
349 return ret;
350 }
351
352 /* Lock onto this value until next refresh cycle */
353 priv->duty_input[channel] = val;
354
355 return 0;
356 }
357
rog_ryujin_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)358 static int rog_ryujin_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
359 long val)
360 {
361 struct rog_ryujin_data *priv = dev_get_drvdata(dev);
362 int ret;
363
364 switch (type) {
365 case hwmon_pwm:
366 switch (attr) {
367 case hwmon_pwm_input:
368 if (val < 0 || val > 255)
369 return -EINVAL;
370
371 ret = rog_ryujin_write_fixed_duty(priv, channel, val);
372 if (ret < 0)
373 return ret;
374 break;
375 default:
376 return -EOPNOTSUPP;
377 }
378 break;
379 default:
380 return -EOPNOTSUPP;
381 }
382
383 return 0;
384 }
385
386 static const struct hwmon_ops rog_ryujin_hwmon_ops = {
387 .is_visible = rog_ryujin_is_visible,
388 .read = rog_ryujin_read,
389 .read_string = rog_ryujin_read_string,
390 .write = rog_ryujin_write
391 };
392
393 static const struct hwmon_channel_info *rog_ryujin_info[] = {
394 HWMON_CHANNEL_INFO(temp,
395 HWMON_T_INPUT | HWMON_T_LABEL),
396 HWMON_CHANNEL_INFO(fan,
397 HWMON_F_INPUT | HWMON_F_LABEL,
398 HWMON_F_INPUT | HWMON_F_LABEL,
399 HWMON_F_INPUT | HWMON_F_LABEL,
400 HWMON_F_INPUT | HWMON_F_LABEL,
401 HWMON_F_INPUT | HWMON_F_LABEL,
402 HWMON_F_INPUT | HWMON_F_LABEL),
403 HWMON_CHANNEL_INFO(pwm,
404 HWMON_PWM_INPUT,
405 HWMON_PWM_INPUT,
406 HWMON_PWM_INPUT),
407 NULL
408 };
409
410 static const struct hwmon_chip_info rog_ryujin_chip_info = {
411 .ops = &rog_ryujin_hwmon_ops,
412 .info = rog_ryujin_info,
413 };
414
rog_ryujin_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)415 static int rog_ryujin_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data,
416 int size)
417 {
418 struct rog_ryujin_data *priv = hid_get_drvdata(hdev);
419
420 if (data[0] != RYUJIN_CMD_PREFIX)
421 return 0;
422
423 if (data[1] == RYUJIN_GET_COOLER_STATUS_CMD_RESPONSE) {
424 /* Received coolant temp and speeds of pump and internal fan */
425 priv->temp_input[0] =
426 data[RYUJIN_TEMP_SENSOR_1] * 1000 + data[RYUJIN_TEMP_SENSOR_2] * 100;
427 priv->speed_input[0] = get_unaligned_le16(data + RYUJIN_PUMP_SPEED);
428 priv->speed_input[1] = get_unaligned_le16(data + RYUJIN_INTERNAL_FAN_SPEED);
429
430 if (!completion_done(&priv->cooler_status_received))
431 complete_all(&priv->cooler_status_received);
432 } else if (data[1] == RYUJIN_GET_CONTROLLER_SPEED_CMD_RESPONSE) {
433 /* Received speeds of four fans attached to the controller */
434 priv->speed_input[2] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_1);
435 priv->speed_input[3] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_2);
436 priv->speed_input[4] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_3);
437 priv->speed_input[5] = get_unaligned_le16(data + RYUJIN_CONTROLLER_SPEED_4);
438
439 if (!completion_done(&priv->controller_status_received))
440 complete_all(&priv->controller_status_received);
441 } else if (data[1] == RYUJIN_GET_COOLER_DUTY_CMD_RESPONSE) {
442 /* Received report for pump and internal fan duties (in %) */
443 if (data[RYUJIN_PUMP_DUTY] == 0 && data[RYUJIN_INTERNAL_FAN_DUTY] == 0) {
444 /*
445 * We received a report with zeroes for duty in both places.
446 * The device returns this as a confirmation that setting values
447 * is successful. If we initiated a write, mark it as complete.
448 */
449 if (!completion_done(&priv->cooler_duty_set))
450 complete_all(&priv->cooler_duty_set);
451 else if (!completion_done(&priv->cooler_duty_received))
452 /*
453 * We didn't initiate a write, but received both zeroes.
454 * This means that either both duties are actually zero,
455 * or that we received a success report caused by userspace.
456 * We're expecting a report, so parse it.
457 */
458 goto read_cooler_duty;
459 return 0;
460 }
461 read_cooler_duty:
462 priv->duty_input[0] = rog_ryujin_percent_to_pwm(data[RYUJIN_PUMP_DUTY]);
463 priv->duty_input[1] = rog_ryujin_percent_to_pwm(data[RYUJIN_INTERNAL_FAN_DUTY]);
464
465 if (!completion_done(&priv->cooler_duty_received))
466 complete_all(&priv->cooler_duty_received);
467 } else if (data[1] == RYUJIN_GET_CONTROLLER_DUTY_CMD_RESPONSE) {
468 /* Received report for controller duty for fans (in PWM) */
469 if (data[RYUJIN_CONTROLLER_DUTY] == 0) {
470 /*
471 * We received a report with a zero for duty. The device returns this as
472 * a confirmation that setting the controller duty value was successful.
473 * If we initiated a write, mark it as complete.
474 */
475 if (!completion_done(&priv->controller_duty_set))
476 complete_all(&priv->controller_duty_set);
477 else if (!completion_done(&priv->controller_duty_received))
478 /*
479 * We didn't initiate a write, but received a zero for duty.
480 * This means that either the duty is actually zero, or that
481 * we received a success report caused by userspace.
482 * We're expecting a report, so parse it.
483 */
484 goto read_controller_duty;
485 return 0;
486 }
487 read_controller_duty:
488 priv->duty_input[2] = data[RYUJIN_CONTROLLER_DUTY];
489
490 if (!completion_done(&priv->controller_duty_received))
491 complete_all(&priv->controller_duty_received);
492 }
493
494 return 0;
495 }
496
rog_ryujin_probe(struct hid_device * hdev,const struct hid_device_id * id)497 static int rog_ryujin_probe(struct hid_device *hdev, const struct hid_device_id *id)
498 {
499 struct rog_ryujin_data *priv;
500 int ret;
501
502 priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
503 if (!priv)
504 return -ENOMEM;
505
506 priv->hdev = hdev;
507 hid_set_drvdata(hdev, priv);
508
509 /*
510 * Initialize priv->updated to STATUS_VALIDITY seconds in the past, making
511 * the initial empty data invalid for rog_ryujin_read() without the need for
512 * a special case there.
513 */
514 priv->updated = jiffies - msecs_to_jiffies(STATUS_VALIDITY);
515
516 ret = hid_parse(hdev);
517 if (ret) {
518 hid_err(hdev, "hid parse failed with %d\n", ret);
519 return ret;
520 }
521
522 /* Enable hidraw so existing user-space tools can continue to work */
523 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
524 if (ret) {
525 hid_err(hdev, "hid hw start failed with %d\n", ret);
526 return ret;
527 }
528
529 ret = hid_hw_open(hdev);
530 if (ret) {
531 hid_err(hdev, "hid hw open failed with %d\n", ret);
532 goto fail_and_stop;
533 }
534
535 priv->buffer = devm_kzalloc(&hdev->dev, MAX_REPORT_LENGTH, GFP_KERNEL);
536 if (!priv->buffer) {
537 ret = -ENOMEM;
538 goto fail_and_close;
539 }
540
541 mutex_init(&priv->status_report_request_mutex);
542 mutex_init(&priv->buffer_lock);
543 spin_lock_init(&priv->status_report_request_lock);
544 init_completion(&priv->cooler_status_received);
545 init_completion(&priv->controller_status_received);
546 init_completion(&priv->cooler_duty_received);
547 init_completion(&priv->controller_duty_received);
548 init_completion(&priv->cooler_duty_set);
549 init_completion(&priv->controller_duty_set);
550
551 priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "rog_ryujin",
552 priv, &rog_ryujin_chip_info, NULL);
553 if (IS_ERR(priv->hwmon_dev)) {
554 ret = PTR_ERR(priv->hwmon_dev);
555 hid_err(hdev, "hwmon registration failed with %d\n", ret);
556 goto fail_and_close;
557 }
558
559 return 0;
560
561 fail_and_close:
562 hid_hw_close(hdev);
563 fail_and_stop:
564 hid_hw_stop(hdev);
565 return ret;
566 }
567
rog_ryujin_remove(struct hid_device * hdev)568 static void rog_ryujin_remove(struct hid_device *hdev)
569 {
570 struct rog_ryujin_data *priv = hid_get_drvdata(hdev);
571
572 hwmon_device_unregister(priv->hwmon_dev);
573
574 hid_hw_close(hdev);
575 hid_hw_stop(hdev);
576 }
577
578 static const struct hid_device_id rog_ryujin_table[] = {
579 { HID_USB_DEVICE(USB_VENDOR_ID_ASUS_ROG, USB_PRODUCT_ID_RYUJIN_AIO) },
580 { }
581 };
582
583 MODULE_DEVICE_TABLE(hid, rog_ryujin_table);
584
585 static struct hid_driver rog_ryujin_driver = {
586 .name = "rog_ryujin",
587 .id_table = rog_ryujin_table,
588 .probe = rog_ryujin_probe,
589 .remove = rog_ryujin_remove,
590 .raw_event = rog_ryujin_raw_event,
591 };
592
rog_ryujin_init(void)593 static int __init rog_ryujin_init(void)
594 {
595 return hid_register_driver(&rog_ryujin_driver);
596 }
597
rog_ryujin_exit(void)598 static void __exit rog_ryujin_exit(void)
599 {
600 hid_unregister_driver(&rog_ryujin_driver);
601 }
602
603 /* When compiled into the kernel, initialize after the HID bus */
604 late_initcall(rog_ryujin_init);
605 module_exit(rog_ryujin_exit);
606
607 MODULE_LICENSE("GPL");
608 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
609 MODULE_DESCRIPTION("Hwmon driver for Asus ROG Ryujin II 360 AIO cooler");
610