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