xref: /linux-6.15/drivers/usb/typec/bus.c (revision 9920184d) 
1 // SPDX-License-Identifier: GPL-2.0
2 /**
3  * Bus for USB Type-C Alternate Modes
4  *
5  * Copyright (C) 2018 Intel Corporation
6  * Author: Heikki Krogerus <[email protected]>
7  */
8 
9 #include <linux/usb/pd_vdo.h>
10 
11 #include "bus.h"
12 
13 static inline int typec_altmode_set_mux(struct altmode *alt, u8 state)
14 {
15 	return alt->mux ? alt->mux->set(alt->mux, state) : 0;
16 }
17 
18 static int typec_altmode_set_state(struct typec_altmode *adev, int state)
19 {
20 	bool is_port = is_typec_port(adev->dev.parent);
21 	struct altmode *port_altmode;
22 	int ret;
23 
24 	port_altmode = is_port ? to_altmode(adev) : to_altmode(adev)->partner;
25 
26 	ret = typec_altmode_set_mux(port_altmode, state);
27 	if (ret)
28 		return ret;
29 
30 	blocking_notifier_call_chain(&port_altmode->nh, state, NULL);
31 
32 	return 0;
33 }
34 
35 /* -------------------------------------------------------------------------- */
36 /* Common API */
37 
38 /**
39  * typec_altmode_notify - Communication between the OS and alternate mode driver
40  * @adev: Handle to the alternate mode
41  * @conf: Alternate mode specific configuration value
42  * @data: Alternate mode specific data
43  *
44  * The primary purpose for this function is to allow the alternate mode drivers
45  * to tell which pin configuration has been negotiated with the partner. That
46  * information will then be used for example to configure the muxes.
47  * Communication to the other direction is also possible, and low level device
48  * drivers can also send notifications to the alternate mode drivers. The actual
49  * communication will be specific for every SVID.
50  */
51 int typec_altmode_notify(struct typec_altmode *adev,
52 			 unsigned long conf, void *data)
53 {
54 	bool is_port;
55 	struct altmode *altmode;
56 	struct altmode *partner;
57 	int ret;
58 
59 	if (!adev)
60 		return 0;
61 
62 	altmode = to_altmode(adev);
63 
64 	if (!altmode->partner)
65 		return -ENODEV;
66 
67 	is_port = is_typec_port(adev->dev.parent);
68 	partner = altmode->partner;
69 
70 	ret = typec_altmode_set_mux(is_port ? altmode : partner, (u8)conf);
71 	if (ret)
72 		return ret;
73 
74 	blocking_notifier_call_chain(is_port ? &altmode->nh : &partner->nh,
75 				     conf, data);
76 
77 	if (partner->adev.ops && partner->adev.ops->notify)
78 		return partner->adev.ops->notify(&partner->adev, conf, data);
79 
80 	return 0;
81 }
82 EXPORT_SYMBOL_GPL(typec_altmode_notify);
83 
84 /**
85  * typec_altmode_enter - Enter Mode
86  * @adev: The alternate mode
87  *
88  * The alternate mode drivers use this function to enter mode. The port drivers
89  * use this to inform the alternate mode drivers that the partner has initiated
90  * Enter Mode command.
91  */
92 int typec_altmode_enter(struct typec_altmode *adev)
93 {
94 	struct altmode *partner = to_altmode(adev)->partner;
95 	struct typec_altmode *pdev = &partner->adev;
96 	int ret;
97 
98 	if (!adev || adev->active)
99 		return 0;
100 
101 	if (!pdev->ops || !pdev->ops->enter)
102 		return -EOPNOTSUPP;
103 
104 	/* Moving to USB Safe State */
105 	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
106 	if (ret)
107 		return ret;
108 
109 	/* Enter Mode */
110 	return pdev->ops->enter(pdev);
111 }
112 EXPORT_SYMBOL_GPL(typec_altmode_enter);
113 
114 /**
115  * typec_altmode_exit - Exit Mode
116  * @adev: The alternate mode
117  *
118  * The partner of @adev has initiated Exit Mode command.
119  */
120 int typec_altmode_exit(struct typec_altmode *adev)
121 {
122 	struct altmode *partner = to_altmode(adev)->partner;
123 	struct typec_altmode *pdev = &partner->adev;
124 	int ret;
125 
126 	if (!adev || !adev->active)
127 		return 0;
128 
129 	if (!pdev->ops || !pdev->ops->enter)
130 		return -EOPNOTSUPP;
131 
132 	/* Moving to USB Safe State */
133 	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
134 	if (ret)
135 		return ret;
136 
137 	/* Exit Mode command */
138 	return pdev->ops->exit(pdev);
139 }
140 EXPORT_SYMBOL_GPL(typec_altmode_exit);
141 
142 /**
143  * typec_altmode_attention - Attention command
144  * @adev: The alternate mode
145  * @vdo: VDO for the Attention command
146  *
147  * Notifies the partner of @adev about Attention command.
148  */
149 void typec_altmode_attention(struct typec_altmode *adev, u32 vdo)
150 {
151 	struct typec_altmode *pdev = &to_altmode(adev)->partner->adev;
152 
153 	if (pdev->ops && pdev->ops->attention)
154 		pdev->ops->attention(pdev, vdo);
155 }
156 EXPORT_SYMBOL_GPL(typec_altmode_attention);
157 
158 /**
159  * typec_altmode_vdm - Send Vendor Defined Messages (VDM) to the partner
160  * @adev: Alternate mode handle
161  * @header: VDM Header
162  * @vdo: Array of Vendor Defined Data Objects
163  * @count: Number of Data Objects
164  *
165  * The alternate mode drivers use this function for SVID specific communication
166  * with the partner. The port drivers use it to deliver the Structured VDMs
167  * received from the partners to the alternate mode drivers.
168  */
169 int typec_altmode_vdm(struct typec_altmode *adev,
170 		      const u32 header, const u32 *vdo, int count)
171 {
172 	struct typec_altmode *pdev;
173 	struct altmode *altmode;
174 
175 	if (!adev)
176 		return 0;
177 
178 	altmode = to_altmode(adev);
179 
180 	if (!altmode->partner)
181 		return -ENODEV;
182 
183 	pdev = &altmode->partner->adev;
184 
185 	if (!pdev->ops || !pdev->ops->vdm)
186 		return -EOPNOTSUPP;
187 
188 	return pdev->ops->vdm(pdev, header, vdo, count);
189 }
190 EXPORT_SYMBOL_GPL(typec_altmode_vdm);
191 
192 const struct typec_altmode *
193 typec_altmode_get_partner(struct typec_altmode *adev)
194 {
195 	return &to_altmode(adev)->partner->adev;
196 }
197 EXPORT_SYMBOL_GPL(typec_altmode_get_partner);
198 
199 /* -------------------------------------------------------------------------- */
200 /* API for the alternate mode drivers */
201 
202 /**
203  * typec_altmode_get_plug - Find cable plug alternate mode
204  * @adev: Handle to partner alternate mode
205  * @index: Cable plug index
206  *
207  * Increment reference count for cable plug alternate mode device. Returns
208  * handle to the cable plug alternate mode, or NULL if none is found.
209  */
210 struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *adev,
211 					     enum typec_plug_index index)
212 {
213 	struct altmode *port = to_altmode(adev)->partner;
214 
215 	if (port->plug[index]) {
216 		get_device(&port->plug[index]->adev.dev);
217 		return &port->plug[index]->adev;
218 	}
219 
220 	return NULL;
221 }
222 EXPORT_SYMBOL_GPL(typec_altmode_get_plug);
223 
224 /**
225  * typec_altmode_put_plug - Decrement cable plug alternate mode reference count
226  * @plug: Handle to the cable plug alternate mode
227  */
228 void typec_altmode_put_plug(struct typec_altmode *plug)
229 {
230 	if (plug)
231 		put_device(&plug->dev);
232 }
233 EXPORT_SYMBOL_GPL(typec_altmode_put_plug);
234 
235 int __typec_altmode_register_driver(struct typec_altmode_driver *drv,
236 				    struct module *module)
237 {
238 	if (!drv->probe)
239 		return -EINVAL;
240 
241 	drv->driver.owner = module;
242 	drv->driver.bus = &typec_bus;
243 
244 	return driver_register(&drv->driver);
245 }
246 EXPORT_SYMBOL_GPL(__typec_altmode_register_driver);
247 
248 void typec_altmode_unregister_driver(struct typec_altmode_driver *drv)
249 {
250 	driver_unregister(&drv->driver);
251 }
252 EXPORT_SYMBOL_GPL(typec_altmode_unregister_driver);
253 
254 /* -------------------------------------------------------------------------- */
255 /* API for the port drivers */
256 
257 /**
258  * typec_match_altmode - Match SVID to an array of alternate modes
259  * @altmodes: Array of alternate modes
260  * @n: Number of elements in the array, or -1 for NULL termiated arrays
261  * @svid: Standard or Vendor ID to match with
262  *
263  * Return pointer to an alternate mode with SVID mathing @svid, or NULL when no
264  * match is found.
265  */
266 struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes,
267 					  size_t n, u16 svid, u8 mode)
268 {
269 	int i;
270 
271 	for (i = 0; i < n; i++) {
272 		if (!altmodes[i])
273 			break;
274 		if (altmodes[i]->svid == svid && altmodes[i]->mode == mode)
275 			return altmodes[i];
276 	}
277 
278 	return NULL;
279 }
280 EXPORT_SYMBOL_GPL(typec_match_altmode);
281 
282 /* -------------------------------------------------------------------------- */
283 
284 static ssize_t
285 description_show(struct device *dev, struct device_attribute *attr, char *buf)
286 {
287 	struct typec_altmode *alt = to_typec_altmode(dev);
288 
289 	return sprintf(buf, "%s\n", alt->desc ? alt->desc : "");
290 }
291 static DEVICE_ATTR_RO(description);
292 
293 static struct attribute *typec_attrs[] = {
294 	&dev_attr_description.attr,
295 	NULL
296 };
297 ATTRIBUTE_GROUPS(typec);
298 
299 static int typec_match(struct device *dev, struct device_driver *driver)
300 {
301 	struct typec_altmode_driver *drv = to_altmode_driver(driver);
302 	struct typec_altmode *altmode = to_typec_altmode(dev);
303 	const struct typec_device_id *id;
304 
305 	for (id = drv->id_table; id->svid; id++)
306 		if (id->svid == altmode->svid &&
307 		    (id->mode == TYPEC_ANY_MODE || id->mode == altmode->mode))
308 			return 1;
309 	return 0;
310 }
311 
312 static int typec_uevent(struct device *dev, struct kobj_uevent_env *env)
313 {
314 	struct typec_altmode *altmode = to_typec_altmode(dev);
315 
316 	if (add_uevent_var(env, "SVID=%04X", altmode->svid))
317 		return -ENOMEM;
318 
319 	if (add_uevent_var(env, "MODE=%u", altmode->mode))
320 		return -ENOMEM;
321 
322 	return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X",
323 			      altmode->svid, altmode->mode);
324 }
325 
326 static int typec_altmode_create_links(struct altmode *alt)
327 {
328 	struct device *port_dev = &alt->partner->adev.dev;
329 	struct device *dev = &alt->adev.dev;
330 	int err;
331 
332 	err = sysfs_create_link(&dev->kobj, &port_dev->kobj, "port");
333 	if (err)
334 		return err;
335 
336 	err = sysfs_create_link(&port_dev->kobj, &dev->kobj, "partner");
337 	if (err)
338 		sysfs_remove_link(&dev->kobj, "port");
339 
340 	return err;
341 }
342 
343 static void typec_altmode_remove_links(struct altmode *alt)
344 {
345 	sysfs_remove_link(&alt->partner->adev.dev.kobj, "partner");
346 	sysfs_remove_link(&alt->adev.dev.kobj, "port");
347 }
348 
349 static int typec_probe(struct device *dev)
350 {
351 	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
352 	struct typec_altmode *adev = to_typec_altmode(dev);
353 	struct altmode *altmode = to_altmode(adev);
354 	int ret;
355 
356 	/* Fail if the port does not support the alternate mode */
357 	if (!altmode->partner)
358 		return -ENODEV;
359 
360 	ret = typec_altmode_create_links(altmode);
361 	if (ret) {
362 		dev_warn(dev, "failed to create symlinks\n");
363 		return ret;
364 	}
365 
366 	ret = drv->probe(adev);
367 	if (ret)
368 		typec_altmode_remove_links(altmode);
369 
370 	return ret;
371 }
372 
373 static int typec_remove(struct device *dev)
374 {
375 	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
376 	struct typec_altmode *adev = to_typec_altmode(dev);
377 	struct altmode *altmode = to_altmode(adev);
378 
379 	typec_altmode_remove_links(altmode);
380 
381 	if (drv->remove)
382 		drv->remove(to_typec_altmode(dev));
383 
384 	if (adev->active) {
385 		WARN_ON(typec_altmode_set_state(adev, TYPEC_STATE_SAFE));
386 		typec_altmode_update_active(adev, false);
387 	}
388 
389 	adev->desc = NULL;
390 	adev->ops = NULL;
391 
392 	return 0;
393 }
394 
395 struct bus_type typec_bus = {
396 	.name = "typec",
397 	.dev_groups = typec_groups,
398 	.match = typec_match,
399 	.uevent = typec_uevent,
400 	.probe = typec_probe,
401 	.remove = typec_remove,
402 };
403