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, dev: urb->dev, |
104 | usb_rcvbulkpipe(urb->dev, POWERZ_EP_DATA_IN), |
105 | transfer_buffer: priv->transfer_buffer, buffer_length: sizeof(priv->transfer_buffer), |
106 | complete_fn: powerz_usb_data_complete, context: 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(x: &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(urb: priv->urb, dev: udev, |
126 | usb_sndbulkpipe(udev, POWERZ_EP_CMD_OUT), |
127 | transfer_buffer: priv->transfer_buffer, buffer_length: 4, complete_fn: powerz_usb_cmd_complete, |
128 | context: priv); |
129 | ret = usb_submit_urb(urb: priv->urb, GFP_KERNEL); |
130 | if (ret) |
131 | return ret; |
132 | |
133 | if (!wait_for_completion_interruptible_timeout |
134 | (x: &priv->completion, timeout: msecs_to_jiffies(m: 5))) { |
135 | usb_kill_urb(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(lock: &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(dev: parent, size: sizeof(*priv), GFP_KERNEL); |
224 | if (!priv) |
225 | return -ENOMEM; |
226 | |
227 | priv->urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
228 | if (!priv->urb) |
229 | return -ENOMEM; |
230 | mutex_init(&priv->mutex); |
231 | init_completion(x: &priv->completion); |
232 | |
233 | hwmon_dev = |
234 | devm_hwmon_device_register_with_info(dev: parent, DRIVER_NAME, drvdata: priv, |
235 | info: &powerz_chip_info, NULL); |
236 | if (IS_ERR(ptr: hwmon_dev)) { |
237 | usb_free_urb(urb: priv->urb); |
238 | return PTR_ERR(ptr: hwmon_dev); |
239 | } |
240 | |
241 | usb_set_intfdata(intf, data: 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(urb: priv->urb); |
252 | usb_free_urb(urb: priv->urb); |
253 | mutex_unlock(lock: &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" ); |
276 | |