[thirdparty/kernel/stable.git] / drivers / usb / typec / bus.c

// SPDX-License-Identifier: GPL-2.0
/**
 * Bus for USB Type-C Alternate Modes
 *
 * Copyright (C) 2018 Intel Corporation
 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
 */

#include <linux/usb/pd_vdo.h>

#include "bus.h"

static inline int typec_altmode_set_mux(struct altmode *alt, u8 state)
{
	return alt->mux ? alt->mux->set(alt->mux, state) : 0;
}

static int typec_altmode_set_state(struct typec_altmode *adev, int state)
{
	bool is_port = is_typec_port(adev->dev.parent);
	struct altmode *port_altmode;
	int ret;

	port_altmode = is_port ? to_altmode(adev) : to_altmode(adev)->partner;

	ret = typec_altmode_set_mux(port_altmode, state);
	if (ret)
		return ret;

	blocking_notifier_call_chain(&port_altmode->nh, state, NULL);

	return 0;
}

/* -------------------------------------------------------------------------- */
/* Common API */

/**
 * typec_altmode_notify - Communication between the OS and alternate mode driver
 * @adev: Handle to the alternate mode
 * @conf: Alternate mode specific configuration value
 * @data: Alternate mode specific data
 *
 * The primary purpose for this function is to allow the alternate mode drivers
 * to tell which pin configuration has been negotiated with the partner. That
 * information will then be used for example to configure the muxes.
 * Communication to the other direction is also possible, and low level device
 * drivers can also send notifications to the alternate mode drivers. The actual
 * communication will be specific for every SVID.
 */
int typec_altmode_notify(struct typec_altmode *adev,
			 unsigned long conf, void *data)
{
	bool is_port;
	struct altmode *altmode;
	struct altmode *partner;
	int ret;

	if (!adev)
		return 0;

	altmode = to_altmode(adev);

	if (!altmode->partner)
		return -ENODEV;

	is_port = is_typec_port(adev->dev.parent);
	partner = altmode->partner;

	ret = typec_altmode_set_mux(is_port ? altmode : partner, (u8)conf);
	if (ret)
		return ret;

	blocking_notifier_call_chain(is_port ? &altmode->nh : &partner->nh,
				     conf, data);

	if (partner->adev.ops && partner->adev.ops->notify)
		return partner->adev.ops->notify(&partner->adev, conf, data);

	return 0;
}
EXPORT_SYMBOL_GPL(typec_altmode_notify);

/**
 * typec_altmode_enter - Enter Mode
 * @adev: The alternate mode
 *
 * The alternate mode drivers use this function to enter mode. The port drivers
 * use this to inform the alternate mode drivers that the partner has initiated
 * Enter Mode command.
 */
int typec_altmode_enter(struct typec_altmode *adev)
{
	struct altmode *partner = to_altmode(adev)->partner;
	struct typec_altmode *pdev = &partner->adev;
	int ret;

	if (!adev || adev->active)
		return 0;

	if (!pdev->ops || !pdev->ops->enter)
		return -EOPNOTSUPP;

	/* Moving to USB Safe State */
	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
	if (ret)
		return ret;

	/* Enter Mode */
	return pdev->ops->enter(pdev);
}
EXPORT_SYMBOL_GPL(typec_altmode_enter);

/**
 * typec_altmode_exit - Exit Mode
 * @adev: The alternate mode
 *
 * The partner of @adev has initiated Exit Mode command.
 */
int typec_altmode_exit(struct typec_altmode *adev)
{
	struct altmode *partner = to_altmode(adev)->partner;
	struct typec_altmode *pdev = &partner->adev;
	int ret;

	if (!adev || !adev->active)
		return 0;

	if (!pdev->ops || !pdev->ops->enter)
		return -EOPNOTSUPP;

	/* Moving to USB Safe State */
	ret = typec_altmode_set_state(adev, TYPEC_STATE_SAFE);
	if (ret)
		return ret;

	/* Exit Mode command */
	return pdev->ops->exit(pdev);
}
EXPORT_SYMBOL_GPL(typec_altmode_exit);

/**
 * typec_altmode_attention - Attention command
 * @adev: The alternate mode
 * @vdo: VDO for the Attention command
 *
 * Notifies the partner of @adev about Attention command.
 */
