drivers/hwmon/aquacomputer_d5next.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * hwmon driver for Aquacomputer devices (D5 Next, Farbwerk, Farbwerk 360, Octo)
   4  *
   5  * Aquacomputer devices send HID reports (with ID 0x01) every second to report
   6  * sensor values.
   7  *
   8  * Copyright 2021 Aleksa Savic <savicaleksa83@gmail.com>
   9  * Copyright 2022 Jack Doan <me@jackdoan.com>
  10  */
  11
  12 #include <linux/crc16.h>
  13 #include <linux/debugfs.h>
  14 #include <linux/hid.h>
  15 #include <linux/hwmon.h>
  16 #include <linux/jiffies.h>
  17 #include <linux/module.h>
  18 #include <linux/mutex.h>
  19 #include <linux/seq_file.h>
  20 #include <asm/unaligned.h>
  21
  22 #define USB_VENDOR_ID_AQUACOMPUTER      0x0c70
  23 #define USB_PRODUCT_ID_FARBWERK         0xf00a
  24 #define USB_PRODUCT_ID_D5NEXT           0xf00e
  25 #define USB_PRODUCT_ID_FARBWERK360      0xf010
  26 #define USB_PRODUCT_ID_OCTO             0xf011
  27
  28 enum kinds { d5next, farbwerk, farbwerk360, octo };
  29
  30 static const char *const aqc_device_names[] = {
  31         [d5next] = "d5next",
  32         [farbwerk] = "farbwerk",
  33         [farbwerk360] = "farbwerk360",
  34         [octo] = "octo"
  35 };
  36
  37 #define DRIVER_NAME                     "aquacomputer_d5next"
  38
  39 #define STATUS_REPORT_ID                0x01
  40 #define STATUS_UPDATE_INTERVAL          (2 * HZ)        /* In seconds */
  41 #define SERIAL_FIRST_PART               3
  42 #define SERIAL_SECOND_PART              5
  43 #define FIRMWARE_VERSION                13
  44
  45 #define CTRL_REPORT_ID                  0x03
  46
  47 /* The HID report that the official software always sends
  48  * after writing values, currently same for all devices
  49  */
  50 #define SECONDARY_CTRL_REPORT_ID        0x02
  51 #define SECONDARY_CTRL_REPORT_SIZE      0x0B
  52
  53 static u8 secondary_ctrl_report[] = {
  54         0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x34, 0xC6
  55 };
  56
  57 /* Register offsets for the D5 Next pump */
  58 #define D5NEXT_POWER_CYCLES             24
  59
  60 #define D5NEXT_COOLANT_TEMP             87
  61
  62 #define D5NEXT_PUMP_SPEED               116
  63 #define D5NEXT_FAN_SPEED                103
  64
  65 #define D5NEXT_PUMP_POWER               114
  66 #define D5NEXT_FAN_POWER                101
  67
  68 #define D5NEXT_PUMP_VOLTAGE             110
  69 #define D5NEXT_FAN_VOLTAGE              97
  70 #define D5NEXT_5V_VOLTAGE               57
  71
  72 #define D5NEXT_PUMP_CURRENT             112
  73 #define D5NEXT_FAN_CURRENT              99
  74
  75 /* Register offsets for the Farbwerk RGB controller */
  76 #define FARBWERK_NUM_SENSORS            4
  77 #define FARBWERK_SENSOR_START           0x2f
  78 #define FARBWERK_SENSOR_SIZE            0x02
  79 #define FARBWERK_SENSOR_DISCONNECTED    0x7FFF
  80
  81 /* Register offsets for the Farbwerk 360 RGB controller */
  82 #define FARBWERK360_NUM_SENSORS         4
  83 #define FARBWERK360_SENSOR_START        0x32
  84 #define FARBWERK360_SENSOR_SIZE         0x02
  85 #define FARBWERK360_SENSOR_DISCONNECTED 0x7FFF
  86
  87 /* Register offsets for the Octo fan controller */
  88 #define OCTO_POWER_CYCLES               0x18
  89 #define OCTO_NUM_FANS                   8
  90 #define OCTO_FAN_PERCENT_OFFSET         0x00
  91 #define OCTO_FAN_VOLTAGE_OFFSET         0x02
  92 #define OCTO_FAN_CURRENT_OFFSET         0x04
  93 #define OCTO_FAN_POWER_OFFSET           0x06
  94 #define OCTO_FAN_SPEED_OFFSET           0x08
  95
  96 static u8 octo_sensor_fan_offsets[] = { 0x7D, 0x8A, 0x97, 0xA4, 0xB1, 0xBE, 0xCB, 0xD8 };
  97
  98 #define OCTO_NUM_SENSORS                4
  99 #define OCTO_SENSOR_START               0x3D
 100 #define OCTO_SENSOR_SIZE                0x02
 101 #define OCTO_SENSOR_DISCONNECTED        0x7FFF
 102
 103 #define OCTO_CTRL_REPORT_SIZE                   0x65F
 104 #define OCTO_CTRL_REPORT_CHECKSUM_OFFSET        0x65D
 105 #define OCTO_CTRL_REPORT_CHECKSUM_START         0x01
 106 #define OCTO_CTRL_REPORT_CHECKSUM_LENGTH        0x65C
 107
 108 /* Fan speed registers in Octo control report (from 0-100%) */
 109 static u16 octo_ctrl_fan_offsets[] = { 0x5B, 0xB0, 0x105, 0x15A, 0x1AF, 0x204, 0x259, 0x2AE };
 110
 111 /* Labels for D5 Next */
 112 static const char *const label_d5next_temp[] = {
 113         "Coolant temp"
 114 };
 115
 116 static const char *const label_d5next_speeds[] = {
 117         "Pump speed",
 118         "Fan speed"
 119 };
 120
 121 static const char *const label_d5next_power[] = {
 122         "Pump power",
 123         "Fan power"
 124 };
 125
 126 static const char *const label_d5next_voltages[] = {
 127         "Pump voltage",
 128         "Fan voltage",
 129         "+5V voltage"
 130 };
 131
 132 static const char *const label_d5next_current[] = {
 133         "Pump current",
 134         "Fan current"
 135 };
 136
 137 /* Labels for Farbwerk, Farbwerk 360 and Octo temperature sensors */
 138 static const char *const label_temp_sensors[] = {
 139         "Sensor 1",
 140         "Sensor 2",
 141         "Sensor 3",
 142         "Sensor 4"
 143 };
 144
 145 /* Labels for Octo */
 146 static const char *const label_fan_speed[] = {
 147         "Fan 1 speed",
 148         "Fan 2 speed",
 149         "Fan 3 speed",
 150         "Fan 4 speed",
 151         "Fan 5 speed",
 152         "Fan 6 speed",
 153         "Fan 7 speed",
 154         "Fan 8 speed"
 155 };
 156
 157 static const char *const label_fan_power[] = {
 158         "Fan 1 power",
 159         "Fan 2 power",
 160         "Fan 3 power",
 161         "Fan 4 power",
 162         "Fan 5 power",
 163         "Fan 6 power",
 164         "Fan 7 power",
 165         "Fan 8 power"
 166 };
 167
 168 static const char *const label_fan_voltage[] = {
 169         "Fan 1 voltage",
 170         "Fan 2 voltage",
 171         "Fan 3 voltage",
 172         "Fan 4 voltage",
 173         "Fan 5 voltage",
 174         "Fan 6 voltage",
 175         "Fan 7 voltage",
 176         "Fan 8 voltage"
 177 };
 178
 179 static const char *const label_fan_current[] = {
 180         "Fan 1 current",
 181         "Fan 2 current",
 182         "Fan 3 current",
 183         "Fan 4 current",
 184         "Fan 5 current",
 185         "Fan 6 current",
 186         "Fan 7 current",
 187         "Fan 8 current"
 188 };
 189
 190 struct aqc_data {
 191         struct hid_device *hdev;
 192         struct device *hwmon_dev;
 193         struct dentry *debugfs;
 194         struct mutex mutex;     /* Used for locking access when reading and writing PWM values */
 195         enum kinds kind;
 196         const char *name;
 197
 198         int buffer_size;
 199         u8 *buffer;
 200         int checksum_start;
 201         int checksum_length;
 202         int checksum_offset;
 203
 204         /* General info, same across all devices */
 205         u32 serial_number[2];
 206         u16 firmware_version;
 207
 208         /* How many times the device was powered on */
 209         u32 power_cycles;
 210
 211         /* Sensor values */
 212         s32 temp_input[4];
 213         u16 speed_input[8];
 214         u32 power_input[8];
 215         u16 voltage_input[8];
 216         u16 current_input[8];
 217
 218         /* Label values */
 219         const char *const *temp_label;
 220         const char *const *speed_label;
 221         const char *const *power_label;
 222         const char *const *voltage_label;
 223         const char *const *current_label;
 224
 225         unsigned long updated;
 226 };
 227
 228 /* Converts from centi-percent */
 229 static int aqc_percent_to_pwm(u16 val)
 230 {
 231         return DIV_ROUND_CLOSEST(val * 255, 100 * 100);
 232 }
 233
 234 /* Converts to centi-percent */
 235 static int aqc_pwm_to_percent(long val)
 236 {
 237         if (val < 0 || val > 255)
 238                 return -EINVAL;
 239
 240         return DIV_ROUND_CLOSEST(val * 100 * 100, 255);
 241 }
 242
 243 /* Expects the mutex to be locked */
 244 static int aqc_get_ctrl_data(struct aqc_data *priv)
 245 {
 246         int ret;
 247
 248         memset(priv->buffer, 0x00, priv->buffer_size);
 249         ret = hid_hw_raw_request(priv->hdev, CTRL_REPORT_ID, priv->buffer, priv->buffer_size,
 250                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
 251         if (ret < 0)
 252                 ret = -ENODATA;
 253
 254         return ret;
 255 }
 256
 257 /* Expects the mutex to be locked */
 258 static int aqc_send_ctrl_data(struct aqc_data *priv)
 259 {
 260         int ret;
 261         u16 checksum;
 262
 263         /* Init and xorout value for CRC-16/USB is 0xffff */
 264         checksum = crc16(0xffff, priv->buffer + priv->checksum_start, priv->checksum_length);
 265         checksum ^= 0xffff;
 266
 267         /* Place the new checksum at the end of the report */
 268         put_unaligned_be16(checksum, priv->buffer + priv->checksum_offset);
 269
 270         /* Send the patched up report back to the device */
 271         ret = hid_hw_raw_request(priv->hdev, CTRL_REPORT_ID, priv->buffer, priv->buffer_size,
 272                                  HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 273         if (ret < 0)
 274                 return ret;
 275
 276         /* The official software sends this report after every change, so do it here as well */
 277         ret = hid_hw_raw_request(priv->hdev, SECONDARY_CTRL_REPORT_ID, secondary_ctrl_report,
 278                                  SECONDARY_CTRL_REPORT_SIZE, HID_FEATURE_REPORT,
 279                                  HID_REQ_SET_REPORT);
 280         return ret;
 281 }
 282
 283 /* Refreshes the control buffer and returns value at offset */
 284 static int aqc_get_ctrl_val(struct aqc_data *priv, int offset)
 285 {
 286         int ret;
 287
 288         mutex_lock(&priv->mutex);
 289
 290         ret = aqc_get_ctrl_data(priv);
 291         if (ret < 0)
 292                 goto unlock_and_return;
 293
 294         ret = get_unaligned_be16(priv->buffer + offset);
 295
 296 unlock_and_return:
 297         mutex_unlock(&priv->mutex);
 298         return ret;
 299 }
 300
 301 static int aqc_set_ctrl_val(struct aqc_data *priv, int offset, long val)
 302 {
 303         int ret;
 304
 305         mutex_lock(&priv->mutex);
 306
 307         ret = aqc_get_ctrl_data(priv);
 308         if (ret < 0)
 309                 goto unlock_and_return;
 310
 311         put_unaligned_be16((u16)val, priv->buffer + offset);
 312
 313         ret = aqc_send_ctrl_data(priv);
 314
 315 unlock_and_return:
 316         mutex_unlock(&priv->mutex);
 317         return ret;
 318 }
 319
 320 static umode_t aqc_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr, int channel)
 321 {
 322         const struct aqc_data *priv = data;
 323
 324         switch (type) {
 325         case hwmon_temp:
 326                 switch (priv->kind) {
 327                 case d5next:
 328                         if (channel == 0)
 329                                 return 0444;
 330                         break;
 331                 case farbwerk:
 332                 case farbwerk360:
 333                 case octo:
 334                         return 0444;
 335                 default:
 336                         break;
 337                 }
 338                 break;
 339         case hwmon_pwm:
 340                 switch (priv->kind) {
 341                 case octo:
 342                         switch (attr) {
 343                         case hwmon_pwm_input:
 344                                 return 0644;
 345                         default:
 346                                 break;
 347                         }
 348                         break;
 349                 default:
 350                         break;
 351                 }
 352                 break;
 353         case hwmon_fan:
 354         case hwmon_power:
 355         case hwmon_curr:
 356                 switch (priv->kind) {
 357                 case d5next:
 358                         if (channel < 2)
 359                                 return 0444;
 360                         break;
 361                 case octo:
 362                         return 0444;
 363                 default:
 364                         break;
 365                 }
 366                 break;
 367         case hwmon_in:
 368                 switch (priv->kind) {
 369                 case d5next:
 370                         if (channel < 3)
 371                                 return 0444;
 372                         break;
 373                 case octo:
 374                         return 0444;
 375                 default:
 376                         break;
 377                 }
 378                 break;
 379         default:
 380                 break;
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int aqc_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
 387                     int channel, long *val)
 388 {
 389         int ret;
 390         struct aqc_data *priv = dev_get_drvdata(dev);
 391
 392         if (time_after(jiffies, priv->updated + STATUS_UPDATE_INTERVAL))
 393                 return -ENODATA;
 394
 395         switch (type) {
 396         case hwmon_temp:
 397                 if (priv->temp_input[channel] == -ENODATA)
 398                         return -ENODATA;
 399
 400                 *val = priv->temp_input[channel];
 401                 break;
 402         case hwmon_fan:
 403                 *val = priv->speed_input[channel];
 404                 break;
 405         case hwmon_power:
 406                 *val = priv->power_input[channel];
 407                 break;
 408         case hwmon_pwm:
 409                 switch (priv->kind) {
 410                 case octo:
 411                         ret = aqc_get_ctrl_val(priv, octo_ctrl_fan_offsets[channel]);
 412                         if (ret < 0)
 413                                 return ret;
 414
 415                         *val = aqc_percent_to_pwm(ret);
 416                         break;
 417                 default:
 418                         break;
 419                 }
 420                 break;
 421         case hwmon_in:
 422                 *val = priv->voltage_input[channel];
 423                 break;
 424         case hwmon_curr:
 425                 *val = priv->current_input[channel];
 426                 break;
 427         default:
 428                 return -EOPNOTSUPP;
 429         }
 430
 431         return 0;
 432 }
 433
 434 static int aqc_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
 435                            int channel, const char **str)
 436 {
 437         struct aqc_data *priv = dev_get_drvdata(dev);
 438
 439         switch (type) {
 440         case hwmon_temp:
 441                 *str = priv->temp_label[channel];
 442                 break;
 443         case hwmon_fan:
 444                 *str = priv->speed_label[channel];
 445                 break;
 446         case hwmon_power:
 447                 *str = priv->power_label[channel];
 448                 break;
 449         case hwmon_in:
 450                 *str = priv->voltage_label[channel];
 451                 break;
 452         case hwmon_curr:
 453                 *str = priv->current_label[channel];
 454                 break;
 455         default:
 456                 return -EOPNOTSUPP;
 457         }
 458
 459         return 0;
 460 }
 461
 462 static int aqc_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
 463                      long val)
 464 {
 465         int ret, pwm_value;
 466         struct aqc_data *priv = dev_get_drvdata(dev);
 467
 468         switch (type) {
 469         case hwmon_pwm:
 470                 switch (attr) {
 471                 case hwmon_pwm_input:
 472                         switch (priv->kind) {
 473                         case octo:
 474                                 pwm_value = aqc_pwm_to_percent(val);
 475                                 if (pwm_value < 0)
 476                                         return pwm_value;
 477
 478                                 ret = aqc_set_ctrl_val(priv, octo_ctrl_fan_offsets[channel],
 479                                                        pwm_value);
 480                                 if (ret < 0)
 481                                         return ret;
 482                                 break;
 483                         default:
 484                                 break;
 485                         }
 486                         break;
 487                 default:
 488                         break;
 489                 }
 490                 break;
 491         default:
 492                 return -EOPNOTSUPP;
 493         }
 494
 495         return 0;
 496 }
 497
 498 static const struct hwmon_ops aqc_hwmon_ops = {
 499         .is_visible = aqc_is_visible,
 500         .read = aqc_read,
 501         .read_string = aqc_read_string,
 502         .write = aqc_write
 503 };
 504
 505 static const struct hwmon_channel_info *aqc_info[] = {
 506         HWMON_CHANNEL_INFO(temp,
 507                            HWMON_T_INPUT | HWMON_T_LABEL,
 508                            HWMON_T_INPUT | HWMON_T_LABEL,
 509                            HWMON_T_INPUT | HWMON_T_LABEL,
 510                            HWMON_T_INPUT | HWMON_T_LABEL),
 511         HWMON_CHANNEL_INFO(fan,
 512                            HWMON_F_INPUT | HWMON_F_LABEL,
 513                            HWMON_F_INPUT | HWMON_F_LABEL,
 514                            HWMON_F_INPUT | HWMON_F_LABEL,
 515                            HWMON_F_INPUT | HWMON_F_LABEL,
 516                            HWMON_F_INPUT | HWMON_F_LABEL,
 517                            HWMON_F_INPUT | HWMON_F_LABEL,
 518                            HWMON_F_INPUT | HWMON_F_LABEL,
 519                            HWMON_F_INPUT | HWMON_F_LABEL),
 520         HWMON_CHANNEL_INFO(power,
 521                            HWMON_P_INPUT | HWMON_P_LABEL,
 522                            HWMON_P_INPUT | HWMON_P_LABEL,
 523                            HWMON_P_INPUT | HWMON_P_LABEL,
 524                            HWMON_P_INPUT | HWMON_P_LABEL,
 525                            HWMON_P_INPUT | HWMON_P_LABEL,
 526                            HWMON_P_INPUT | HWMON_P_LABEL,
 527                            HWMON_P_INPUT | HWMON_P_LABEL,
 528                            HWMON_P_INPUT | HWMON_P_LABEL),
 529         HWMON_CHANNEL_INFO(pwm,
 530                            HWMON_PWM_INPUT,
 531                            HWMON_PWM_INPUT,
 532                            HWMON_PWM_INPUT,
 533                            HWMON_PWM_INPUT,
 534                            HWMON_PWM_INPUT,
 535                            HWMON_PWM_INPUT,
 536                            HWMON_PWM_INPUT,
 537                            HWMON_PWM_INPUT),
 538         HWMON_CHANNEL_INFO(in,
 539                            HWMON_I_INPUT | HWMON_I_LABEL,
 540                            HWMON_I_INPUT | HWMON_I_LABEL,
 541                            HWMON_I_INPUT | HWMON_I_LABEL,
 542                            HWMON_I_INPUT | HWMON_I_LABEL,
 543                            HWMON_I_INPUT | HWMON_I_LABEL,
 544                            HWMON_I_INPUT | HWMON_I_LABEL,
 545                            HWMON_I_INPUT | HWMON_I_LABEL,
 546                            HWMON_I_INPUT | HWMON_I_LABEL),
 547         HWMON_CHANNEL_INFO(curr,
 548                            HWMON_C_INPUT | HWMON_C_LABEL,
 549                            HWMON_C_INPUT | HWMON_C_LABEL,
 550                            HWMON_C_INPUT | HWMON_C_LABEL,
 551                            HWMON_C_INPUT | HWMON_C_LABEL,
 552                            HWMON_C_INPUT | HWMON_C_LABEL,
 553                            HWMON_C_INPUT | HWMON_C_LABEL,
 554                            HWMON_C_INPUT | HWMON_C_LABEL,
 555                            HWMON_C_INPUT | HWMON_C_LABEL),
 556         NULL
 557 };
 558
 559 static const struct hwmon_chip_info aqc_chip_info = {
 560         .ops = &aqc_hwmon_ops,
 561         .info = aqc_info,
 562 };
 563
 564 static int aqc_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)
 565 {
 566         int i, sensor_value;
 567         struct aqc_data *priv;
 568
 569         if (report->id != STATUS_REPORT_ID)
 570                 return 0;
 571
 572         priv = hid_get_drvdata(hdev);
 573
 574         /* Info provided with every report */
 575         priv->serial_number[0] = get_unaligned_be16(data + SERIAL_FIRST_PART);
 576         priv->serial_number[1] = get_unaligned_be16(data + SERIAL_SECOND_PART);
 577         priv->firmware_version = get_unaligned_be16(data + FIRMWARE_VERSION);
 578
 579         /* Sensor readings */
 580         switch (priv->kind) {
 581         case d5next:
 582                 priv->power_cycles = get_unaligned_be32(data + D5NEXT_POWER_CYCLES);
 583
 584                 priv->temp_input[0] = get_unaligned_be16(data + D5NEXT_COOLANT_TEMP) * 10;
 585
 586                 priv->speed_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_SPEED);
 587                 priv->speed_input[1] = get_unaligned_be16(data + D5NEXT_FAN_SPEED);
 588
 589                 priv->power_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_POWER) * 10000;
 590                 priv->power_input[1] = get_unaligned_be16(data + D5NEXT_FAN_POWER) * 10000;
 591
 592                 priv->voltage_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_VOLTAGE) * 10;
 593                 priv->voltage_input[1] = get_unaligned_be16(data + D5NEXT_FAN_VOLTAGE) * 10;
 594                 priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10;
 595
 596                 priv->current_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_CURRENT);
 597                 priv->current_input[1] = get_unaligned_be16(data + D5NEXT_FAN_CURRENT);
 598                 break;
 599         case farbwerk:
 600                 /* Temperature sensor readings */
 601                 for (i = 0; i < FARBWERK_NUM_SENSORS; i++) {
 602                         sensor_value = get_unaligned_be16(data + FARBWERK_SENSOR_START +
 603                                                           i * FARBWERK_SENSOR_SIZE);
 604                         if (sensor_value == FARBWERK_SENSOR_DISCONNECTED)
 605                                 priv->temp_input[i] = -ENODATA;
 606                         else
 607                                 priv->temp_input[i] = sensor_value * 10;
 608                 }
 609                 break;
 610         case farbwerk360:
 611                 /* Temperature sensor readings */
 612                 for (i = 0; i < FARBWERK360_NUM_SENSORS; i++) {
 613                         sensor_value = get_unaligned_be16(data + FARBWERK360_SENSOR_START +
 614                                                           i * FARBWERK360_SENSOR_SIZE);
 615                         if (sensor_value == FARBWERK360_SENSOR_DISCONNECTED)
 616                                 priv->temp_input[i] = -ENODATA;
 617                         else
 618                                 priv->temp_input[i] = sensor_value * 10;
 619                 }
 620                 break;
 621         case octo:
 622                 priv->power_cycles = get_unaligned_be32(data + OCTO_POWER_CYCLES);
 623
 624                 /* Fan speed and related readings */
 625                 for (i = 0; i < OCTO_NUM_FANS; i++) {
 626                         priv->speed_input[i] =
 627                             get_unaligned_be16(data + octo_sensor_fan_offsets[i] +
 628                                                OCTO_FAN_SPEED_OFFSET);
 629                         priv->power_input[i] =
 630                             get_unaligned_be16(data + octo_sensor_fan_offsets[i] +
 631                                                OCTO_FAN_POWER_OFFSET) * 10000;
 632                         priv->voltage_input[i] =
 633                             get_unaligned_be16(data + octo_sensor_fan_offsets[i] +
 634                                                OCTO_FAN_VOLTAGE_OFFSET) * 10;
 635                         priv->current_input[i] =
 636                             get_unaligned_be16(data + octo_sensor_fan_offsets[i] +
 637                                                OCTO_FAN_CURRENT_OFFSET);
 638                 }
 639
 640                 /* Temperature sensor readings */
 641                 for (i = 0; i < OCTO_NUM_SENSORS; i++) {
 642                         sensor_value = get_unaligned_be16(data + OCTO_SENSOR_START +
 643                                                           i * OCTO_SENSOR_SIZE);
 644                         if (sensor_value == OCTO_SENSOR_DISCONNECTED)
 645                                 priv->temp_input[i] = -ENODATA;
 646                         else
 647                                 priv->temp_input[i] = sensor_value * 10;
 648                 }
 649                 break;
 650         default:
 651                 break;
 652         }
 653
 654         priv->updated = jiffies;
 655
 656         return 0;
 657 }
 658
 659 #ifdef CONFIG_DEBUG_FS
 660
 661 static int serial_number_show(struct seq_file *seqf, void *unused)
 662 {
 663         struct aqc_data *priv = seqf->private;
 664
 665         seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]);
 666
 667         return 0;
 668 }
 669 DEFINE_SHOW_ATTRIBUTE(serial_number);
 670
 671 static int firmware_version_show(struct seq_file *seqf, void *unused)
 672 {
 673         struct aqc_data *priv = seqf->private;
 674
 675         seq_printf(seqf, "%u\n", priv->firmware_version);
 676
 677         return 0;
 678 }
 679 DEFINE_SHOW_ATTRIBUTE(firmware_version);
 680
 681 static int power_cycles_show(struct seq_file *seqf, void *unused)
 682 {
 683         struct aqc_data *priv = seqf->private;
 684
 685         seq_printf(seqf, "%u\n", priv->power_cycles);
 686
 687         return 0;
 688 }
 689 DEFINE_SHOW_ATTRIBUTE(power_cycles);
 690
 691 static void aqc_debugfs_init(struct aqc_data *priv)
 692 {
 693         char name[64];
 694
 695         scnprintf(name, sizeof(name), "%s_%s-%s", "aquacomputer", priv->name,
 696                   dev_name(&priv->hdev->dev));
 697
 698         priv->debugfs = debugfs_create_dir(name, NULL);
 699         debugfs_create_file("serial_number", 0444, priv->debugfs, priv, &serial_number_fops);
 700         debugfs_create_file("firmware_version", 0444, priv->debugfs, priv, &firmware_version_fops);
 701
 702         switch (priv->kind) {
 703         case d5next:
 704         case octo:
 705                 debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops);
 706                 break;
 707         default:
 708                 break;
 709         }
 710 }
 711
 712 #else
 713
 714 static void aqc_debugfs_init(struct aqc_data *priv)
 715 {
 716 }
 717
 718 #endif
 719
 720 static int aqc_probe(struct hid_device *hdev, const struct hid_device_id *id)
 721 {
 722         struct aqc_data *priv;
 723         int ret;
 724
 725         priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
 726         if (!priv)
 727                 return -ENOMEM;
 728
 729         priv->hdev = hdev;
 730         hid_set_drvdata(hdev, priv);
 731
 732         priv->updated = jiffies - STATUS_UPDATE_INTERVAL;
 733
 734         ret = hid_parse(hdev);
 735         if (ret)
 736                 return ret;
 737
 738         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 739         if (ret)
 740                 return ret;
 741
 742         ret = hid_hw_open(hdev);
 743         if (ret)
 744                 goto fail_and_stop;
 745
 746         switch (hdev->product) {
 747         case USB_PRODUCT_ID_D5NEXT:
 748                 priv->kind = d5next;
 749
 750                 priv->temp_label = label_d5next_temp;
 751                 priv->speed_label = label_d5next_speeds;
 752                 priv->power_label = label_d5next_power;
 753                 priv->voltage_label = label_d5next_voltages;
 754                 priv->current_label = label_d5next_current;
 755                 break;
 756         case USB_PRODUCT_ID_FARBWERK:
 757                 priv->kind = farbwerk;
 758
 759                 priv->temp_label = label_temp_sensors;
 760                 break;
 761         case USB_PRODUCT_ID_FARBWERK360:
 762                 priv->kind = farbwerk360;
 763
 764                 priv->temp_label = label_temp_sensors;
 765                 break;
 766         case USB_PRODUCT_ID_OCTO:
 767                 priv->kind = octo;
 768                 priv->buffer_size = OCTO_CTRL_REPORT_SIZE;
 769                 priv->checksum_start = OCTO_CTRL_REPORT_CHECKSUM_START;
 770                 priv->checksum_length = OCTO_CTRL_REPORT_CHECKSUM_LENGTH;
 771                 priv->checksum_offset = OCTO_CTRL_REPORT_CHECKSUM_OFFSET;
 772
 773                 priv->temp_label = label_temp_sensors;
 774                 priv->speed_label = label_fan_speed;
 775                 priv->power_label = label_fan_power;
 776                 priv->voltage_label = label_fan_voltage;
 777                 priv->current_label = label_fan_current;
 778                 break;
 779         default:
 780                 break;
 781         }
 782
 783         priv->name = aqc_device_names[priv->kind];
 784
 785         priv->buffer = devm_kzalloc(&hdev->dev, priv->buffer_size, GFP_KERNEL);
 786         if (!priv->buffer) {
 787                 ret = -ENOMEM;
 788                 goto fail_and_close;
 789         }
 790
 791         mutex_init(&priv->mutex);
 792
 793         priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, priv->name, priv,
 794                                                           &aqc_chip_info, NULL);
 795
 796         if (IS_ERR(priv->hwmon_dev)) {
 797                 ret = PTR_ERR(priv->hwmon_dev);
 798                 goto fail_and_close;
 799         }
 800
 801         aqc_debugfs_init(priv);
 802
 803         return 0;
 804
 805 fail_and_close:
 806         hid_hw_close(hdev);
 807 fail_and_stop:
 808         hid_hw_stop(hdev);
 809         return ret;
 810 }
 811
 812 static void aqc_remove(struct hid_device *hdev)
 813 {
 814         struct aqc_data *priv = hid_get_drvdata(hdev);
 815
 816         debugfs_remove_recursive(priv->debugfs);
 817         hwmon_device_unregister(priv->hwmon_dev);
 818
 819         hid_hw_close(hdev);
 820         hid_hw_stop(hdev);
 821 }
 822
 823 static const struct hid_device_id aqc_table[] = {
 824         { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_D5NEXT) },
 825         { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK) },
 826         { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_FARBWERK360) },
 827         { HID_USB_DEVICE(USB_VENDOR_ID_AQUACOMPUTER, USB_PRODUCT_ID_OCTO) },
 828         { }
 829 };
 830
 831 MODULE_DEVICE_TABLE(hid, aqc_table);
 832
 833 static struct hid_driver aqc_driver = {
 834         .name = DRIVER_NAME,
 835         .id_table = aqc_table,
 836         .probe = aqc_probe,
 837         .remove = aqc_remove,
 838         .raw_event = aqc_raw_event,
 839 };
 840
 841 static int __init aqc_init(void)
 842 {
 843         return hid_register_driver(&aqc_driver);
 844 }
 845
 846 static void __exit aqc_exit(void)
 847 {
 848         hid_unregister_driver(&aqc_driver);
 849 }
 850
 851 /* Request to initialize after the HID bus to ensure it's not being loaded before */
 852 late_initcall(aqc_init);
 853 module_exit(aqc_exit);
 854
 855 MODULE_LICENSE("GPL");
 856 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
 857 MODULE_AUTHOR("Jack Doan <me@jackdoan.com>");
 858 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer devices");