drivers/hwmon/powerz.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Copyright (C) 2023 Thomas Weißschuh <linux@weissschuh.net>
   4  */
   5 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   6
   7 #include <linux/completion.h>
   8 #include <linux/device.h>
   9 #include <linux/hwmon.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/types.h>
  13 #include <linux/usb.h>
  14
  15 #define DRIVER_NAME     "powerz"
  16 #define POWERZ_EP_CMD_OUT       0x01
  17 #define POWERZ_EP_DATA_IN       0x81
  18
  19 struct powerz_sensor_data {
  20         u8 _unknown_1[8];
  21         __le32 V_bus;
  22         __le32 I_bus;
  23         __le32 V_bus_avg;
  24         __le32 I_bus_avg;
  25         u8 _unknown_2[8];
  26         u8 temp[2];
  27         __le16 V_cc1;
  28         __le16 V_cc2;
  29         __le16 V_dp;
  30         __le16 V_dm;
  31         __le16 V_dd;
  32         u8 _unknown_3[4];
  33 } __packed;
  34
  35 struct powerz_priv {
  36         char transfer_buffer[64];       /* first member to satisfy DMA alignment */
  37         struct mutex mutex;
  38         struct completion completion;
  39         struct urb *urb;
  40         int status;
  41 };
  42
  43 static const struct hwmon_channel_info *const powerz_info[] = {
  44         HWMON_CHANNEL_INFO(in,
  45                            HWMON_I_INPUT | HWMON_I_LABEL | HWMON_I_AVERAGE,
  46                            HWMON_I_INPUT | HWMON_I_LABEL,
  47                            HWMON_I_INPUT | HWMON_I_LABEL,
  48                            HWMON_I_INPUT | HWMON_I_LABEL,
  49                            HWMON_I_INPUT | HWMON_I_LABEL,
  50                            HWMON_I_INPUT | HWMON_I_LABEL),
  51         HWMON_CHANNEL_INFO(curr,
  52                            HWMON_C_INPUT | HWMON_C_LABEL | HWMON_C_AVERAGE),
  53             HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_LABEL),
  54         NULL
  55 };
  56
  57 static umode_t powerz_is_visible(const void *data, enum hwmon_sensor_types type,
  58                                  u32 attr, int channel)
  59 {
  60         return 0444;
  61 }
  62
  63 static int powerz_read_string(struct device *dev, enum hwmon_sensor_types type,
  64                               u32 attr, int channel, const char **str)
  65 {
  66         if (type == hwmon_curr && attr == hwmon_curr_label) {
  67                 *str = "IBUS";
  68         } else if (type == hwmon_in && attr == hwmon_in_label) {
  69                 if (channel == 0)
  70                         *str = "VBUS";
  71                 else if (channel == 1)
  72                         *str = "VCC1";
  73                 else if (channel == 2)
  74                         *str = "VCC2";
  75                 else if (channel == 3)
  76                         *str = "VDP";
  77                 else if (channel == 4)
  78                         *str = "VDM";
  79                 else if (channel == 5)
  80                         *str = "VDD";
  81                 else
  82                         return -EOPNOTSUPP;
  83         } else if (type == hwmon_temp && attr == hwmon_temp_label) {
  84                 *str = "TEMP";
  85         } else {
  86                 return -EOPNOTSUPP;
  87         }
  88
  89         return 0;
  90 }
  91
  92 static void powerz_usb_data_complete(struct urb *urb)
  93 {
  94         struct powerz_priv *priv = urb->context;
  95
  96         complete(&priv->completion);
  97 }
  98
  99 static void powerz_usb_cmd_complete(struct urb *urb)
 100 {
 101         struct powerz_priv *priv = urb->context;
 102
 103         usb_fill_bulk_urb(urb, urb->dev,
 104                           usb_rcvbulkpipe(urb->dev, POWERZ_EP_DATA_IN),
 105                           priv->transfer_buffer, sizeof(priv->transfer_buffer),
 106                           powerz_usb_data_complete, priv);
 107
 108         priv->status = usb_submit_urb(urb, GFP_ATOMIC);
 109         if (priv->status)
 110                 complete(&priv->completion);
 111 }
 112
 113 static int powerz_read_data(struct usb_device *udev, struct powerz_priv *priv)
 114 {
 115         int ret;
 116
 117         priv->status = -ETIMEDOUT;
 118         reinit_completion(&priv->completion);
 119
 120         priv->transfer_buffer[0] = 0x0c;
 121         priv->transfer_buffer[1] = 0x00;
 122         priv->transfer_buffer[2] = 0x02;
 123         priv->transfer_buffer[3] = 0x00;
 124
 125         usb_fill_bulk_urb(priv->urb, udev,
 126                           usb_sndbulkpipe(udev, POWERZ_EP_CMD_OUT),
 127                           priv->transfer_buffer, 4, powerz_usb_cmd_complete,
 128                           priv);
 129         ret = usb_submit_urb(priv->urb, GFP_KERNEL);
 130         if (ret)
 131                 return ret;
 132
 133         if (!wait_for_completion_interruptible_timeout
 134             (&priv->completion, msecs_to_jiffies(5))) {
 135                 usb_kill_urb(priv->urb);
 136                 return -EIO;
 137         }
 138
 139         if (priv->urb->actual_length < sizeof(struct powerz_sensor_data))
 140                 return -EIO;
 141
 142         return priv->status;
 143 }
 144
 145 static int powerz_read(struct device *dev, enum hwmon_sensor_types type,
 146                        u32 attr, int channel, long *val)
 147 {
 148         struct usb_interface *intf = to_usb_interface(dev->parent);
 149         struct usb_device *udev = interface_to_usbdev(intf);
 150         struct powerz_priv *priv = usb_get_intfdata(intf);
 151         struct powerz_sensor_data *data;
 152         int ret;
 153
 154         if (!priv)
 155                 return -EIO;    /* disconnected */
 156
 157         mutex_lock(&priv->mutex);
 158         ret = powerz_read_data(udev, priv);
 159         if (ret)
 160                 goto out;
 161
 162         data = (struct powerz_sensor_data *)priv->transfer_buffer;
 163
 164         if (type == hwmon_curr) {
 165                 if (attr == hwmon_curr_input)
 166                         *val = ((s32)le32_to_cpu(data->I_bus)) / 1000;
 167                 else if (attr == hwmon_curr_average)
 168                         *val = ((s32)le32_to_cpu(data->I_bus_avg)) / 1000;
 169                 else
 170                         ret = -EOPNOTSUPP;
 171         } else if (type == hwmon_in) {
 172                 if (attr == hwmon_in_input) {
 173                         if (channel == 0)
 174                                 *val = le32_to_cpu(data->V_bus) / 1000;
 175                         else if (channel == 1)
 176                                 *val = le16_to_cpu(data->V_cc1) / 10;
 177                         else if (channel == 2)
 178                                 *val = le16_to_cpu(data->V_cc2) / 10;
 179                         else if (channel == 3)
 180                                 *val = le16_to_cpu(data->V_dp) / 10;
 181                         else if (channel == 4)
 182                                 *val = le16_to_cpu(data->V_dm) / 10;
 183                         else if (channel == 5)
 184                                 *val = le16_to_cpu(data->V_dd) / 10;
 185                         else
 186                                 ret = -EOPNOTSUPP;
 187                 } else if (attr == hwmon_in_average && channel == 0) {
 188                         *val = le32_to_cpu(data->V_bus_avg) / 1000;
 189                 } else {
 190                         ret = -EOPNOTSUPP;
 191                 }
 192         } else if (type == hwmon_temp && attr == hwmon_temp_input) {
 193                 *val = data->temp[1] * 2000 + data->temp[0] * 1000 / 128;
 194         } else {
 195                 ret = -EOPNOTSUPP;
 196         }
 197
 198 out:
 199         mutex_unlock(&priv->mutex);
 200         return ret;
 201 }
 202
 203 static const struct hwmon_ops powerz_hwmon_ops = {
 204         .is_visible = powerz_is_visible,
 205         .read = powerz_read,
 206         .read_string = powerz_read_string,
 207 };
 208
 209 static const struct hwmon_chip_info powerz_chip_info = {
 210         .ops = &powerz_hwmon_ops,
 211         .info = powerz_info,
 212 };
 213
 214 static int powerz_probe(struct usb_interface *intf,
 215                         const struct usb_device_id *id)
 216 {
 217         struct powerz_priv *priv;
 218         struct device *hwmon_dev;
 219         struct device *parent;
 220
 221         parent = &intf->dev;
 222
 223         priv = devm_kzalloc(parent, sizeof(*priv), GFP_KERNEL);
 224         if (!priv)
 225                 return -ENOMEM;
 226
 227         priv->urb = usb_alloc_urb(0, GFP_KERNEL);
 228         if (!priv->urb)
 229                 return -ENOMEM;
 230         mutex_init(&priv->mutex);
 231         init_completion(&priv->completion);
 232
 233         hwmon_dev =
 234             devm_hwmon_device_register_with_info(parent, DRIVER_NAME, priv,
 235                                                  &powerz_chip_info, NULL);
 236         if (IS_ERR(hwmon_dev)) {
 237                 usb_free_urb(priv->urb);
 238                 return PTR_ERR(hwmon_dev);
 239         }
 240
 241         usb_set_intfdata(intf, priv);
 242
 243         return 0;
 244 }
 245
 246 static void powerz_disconnect(struct usb_interface *intf)
 247 {
 248         struct powerz_priv *priv = usb_get_intfdata(intf);
 249
 250         mutex_lock(&priv->mutex);
 251         usb_kill_urb(priv->urb);
 252         usb_free_urb(priv->urb);
 253         mutex_unlock(&priv->mutex);
 254 }
 255
 256 static const struct usb_device_id powerz_id_table[] = {
 257         { USB_DEVICE_INTERFACE_NUMBER(0x5FC9, 0x0061, 0x00) },  /* ChargerLAB POWER-Z KM002C */
 258         { USB_DEVICE_INTERFACE_NUMBER(0x5FC9, 0x0063, 0x00) },  /* ChargerLAB POWER-Z KM003C */
 259         { }
 260 };
 261
 262 MODULE_DEVICE_TABLE(usb, powerz_id_table);
 263
 264 static struct usb_driver powerz_driver = {
 265         .name = DRIVER_NAME,
 266         .id_table = powerz_id_table,
 267         .probe = powerz_probe,
 268         .disconnect = powerz_disconnect,
 269 };
 270
 271 module_usb_driver(powerz_driver);
 272
 273 MODULE_LICENSE("GPL");
 274 MODULE_AUTHOR("Thomas Weißschuh <linux@weissschuh.net>");
 275 MODULE_DESCRIPTION("ChargerLAB POWER-Z USB-C tester");