void typec_altmode_attention(struct typec_altmode *adev, u32 vdo)
{
	struct typec_altmode *pdev = &to_altmode(adev)->partner->adev;

	if (pdev->ops && pdev->ops->attention)
		pdev->ops->attention(pdev, vdo);
}
EXPORT_SYMBOL_GPL(typec_altmode_attention);

/**
 * typec_altmode_vdm - Send Vendor Defined Messages (VDM) to the partner
 * @adev: Alternate mode handle
 * @header: VDM Header
 * @vdo: Array of Vendor Defined Data Objects
 * @count: Number of Data Objects
 *
 * The alternate mode drivers use this function for SVID specific communication
 * with the partner. The port drivers use it to deliver the Structured VDMs
 * received from the partners to the alternate mode drivers.
 */
int typec_altmode_vdm(struct typec_altmode *adev,
		      const u32 header, const u32 *vdo, int count)
{
	struct typec_altmode *pdev;
	struct altmode *altmode;

	if (!adev)
		return 0;

	altmode = to_altmode(adev);

	if (!altmode->partner)
		return -ENODEV;

	pdev = &altmode->partner->adev;

	if (!pdev->ops || !pdev->ops->vdm)
		return -EOPNOTSUPP;

	return pdev->ops->vdm(pdev, header, vdo, count);
}
EXPORT_SYMBOL_GPL(typec_altmode_vdm);

const struct typec_altmode *
typec_altmode_get_partner(struct typec_altmode *adev)
{
	return adev ? &to_altmode(adev)->partner->adev : NULL;
}
EXPORT_SYMBOL_GPL(typec_altmode_get_partner);

/* -------------------------------------------------------------------------- */
/* API for the alternate mode drivers */

/**
 * typec_altmode_get_plug - Find cable plug alternate mode
 * @adev: Handle to partner alternate mode
 * @index: Cable plug index
 *
 * Increment reference count for cable plug alternate mode device. Returns
 * handle to the cable plug alternate mode, or NULL if none is found.
 */
struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *adev,
					     enum typec_plug_index index)
{
	struct altmode *port = to_altmode(adev)->partner;

