1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * USB Role Switch Support
  4 *
  5 * Copyright (C) 2018 Intel Corporation
  6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
  7 *         Hans de Goede <hdegoede@redhat.com>
  8 */
  9
 10#include <linux/usb/role.h>
 11#include <linux/property.h>
 12#include <linux/device.h>
 13#include <linux/module.h>
 14#include <linux/mutex.h>
 15#include <linux/slab.h>
 16
 17static const struct class role_class = {
 18	.name = "usb_role",
 19};
 20
 21struct usb_role_switch {
 22	struct device dev;
 23	struct mutex lock; /* device lock*/
 24	struct module *module; /* the module this device depends on */
 25	enum usb_role role;
 26	bool registered;
 27
 28	/* From descriptor */
 29	struct device *usb2_port;
 30	struct device *usb3_port;
 31	struct device *udc;
 32	usb_role_switch_set_t set;
 33	usb_role_switch_get_t get;
 34	bool allow_userspace_control;
 35};
 36
 37#define to_role_switch(d)	container_of(d, struct usb_role_switch, dev)
 38
 39/**
 40 * usb_role_switch_set_role - Set USB role for a switch
 41 * @sw: USB role switch
 42 * @role: USB role to be switched to
 43 *
 44 * Set USB role @role for @sw.
 45 */
 46int usb_role_switch_set_role(struct usb_role_switch *sw, enum usb_role role)
 47{
 48	int ret;
 49
 50	if (IS_ERR_OR_NULL(sw))
 51		return 0;
 52
 53	if (!sw->registered)
 54		return -EOPNOTSUPP;
 55
 56	mutex_lock(&sw->lock);
 57
 58	ret = sw->set(sw, role);
 59	if (!ret) {
 60		sw->role = role;
 61		kobject_uevent(&sw->dev.kobj, KOBJ_CHANGE);
 62	}
 63
 64	mutex_unlock(&sw->lock);
 65
 66	return ret;
 67}
 68EXPORT_SYMBOL_GPL(usb_role_switch_set_role);
 69
 70/**
 71 * usb_role_switch_get_role - Get the USB role for a switch
 72 * @sw: USB role switch
 73 *
 74 * Depending on the role-switch-driver this function returns either a cached
 75 * value of the last set role, or reads back the actual value from the hardware.
 76 */
 77enum usb_role usb_role_switch_get_role(struct usb_role_switch *sw)
 78{
 79	enum usb_role role;
 80
 81	if (IS_ERR_OR_NULL(sw) || !sw->registered)
 82		return USB_ROLE_NONE;
 83
 84	mutex_lock(&sw->lock);
 85
 86	if (sw->get)
 87		role = sw->get(sw);
 88	else
 89		role = sw->role;
 90
 91	mutex_unlock(&sw->lock);
 92
 93	return role;
 94}
 95EXPORT_SYMBOL_GPL(usb_role_switch_get_role);
 96
 97static void *usb_role_switch_match(const struct fwnode_handle *fwnode, const char *id,
 98				   void *data)
 99{
100	struct device *dev;
101
102	if (id && !fwnode_property_present(fwnode, id))
103		return NULL;
104
105	dev = class_find_device_by_fwnode(&role_class, fwnode);
106
107	return dev ? to_role_switch(dev) : ERR_PTR(-EPROBE_DEFER);
108}
109
110static struct usb_role_switch *
111usb_role_switch_is_parent(struct fwnode_handle *fwnode)
112{
113	struct fwnode_handle *parent = fwnode_get_parent(fwnode);
114	struct device *dev;
115
116	if (!fwnode_property_present(parent, "usb-role-switch")) {
117		fwnode_handle_put(parent);
118		return NULL;
119	}
120
121	dev = class_find_device_by_fwnode(&role_class, parent);
122	fwnode_handle_put(parent);
123	return dev ? to_role_switch(dev) : ERR_PTR(-EPROBE_DEFER);
124}
125
126/**
127 * usb_role_switch_get - Find USB role switch linked with the caller
128 * @dev: The caller device
129 *
130 * Finds and returns role switch linked with @dev. The reference count for the
131 * found switch is incremented.
132 */
133struct usb_role_switch *usb_role_switch_get(struct device *dev)
134{
135	struct usb_role_switch *sw;
136
137	sw = usb_role_switch_is_parent(dev_fwnode(dev));
138	if (!sw)
139		sw = device_connection_find_match(dev, "usb-role-switch", NULL,
140						  usb_role_switch_match);
141
142	if (!IS_ERR_OR_NULL(sw))
143		WARN_ON(!try_module_get(sw->module));
144
145	return sw;
146}
147EXPORT_SYMBOL_GPL(usb_role_switch_get);
148
149/**
150 * fwnode_usb_role_switch_get - Find USB role switch linked with the caller
151 * @fwnode: The caller device node
152 *
153 * This is similar to the usb_role_switch_get() function above, but it searches
154 * the switch using fwnode instead of device entry.
155 */
156struct usb_role_switch *fwnode_usb_role_switch_get(struct fwnode_handle *fwnode)
157{
158	struct usb_role_switch *sw;
159
160	sw = usb_role_switch_is_parent(fwnode);
161	if (!sw)
162		sw = fwnode_connection_find_match(fwnode, "usb-role-switch",
163						  NULL, usb_role_switch_match);
164	if (!IS_ERR_OR_NULL(sw))
165		WARN_ON(!try_module_get(sw->module));
166
167	return sw;
168}
169EXPORT_SYMBOL_GPL(fwnode_usb_role_switch_get);
170
171/**
172 * usb_role_switch_put - Release handle to a switch
173 * @sw: USB Role Switch
174 *
175 * Decrement reference count for @sw.
176 */
177void usb_role_switch_put(struct usb_role_switch *sw)
178{
179	if (!IS_ERR_OR_NULL(sw)) {
180		module_put(sw->module);
181		put_device(&sw->dev);
182	}
183}
184EXPORT_SYMBOL_GPL(usb_role_switch_put);
185
186/**
187 * usb_role_switch_find_by_fwnode - Find USB role switch with its fwnode
188 * @fwnode: fwnode of the USB Role Switch
189 *
190 * Finds and returns role switch with @fwnode. The reference count for the
191 * found switch is incremented.
192 */
193struct usb_role_switch *
194usb_role_switch_find_by_fwnode(const struct fwnode_handle *fwnode)
195{
196	struct device *dev;
197	struct usb_role_switch *sw = NULL;
198
199	if (!fwnode)
200		return NULL;
201
202	dev = class_find_device_by_fwnode(&role_class, fwnode);
203	if (dev) {
204		sw = to_role_switch(dev);
205		WARN_ON(!try_module_get(sw->module));
206	}
207
208	return sw;
209}
210EXPORT_SYMBOL_GPL(usb_role_switch_find_by_fwnode);
211
212static umode_t
213usb_role_switch_is_visible(struct kobject *kobj, struct attribute *attr, int n)
214{
215	struct device *dev = kobj_to_dev(kobj);
216	struct usb_role_switch *sw = to_role_switch(dev);
217
218	if (sw->allow_userspace_control)
219		return attr->mode;
220
221	return 0;
222}
223
224static const char * const usb_roles[] = {
225	[USB_ROLE_NONE]		= "none",
226	[USB_ROLE_HOST]		= "host",
227	[USB_ROLE_DEVICE]	= "device",
228};
229
230const char *usb_role_string(enum usb_role role)
231{
232	if (role < 0 || role >= ARRAY_SIZE(usb_roles))
233		return "unknown";
234
235	return usb_roles[role];
236}
237EXPORT_SYMBOL_GPL(usb_role_string);
238
239static ssize_t
240role_show(struct device *dev, struct device_attribute *attr, char *buf)
241{
242	struct usb_role_switch *sw = to_role_switch(dev);
243	enum usb_role role = usb_role_switch_get_role(sw);
244
245	return sprintf(buf, "%s\n", usb_roles[role]);
246}
247
248static ssize_t role_store(struct device *dev, struct device_attribute *attr,
249			  const char *buf, size_t size)
250{
251	struct usb_role_switch *sw = to_role_switch(dev);
252	int ret;
253
254	ret = sysfs_match_string(usb_roles, buf);
255	if (ret < 0) {
256		bool res;
257
258		/* Extra check if the user wants to disable the switch */
259		ret = kstrtobool(buf, &res);
260		if (ret || res)
261			return -EINVAL;
262	}
263
264	ret = usb_role_switch_set_role(sw, ret);
265	if (ret)
266		return ret;
267
268	return size;
269}
270static DEVICE_ATTR_RW(role);
271
272static struct attribute *usb_role_switch_attrs[] = {
273	&dev_attr_role.attr,
274	NULL,
275};
276
277static const struct attribute_group usb_role_switch_group = {
278	.is_visible = usb_role_switch_is_visible,
279	.attrs = usb_role_switch_attrs,
280};
281
282static const struct attribute_group *usb_role_switch_groups[] = {
283	&usb_role_switch_group,
284	NULL,
285};
286
287static int usb_role_switch_uevent(const struct device *dev, struct kobj_uevent_env *env)
288{
289	int ret;
290
291	ret = add_uevent_var(env, "USB_ROLE_SWITCH=%s", dev_name(dev));
292	if (ret)
293		dev_err(dev, "failed to add uevent USB_ROLE_SWITCH\n");
294
295	return ret;
296}
297
298static void usb_role_switch_release(struct device *dev)
299{
300	struct usb_role_switch *sw = to_role_switch(dev);
301
302	kfree(sw);
303}
304
305static const struct device_type usb_role_dev_type = {
306	.name = "usb_role_switch",
307	.groups = usb_role_switch_groups,
308	.uevent = usb_role_switch_uevent,
309	.release = usb_role_switch_release,
310};
311
312/**
313 * usb_role_switch_register - Register USB Role Switch
314 * @parent: Parent device for the switch
315 * @desc: Description of the switch
316 *
317 * USB Role Switch is a device capable or choosing the role for USB connector.
318 * On platforms where the USB controller is dual-role capable, the controller
319 * driver will need to register the switch. On platforms where the USB host and
320 * USB device controllers behind the connector are separate, there will be a
321 * mux, and the driver for that mux will need to register the switch.
322 *
323 * Returns handle to a new role switch or ERR_PTR. The content of @desc is
324 * copied.
325 */
326struct usb_role_switch *
327usb_role_switch_register(struct device *parent,
328			 const struct usb_role_switch_desc *desc)
329{
330	struct usb_role_switch *sw;
331	int ret;
332
333	if (!desc || !desc->set)
334		return ERR_PTR(-EINVAL);
335
336	sw = kzalloc(sizeof(*sw), GFP_KERNEL);
337	if (!sw)
338		return ERR_PTR(-ENOMEM);
339
340	mutex_init(&sw->lock);
341
342	sw->allow_userspace_control = desc->allow_userspace_control;
343	sw->usb2_port = desc->usb2_port;
344	sw->usb3_port = desc->usb3_port;
345	sw->udc = desc->udc;
346	sw->set = desc->set;
347	sw->get = desc->get;
348
349	sw->module = parent->driver->owner;
350	sw->dev.parent = parent;
351	sw->dev.fwnode = desc->fwnode;
352	sw->dev.class = &role_class;
353	sw->dev.type = &usb_role_dev_type;
354	dev_set_drvdata(&sw->dev, desc->driver_data);
355	dev_set_name(&sw->dev, "%s-role-switch",
356		     desc->name ? desc->name : dev_name(parent));
357
358	ret = device_register(&sw->dev);
359	if (ret) {
360		put_device(&sw->dev);
361		return ERR_PTR(ret);
362	}
363
364	sw->registered = true;
365
366	/* TODO: Symlinks for the host port and the device controller. */
367
368	return sw;
369}
370EXPORT_SYMBOL_GPL(usb_role_switch_register);
371
372/**
373 * usb_role_switch_unregister - Unregsiter USB Role Switch
374 * @sw: USB Role Switch
375 *
376 * Unregister switch that was registered with usb_role_switch_register().
377 */
378void usb_role_switch_unregister(struct usb_role_switch *sw)
379{
380	if (!IS_ERR_OR_NULL(sw)) {
381		sw->registered = false;
382		device_unregister(&sw->dev);
383	}
384}
385EXPORT_SYMBOL_GPL(usb_role_switch_unregister);
386
387/**
388 * usb_role_switch_set_drvdata - Assign private data pointer to a switch
389 * @sw: USB Role Switch
390 * @data: Private data pointer
391 */
392void usb_role_switch_set_drvdata(struct usb_role_switch *sw, void *data)
393{
394	dev_set_drvdata(&sw->dev, data);
395}
396EXPORT_SYMBOL_GPL(usb_role_switch_set_drvdata);
397
398/**
399 * usb_role_switch_get_drvdata - Get the private data pointer of a switch
400 * @sw: USB Role Switch
401 */
402void *usb_role_switch_get_drvdata(struct usb_role_switch *sw)
403{
404	return dev_get_drvdata(&sw->dev);
405}
406EXPORT_SYMBOL_GPL(usb_role_switch_get_drvdata);
407
408static int __init usb_roles_init(void)
409{
410	return class_register(&role_class);
411}
412subsys_initcall(usb_roles_init);
413
414static void __exit usb_roles_exit(void)
415{
416	class_unregister(&role_class);
417}
418module_exit(usb_roles_exit);
419
420MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
421MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
422MODULE_LICENSE("GPL v2");
423MODULE_DESCRIPTION("USB Role Class");