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