Commit | Line | Data |
---|---|---|
6084f1bf PZ |
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> | |
6eb0de82 | 14 | #include <linux/module.h> |
5a0e3ad6 | 15 | #include <linux/slab.h> |
6084f1bf PZ |
16 | #include <linux/interrupt.h> |
17 | #include <linux/usb.h> | |
c2344f13 | 18 | #include <linux/workqueue.h> |
6084f1bf PZ |
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 { | |
16bc1bb2 | 35 | struct usb_phy phy; |
6084f1bf PZ |
36 | struct device *dev; |
37 | struct regulator *vbus_draw; | |
38 | int vbus_draw_enabled; | |
39 | unsigned mA; | |
934ccec4 | 40 | struct delayed_work work; |
e44694e8 | 41 | int vbus; |
123bbcee | 42 | int irq; |
6084f1bf PZ |
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 \ | |
da020b49 | 56 | (IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING) |
6084f1bf PZ |
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 | ||
c2344f13 | 84 | static int is_vbus_powered(struct gpio_vbus_mach_info *pdata) |
6084f1bf | 85 | { |
c2344f13 | 86 | int vbus; |
6084f1bf PZ |
87 | |
88 | vbus = gpio_get_value(pdata->gpio_vbus); | |
89 | if (pdata->gpio_vbus_inverted) | |
90 | vbus = !vbus; | |
91 | ||
c2344f13 RJ |
92 | return vbus; |
93 | } | |
94 | ||
95 | static void gpio_vbus_work(struct work_struct *work) | |
96 | { | |
97 | struct gpio_vbus_data *gpio_vbus = | |
934ccec4 | 98 | container_of(work, struct gpio_vbus_data, work.work); |
c2344f13 | 99 | struct gpio_vbus_mach_info *pdata = gpio_vbus->dev->platform_data; |
e44694e8 | 100 | int gpio, status, vbus; |
6084f1bf | 101 | |
16bc1bb2 | 102 | if (!gpio_vbus->phy.otg->gadget) |
c2344f13 | 103 | return; |
6084f1bf | 104 | |
e44694e8 SK |
105 | vbus = is_vbus_powered(pdata); |
106 | if ((vbus ^ gpio_vbus->vbus) == 0) | |
107 | return; | |
108 | gpio_vbus->vbus = vbus; | |
109 | ||
6084f1bf PZ |
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; | |
e44694e8 SK |
116 | |
117 | if (vbus) { | |
662c738d | 118 | status = USB_EVENT_VBUS; |
16bc1bb2 | 119 | gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; |
662c738d | 120 | gpio_vbus->phy.last_event = status; |
16bc1bb2 | 121 | usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); |
6084f1bf PZ |
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); | |
662c738d HS |
129 | |
130 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | |
131 | status, gpio_vbus->phy.otg->gadget); | |
6084f1bf PZ |
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 | ||
16bc1bb2 | 139 | usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); |
662c738d | 140 | status = USB_EVENT_NONE; |
16bc1bb2 | 141 | gpio_vbus->phy.state = OTG_STATE_B_IDLE; |
662c738d HS |
142 | gpio_vbus->phy.last_event = status; |
143 | ||
144 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | |
145 | status, gpio_vbus->phy.otg->gadget); | |
6084f1bf | 146 | } |
c2344f13 RJ |
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); | |
16bc1bb2 | 155 | struct usb_otg *otg = gpio_vbus->phy.otg; |
c2344f13 RJ |
156 | |
157 | dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n", | |
158 | is_vbus_powered(pdata) ? "supplied" : "inactive", | |
16bc1bb2 | 159 | otg->gadget ? otg->gadget->name : "none"); |
c2344f13 | 160 | |
16bc1bb2 | 161 | if (otg->gadget) |
934ccec4 | 162 | schedule_delayed_work(&gpio_vbus->work, msecs_to_jiffies(100)); |
6084f1bf PZ |
163 | |
164 | return IRQ_HANDLED; | |
165 | } | |
166 | ||
167 | /* OTG transceiver interface */ | |
168 | ||
169 | /* bind/unbind the peripheral controller */ | |
16bc1bb2 HK |
170 | static int gpio_vbus_set_peripheral(struct usb_otg *otg, |
171 | struct usb_gadget *gadget) | |
6084f1bf PZ |
172 | { |
173 | struct gpio_vbus_data *gpio_vbus; | |
174 | struct gpio_vbus_mach_info *pdata; | |
175 | struct platform_device *pdev; | |
123bbcee | 176 | int gpio; |
6084f1bf | 177 | |
16bc1bb2 | 178 | gpio_vbus = container_of(otg->phy, struct gpio_vbus_data, phy); |
6084f1bf PZ |
179 | pdev = to_platform_device(gpio_vbus->dev); |
180 | pdata = gpio_vbus->dev->platform_data; | |
6084f1bf PZ |
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); | |
16bc1bb2 | 194 | otg->phy->state = OTG_STATE_UNDEFINED; |
6084f1bf PZ |
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 */ | |
e44694e8 | 204 | gpio_vbus->vbus = 0; /* start with disconnected */ |
123bbcee | 205 | gpio_vbus_irq(gpio_vbus->irq, pdev); |
6084f1bf PZ |
206 | return 0; |
207 | } | |
208 | ||
209 | /* effective for B devices, ignored for A-peripheral */ | |
16bc1bb2 | 210 | static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA) |
6084f1bf PZ |
211 | { |
212 | struct gpio_vbus_data *gpio_vbus; | |
213 | ||
16bc1bb2 | 214 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf | 215 | |
16bc1bb2 | 216 | if (phy->state == OTG_STATE_B_PERIPHERAL) |
6084f1bf PZ |
217 | set_vbus_draw(gpio_vbus, mA); |
218 | return 0; | |
219 | } | |
220 | ||
221 | /* for non-OTG B devices: set/clear transceiver suspend mode */ | |
16bc1bb2 | 222 | static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend) |
6084f1bf PZ |
223 | { |
224 | struct gpio_vbus_data *gpio_vbus; | |
225 | ||
16bc1bb2 | 226 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf PZ |
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 | */ | |
16bc1bb2 | 234 | return gpio_vbus_set_power(phy, suspend ? 0 : gpio_vbus->mA); |
6084f1bf PZ |
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; | |
c8240c1b | 245 | unsigned long irqflags; |
6084f1bf PZ |
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 | ||
16bc1bb2 HK |
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 | ||
6084f1bf PZ |
261 | platform_set_drvdata(pdev, gpio_vbus); |
262 | gpio_vbus->dev = &pdev->dev; | |
16bc1bb2 HK |
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; | |
6084f1bf PZ |
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; | |
c8240c1b SK |
282 | irqflags = (res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED; |
283 | } else { | |
6084f1bf | 284 | irq = gpio_to_irq(gpio); |
c8240c1b SK |
285 | irqflags = VBUS_IRQ_FLAGS; |
286 | } | |
6084f1bf | 287 | |
123bbcee SK |
288 | gpio_vbus->irq = irq; |
289 | ||
6084f1bf PZ |
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 | ||
c8240c1b | 304 | err = request_irq(irq, gpio_vbus_irq, irqflags, "vbus_detect", pdev); |
6084f1bf PZ |
305 | if (err) { |
306 | dev_err(&pdev->dev, "can't request irq %i, err: %d\n", | |
307 | irq, err); | |
308 | goto err_irq; | |
309 | } | |
662c738d HS |
310 | |
311 | ATOMIC_INIT_NOTIFIER_HEAD(&gpio_vbus->phy.notifier); | |
312 | ||
934ccec4 | 313 | INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work); |
6084f1bf | 314 | |
2887ba9e DES |
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 | ||
6084f1bf | 322 | /* only active when a gadget is registered */ |
16bc1bb2 | 323 | err = usb_set_transceiver(&gpio_vbus->phy); |
6084f1bf PZ |
324 | if (err) { |
325 | dev_err(&pdev->dev, "can't register transceiver, err: %d\n", | |
326 | err); | |
327 | goto err_otg; | |
328 | } | |
329 | ||
7cbb062a SK |
330 | device_init_wakeup(&pdev->dev, pdata->wakeup); |
331 | ||
6084f1bf PZ |
332 | return 0; |
333 | err_otg: | |
a6dc9cf7 | 334 | regulator_put(gpio_vbus->vbus_draw); |
0d13eebc | 335 | free_irq(irq, pdev); |
6084f1bf PZ |
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); | |
16bc1bb2 | 342 | kfree(gpio_vbus->phy.otg); |
6084f1bf PZ |
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 | ||
7cbb062a | 353 | device_init_wakeup(&pdev->dev, 0); |
ec1ac6e1 | 354 | cancel_delayed_work_sync(&gpio_vbus->work); |
6084f1bf PZ |
355 | regulator_put(gpio_vbus->vbus_draw); |
356 | ||
16bc1bb2 | 357 | usb_set_transceiver(NULL); |
6084f1bf | 358 | |
123bbcee | 359 | free_irq(gpio_vbus->irq, pdev); |
6084f1bf PZ |
360 | if (gpio_is_valid(pdata->gpio_pullup)) |
361 | gpio_free(pdata->gpio_pullup); | |
362 | gpio_free(gpio); | |
363 | platform_set_drvdata(pdev, NULL); | |
16bc1bb2 | 364 | kfree(gpio_vbus->phy.otg); |
6084f1bf PZ |
365 | kfree(gpio_vbus); |
366 | ||
367 | return 0; | |
368 | } | |
369 | ||
7cbb062a SK |
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 | ||
6084f1bf PZ |
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, | |
7cbb062a SK |
405 | #ifdef CONFIG_PM |
406 | .pm = &gpio_vbus_dev_pm_ops, | |
407 | #endif | |
6084f1bf PZ |
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"); |