projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
power_supply: charger-manager: Use power_supply_*() API for accessing function attrs
[deliverable/linux.git] / drivers / power / da9150-charger.c
CommitLineData
c1a281e3
AT		 1/*
2 * DA9150 Charger Driver
3 *
4 * Copyright (c) 2014 Dialog Semiconductor
5 *
6 * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 */
13
14#include <linux/kernel.h>
15#include <linux/slab.h>
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/of.h>
19#include <linux/of_platform.h>
20#include <linux/interrupt.h>
21#include <linux/power_supply.h>
22#include <linux/notifier.h>
23#include <linux/usb/phy.h>
24#include <linux/iio/consumer.h>
25#include <linux/mfd/da9150/core.h>
26#include <linux/mfd/da9150/registers.h>
27
28/* Private data */
29struct da9150_charger {
30 struct da9150 *da9150;
31 struct device *dev;
32
33 struct power_supply usb;
34 struct power_supply battery;
35 struct power_supply *supply_online;
36
37 struct usb_phy *usb_phy;
38 struct notifier_block otg_nb;
39 struct work_struct otg_work;
40 unsigned long usb_event;
41
42 struct iio_channel *ibus_chan;
43 struct iio_channel *vbus_chan;
44 struct iio_channel *tjunc_chan;
45 struct iio_channel *vbat_chan;
46};
47
48static inline int da9150_charger_supply_online(struct da9150_charger *charger,
49 struct power_supply *psy,
50 union power_supply_propval *val)
51{
52 val->intval = (psy == charger->supply_online) ? 1 : 0;
53
54 return 0;
55}
56
57/* Charger Properties */
58static int da9150_charger_vbus_voltage_now(struct da9150_charger *charger,
59 union power_supply_propval *val)
60{
61 int v_val, ret;
62
63 /* Read processed value - mV units */
64 ret = iio_read_channel_processed(charger->vbus_chan, &v_val);
65 if (ret < 0)
66 return ret;
67
68 /* Convert voltage to expected uV units */
69 val->intval = v_val * 1000;
70
71 return 0;
72}
73
74static int da9150_charger_ibus_current_avg(struct da9150_charger *charger,
75 union power_supply_propval *val)
76{
77 int i_val, ret;
78
79 /* Read processed value - mA units */
80 ret = iio_read_channel_processed(charger->ibus_chan, &i_val);
81 if (ret < 0)
82 return ret;
83
84 /* Convert current to expected uA units */
85 val->intval = i_val * 1000;
86
87 return 0;
88}
89
90static int da9150_charger_tjunc_temp(struct da9150_charger *charger,
91 union power_supply_propval *val)
92{
93 int t_val, ret;
94
95 /* Read processed value - 0.001 degrees C units */
96 ret = iio_read_channel_processed(charger->tjunc_chan, &t_val);
97 if (ret < 0)
98 return ret;
99
100 /* Convert temp to expect 0.1 degrees C units */
101 val->intval = t_val / 100;
102
103 return 0;
104}
105
106static enum power_supply_property da9150_charger_props[] = {
107 POWER_SUPPLY_PROP_ONLINE,
108 POWER_SUPPLY_PROP_VOLTAGE_NOW,
109 POWER_SUPPLY_PROP_CURRENT_AVG,
110 POWER_SUPPLY_PROP_TEMP,
111};
112
113static int da9150_charger_get_prop(struct power_supply *psy,
114 enum power_supply_property psp,
115 union power_supply_propval *val)
116{
117 struct da9150_charger *charger = dev_get_drvdata(psy->dev->parent);
118 int ret;
119
120 switch (psp) {
121 case POWER_SUPPLY_PROP_ONLINE:
122 ret = da9150_charger_supply_online(charger, psy, val);
123 break;
124 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
125 ret = da9150_charger_vbus_voltage_now(charger, val);
126 break;
127 case POWER_SUPPLY_PROP_CURRENT_AVG:
128 ret = da9150_charger_ibus_current_avg(charger, val);
129 break;
130 case POWER_SUPPLY_PROP_TEMP:
131 ret = da9150_charger_tjunc_temp(charger, val);
132 break;
133 default:
134 ret = -EINVAL;
135 break;
136 }
137
138 return ret;
139}
140
141/* Battery Properties */
142static int da9150_charger_battery_status(struct da9150_charger *charger,
143 union power_supply_propval *val)
144{
145 u8 reg;
146
147 /* Check to see if battery is discharging */
148 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
149
150 if (((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_OFF) ||
151 ((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_WAIT)) {
152 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
153
154 return 0;
155 }
156
157 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
158
159 /* Now check for other states */
160 switch (reg & DA9150_CHG_STAT_MASK) {
161 case DA9150_CHG_STAT_ACT:
162 case DA9150_CHG_STAT_PRE:
163 case DA9150_CHG_STAT_CC:
164 case DA9150_CHG_STAT_CV:
165 val->intval = POWER_SUPPLY_STATUS_CHARGING;
166 break;
167 case DA9150_CHG_STAT_OFF:
168 case DA9150_CHG_STAT_SUSP:
169 case DA9150_CHG_STAT_TEMP:
170 case DA9150_CHG_STAT_TIME:
171 case DA9150_CHG_STAT_BAT:
172 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
173 break;
174 case DA9150_CHG_STAT_FULL:
175 val->intval = POWER_SUPPLY_STATUS_FULL;
176 break;
177 default:
178 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
179 break;
180 }
181
182 return 0;
183}
184
185static int da9150_charger_battery_health(struct da9150_charger *charger,
186 union power_supply_propval *val)
187{
188 u8 reg;
189
190 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
191
192 /* Check if temperature limit reached */
193 switch (reg & DA9150_CHG_TEMP_MASK) {
194 case DA9150_CHG_TEMP_UNDER:
195 val->intval = POWER_SUPPLY_HEALTH_COLD;
196 return 0;
197 case DA9150_CHG_TEMP_OVER:
198 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
199 return 0;
200 default:
201 break;
202 }
203
204 /* Check for other health states */
205 switch (reg & DA9150_CHG_STAT_MASK) {
206 case DA9150_CHG_STAT_ACT:
207 case DA9150_CHG_STAT_PRE:
208 val->intval = POWER_SUPPLY_HEALTH_DEAD;
209 break;
210 case DA9150_CHG_STAT_TIME:
211 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
212 break;
213 default:
214 val->intval = POWER_SUPPLY_HEALTH_GOOD;
215 break;
216 }
217
218 return 0;
219}
220
221static int da9150_charger_battery_present(struct da9150_charger *charger,
222 union power_supply_propval *val)
223{
224 u8 reg;
225
226 /* Check if battery present or removed */
227 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
228 if ((reg & DA9150_CHG_STAT_MASK) == DA9150_CHG_STAT_BAT)
229 val->intval = 0;
230 else
231 val->intval = 1;
232
233 return 0;
234}
235
236static int da9150_charger_battery_charge_type(struct da9150_charger *charger,
237 union power_supply_propval *val)
238{
239 u8 reg;
240
241 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
242
243 switch (reg & DA9150_CHG_STAT_MASK) {
244 case DA9150_CHG_STAT_CC:
245 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
246 break;
247 case DA9150_CHG_STAT_ACT:
248 case DA9150_CHG_STAT_PRE:
249 case DA9150_CHG_STAT_CV:
250 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
251 break;
252 default:
253 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
254 break;
255 }
256
257 return 0;
258}
259
260static int da9150_charger_battery_voltage_min(struct da9150_charger *charger,
261 union power_supply_propval *val)
262{
263 u8 reg;
264
265 reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_C);
266
267 /* Value starts at 2500 mV, 50 mV increments, presented in uV */
268 val->intval = ((reg & DA9150_CHG_VFAULT_MASK) * 50000) + 2500000;
269
270 return 0;
271}
272
273static int da9150_charger_battery_voltage_now(struct da9150_charger *charger,
274 union power_supply_propval *val)
275{
276 int v_val, ret;
277
278 /* Read processed value - mV units */
279 ret = iio_read_channel_processed(charger->vbat_chan, &v_val);
280 if (ret < 0)
281 return ret;
282
283 val->intval = v_val * 1000;
284
285 return 0;
286}
287
288static int da9150_charger_battery_current_max(struct da9150_charger *charger,
289 union power_supply_propval *val)
290{
291 int reg;
292
293 reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_D);
294
295 /* 25mA increments */
296 val->intval = reg * 25000;
297
298 return 0;
299}
300
301static int da9150_charger_battery_voltage_max(struct da9150_charger *charger,
302 union power_supply_propval *val)
303{
304 u8 reg;
305
306 reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_B);
307
308 /* Value starts at 3650 mV, 25 mV increments, presented in uV */
309 val->intval = ((reg & DA9150_CHG_VBAT_MASK) * 25000) + 3650000;
310 return 0;
311}
312
313static enum power_supply_property da9150_charger_bat_props[] = {
314 POWER_SUPPLY_PROP_STATUS,
315 POWER_SUPPLY_PROP_ONLINE,
316 POWER_SUPPLY_PROP_HEALTH,
317 POWER_SUPPLY_PROP_PRESENT,
318 POWER_SUPPLY_PROP_CHARGE_TYPE,
319 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
320 POWER_SUPPLY_PROP_VOLTAGE_NOW,
321 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
322 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
323};
324
325static int da9150_charger_battery_get_prop(struct power_supply *psy,
326 enum power_supply_property psp,
327 union power_supply_propval *val)
328{
329 struct da9150_charger *charger = dev_get_drvdata(psy->dev->parent);
330 int ret;
331
332 switch (psp) {
333 case POWER_SUPPLY_PROP_STATUS:
334 ret = da9150_charger_battery_status(charger, val);
335 break;
336 case POWER_SUPPLY_PROP_ONLINE:
337 ret = da9150_charger_supply_online(charger, psy, val);
338 break;
339 case POWER_SUPPLY_PROP_HEALTH:
340 ret = da9150_charger_battery_health(charger, val);
341 break;
342 case POWER_SUPPLY_PROP_PRESENT:
343 ret = da9150_charger_battery_present(charger, val);
344 break;
345 case POWER_SUPPLY_PROP_CHARGE_TYPE:
346 ret = da9150_charger_battery_charge_type(charger, val);
347 break;
348 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
349 ret = da9150_charger_battery_voltage_min(charger, val);
350 break;
351 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
352 ret = da9150_charger_battery_voltage_now(charger, val);
353 break;
354 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
355 ret = da9150_charger_battery_current_max(charger, val);
356 break;
357 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
358 ret = da9150_charger_battery_voltage_max(charger, val);
359 break;
360 default:
361 ret = -EINVAL;
362 break;
363 }
364
365 return ret;
366}
367
368static irqreturn_t da9150_charger_chg_irq(int irq, void *data)
369{
370 struct da9150_charger *charger = data;
371
372 power_supply_changed(&charger->battery);
373
374 return IRQ_HANDLED;
375}
376
377static irqreturn_t da9150_charger_tjunc_irq(int irq, void *data)
378{
379 struct da9150_charger *charger = data;
380
381 /* Nothing we can really do except report this. */
382 dev_crit(charger->dev, "TJunc over temperature!!!\n");
383 power_supply_changed(&charger->usb);
384
385 return IRQ_HANDLED;
386}
387
388static irqreturn_t da9150_charger_vfault_irq(int irq, void *data)
389{
390 struct da9150_charger *charger = data;
391
392 /* Nothing we can really do except report this. */
393 dev_crit(charger->dev, "VSYS under voltage!!!\n");
394 power_supply_changed(&charger->usb);
395 power_supply_changed(&charger->battery);
396
397 return IRQ_HANDLED;
398}
399
400static irqreturn_t da9150_charger_vbus_irq(int irq, void *data)
401{
402 struct da9150_charger *charger = data;
403 u8 reg;
404
405 reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
406
407 /* Charger plugged in or battery only */
408 switch (reg & DA9150_VBUS_STAT_MASK) {
409 case DA9150_VBUS_STAT_OFF:
410 case DA9150_VBUS_STAT_WAIT:
411 charger->supply_online = &charger->battery;
412 break;
413 case DA9150_VBUS_STAT_CHG:
414 charger->supply_online = &charger->usb;
415 break;
416 default:
417 dev_warn(charger->dev, "Unknown VBUS state - reg = 0x%x\n",
418 reg);
419 charger->supply_online = NULL;
420 break;
421 }
422
423 power_supply_changed(&charger->usb);
424 power_supply_changed(&charger->battery);
425
426 return IRQ_HANDLED;
427}
428
429static void da9150_charger_otg_work(struct work_struct *data)
430{
431 struct da9150_charger *charger =
432 container_of(data, struct da9150_charger, otg_work);
433
434 switch (charger->usb_event) {
435 case USB_EVENT_ID:
436 /* Enable OTG Boost */
437 da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
438 DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_OTG);
439 break;
440 case USB_EVENT_NONE:
441 /* Revert to charge mode */
442 power_supply_changed(&charger->usb);
443 power_supply_changed(&charger->battery);
444 da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
445 DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_CHG);
446 break;
447 }
448}
449
450static int da9150_charger_otg_ncb(struct notifier_block *nb, unsigned long val,
451 void *priv)
452{
453 struct da9150_charger *charger =
454 container_of(nb, struct da9150_charger, otg_nb);
455
456 dev_dbg(charger->dev, "DA9150 OTG notify %lu\n", val);
457
458 charger->usb_event = val;
459 schedule_work(&charger->otg_work);
460
461 return NOTIFY_OK;
462}
463
464static int da9150_charger_register_irq(struct platform_device *pdev,
465 irq_handler_t handler,
466 const char *irq_name)
467{
468 struct device *dev = &pdev->dev;
469 struct da9150_charger *charger = platform_get_drvdata(pdev);
470 int irq, ret;
471
472 irq = platform_get_irq_byname(pdev, irq_name);
473 if (irq < 0) {
474 dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
475 return irq;
476 }
477
478 ret = request_threaded_irq(irq, NULL, handler, IRQF_ONESHOT, irq_name,
479 charger);
480 if (ret)
481 dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
482
483 return ret;
484}
485
486static void da9150_charger_unregister_irq(struct platform_device *pdev,
487 const char *irq_name)
488{
489 struct device *dev = &pdev->dev;
490 struct da9150_charger *charger = platform_get_drvdata(pdev);
491 int irq;
492
493 irq = platform_get_irq_byname(pdev, irq_name);
494 if (irq < 0) {
495 dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
496 return;
497 }
498
499 free_irq(irq, charger);
500}
501
502static int da9150_charger_probe(struct platform_device *pdev)
503{
504 struct device *dev = &pdev->dev;
505 struct da9150 *da9150 = dev_get_drvdata(dev->parent);
506 struct da9150_charger *charger;
507 struct power_supply *usb, *battery;
508 u8 reg;
509 int ret;
510
511 charger = devm_kzalloc(dev, sizeof(struct da9150_charger), GFP_KERNEL);
512 if (!charger)
513 return -ENOMEM;
514
515 platform_set_drvdata(pdev, charger);
516 charger->da9150 = da9150;
517 charger->dev = dev;
518
519 /* Acquire ADC channels */
520 charger->ibus_chan = iio_channel_get(dev, "CHAN_IBUS");
521 if (IS_ERR(charger->ibus_chan)) {
522 ret = PTR_ERR(charger->ibus_chan);
523 goto ibus_chan_fail;
524 }
525
526 charger->vbus_chan = iio_channel_get(dev, "CHAN_VBUS");
527 if (IS_ERR(charger->vbus_chan)) {
528 ret = PTR_ERR(charger->vbus_chan);
529 goto vbus_chan_fail;
530 }
531
532 charger->tjunc_chan = iio_channel_get(dev, "CHAN_TJUNC");
533 if (IS_ERR(charger->tjunc_chan)) {
534 ret = PTR_ERR(charger->tjunc_chan);
535 goto tjunc_chan_fail;
536 }
537
538 charger->vbat_chan = iio_channel_get(dev, "CHAN_VBAT");
539 if (IS_ERR(charger->vbat_chan)) {
540 ret = PTR_ERR(charger->vbat_chan);
541 goto vbat_chan_fail;
542 }
543
544 /* Register power supplies */
545 usb = &charger->usb;
546 battery = &charger->battery;
547
548 usb->name = "da9150-usb",
549 usb->type = POWER_SUPPLY_TYPE_USB;
550 usb->properties = da9150_charger_props;
551 usb->num_properties = ARRAY_SIZE(da9150_charger_props);
552 usb->get_property = da9150_charger_get_prop;
2dc9215d 553 ret = power_supply_register(dev, usb, NULL);
c1a281e3
AT		 554 if (ret)
555 goto usb_fail;
556
557 battery->name = "da9150-battery";
558 battery->type = POWER_SUPPLY_TYPE_BATTERY;
559 battery->properties = da9150_charger_bat_props;
560 battery->num_properties = ARRAY_SIZE(da9150_charger_bat_props);
561 battery->get_property = da9150_charger_battery_get_prop;
2dc9215d 562 ret = power_supply_register(dev, battery, NULL);
c1a281e3
AT		 563 if (ret)
564 goto battery_fail;
565
566 /* Get initial online supply */
567 reg = da9150_reg_read(da9150, DA9150_STATUS_H);
568
569 switch (reg & DA9150_VBUS_STAT_MASK) {
570 case DA9150_VBUS_STAT_OFF:
571 case DA9150_VBUS_STAT_WAIT:
572 charger->supply_online = &charger->battery;
573 break;
574 case DA9150_VBUS_STAT_CHG:
575 charger->supply_online = &charger->usb;
576 break;
577 default:
578 dev_warn(dev, "Unknown VBUS state - reg = 0x%x\n", reg);
579 charger->supply_online = NULL;
580 break;
581 }
582
583 /* Setup OTG reporting & configuration */
584 charger->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
585 if (!IS_ERR_OR_NULL(charger->usb_phy)) {
586 INIT_WORK(&charger->otg_work, da9150_charger_otg_work);
587 charger->otg_nb.notifier_call = da9150_charger_otg_ncb;
588 usb_register_notifier(charger->usb_phy, &charger->otg_nb);
589 }
590
591 /* Register IRQs */
592 ret = da9150_charger_register_irq(pdev, da9150_charger_chg_irq,
593 "CHG_STATUS");
594 if (ret < 0)
595 goto chg_irq_fail;
596
597 ret = da9150_charger_register_irq(pdev, da9150_charger_tjunc_irq,
598 "CHG_TJUNC");
599 if (ret < 0)
600 goto tjunc_irq_fail;
601
602 ret = da9150_charger_register_irq(pdev, da9150_charger_vfault_irq,
603 "CHG_VFAULT");
604 if (ret < 0)
605 goto vfault_irq_fail;
606
607 ret = da9150_charger_register_irq(pdev, da9150_charger_vbus_irq,
608 "CHG_VBUS");
609 if (ret < 0)
610 goto vbus_irq_fail;
611
612 return 0;
613
614
615vbus_irq_fail:
616 da9150_charger_unregister_irq(pdev, "CHG_VFAULT");
617vfault_irq_fail:
618 da9150_charger_unregister_irq(pdev, "CHG_TJUNC");
619tjunc_irq_fail:
620 da9150_charger_unregister_irq(pdev, "CHG_STATUS");
621chg_irq_fail:
622 if (!IS_ERR_OR_NULL(charger->usb_phy))
623 usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
624battery_fail:
625 power_supply_unregister(usb);
626
627usb_fail:
628 iio_channel_release(charger->vbat_chan);
629
630vbat_chan_fail:
631 iio_channel_release(charger->tjunc_chan);
632
633tjunc_chan_fail:
634 iio_channel_release(charger->vbus_chan);
635
636vbus_chan_fail:
637 iio_channel_release(charger->ibus_chan);
638
639ibus_chan_fail:
640 return ret;
641}
642
643static int da9150_charger_remove(struct platform_device *pdev)
644{
645 struct da9150_charger *charger = platform_get_drvdata(pdev);
646 int irq;
647
648 /* Make sure IRQs are released before unregistering power supplies */
649 irq = platform_get_irq_byname(pdev, "CHG_VBUS");
650 free_irq(irq, charger);
651
652 irq = platform_get_irq_byname(pdev, "CHG_VFAULT");
653 free_irq(irq, charger);
654
655 irq = platform_get_irq_byname(pdev, "CHG_TJUNC");
656 free_irq(irq, charger);
657
658 irq = platform_get_irq_byname(pdev, "CHG_STATUS");
659 free_irq(irq, charger);
660
661 if (!IS_ERR_OR_NULL(charger->usb_phy))
662 usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
663
664 power_supply_unregister(&charger->battery);
665 power_supply_unregister(&charger->usb);
666
667 /* Release ADC channels */
668 iio_channel_release(charger->ibus_chan);
669 iio_channel_release(charger->vbus_chan);
670 iio_channel_release(charger->tjunc_chan);
671 iio_channel_release(charger->vbat_chan);
672
673 return 0;
674}
675
676static struct platform_driver da9150_charger_driver = {
677 .driver = {
678 .name = "da9150-charger",
679 },
680 .probe = da9150_charger_probe,
681 .remove = da9150_charger_remove,
682};
683
684module_platform_driver(da9150_charger_driver);
685
686MODULE_DESCRIPTION("Charger Driver for DA9150");
687MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
688MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.050516 seconds and 5 git commands to generate.