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 int ret; 65 66 if (!vbus_draw) 67 return; 68 69 enabled = gpio_vbus->vbus_draw_enabled; 70 if (mA) { 71 regulator_set_current_limit(vbus_draw, 0, 1000 * mA); 72 if (!enabled) { 73 ret = regulator_enable(vbus_draw); 74 if (ret < 0) 75 return; 76 gpio_vbus->vbus_draw_enabled = 1; 77 } 78 } else { 79 if (enabled) { 80 ret = regulator_disable(vbus_draw); 81 if (ret < 0) 82 return; 83 gpio_vbus->vbus_draw_enabled = 0; 84 } 85 } 86 gpio_vbus->mA = mA; 87 } 88 89 static int is_vbus_powered(struct gpio_vbus_mach_info *pdata) 90 { 91 int vbus; 92 93 vbus = gpio_get_value(pdata->gpio_vbus); 94 if (pdata->gpio_vbus_inverted) 95 vbus = !vbus; 96 97 return vbus; 98 } 99 100 static void gpio_vbus_work(struct work_struct *work) 101 { 102 struct gpio_vbus_data *gpio_vbus = 103 container_of(work, struct gpio_vbus_data, work.work); 104 struct gpio_vbus_mach_info *pdata = dev_get_platdata(gpio_vbus->dev); 105 int gpio, status, vbus; 106 107 if (!gpio_vbus->phy.otg->gadget) 108 return; 109 110 vbus = is_vbus_powered(pdata); 111 if ((vbus ^ gpio_vbus->vbus) == 0) 112 return; 113 gpio_vbus->vbus = vbus; 114 115 /* Peripheral controllers which manage the pullup themselves won't have 116 * gpio_pullup configured here. If it's configured here, we'll do what 117 * isp1301_omap::b_peripheral() does and enable the pullup here... although 118 * that may complicate usb_gadget_{,dis}connect() support. 119 */ 120 gpio = pdata->gpio_pullup; 121 122 if (vbus) { 123 status = USB_EVENT_VBUS; 124 gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; 125 gpio_vbus->phy.last_event = status; 126 usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); 127 128 /* drawing a "unit load" is *always* OK, except for OTG */ 129 set_vbus_draw(gpio_vbus, 100); 130 131 /* optionally enable D+ pullup */ 132 if (gpio_is_valid(gpio)) 133 gpio_set_value(gpio, !pdata->gpio_pullup_inverted); 134 135 atomic_notifier_call_chain(&gpio_vbus->phy.notifier, 136 status, gpio_vbus->phy.otg->gadget); 137 } else { 138 /* optionally disable D+ pullup */ 139 if (gpio_is_valid(gpio)) 140 gpio_set_value(gpio, pdata->gpio_pullup_inverted); 141 142 set_vbus_draw(gpio_vbus, 0); 143 144 usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); 145 status = USB_EVENT_NONE; 146 gpio_vbus->phy.state = OTG_STATE_B_IDLE; 147 gpio_vbus->phy.last_event = status; 148 149 atomic_notifier_call_chain(&gpio_vbus->phy.notifier, 150 status, gpio_vbus->phy.otg->gadget); 151 } 152 } 153 154 /* VBUS change IRQ handler */ 155 static irqreturn_t gpio_vbus_irq(int irq, void *data) 156 { 157 struct platform_device *pdev = data; 158 struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); 159 struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); 160 struct usb_otg *otg = gpio_vbus->phy.otg; 161 162 dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n", 163 is_vbus_powered(pdata) ? "supplied" : "inactive", 164 otg->gadget ? otg->gadget->name : "none"); 165 166 if (otg->gadget) 167 schedule_delayed_work(&gpio_vbus->work, msecs_to_jiffies(100)); 168 169 return IRQ_HANDLED; 170 } 171 172 /* OTG transceiver interface */ 173 174 /* bind/unbind the peripheral controller */ 175 static int gpio_vbus_set_peripheral(struct usb_otg *otg, 176 struct usb_gadget *gadget) 177 { 178 struct gpio_vbus_data *gpio_vbus; 179 struct gpio_vbus_mach_info *pdata; 180 struct platform_device *pdev; 181 int gpio; 182 183 gpio_vbus = container_of(otg->phy, struct gpio_vbus_data, phy); 184 pdev = to_platform_device(gpio_vbus->dev); 185 pdata = dev_get_platdata(gpio_vbus->dev); 186 gpio = pdata->gpio_pullup; 187 188 if (!gadget) { 189 dev_dbg(&pdev->dev, "unregistering gadget '%s'\n", 190 otg->gadget->name); 191 192 /* optionally disable D+ pullup */ 193 if (gpio_is_valid(gpio)) 194 gpio_set_value(gpio, pdata->gpio_pullup_inverted); 195 196 set_vbus_draw(gpio_vbus, 0); 197 198 usb_gadget_vbus_disconnect(otg->gadget); 199 otg->phy->state = OTG_STATE_UNDEFINED; 200 201 otg->gadget = NULL; 202 return 0; 203 } 204 205 otg->gadget = gadget; 206 dev_dbg(&pdev->dev, "registered gadget '%s'\n", gadget->name); 207 208 /* initialize connection state */ 209 gpio_vbus->vbus = 0; /* start with disconnected */ 210 gpio_vbus_irq(gpio_vbus->irq, pdev); 211 return 0; 212 } 213 214 /* effective for B devices, ignored for A-peripheral */ 215 static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA) 216 { 217 struct gpio_vbus_data *gpio_vbus; 218 219 gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); 220 221 if (phy->state == OTG_STATE_B_PERIPHERAL) 222 set_vbus_draw(gpio_vbus, mA); 223 return 0; 224 } 225 226 /* for non-OTG B devices: set/clear transceiver suspend mode */ 227 static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend) 228 { 229 struct gpio_vbus_data *gpio_vbus; 230 231 gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); 232 233 /* draw max 0 mA from vbus in suspend mode; or the previously 234 * recorded amount of current if not suspended 235 * 236 * NOTE: high powered configs (mA > 100) may draw up to 2.5 mA 237 * if they're wake-enabled ... we don't handle that yet. 238 */ 239 return gpio_vbus_set_power(phy, suspend ? 0 : gpio_vbus->mA); 240 } 241 242 /* platform driver interface */ 243 244 static int gpio_vbus_probe(struct platform_device *pdev) 245 { 246 struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); 247 struct gpio_vbus_data *gpio_vbus; 248 struct resource *res; 249 int err, gpio, irq; 250 unsigned long irqflags; 251 252 if (!pdata || !gpio_is_valid(pdata->gpio_vbus)) 253 return -EINVAL; 254 gpio = pdata->gpio_vbus; 255 256 gpio_vbus = kzalloc(sizeof(struct gpio_vbus_data), GFP_KERNEL); 257 if (!gpio_vbus) 258 return -ENOMEM; 259 260 gpio_vbus->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL); 261 if (!gpio_vbus->phy.otg) { 262 kfree(gpio_vbus); 263 return -ENOMEM; 264 } 265 266 platform_set_drvdata(pdev, gpio_vbus); 267 gpio_vbus->dev = &pdev->dev; 268 gpio_vbus->phy.label = "gpio-vbus"; 269 gpio_vbus->phy.dev = gpio_vbus->dev; 270 gpio_vbus->phy.set_power = gpio_vbus_set_power; 271 gpio_vbus->phy.set_suspend = gpio_vbus_set_suspend; 272 gpio_vbus->phy.state = OTG_STATE_UNDEFINED; 273 274 gpio_vbus->phy.otg->phy = &gpio_vbus->phy; 275 gpio_vbus->phy.otg->set_peripheral = gpio_vbus_set_peripheral; 276 277 err = gpio_request(gpio, "vbus_detect"); 278 if (err) { 279 dev_err(&pdev->dev, "can't request vbus gpio %d, err: %d\n", 280 gpio, err); 281 goto err_gpio; 282 } 283 gpio_direction_input(gpio); 284 285 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); 286 if (res) { 287 irq = res->start; 288 irqflags = (res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED; 289 } else { 290 irq = gpio_to_irq(gpio); 291 irqflags = VBUS_IRQ_FLAGS; 292 } 293 294 gpio_vbus->irq = irq; 295 296 /* if data line pullup is in use, initialize it to "not pulling up" */ 297 gpio = pdata->gpio_pullup; 298 if (gpio_is_valid(gpio)) { 299 err = gpio_request(gpio, "udc_pullup"); 300 if (err) { 301 dev_err(&pdev->dev, 302 "can't request pullup gpio %d, err: %d\n", 303 gpio, err); 304 gpio_free(pdata->gpio_vbus); 305 goto err_gpio; 306 } 307 gpio_direction_output(gpio, pdata->gpio_pullup_inverted); 308 } 309 310 err = request_irq(irq, gpio_vbus_irq, irqflags, "vbus_detect", pdev); 311 if (err) { 312 dev_err(&pdev->dev, "can't request irq %i, err: %d\n", 313 irq, err); 314 goto err_irq; 315 } 316 317 ATOMIC_INIT_NOTIFIER_HEAD(&gpio_vbus->phy.notifier); 318 319 INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work); 320 321 gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw"); 322 if (IS_ERR(gpio_vbus->vbus_draw)) { 323 dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n", 324 PTR_ERR(gpio_vbus->vbus_draw)); 325 gpio_vbus->vbus_draw = NULL; 326 } 327 328 /* only active when a gadget is registered */ 329 err = usb_add_phy(&gpio_vbus->phy, USB_PHY_TYPE_USB2); 330 if (err) { 331 dev_err(&pdev->dev, "can't register transceiver, err: %d\n", 332 err); 333 goto err_otg; 334 } 335 336 device_init_wakeup(&pdev->dev, pdata->wakeup); 337 338 return 0; 339 err_otg: 340 regulator_put(gpio_vbus->vbus_draw); 341 free_irq(irq, pdev); 342 err_irq: 343 if (gpio_is_valid(pdata->gpio_pullup)) 344 gpio_free(pdata->gpio_pullup); 345 gpio_free(pdata->gpio_vbus); 346 err_gpio: 347 kfree(gpio_vbus->phy.otg); 348 kfree(gpio_vbus); 349 return err; 350 } 351 352 static int gpio_vbus_remove(struct platform_device *pdev) 353 { 354 struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); 355 struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); 356 int gpio = pdata->gpio_vbus; 357 358 device_init_wakeup(&pdev->dev, 0); 359 cancel_delayed_work_sync(&gpio_vbus->work); 360 regulator_put(gpio_vbus->vbus_draw); 361 362 usb_remove_phy(&gpio_vbus->phy); 363 364 free_irq(gpio_vbus->irq, pdev); 365 if (gpio_is_valid(pdata->gpio_pullup)) 366 gpio_free(pdata->gpio_pullup); 367 gpio_free(gpio); 368 kfree(gpio_vbus->phy.otg); 369 kfree(gpio_vbus); 370 371 return 0; 372 } 373 374 #ifdef CONFIG_PM 375 static int gpio_vbus_pm_suspend(struct device *dev) 376 { 377 struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); 378 379 if (device_may_wakeup(dev)) 380 enable_irq_wake(gpio_vbus->irq); 381 382 return 0; 383 } 384 385 static int gpio_vbus_pm_resume(struct device *dev) 386 { 387 struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); 388 389 if (device_may_wakeup(dev)) 390 disable_irq_wake(gpio_vbus->irq); 391 392 return 0; 393 } 394 395 static const struct dev_pm_ops gpio_vbus_dev_pm_ops = { 396 .suspend = gpio_vbus_pm_suspend, 397 .resume = gpio_vbus_pm_resume, 398 }; 399 #endif 400 401 MODULE_ALIAS("platform:gpio-vbus"); 402 403 static struct platform_driver gpio_vbus_driver = { 404 .driver = { 405 .name = "gpio-vbus", 406 .owner = THIS_MODULE, 407 #ifdef CONFIG_PM 408 .pm = &gpio_vbus_dev_pm_ops, 409 #endif 410 }, 411 .probe = gpio_vbus_probe, 412 .remove = gpio_vbus_remove, 413 }; 414 415 module_platform_driver(gpio_vbus_driver); 416 417 MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver"); 418 MODULE_AUTHOR("Philipp Zabel"); 419 MODULE_LICENSE("GPL"); 420