drivers/hwmon/nzxt-smart2.c

   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
 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
 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
 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
 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
 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
 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
 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  */
 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  */
 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
 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
 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
 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
 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
 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
 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
 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
 724 static void mutex_fini(void *lock)
 725 {
 726         mutex_destroy(lock);
 727 }
 728
 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
 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
 816 static int __init nzxt_smart2_init(void)
 817 {
 818         return hid_register_driver(&nzxt_smart2_hid_driver);
 819 }
 820
 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);