drivers/usb/otg/gpio_vbus.c

   1 /*
   2  * gpio-vbus.c - simple GPIO VBUS sensing driver for B peripheral devices
   3  *
   4  * Copyright (c) 2008 Philipp Zabel <philipp.zabel@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/gpio.h>
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/usb.h>
  18 #include <linux/workqueue.h>
  19
  20 #include <linux/regulator/consumer.h>
  21
  22 #include <linux/usb/gadget.h>
  23 #include <linux/usb/gpio_vbus.h>
  24 #include <linux/usb/otg.h>
  25
  26
  27 /*
  28  * A simple GPIO VBUS sensing driver for B peripheral only devices
  29  * with internal transceivers. It can control a D+ pullup GPIO and
  30  * a regulator to limit the current drawn from VBUS.
  31  *
  32  * Needs to be loaded before the UDC driver that will use it.
  33  */
  34 struct gpio_vbus_data {
  35         struct usb_phy          phy;
  36         struct device          *dev;
  37         struct regulator       *vbus_draw;
  38         int                     vbus_draw_enabled;
  39         unsigned                mA;
  40         struct delayed_work     work;
  41         int                     vbus;
  42         int                     irq;
  43 };
  44
  45
  46 /*
  47  * This driver relies on "both edges" triggering.  VBUS has 100 msec to
  48  * stabilize, so the peripheral controller driver may need to cope with
  49  * some bouncing due to current surges (e.g. charging local capacitance)
  50  * and contact chatter.
  51  *
  52  * REVISIT in desperate straits, toggling between rising and falling
  53  * edges might be workable.
  54  */
  55 #define VBUS_IRQ_FLAGS \
  56         (IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
  57
  58
  59 /* interface to regulator framework */
  60 static void set_vbus_draw(struct gpio_vbus_data *gpio_vbus, unsigned mA)
  61 {
  62         struct regulator *vbus_draw = gpio_vbus->vbus_draw;
  63         int enabled;
  64
  65         if (!vbus_draw)
  66                 return;
  67
  68         enabled = gpio_vbus->vbus_draw_enabled;
  69         if (mA) {
  70                 regulator_set_current_limit(vbus_draw, 0, 1000 * mA);
  71                 if (!enabled) {
  72                         regulator_enable(vbus_draw);
  73                         gpio_vbus->vbus_draw_enabled = 1;
  74                 }
  75         } else {
  76                 if (enabled) {
  77                         regulator_disable(vbus_draw);
  78                         gpio_vbus->vbus_draw_enabled = 0;
  79                 }
  80         }
  81         gpio_vbus->mA = mA;
  82 }
  83
  84 static int is_vbus_powered(struct gpio_vbus_mach_info *pdata)
  85 {
  86         int vbus;
  87
  88         vbus = gpio_get_value(pdata->gpio_vbus);
  89         if (pdata->gpio_vbus_inverted)
  90                 vbus = !vbus;
  91
  92         return vbus;
  93 }
  94
  95 static void gpio_vbus_work(struct work_struct *work)
  96 {
  97         struct gpio_vbus_data *gpio_vbus =
  98                 container_of(work, struct gpio_vbus_data, work.work);
  99         struct gpio_vbus_mach_info *pdata = gpio_vbus->dev->platform_data;
 100         int gpio, status, vbus;
 101
 102         if (!gpio_vbus->phy.otg->gadget)
 103                 return;
 104
 105         vbus = is_vbus_powered(pdata);
 106         if ((vbus ^ gpio_vbus->vbus) == 0)
 107                 return;
 108         gpio_vbus->vbus = vbus;
 109
 110         /* Peripheral controllers which manage the pullup themselves won't have
 111          * gpio_pullup configured here.  If it's configured here, we'll do what
 112          * isp1301_omap::b_peripheral() does and enable the pullup here... although
 113          * that may complicate usb_gadget_{,dis}connect() support.
 114          */
 115         gpio = pdata->gpio_pullup;
 116
 117         if (vbus) {
 118                 status = USB_EVENT_VBUS;
 119                 gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL;
 120                 gpio_vbus->phy.last_event = status;
 121                 usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget);
 122
 123                 /* drawing a "unit load" is *always* OK, except for OTG */
 124                 set_vbus_draw(gpio_vbus, 100);
 125
 126                 /* optionally enable D+ pullup */
 127                 if (gpio_is_valid(gpio))
 128                         gpio_set_value(gpio, !pdata->gpio_pullup_inverted);
 129
 130                 atomic_notifier_call_chain(&gpio_vbus->phy.notifier,
 131                                            status, gpio_vbus->phy.otg->gadget);
 132         } else {
 133                 /* optionally disable D+ pullup */
 134                 if (gpio_is_valid(gpio))
 135                         gpio_set_value(gpio, pdata->gpio_pullup_inverted);
 136
 137                 set_vbus_draw(gpio_vbus, 0);
 138
 139                 usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget);
 140                 status = USB_EVENT_NONE;
 141                 gpio_vbus->phy.state = OTG_STATE_B_IDLE;
 142                 gpio_vbus->phy.last_event = status;
 143
 144                 atomic_notifier_call_chain(&gpio_vbus->phy.notifier,
 145                                            status, gpio_vbus->phy.otg->gadget);
 146         }
 147 }
 148
 149 /* VBUS change IRQ handler */
 150 static irqreturn_t gpio_vbus_irq(int irq, void *data)
 151 {
 152         struct platform_device *pdev = data;
 153         struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
 154         struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
 155         struct usb_otg *otg = gpio_vbus->phy.otg;
 156
 157         dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n",
 158                 is_vbus_powered(pdata) ? "supplied" : "inactive",
 159                 otg->gadget ? otg->gadget->name : "none");
 160
 161         if (otg->gadget)
 162                 schedule_delayed_work(&gpio_vbus->work, msecs_to_jiffies(100));
 163
 164         return IRQ_HANDLED;
 165 }
 166
 167 /* OTG transceiver interface */
 168
 169 /* bind/unbind the peripheral controller */
 170 static int gpio_vbus_set_peripheral(struct usb_otg *otg,
 171                                         struct usb_gadget *gadget)
 172 {
 173         struct gpio_vbus_data *gpio_vbus;
 174         struct gpio_vbus_mach_info *pdata;
 175         struct platform_device *pdev;
 176         int gpio;
 177
 178         gpio_vbus = container_of(otg->phy, struct gpio_vbus_data, phy);
 179         pdev = to_platform_device(gpio_vbus->dev);
 180         pdata = gpio_vbus->dev->platform_data;
 181         gpio = pdata->gpio_pullup;
 182
 183         if (!gadget) {
 184                 dev_dbg(&pdev->dev, "unregistering gadget '%s'\n",
 185                         otg->gadget->name);
 186
 187                 /* optionally disable D+ pullup */
 188                 if (gpio_is_valid(gpio))
 189                         gpio_set_value(gpio, pdata->gpio_pullup_inverted);
 190
 191                 set_vbus_draw(gpio_vbus, 0);
 192
 193                 usb_gadget_vbus_disconnect(otg->gadget);
 194                 otg->phy->state = OTG_STATE_UNDEFINED;
 195
 196                 otg->gadget = NULL;
 197                 return 0;
 198         }
 199
 200         otg->gadget = gadget;
 201         dev_dbg(&pdev->dev, "registered gadget '%s'\n", gadget->name);
 202
 203         /* initialize connection state */
 204         gpio_vbus->vbus = 0; /* start with disconnected */
 205         gpio_vbus_irq(gpio_vbus->irq, pdev);
 206         return 0;
 207 }
 208
 209 /* effective for B devices, ignored for A-peripheral */
 210 static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA)
 211 {
 212         struct gpio_vbus_data *gpio_vbus;
 213
 214         gpio_vbus = container_of(phy, struct gpio_vbus_data, phy);
 215
 216         if (phy->state == OTG_STATE_B_PERIPHERAL)
 217                 set_vbus_draw(gpio_vbus, mA);
 218         return 0;
 219 }
 220
 221 /* for non-OTG B devices: set/clear transceiver suspend mode */
 222 static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend)
 223 {
 224         struct gpio_vbus_data *gpio_vbus;
 225
 226         gpio_vbus = container_of(phy, struct gpio_vbus_data, phy);
 227
 228         /* draw max 0 mA from vbus in suspend mode; or the previously
 229          * recorded amount of current if not suspended
 230          *
 231          * NOTE: high powered configs (mA > 100) may draw up to 2.5 mA
 232          * if they're wake-enabled ... we don't handle that yet.
 233          */
 234         return gpio_vbus_set_power(phy, suspend ? 0 : gpio_vbus->mA);
 235 }
 236
 237 /* platform driver interface */
 238
 239 static int __init gpio_vbus_probe(struct platform_device *pdev)
 240 {
 241         struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
 242         struct gpio_vbus_data *gpio_vbus;
 243         struct resource *res;
 244         int err, gpio, irq;
 245         unsigned long irqflags;
 246
 247         if (!pdata || !gpio_is_valid(pdata->gpio_vbus))
 248                 return -EINVAL;
 249         gpio = pdata->gpio_vbus;
 250
 251         gpio_vbus = kzalloc(sizeof(struct gpio_vbus_data), GFP_KERNEL);
 252         if (!gpio_vbus)
 253                 return -ENOMEM;
 254
 255         gpio_vbus->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
 256         if (!gpio_vbus->phy.otg) {
 257                 kfree(gpio_vbus);
 258                 return -ENOMEM;
 259         }
 260
 261         platform_set_drvdata(pdev, gpio_vbus);
 262         gpio_vbus->dev = &pdev->dev;
 263         gpio_vbus->phy.label = "gpio-vbus";
 264         gpio_vbus->phy.set_power = gpio_vbus_set_power;
 265         gpio_vbus->phy.set_suspend = gpio_vbus_set_suspend;
 266         gpio_vbus->phy.state = OTG_STATE_UNDEFINED;
 267
 268         gpio_vbus->phy.otg->phy = &gpio_vbus->phy;
 269         gpio_vbus->phy.otg->set_peripheral = gpio_vbus_set_peripheral;
 270
 271         err = gpio_request(gpio, "vbus_detect");
 272         if (err) {
 273                 dev_err(&pdev->dev, "can't request vbus gpio %d, err: %d\n",
 274                         gpio, err);
 275                 goto err_gpio;
 276         }
 277         gpio_direction_input(gpio);
 278
 279         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 280         if (res) {
 281                 irq = res->start;
 282                 irqflags = (res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED;
 283         } else {
 284                 irq = gpio_to_irq(gpio);
 285                 irqflags = VBUS_IRQ_FLAGS;
 286         }
 287
 288         gpio_vbus->irq = irq;
 289
 290         /* if data line pullup is in use, initialize it to "not pulling up" */
 291         gpio = pdata->gpio_pullup;
 292         if (gpio_is_valid(gpio)) {
 293                 err = gpio_request(gpio, "udc_pullup");
 294                 if (err) {
 295                         dev_err(&pdev->dev,
 296                                 "can't request pullup gpio %d, err: %d\n",
 297                                 gpio, err);
 298                         gpio_free(pdata->gpio_vbus);
 299                         goto err_gpio;
 300                 }
 301                 gpio_direction_output(gpio, pdata->gpio_pullup_inverted);
 302         }
 303
 304         err = request_irq(irq, gpio_vbus_irq, irqflags, "vbus_detect", pdev);
 305         if (err) {
 306                 dev_err(&pdev->dev, "can't request irq %i, err: %d\n",
 307                         irq, err);
 308                 goto err_irq;
 309         }
 310
 311         ATOMIC_INIT_NOTIFIER_HEAD(&gpio_vbus->phy.notifier);
 312
 313         INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work);
 314
 315         gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
 316         if (IS_ERR(gpio_vbus->vbus_draw)) {
 317                 dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
 318                         PTR_ERR(gpio_vbus->vbus_draw));
 319                 gpio_vbus->vbus_draw = NULL;
 320         }
 321
 322         /* only active when a gadget is registered */
 323         err = usb_add_phy(&gpio_vbus->phy, USB_PHY_TYPE_USB2);
 324         if (err) {
 325                 dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
 326                         err);
 327                 goto err_otg;
 328         }
 329
 330         device_init_wakeup(&pdev->dev, pdata->wakeup);
 331
 332         return 0;
 333 err_otg:
 334         regulator_put(gpio_vbus->vbus_draw);
 335         free_irq(irq, pdev);
 336 err_irq:
 337         if (gpio_is_valid(pdata->gpio_pullup))
 338                 gpio_free(pdata->gpio_pullup);
 339         gpio_free(pdata->gpio_vbus);
 340 err_gpio:
 341         platform_set_drvdata(pdev, NULL);
 342         kfree(gpio_vbus->phy.otg);
 343         kfree(gpio_vbus);
 344         return err;
 345 }
 346
 347 static int __exit gpio_vbus_remove(struct platform_device *pdev)
 348 {
 349         struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
 350         struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
 351         int gpio = pdata->gpio_vbus;
 352
 353         device_init_wakeup(&pdev->dev, 0);
 354         cancel_delayed_work_sync(&gpio_vbus->work);
 355         regulator_put(gpio_vbus->vbus_draw);
 356
 357         usb_remove_phy(&gpio_vbus->phy);
 358
 359         free_irq(gpio_vbus->irq, pdev);
 360         if (gpio_is_valid(pdata->gpio_pullup))
 361                 gpio_free(pdata->gpio_pullup);
 362         gpio_free(gpio);
 363         platform_set_drvdata(pdev, NULL);
 364         kfree(gpio_vbus->phy.otg);
 365         kfree(gpio_vbus);
 366
 367         return 0;
 368 }
 369
 370 #ifdef CONFIG_PM
 371 static int gpio_vbus_pm_suspend(struct device *dev)
 372 {
 373         struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev);
 374
 375         if (device_may_wakeup(dev))
 376                 enable_irq_wake(gpio_vbus->irq);
 377
 378         return 0;
 379 }
 380
 381 static int gpio_vbus_pm_resume(struct device *dev)
 382 {
 383         struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev);
 384
 385         if (device_may_wakeup(dev))
 386                 disable_irq_wake(gpio_vbus->irq);
 387
 388         return 0;
 389 }
 390
 391 static const struct dev_pm_ops gpio_vbus_dev_pm_ops = {
 392         .suspend        = gpio_vbus_pm_suspend,
 393         .resume         = gpio_vbus_pm_resume,
 394 };
 395 #endif
 396
 397 /* NOTE:  the gpio-vbus device may *NOT* be hotplugged */
 398
 399 MODULE_ALIAS("platform:gpio-vbus");
 400
 401 static struct platform_driver gpio_vbus_driver = {
 402         .driver = {
 403                 .name  = "gpio-vbus",
 404                 .owner = THIS_MODULE,
 405 #ifdef CONFIG_PM
 406                 .pm = &gpio_vbus_dev_pm_ops,
 407 #endif
 408         },
 409         .remove  = __exit_p(gpio_vbus_remove),
 410 };
 411
 412 static int __init gpio_vbus_init(void)
 413 {
 414         return platform_driver_probe(&gpio_vbus_driver, gpio_vbus_probe);
 415 }
 416 module_init(gpio_vbus_init);
 417
 418 static void __exit gpio_vbus_exit(void)
 419 {
 420         platform_driver_unregister(&gpio_vbus_driver);
 421 }
 422 module_exit(gpio_vbus_exit);
 423
 424 MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver");
 425 MODULE_AUTHOR("Philipp Zabel");
 426 MODULE_LICENSE("GPL");