	if (port->plug[index]) {
		get_device(&port->plug[index]->adev.dev);
		return &port->plug[index]->adev;
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(typec_altmode_get_plug);

/**
 * typec_altmode_put_plug - Decrement cable plug alternate mode reference count
 * @plug: Handle to the cable plug alternate mode
 */
void typec_altmode_put_plug(struct typec_altmode *plug)
{
	if (plug)
		put_device(&plug->dev);
}
EXPORT_SYMBOL_GPL(typec_altmode_put_plug);

int __typec_altmode_register_driver(struct typec_altmode_driver *drv,
				    struct module *module)
{
	if (!drv->probe)
		return -EINVAL;

	drv->driver.owner = module;
	drv->driver.bus = &typec_bus;

	return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(__typec_altmode_register_driver);

void typec_altmode_unregister_driver(struct typec_altmode_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL_GPL(typec_altmode_unregister_driver);

/* -------------------------------------------------------------------------- */
/* API for the port drivers */

/**
 * typec_match_altmode - Match SVID and mode to an array of alternate modes
 * @altmodes: Array of alternate modes
 * @n: Number of elements in the array, or -1 for NULL terminated arrays
 * @svid: Standard or Vendor ID to match with
 * @mode: Mode to match with
 *
 * Return pointer to an alternate mode with SVID matching @svid, or NULL when no
 * match is found.
 */
struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes,
					  size_t n, u16 svid, u8 mode)
{
	int i;

	for (i = 0; i < n; i++) {
		if (!altmodes[i])
			break;
		if (altmodes[i]->svid == svid && altmodes[i]->mode == mode)
			return altmodes[i];
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(typec_match_altmode);

/* -------------------------------------------------------------------------- */

static ssize_t
description_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct typec_altmode *alt = to_typec_altmode(dev);

	return sprintf(buf, "%s\n", alt->desc ? alt->desc : "");
}
static DEVICE_ATTR_RO(description);

static struct attribute *typec_attrs[] = {
	&dev_attr_description.attr,
	NULL
};
ATTRIBUTE_GROUPS(typec);

static int typec_match(struct device *dev, struct device_driver *driver)
{
	struct typec_altmode_driver *drv = to_altmode_driver(driver);
	struct typec_altmode *altmode = to_typec_altmode(dev);
	const struct typec_device_id *id;

	for (id = drv->id_table; id->svid; id++)
		if (id->svid == altmode->svid &&
		    (id->mode == TYPEC_ANY_MODE || id->mode == altmode->mode))
			return 1;
	return 0;
}

static int typec_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct typec_altmode *altmode = to_typec_altmode(dev);

	if (add_uevent_var(env, "SVID=%04X", altmode->svid))
		return -ENOMEM;

	if (add_uevent_var(env, "MODE=%u", altmode->mode))
		return -ENOMEM;

	return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X",
			      altmode->svid, altmode->mode);
}

static int typec_altmode_create_links(struct altmode *alt)
{
	struct device *port_dev = &alt->partner->adev.dev;
	struct device *dev = &alt->adev.dev;
	int err;

	err = sysfs_create_link(&dev->kobj, &port_dev->kobj, "port");
	if (err)
		return err;

	err = sysfs_create_link(&port_dev->kobj, &dev->kobj, "partner");
	if (err)
		sysfs_remove_link(&dev->kobj, "port");

	return err;
}

static void typec_altmode_remove_links(struct altmode *alt)
{
	sysfs_remove_link(&alt->partner->adev.dev.kobj, "partner");
	sysfs_remove_link(&alt->adev.dev.kobj, "port");
}

static int typec_probe(struct device *dev)
{
	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
	struct typec_altmode *adev = to_typec_altmode(dev);
	struct altmode *altmode = to_altmode(adev);
	int ret;

	/* Fail if the port does not support the alternate mode */
	if (!altmode->partner)
		return -ENODEV;

	ret = typec_altmode_create_links(altmode);
	if (ret) {
		dev_warn(dev, "failed to create symlinks\n");
		return ret;
	}

	ret = drv->probe(adev);
	if (ret)
		typec_altmode_remove_links(altmode);

	return ret;
}

static int typec_remove(struct device *dev)
{
	struct typec_altmode_driver *drv = to_altmode_driver(dev->driver);
	struct typec_altmode *adev = to_typec_altmode(dev);
	struct altmode *altmode = to_altmode(adev);

	typec_altmode_remove_links(altmode);

	if (drv->remove)
		drv->remove(to_typec_altmode(dev));

	if (adev->active) {
		WARN_ON(typec_altmode_set_state(adev, TYPEC_STATE_SAFE));
		typec_altmode_update_active(adev, false);
	}

	adev->desc = NULL;
	adev->ops = NULL;

	return 0;
}

struct bus_type typec_bus = {
	.name = "typec",
	.dev_groups = typec_groups,
	.match = typec_match,
	.uevent = typec_uevent,
	.probe = typec_probe,
	.remove = typec_remove,
};
Commit	Line	Data
8a37d87d HK	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
	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	{
9920184d	54	bool is_port;
8a37d87d HK	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
9920184d	67	is_port = is_typec_port(adev->dev.parent);
8a37d87d HK	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	{
5f54a85d	195	return adev ? &to_altmode(adev)->partner->adev : NULL;
8a37d87d HK	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	/**
40de5fe4	258	* typec_match_altmode - Match SVID and mode to an array of alternate modes
8a37d87d	259	* @altmodes: Array of alternate modes
40de5fe4	260	* @n: Number of elements in the array, or -1 for NULL terminated arrays
8a37d87d	261	* @svid: Standard or Vendor ID to match with
40de5fe4	262	* @mode: Mode to match with
8a37d87d	263	*
40de5fe4	264	* Return pointer to an alternate mode with SVID matching @svid, or NULL when no
8a37d87d HK	265	* match is found.
	266	*/
	267	struct 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	}
	281	EXPORT_SYMBOL_GPL(typec_match_altmode);
	282
	283	/* -------------------------------------------------------------------------- */
	284
	285	static ssize_t
	286	description_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	}
	292	static DEVICE_ATTR_RO(description);
	293
	294	static struct attribute *typec_attrs[] = {
	295	&dev_attr_description.attr,
	296	NULL
	297	};
	298	ATTRIBUTE_GROUPS(typec);
	299
	300	static 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
	313	static 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
	327	static 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
344	static 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
350	static 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
374	static 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
396	struct 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	};