1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Reverse-engineered NZXT RGB & Fan Controller/Smart Device v2 driver.
4 *
5 * Copyright (c) 2021 Aleksandr Mezin
6 */
7
8 #include <linux/hid.h>
9 #include <linux/hwmon.h>
10 #include <linux/math.h>
11 #include <linux/module.h>
12 #include <linux/mutex.h>
13 #include <linux/spinlock.h>
14 #include <linux/wait.h>
15
16 #include <asm/byteorder.h>
17 #include <asm/unaligned.h>
18
19 /*
20 * The device has only 3 fan channels/connectors. But all HID reports have
21 * space reserved for up to 8 channels.
22 */
23 #define FAN_CHANNELS 3
24 #define FAN_CHANNELS_MAX 8
25
26 #define UPDATE_INTERVAL_DEFAULT_MS 1000
27
28 /* These strings match labels on the device exactly */
29 static const char *const fan_label[] = {
30 "FAN 1",
31 "FAN 2",
32 "FAN 3",
33 };
34
35 static const char *const curr_label[] = {
36 "FAN 1 Current",
37 "FAN 2 Current",
38 "FAN 3 Current",
39 };
40
41 static const char *const in_label[] = {
42 "FAN 1 Voltage",
43 "FAN 2 Voltage",
44 "FAN 3 Voltage",
45 };
46
47 enum {
48 INPUT_REPORT_ID_FAN_CONFIG = 0x61,
49 INPUT_REPORT_ID_FAN_STATUS = 0x67,
50 };
51
52 enum {
53 FAN_STATUS_REPORT_SPEED = 0x02,
54 FAN_STATUS_REPORT_VOLTAGE = 0x04,
55 };
56
57 enum {
58 FAN_TYPE_NONE = 0,
59 FAN_TYPE_DC = 1,
60 FAN_TYPE_PWM = 2,
61 };
62
63 struct unknown_static_data {
64 /*
65 * Some configuration data? Stays the same after fan speed changes,
66 * changes in fan configuration, reboots and driver reloads.
67 *
68 * The same data in multiple report types.
69 *
70 * Byte 12 seems to be the number of fan channels, but I am not sure.
71 */
72 u8 unknown1[14];
73 } __packed;
74
75 /*
76 * The device sends this input report in response to "detect fans" command:
77 * a 2-byte output report { 0x60, 0x03 }.
78 */
79 struct fan_config_report {
80 /* report_id should be INPUT_REPORT_ID_FAN_CONFIG = 0x61 */
81 u8 report_id;
82 /* Always 0x03 */
83 u8 magic;
84 struct unknown_static_data unknown_data;
85 /* Fan type as detected by the device. See FAN_TYPE_* enum. */
86 u8 fan_type[FAN_CHANNELS_MAX];
87 } __packed;
88
89 /*
90 * The device sends these reports at a fixed interval (update interval) -
91 * one report with type = FAN_STATUS_REPORT_SPEED, and one report with type =
92 * FAN_STATUS_REPORT_VOLTAGE per update interval.
93 */
94 struct fan_status_report {
95 /* report_id should be INPUT_REPORT_ID_STATUS = 0x67 */
96 u8 report_id;
97 /* FAN_STATUS_REPORT_SPEED = 0x02 or FAN_STATUS_REPORT_VOLTAGE = 0x04 */
98 u8 type;
99 struct unknown_static_data unknown_data;
100 /* Fan type as detected by the device. See FAN_TYPE_* enum. */
101 u8 fan_type[FAN_CHANNELS_MAX];
102
103 union {
104 /* When type == FAN_STATUS_REPORT_SPEED */
105 struct {
106 /*
107 * Fan speed, in RPM. Zero for channels without fans
108 * connected.
109 */
110 __le16 fan_rpm[FAN_CHANNELS_MAX];
111 /*
112 * Fan duty cycle, in percent. Non-zero even for
113 * channels without fans connected.
114 */
115 u8 duty_percent[FAN_CHANNELS_MAX];
116 /*
117 * Exactly the same values as duty_percent[], non-zero
118 * for disconnected fans too.
119 */
120 u8 duty_percent_dup[FAN_CHANNELS_MAX];
121 /* "Case Noise" in db */
122 u8 noise_db;
123 } __packed fan_speed;
124 /* When type == FAN_STATUS_REPORT_VOLTAGE */
125 struct {
126 /*
127 * Voltage, in millivolts. Non-zero even when fan is
128 * not connected.
129 */
130 __le16 fan_in[FAN_CHANNELS_MAX];
131 /*
132 * Current, in milliamperes. Near-zero when
133 * disconnected.
134 */
135 __le16 fan_current[FAN_CHANNELS_MAX];
136 } __packed fan_voltage;
137 } __packed;
138 } __packed;
139
140 #define OUTPUT_REPORT_SIZE 64
141
142 enum {
143 OUTPUT_REPORT_ID_INIT_COMMAND = 0x60,
144 OUTPUT_REPORT_ID_SET_FAN_SPEED = 0x62,
145 };
146
147 enum {
148 INIT_COMMAND_SET_UPDATE_INTERVAL = 0x02,
149 INIT_COMMAND_DETECT_FANS = 0x03,
150 };
151
152 /*
153 * This output report sets pwm duty cycle/target fan speed for one or more
154 * channels.
155 */
156 struct set_fan_speed_report {
157 /* report_id should be OUTPUT_REPORT_ID_SET_FAN_SPEED = 0x62 */
158 u8 report_id;
159 /* Should be 0x01 */
160 u8 magic;
161 /* To change fan speed on i-th channel, set i-th bit here */
162 u8 channel_bit_mask;
163 /*
164 * Fan duty cycle/target speed in percent. For voltage-controlled fans,
165 * the minimal voltage (duty_percent = 1) is about 9V.
166 * Setting duty_percent to 0 (if the channel is selected in
167 * channel_bit_mask) turns off the fan completely (regardless of the
168 * control mode).
169 */
170 u8 duty_percent[FAN_CHANNELS_MAX];
171 } __packed;
172
173 struct drvdata {
174 struct hid_device *hid;
175 struct device *hwmon;
176
177 u8 fan_duty_percent[FAN_CHANNELS];
178 u16 fan_rpm[FAN_CHANNELS];
179 bool pwm_status_received;
180
181 u16 fan_in[FAN_CHANNELS];
182 u16 fan_curr[FAN_CHANNELS];
183 bool voltage_status_received;
184
185 u8 fan_type[FAN_CHANNELS];
186 bool fan_config_received;
187
188 /*
189 * wq is used to wait for *_received flags to become true.
190 * All accesses to *_received flags and fan_* arrays are performed with
191 * wq.lock held.
192 */
193 wait_queue_head_t wq;
194 /*
195 * mutex is used to:
196 * 1) Prevent concurrent conflicting changes to update interval and pwm
197 * values (after sending an output hid report, the corresponding field
198 * in drvdata must be updated, and only then new output reports can be
199 * sent).
200 * 2) Synchronize access to output_buffer (well, the buffer is here,
201 * because synchronization is necessary anyway - so why not get rid of
202 * a kmalloc?).
203 */
204 struct mutex mutex;
205 long update_interval;
206 u8 output_buffer[OUTPUT_REPORT_SIZE];
207 };
208
scale_pwm_value(long val,long orig_max,long new_max)209 static long scale_pwm_value(long val, long orig_max, long new_max)
210 {
211 if (val <= 0)
212 return 0;
213
214 /*
215 * Positive values should not become zero: 0 completely turns off the
216 * fan.
217 */
218 return max(1L, DIV_ROUND_CLOSEST(min(val, orig_max) * new_max, orig_max));
219 }
220
handle_fan_config_report(struct drvdata * drvdata,void * data,int size)221 static void handle_fan_config_report(struct drvdata *drvdata, void *data, int size)
222 {
223 struct fan_config_report *report = data;
224 int i;
225
226 if (size < sizeof(struct fan_config_report))
227 return;
228
229 if (report->magic != 0x03)
230 return;
231
232 spin_lock(&drvdata->wq.lock);
233
234 for (i = 0; i < FAN_CHANNELS; i++)
235 drvdata->fan_type[i] = report->fan_type[i];
236
237 drvdata->fan_config_received = true;
238 wake_up_all_locked(&drvdata->wq);
239 spin_unlock(&drvdata->wq.lock);
240 }
241
handle_fan_status_report(struct drvdata * drvdata,void * data,int size)242 static void handle_fan_status_report(struct drvdata *drvdata, void *data, int size)
243 {
244 struct fan_status_report *report = data;
245 int i;
246
247 if (size < sizeof(struct fan_status_report))
248 return;
249
250 spin_lock(&drvdata->wq.lock);
251
252 /*
253 * The device sends INPUT_REPORT_ID_FAN_CONFIG = 0x61 report in response
254 * to "detect fans" command. Only accept other data after getting 0x61,
255 * to make sure that fan detection is complete. In particular, fan
256 * detection resets pwm values.
257 */
258 if (!drvdata->fan_config_received) {
259 spin_unlock(&drvdata->wq.lock);
260 return;
261 }
262
263 for (i = 0; i < FAN_CHANNELS; i++) {
264 if (drvdata->fan_type[i] == report->fan_type[i])
265 continue;
266
267 /*
268 * This should not happen (if my expectations about the device
269 * are correct).
270 *
271 * Even if the userspace sends fan detect command through
272 * hidraw, fan config report should arrive first.
273 */
274 hid_warn_once(drvdata->hid,
275 "Fan %d type changed unexpectedly from %d to %d",
276 i, drvdata->fan_type[i], report->fan_type[i]);
277 drvdata->fan_type[i] = report->fan_type[i];
278 }
279
280 switch (report->type) {
281 case FAN_STATUS_REPORT_SPEED:
282 for (i = 0; i < FAN_CHANNELS; i++) {
283 drvdata->fan_rpm[i] =
284 get_unaligned_le16(&report->fan_speed.fan_rpm[i]);
285 drvdata->fan_duty_percent[i] =
286 report->fan_speed.duty_percent[i];
287 }
288
289 drvdata->pwm_status_received = true;
290 wake_up_all_locked(&drvdata->wq);
291 break;
292
293 case FAN_STATUS_REPORT_VOLTAGE:
294 for (i = 0; i < FAN_CHANNELS; i++) {
295 drvdata->fan_in[i] =
296 get_unaligned_le16(&report->fan_voltage.fan_in[i]);
297 drvdata->fan_curr[i] =
298 get_unaligned_le16(&report->fan_voltage.fan_current[i]);
299 }
300
301 drvdata->voltage_status_received = true;
302 wake_up_all_locked(&drvdata->wq);
303 break;
304 }
305
306 spin_unlock(&drvdata->wq.lock);
307 }
308
nzxt_smart2_hwmon_is_visible(const void * data,enum hwmon_sensor_types type,u32 attr,int channel)309 static umode_t nzxt_smart2_hwmon_is_visible(const void *data,
310 enum hwmon_sensor_types type,
311 u32 attr, int channel)
312 {
313 switch (type) {
314 case hwmon_pwm:
315 switch (attr) {
316 case hwmon_pwm_input:
317 case hwmon_pwm_enable:
318 return 0644;
319
320 default:
321 return 0444;
322 }
323
324 case hwmon_chip:
325 switch (attr) {
326 case hwmon_chip_update_interval:
327 return 0644;
328
329 default:
330 return 0444;
331 }
332
333 default:
334 return 0444;
335 }
336 }
337
nzxt_smart2_hwmon_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)338 static int nzxt_smart2_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
339 u32 attr, int channel, long *val)
340 {
341 struct drvdata *drvdata = dev_get_drvdata(dev);
342 int res = -EINVAL;
343
344 if (type == hwmon_chip) {
345 switch (attr) {
346 case hwmon_chip_update_interval:
347 *val = drvdata->update_interval;
348 return 0;
349
350 default:
351 return -EINVAL;
352 }
353 }
354
355 spin_lock_irq(&drvdata->wq.lock);
356
357 switch (type) {
358 case hwmon_pwm:
359 /*
360 * fancontrol:
361 * 1) remembers pwm* values when it starts
362 * 2) needs pwm*_enable to be 1 on controlled fans
363 * So make sure we have correct data before allowing pwm* reads.
364 * Returning errors for pwm of fan speed read can even cause
365 * fancontrol to shut down. So the wait is unavoidable.
366 */
367 switch (attr) {
368 case hwmon_pwm_enable:
369 res = wait_event_interruptible_locked_irq(drvdata->wq,
370 drvdata->fan_config_received);
371 if (res)
372 goto unlock;
373
374 *val = drvdata->fan_type[channel] != FAN_TYPE_NONE;
375 break;
376
377 case hwmon_pwm_mode:
378 res = wait_event_interruptible_locked_irq(drvdata->wq,
379 drvdata->fan_config_received);
380 if (res)
381 goto unlock;
382
383 *val = drvdata->fan_type[channel] == FAN_TYPE_PWM;
384 break;
385
386 case hwmon_pwm_input:
387 res = wait_event_interruptible_locked_irq(drvdata->wq,
388 drvdata->pwm_status_received);
389 if (res)
390 goto unlock;
391
392 *val = scale_pwm_value(drvdata->fan_duty_percent[channel],
393 100, 255);
394 break;
395 }
396 break;
397
398 case hwmon_fan:
399 /*
400 * It's not strictly necessary to wait for *_received in the
401 * remaining cases (fancontrol doesn't care about them). But I'm
402 * doing it to have consistent behavior.
403 */
404 if (attr == hwmon_fan_input) {
405 res = wait_event_interruptible_locked_irq(drvdata->wq,
406 drvdata->pwm_status_received);
407 if (res)
408 goto unlock;
409
410 *val = drvdata->fan_rpm[channel];
411 }
412 break;
413
414 case hwmon_in:
415 if (attr == hwmon_in_input) {
416 res = wait_event_interruptible_locked_irq(drvdata->wq,
417 drvdata->voltage_status_received);
418 if (res)
419 goto unlock;
420
421 *val = drvdata->fan_in[channel];
422 }
423 break;
424
425 case hwmon_curr:
426 if (attr == hwmon_curr_input) {
427 res = wait_event_interruptible_locked_irq(drvdata->wq,
428 drvdata->voltage_status_received);
429 if (res)
430 goto unlock;
431
432 *val = drvdata->fan_curr[channel];
433 }
434 break;
435
436 default:
437 break;
438 }
439
440 unlock:
441 spin_unlock_irq(&drvdata->wq.lock);
442 return res;
443 }
444
send_output_report(struct drvdata * drvdata,const void * data,size_t data_size)445 static int send_output_report(struct drvdata *drvdata, const void *data,
446 size_t data_size)
447 {
448 int ret;
449
450 if (data_size > sizeof(drvdata->output_buffer))
451 return -EINVAL;
452
453 memcpy(drvdata->output_buffer, data, data_size);
454
455 if (data_size < sizeof(drvdata->output_buffer))
456 memset(drvdata->output_buffer + data_size, 0,
457 sizeof(drvdata->output_buffer) - data_size);
458
459 ret = hid_hw_output_report(drvdata->hid, drvdata->output_buffer,
460 sizeof(drvdata->output_buffer));
461 return ret < 0 ? ret : 0;
462 }
463
set_pwm(struct drvdata * drvdata,int channel,long val)464 static int set_pwm(struct drvdata *drvdata, int channel, long val)
465 {
466 int ret;
467 u8 duty_percent = scale_pwm_value(val, 255, 100);
468
469 struct set_fan_speed_report report = {
470 .report_id = OUTPUT_REPORT_ID_SET_FAN_SPEED,
471 .magic = 1,
472 .channel_bit_mask = 1 << channel
473 };
474
475 ret = mutex_lock_interruptible(&drvdata->mutex);
476 if (ret)
477 return ret;
478
479 report.duty_percent[channel] = duty_percent;
480 ret = send_output_report(drvdata, &report, sizeof(report));
481 if (ret)
482 goto unlock;
483
484 /*
485 * pwmconfig and fancontrol scripts expect pwm writes to take effect
486 * immediately (i. e. read from pwm* sysfs should return the value
487 * written into it). The device seems to always accept pwm values - even
488 * when there is no fan connected - so update pwm status without waiting
489 * for a report, to make pwmconfig and fancontrol happy. Worst case -
490 * if the device didn't accept new pwm value for some reason (never seen
491 * this in practice) - it will be reported incorrectly only until next
492 * update. This avoids "fan stuck" messages from pwmconfig, and
493 * fancontrol setting fan speed to 100% during shutdown.
494 */
495 spin_lock_bh(&drvdata->wq.lock);
496 drvdata->fan_duty_percent[channel] = duty_percent;
497 spin_unlock_bh(&drvdata->wq.lock);
498
499 unlock:
500 mutex_unlock(&drvdata->mutex);
501 return ret;
502 }
503
504 /*
505 * Workaround for fancontrol/pwmconfig trying to write to pwm*_enable even if it
506 * already is 1 and read-only. Otherwise, fancontrol won't restore pwm on
507 * shutdown properly.
508 */
set_pwm_enable(struct drvdata * drvdata,int channel,long val)509 static int set_pwm_enable(struct drvdata *drvdata, int channel, long val)
510 {
511 long expected_val;
512 int res;
513
514 spin_lock_irq(&drvdata->wq.lock);
515
516 res = wait_event_interruptible_locked_irq(drvdata->wq,
517 drvdata->fan_config_received);
518 if (res) {
519 spin_unlock_irq(&drvdata->wq.lock);
520 return res;
521 }
522
523 expected_val = drvdata->fan_type[channel] != FAN_TYPE_NONE;
524
525 spin_unlock_irq(&drvdata->wq.lock);
526
527 return (val == expected_val) ? 0 : -EOPNOTSUPP;
528 }
529
530 /*
531 * Control byte | Actual update interval in seconds
532 * 0xff | 65.5
533 * 0xf7 | 63.46
534 * 0x7f | 32.74
535 * 0x3f | 16.36
536 * 0x1f | 8.17
537 * 0x0f | 4.07
538 * 0x07 | 2.02
539 * 0x03 | 1.00
540 * 0x02 | 0.744
541 * 0x01 | 0.488
542 * 0x00 | 0.25
543 */
update_interval_to_control_byte(long interval)544 static u8 update_interval_to_control_byte(long interval)
545 {
546 if (interval <= 250)
547 return 0;
548
549 return clamp_val(1 + DIV_ROUND_CLOSEST(interval - 488, 256), 0, 255);
550 }
551
control_byte_to_update_interval(u8 control_byte)552 static long control_byte_to_update_interval(u8 control_byte)
553 {
554 if (control_byte == 0)
555 return 250;
556
557 return 488 + (control_byte - 1) * 256;
558 }
559
set_update_interval(struct drvdata * drvdata,long val)560 static int set_update_interval(struct drvdata *drvdata, long val)
561 {
562 u8 control = update_interval_to_control_byte(val);
563 u8 report[] = {
564 OUTPUT_REPORT_ID_INIT_COMMAND,
565 INIT_COMMAND_SET_UPDATE_INTERVAL,
566 0x01,
567 0xe8,
568 control,
569 0x01,
570 0xe8,
571 control,
572 };
573 int ret;
574
575 ret = send_output_report(drvdata, report, sizeof(report));
576 if (ret)
577 return ret;
578
579 drvdata->update_interval = control_byte_to_update_interval(control);
580 return 0;
581 }
582
init_device(struct drvdata * drvdata,long update_interval)583 static int init_device(struct drvdata *drvdata, long update_interval)
584 {
585 int ret;
586 static const u8 detect_fans_report[] = {
587 OUTPUT_REPORT_ID_INIT_COMMAND,
588 INIT_COMMAND_DETECT_FANS,
589 };
590
591 ret = send_output_report(drvdata, detect_fans_report,
592 sizeof(detect_fans_report));
593 if (ret)
594 return ret;
595
596 return set_update_interval(drvdata, update_interval);
597 }
598
nzxt_smart2_hwmon_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)599 static int nzxt_smart2_hwmon_write(struct device *dev,
600 enum hwmon_sensor_types type, u32 attr,
601 int channel, long val)
602 {
603 struct drvdata *drvdata = dev_get_drvdata(dev);
604 int ret;
605
606 switch (type) {
607 case hwmon_pwm:
608 switch (attr) {
609 case hwmon_pwm_enable:
610 return set_pwm_enable(drvdata, channel, val);
611
612 case hwmon_pwm_input:
613 return set_pwm(drvdata, channel, val);
614
615 default:
616 return -EINVAL;
617 }
618
619 case hwmon_chip:
620 switch (attr) {
621 case hwmon_chip_update_interval:
622 ret = mutex_lock_interruptible(&drvdata->mutex);
623 if (ret)
624 return ret;
625
626 ret = set_update_interval(drvdata, val);
627
628 mutex_unlock(&drvdata->mutex);
629 return ret;
630
631 default:
632 return -EINVAL;
633 }
634
635 default:
636 return -EINVAL;
637 }
638 }
639
nzxt_smart2_hwmon_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)640 static int nzxt_smart2_hwmon_read_string(struct device *dev,
641 enum hwmon_sensor_types type, u32 attr,
642 int channel, const char **str)
643 {
644 switch (type) {
645 case hwmon_fan:
646 *str = fan_label[channel];
647 return 0;
648 case hwmon_curr:
649 *str = curr_label[channel];
650 return 0;
651 case hwmon_in:
652 *str = in_label[channel];
653 return 0;
654 default:
655 return -EINVAL;
656 }
657 }
658
659 static const struct hwmon_ops nzxt_smart2_hwmon_ops = {
660 .is_visible = nzxt_smart2_hwmon_is_visible,
661 .read = nzxt_smart2_hwmon_read,
662 .read_string = nzxt_smart2_hwmon_read_string,
663 .write = nzxt_smart2_hwmon_write,
664 };
665
666 static const struct hwmon_channel_info * const nzxt_smart2_channel_info[] = {
667 HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_LABEL,
668 HWMON_F_INPUT | HWMON_F_LABEL,
669 HWMON_F_INPUT | HWMON_F_LABEL),
670 HWMON_CHANNEL_INFO(pwm, HWMON_PWM_INPUT | HWMON_PWM_MODE | HWMON_PWM_ENABLE,
671 HWMON_PWM_INPUT | HWMON_PWM_MODE | HWMON_PWM_ENABLE,
672 HWMON_PWM_INPUT | HWMON_PWM_MODE | HWMON_PWM_ENABLE),
673 HWMON_CHANNEL_INFO(in, HWMON_I_INPUT | HWMON_I_LABEL,
674 HWMON_I_INPUT | HWMON_I_LABEL,
675 HWMON_I_INPUT | HWMON_I_LABEL),
676 HWMON_CHANNEL_INFO(curr, HWMON_C_INPUT | HWMON_C_LABEL,
677 HWMON_C_INPUT | HWMON_C_LABEL,
678 HWMON_C_INPUT | HWMON_C_LABEL),
679 HWMON_CHANNEL_INFO(chip, HWMON_C_UPDATE_INTERVAL),
680 NULL
681 };
682
683 static const struct hwmon_chip_info nzxt_smart2_chip_info = {
684 .ops = &nzxt_smart2_hwmon_ops,
685 .info = nzxt_smart2_channel_info,
686 };
687
nzxt_smart2_hid_raw_event(struct hid_device * hdev,struct hid_report * report,u8 * data,int size)688 static int nzxt_smart2_hid_raw_event(struct hid_device *hdev,
689 struct hid_report *report, u8 *data, int size)
690 {
691 struct drvdata *drvdata = hid_get_drvdata(hdev);
692 u8 report_id = *data;
693
694 switch (report_id) {
695 case INPUT_REPORT_ID_FAN_CONFIG:
696 handle_fan_config_report(drvdata, data, size);
697 break;
698
699 case INPUT_REPORT_ID_FAN_STATUS:
700 handle_fan_status_report(drvdata, data, size);
701 break;
702 }
703
704 return 0;
705 }
706
nzxt_smart2_hid_reset_resume(struct hid_device * hdev)707 static int __maybe_unused nzxt_smart2_hid_reset_resume(struct hid_device *hdev)
708 {
709 struct drvdata *drvdata = hid_get_drvdata(hdev);
710
711 /*
712 * Userspace is still frozen (so no concurrent sysfs attribute access
713 * is possible), but raw_event can already be called concurrently.
714 */
715 spin_lock_bh(&drvdata->wq.lock);
716 drvdata->fan_config_received = false;
717 drvdata->pwm_status_received = false;
718 drvdata->voltage_status_received = false;
719 spin_unlock_bh(&drvdata->wq.lock);
720
721 return init_device(drvdata, drvdata->update_interval);
722 }
723
mutex_fini(void * lock)724 static void mutex_fini(void *lock)
725 {
726 mutex_destroy(lock);
727 }
728
nzxt_smart2_hid_probe(struct hid_device * hdev,const struct hid_device_id * id)729 static int nzxt_smart2_hid_probe(struct hid_device *hdev,
730 const struct hid_device_id *id)
731 {
732 struct drvdata *drvdata;
733 int ret;
734
735 drvdata = devm_kzalloc(&hdev->dev, sizeof(struct drvdata), GFP_KERNEL);
736 if (!drvdata)
737 return -ENOMEM;
738
739 drvdata->hid = hdev;
740 hid_set_drvdata(hdev, drvdata);
741
742 init_waitqueue_head(&drvdata->wq);
743
744 mutex_init(&drvdata->mutex);
745 ret = devm_add_action_or_reset(&hdev->dev, mutex_fini, &drvdata->mutex);
746 if (ret)
747 return ret;
748
749 ret = hid_parse(hdev);
750 if (ret)
751 return ret;
752
753 ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
754 if (ret)
755 return ret;
756
757 ret = hid_hw_open(hdev);
758 if (ret)
759 goto out_hw_stop;
760
761 hid_device_io_start(hdev);
762
763 init_device(drvdata, UPDATE_INTERVAL_DEFAULT_MS);
764
765 drvdata->hwmon =
766 hwmon_device_register_with_info(&hdev->dev, "nzxtsmart2", drvdata,
767 &nzxt_smart2_chip_info, NULL);
768 if (IS_ERR(drvdata->hwmon)) {
769 ret = PTR_ERR(drvdata->hwmon);
770 goto out_hw_close;
771 }
772
773 return 0;
774
775 out_hw_close:
776 hid_hw_close(hdev);
777
778 out_hw_stop:
779 hid_hw_stop(hdev);
780 return ret;
781 }
782
nzxt_smart2_hid_remove(struct hid_device * hdev)783 static void nzxt_smart2_hid_remove(struct hid_device *hdev)
784 {
785 struct drvdata *drvdata = hid_get_drvdata(hdev);
786
787 hwmon_device_unregister(drvdata->hwmon);
788
789 hid_hw_close(hdev);
790 hid_hw_stop(hdev);
791 }
792
793 static const struct hid_device_id nzxt_smart2_hid_id_table[] = {
794 { HID_USB_DEVICE(0x1e71, 0x2006) }, /* NZXT Smart Device V2 */
795 { HID_USB_DEVICE(0x1e71, 0x200d) }, /* NZXT Smart Device V2 */
796 { HID_USB_DEVICE(0x1e71, 0x200f) }, /* NZXT Smart Device V2 */
797 { HID_USB_DEVICE(0x1e71, 0x2009) }, /* NZXT RGB & Fan Controller */
798 { HID_USB_DEVICE(0x1e71, 0x200e) }, /* NZXT RGB & Fan Controller */
799 { HID_USB_DEVICE(0x1e71, 0x2010) }, /* NZXT RGB & Fan Controller */
800 { HID_USB_DEVICE(0x1e71, 0x2011) }, /* NZXT RGB & Fan Controller (6 RGB) */
801 { HID_USB_DEVICE(0x1e71, 0x2019) }, /* NZXT RGB & Fan Controller (6 RGB) */
802 {},
803 };
804
805 static struct hid_driver nzxt_smart2_hid_driver = {
806 .name = "nzxt-smart2",
807 .id_table = nzxt_smart2_hid_id_table,
808 .probe = nzxt_smart2_hid_probe,
809 .remove = nzxt_smart2_hid_remove,
810 .raw_event = nzxt_smart2_hid_raw_event,
811 #ifdef CONFIG_PM
812 .reset_resume = nzxt_smart2_hid_reset_resume,
813 #endif
814 };
815
nzxt_smart2_init(void)816 static int __init nzxt_smart2_init(void)
817 {
818 return hid_register_driver(&nzxt_smart2_hid_driver);
819 }
820
nzxt_smart2_exit(void)821 static void __exit nzxt_smart2_exit(void)
822 {
823 hid_unregister_driver(&nzxt_smart2_hid_driver);
824 }
825
826 MODULE_DEVICE_TABLE(hid, nzxt_smart2_hid_id_table);
827 MODULE_AUTHOR("Aleksandr Mezin <mezin.alexander@gmail.com>");
828 MODULE_DESCRIPTION("Driver for NZXT RGB & Fan Controller/Smart Device V2");
829 MODULE_LICENSE("GPL");
830
831 /*
832 * With module_init()/module_hid_driver() and the driver built into the kernel:
833 *
834 * Driver 'nzxt_smart2' was unable to register with bus_type 'hid' because the
835 * bus was not initialized.
836 */
837 late_initcall(nzxt_smart2_init);
838 module_exit(nzxt_smart2_exit);
839
