drivers/usb/misc/onboard_usb_hub.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for onboard USB hubs
   4  *
   5  * Copyright (c) 2022, Google LLC
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/export.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/list.h>
  14 #include <linux/module.h>
  15 #include <linux/mutex.h>
  16 #include <linux/of.h>
  17 #include <linux/of_platform.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/regulator/consumer.h>
  20 #include <linux/slab.h>
  21 #include <linux/suspend.h>
  22 #include <linux/sysfs.h>
  23 #include <linux/usb.h>
  24 #include <linux/usb/hcd.h>
  25 #include <linux/usb/onboard_hub.h>
  26 #include <linux/workqueue.h>
  27
  28 #include "onboard_usb_hub.h"
  29
  30 static struct usb_device_driver onboard_hub_usbdev_driver;
  31
  32 /************************** Platform driver **************************/
  33
  34 struct usbdev_node {
  35         struct usb_device *udev;
  36         struct list_head list;
  37 };
  38
  39 struct onboard_hub {
  40         struct regulator *vdd;
  41         struct device *dev;
  42         const struct onboard_hub_pdata *pdata;
  43         struct gpio_desc *reset_gpio;
  44         bool always_powered_in_suspend;
  45         bool is_powered_on;
  46         bool going_away;
  47         struct list_head udev_list;
  48         struct work_struct attach_usb_driver_work;
  49         struct mutex lock;
  50 };
  51
  52 static int onboard_hub_power_on(struct onboard_hub *hub)
  53 {
  54         int err;
  55
  56         err = regulator_enable(hub->vdd);
  57         if (err) {
  58                 dev_err(hub->dev, "failed to enable regulator: %d\n", err);
  59                 return err;
  60         }
  61
  62         fsleep(hub->pdata->reset_us);
  63         gpiod_set_value_cansleep(hub->reset_gpio, 0);
  64
  65         hub->is_powered_on = true;
  66
  67         return 0;
  68 }
  69
  70 static int onboard_hub_power_off(struct onboard_hub *hub)
  71 {
  72         int err;
  73
  74         gpiod_set_value_cansleep(hub->reset_gpio, 1);
  75
  76         err = regulator_disable(hub->vdd);
  77         if (err) {
  78                 dev_err(hub->dev, "failed to disable regulator: %d\n", err);
  79                 return err;
  80         }
  81
  82         hub->is_powered_on = false;
  83
  84         return 0;
  85 }
  86
  87 static int __maybe_unused onboard_hub_suspend(struct device *dev)
  88 {
  89         struct onboard_hub *hub = dev_get_drvdata(dev);
  90         struct usbdev_node *node;
  91         bool power_off = true;
  92
  93         if (hub->always_powered_in_suspend)
  94                 return 0;
  95
  96         mutex_lock(&hub->lock);
  97
  98         list_for_each_entry(node, &hub->udev_list, list) {
  99                 if (!device_may_wakeup(node->udev->bus->controller))
 100                         continue;
 101
 102                 if (usb_wakeup_enabled_descendants(node->udev)) {
 103                         power_off = false;
 104                         break;
 105                 }
 106         }
 107
 108         mutex_unlock(&hub->lock);
 109
 110         if (!power_off)
 111                 return 0;
 112
 113         return onboard_hub_power_off(hub);
 114 }
 115
 116 static int __maybe_unused onboard_hub_resume(struct device *dev)
 117 {
 118         struct onboard_hub *hub = dev_get_drvdata(dev);
 119
 120         if (hub->is_powered_on)
 121                 return 0;
 122
 123         return onboard_hub_power_on(hub);
 124 }
 125
 126 static inline void get_udev_link_name(const struct usb_device *udev, char *buf, size_t size)
 127 {
 128         snprintf(buf, size, "usb_dev.%s", dev_name(&udev->dev));
 129 }
 130
 131 static int onboard_hub_add_usbdev(struct onboard_hub *hub, struct usb_device *udev)
 132 {
 133         struct usbdev_node *node;
 134         char link_name[64];
 135         int err;
 136
 137         mutex_lock(&hub->lock);
 138
 139         if (hub->going_away) {
 140                 err = -EINVAL;
 141                 goto error;
 142         }
 143
 144         node = kzalloc(sizeof(*node), GFP_KERNEL);
 145         if (!node) {
 146                 err = -ENOMEM;
 147                 goto error;
 148         }
 149
 150         node->udev = udev;
 151
 152         list_add(&node->list, &hub->udev_list);
 153
 154         mutex_unlock(&hub->lock);
 155
 156         get_udev_link_name(udev, link_name, sizeof(link_name));
 157         WARN_ON(sysfs_create_link(&hub->dev->kobj, &udev->dev.kobj, link_name));
 158
 159         return 0;
 160
 161 error:
 162         mutex_unlock(&hub->lock);
 163
 164         return err;
 165 }
 166
 167 static void onboard_hub_remove_usbdev(struct onboard_hub *hub, const struct usb_device *udev)
 168 {
 169         struct usbdev_node *node;
 170         char link_name[64];
 171
 172         get_udev_link_name(udev, link_name, sizeof(link_name));
 173         sysfs_remove_link(&hub->dev->kobj, link_name);
 174
 175         mutex_lock(&hub->lock);
 176
 177         list_for_each_entry(node, &hub->udev_list, list) {
 178                 if (node->udev == udev) {
 179                         list_del(&node->list);
 180                         kfree(node);
 181                         break;
 182                 }
 183         }
 184
 185         mutex_unlock(&hub->lock);
 186 }
 187
 188 static ssize_t always_powered_in_suspend_show(struct device *dev, struct device_attribute *attr,
 189                            char *buf)
 190 {
 191         const struct onboard_hub *hub = dev_get_drvdata(dev);
 192
 193         return sysfs_emit(buf, "%d\n", hub->always_powered_in_suspend);
 194 }
 195
 196 static ssize_t always_powered_in_suspend_store(struct device *dev, struct device_attribute *attr,
 197                             const char *buf, size_t count)
 198 {
 199         struct onboard_hub *hub = dev_get_drvdata(dev);
 200         bool val;
 201         int ret;
 202
 203         ret = kstrtobool(buf, &val);
 204         if (ret < 0)
 205                 return ret;
 206
 207         hub->always_powered_in_suspend = val;
 208
 209         return count;
 210 }
 211 static DEVICE_ATTR_RW(always_powered_in_suspend);
 212
 213 static struct attribute *onboard_hub_attrs[] = {
 214         &dev_attr_always_powered_in_suspend.attr,
 215         NULL,
 216 };
 217 ATTRIBUTE_GROUPS(onboard_hub);
 218
 219 static void onboard_hub_attach_usb_driver(struct work_struct *work)
 220 {
 221         int err;
 222
 223         err = driver_attach(&onboard_hub_usbdev_driver.drvwrap.driver);
 224         if (err)
 225                 pr_err("Failed to attach USB driver: %d\n", err);
 226 }
 227
 228 static int onboard_hub_probe(struct platform_device *pdev)
 229 {
 230         const struct of_device_id *of_id;
 231         struct device *dev = &pdev->dev;
 232         struct onboard_hub *hub;
 233         int err;
 234
 235         hub = devm_kzalloc(dev, sizeof(*hub), GFP_KERNEL);
 236         if (!hub)
 237                 return -ENOMEM;
 238
 239         of_id = of_match_device(onboard_hub_match, &pdev->dev);
 240         if (!of_id)
 241                 return -ENODEV;
 242
 243         hub->pdata = of_id->data;
 244         if (!hub->pdata)
 245                 return -EINVAL;
 246
 247         hub->vdd = devm_regulator_get(dev, "vdd");
 248         if (IS_ERR(hub->vdd))
 249                 return PTR_ERR(hub->vdd);
 250
 251         hub->reset_gpio = devm_gpiod_get_optional(dev, "reset",
 252                                                   GPIOD_OUT_HIGH);
 253         if (IS_ERR(hub->reset_gpio))
 254                 return dev_err_probe(dev, PTR_ERR(hub->reset_gpio), "failed to get reset GPIO\n");
 255
 256         hub->dev = dev;
 257         mutex_init(&hub->lock);
 258         INIT_LIST_HEAD(&hub->udev_list);
 259
 260         dev_set_drvdata(dev, hub);
 261
 262         err = onboard_hub_power_on(hub);
 263         if (err)
 264                 return err;
 265
 266         /*
 267          * The USB driver might have been detached from the USB devices by
 268          * onboard_hub_remove() (e.g. through an 'unbind' by userspace),
 269          * make sure to re-attach it if needed.
 270          *
 271          * This needs to be done deferred to avoid self-deadlocks on systems
 272          * with nested onboard hubs.
 273          */
 274         INIT_WORK(&hub->attach_usb_driver_work, onboard_hub_attach_usb_driver);
 275         schedule_work(&hub->attach_usb_driver_work);
 276
 277         return 0;
 278 }
 279
 280 static int onboard_hub_remove(struct platform_device *pdev)
 281 {
 282         struct onboard_hub *hub = dev_get_drvdata(&pdev->dev);
 283         struct usbdev_node *node;
 284         struct usb_device *udev;
 285
 286         hub->going_away = true;
 287
 288         if (&hub->attach_usb_driver_work != current_work())
 289                 cancel_work_sync(&hub->attach_usb_driver_work);
 290
 291         mutex_lock(&hub->lock);
 292
 293         /* unbind the USB devices to avoid dangling references to this device */
 294         while (!list_empty(&hub->udev_list)) {
 295                 node = list_first_entry(&hub->udev_list, struct usbdev_node, list);
 296                 udev = node->udev;
 297
 298                 /*
 299                  * Unbinding the driver will call onboard_hub_remove_usbdev(),
 300                  * which acquires hub->lock.  We must release the lock first.
 301                  */
 302                 get_device(&udev->dev);
 303                 mutex_unlock(&hub->lock);
 304                 device_release_driver(&udev->dev);
 305                 put_device(&udev->dev);
 306                 mutex_lock(&hub->lock);
 307         }
 308
 309         mutex_unlock(&hub->lock);
 310
 311         return onboard_hub_power_off(hub);
 312 }
 313
 314 MODULE_DEVICE_TABLE(of, onboard_hub_match);
 315
 316 static const struct dev_pm_ops __maybe_unused onboard_hub_pm_ops = {
 317         SET_LATE_SYSTEM_SLEEP_PM_OPS(onboard_hub_suspend, onboard_hub_resume)
 318 };
 319
 320 static struct platform_driver onboard_hub_driver = {
 321         .probe = onboard_hub_probe,
 322         .remove = onboard_hub_remove,
 323
 324         .driver = {
 325                 .name = "onboard-usb-hub",
 326                 .of_match_table = onboard_hub_match,
 327                 .pm = pm_ptr(&onboard_hub_pm_ops),
 328                 .dev_groups = onboard_hub_groups,
 329         },
 330 };
 331
 332 /************************** USB driver **************************/
 333
 334 #define VENDOR_ID_GENESYS       0x05e3
 335 #define VENDOR_ID_MICROCHIP     0x0424
 336 #define VENDOR_ID_REALTEK       0x0bda
 337 #define VENDOR_ID_TI            0x0451
 338
 339 /*
 340  * Returns the onboard_hub platform device that is associated with the USB
 341  * device passed as parameter.
 342  */
 343 static struct onboard_hub *_find_onboard_hub(struct device *dev)
 344 {
 345         struct platform_device *pdev;
 346         struct device_node *np;
 347         struct onboard_hub *hub;
 348
 349         pdev = of_find_device_by_node(dev->of_node);
 350         if (!pdev) {
 351                 np = of_parse_phandle(dev->of_node, "peer-hub", 0);
 352                 if (!np) {
 353                         dev_err(dev, "failed to find device node for peer hub\n");
 354                         return ERR_PTR(-EINVAL);
 355                 }
 356
 357                 pdev = of_find_device_by_node(np);
 358                 of_node_put(np);
 359
 360                 if (!pdev)
 361                         return ERR_PTR(-ENODEV);
 362         }
 363
 364         hub = dev_get_drvdata(&pdev->dev);
 365         put_device(&pdev->dev);
 366
 367         /*
 368          * The presence of drvdata ('hub') indicates that the platform driver
 369          * finished probing. This handles the case where (conceivably) we could
 370          * be running at the exact same time as the platform driver's probe. If
 371          * we detect the race we request probe deferral and we'll come back and
 372          * try again.
 373          */
 374         if (!hub)
 375                 return ERR_PTR(-EPROBE_DEFER);
 376
 377         return hub;
 378 }
 379
 380 static int onboard_hub_usbdev_probe(struct usb_device *udev)
 381 {
 382         struct device *dev = &udev->dev;
 383         struct onboard_hub *hub;
 384         int err;
 385
 386         /* ignore supported hubs without device tree node */
 387         if (!dev->of_node)
 388                 return -ENODEV;
 389
 390         hub = _find_onboard_hub(dev);
 391         if (IS_ERR(hub))
 392                 return PTR_ERR(hub);
 393
 394         dev_set_drvdata(dev, hub);
 395
 396         err = onboard_hub_add_usbdev(hub, udev);
 397         if (err)
 398                 return err;
 399
 400         return 0;
 401 }
 402
 403 static void onboard_hub_usbdev_disconnect(struct usb_device *udev)
 404 {
 405         struct onboard_hub *hub = dev_get_drvdata(&udev->dev);
 406
 407         onboard_hub_remove_usbdev(hub, udev);
 408 }
 409
 410 static const struct usb_device_id onboard_hub_id_table[] = {
 411         { USB_DEVICE(VENDOR_ID_GENESYS, 0x0608) }, /* Genesys Logic GL850G USB 2.0 */
 412         { USB_DEVICE(VENDOR_ID_MICROCHIP, 0x2514) }, /* USB2514B USB 2.0 */
 413         { USB_DEVICE(VENDOR_ID_REALTEK, 0x0411) }, /* RTS5411 USB 3.1 */
 414         { USB_DEVICE(VENDOR_ID_REALTEK, 0x5411) }, /* RTS5411 USB 2.1 */
 415         { USB_DEVICE(VENDOR_ID_REALTEK, 0x0414) }, /* RTS5414 USB 3.2 */
 416         { USB_DEVICE(VENDOR_ID_REALTEK, 0x5414) }, /* RTS5414 USB 2.1 */
 417         { USB_DEVICE(VENDOR_ID_TI, 0x8140) }, /* TI USB8041 3.0 */
 418         { USB_DEVICE(VENDOR_ID_TI, 0x8142) }, /* TI USB8041 2.0 */
 419         {}
 420 };
 421 MODULE_DEVICE_TABLE(usb, onboard_hub_id_table);
 422
 423 static struct usb_device_driver onboard_hub_usbdev_driver = {
 424         .name = "onboard-usb-hub",
 425         .probe = onboard_hub_usbdev_probe,
 426         .disconnect = onboard_hub_usbdev_disconnect,
 427         .generic_subclass = 1,
 428         .supports_autosuspend = 1,
 429         .id_table = onboard_hub_id_table,
 430 };
 431
 432 static int __init onboard_hub_init(void)
 433 {
 434         int ret;
 435
 436         ret = usb_register_device_driver(&onboard_hub_usbdev_driver, THIS_MODULE);
 437         if (ret)
 438                 return ret;
 439
 440         ret = platform_driver_register(&onboard_hub_driver);
 441         if (ret)
 442                 usb_deregister_device_driver(&onboard_hub_usbdev_driver);
 443
 444         return ret;
 445 }
 446 module_init(onboard_hub_init);
 447
 448 static void __exit onboard_hub_exit(void)
 449 {
 450         usb_deregister_device_driver(&onboard_hub_usbdev_driver);
 451         platform_driver_unregister(&onboard_hub_driver);
 452 }
 453 module_exit(onboard_hub_exit);
 454
 455 MODULE_AUTHOR("Matthias Kaehlcke <mka@chromium.org>");
 456 MODULE_DESCRIPTION("Driver for discrete onboard USB hubs");
 457 MODULE_LICENSE("GPL v2");