drivers/hwmon/aquacomputer_d5next.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * hwmon driver for Aquacomputer D5 Next watercooling pump
   4  *
   5  * The D5 Next sends HID reports (with ID 0x01) every second to report sensor values
   6  * (coolant temperature, pump and fan speed, voltage, current and power). It responds to
   7  * Get_Report requests, but returns a dummy value of no use.
   8  *
   9  * Copyright 2021 Aleksa Savic <savicaleksa83@gmail.com>
  10  */
  11
  12 #include <asm/unaligned.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/seq_file.h>
  19
  20 #define DRIVER_NAME                     "aquacomputer-d5next"
  21
  22 #define D5NEXT_STATUS_REPORT_ID 0x01
  23 #define D5NEXT_STATUS_UPDATE_INTERVAL   (2 * HZ) /* In seconds */
  24
  25 /* Register offsets for the D5 Next pump */
  26
  27 #define D5NEXT_SERIAL_FIRST_PART        3
  28 #define D5NEXT_SERIAL_SECOND_PART       5
  29 #define D5NEXT_FIRMWARE_VERSION 13
  30 #define D5NEXT_POWER_CYCLES             24
  31
  32 #define D5NEXT_COOLANT_TEMP             87
  33
  34 #define D5NEXT_PUMP_SPEED               116
  35 #define D5NEXT_FAN_SPEED                103
  36
  37 #define D5NEXT_PUMP_POWER               114
  38 #define D5NEXT_FAN_POWER                101
  39
  40 #define D5NEXT_PUMP_VOLTAGE             110
  41 #define D5NEXT_FAN_VOLTAGE              97
  42 #define D5NEXT_5V_VOLTAGE               57
  43
  44 #define D5NEXT_PUMP_CURRENT             112
  45 #define D5NEXT_FAN_CURRENT              99
  46
  47 /* Labels for provided values */
  48
  49 #define L_COOLANT_TEMP                  "Coolant temp"
  50
  51 #define L_PUMP_SPEED                    "Pump speed"
  52 #define L_FAN_SPEED                     "Fan speed"
  53
  54 #define L_PUMP_POWER                    "Pump power"
  55 #define L_FAN_POWER                     "Fan power"
  56
  57 #define L_PUMP_VOLTAGE                  "Pump voltage"
  58 #define L_FAN_VOLTAGE                   "Fan voltage"
  59 #define L_5V_VOLTAGE                    "+5V voltage"
  60
  61 #define L_PUMP_CURRENT                  "Pump current"
  62 #define L_FAN_CURRENT                   "Fan current"
  63
  64 static const char *const label_speeds[] = {
  65         L_PUMP_SPEED,
  66         L_FAN_SPEED,
  67 };
  68
  69 static const char *const label_power[] = {
  70         L_PUMP_POWER,
  71         L_FAN_POWER,
  72 };
  73
  74 static const char *const label_voltages[] = {
  75         L_PUMP_VOLTAGE,
  76         L_FAN_VOLTAGE,
  77         L_5V_VOLTAGE,
  78 };
  79
  80 static const char *const label_current[] = {
  81         L_PUMP_CURRENT,
  82         L_FAN_CURRENT,
  83 };
  84
  85 struct d5next_data {
  86         struct hid_device *hdev;
  87         struct device *hwmon_dev;
  88         struct dentry *debugfs;
  89         s32 temp_input;
  90         u16 speed_input[2];
  91         u32 power_input[2];
  92         u16 voltage_input[3];
  93         u16 current_input[2];
  94         u32 serial_number[2];
  95         u16 firmware_version;
  96         u32 power_cycles; /* How many times the device was powered on */
  97         unsigned long updated;
  98 };
  99
 100 static umode_t d5next_is_visible(const void *data, enum hwmon_sensor_types type, u32 attr,
 101                                  int channel)
 102 {
 103         return 0444;
 104 }
 105
 106 static int d5next_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
 107                        long *val)
 108 {
 109         struct d5next_data *priv = dev_get_drvdata(dev);
 110
 111         if (time_after(jiffies, priv->updated + D5NEXT_STATUS_UPDATE_INTERVAL))
 112                 return -ENODATA;
 113
 114         switch (type) {
 115         case hwmon_temp:
 116                 *val = priv->temp_input;
 117                 break;
 118         case hwmon_fan:
 119                 *val = priv->speed_input[channel];
 120                 break;
 121         case hwmon_power:
 122                 *val = priv->power_input[channel];
 123                 break;
 124         case hwmon_in:
 125                 *val = priv->voltage_input[channel];
 126                 break;
 127         case hwmon_curr:
 128                 *val = priv->current_input[channel];
 129                 break;
 130         default:
 131                 return -EOPNOTSUPP;
 132         }
 133
 134         return 0;
 135 }
 136
 137 static int d5next_read_string(struct device *dev, enum hwmon_sensor_types type, u32 attr,
 138                               int channel, const char **str)
 139 {
 140         switch (type) {
 141         case hwmon_temp:
 142                 *str = L_COOLANT_TEMP;
 143                 break;
 144         case hwmon_fan:
 145                 *str = label_speeds[channel];
 146                 break;
 147         case hwmon_power:
 148                 *str = label_power[channel];
 149                 break;
 150         case hwmon_in:
 151                 *str = label_voltages[channel];
 152                 break;
 153         case hwmon_curr:
 154                 *str = label_current[channel];
 155                 break;
 156         default:
 157                 return -EOPNOTSUPP;
 158         }
 159
 160         return 0;
 161 }
 162
 163 static const struct hwmon_ops d5next_hwmon_ops = {
 164         .is_visible = d5next_is_visible,
 165         .read = d5next_read,
 166         .read_string = d5next_read_string,
 167 };
 168
 169 static const struct hwmon_channel_info *d5next_info[] = {
 170         HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_LABEL),
 171         HWMON_CHANNEL_INFO(fan, HWMON_F_INPUT | HWMON_F_LABEL, HWMON_F_INPUT | HWMON_F_LABEL),
 172         HWMON_CHANNEL_INFO(power, HWMON_P_INPUT | HWMON_P_LABEL, HWMON_P_INPUT | HWMON_P_LABEL),
 173         HWMON_CHANNEL_INFO(in, HWMON_I_INPUT | HWMON_I_LABEL, HWMON_I_INPUT | HWMON_I_LABEL,
 174                            HWMON_I_INPUT | HWMON_I_LABEL),
 175         HWMON_CHANNEL_INFO(curr, HWMON_C_INPUT | HWMON_C_LABEL, HWMON_C_INPUT | HWMON_C_LABEL),
 176         NULL
 177 };
 178
 179 static const struct hwmon_chip_info d5next_chip_info = {
 180         .ops = &d5next_hwmon_ops,
 181         .info = d5next_info,
 182 };
 183
 184 static int d5next_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size)
 185 {
 186         struct d5next_data *priv;
 187
 188         if (report->id != D5NEXT_STATUS_REPORT_ID)
 189                 return 0;
 190
 191         priv = hid_get_drvdata(hdev);
 192
 193         /* Info provided with every report */
 194
 195         priv->serial_number[0] = get_unaligned_be16(data + D5NEXT_SERIAL_FIRST_PART);
 196         priv->serial_number[1] = get_unaligned_be16(data + D5NEXT_SERIAL_SECOND_PART);
 197
 198         priv->firmware_version = get_unaligned_be16(data + D5NEXT_FIRMWARE_VERSION);
 199         priv->power_cycles = get_unaligned_be32(data + D5NEXT_POWER_CYCLES);
 200
 201         /* Sensor readings */
 202
 203         priv->temp_input = get_unaligned_be16(data + D5NEXT_COOLANT_TEMP) * 10;
 204
 205         priv->speed_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_SPEED);
 206         priv->speed_input[1] = get_unaligned_be16(data + D5NEXT_FAN_SPEED);
 207
 208         priv->power_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_POWER) * 10000;
 209         priv->power_input[1] = get_unaligned_be16(data + D5NEXT_FAN_POWER) * 10000;
 210
 211         priv->voltage_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_VOLTAGE) * 10;
 212         priv->voltage_input[1] = get_unaligned_be16(data + D5NEXT_FAN_VOLTAGE) * 10;
 213         priv->voltage_input[2] = get_unaligned_be16(data + D5NEXT_5V_VOLTAGE) * 10;
 214
 215         priv->current_input[0] = get_unaligned_be16(data + D5NEXT_PUMP_CURRENT);
 216         priv->current_input[1] = get_unaligned_be16(data + D5NEXT_FAN_CURRENT);
 217
 218         priv->updated = jiffies;
 219
 220         return 0;
 221 }
 222
 223 #ifdef CONFIG_DEBUG_FS
 224
 225 static int serial_number_show(struct seq_file *seqf, void *unused)
 226 {
 227         struct d5next_data *priv = seqf->private;
 228
 229         seq_printf(seqf, "%05u-%05u\n", priv->serial_number[0], priv->serial_number[1]);
 230
 231         return 0;
 232 }
 233 DEFINE_SHOW_ATTRIBUTE(serial_number);
 234
 235 static int firmware_version_show(struct seq_file *seqf, void *unused)
 236 {
 237         struct d5next_data *priv = seqf->private;
 238
 239         seq_printf(seqf, "%u\n", priv->firmware_version);
 240
 241         return 0;
 242 }
 243 DEFINE_SHOW_ATTRIBUTE(firmware_version);
 244
 245 static int power_cycles_show(struct seq_file *seqf, void *unused)
 246 {
 247         struct d5next_data *priv = seqf->private;
 248
 249         seq_printf(seqf, "%u\n", priv->power_cycles);
 250
 251         return 0;
 252 }
 253 DEFINE_SHOW_ATTRIBUTE(power_cycles);
 254
 255 static void d5next_debugfs_init(struct d5next_data *priv)
 256 {
 257         char name[32];
 258
 259         scnprintf(name, sizeof(name), "%s-%s", DRIVER_NAME, dev_name(&priv->hdev->dev));
 260
 261         priv->debugfs = debugfs_create_dir(name, NULL);
 262         debugfs_create_file("serial_number", 0444, priv->debugfs, priv, &serial_number_fops);
 263         debugfs_create_file("firmware_version", 0444, priv->debugfs, priv, &firmware_version_fops);
 264         debugfs_create_file("power_cycles", 0444, priv->debugfs, priv, &power_cycles_fops);
 265 }
 266
 267 #else
 268
 269 static void d5next_debugfs_init(struct d5next_data *priv)
 270 {
 271 }
 272
 273 #endif
 274
 275 static int d5next_probe(struct hid_device *hdev, const struct hid_device_id *id)
 276 {
 277         struct d5next_data *priv;
 278         int ret;
 279
 280         priv = devm_kzalloc(&hdev->dev, sizeof(*priv), GFP_KERNEL);
 281         if (!priv)
 282                 return -ENOMEM;
 283
 284         priv->hdev = hdev;
 285         hid_set_drvdata(hdev, priv);
 286
 287         priv->updated = jiffies - D5NEXT_STATUS_UPDATE_INTERVAL;
 288
 289         ret = hid_parse(hdev);
 290         if (ret)
 291                 return ret;
 292
 293         ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
 294         if (ret)
 295                 return ret;
 296
 297         ret = hid_hw_open(hdev);
 298         if (ret)
 299                 goto fail_and_stop;
 300
 301         priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "d5next", priv,
 302                                                           &d5next_chip_info, NULL);
 303
 304         if (IS_ERR(priv->hwmon_dev)) {
 305                 ret = PTR_ERR(priv->hwmon_dev);
 306                 goto fail_and_close;
 307         }
 308
 309         d5next_debugfs_init(priv);
 310
 311         return 0;
 312
 313 fail_and_close:
 314         hid_hw_close(hdev);
 315 fail_and_stop:
 316         hid_hw_stop(hdev);
 317         return ret;
 318 }
 319
 320 static void d5next_remove(struct hid_device *hdev)
 321 {
 322         struct d5next_data *priv = hid_get_drvdata(hdev);
 323
 324         debugfs_remove_recursive(priv->debugfs);
 325         hwmon_device_unregister(priv->hwmon_dev);
 326
 327         hid_hw_close(hdev);
 328         hid_hw_stop(hdev);
 329 }
 330
 331 static const struct hid_device_id d5next_table[] = {
 332         { HID_USB_DEVICE(0x0c70, 0xf00e) }, /* Aquacomputer D5 Next */
 333         {},
 334 };
 335
 336 MODULE_DEVICE_TABLE(hid, d5next_table);
 337
 338 static struct hid_driver d5next_driver = {
 339         .name = DRIVER_NAME,
 340         .id_table = d5next_table,
 341         .probe = d5next_probe,
 342         .remove = d5next_remove,
 343         .raw_event = d5next_raw_event,
 344 };
 345
 346 static int __init d5next_init(void)
 347 {
 348         return hid_register_driver(&d5next_driver);
 349 }
 350
 351 static void __exit d5next_exit(void)
 352 {
 353         hid_unregister_driver(&d5next_driver);
 354 }
 355
 356 /* Request to initialize after the HID bus to ensure it's not being loaded before */
 357
 358 late_initcall(d5next_init);
 359 module_exit(d5next_exit);
 360
 361 MODULE_LICENSE("GPL");
 362 MODULE_AUTHOR("Aleksa Savic <savicaleksa83@gmail.com>");
 363 MODULE_DESCRIPTION("Hwmon driver for Aquacomputer D5 Next pump");