drivers/usb/roles/class.c

   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 const struct class role_class = {
  18         .name = "usb_role",
  19 };
  20
  21 struct 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  */
  46 int 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 }
  68 EXPORT_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  */
  77 enum 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 }
  95 EXPORT_SYMBOL_GPL(usb_role_switch_get_role);
  96
  97 static 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
 110 static struct usb_role_switch *
 111 usb_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  */
 133 struct 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 }
 147 EXPORT_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  */
 156 struct 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 }
 169 EXPORT_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  */
 177 void 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 }
 184 EXPORT_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  */
 193 struct usb_role_switch *
 194 usb_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 }
 210 EXPORT_SYMBOL_GPL(usb_role_switch_find_by_fwnode);
 211
 212 static umode_t
 213 usb_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
 224 static const char * const usb_roles[] = {
 225         [USB_ROLE_NONE]         = "none",
 226         [USB_ROLE_HOST]         = "host",
 227         [USB_ROLE_DEVICE]       = "device",
 228 };
 229
 230 const 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 }
 237 EXPORT_SYMBOL_GPL(usb_role_string);
 238
 239 static ssize_t
 240 role_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
 248 static 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 }
 270 static DEVICE_ATTR_RW(role);
 271
 272 static struct attribute *usb_role_switch_attrs[] = {
 273         &dev_attr_role.attr,
 274         NULL,
 275 };
 276
 277 static const struct attribute_group usb_role_switch_group = {
 278         .is_visible = usb_role_switch_is_visible,
 279         .attrs = usb_role_switch_attrs,
 280 };
 281
 282 static const struct attribute_group *usb_role_switch_groups[] = {
 283         &usb_role_switch_group,
 284         NULL,
 285 };
 286
 287 static 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
 298 static 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
 305 static 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  */
 326 struct usb_role_switch *
 327 usb_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 }
 370 EXPORT_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  */
 378 void 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 }
 385 EXPORT_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  */
 392 void usb_role_switch_set_drvdata(struct usb_role_switch *sw, void *data)
 393 {
 394         dev_set_drvdata(&sw->dev, data);
 395 }
 396 EXPORT_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  */
 402 void *usb_role_switch_get_drvdata(struct usb_role_switch *sw)
 403 {
 404         return dev_get_drvdata(&sw->dev);
 405 }
 406 EXPORT_SYMBOL_GPL(usb_role_switch_get_drvdata);
 407
 408 static int __init usb_roles_init(void)
 409 {
 410         return class_register(&role_class);
 411 }
 412 subsys_initcall(usb_roles_init);
 413
 414 static void __exit usb_roles_exit(void)
 415 {
 416         class_unregister(&role_class);
 417 }
 418 module_exit(usb_roles_exit);
 419
 420 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
 421 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
 422 MODULE_LICENSE("GPL v2");
 423 MODULE_DESCRIPTION("USB Role Class");