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