POWER-Z is a series of devices to monitor power characteristics of USB-C connections and display those on a on-device display. Some of the devices, notably KM002C and KM003C, contain an additional port which exposes the measurements via USB. This is a driver for this monitor port. It was developed and tested with the KM003C. Signed-off-by: Thomas Weißschuh <linux@xxxxxxxxxxxxxx> --- Changes in v2: - fix syntax error in Kconfig - avoid double free of urb in case of failure - Link to v1: https://lore.kernel.org/r/20230831-powerz-v1-1-03979e519f52@xxxxxxxxxxxxxx --- MAINTAINERS | 6 ++ drivers/hwmon/Kconfig | 10 ++ drivers/hwmon/Makefile | 1 + drivers/hwmon/powerz.c | 257 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 274 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 4e3419c04f27..12bcf14597c4 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -4795,6 +4795,12 @@ X: drivers/char/ipmi/ X: drivers/char/random.c X: drivers/char/tpm/ +CHARGERLAB POWER-Z HARDWARE MONITOR DRIVER +M: Thomas Weißschuh <linux@xxxxxxxxxxxxxx> +L: linux-hwmon@xxxxxxxxxxxxxxx +S: Maintained +F: drivers/hwmon/powerz.c + CHECKPATCH M: Andy Whitcroft <apw@xxxxxxxxxxxxx> M: Joe Perches <joe@xxxxxxxxxxx> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig index ec38c8892158..12af9f9cfd9f 100644 --- a/drivers/hwmon/Kconfig +++ b/drivers/hwmon/Kconfig @@ -839,6 +839,16 @@ config SENSORS_JC42 This driver can also be built as a module. If so, the module will be called jc42. +config SENSORS_POWERZ + tristate "ChargerLAB POWER-Z USB-C tester" + depends on USB + help + If you say yes here you get support for ChargerLAB POWER-Z series of + USB-C charging testers. + + This driver can also be built as a module. If so, the module + will be called powerz. + config SENSORS_POWR1220 tristate "Lattice POWR1220 Power Monitoring" depends on I2C diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile index 4ac9452b5430..019189500e5d 100644 --- a/drivers/hwmon/Makefile +++ b/drivers/hwmon/Makefile @@ -176,6 +176,7 @@ obj-$(CONFIG_SENSORS_OXP) += oxp-sensors.o obj-$(CONFIG_SENSORS_PC87360) += pc87360.o obj-$(CONFIG_SENSORS_PC87427) += pc87427.o obj-$(CONFIG_SENSORS_PCF8591) += pcf8591.o +obj-$(CONFIG_SENSORS_POWERZ) += powerz.o obj-$(CONFIG_SENSORS_POWR1220) += powr1220.o obj-$(CONFIG_SENSORS_PWM_FAN) += pwm-fan.o obj-$(CONFIG_SENSORS_RASPBERRYPI_HWMON) += raspberrypi-hwmon.o diff --git a/drivers/hwmon/powerz.c b/drivers/hwmon/powerz.c new file mode 100644 index 000000000000..cbdbc1ce0e81 --- /dev/null +++ b/drivers/hwmon/powerz.c @@ -0,0 +1,257 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Copyright (C) 2023 Thomas Weißschuh <linux@xxxxxxxxxxxxxx> + */ +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/completion.h> +#include <linux/hwmon.h> +#include <linux/module.h> +#include <linux/usb.h> + +#define DRIVER_NAME "powerz" +#define POWERZ_EP_CMD_OUT 0x01 +#define POWERZ_EP_DATA_IN 0x81 + +struct powerz_sensor_data { + u8 _unknown_1[8]; + __le32 Vbus; + __le32 Ibus; + __le32 Vbus_avg; + __le32 Ibus_avg; + u8 _unknown_2[8]; + u8 temp[2]; + __le16 cc1; + __le16 cc2; + __le16 dp; + __le16 dm; + u8 _unknown_3[6]; +} __packed; + +struct powerz_priv { + struct device *hwmon_dev; + struct usb_interface *intf; +}; + +static const struct hwmon_channel_info * const powerz_info[] = { + HWMON_CHANNEL_INFO(in, + HWMON_I_INPUT | HWMON_I_LABEL | HWMON_I_AVERAGE, + HWMON_I_INPUT | HWMON_I_LABEL, + HWMON_I_INPUT | HWMON_I_LABEL, + HWMON_I_INPUT | HWMON_I_LABEL, + HWMON_I_INPUT | HWMON_I_LABEL), + HWMON_CHANNEL_INFO(curr, HWMON_C_INPUT | HWMON_C_LABEL | HWMON_C_AVERAGE), + HWMON_CHANNEL_INFO(temp, HWMON_T_INPUT | HWMON_T_LABEL), + NULL +}; + +static umode_t powerz_is_visible(const void *data, enum hwmon_sensor_types type, + u32 attr, int channel) +{ + return 0444; +} + +static int powerz_read_string(struct device *dev, enum hwmon_sensor_types type, + u32 attr, int channel, const char **str) +{ + if (type == hwmon_curr && attr == hwmon_curr_label) + *str = "bus"; + else if (type == hwmon_in && attr == hwmon_in_label && channel == 0) + *str = "bus"; + else if (type == hwmon_in && attr == hwmon_in_label && channel == 1) + *str = "cc1"; + else if (type == hwmon_in && attr == hwmon_in_label && channel == 2) + *str = "cc2"; + else if (type == hwmon_in && attr == hwmon_in_label && channel == 3) + *str = "dp"; + else if (type == hwmon_in && attr == hwmon_in_label && channel == 4) + *str = "dm"; + else if (type == hwmon_temp && attr == hwmon_temp_label) + *str = "temp"; + else + return -EINVAL; + + return 0; +} + +struct powerz_usb_ctx { + char transfer_buffer[64]; + struct completion completion; + int status; +}; + +static void powerz_usb_data_complete(struct urb *urb) +{ + struct powerz_usb_ctx *ctx = urb->context; + + ctx->status = 0; + complete(&ctx->completion); +} + +static void powerz_usb_cmd_complete(struct urb *urb) +{ + struct powerz_usb_ctx *ctx = urb->context; + int ret; + + usb_fill_bulk_urb(urb, urb->dev, usb_rcvbulkpipe(urb->dev, POWERZ_EP_DATA_IN), + ctx->transfer_buffer, sizeof(ctx->transfer_buffer), + powerz_usb_data_complete, ctx); + + ret = usb_submit_urb(urb, GFP_ATOMIC); + if (ret) { + ctx->status = ret; + complete(&ctx->completion); + } +} + +static struct powerz_sensor_data *powerz_read_data(struct usb_device *udev, + struct powerz_usb_ctx *ctx) +{ + struct urb *urb; + int r; + + ctx->status = -ETIMEDOUT; + init_completion(&ctx->completion); + + urb = usb_alloc_urb(0, GFP_KERNEL); + if (!urb) + return ERR_PTR(-ENOMEM); + + ctx->transfer_buffer[0] = 0x0c; + ctx->transfer_buffer[1] = 0x00; + ctx->transfer_buffer[2] = 0x02; + ctx->transfer_buffer[3] = 0x00; + + usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, POWERZ_EP_CMD_OUT), + ctx->transfer_buffer, 4, powerz_usb_cmd_complete, ctx); + r = usb_submit_urb(urb, GFP_KERNEL); + if (r) { + usb_free_urb(urb); + return ERR_PTR(r); + } + + if (!wait_for_completion_interruptible_timeout(&ctx->completion, msecs_to_jiffies(5))) { + usb_kill_urb(urb); + usb_free_urb(urb); + return ERR_PTR(-EIO); + } + + if (ctx->status) { + usb_free_urb(urb); + return ERR_PTR(ctx->status); + } + + if (urb->actual_length < (sizeof(struct powerz_sensor_data))) { + usb_free_urb(urb); + return ERR_PTR(-EIO); + } + + usb_free_urb(urb); + return (struct powerz_sensor_data *)(ctx->transfer_buffer); +} + +static int powerz_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, + int channel, long *val) +{ + struct usb_interface *intf = to_usb_interface(dev->parent); + struct usb_device *udev = interface_to_usbdev(intf); + struct powerz_sensor_data *data; + struct powerz_usb_ctx *ctx; + + ctx = kmalloc(sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + + data = powerz_read_data(udev, ctx); + if (IS_ERR(data)) { + kfree(ctx); + return PTR_ERR(data); + } + + if (type == hwmon_curr && attr == hwmon_curr_input) + *val = ((s32)le32_to_cpu(data->Ibus)) / 1000; + else if (type == hwmon_curr && attr == hwmon_curr_average) + *val = ((s32)le32_to_cpu(data->Ibus_avg)) / 1000; + else if (type == hwmon_in && attr == hwmon_in_input && channel == 0) + *val = le32_to_cpu(data->Vbus) / 1000; + else if (type == hwmon_in && attr == hwmon_in_average && channel == 0) + *val = le32_to_cpu(data->Vbus_avg) / 1000; + else if (type == hwmon_in && attr == hwmon_in_input && channel == 1) + *val = le16_to_cpu(data->cc1) / 10; + else if (type == hwmon_in && attr == hwmon_in_input && channel == 2) + *val = le16_to_cpu(data->cc2) / 10; + else if (type == hwmon_in && attr == hwmon_in_input && channel == 3) + *val = le16_to_cpu(data->dp) / 10; + else if (type == hwmon_in && attr == hwmon_in_input && channel == 4) + *val = le16_to_cpu(data->dm) / 10; + else if (type == hwmon_temp && attr == hwmon_temp_input) + *val = ((long)data->temp[1]) * 2000 + ((long)data->temp[0]) * 1000 / 128; + else + return -EINVAL; + + kfree(ctx); + + return 0; +} + +static const struct hwmon_ops powerz_hwmon_ops = { + .is_visible = powerz_is_visible, + .read = powerz_read, + .read_string = powerz_read_string, +}; + +static const struct hwmon_chip_info powerz_chip_info = { + .ops = &powerz_hwmon_ops, + .info = powerz_info, +}; + +static int powerz_probe(struct usb_interface *intf, const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(intf); + struct powerz_priv *priv; + struct device *parent; + const char *name; + int ret; + + parent = &intf->dev; + + priv = devm_kzalloc(parent, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + name = devm_hwmon_sanitize_name(parent, udev->product ?: DRIVER_NAME); + priv->hwmon_dev = hwmon_device_register_with_info(parent, name, + priv, + &powerz_chip_info, + NULL); + ret = PTR_ERR_OR_ZERO(priv->hwmon_dev); + priv->intf = intf; + usb_set_intfdata(intf, priv); + + return ret; +} + +static void powerz_disconnect(struct usb_interface *intf) +{ + struct powerz_priv *priv = usb_get_intfdata(intf); + + hwmon_device_unregister(priv->hwmon_dev); +} + +static const struct usb_device_id powerz_id_table[] = { + { USB_DEVICE_INTERFACE_NUMBER(0x5FC9, 0x0063, 0x00) }, /* ChargerLAB POWER-Z KM003C */ + { } +}; +MODULE_DEVICE_TABLE(usb, powerz_id_table); + +static struct usb_driver powerz_driver = { + .name = DRIVER_NAME, + .id_table = powerz_id_table, + .probe = powerz_probe, + .disconnect = powerz_disconnect, +}; +module_usb_driver(powerz_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Thomas Weißschuh <linux@xxxxxxxxxxxxxx>"); +MODULE_DESCRIPTION("ChargerLAB POWER-Z USB-C tester"); --- base-commit: b97d64c722598ffed42ece814a2cb791336c6679 change-id: 20230831-powerz-2ccb978a8e57 Best regards, -- Thomas Weißschuh <linux@xxxxxxxxxxxxxx>
