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; | |
e8d891fb | 64 | int ret; |
6084f1bf PZ |
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) { | |
e8d891fb FB |
73 | ret = regulator_enable(vbus_draw); |
74 | if (ret < 0) | |
75 | return; | |
6084f1bf PZ |
76 | gpio_vbus->vbus_draw_enabled = 1; |
77 | } | |
78 | } else { | |
79 | if (enabled) { | |
e8d891fb FB |
80 | ret = regulator_disable(vbus_draw); |
81 | if (ret < 0) | |
82 | return; | |
6084f1bf PZ |
83 | gpio_vbus->vbus_draw_enabled = 0; |
84 | } | |
85 | } | |
86 | gpio_vbus->mA = mA; | |
87 | } | |
88 | ||
c2344f13 | 89 | static int is_vbus_powered(struct gpio_vbus_mach_info *pdata) |
6084f1bf | 90 | { |
c2344f13 | 91 | int vbus; |
6084f1bf PZ |
92 | |
93 | vbus = gpio_get_value(pdata->gpio_vbus); | |
94 | if (pdata->gpio_vbus_inverted) | |
95 | vbus = !vbus; | |
96 | ||
c2344f13 RJ |
97 | return vbus; |
98 | } | |
99 | ||
100 | static void gpio_vbus_work(struct work_struct *work) | |
101 | { | |
102 | struct gpio_vbus_data *gpio_vbus = | |
934ccec4 | 103 | container_of(work, struct gpio_vbus_data, work.work); |
19f9e188 | 104 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(gpio_vbus->dev); |
e44694e8 | 105 | int gpio, status, vbus; |
6084f1bf | 106 | |
16bc1bb2 | 107 | if (!gpio_vbus->phy.otg->gadget) |
c2344f13 | 108 | return; |
6084f1bf | 109 | |
e44694e8 SK |
110 | vbus = is_vbus_powered(pdata); |
111 | if ((vbus ^ gpio_vbus->vbus) == 0) | |
112 | return; | |
113 | gpio_vbus->vbus = vbus; | |
114 | ||
6084f1bf PZ |
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; | |
e44694e8 SK |
121 | |
122 | if (vbus) { | |
662c738d | 123 | status = USB_EVENT_VBUS; |
16bc1bb2 | 124 | gpio_vbus->phy.state = OTG_STATE_B_PERIPHERAL; |
662c738d | 125 | gpio_vbus->phy.last_event = status; |
16bc1bb2 | 126 | usb_gadget_vbus_connect(gpio_vbus->phy.otg->gadget); |
6084f1bf PZ |
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); | |
662c738d HS |
134 | |
135 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | |
136 | status, gpio_vbus->phy.otg->gadget); | |
6084f1bf PZ |
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 | ||
16bc1bb2 | 144 | usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); |
662c738d | 145 | status = USB_EVENT_NONE; |
16bc1bb2 | 146 | gpio_vbus->phy.state = OTG_STATE_B_IDLE; |
662c738d HS |
147 | gpio_vbus->phy.last_event = status; |
148 | ||
149 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | |
150 | status, gpio_vbus->phy.otg->gadget); | |
6084f1bf | 151 | } |
c2344f13 RJ |
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; | |
19f9e188 | 158 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); |
c2344f13 | 159 | struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); |
16bc1bb2 | 160 | struct usb_otg *otg = gpio_vbus->phy.otg; |
c2344f13 RJ |
161 | |
162 | dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n", | |
163 | is_vbus_powered(pdata) ? "supplied" : "inactive", | |
16bc1bb2 | 164 | otg->gadget ? otg->gadget->name : "none"); |
c2344f13 | 165 | |
16bc1bb2 | 166 | if (otg->gadget) |
934ccec4 | 167 | schedule_delayed_work(&gpio_vbus->work, msecs_to_jiffies(100)); |
6084f1bf PZ |
168 | |
169 | return IRQ_HANDLED; | |
170 | } | |
171 | ||
172 | /* OTG transceiver interface */ | |
173 | ||
174 | /* bind/unbind the peripheral controller */ | |
16bc1bb2 HK |
175 | static int gpio_vbus_set_peripheral(struct usb_otg *otg, |
176 | struct usb_gadget *gadget) | |
6084f1bf PZ |
177 | { |
178 | struct gpio_vbus_data *gpio_vbus; | |
179 | struct gpio_vbus_mach_info *pdata; | |
180 | struct platform_device *pdev; | |
123bbcee | 181 | int gpio; |
6084f1bf | 182 | |
16bc1bb2 | 183 | gpio_vbus = container_of(otg->phy, struct gpio_vbus_data, phy); |
6084f1bf | 184 | pdev = to_platform_device(gpio_vbus->dev); |
19f9e188 | 185 | pdata = dev_get_platdata(gpio_vbus->dev); |
6084f1bf PZ |
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); | |
16bc1bb2 | 199 | otg->phy->state = OTG_STATE_UNDEFINED; |
6084f1bf PZ |
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 */ | |
e44694e8 | 209 | gpio_vbus->vbus = 0; /* start with disconnected */ |
123bbcee | 210 | gpio_vbus_irq(gpio_vbus->irq, pdev); |
6084f1bf PZ |
211 | return 0; |
212 | } | |
213 | ||
214 | /* effective for B devices, ignored for A-peripheral */ | |
16bc1bb2 | 215 | static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA) |
6084f1bf PZ |
216 | { |
217 | struct gpio_vbus_data *gpio_vbus; | |
218 | ||
16bc1bb2 | 219 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf | 220 | |
16bc1bb2 | 221 | if (phy->state == OTG_STATE_B_PERIPHERAL) |
6084f1bf PZ |
222 | set_vbus_draw(gpio_vbus, mA); |
223 | return 0; | |
224 | } | |
225 | ||
226 | /* for non-OTG B devices: set/clear transceiver suspend mode */ | |
16bc1bb2 | 227 | static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend) |
6084f1bf PZ |
228 | { |
229 | struct gpio_vbus_data *gpio_vbus; | |
230 | ||
16bc1bb2 | 231 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf PZ |
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 | */ | |
16bc1bb2 | 239 | return gpio_vbus_set_power(phy, suspend ? 0 : gpio_vbus->mA); |
6084f1bf PZ |
240 | } |
241 | ||
242 | /* platform driver interface */ | |
243 | ||
eaaa775b | 244 | static int gpio_vbus_probe(struct platform_device *pdev) |
6084f1bf | 245 | { |
19f9e188 | 246 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); |
6084f1bf PZ |
247 | struct gpio_vbus_data *gpio_vbus; |
248 | struct resource *res; | |
249 | int err, gpio, irq; | |
c8240c1b | 250 | unsigned long irqflags; |
6084f1bf PZ |
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 | ||
16bc1bb2 HK |
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 | ||
6084f1bf PZ |
266 | platform_set_drvdata(pdev, gpio_vbus); |
267 | gpio_vbus->dev = &pdev->dev; | |
16bc1bb2 | 268 | gpio_vbus->phy.label = "gpio-vbus"; |
1abd8b31 | 269 | gpio_vbus->phy.dev = gpio_vbus->dev; |
16bc1bb2 HK |
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; | |
6084f1bf PZ |
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; | |
c8240c1b SK |
288 | irqflags = (res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED; |
289 | } else { | |
6084f1bf | 290 | irq = gpio_to_irq(gpio); |
c8240c1b SK |
291 | irqflags = VBUS_IRQ_FLAGS; |
292 | } | |
6084f1bf | 293 | |
123bbcee SK |
294 | gpio_vbus->irq = irq; |
295 | ||
6084f1bf PZ |
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 | ||
c8240c1b | 310 | err = request_irq(irq, gpio_vbus_irq, irqflags, "vbus_detect", pdev); |
6084f1bf PZ |
311 | if (err) { |
312 | dev_err(&pdev->dev, "can't request irq %i, err: %d\n", | |
313 | irq, err); | |
314 | goto err_irq; | |
315 | } | |
662c738d HS |
316 | |
317 | ATOMIC_INIT_NOTIFIER_HEAD(&gpio_vbus->phy.notifier); | |
318 | ||
934ccec4 | 319 | INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work); |
6084f1bf | 320 | |
2887ba9e DES |
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 | ||
6084f1bf | 328 | /* only active when a gadget is registered */ |
662dca54 | 329 | err = usb_add_phy(&gpio_vbus->phy, USB_PHY_TYPE_USB2); |
6084f1bf PZ |
330 | if (err) { |
331 | dev_err(&pdev->dev, "can't register transceiver, err: %d\n", | |
332 | err); | |
333 | goto err_otg; | |
334 | } | |
335 | ||
7cbb062a SK |
336 | device_init_wakeup(&pdev->dev, pdata->wakeup); |
337 | ||
6084f1bf PZ |
338 | return 0; |
339 | err_otg: | |
a6dc9cf7 | 340 | regulator_put(gpio_vbus->vbus_draw); |
0d13eebc | 341 | free_irq(irq, pdev); |
6084f1bf PZ |
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: | |
16bc1bb2 | 347 | kfree(gpio_vbus->phy.otg); |
6084f1bf PZ |
348 | kfree(gpio_vbus); |
349 | return err; | |
350 | } | |
351 | ||
eaaa775b | 352 | static int gpio_vbus_remove(struct platform_device *pdev) |
6084f1bf PZ |
353 | { |
354 | struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); | |
19f9e188 | 355 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); |
6084f1bf PZ |
356 | int gpio = pdata->gpio_vbus; |
357 | ||
7cbb062a | 358 | device_init_wakeup(&pdev->dev, 0); |
ec1ac6e1 | 359 | cancel_delayed_work_sync(&gpio_vbus->work); |
6084f1bf PZ |
360 | regulator_put(gpio_vbus->vbus_draw); |
361 | ||
662dca54 | 362 | usb_remove_phy(&gpio_vbus->phy); |
6084f1bf | 363 | |
123bbcee | 364 | free_irq(gpio_vbus->irq, pdev); |
6084f1bf PZ |
365 | if (gpio_is_valid(pdata->gpio_pullup)) |
366 | gpio_free(pdata->gpio_pullup); | |
367 | gpio_free(gpio); | |
16bc1bb2 | 368 | kfree(gpio_vbus->phy.otg); |
6084f1bf PZ |
369 | kfree(gpio_vbus); |
370 | ||
371 | return 0; | |
372 | } | |
373 | ||
7cbb062a SK |
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 | ||
6084f1bf PZ |
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, | |
7cbb062a SK |
407 | #ifdef CONFIG_PM |
408 | .pm = &gpio_vbus_dev_pm_ops, | |
409 | #endif | |
6084f1bf | 410 | }, |
eaaa775b JH |
411 | .probe = gpio_vbus_probe, |
412 | .remove = gpio_vbus_remove, | |
6084f1bf PZ |
413 | }; |
414 | ||
eaaa775b | 415 | module_platform_driver(gpio_vbus_driver); |
6084f1bf PZ |
416 | |
417 | MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver"); | |
418 | MODULE_AUTHOR("Philipp Zabel"); | |
419 | MODULE_LICENSE("GPL"); |