xref: /linux-6.15/drivers/usb/typec/bus.c (revision cf2f58fb) 
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 	if (is_typec_port(pdev->dev.parent) && !pdev->active)
105 		return -EPERM;
106 
107 	/* Moving to USB Safe State */
108 	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
109 	if (ret)
110 		return ret;
111 
112 	/* Enter Mode */
113 	return pdev->ops->enter(pdev);
114 }
115 EXPORT_SYMBOL_GPL(typec_altmode_enter);
116 
117 /**
118  * typec_altmode_exit - Exit Mode
119  * @adev: The alternate mode
120  *
121  * The partner of @adev has initiated Exit Mode command.
122  */
123 int typec_altmode_exit(struct typec_altmode *adev)
124 {
125 	struct altmode *partner = to_altmode(adev)->partner;
126 	struct typec_altmode *pdev = &partner->adev;
127 	int ret;
128 
129 	if (!adev || !adev->active)
130 		return 0;
131 
132 	if (!pdev->ops || !pdev->ops->enter)
133 		return -EOPNOTSUPP;
134 
135 	/* Moving to USB Safe State */
136 	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
137 	if (ret)
138 		return ret;
139 
140 	/* Exit Mode command */
141 	return pdev->ops->exit(pdev);
142 }
143 EXPORT_SYMBOL_GPL(typec_altmode_exit);
144 
145 /**
146  * typec_altmode_attention - Attention command
147  * @adev: The alternate mode
148  * @vdo: VDO for the Attention command
149  *
150  * Notifies the partner of @adev about Attention command.
151  */
152 void typec_altmode_attention(struct typec_altmode *adev, u32 vdo)
153 {
154 	struct typec_altmode *pdev = &to_altmode(adev)->partner->adev;
155 
156 	if (pdev->ops && pdev->ops->attention)
157 		pdev->ops->attention(pdev, vdo);
158 }
159 EXPORT_SYMBOL_GPL(typec_altmode_attention);
160 
161 /**
162  * typec_altmode_vdm - Send Vendor Defined Messages (VDM) to the partner
163  * @adev: Alternate mode handle
164  * @header: VDM Header
165  * @vdo: Array of Vendor Defined Data Objects
166  * @count: Number of Data Objects
167  *
168  * The alternate mode drivers use this function for SVID specific communication
169  * with the partner. The port drivers use it to deliver the Structured VDMs
170  * received from the partners to the alternate mode drivers.
171  */
172 int typec_altmode_vdm(struct typec_altmode *adev,
173 		      const u32 header, const u32 *vdo, int count)
174 {
175 	struct typec_altmode *pdev;
176 	struct altmode *altmode;
177 
178 	if (!adev)
179 		return 0;
180 
181 	altmode = to_altmode(adev);
182 
183 	if (!altmode->partner)
184 		return -ENODEV;
185 
186 	pdev = &altmode->partner->adev;
187 
188 	if (!pdev->ops || !pdev->ops->vdm)
189 		return -EOPNOTSUPP;
190 
191 	return pdev->ops->vdm(pdev, header, vdo, count);
192 }
193 EXPORT_SYMBOL_GPL(typec_altmode_vdm);
194 
195 const struct typec_altmode *
196 typec_altmode_get_partner(struct typec_altmode *adev)
197 {
198 	return adev ? &to_altmode(adev)->partner->adev : NULL;
199 }
200 EXPORT_SYMBOL_GPL(typec_altmode_get_partner);
201 
202 /* -------------------------------------------------------------------------- */
203 /* API for the alternate mode drivers */
204 
205 /**
206  * typec_altmode_get_plug - Find cable plug alternate mode
207  * @adev: Handle to partner alternate mode
208  * @index: Cable plug index
209  *
210  * Increment reference count for cable plug alternate mode device. Returns
211  * handle to the cable plug alternate mode, or NULL if none is found.
212  */
213 struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *adev,
214 					     enum typec_plug_index index)
215 {
216 	struct altmode *port = to_altmode(adev)->partner;
217 
218 	if (port->plug[index]) {
219 		get_device(&port->plug[index]->adev.dev);
220 		return &port->plug[index]->adev;
221 	}
222 
223 	return NULL;
224 }
225 EXPORT_SYMBOL_GPL(typec_altmode_get_plug);
226 
227 /**
228  * typec_altmode_put_plug - Decrement cable plug alternate mode reference count
229  * @plug: Handle to the cable plug alternate mode
230  */
231 void typec_altmode_put_plug(struct typec_altmode *plug)
232 {
233 	if (plug)
234 		put_device(&plug->dev);
235 }
236 EXPORT_SYMBOL_GPL(typec_altmode_put_plug);
237 
238 int __typec_altmode_register_driver(struct typec_altmode_driver *drv,
239 				    struct module *module)
240 {
241 	if (!drv->probe)
242 		return -EINVAL;
243 
244 	drv->driver.owner = module;
245 	drv->driver.bus = &typec_bus;
246 
247 	return driver_register(&drv->driver);
248 }
249 EXPORT_SYMBOL_GPL(__typec_altmode_register_driver);
250 
251 void typec_altmode_unregister_driver(struct typec_altmode_driver *drv)
252 {
253 	driver_unregister(&drv->driver);
254 }
255 EXPORT_SYMBOL_GPL(typec_altmode_unregister_driver);
256 
257 /* -------------------------------------------------------------------------- */
258 /* API for the port drivers */
259 
260 /**
261  * typec_match_altmode - Match SVID and mode to an array of alternate modes
262  * @altmodes: Array of alternate modes
263  * @n: Number of elements in the array, or -1 for NULL terminated arrays
264  * @svid: Standard or Vendor ID to match with
265  * @mode: Mode to match with
266  *
267  * Return pointer to an alternate mode with SVID matching @svid, or NULL when no
268  * match is found.
269  */
270 struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes,
271 					  size_t n, u16 svid, u8 mode)
272 {
273 	int i;
274 
275 	for (i = 0; i < n; i++) {
276 		if (!altmodes[i])
277 			break;
278 		if (altmodes[i]->svid == svid && altmodes[i]->mode == mode)
279 			return altmodes[i];
280 	}
281 
282 	return NULL;
283 }
284 EXPORT_SYMBOL_GPL(typec_match_altmode);
285 
286 /* -------------------------------------------------------------------------- */
287 
288 static ssize_t
289 description_show(struct device *dev, struct device_attribute *attr, char *buf)
290 {
291 	struct typec_altmode *alt = to_typec_altmode(dev);
292 
293 	return sprintf(buf, "%s\n", alt->desc ? alt->desc : "");
294 }
295 static DEVICE_ATTR_RO(description);
296 
297 static struct attribute *typec_attrs[] = {
298 	&dev_attr_description.attr,
299 	NULL
300 };
301 ATTRIBUTE_GROUPS(typec);
302 
303 static int typec_match(struct device *dev, struct device_driver *driver)
304 {
305 	struct typec_altmode_driver *drv = to_altmode_driver(driver);
306 	struct typec_altmode *altmode = to_typec_altmode(dev);
307 	const struct typec_device_id *id;
308 
309 	for (id = drv->id_table; id->svid; id++)
310 		if (id->svid == altmode->svid &&
311 		    (id->mode == TYPEC_ANY_MODE || id->mode == altmode->mode))
312 			return 1;
313 	return 0;
314 }
315 
316 static int typec_uevent(struct device *dev, struct kobj_uevent_env *env)
317 {
318 	struct typec_altmode *altmode = to_typec_altmode(dev);
319 
320 	if (add_uevent_var(env, "SVID=%04X", altmode->svid))
321 		return -ENOMEM;
322 
323 	if (add_uevent_var(env, "MODE=%u", altmode->mode))
324 		return -ENOMEM;
325 
326 	return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X",
327 			      altmode->svid, altmode->mode);
328 }
329 
330 static int typec_altmode_create_links(struct altmode *alt)
331 {
332 	struct device *port_dev = &alt->partner->adev.dev;
333 	struct device *dev = &alt->adev.dev;
334 	int err;
335 
336 	err = sysfs_create_link(&dev->kobj, &port_dev->kobj, "port");
337 	if (err)
338 		return err;
339 
340 	err = sysfs_create_link(&port_dev->kobj, &dev->kobj, "partner");
341 	if (err)
342 		sysfs_remove_link(&dev->kobj, "port");
343 
344 	return err;
345 }
346 
347 static void typec_altmode_remove_links(struct altmode *alt)
348 {
349 	sysfs_remove_link(&alt->partner->adev.dev.kobj, "partner");
350 	sysfs_remove_link(&alt->adev.dev.kobj, "port");
351 }
352 
353 static int typec_probe(struct device *dev)
354 {
355 	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
356 	struct typec_altmode *adev = to_typec_altmode(dev);
357 	struct altmode *altmode = to_altmode(adev);
358 	int ret;
359 
360 	/* Fail if the port does not support the alternate mode */
361 	if (!altmode->partner)
362 		return -ENODEV;
363 
364 	ret = typec_altmode_create_links(altmode);
365 	if (ret) {
366 		dev_warn(dev, "failed to create symlinks\n");
367 		return ret;
368 	}
369 
370 	ret = drv->probe(adev);
371 	if (ret)
372 		typec_altmode_remove_links(altmode);
373 
374 	return ret;
375 }
376 
377 static int typec_remove(struct device *dev)
378 {
379 	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
380 	struct typec_altmode *adev = to_typec_altmode(dev);
381 	struct altmode *altmode = to_altmode(adev);
382 
383 	typec_altmode_remove_links(altmode);
384 
385 	if (drv->remove)
386 		drv->remove(to_typec_altmode(dev));
387 
388 	if (adev->active) {
389 		WARN_ON(typec_altmode_set_state(adev, TYPEC_STATE_SAFE));
390 		typec_altmode_update_active(adev, false);
391 	}
392 
393 	adev->desc = NULL;
394 	adev->ops = NULL;
395 
396 	return 0;
397 }
398 
399 struct bus_type typec_bus = {
400 	.name = "typec",
401 	.dev_groups = typec_groups,
402 	.match = typec_match,
403 	.uevent = typec_uevent,
404 	.probe = typec_probe,
405 	.remove = typec_remove,
406 };
407