]>
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; |
e47d9254 | 124 | gpio_vbus->phy.otg->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); | |
b20f3f9e | 137 | usb_phy_set_event(&gpio_vbus->phy, USB_EVENT_ENUMERATED); |
6084f1bf PZ |
138 | } else { |
139 | /* optionally disable D+ pullup */ | |
140 | if (gpio_is_valid(gpio)) | |
141 | gpio_set_value(gpio, pdata->gpio_pullup_inverted); | |
142 | ||
143 | set_vbus_draw(gpio_vbus, 0); | |
144 | ||
16bc1bb2 | 145 | usb_gadget_vbus_disconnect(gpio_vbus->phy.otg->gadget); |
662c738d | 146 | status = USB_EVENT_NONE; |
e47d9254 | 147 | gpio_vbus->phy.otg->state = OTG_STATE_B_IDLE; |
662c738d HS |
148 | gpio_vbus->phy.last_event = status; |
149 | ||
150 | atomic_notifier_call_chain(&gpio_vbus->phy.notifier, | |
151 | status, gpio_vbus->phy.otg->gadget); | |
b20f3f9e | 152 | usb_phy_set_event(&gpio_vbus->phy, USB_EVENT_NONE); |
6084f1bf | 153 | } |
c2344f13 RJ |
154 | } |
155 | ||
156 | /* VBUS change IRQ handler */ | |
157 | static irqreturn_t gpio_vbus_irq(int irq, void *data) | |
158 | { | |
159 | struct platform_device *pdev = data; | |
19f9e188 | 160 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); |
c2344f13 | 161 | struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); |
16bc1bb2 | 162 | struct usb_otg *otg = gpio_vbus->phy.otg; |
c2344f13 RJ |
163 | |
164 | dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n", | |
165 | is_vbus_powered(pdata) ? "supplied" : "inactive", | |
16bc1bb2 | 166 | otg->gadget ? otg->gadget->name : "none"); |
c2344f13 | 167 | |
16bc1bb2 | 168 | if (otg->gadget) |
934ccec4 | 169 | schedule_delayed_work(&gpio_vbus->work, msecs_to_jiffies(100)); |
6084f1bf PZ |
170 | |
171 | return IRQ_HANDLED; | |
172 | } | |
173 | ||
174 | /* OTG transceiver interface */ | |
175 | ||
176 | /* bind/unbind the peripheral controller */ | |
16bc1bb2 HK |
177 | static int gpio_vbus_set_peripheral(struct usb_otg *otg, |
178 | struct usb_gadget *gadget) | |
6084f1bf PZ |
179 | { |
180 | struct gpio_vbus_data *gpio_vbus; | |
181 | struct gpio_vbus_mach_info *pdata; | |
182 | struct platform_device *pdev; | |
123bbcee | 183 | int gpio; |
6084f1bf | 184 | |
19c1eac2 | 185 | gpio_vbus = container_of(otg->usb_phy, struct gpio_vbus_data, phy); |
6084f1bf | 186 | pdev = to_platform_device(gpio_vbus->dev); |
19f9e188 | 187 | pdata = dev_get_platdata(gpio_vbus->dev); |
6084f1bf PZ |
188 | gpio = pdata->gpio_pullup; |
189 | ||
190 | if (!gadget) { | |
191 | dev_dbg(&pdev->dev, "unregistering gadget '%s'\n", | |
192 | otg->gadget->name); | |
193 | ||
194 | /* optionally disable D+ pullup */ | |
195 | if (gpio_is_valid(gpio)) | |
196 | gpio_set_value(gpio, pdata->gpio_pullup_inverted); | |
197 | ||
198 | set_vbus_draw(gpio_vbus, 0); | |
199 | ||
200 | usb_gadget_vbus_disconnect(otg->gadget); | |
e47d9254 | 201 | otg->state = OTG_STATE_UNDEFINED; |
6084f1bf PZ |
202 | |
203 | otg->gadget = NULL; | |
204 | return 0; | |
205 | } | |
206 | ||
207 | otg->gadget = gadget; | |
208 | dev_dbg(&pdev->dev, "registered gadget '%s'\n", gadget->name); | |
209 | ||
210 | /* initialize connection state */ | |
e44694e8 | 211 | gpio_vbus->vbus = 0; /* start with disconnected */ |
123bbcee | 212 | gpio_vbus_irq(gpio_vbus->irq, pdev); |
6084f1bf PZ |
213 | return 0; |
214 | } | |
215 | ||
216 | /* effective for B devices, ignored for A-peripheral */ | |
16bc1bb2 | 217 | static int gpio_vbus_set_power(struct usb_phy *phy, unsigned mA) |
6084f1bf PZ |
218 | { |
219 | struct gpio_vbus_data *gpio_vbus; | |
220 | ||
16bc1bb2 | 221 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf | 222 | |
e47d9254 | 223 | if (phy->otg->state == OTG_STATE_B_PERIPHERAL) |
6084f1bf PZ |
224 | set_vbus_draw(gpio_vbus, mA); |
225 | return 0; | |
226 | } | |
227 | ||
228 | /* for non-OTG B devices: set/clear transceiver suspend mode */ | |
16bc1bb2 | 229 | static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend) |
6084f1bf PZ |
230 | { |
231 | struct gpio_vbus_data *gpio_vbus; | |
232 | ||
16bc1bb2 | 233 | gpio_vbus = container_of(phy, struct gpio_vbus_data, phy); |
6084f1bf PZ |
234 | |
235 | /* draw max 0 mA from vbus in suspend mode; or the previously | |
236 | * recorded amount of current if not suspended | |
237 | * | |
238 | * NOTE: high powered configs (mA > 100) may draw up to 2.5 mA | |
239 | * if they're wake-enabled ... we don't handle that yet. | |
240 | */ | |
16bc1bb2 | 241 | return gpio_vbus_set_power(phy, suspend ? 0 : gpio_vbus->mA); |
6084f1bf PZ |
242 | } |
243 | ||
244 | /* platform driver interface */ | |
245 | ||
eaaa775b | 246 | static int gpio_vbus_probe(struct platform_device *pdev) |
6084f1bf | 247 | { |
19f9e188 | 248 | struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev); |
6084f1bf PZ |
249 | struct gpio_vbus_data *gpio_vbus; |
250 | struct resource *res; | |
251 | int err, gpio, irq; | |
c8240c1b | 252 | unsigned long irqflags; |
6084f1bf PZ |
253 | |
254 | if (!pdata || !gpio_is_valid(pdata->gpio_vbus)) | |
255 | return -EINVAL; | |
256 | gpio = pdata->gpio_vbus; | |
257 | ||
9f7b23ce HS |
258 | gpio_vbus = devm_kzalloc(&pdev->dev, sizeof(struct gpio_vbus_data), |
259 | GFP_KERNEL); | |
6084f1bf PZ |
260 | if (!gpio_vbus) |
261 | return -ENOMEM; | |
262 | ||
9f7b23ce HS |
263 | gpio_vbus->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg), |
264 | GFP_KERNEL); | |
0c582408 | 265 | if (!gpio_vbus->phy.otg) |
16bc1bb2 | 266 | return -ENOMEM; |
16bc1bb2 | 267 | |
6084f1bf PZ |
268 | platform_set_drvdata(pdev, gpio_vbus); |
269 | gpio_vbus->dev = &pdev->dev; | |
16bc1bb2 | 270 | gpio_vbus->phy.label = "gpio-vbus"; |
1abd8b31 | 271 | gpio_vbus->phy.dev = gpio_vbus->dev; |
16bc1bb2 HK |
272 | gpio_vbus->phy.set_power = gpio_vbus_set_power; |
273 | gpio_vbus->phy.set_suspend = gpio_vbus_set_suspend; | |
16bc1bb2 | 274 | |
e47d9254 | 275 | gpio_vbus->phy.otg->state = OTG_STATE_UNDEFINED; |
19c1eac2 | 276 | gpio_vbus->phy.otg->usb_phy = &gpio_vbus->phy; |
16bc1bb2 | 277 | gpio_vbus->phy.otg->set_peripheral = gpio_vbus_set_peripheral; |
6084f1bf | 278 | |
9f7b23ce | 279 | err = devm_gpio_request(&pdev->dev, gpio, "vbus_detect"); |
6084f1bf PZ |
280 | if (err) { |
281 | dev_err(&pdev->dev, "can't request vbus gpio %d, err: %d\n", | |
282 | gpio, err); | |
9f7b23ce | 283 | return err; |
6084f1bf PZ |
284 | } |
285 | gpio_direction_input(gpio); | |
286 | ||
287 | res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); | |
288 | if (res) { | |
289 | irq = res->start; | |
c8240c1b SK |
290 | irqflags = (res->flags & IRQF_TRIGGER_MASK) | IRQF_SHARED; |
291 | } else { | |
6084f1bf | 292 | irq = gpio_to_irq(gpio); |
c8240c1b SK |
293 | irqflags = VBUS_IRQ_FLAGS; |
294 | } | |
6084f1bf | 295 | |
123bbcee SK |
296 | gpio_vbus->irq = irq; |
297 | ||
6084f1bf PZ |
298 | /* if data line pullup is in use, initialize it to "not pulling up" */ |
299 | gpio = pdata->gpio_pullup; | |
300 | if (gpio_is_valid(gpio)) { | |
9f7b23ce | 301 | err = devm_gpio_request(&pdev->dev, gpio, "udc_pullup"); |
6084f1bf PZ |
302 | if (err) { |
303 | dev_err(&pdev->dev, | |
304 | "can't request pullup gpio %d, err: %d\n", | |
305 | gpio, err); | |
9f7b23ce | 306 | return err; |
6084f1bf PZ |
307 | } |
308 | gpio_direction_output(gpio, pdata->gpio_pullup_inverted); | |
309 | } | |
310 | ||
9f7b23ce HS |
311 | err = devm_request_irq(&pdev->dev, irq, gpio_vbus_irq, irqflags, |
312 | "vbus_detect", pdev); | |
6084f1bf PZ |
313 | if (err) { |
314 | dev_err(&pdev->dev, "can't request irq %i, err: %d\n", | |
315 | irq, err); | |
9f7b23ce | 316 | return err; |
6084f1bf | 317 | } |
662c738d | 318 | |
934ccec4 | 319 | INIT_DELAYED_WORK(&gpio_vbus->work, gpio_vbus_work); |
6084f1bf | 320 | |
9f7b23ce | 321 | gpio_vbus->vbus_draw = devm_regulator_get(&pdev->dev, "vbus_draw"); |
2887ba9e DES |
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); | |
9f7b23ce | 333 | return err; |
6084f1bf PZ |
334 | } |
335 | ||
7cbb062a SK |
336 | device_init_wakeup(&pdev->dev, pdata->wakeup); |
337 | ||
6084f1bf | 338 | return 0; |
6084f1bf PZ |
339 | } |
340 | ||
eaaa775b | 341 | static int gpio_vbus_remove(struct platform_device *pdev) |
6084f1bf PZ |
342 | { |
343 | struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev); | |
6084f1bf | 344 | |
7cbb062a | 345 | device_init_wakeup(&pdev->dev, 0); |
ec1ac6e1 | 346 | cancel_delayed_work_sync(&gpio_vbus->work); |
6084f1bf | 347 | |
662dca54 | 348 | usb_remove_phy(&gpio_vbus->phy); |
6084f1bf | 349 | |
6084f1bf PZ |
350 | return 0; |
351 | } | |
352 | ||
7cbb062a SK |
353 | #ifdef CONFIG_PM |
354 | static int gpio_vbus_pm_suspend(struct device *dev) | |
355 | { | |
356 | struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); | |
357 | ||
358 | if (device_may_wakeup(dev)) | |
359 | enable_irq_wake(gpio_vbus->irq); | |
360 | ||
361 | return 0; | |
362 | } | |
363 | ||
364 | static int gpio_vbus_pm_resume(struct device *dev) | |
365 | { | |
366 | struct gpio_vbus_data *gpio_vbus = dev_get_drvdata(dev); | |
367 | ||
368 | if (device_may_wakeup(dev)) | |
369 | disable_irq_wake(gpio_vbus->irq); | |
370 | ||
371 | return 0; | |
372 | } | |
373 | ||
374 | static const struct dev_pm_ops gpio_vbus_dev_pm_ops = { | |
375 | .suspend = gpio_vbus_pm_suspend, | |
376 | .resume = gpio_vbus_pm_resume, | |
377 | }; | |
378 | #endif | |
379 | ||
6084f1bf PZ |
380 | MODULE_ALIAS("platform:gpio-vbus"); |
381 | ||
382 | static struct platform_driver gpio_vbus_driver = { | |
383 | .driver = { | |
384 | .name = "gpio-vbus", | |
7cbb062a SK |
385 | #ifdef CONFIG_PM |
386 | .pm = &gpio_vbus_dev_pm_ops, | |
387 | #endif | |
6084f1bf | 388 | }, |
eaaa775b JH |
389 | .probe = gpio_vbus_probe, |
390 | .remove = gpio_vbus_remove, | |
6084f1bf PZ |
391 | }; |
392 | ||
eaaa775b | 393 | module_platform_driver(gpio_vbus_driver); |
6084f1bf PZ |
394 | |
395 | MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver"); | |
396 | MODULE_AUTHOR("Philipp Zabel"); | |
397 | MODULE_LICENSE("GPL"); |