Commit | Line | Data |
---|---|---|
b2998049 AV |
1 | /* |
2 | * Common power driver for PDAs and phones with one or two external | |
3 | * power supplies (AC/USB) connected to main and backup batteries, | |
4 | * and optional builtin charger. | |
5 | * | |
6 | * Copyright © 2007 Anton Vorontsov <cbou@mail.ru> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/platform_device.h> | |
5bf2b994 | 15 | #include <linux/err.h> |
b2998049 | 16 | #include <linux/interrupt.h> |
9ad63986 | 17 | #include <linux/notifier.h> |
b2998049 AV |
18 | #include <linux/power_supply.h> |
19 | #include <linux/pda_power.h> | |
5bf2b994 | 20 | #include <linux/regulator/consumer.h> |
b2998049 AV |
21 | #include <linux/timer.h> |
22 | #include <linux/jiffies.h> | |
5bf2b994 | 23 | #include <linux/usb/otg.h> |
b2998049 AV |
24 | |
25 | static inline unsigned int get_irq_flags(struct resource *res) | |
26 | { | |
74194cc7 | 27 | unsigned int flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED; |
b2998049 AV |
28 | |
29 | flags |= res->flags & IRQF_TRIGGER_MASK; | |
30 | ||
31 | return flags; | |
32 | } | |
33 | ||
34 | static struct device *dev; | |
35 | static struct pda_power_pdata *pdata; | |
36 | static struct resource *ac_irq, *usb_irq; | |
37 | static struct timer_list charger_timer; | |
38 | static struct timer_list supply_timer; | |
c3caebad AV |
39 | static struct timer_list polling_timer; |
40 | static int polling; | |
b2998049 | 41 | |
1c74529d | 42 | #ifdef CONFIG_USB_OTG_UTILS |
86753811 | 43 | static struct usb_phy *transceiver; |
9ad63986 | 44 | static struct notifier_block otg_nb; |
1c74529d AL |
45 | #endif |
46 | ||
5bf2b994 PZ |
47 | static struct regulator *ac_draw; |
48 | ||
bfde2662 AV |
49 | enum { |
50 | PDA_PSY_OFFLINE = 0, | |
51 | PDA_PSY_ONLINE = 1, | |
52 | PDA_PSY_TO_CHANGE, | |
53 | }; | |
54 | static int new_ac_status = -1; | |
55 | static int new_usb_status = -1; | |
56 | static int ac_status = -1; | |
57 | static int usb_status = -1; | |
58 | ||
b2998049 AV |
59 | static int pda_power_get_property(struct power_supply *psy, |
60 | enum power_supply_property psp, | |
61 | union power_supply_propval *val) | |
62 | { | |
63 | switch (psp) { | |
64 | case POWER_SUPPLY_PROP_ONLINE: | |
65 | if (psy->type == POWER_SUPPLY_TYPE_MAINS) | |
66 | val->intval = pdata->is_ac_online ? | |
67 | pdata->is_ac_online() : 0; | |
68 | else | |
69 | val->intval = pdata->is_usb_online ? | |
70 | pdata->is_usb_online() : 0; | |
71 | break; | |
72 | default: | |
73 | return -EINVAL; | |
74 | } | |
75 | return 0; | |
76 | } | |
77 | ||
78 | static enum power_supply_property pda_power_props[] = { | |
79 | POWER_SUPPLY_PROP_ONLINE, | |
80 | }; | |
81 | ||
82 | static char *pda_power_supplied_to[] = { | |
83 | "main-battery", | |
84 | "backup-battery", | |
85 | }; | |
86 | ||
bfde2662 AV |
87 | static struct power_supply pda_psy_ac = { |
88 | .name = "ac", | |
89 | .type = POWER_SUPPLY_TYPE_MAINS, | |
90 | .supplied_to = pda_power_supplied_to, | |
91 | .num_supplicants = ARRAY_SIZE(pda_power_supplied_to), | |
92 | .properties = pda_power_props, | |
93 | .num_properties = ARRAY_SIZE(pda_power_props), | |
94 | .get_property = pda_power_get_property, | |
b2998049 AV |
95 | }; |
96 | ||
bfde2662 AV |
97 | static struct power_supply pda_psy_usb = { |
98 | .name = "usb", | |
99 | .type = POWER_SUPPLY_TYPE_USB, | |
100 | .supplied_to = pda_power_supplied_to, | |
101 | .num_supplicants = ARRAY_SIZE(pda_power_supplied_to), | |
102 | .properties = pda_power_props, | |
103 | .num_properties = ARRAY_SIZE(pda_power_props), | |
104 | .get_property = pda_power_get_property, | |
105 | }; | |
106 | ||
107 | static void update_status(void) | |
108 | { | |
109 | if (pdata->is_ac_online) | |
110 | new_ac_status = !!pdata->is_ac_online(); | |
111 | ||
112 | if (pdata->is_usb_online) | |
113 | new_usb_status = !!pdata->is_usb_online(); | |
114 | } | |
115 | ||
b2998049 AV |
116 | static void update_charger(void) |
117 | { | |
5bf2b994 PZ |
118 | static int regulator_enabled; |
119 | int max_uA = pdata->ac_max_uA; | |
120 | ||
121 | if (pdata->set_charge) { | |
122 | if (new_ac_status > 0) { | |
123 | dev_dbg(dev, "charger on (AC)\n"); | |
124 | pdata->set_charge(PDA_POWER_CHARGE_AC); | |
125 | } else if (new_usb_status > 0) { | |
126 | dev_dbg(dev, "charger on (USB)\n"); | |
127 | pdata->set_charge(PDA_POWER_CHARGE_USB); | |
128 | } else { | |
129 | dev_dbg(dev, "charger off\n"); | |
130 | pdata->set_charge(0); | |
131 | } | |
132 | } else if (ac_draw) { | |
133 | if (new_ac_status > 0) { | |
134 | regulator_set_current_limit(ac_draw, max_uA, max_uA); | |
135 | if (!regulator_enabled) { | |
136 | dev_dbg(dev, "charger on (AC)\n"); | |
137 | regulator_enable(ac_draw); | |
138 | regulator_enabled = 1; | |
139 | } | |
140 | } else { | |
141 | if (regulator_enabled) { | |
142 | dev_dbg(dev, "charger off\n"); | |
143 | regulator_disable(ac_draw); | |
144 | regulator_enabled = 0; | |
145 | } | |
146 | } | |
b2998049 | 147 | } |
b2998049 AV |
148 | } |
149 | ||
bfde2662 | 150 | static void supply_timer_func(unsigned long unused) |
b2998049 | 151 | { |
bfde2662 AV |
152 | if (ac_status == PDA_PSY_TO_CHANGE) { |
153 | ac_status = new_ac_status; | |
154 | power_supply_changed(&pda_psy_ac); | |
155 | } | |
5ebf6e6a | 156 | |
bfde2662 AV |
157 | if (usb_status == PDA_PSY_TO_CHANGE) { |
158 | usb_status = new_usb_status; | |
159 | power_supply_changed(&pda_psy_usb); | |
160 | } | |
b2998049 AV |
161 | } |
162 | ||
bfde2662 | 163 | static void psy_changed(void) |
b2998049 AV |
164 | { |
165 | update_charger(); | |
166 | ||
bfde2662 AV |
167 | /* |
168 | * Okay, charger set. Now wait a bit before notifying supplicants, | |
169 | * charge power should stabilize. | |
170 | */ | |
b2998049 AV |
171 | mod_timer(&supply_timer, |
172 | jiffies + msecs_to_jiffies(pdata->wait_for_charger)); | |
b2998049 AV |
173 | } |
174 | ||
bfde2662 AV |
175 | static void charger_timer_func(unsigned long unused) |
176 | { | |
177 | update_status(); | |
178 | psy_changed(); | |
179 | } | |
180 | ||
5ebf6e6a | 181 | static irqreturn_t power_changed_isr(int irq, void *power_supply) |
b2998049 | 182 | { |
bfde2662 AV |
183 | if (power_supply == &pda_psy_ac) |
184 | ac_status = PDA_PSY_TO_CHANGE; | |
185 | else if (power_supply == &pda_psy_usb) | |
186 | usb_status = PDA_PSY_TO_CHANGE; | |
187 | else | |
188 | return IRQ_NONE; | |
189 | ||
190 | /* | |
191 | * Wait a bit before reading ac/usb line status and setting charger, | |
192 | * because ac/usb status readings may lag from irq. | |
193 | */ | |
b2998049 AV |
194 | mod_timer(&charger_timer, |
195 | jiffies + msecs_to_jiffies(pdata->wait_for_status)); | |
bfde2662 | 196 | |
b2998049 AV |
197 | return IRQ_HANDLED; |
198 | } | |
199 | ||
c3caebad AV |
200 | static void polling_timer_func(unsigned long unused) |
201 | { | |
202 | int changed = 0; | |
203 | ||
204 | dev_dbg(dev, "polling...\n"); | |
205 | ||
206 | update_status(); | |
207 | ||
208 | if (!ac_irq && new_ac_status != ac_status) { | |
209 | ac_status = PDA_PSY_TO_CHANGE; | |
210 | changed = 1; | |
211 | } | |
212 | ||
213 | if (!usb_irq && new_usb_status != usb_status) { | |
214 | usb_status = PDA_PSY_TO_CHANGE; | |
215 | changed = 1; | |
216 | } | |
217 | ||
218 | if (changed) | |
219 | psy_changed(); | |
220 | ||
221 | mod_timer(&polling_timer, | |
222 | jiffies + msecs_to_jiffies(pdata->polling_interval)); | |
223 | } | |
224 | ||
5bf2b994 PZ |
225 | #ifdef CONFIG_USB_OTG_UTILS |
226 | static int otg_is_usb_online(void) | |
227 | { | |
9ad63986 DZ |
228 | return (transceiver->last_event == USB_EVENT_VBUS || |
229 | transceiver->last_event == USB_EVENT_ENUMERATED); | |
230 | } | |
231 | ||
232 | static int otg_is_ac_online(void) | |
233 | { | |
234 | return (transceiver->last_event == USB_EVENT_CHARGER); | |
235 | } | |
236 | ||
237 | static int otg_handle_notification(struct notifier_block *nb, | |
238 | unsigned long event, void *unused) | |
239 | { | |
240 | switch (event) { | |
241 | case USB_EVENT_CHARGER: | |
242 | ac_status = PDA_PSY_TO_CHANGE; | |
243 | break; | |
244 | case USB_EVENT_VBUS: | |
245 | case USB_EVENT_ENUMERATED: | |
246 | usb_status = PDA_PSY_TO_CHANGE; | |
247 | break; | |
248 | case USB_EVENT_NONE: | |
249 | ac_status = PDA_PSY_TO_CHANGE; | |
250 | usb_status = PDA_PSY_TO_CHANGE; | |
251 | break; | |
252 | default: | |
253 | return NOTIFY_OK; | |
254 | } | |
255 | ||
256 | /* | |
257 | * Wait a bit before reading ac/usb line status and setting charger, | |
258 | * because ac/usb status readings may lag from irq. | |
259 | */ | |
260 | mod_timer(&charger_timer, | |
261 | jiffies + msecs_to_jiffies(pdata->wait_for_status)); | |
262 | ||
263 | return NOTIFY_OK; | |
5bf2b994 PZ |
264 | } |
265 | #endif | |
266 | ||
b2998049 AV |
267 | static int pda_power_probe(struct platform_device *pdev) |
268 | { | |
269 | int ret = 0; | |
270 | ||
271 | dev = &pdev->dev; | |
272 | ||
273 | if (pdev->id != -1) { | |
274 | dev_err(dev, "it's meaningless to register several " | |
275 | "pda_powers; use id = -1\n"); | |
276 | ret = -EINVAL; | |
277 | goto wrongid; | |
278 | } | |
279 | ||
280 | pdata = pdev->dev.platform_data; | |
281 | ||
f6b6b180 PZ |
282 | if (pdata->init) { |
283 | ret = pdata->init(dev); | |
284 | if (ret < 0) | |
285 | goto init_failed; | |
286 | } | |
287 | ||
bfde2662 | 288 | update_status(); |
b2998049 AV |
289 | update_charger(); |
290 | ||
291 | if (!pdata->wait_for_status) | |
292 | pdata->wait_for_status = 500; | |
293 | ||
294 | if (!pdata->wait_for_charger) | |
295 | pdata->wait_for_charger = 500; | |
296 | ||
c3caebad AV |
297 | if (!pdata->polling_interval) |
298 | pdata->polling_interval = 2000; | |
299 | ||
5bf2b994 PZ |
300 | if (!pdata->ac_max_uA) |
301 | pdata->ac_max_uA = 500000; | |
302 | ||
b2998049 AV |
303 | setup_timer(&charger_timer, charger_timer_func, 0); |
304 | setup_timer(&supply_timer, supply_timer_func, 0); | |
305 | ||
306 | ac_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "ac"); | |
307 | usb_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "usb"); | |
b2998049 AV |
308 | |
309 | if (pdata->supplied_to) { | |
bfde2662 AV |
310 | pda_psy_ac.supplied_to = pdata->supplied_to; |
311 | pda_psy_ac.num_supplicants = pdata->num_supplicants; | |
312 | pda_psy_usb.supplied_to = pdata->supplied_to; | |
313 | pda_psy_usb.num_supplicants = pdata->num_supplicants; | |
b2998049 AV |
314 | } |
315 | ||
5bf2b994 PZ |
316 | ac_draw = regulator_get(dev, "ac_draw"); |
317 | if (IS_ERR(ac_draw)) { | |
318 | dev_dbg(dev, "couldn't get ac_draw regulator\n"); | |
319 | ac_draw = NULL; | |
320 | ret = PTR_ERR(ac_draw); | |
321 | } | |
322 | ||
1c74529d | 323 | #ifdef CONFIG_USB_OTG_UTILS |
662dca54 | 324 | transceiver = usb_get_phy(USB_PHY_TYPE_USB2); |
ded017ee KVA |
325 | if (!IS_ERR_OR_NULL(transceiver)) { |
326 | if (!pdata->is_usb_online) | |
327 | pdata->is_usb_online = otg_is_usb_online; | |
328 | if (!pdata->is_ac_online) | |
329 | pdata->is_ac_online = otg_is_ac_online; | |
9ad63986 | 330 | } |
1c74529d | 331 | #endif |
9ad63986 | 332 | |
9ef45106 | 333 | if (pdata->is_ac_online) { |
bfde2662 | 334 | ret = power_supply_register(&pdev->dev, &pda_psy_ac); |
9ef45106 DB |
335 | if (ret) { |
336 | dev_err(dev, "failed to register %s power supply\n", | |
bfde2662 | 337 | pda_psy_ac.name); |
9ef45106 DB |
338 | goto ac_supply_failed; |
339 | } | |
b2998049 | 340 | |
9ef45106 DB |
341 | if (ac_irq) { |
342 | ret = request_irq(ac_irq->start, power_changed_isr, | |
343 | get_irq_flags(ac_irq), ac_irq->name, | |
bfde2662 | 344 | &pda_psy_ac); |
9ef45106 DB |
345 | if (ret) { |
346 | dev_err(dev, "request ac irq failed\n"); | |
347 | goto ac_irq_failed; | |
348 | } | |
c3caebad AV |
349 | } else { |
350 | polling = 1; | |
9ef45106 | 351 | } |
b2998049 AV |
352 | } |
353 | ||
9ef45106 | 354 | if (pdata->is_usb_online) { |
bfde2662 | 355 | ret = power_supply_register(&pdev->dev, &pda_psy_usb); |
b2998049 | 356 | if (ret) { |
9ef45106 | 357 | dev_err(dev, "failed to register %s power supply\n", |
bfde2662 | 358 | pda_psy_usb.name); |
9ef45106 | 359 | goto usb_supply_failed; |
b2998049 | 360 | } |
b2998049 | 361 | |
9ef45106 DB |
362 | if (usb_irq) { |
363 | ret = request_irq(usb_irq->start, power_changed_isr, | |
364 | get_irq_flags(usb_irq), | |
bfde2662 | 365 | usb_irq->name, &pda_psy_usb); |
9ef45106 DB |
366 | if (ret) { |
367 | dev_err(dev, "request usb irq failed\n"); | |
368 | goto usb_irq_failed; | |
369 | } | |
c3caebad AV |
370 | } else { |
371 | polling = 1; | |
b2998049 AV |
372 | } |
373 | } | |
374 | ||
1c74529d | 375 | #ifdef CONFIG_USB_OTG_UTILS |
ded017ee | 376 | if (!IS_ERR_OR_NULL(transceiver) && pdata->use_otg_notifier) { |
9ad63986 | 377 | otg_nb.notifier_call = otg_handle_notification; |
fcc8ebc9 | 378 | ret = usb_register_notifier(transceiver, &otg_nb); |
9ad63986 DZ |
379 | if (ret) { |
380 | dev_err(dev, "failure to register otg notifier\n"); | |
381 | goto otg_reg_notifier_failed; | |
382 | } | |
383 | polling = 0; | |
384 | } | |
1c74529d | 385 | #endif |
9ad63986 | 386 | |
c3caebad AV |
387 | if (polling) { |
388 | dev_dbg(dev, "will poll for status\n"); | |
389 | setup_timer(&polling_timer, polling_timer_func, 0); | |
390 | mod_timer(&polling_timer, | |
391 | jiffies + msecs_to_jiffies(pdata->polling_interval)); | |
392 | } | |
393 | ||
394 | if (ac_irq || usb_irq) | |
395 | device_init_wakeup(&pdev->dev, 1); | |
8f8e9b38 | 396 | |
9ef45106 | 397 | return 0; |
b2998049 | 398 | |
1c74529d | 399 | #ifdef CONFIG_USB_OTG_UTILS |
9ad63986 DZ |
400 | otg_reg_notifier_failed: |
401 | if (pdata->is_usb_online && usb_irq) | |
402 | free_irq(usb_irq->start, &pda_psy_usb); | |
1c74529d | 403 | #endif |
b2998049 | 404 | usb_irq_failed: |
9ef45106 | 405 | if (pdata->is_usb_online) |
bfde2662 | 406 | power_supply_unregister(&pda_psy_usb); |
9ef45106 DB |
407 | usb_supply_failed: |
408 | if (pdata->is_ac_online && ac_irq) | |
bfde2662 | 409 | free_irq(ac_irq->start, &pda_psy_ac); |
1c74529d | 410 | #ifdef CONFIG_USB_OTG_UTILS |
ded017ee | 411 | if (!IS_ERR_OR_NULL(transceiver)) |
721002ec | 412 | usb_put_phy(transceiver); |
1c74529d | 413 | #endif |
b2998049 | 414 | ac_irq_failed: |
9ef45106 | 415 | if (pdata->is_ac_online) |
bfde2662 | 416 | power_supply_unregister(&pda_psy_ac); |
9ef45106 | 417 | ac_supply_failed: |
5bf2b994 PZ |
418 | if (ac_draw) { |
419 | regulator_put(ac_draw); | |
420 | ac_draw = NULL; | |
421 | } | |
f6b6b180 PZ |
422 | if (pdata->exit) |
423 | pdata->exit(dev); | |
424 | init_failed: | |
b2998049 | 425 | wrongid: |
b2998049 AV |
426 | return ret; |
427 | } | |
428 | ||
429 | static int pda_power_remove(struct platform_device *pdev) | |
430 | { | |
9ef45106 | 431 | if (pdata->is_usb_online && usb_irq) |
bfde2662 | 432 | free_irq(usb_irq->start, &pda_psy_usb); |
9ef45106 | 433 | if (pdata->is_ac_online && ac_irq) |
bfde2662 AV |
434 | free_irq(ac_irq->start, &pda_psy_ac); |
435 | ||
c3caebad AV |
436 | if (polling) |
437 | del_timer_sync(&polling_timer); | |
b2998049 AV |
438 | del_timer_sync(&charger_timer); |
439 | del_timer_sync(&supply_timer); | |
bfde2662 | 440 | |
9ef45106 | 441 | if (pdata->is_usb_online) |
bfde2662 | 442 | power_supply_unregister(&pda_psy_usb); |
9ef45106 | 443 | if (pdata->is_ac_online) |
bfde2662 | 444 | power_supply_unregister(&pda_psy_ac); |
5bf2b994 | 445 | #ifdef CONFIG_USB_OTG_UTILS |
ded017ee | 446 | if (!IS_ERR_OR_NULL(transceiver)) |
721002ec | 447 | usb_put_phy(transceiver); |
5bf2b994 PZ |
448 | #endif |
449 | if (ac_draw) { | |
450 | regulator_put(ac_draw); | |
451 | ac_draw = NULL; | |
452 | } | |
f6b6b180 PZ |
453 | if (pdata->exit) |
454 | pdata->exit(dev); | |
bfde2662 | 455 | |
b2998049 AV |
456 | return 0; |
457 | } | |
458 | ||
8f8e9b38 | 459 | #ifdef CONFIG_PM |
e82374fd RJ |
460 | static int ac_wakeup_enabled; |
461 | static int usb_wakeup_enabled; | |
462 | ||
8f8e9b38 DB |
463 | static int pda_power_suspend(struct platform_device *pdev, pm_message_t state) |
464 | { | |
a3bcbbee DM |
465 | if (pdata->suspend) { |
466 | int ret = pdata->suspend(state); | |
467 | ||
468 | if (ret) | |
469 | return ret; | |
470 | } | |
471 | ||
8f8e9b38 DB |
472 | if (device_may_wakeup(&pdev->dev)) { |
473 | if (ac_irq) | |
e82374fd | 474 | ac_wakeup_enabled = !enable_irq_wake(ac_irq->start); |
8f8e9b38 | 475 | if (usb_irq) |
e82374fd | 476 | usb_wakeup_enabled = !enable_irq_wake(usb_irq->start); |
8f8e9b38 DB |
477 | } |
478 | ||
479 | return 0; | |
480 | } | |
481 | ||
482 | static int pda_power_resume(struct platform_device *pdev) | |
483 | { | |
484 | if (device_may_wakeup(&pdev->dev)) { | |
e82374fd | 485 | if (usb_irq && usb_wakeup_enabled) |
8f8e9b38 | 486 | disable_irq_wake(usb_irq->start); |
e82374fd | 487 | if (ac_irq && ac_wakeup_enabled) |
8f8e9b38 DB |
488 | disable_irq_wake(ac_irq->start); |
489 | } | |
490 | ||
a3bcbbee DM |
491 | if (pdata->resume) |
492 | return pdata->resume(); | |
493 | ||
8f8e9b38 DB |
494 | return 0; |
495 | } | |
496 | #else | |
497 | #define pda_power_suspend NULL | |
498 | #define pda_power_resume NULL | |
499 | #endif /* CONFIG_PM */ | |
500 | ||
b2998049 AV |
501 | static struct platform_driver pda_power_pdrv = { |
502 | .driver = { | |
503 | .name = "pda-power", | |
504 | }, | |
505 | .probe = pda_power_probe, | |
506 | .remove = pda_power_remove, | |
8f8e9b38 DB |
507 | .suspend = pda_power_suspend, |
508 | .resume = pda_power_resume, | |
b2998049 AV |
509 | }; |
510 | ||
300bac7f | 511 | module_platform_driver(pda_power_pdrv); |
b2998049 | 512 | |
b2998049 AV |
513 | MODULE_LICENSE("GPL"); |
514 | MODULE_AUTHOR("Anton Vorontsov <cbou@mail.ru>"); | |
300bac7f | 515 | MODULE_ALIAS("platform:pda-power"); |