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 | ||
9f7b23ce HS |
256 | gpio_vbus = devm_kzalloc(&pdev->dev, sizeof(struct gpio_vbus_data), |
257 | GFP_KERNEL); | |
6084f1bf PZ |
258 | if (!gpio_vbus) |
259 | return -ENOMEM; | |
260 | ||
9f7b23ce HS |
261 | gpio_vbus->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg), |
262 | GFP_KERNEL); | |
0c582408 | 263 | if (!gpio_vbus->phy.otg) |
16bc1bb2 | 264 | return -ENOMEM; |
16bc1bb2 | 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 | 276 | |
9f7b23ce | 277 | err = devm_gpio_request(&pdev->dev, gpio, "vbus_detect"); |
6084f1bf PZ |
278 | if (err) { |
279 | dev_err(&pdev->dev, "can't request vbus gpio %d, err: %d\n", | |
280 | gpio, err); | |
9f7b23ce | 281 | return err; |
6084f1bf PZ |
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)) { | |
9f7b23ce | 299 | err = devm_gpio_request(&pdev->dev, gpio, "udc_pullup"); |
6084f1bf PZ |
300 | if (err) { |
301 | dev_err(&pdev->dev, | |
302 | "can't request pullup gpio %d, err: %d\n", | |
303 | gpio, err); | |
9f7b23ce | 304 | return err; |
6084f1bf PZ |
305 | } |
306 | gpio_direction_output(gpio, pdata->gpio_pullup_inverted); | |
307 | } | |
308 | ||
9f7b23ce HS |
309 | err = devm_request_irq(&pdev->dev, irq, gpio_vbus_irq, irqflags, |
310 | "vbus_detect", pdev); | |
6084f1bf PZ |
311 | if (err) { |
312 | dev_err(&pdev->dev, "can't request irq %i, err: %d\n", | |
313 | irq, err); | |
9f7b23ce | 314 | return err; |
6084f1bf | 315 | } |
662c738d | 316 | |
934ccec4 | 317 | INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work); |
6084f1bf | 318 | |
9f7b23ce | 319 | gpio_vbus->vbus_draw = devm_regulator_get(&pdev->dev, "vbus_draw"); |
2887ba9e DES |
320 | if (IS_ERR(gpio_vbus->vbus_draw)) { |
321 | dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n", | |
322 | PTR_ERR(gpio_vbus->vbus_draw)); | |
323 | gpio_vbus->vbus_draw = NULL; | |
324 | } | |
325 | ||
6084f1bf | 326 | /* only active when a gadget is registered */ |
662dca54 | 327 | err = usb_add_phy(&gpio_vbus->phy, USB_PHY_TYPE_USB2); |
6084f1bf PZ |
328 | if (err) { |
329 | dev_err(&pdev->dev, "can't register transceiver, err: %d\n", | |
330 | err); | |
9f7b23ce | 331 | return err; |
6084f1bf PZ |
332 | } |
333 | ||
7cbb062a SK |
334 | device_init_wakeup(&pdev->dev, pdata->wakeup); |
335 | ||
6084f1bf | 336 | return 0; |
6084f1bf PZ |
337 | } |
338 | ||
eaaa775b | 339 | static int gpio_vbus_remove(struct platform_device *pdev) |
6084f1bf PZ |
340 | { |
341 | struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); | |
6084f1bf | 342 | |
7cbb062a | 343 | device_init_wakeup(&pdev->dev, 0); |
ec1ac6e1 | 344 | cancel_delayed_work_sync(&gpio_vbus->work); |
6084f1bf | 345 | |
662dca54 | 346 | usb_remove_phy(&gpio_vbus->phy); |
6084f1bf | 347 | |
6084f1bf PZ |
348 | return 0; |
349 | } | |
350 | ||
7cbb062a SK |
351 | #ifdef CONFIG_PM |
352 | static int gpio_vbus_pm_suspend(struct device *dev) | |
353 | { | |
354 | struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); | |
355 | ||
356 | if (device_may_wakeup(dev)) | |
357 | enable_irq_wake(gpio_vbus->irq); | |
358 | ||
359 | return 0; | |
360 | } | |
361 | ||
362 | static int gpio_vbus_pm_resume(struct device *dev) | |
363 | { | |
364 | struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); | |
365 | ||
366 | if (device_may_wakeup(dev)) | |
367 | disable_irq_wake(gpio_vbus->irq); | |
368 | ||
369 | return 0; | |
370 | } | |
371 | ||
372 | static const struct dev_pm_ops gpio_vbus_dev_pm_ops = { | |
373 | .suspend = gpio_vbus_pm_suspend, | |
374 | .resume = gpio_vbus_pm_resume, | |
375 | }; | |
376 | #endif | |
377 | ||
6084f1bf PZ |
378 | MODULE_ALIAS("platform:gpio-vbus"); |
379 | ||
380 | static struct platform_driver gpio_vbus_driver = { | |
381 | .driver = { | |
382 | .name = "gpio-vbus", | |
383 | .owner = THIS_MODULE, | |
7cbb062a SK |
384 | #ifdef CONFIG_PM |
385 | .pm = &gpio_vbus_dev_pm_ops, | |
386 | #endif | |
6084f1bf | 387 | }, |
eaaa775b JH |
388 | .probe = gpio_vbus_probe, |
389 | .remove = gpio_vbus_remove, | |
6084f1bf PZ |
390 | }; |
391 | ||
eaaa775b | 392 | module_platform_driver(gpio_vbus_driver); |
6084f1bf PZ |
393 | |
394 | MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver"); | |
395 | MODULE_AUTHOR("Philipp Zabel"); | |
396 | MODULE_LICENSE("GPL"); |