2 * TWL4030/TPS65950 BCI (Battery Charger Interface) driver
4 * Copyright (C) 2010 Gražvydas Ignotas <notasas@gmail.com>
6 * based on twl4030_bci_battery.c by TI
7 * Copyright (C) 2008 Texas Instruments, Inc.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/err.h>
19 #include <linux/platform_device.h>
20 #include <linux/interrupt.h>
21 #include <linux/i2c/twl.h>
22 #include <linux/power_supply.h>
23 #include <linux/notifier.h>
24 #include <linux/usb/otg.h>
26 #define TWL4030_BCIMSTATEC 0x02
27 #define TWL4030_BCIICHG 0x08
28 #define TWL4030_BCIVAC 0x0a
29 #define TWL4030_BCIVBUS 0x0c
30 #define TWL4030_BCIMFSTS4 0x10
31 #define TWL4030_BCICTL1 0x23
33 #define TWL4030_BCIAUTOWEN BIT(5)
34 #define TWL4030_CONFIG_DONE BIT(4)
35 #define TWL4030_BCIAUTOUSB BIT(1)
36 #define TWL4030_BCIAUTOAC BIT(0)
37 #define TWL4030_CGAIN BIT(5)
38 #define TWL4030_USBFASTMCHG BIT(2)
39 #define TWL4030_STS_VBUS BIT(7)
40 #define TWL4030_STS_USB_ID BIT(2)
43 #define TWL4030_WOVF BIT(0) /* Watchdog overflow */
44 #define TWL4030_TMOVF BIT(1) /* Timer overflow */
45 #define TWL4030_ICHGHIGH BIT(2) /* Battery charge current high */
46 #define TWL4030_ICHGLOW BIT(3) /* Battery cc. low / FSM state change */
47 #define TWL4030_ICHGEOC BIT(4) /* Battery current end-of-charge */
48 #define TWL4030_TBATOR2 BIT(5) /* Battery temperature out of range 2 */
49 #define TWL4030_TBATOR1 BIT(6) /* Battery temperature out of range 1 */
50 #define TWL4030_BATSTS BIT(7) /* Battery status */
52 #define TWL4030_VBATLVL BIT(0) /* VBAT level */
53 #define TWL4030_VBATOV BIT(1) /* VBAT overvoltage */
54 #define TWL4030_VBUSOV BIT(2) /* VBUS overvoltage */
55 #define TWL4030_ACCHGOV BIT(3) /* Ac charger overvoltage */
57 #define TWL4030_MSTATEC_USB BIT(4)
58 #define TWL4030_MSTATEC_AC BIT(5)
59 #define TWL4030_MSTATEC_MASK 0x0f
60 #define TWL4030_MSTATEC_QUICK1 0x02
61 #define TWL4030_MSTATEC_QUICK7 0x07
62 #define TWL4030_MSTATEC_COMPLETE1 0x0b
63 #define TWL4030_MSTATEC_COMPLETE4 0x0e
65 static bool allow_usb
;
66 module_param(allow_usb
, bool, 0644);
67 MODULE_PARM_DESC(allow_usb
, "Allow USB charge drawing default current");
71 struct power_supply ac
;
72 struct power_supply usb
;
73 struct usb_phy
*transceiver
;
74 struct notifier_block usb_nb
;
75 struct work_struct work
;
83 * clear and set bits on an given register on a given module
85 static int twl4030_clear_set(u8 mod_no
, u8 clear
, u8 set
, u8 reg
)
90 ret
= twl_i2c_read_u8(mod_no
, &val
, reg
);
97 return twl_i2c_write_u8(mod_no
, val
, reg
);
100 static int twl4030_bci_read(u8 reg
, u8
*val
)
102 return twl_i2c_read_u8(TWL4030_MODULE_MAIN_CHARGE
, val
, reg
);
105 static int twl4030_clear_set_boot_bci(u8 clear
, u8 set
)
107 return twl4030_clear_set(TWL4030_MODULE_PM_MASTER
, 0,
108 TWL4030_CONFIG_DONE
| TWL4030_BCIAUTOWEN
| set
,
109 TWL4030_PM_MASTER_BOOT_BCI
);
112 static int twl4030bci_read_adc_val(u8 reg
)
118 ret
= twl4030_bci_read(reg
+ 1, &val
);
122 temp
= (int)(val
& 0x03) << 8;
125 ret
= twl4030_bci_read(reg
, &val
);
133 * Check if VBUS power is present
135 static int twl4030_bci_have_vbus(struct twl4030_bci
*bci
)
140 ret
= twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER
, &hwsts
,
141 TWL4030_PM_MASTER_STS_HW_CONDITIONS
);
145 dev_dbg(bci
->dev
, "check_vbus: HW_CONDITIONS %02x\n", hwsts
);
147 /* in case we also have STS_USB_ID, VBUS is driven by TWL itself */
148 if ((hwsts
& TWL4030_STS_VBUS
) && !(hwsts
& TWL4030_STS_USB_ID
))
155 * Enable/Disable USB Charge funtionality.
157 static int twl4030_charger_enable_usb(struct twl4030_bci
*bci
, bool enable
)
162 /* Check for USB charger conneted */
163 if (!twl4030_bci_have_vbus(bci
))
167 * Until we can find out what current the device can provide,
168 * require a module param to enable USB charging.
171 dev_warn(bci
->dev
, "USB charging is disabled.\n");
175 /* forcing the field BCIAUTOUSB (BOOT_BCI[1]) to 1 */
176 ret
= twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOUSB
);
180 /* forcing USBFASTMCHG(BCIMFSTS4[2]) to 1 */
181 ret
= twl4030_clear_set(TWL4030_MODULE_MAIN_CHARGE
, 0,
182 TWL4030_USBFASTMCHG
, TWL4030_BCIMFSTS4
);
184 ret
= twl4030_clear_set_boot_bci(TWL4030_BCIAUTOUSB
, 0);
191 * Enable/Disable AC Charge funtionality.
193 static int twl4030_charger_enable_ac(bool enable
)
198 ret
= twl4030_clear_set_boot_bci(0, TWL4030_BCIAUTOAC
);
200 ret
= twl4030_clear_set_boot_bci(TWL4030_BCIAUTOAC
, 0);
206 * TWL4030 CHG_PRES (AC charger presence) events
208 static irqreturn_t
twl4030_charger_interrupt(int irq
, void *arg
)
210 struct twl4030_bci
*bci
= arg
;
212 dev_dbg(bci
->dev
, "CHG_PRES irq\n");
213 power_supply_changed(&bci
->ac
);
214 power_supply_changed(&bci
->usb
);
220 * TWL4030 BCI monitoring events
222 static irqreturn_t
twl4030_bci_interrupt(int irq
, void *arg
)
224 struct twl4030_bci
*bci
= arg
;
228 ret
= twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS
, &irqs1
,
229 TWL4030_INTERRUPTS_BCIISR1A
);
233 ret
= twl_i2c_read_u8(TWL4030_MODULE_INTERRUPTS
, &irqs2
,
234 TWL4030_INTERRUPTS_BCIISR2A
);
238 dev_dbg(bci
->dev
, "BCI irq %02x %02x\n", irqs2
, irqs1
);
240 if (irqs1
& (TWL4030_ICHGLOW
| TWL4030_ICHGEOC
)) {
241 /* charger state change, inform the core */
242 power_supply_changed(&bci
->ac
);
243 power_supply_changed(&bci
->usb
);
246 /* various monitoring events, for now we just log them here */
247 if (irqs1
& (TWL4030_TBATOR2
| TWL4030_TBATOR1
))
248 dev_warn(bci
->dev
, "battery temperature out of range\n");
250 if (irqs1
& TWL4030_BATSTS
)
251 dev_crit(bci
->dev
, "battery disconnected\n");
253 if (irqs2
& TWL4030_VBATOV
)
254 dev_crit(bci
->dev
, "VBAT overvoltage\n");
256 if (irqs2
& TWL4030_VBUSOV
)
257 dev_crit(bci
->dev
, "VBUS overvoltage\n");
259 if (irqs2
& TWL4030_ACCHGOV
)
260 dev_crit(bci
->dev
, "Ac charger overvoltage\n");
265 static void twl4030_bci_usb_work(struct work_struct
*data
)
267 struct twl4030_bci
*bci
= container_of(data
, struct twl4030_bci
, work
);
269 switch (bci
->event
) {
271 case USB_EVENT_CHARGER
:
272 twl4030_charger_enable_usb(bci
, true);
275 twl4030_charger_enable_usb(bci
, false);
280 static int twl4030_bci_usb_ncb(struct notifier_block
*nb
, unsigned long val
,
283 struct twl4030_bci
*bci
= container_of(nb
, struct twl4030_bci
, usb_nb
);
285 dev_dbg(bci
->dev
, "OTG notify %lu\n", val
);
288 schedule_work(&bci
->work
);
294 * TI provided formulas:
295 * CGAIN == 0: ICHG = (BCIICHG * 1.7) / (2^10 - 1) - 0.85
296 * CGAIN == 1: ICHG = (BCIICHG * 3.4) / (2^10 - 1) - 1.7
297 * Here we use integer approximation of:
298 * CGAIN == 0: val * 1.6618 - 0.85
299 * CGAIN == 1: (val * 1.6618 - 0.85) * 2
301 static int twl4030_charger_get_current(void)
307 curr
= twl4030bci_read_adc_val(TWL4030_BCIICHG
);
311 ret
= twl4030_bci_read(TWL4030_BCICTL1
, &bcictl1
);
315 ret
= (curr
* 16618 - 850 * 10000) / 10;
316 if (bcictl1
& TWL4030_CGAIN
)
323 * Returns the main charge FSM state
326 static int twl4030bci_state(struct twl4030_bci
*bci
)
331 ret
= twl4030_bci_read(TWL4030_BCIMSTATEC
, &state
);
333 pr_err("twl4030_bci: error reading BCIMSTATEC\n");
337 dev_dbg(bci
->dev
, "state: %02x\n", state
);
342 static int twl4030_bci_state_to_status(int state
)
344 state
&= TWL4030_MSTATEC_MASK
;
345 if (TWL4030_MSTATEC_QUICK1
<= state
&& state
<= TWL4030_MSTATEC_QUICK7
)
346 return POWER_SUPPLY_STATUS_CHARGING
;
347 else if (TWL4030_MSTATEC_COMPLETE1
<= state
&&
348 state
<= TWL4030_MSTATEC_COMPLETE4
)
349 return POWER_SUPPLY_STATUS_FULL
;
351 return POWER_SUPPLY_STATUS_NOT_CHARGING
;
354 static int twl4030_bci_get_property(struct power_supply
*psy
,
355 enum power_supply_property psp
,
356 union power_supply_propval
*val
)
358 struct twl4030_bci
*bci
= dev_get_drvdata(psy
->dev
->parent
);
363 state
= twl4030bci_state(bci
);
367 if (psy
->type
== POWER_SUPPLY_TYPE_USB
)
368 is_charging
= state
& TWL4030_MSTATEC_USB
;
370 is_charging
= state
& TWL4030_MSTATEC_AC
;
373 case POWER_SUPPLY_PROP_STATUS
:
375 val
->intval
= twl4030_bci_state_to_status(state
);
377 val
->intval
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
379 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
380 /* charging must be active for meaningful result */
383 if (psy
->type
== POWER_SUPPLY_TYPE_USB
) {
384 ret
= twl4030bci_read_adc_val(TWL4030_BCIVBUS
);
387 /* BCIVBUS uses ADCIN8, 7/1023 V/step */
388 val
->intval
= ret
* 6843;
390 ret
= twl4030bci_read_adc_val(TWL4030_BCIVAC
);
393 /* BCIVAC uses ADCIN11, 10/1023 V/step */
394 val
->intval
= ret
* 9775;
397 case POWER_SUPPLY_PROP_CURRENT_NOW
:
400 /* current measurement is shared between AC and USB */
401 ret
= twl4030_charger_get_current();
406 case POWER_SUPPLY_PROP_ONLINE
:
407 val
->intval
= is_charging
&&
408 twl4030_bci_state_to_status(state
) !=
409 POWER_SUPPLY_STATUS_NOT_CHARGING
;
418 static enum power_supply_property twl4030_charger_props
[] = {
419 POWER_SUPPLY_PROP_STATUS
,
420 POWER_SUPPLY_PROP_ONLINE
,
421 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
422 POWER_SUPPLY_PROP_CURRENT_NOW
,
425 static int __init
twl4030_bci_probe(struct platform_device
*pdev
)
427 struct twl4030_bci
*bci
;
431 bci
= kzalloc(sizeof(*bci
), GFP_KERNEL
);
435 bci
->dev
= &pdev
->dev
;
436 bci
->irq_chg
= platform_get_irq(pdev
, 0);
437 bci
->irq_bci
= platform_get_irq(pdev
, 1);
439 platform_set_drvdata(pdev
, bci
);
441 bci
->ac
.name
= "twl4030_ac";
442 bci
->ac
.type
= POWER_SUPPLY_TYPE_MAINS
;
443 bci
->ac
.properties
= twl4030_charger_props
;
444 bci
->ac
.num_properties
= ARRAY_SIZE(twl4030_charger_props
);
445 bci
->ac
.get_property
= twl4030_bci_get_property
;
447 ret
= power_supply_register(&pdev
->dev
, &bci
->ac
);
449 dev_err(&pdev
->dev
, "failed to register ac: %d\n", ret
);
450 goto fail_register_ac
;
453 bci
->usb
.name
= "twl4030_usb";
454 bci
->usb
.type
= POWER_SUPPLY_TYPE_USB
;
455 bci
->usb
.properties
= twl4030_charger_props
;
456 bci
->usb
.num_properties
= ARRAY_SIZE(twl4030_charger_props
);
457 bci
->usb
.get_property
= twl4030_bci_get_property
;
459 ret
= power_supply_register(&pdev
->dev
, &bci
->usb
);
461 dev_err(&pdev
->dev
, "failed to register usb: %d\n", ret
);
462 goto fail_register_usb
;
465 ret
= request_threaded_irq(bci
->irq_chg
, NULL
,
466 twl4030_charger_interrupt
, 0, pdev
->name
, bci
);
468 dev_err(&pdev
->dev
, "could not request irq %d, status %d\n",
473 ret
= request_threaded_irq(bci
->irq_bci
, NULL
,
474 twl4030_bci_interrupt
, 0, pdev
->name
, bci
);
476 dev_err(&pdev
->dev
, "could not request irq %d, status %d\n",
481 INIT_WORK(&bci
->work
, twl4030_bci_usb_work
);
483 bci
->transceiver
= usb_get_phy(USB_PHY_TYPE_USB2
);
484 if (!IS_ERR_OR_NULL(bci
->transceiver
)) {
485 bci
->usb_nb
.notifier_call
= twl4030_bci_usb_ncb
;
486 usb_register_notifier(bci
->transceiver
, &bci
->usb_nb
);
489 /* Enable interrupts now. */
490 reg
= ~(u32
)(TWL4030_ICHGLOW
| TWL4030_ICHGEOC
| TWL4030_TBATOR2
|
491 TWL4030_TBATOR1
| TWL4030_BATSTS
);
492 ret
= twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS
, reg
,
493 TWL4030_INTERRUPTS_BCIIMR1A
);
495 dev_err(&pdev
->dev
, "failed to unmask interrupts: %d\n", ret
);
496 goto fail_unmask_interrupts
;
499 reg
= ~(u32
)(TWL4030_VBATOV
| TWL4030_VBUSOV
| TWL4030_ACCHGOV
);
500 ret
= twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS
, reg
,
501 TWL4030_INTERRUPTS_BCIIMR2A
);
503 dev_warn(&pdev
->dev
, "failed to unmask interrupts: %d\n", ret
);
505 twl4030_charger_enable_ac(true);
506 twl4030_charger_enable_usb(bci
, true);
510 fail_unmask_interrupts
:
511 if (!IS_ERR_OR_NULL(bci
->transceiver
)) {
512 usb_unregister_notifier(bci
->transceiver
, &bci
->usb_nb
);
513 usb_put_phy(bci
->transceiver
);
515 free_irq(bci
->irq_bci
, bci
);
517 free_irq(bci
->irq_chg
, bci
);
519 power_supply_unregister(&bci
->usb
);
521 power_supply_unregister(&bci
->ac
);
523 platform_set_drvdata(pdev
, NULL
);
529 static int __exit
twl4030_bci_remove(struct platform_device
*pdev
)
531 struct twl4030_bci
*bci
= platform_get_drvdata(pdev
);
533 twl4030_charger_enable_ac(false);
534 twl4030_charger_enable_usb(bci
, false);
536 /* mask interrupts */
537 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS
, 0xff,
538 TWL4030_INTERRUPTS_BCIIMR1A
);
539 twl_i2c_write_u8(TWL4030_MODULE_INTERRUPTS
, 0xff,
540 TWL4030_INTERRUPTS_BCIIMR2A
);
542 if (!IS_ERR_OR_NULL(bci
->transceiver
)) {
543 usb_unregister_notifier(bci
->transceiver
, &bci
->usb_nb
);
544 usb_put_phy(bci
->transceiver
);
546 free_irq(bci
->irq_bci
, bci
);
547 free_irq(bci
->irq_chg
, bci
);
548 power_supply_unregister(&bci
->usb
);
549 power_supply_unregister(&bci
->ac
);
550 platform_set_drvdata(pdev
, NULL
);
556 static struct platform_driver twl4030_bci_driver
= {
558 .name
= "twl4030_bci",
559 .owner
= THIS_MODULE
,
561 .remove
= __exit_p(twl4030_bci_remove
),
564 static int __init
twl4030_bci_init(void)
566 return platform_driver_probe(&twl4030_bci_driver
, twl4030_bci_probe
);
568 module_init(twl4030_bci_init
);
570 static void __exit
twl4030_bci_exit(void)
572 platform_driver_unregister(&twl4030_bci_driver
);
574 module_exit(twl4030_bci_exit
);
576 MODULE_AUTHOR("Gražvydas Ignotas");
577 MODULE_DESCRIPTION("TWL4030 Battery Charger Interface driver");
578 MODULE_LICENSE("GPL");
579 MODULE_ALIAS("platform:twl4030_bci");