2 * linux/drivers/power/twl6030_bci_battery.c
4 * OMAP4:TWL6030 battery driver for Linux
6 * Copyright (C) 2008-2009 Texas Instruments, Inc.
7 * Author: Texas Instruments, Inc.
9 * This package is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/interrupt.h>
22 #include <linux/delay.h>
23 #include <linux/platform_device.h>
24 #include <linux/slab.h>
25 #include <linux/i2c/twl.h>
26 #include <linux/power_supply.h>
27 #include <linux/i2c/twl6030-gpadc.h>
28 #include <linux/i2c/bq2415x.h>
29 #include <linux/wakelock.h>
30 #include <linux/usb/otg.h>
32 #define CONTROLLER_INT_MASK 0x00
33 #define CONTROLLER_CTRL1 0x01
34 #define CONTROLLER_WDG 0x02
35 #define CONTROLLER_STAT1 0x03
36 #define CHARGERUSB_INT_STATUS 0x04
37 #define CHARGERUSB_INT_MASK 0x05
38 #define CHARGERUSB_STATUS_INT1 0x06
39 #define CHARGERUSB_STATUS_INT2 0x07
40 #define CHARGERUSB_CTRL1 0x08
41 #define CHARGERUSB_CTRL2 0x09
42 #define CHARGERUSB_CTRL3 0x0A
43 #define CHARGERUSB_STAT1 0x0B
44 #define CHARGERUSB_VOREG 0x0C
45 #define CHARGERUSB_VICHRG 0x0D
46 #define CHARGERUSB_CINLIMIT 0x0E
47 #define CHARGERUSB_CTRLLIMIT1 0x0F
48 #define CHARGERUSB_CTRLLIMIT2 0x10
49 #define ANTICOLLAPSE_CTRL1 0x11
50 #define ANTICOLLAPSE_CTRL2 0x12
52 /* TWL6032 registers 0xDA to 0xDE - TWL6032_MODULE_CHARGER */
53 #define CONTROLLER_CTRL2 0x00
54 #define CONTROLLER_VSEL_COMP 0x01
55 #define CHARGERUSB_VSYSREG 0x02
56 #define CHARGERUSB_VICHRG_PC 0x03
57 #define LINEAR_CHRG_STS 0x04
59 /* TWL6032 Charger Mode Register */
60 #define CHARGER_MODE_REG 0xD4
61 #define CHARGER_MODE_POWERPATH BIT(3)
62 #define CHARGER_MODE_AUTOCHARGE BIT(6)
64 #define LINEAR_CHRG_STS_CRYSTL_OSC_OK 0x40
65 #define LINEAR_CHRG_STS_END_OF_CHARGE 0x20
66 #define LINEAR_CHRG_STS_VBATOV 0x10
67 #define LINEAR_CHRG_STS_VSYSOV 0x08
68 #define LINEAR_CHRG_STS_DPPM_STS 0x04
69 #define LINEAR_CHRG_STS_CV_STS 0x02
70 #define LINEAR_CHRG_STS_CC_STS 0x01
72 #define FG_REG_00 0x00
73 #define FG_REG_01 0x01
74 #define FG_REG_02 0x02
75 #define FG_REG_03 0x03
76 #define FG_REG_04 0x04
77 #define FG_REG_05 0x05
78 #define FG_REG_06 0x06
79 #define FG_REG_07 0x07
80 #define FG_REG_08 0x08
81 #define FG_REG_09 0x09
82 #define FG_REG_10 0x0A
83 #define FG_REG_11 0x0B
85 /* CONTROLLER_INT_MASK */
86 #define MVAC_FAULT (1 << 7)
87 #define MAC_EOC (1 << 6)
88 #define LINCH_GATED (1 << 5)
89 #define MBAT_REMOVED (1 << 4)
90 #define MFAULT_WDG (1 << 3)
91 #define MBAT_TEMP (1 << 2)
92 #define MVBUS_DET (1 << 1)
93 #define MVAC_DET (1 << 0)
95 /* CONTROLLER_CTRL1 */
96 #define CONTROLLER_CTRL1_EN_LINCH (1 << 5)
97 #define CONTROLLER_CTRL1_EN_CHARGER (1 << 4)
98 #define CONTROLLER_CTRL1_SEL_CHARGER (1 << 3)
100 /* CONTROLLER_STAT1 */
101 #define CONTROLLER_STAT1_EXTCHRG_STATZ (1 << 7)
102 #define CONTROLLER_STAT1_LINCH_GATED (1 << 6)
103 #define CONTROLLER_STAT1_CHRG_DET_N (1 << 5)
104 #define CONTROLLER_STAT1_FAULT_WDG (1 << 4)
105 #define CONTROLLER_STAT1_VAC_DET (1 << 3)
106 #define VAC_DET (1 << 3)
107 #define CONTROLLER_STAT1_VBUS_DET (1 << 2)
108 #define VBUS_DET (1 << 2)
109 #define CONTROLLER_STAT1_BAT_REMOVED (1 << 1)
110 #define CONTROLLER_STAT1_BAT_TEMP_OVRANGE (1 << 0)
112 /* CHARGERUSB_INT_STATUS */
113 #define EN_LINCH (1 << 4)
114 #define CURRENT_TERM_INT (1 << 3)
115 #define CHARGERUSB_STAT (1 << 2)
116 #define CHARGERUSB_THMREG (1 << 1)
117 #define CHARGERUSB_FAULT (1 << 0)
119 /* CHARGERUSB_INT_MASK */
120 #define MASK_MCURRENT_TERM (1 << 3)
121 #define MASK_MCHARGERUSB_STAT (1 << 2)
122 #define MASK_MCHARGERUSB_THMREG (1 << 1)
123 #define MASK_MCHARGERUSB_FAULT (1 << 0)
125 /* CHARGERUSB_STATUS_INT1 */
126 #define CHARGERUSB_STATUS_INT1_TMREG (1 << 7)
127 #define CHARGERUSB_STATUS_INT1_NO_BAT (1 << 6)
128 #define CHARGERUSB_STATUS_INT1_BST_OCP (1 << 5)
129 #define CHARGERUSB_STATUS_INT1_TH_SHUTD (1 << 4)
130 #define CHARGERUSB_STATUS_INT1_BAT_OVP (1 << 3)
131 #define CHARGERUSB_STATUS_INT1_POOR_SRC (1 << 2)
132 #define CHARGERUSB_STATUS_INT1_SLP_MODE (1 << 1)
133 #define CHARGERUSB_STATUS_INT1_VBUS_OVP (1 << 0)
135 /* CHARGERUSB_STATUS_INT2 */
136 #define ICCLOOP (1 << 3)
137 #define CURRENT_TERM (1 << 2)
138 #define CHARGE_DONE (1 << 1)
139 #define ANTICOLLAPSE (1 << 0)
141 /* CHARGERUSB_CTRL1 */
142 #define SUSPEND_BOOT (1 << 7)
143 #define OPA_MODE (1 << 6)
144 #define HZ_MODE (1 << 5)
145 #define TERM (1 << 4)
147 /* CHARGERUSB_CTRL2 */
148 #define CHARGERUSB_CTRL2_VITERM_50 (0 << 5)
149 #define CHARGERUSB_CTRL2_VITERM_100 (1 << 5)
150 #define CHARGERUSB_CTRL2_VITERM_150 (2 << 5)
151 #define CHARGERUSB_CTRL2_VITERM_400 (7 << 5)
153 /* CHARGERUSB_CTRL3 */
154 #define VBUSCHRG_LDO_OVRD (1 << 7)
155 #define CHARGE_ONCE (1 << 6)
156 #define BST_HW_PR_DIS (1 << 5)
157 #define AUTOSUPPLY (1 << 3)
158 #define BUCK_HSILIM (1 << 0)
160 /* CHARGERUSB_VOREG */
161 #define CHARGERUSB_VOREG_3P52 0x01
162 #define CHARGERUSB_VOREG_4P0 0x19
163 #define CHARGERUSB_VOREG_4P2 0x23
164 #define CHARGERUSB_VOREG_4P76 0x3F
166 /* CHARGERUSB_VICHRG */
167 #define CHARGERUSB_VICHRG_300 0x0
168 #define CHARGERUSB_VICHRG_500 0x4
169 #define CHARGERUSB_VICHRG_1500 0xE
171 /* CHARGERUSB_CINLIMIT */
172 #define CHARGERUSB_CIN_LIMIT_100 0x1
173 #define CHARGERUSB_CIN_LIMIT_300 0x5
174 #define CHARGERUSB_CIN_LIMIT_500 0x9
175 #define CHARGERUSB_CIN_LIMIT_NONE 0xF
177 /* CHARGERUSB_CTRLLIMIT1 */
178 #define VOREGL_4P16 0x21
179 #define VOREGL_4P56 0x35
181 /* CHARGERUSB_CTRLLIMIT2 */
182 #define CHARGERUSB_CTRLLIMIT2_1500 0x0E
183 #define LOCK_LIMIT (1 << 4)
185 /* ANTICOLLAPSE_CTRL2 */
186 #define BUCK_VTH_SHIFT 5
189 #define CC_ACTIVE_MODE_SHIFT 6
190 #define CC_AUTOCLEAR (1 << 2)
191 #define CC_CAL_EN (1 << 1)
192 #define CC_PAUSE (1 << 0)
194 #define REG_TOGGLE1 0x90
195 #define FGDITHS (1 << 7)
196 #define FGDITHR (1 << 6)
200 /* TWL6030_GPADC_CTRL */
201 #define GPADC_CTRL_TEMP1_EN (1 << 0) /* input ch 1 */
202 #define GPADC_CTRL_TEMP2_EN (1 << 1) /* input ch 4 */
203 #define GPADC_CTRL_SCALER_EN (1 << 2) /* input ch 2 */
204 #define GPADC_CTRL_SCALER_DIV4 (1 << 3)
205 #define GPADC_CTRL_SCALER_EN_CH11 (1 << 4) /* input ch 11 */
206 #define GPADC_CTRL_TEMP1_EN_MONITOR (1 << 5)
207 #define GPADC_CTRL_TEMP2_EN_MONITOR (1 << 6)
208 #define GPADC_CTRL_ISOURCE_EN (1 << 7)
210 #define GPADC_ISOURCE_22uA 22
211 #define GPADC_ISOURCE_7uA 7
213 /* TWL6030/6032 BATTERY VOLTAGE GPADC CHANNELS */
215 #define TWL6030_GPADC_VBAT_CHNL 0x07
216 #define TWL6032_GPADC_VBAT_CHNL 0x12
218 /* TWL6030_GPADC_CTRL2 */
219 #define GPADC_CTRL2_CH18_SCALER_EN BIT(2)
221 #define ENABLE_ISOURCE 0x80
223 #define REG_MISC1 0xE4
224 #define VAC_MEAS 0x04
225 #define VBAT_MEAS 0x02
228 #define REG_USB_VBUS_CTRL_SET 0x04
229 #define VBUS_MEAS 0x01
230 #define REG_USB_ID_CTRL_SET 0x06
233 #define BBSPOR_CFG 0xE6
234 #define BB_CHG_EN (1 << 3)
236 #define STS_HW_CONDITIONS 0x21
237 #define STS_USB_ID (1 << 2) /* Level status of USB ID */
239 #define BATTERY_RESISTOR 10000
240 #define SIMULATOR_RESISTOR 5000
241 #define BATTERY_DETECT_THRESHOLD ((BATTERY_RESISTOR + SIMULATOR_RESISTOR) / 2)
242 #define CHARGING_CAPACITY_UPDATE_PERIOD (1000 * 60 * 10)
244 /* To get VBUS input limit from twl6030_usb */
245 #if CONFIG_TWL6030_USB
246 extern unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x);
248 static inline unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x)
254 /* Ptr to thermistor table */
255 static const unsigned int fuelgauge_rate[4] = {1, 4, 16, 64};
256 static struct wake_lock chrg_lock;
259 struct twl6030_bci_device_info {
286 u8 watchdog_duration;
287 u16 current_avg_interval;
288 u16 monitoring_interval;
289 unsigned int min_vbus;
291 struct twl4030_bci_platform_data *platform_data;
293 unsigned int charger_incurrentmA;
294 unsigned int charger_outcurrentmA;
295 unsigned long usb_max_power;
298 unsigned int capacity;
299 unsigned int capacity_debounce_count;
300 unsigned long ac_next_refresh;
301 unsigned int prev_capacity;
302 unsigned int wakelock_enabled;
304 struct power_supply bat;
305 struct power_supply usb;
306 struct power_supply ac;
307 struct power_supply bk_bat;
309 struct otg_transceiver *otg;
310 struct notifier_block nb;
311 struct work_struct usb_work;
313 struct delayed_work twl6030_bci_monitor_work;
314 struct delayed_work twl6030_current_avg_work;
316 unsigned long features;
321 /* max scale current based on sense resitor */
322 int current_max_scale;
325 static BLOCKING_NOTIFIER_HEAD(notifier_list);
326 extern u32 wakeup_timer_seconds;
328 static void twl6030_config_min_vbus_reg(struct twl6030_bci_device_info *di,
334 /* not required on TWL6032 */
335 if (di->features & TWL6032_SUBCLASS)
338 if (value > 4760 || value < 4200) {
339 dev_dbg(di->dev, "invalid min vbus\n");
343 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
347 rd_reg = rd_reg & 0x1F;
348 rd_reg = rd_reg | (((value - 4200)/80) << BUCK_VTH_SHIFT);
349 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, rd_reg,
355 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
358 static void twl6030_config_iterm_reg(struct twl6030_bci_device_info *di,
359 unsigned int term_currentmA)
363 if ((term_currentmA > 400) || (term_currentmA < 50)) {
364 dev_dbg(di->dev, "invalid termination current\n");
368 term_currentmA = ((term_currentmA - 50)/50) << 5;
369 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, term_currentmA,
372 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
375 static unsigned int twl6030_get_iterm_reg(struct twl6030_bci_device_info *di)
378 unsigned int currentmA;
381 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_CTRL2);
383 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
386 currentmA = 50 + (val >> 5) * 50;
391 static void twl6030_config_voreg_reg(struct twl6030_bci_device_info *di,
392 unsigned int voltagemV)
396 if ((voltagemV < 3500) || (voltagemV > 4760)) {
397 dev_dbg(di->dev, "invalid charger_voltagemV\n");
401 voltagemV = (voltagemV - 3500) / 20;
402 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
405 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
408 static unsigned int twl6030_get_voreg_reg(struct twl6030_bci_device_info *di)
411 unsigned int voltagemV;
414 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_VOREG);
416 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
419 voltagemV = 3500 + (val * 20);
424 static void twl6030_config_vichrg_reg(struct twl6030_bci_device_info *di,
425 unsigned int currentmA)
429 if ((currentmA >= 300) && (currentmA <= 450))
430 currentmA = (currentmA - 300) / 50;
431 else if ((currentmA >= 500) && (currentmA <= 1500))
432 currentmA = (currentmA - 500) / 100 + 4;
434 dev_dbg(di->dev, "invalid charger_currentmA\n");
438 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
441 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
444 static void twl6030_config_cinlimit_reg(struct twl6030_bci_device_info *di,
445 unsigned int currentmA)
449 if ((currentmA >= 50) && (currentmA <= 750))
450 currentmA = (currentmA - 50) / 50;
451 else if ((currentmA > 750) && (currentmA <= 1500) &&
452 (di->features & TWL6032_SUBCLASS)) {
453 currentmA = ((currentmA % 100) ? 0x30 : 0x20) +
454 ((currentmA - 100) / 100);
455 } else if (currentmA < 50) {
456 dev_dbg(di->dev, "invalid input current limit\n");
459 /* This is no current limit */
463 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
464 CHARGERUSB_CINLIMIT);
466 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
469 static void twl6030_config_limit1_reg(struct twl6030_bci_device_info *di,
470 unsigned int voltagemV)
474 if ((voltagemV < 3500) || (voltagemV > 4760)) {
475 dev_dbg(di->dev, "invalid max_charger_voltagemV\n");
479 voltagemV = (voltagemV - 3500) / 20;
480 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
481 CHARGERUSB_CTRLLIMIT1);
483 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
486 static unsigned int twl6030_get_limit1_reg(struct twl6030_bci_device_info *di)
489 unsigned int voltagemV;
492 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
493 CHARGERUSB_CTRLLIMIT1);
495 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
498 voltagemV = 3500 + (val * 20);
503 static void twl6030_config_limit2_reg(struct twl6030_bci_device_info *di,
504 unsigned int currentmA)
508 if ((currentmA >= 300) && (currentmA <= 450))
509 currentmA = (currentmA - 300) / 50;
510 else if ((currentmA >= 500) && (currentmA <= 1500))
511 currentmA = (currentmA - 500) / 100 + 4;
513 dev_dbg(di->dev, "invalid max_charger_currentmA\n");
517 currentmA |= LOCK_LIMIT;
518 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
519 CHARGERUSB_CTRLLIMIT2);
521 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
524 static const int vichrg[] = {
525 300, 350, 400, 450, 500, 600, 700, 800,
526 900, 1000, 1100, 1200, 1300, 1400, 1500, 300
529 static unsigned int twl6030_get_limit2_reg(struct twl6030_bci_device_info *di)
532 unsigned int currentmA;
535 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
536 CHARGERUSB_CTRLLIMIT2);
538 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
541 currentmA = vichrg[val & 0xF];
547 * Return channel value
550 static int twl6030_get_gpadc_conversion(struct twl6030_bci_device_info *di,
553 struct twl6030_gpadc_request req;
557 req.channels = (1 << channel_no);
558 req.method = TWL6030_GPADC_SW2;
561 ret = twl6030_gpadc_conversion(&req);
565 if (req.rbuf[channel_no] > 0)
566 temp = req.rbuf[channel_no];
571 static int is_battery_present(struct twl6030_bci_device_info *di)
574 static unsigned int current_src_val;
577 * Prevent charging on batteries were id resistor is
580 val = twl6030_get_gpadc_conversion(di, 0);
583 * twl6030_get_gpadc_conversion for
584 * 6030 return resistance, for 6032 - voltage and
585 * it should be converted to resistance before
588 if (!current_src_val) {
591 if (twl_i2c_read_u8(TWL_MODULE_MADC, ®,
593 pr_err("%s: Error reading TWL6030_GPADC_CTRL\n",
596 current_src_val = (reg & GPADC_CTRL_ISOURCE_EN) ?
601 val = (val * 1000) / current_src_val;
603 if (val < BATTERY_DETECT_THRESHOLD)
609 static void twl6030_stop_usb_charger(struct twl6030_bci_device_info *di)
614 if (di->use_hw_charger) {
615 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, ®,
620 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
628 di->charger_source = 0;
629 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
631 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
635 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
638 static void twl6030_start_usb_charger(struct twl6030_bci_device_info *di)
643 if (di->use_hw_charger) {
644 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, ®,
650 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
658 if (!is_battery_present(di)) {
659 dev_dbg(di->dev, "BATTERY NOT DETECTED!\n");
663 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
666 dev_dbg(di->dev, "USB input current limit %dmA\n",
667 di->charger_incurrentmA);
668 if (di->charger_incurrentmA < 50) {
669 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
670 0, CONTROLLER_CTRL1);
677 twl6030_config_vichrg_reg(di, di->charger_outcurrentmA);
678 twl6030_config_cinlimit_reg(di, di->charger_incurrentmA);
679 twl6030_config_voreg_reg(di, di->platform_data->max_bat_voltagemV);
680 twl6030_config_iterm_reg(di, di->platform_data->termination_currentmA);
682 if (di->charger_incurrentmA >= 50) {
683 reg = CONTROLLER_CTRL1_EN_CHARGER;
685 if (di->use_power_path)
686 reg |= CONTROLLER_CTRL1_EN_LINCH;
688 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
693 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
697 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
700 static void twl6030_stop_ac_charger(struct twl6030_bci_device_info *di)
705 di->charger_source = 0;
706 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
707 events = BQ2415x_STOP_CHARGING;
709 if (di->use_hw_charger)
712 blocking_notifier_call_chain(¬ifier_list, events, NULL);
714 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
716 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
718 if (di->wakelock_enabled)
719 wake_unlock(&chrg_lock);
722 static void twl6030_start_ac_charger(struct twl6030_bci_device_info *di)
727 if (!is_battery_present(di)) {
728 dev_dbg(di->dev, "BATTERY NOT DETECTED!\n");
731 dev_dbg(di->dev, "AC charger detected\n");
732 di->charger_source = POWER_SUPPLY_TYPE_MAINS;
733 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
734 events = BQ2415x_START_CHARGING;
736 if (di->use_hw_charger)
739 blocking_notifier_call_chain(¬ifier_list, events, NULL);
741 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
742 CONTROLLER_CTRL1_EN_CHARGER |
743 CONTROLLER_CTRL1_SEL_CHARGER,
746 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
748 if (di->wakelock_enabled)
749 wake_lock(&chrg_lock);
752 static void twl6030_stop_charger(struct twl6030_bci_device_info *di)
754 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
755 twl6030_stop_ac_charger(di);
756 else if (di->charger_source == POWER_SUPPLY_TYPE_USB)
757 twl6030_stop_usb_charger(di);
760 static void twl6032_charger_ctrl_interrupt(struct twl6030_bci_device_info *di)
762 u8 stat_toggle, stat_reset, stat_set = 0;
763 u8 present_state = 0, linear_state;
764 u8 present_status = 0;
767 err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_state,
770 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
775 err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_status,
776 CHARGERUSB_INT_STATUS);
778 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
783 linear_state = di->linear_stat;
785 stat_toggle = linear_state ^ present_state;
786 stat_set = stat_toggle & present_state;
787 stat_reset = stat_toggle & linear_state;
788 di->linear_stat = present_state;
790 if (stat_set & LINEAR_CHRG_STS_CRYSTL_OSC_OK)
791 dev_dbg(di->dev, "Linear status: CRYSTAL OSC OK\n");
792 if (present_state & LINEAR_CHRG_STS_END_OF_CHARGE) {
793 dev_dbg(di->dev, "Linear status: END OF CHARGE\n");
794 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
796 if (present_status & EN_LINCH) {
797 dev_dbg(di->dev, "Linear status: START OF CHARGE\n");
798 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
801 if (stat_set & LINEAR_CHRG_STS_VBATOV) {
802 dev_dbg(di->dev, "Linear Status: VBATOV\n");
803 di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
805 if (stat_reset & LINEAR_CHRG_STS_VBATOV) {
806 dev_dbg(di->dev, "Linear Status: VBATOV\n");
807 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
810 if (stat_set & LINEAR_CHRG_STS_VSYSOV)
811 dev_dbg(di->dev, "Linear Status: VSYSOV\n");
812 if (stat_set & LINEAR_CHRG_STS_DPPM_STS)
813 dev_dbg(di->dev, "Linear Status: DPPM STS\n");
814 if (stat_set & LINEAR_CHRG_STS_CV_STS)
815 dev_dbg(di->dev, "Linear Status: CV STS\n");
816 if (stat_set & LINEAR_CHRG_STS_CC_STS)
817 dev_dbg(di->dev, "Linear Status: CC STS\n");
821 * Interrupt service routine
823 * Attends to TWL 6030 power module interruptions events, specifically
824 * USB_PRES (USB charger presence) CHG_PRES (AC charger presence) events
827 static irqreturn_t twl6030charger_ctrl_interrupt(int irq, void *_di)
829 struct twl6030_bci_device_info *di = _di;
831 int charger_fault = 0;
833 u8 stat_toggle, stat_reset, stat_set = 0;
835 u8 present_charge_state = 0;
836 u8 ac_or_vbus, no_ac_and_vbus = 0;
837 u8 hw_state = 0, temp = 0;
839 /* read charger controller_stat1 */
840 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &present_charge_state,
844 * Since present state read failed, charger_state is no
845 * longer valid, reset to zero inorder to detect next events
851 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
855 charge_state = di->stat1;
857 stat_toggle = charge_state ^ present_charge_state;
858 stat_set = stat_toggle & present_charge_state;
859 stat_reset = stat_toggle & charge_state;
861 no_ac_and_vbus = !((present_charge_state) & (VBUS_DET | VAC_DET));
862 ac_or_vbus = charge_state & (VBUS_DET | VAC_DET);
863 if (no_ac_and_vbus && ac_or_vbus) {
864 di->charger_source = 0;
865 dev_dbg(di->dev, "No Charging source\n");
866 /* disable charging when no source present */
869 charge_state = present_charge_state;
870 di->stat1 = present_charge_state;
871 if ((charge_state & VAC_DET) &&
872 (charge_state & CONTROLLER_STAT1_EXTCHRG_STATZ)) {
873 events = BQ2415x_CHARGER_FAULT;
874 blocking_notifier_call_chain(¬ifier_list, events, NULL);
877 if (stat_reset & VBUS_DET) {
878 /* On a USB detach, UNMASK VBUS OVP if masked*/
879 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &temp,
880 CHARGERUSB_INT_MASK);
884 if (temp & MASK_MCHARGERUSB_FAULT) {
885 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
886 (temp & ~MASK_MCHARGERUSB_FAULT),
887 CHARGERUSB_INT_MASK);
892 dev_dbg(di->dev, "usb removed\n");
893 twl6030_stop_usb_charger(di);
894 if (present_charge_state & VAC_DET)
895 twl6030_start_ac_charger(di);
899 if (stat_set & VBUS_DET) {
900 /* In HOST mode (ID GROUND) when a device is connected,
901 * Mask VBUS OVP interrupt and do no enable usb
904 if (hw_state & STS_USB_ID) {
905 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
907 CHARGERUSB_INT_MASK);
911 if (!(temp & MASK_MCHARGERUSB_FAULT)) {
912 ret = twl_i2c_write_u8(
913 TWL6030_MODULE_CHARGER,
914 (temp | MASK_MCHARGERUSB_FAULT),
915 CHARGERUSB_INT_MASK);
920 di->usb_online = POWER_SUPPLY_TYPE_USB;
921 if ((present_charge_state & VAC_DET) &&
922 (di->vac_priority == 2))
923 dev_dbg(di->dev, "USB charger detected"
924 ", continue with VAC\n");
927 POWER_SUPPLY_TYPE_USB;
929 POWER_SUPPLY_STATUS_CHARGING;
931 dev_dbg(di->dev, "vbus detect\n");
935 if (stat_reset & VAC_DET) {
937 dev_dbg(di->dev, "vac removed\n");
938 twl6030_stop_ac_charger(di);
939 if (present_charge_state & VBUS_DET) {
940 di->charger_source = POWER_SUPPLY_TYPE_USB;
942 POWER_SUPPLY_STATUS_CHARGING;
943 twl6030_start_usb_charger(di);
946 if (stat_set & VAC_DET) {
947 di->ac_online = POWER_SUPPLY_TYPE_MAINS;
948 if ((present_charge_state & VBUS_DET) &&
949 (di->vac_priority == 3))
951 "AC charger detected"
952 ", continue with VBUS\n");
954 twl6030_start_ac_charger(di);
957 if (stat_set & CONTROLLER_STAT1_FAULT_WDG) {
959 dev_dbg(di->dev, "Fault watchdog fired\n");
961 if (stat_reset & CONTROLLER_STAT1_FAULT_WDG)
962 dev_dbg(di->dev, "Fault watchdog recovered\n");
963 if (stat_set & CONTROLLER_STAT1_BAT_REMOVED)
964 dev_dbg(di->dev, "Battery removed\n");
965 if (stat_reset & CONTROLLER_STAT1_BAT_REMOVED)
966 dev_dbg(di->dev, "Battery inserted\n");
967 if (stat_set & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
968 dev_dbg(di->dev, "Battery temperature overrange\n");
969 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
971 if (stat_reset & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
972 dev_dbg(di->dev, "Battery temperature within range\n");
973 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
975 if (di->features & TWL6032_SUBCLASS)
976 twl6032_charger_ctrl_interrupt(di);
979 twl6030_stop_usb_charger(di);
980 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
981 dev_err(di->dev, "Charger Fault stop charging\n");
984 if (di->capacity != -1)
985 power_supply_changed(&di->bat);
987 cancel_delayed_work(&di->twl6030_bci_monitor_work);
988 schedule_delayed_work(&di->twl6030_bci_monitor_work, 0);
994 static irqreturn_t twl6030charger_fault_interrupt(int irq, void *_di)
996 struct twl6030_bci_device_info *di = _di;
997 int charger_fault = 0;
1000 u8 usb_charge_sts = 0, usb_charge_sts1 = 0, usb_charge_sts2 = 0;
1002 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts,
1003 CHARGERUSB_INT_STATUS);
1007 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts1,
1008 CHARGERUSB_STATUS_INT1);
1012 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts2,
1013 CHARGERUSB_STATUS_INT2);
1017 di->status_int1 = usb_charge_sts1;
1018 di->status_int2 = usb_charge_sts2;
1019 if (usb_charge_sts & CURRENT_TERM_INT)
1020 dev_dbg(di->dev, "USB CURRENT_TERM_INT\n");
1021 if (usb_charge_sts & CHARGERUSB_THMREG)
1022 dev_dbg(di->dev, "USB CHARGERUSB_THMREG\n");
1023 if (usb_charge_sts & CHARGERUSB_FAULT)
1024 dev_dbg(di->dev, "USB CHARGERUSB_FAULT\n");
1026 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TMREG)
1027 dev_dbg(di->dev, "USB CHARGER Thermal regulation activated\n");
1028 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_NO_BAT)
1029 dev_dbg(di->dev, "No Battery Present\n");
1030 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BST_OCP)
1031 dev_dbg(di->dev, "USB CHARGER Boost Over current protection\n");
1032 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1034 dev_dbg(di->dev, "USB CHARGER Thermal Shutdown\n");
1036 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BAT_OVP)
1037 dev_dbg(di->dev, "USB CHARGER Bat Over Voltage Protection\n");
1038 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_POOR_SRC)
1039 dev_dbg(di->dev, "USB CHARGER Poor input source\n");
1040 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1041 dev_dbg(di->dev, "USB CHARGER Sleep mode\n");
1042 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_VBUS_OVP)
1043 dev_dbg(di->dev, "USB CHARGER VBUS over voltage\n");
1045 if (usb_charge_sts2 & CHARGE_DONE) {
1046 di->charge_status = POWER_SUPPLY_STATUS_FULL;
1047 dev_dbg(di->dev, "USB charge done\n");
1049 if (usb_charge_sts2 & CURRENT_TERM)
1050 dev_dbg(di->dev, "USB CURRENT_TERM\n");
1051 if (usb_charge_sts2 & ICCLOOP)
1052 dev_dbg(di->dev, "USB ICCLOOP\n");
1053 if (usb_charge_sts2 & ANTICOLLAPSE)
1054 dev_dbg(di->dev, "USB ANTICOLLAPSE\n");
1056 if (charger_fault) {
1057 twl6030_stop_usb_charger(di);
1058 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1059 dev_err(di->dev, "Charger Fault stop charging\n");
1061 dev_dbg(di->dev, "Charger fault detected STS, INT1, INT2 %x %x %x\n",
1062 usb_charge_sts, usb_charge_sts1, usb_charge_sts2);
1064 power_supply_changed(&di->bat);
1070 * In HW charger mode on 6032 irq routines must only deal with updating
1071 * state of charger. The hardware deals with start/stop conditions
1074 static irqreturn_t twl6032charger_ctrl_interrupt_hw(int irq, void *_di)
1076 struct twl6030_bci_device_info *di = _di;
1078 int charger_stop = 0, end_of_charge = 0;
1081 /* read charger controller_stat1 */
1082 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1087 ret = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &linear,
1092 if (!(stat1 & (VBUS_DET | VAC_DET))) {
1094 di->ac_online = di->usb_online = 0;
1097 if (!(di->usb_online || di->ac_online)) {
1098 if (stat1 & VBUS_DET) {
1100 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1101 } else if (stat1 & VAC_DET) {
1103 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1107 if (stat1 & CONTROLLER_STAT1_FAULT_WDG) {
1109 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1110 dev_dbg(di->dev, "Charger error : Fault watchdog\n");
1112 if (stat1 & CONTROLLER_STAT1_BAT_REMOVED) {
1114 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1115 dev_dbg(di->dev, "Battery removed\n");
1117 if (stat1 & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
1120 "Charger error : Battery temperature overrange\n");
1121 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1124 if ((stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
1125 di->use_power_path) {
1129 if (linear & LINEAR_CHRG_STS_CRYSTL_OSC_OK) {
1130 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1131 dev_dbg(di->dev, "Charger error: CRYSTAL OSC OK\n");
1134 if (linear & LINEAR_CHRG_STS_END_OF_CHARGE) {
1136 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1137 dev_dbg(di->dev, "Charger: Full charge\n");
1140 if (linear & LINEAR_CHRG_STS_VBATOV) {
1141 di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1143 "Charger error : Linear Status: VBATOV\n");
1146 if (linear & LINEAR_CHRG_STS_VSYSOV) {
1147 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1149 "Charger error : Linear Status: VSYSOV\n");
1154 if (!(stat1 & (VBUS_DET | VAC_DET))) {
1155 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1159 POWER_SUPPLY_STATUS_FULL;
1162 POWER_SUPPLY_STATUS_NOT_CHARGING;
1166 power_supply_changed(&di->bat);
1172 static irqreturn_t twl6032charger_fault_interrupt_hw(int irq, void *_di)
1174 struct twl6030_bci_device_info *di = _di;
1175 int charger_stop = 0, charger_start = 0;
1177 u8 sts, sts_int1, sts_int2, stat1;
1179 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts,
1180 CHARGERUSB_INT_STATUS);
1184 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int1,
1185 CHARGERUSB_STATUS_INT1);
1189 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int2,
1190 CHARGERUSB_STATUS_INT2);
1194 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1199 if (sts & EN_LINCH) {
1201 dev_dbg(di->dev, "Charger: EN_LINCH\n");
1205 if ((sts & CURRENT_TERM_INT) && !di->use_power_path) {
1206 dev_dbg(di->dev, "Charger: CURRENT_TERM_INT\n");
1208 if (sts_int2 & CURRENT_TERM) {
1210 dev_dbg(di->dev, "Charger error: CURRENT_TERM\n");
1214 if (sts & CHARGERUSB_STAT) {
1215 dev_dbg(di->dev, "Charger: CHARGEUSB_STAT\n");
1217 if (sts_int2 & ANTICOLLAPSE)
1218 dev_dbg(di->dev, "Charger error: ANTICOLLAPSE\n");
1221 if (sts & CHARGERUSB_THMREG) {
1222 dev_dbg(di->dev, "Charger: CHARGERUSB_THMREG\n");
1224 if (sts_int1 & CHARGERUSB_STATUS_INT1_TMREG)
1225 dev_dbg(di->dev, "Charger error: TMREG\n");
1228 if (sts & CHARGERUSB_FAULT) {
1229 dev_dbg(di->dev, "Charger: CHARGERUSB_FAULT\n");
1233 if (!di->use_power_path) {
1234 if (sts_int1 & CHARGERUSB_STATUS_INT1_NO_BAT) {
1235 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1237 "Charger error : NO_BAT\n");
1239 if (sts_int1 & CHARGERUSB_STATUS_INT1_BAT_OVP) {
1241 POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1242 dev_dbg(di->dev, "Charger error : BAT_OVP\n");
1246 if (sts_int1 & CHARGERUSB_STATUS_INT1_BST_OCP) {
1247 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1248 printk(KERN_ERR "Charger error : BST_OCP\n");
1250 if (sts_int1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1251 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1252 printk(KERN_ERR "Charger error : TH_SHUTD\n");
1254 if (sts_int1 & CHARGERUSB_STATUS_INT1_POOR_SRC) {
1255 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1256 printk(KERN_ERR "Charger error : POOR_SRC\n");
1258 if (sts_int1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1259 dev_dbg(di->dev, "Charger error: SLP_MODE\n");
1261 if (sts_int1 & CHARGERUSB_STATUS_INT1_VBUS_OVP) {
1262 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1263 printk(KERN_ERR "Charger error : VBUS_OVP\n");
1268 if (!(stat1 & (VBUS_DET | VAC_DET)))
1269 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1271 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1275 if (charger_start) {
1276 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1277 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1280 power_supply_changed(&di->bat);
1285 static void twl6030battery_current(struct twl6030_bci_device_info *di)
1290 int current_now = 0;
1292 /* FG_REG_10, 11 is 14 bit signed instantaneous current sample value */
1293 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *)&read_value,
1296 dev_dbg(di->dev, "failed to read FG_REG_10: current_now\n");
1300 temp = ((s16)(read_value << 2) >> 2);
1301 current_now = temp - di->cc_offset;
1303 /* current drawn per sec */
1304 current_now = current_now * fuelgauge_rate[di->fuelgauge_mode];
1305 /* current in mAmperes */
1306 current_now = (current_now * di->current_max_scale) >> 13;
1307 /* current in uAmperes */
1308 current_now = current_now * 1000;
1309 di->current_uA = current_now;
1315 * Setup the twl6030 BCI module to enable backup
1318 static int twl6030backupbatt_setup(void)
1323 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, BBSPOR_CFG);
1327 rd_reg |= BB_CHG_EN;
1328 ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, BBSPOR_CFG);
1334 * Setup the twl6030 BCI module to measure battery
1337 static int twl6030battery_temp_setup(bool enable)
1342 ret = twl_i2c_read_u8(TWL_MODULE_MADC, &rd_reg, TWL6030_GPADC_CTRL);
1347 rd_reg |= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1348 GPADC_CTRL_TEMP1_EN_MONITOR |
1349 GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1351 rd_reg ^= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1352 GPADC_CTRL_TEMP1_EN_MONITOR |
1353 GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1355 ret = twl_i2c_write_u8(TWL_MODULE_MADC, rd_reg, TWL6030_GPADC_CTRL);
1360 static int twl6030battery_voltage_setup(struct twl6030_bci_device_info *di)
1365 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, REG_MISC1);
1369 rd_reg = rd_reg | VAC_MEAS | VBAT_MEAS | BB_MEAS;
1370 ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, REG_MISC1);
1374 ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_VBUS_CTRL_SET);
1378 rd_reg = rd_reg | VBUS_MEAS;
1379 ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_VBUS_CTRL_SET);
1383 ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_ID_CTRL_SET);
1387 rd_reg = rd_reg | ID_MEAS;
1388 ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_ID_CTRL_SET);
1392 if (di->features & TWL6032_SUBCLASS)
1393 ret = twl_i2c_write_u8(TWL_MODULE_MADC,
1394 GPADC_CTRL2_CH18_SCALER_EN,
1395 TWL6030_GPADC_CTRL2);
1400 static int twl6030battery_current_setup(bool enable)
1406 * Writing 0 to REG_TOGGLE1 has no effect, so
1407 * can directly set/reset FG.
1410 reg = FGDITHS | FGS;
1412 reg = FGDITHR | FGR;
1414 ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, reg, REG_TOGGLE1);
1418 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
1423 static enum power_supply_property twl6030_bci_battery_props[] = {
1424 POWER_SUPPLY_PROP_STATUS,
1425 POWER_SUPPLY_PROP_HEALTH,
1426 POWER_SUPPLY_PROP_ONLINE,
1427 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1428 POWER_SUPPLY_PROP_CURRENT_NOW,
1429 POWER_SUPPLY_PROP_CURRENT_AVG,
1430 POWER_SUPPLY_PROP_CAPACITY,
1431 POWER_SUPPLY_PROP_TEMP,
1434 static enum power_supply_property twl6030_usb_props[] = {
1435 POWER_SUPPLY_PROP_ONLINE,
1436 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1439 static enum power_supply_property twl6030_ac_props[] = {
1440 POWER_SUPPLY_PROP_ONLINE,
1441 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1444 static enum power_supply_property twl6030_bk_bci_battery_props[] = {
1445 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1448 static void twl6030_current_avg(struct work_struct *work)
1452 int current_avg_uA = 0;
1454 struct twl6030_bci_device_info *di = container_of(work,
1455 struct twl6030_bci_device_info,
1456 twl6030_current_avg_work.work);
1458 di->charge_n2 = di->charge_n1;
1459 di->timer_n2 = di->timer_n1;
1461 /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1462 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1467 * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1468 * accumulates instantaneous current value
1470 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1474 /* FG_REG_08, 09 is 10 bit signed calibration offset value */
1475 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &cc_offset,
1479 cc_offset = ((s16)(cc_offset << 6) >> 6);
1480 di->cc_offset = cc_offset;
1482 samples = di->timer_n1 - di->timer_n2;
1483 /* check for timer overflow */
1484 if (di->timer_n1 < di->timer_n2)
1485 samples = samples + (1 << 24);
1487 /* offset is accumulative over number of samples */
1488 cc_offset = cc_offset * samples;
1490 current_avg_uA = ((di->charge_n1 - di->charge_n2 - cc_offset)
1491 * di->current_max_scale) /
1492 fuelgauge_rate[di->fuelgauge_mode];
1493 /* clock is a fixed 32Khz */
1494 current_avg_uA >>= 15;
1496 /* Correct for the fuelguage sampling rate */
1497 samples /= fuelgauge_rate[di->fuelgauge_mode] * 4;
1500 * Only update the current average if we have had a valid number
1501 * of samples in the accumulation.
1504 current_avg_uA = current_avg_uA / samples;
1505 di->current_avg_uA = current_avg_uA * 1000;
1508 schedule_delayed_work(&di->twl6030_current_avg_work,
1509 msecs_to_jiffies(1000 * di->current_avg_interval));
1512 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1515 static int capacity_changed(struct twl6030_bci_device_info *di)
1517 int curr_capacity = di->capacity;
1518 int charger_source = di->charger_source;
1519 int charging_disabled = 0;
1521 /* Because system load is always greater than
1522 * termination current, we will never get a CHARGE DONE
1523 * int from BQ. And charging will alwys be in progress.
1524 * We consider Vbat>3900 to be a full battery.
1525 * Since Voltage measured during charging is Voreg ~4.2v,
1526 * we dont update capacity if we are charging.
1529 /* if it has been more than 10 minutes since our last update
1530 * and we are charging we force a update.
1533 if (time_after(jiffies, di->ac_next_refresh)
1534 && (di->charger_source != POWER_SUPPLY_TYPE_BATTERY)) {
1536 charging_disabled = 1;
1537 di->ac_next_refresh = jiffies +
1538 msecs_to_jiffies(CHARGING_CAPACITY_UPDATE_PERIOD);
1541 /* We have to disable charging to read correct
1544 twl6030_stop_charger(di);
1545 /*voltage setteling time*/
1548 di->voltage_mV = twl6030_get_gpadc_conversion(di,
1549 di->gpadc_vbat_chnl);
1552 /* Setting the capacity level only makes sense when on
1553 * the battery is powering the board.
1555 if (di->charge_status == POWER_SUPPLY_STATUS_DISCHARGING) {
1556 if (di->voltage_mV < 3500)
1558 else if (di->voltage_mV < 3600 && di->voltage_mV >= 3500)
1560 else if (di->voltage_mV < 3700 && di->voltage_mV >= 3600)
1562 else if (di->voltage_mV < 3800 && di->voltage_mV >= 3700)
1564 else if (di->voltage_mV < 3900 && di->voltage_mV >= 3800)
1566 else if (di->voltage_mV >= 3900)
1567 curr_capacity = 100;
1570 /* if we disabled charging to check capacity,
1571 * enable it again after we read the
1574 if (charging_disabled) {
1575 if (charger_source == POWER_SUPPLY_TYPE_MAINS)
1576 twl6030_start_ac_charger(di);
1577 else if (charger_source == POWER_SUPPLY_TYPE_USB)
1578 twl6030_start_usb_charger(di);
1581 /* if battery is not present we assume it is on battery simulator and
1582 * current capacity is set to 100%
1584 if (!is_battery_present(di))
1585 curr_capacity = 100;
1587 /* Debouncing of voltage change. */
1588 if (di->capacity == -1) {
1589 di->capacity = curr_capacity;
1590 di->capacity_debounce_count = 0;
1594 if (curr_capacity != di->prev_capacity) {
1595 di->prev_capacity = curr_capacity;
1596 di->capacity_debounce_count = 0;
1597 } else if (++di->capacity_debounce_count >= 4) {
1598 di->capacity = curr_capacity;
1599 di->capacity_debounce_count = 0;
1606 static int twl6030_set_watchdog(struct twl6030_bci_device_info *di, int val)
1608 di->watchdog_duration = val;
1610 dev_dbg(di->dev, "Watchdog reset %d", val);
1612 return twl_i2c_write_u8(TWL6030_MODULE_CHARGER, val, CONTROLLER_WDG);
1616 static void twl6030_bci_battery_work(struct work_struct *work)
1618 struct twl6030_bci_device_info *di = container_of(work,
1619 struct twl6030_bci_device_info, twl6030_bci_monitor_work.work);
1620 struct twl6030_gpadc_request req;
1625 /* Kick the charger watchdog */
1626 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING)
1627 twl6030_set_watchdog(di, di->watchdog_duration);
1629 req.method = TWL6030_GPADC_SW2;
1630 req.channels = (1 << 1) | (1 << di->gpadc_vbat_chnl) | (1 << 8);
1634 ret = twl6030_gpadc_conversion(&req);
1636 schedule_delayed_work(&di->twl6030_bci_monitor_work,
1637 msecs_to_jiffies(1000 * di->monitoring_interval));
1639 dev_dbg(di->dev, "gpadc conversion failed: %d\n", ret);
1643 if (req.rbuf[di->gpadc_vbat_chnl] > 0)
1644 di->voltage_mV = req.rbuf[di->gpadc_vbat_chnl];
1646 if (req.rbuf[8] > 0)
1647 di->bk_voltage_mV = req.rbuf[8];
1649 if (di->platform_data->battery_tmp_tbl == NULL)
1652 adc_code = req.rbuf[1];
1653 for (temp = 0; temp < di->platform_data->tblsize; temp++) {
1654 if (adc_code >= di->platform_data->
1655 battery_tmp_tbl[temp])
1659 /* first 2 values are for negative temperature */
1660 di->temp_C = (temp - 2); /* in degrees Celsius */
1662 if (capacity_changed(di))
1663 power_supply_changed(&di->bat);
1666 static void twl6030_current_mode_changed(struct twl6030_bci_device_info *di)
1670 /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1671 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1676 * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1677 * accumulates instantaneous current value
1679 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1684 cancel_delayed_work(&di->twl6030_current_avg_work);
1685 schedule_delayed_work(&di->twl6030_current_avg_work,
1686 msecs_to_jiffies(1000 * di->current_avg_interval));
1689 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1692 static void twl6030_work_interval_changed(struct twl6030_bci_device_info *di)
1694 cancel_delayed_work(&di->twl6030_bci_monitor_work);
1695 schedule_delayed_work(&di->twl6030_bci_monitor_work,
1696 msecs_to_jiffies(1000 * di->monitoring_interval));
1699 #define to_twl6030_bci_device_info(x) container_of((x), \
1700 struct twl6030_bci_device_info, bat);
1702 static void twl6030_bci_battery_external_power_changed(struct power_supply *psy)
1704 struct twl6030_bci_device_info *di = to_twl6030_bci_device_info(psy);
1706 cancel_delayed_work(&di->twl6030_bci_monitor_work);
1707 schedule_delayed_work(&di->twl6030_bci_monitor_work, 0);
1710 #define to_twl6030_ac_device_info(x) container_of((x), \
1711 struct twl6030_bci_device_info, ac);
1713 static int twl6030_ac_get_property(struct power_supply *psy,
1714 enum power_supply_property psp,
1715 union power_supply_propval *val)
1717 struct twl6030_bci_device_info *di = to_twl6030_ac_device_info(psy);
1720 case POWER_SUPPLY_PROP_ONLINE:
1721 val->intval = di->ac_online;
1723 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1724 val->intval = twl6030_get_gpadc_conversion(di, 9) * 1000;
1733 #define to_twl6030_usb_device_info(x) container_of((x), \
1734 struct twl6030_bci_device_info, usb);
1736 static int twl6030_usb_get_property(struct power_supply *psy,
1737 enum power_supply_property psp,
1738 union power_supply_propval *val)
1740 struct twl6030_bci_device_info *di = to_twl6030_usb_device_info(psy);
1743 case POWER_SUPPLY_PROP_ONLINE:
1744 val->intval = di->usb_online;
1746 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1747 val->intval = twl6030_get_gpadc_conversion(di, 10) * 1000;
1756 #define to_twl6030_bk_bci_device_info(x) container_of((x), \
1757 struct twl6030_bci_device_info, bk_bat);
1759 static int twl6030_bk_bci_battery_get_property(struct power_supply *psy,
1760 enum power_supply_property psp,
1761 union power_supply_propval *val)
1763 struct twl6030_bci_device_info *di = to_twl6030_bk_bci_device_info(psy);
1766 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1767 val->intval = di->bk_voltage_mV * 1000;
1776 static int twl6030_bci_battery_get_property(struct power_supply *psy,
1777 enum power_supply_property psp,
1778 union power_supply_propval *val)
1780 struct twl6030_bci_device_info *di;
1782 di = to_twl6030_bci_device_info(psy);
1785 case POWER_SUPPLY_PROP_STATUS:
1786 val->intval = di->charge_status;
1788 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1789 di->voltage_mV = twl6030_get_gpadc_conversion(di,
1790 di->gpadc_vbat_chnl);
1791 val->intval = di->voltage_mV * 1000;
1793 case POWER_SUPPLY_PROP_CURRENT_NOW:
1794 twl6030battery_current(di);
1795 val->intval = di->current_uA;
1797 case POWER_SUPPLY_PROP_TEMP:
1798 val->intval = di->temp_C;
1800 case POWER_SUPPLY_PROP_ONLINE:
1801 val->intval = di->charger_source;
1803 case POWER_SUPPLY_PROP_CURRENT_AVG:
1804 val->intval = di->current_avg_uA;
1806 case POWER_SUPPLY_PROP_HEALTH:
1807 val->intval = di->bat_health;
1809 case POWER_SUPPLY_PROP_CAPACITY:
1810 val->intval = di->capacity;
1818 int twl6030_register_notifier(struct notifier_block *nb,
1819 unsigned int events)
1821 return blocking_notifier_chain_register(¬ifier_list, nb);
1823 EXPORT_SYMBOL_GPL(twl6030_register_notifier);
1825 int twl6030_unregister_notifier(struct notifier_block *nb,
1826 unsigned int events)
1828 return blocking_notifier_chain_unregister(¬ifier_list, nb);
1830 EXPORT_SYMBOL_GPL(twl6030_unregister_notifier);
1832 static void twl6030_usb_charger_work(struct work_struct *work)
1834 struct twl6030_bci_device_info *di =
1835 container_of(work, struct twl6030_bci_device_info, usb_work);
1837 switch (di->event) {
1838 case USB_EVENT_CHARGER:
1839 /* POWER_SUPPLY_TYPE_USB_DCP */
1840 di->usb_online = POWER_SUPPLY_TYPE_USB_DCP;
1841 di->charger_incurrentmA = 1800;
1843 case USB_EVENT_VBUS:
1844 switch (di->usb_online) {
1845 case POWER_SUPPLY_TYPE_USB_CDP:
1847 * Only 500mA here or high speed chirp
1848 * handshaking may break
1850 di->charger_incurrentmA = 500;
1851 case POWER_SUPPLY_TYPE_USB:
1855 case USB_EVENT_NONE:
1857 di->charger_incurrentmA = 0;
1859 case USB_EVENT_ENUMERATED:
1860 if (di->usb_online == POWER_SUPPLY_TYPE_USB_CDP)
1861 di->charger_incurrentmA = 560;
1863 di->charger_incurrentmA = di->usb_max_power;
1868 twl6030_start_usb_charger(di);
1869 power_supply_changed(&di->usb);
1872 static int twl6030_usb_notifier_call(struct notifier_block *nb,
1873 unsigned long event, void *data)
1875 struct twl6030_bci_device_info *di =
1876 container_of(nb, struct twl6030_bci_device_info, nb);
1880 case USB_EVENT_VBUS:
1881 di->usb_online = *((unsigned int *) data);
1883 case USB_EVENT_ENUMERATED:
1884 di->usb_max_power = *((unsigned int *) data);
1886 case USB_EVENT_CHARGER:
1887 case USB_EVENT_NONE:
1894 schedule_work(&di->usb_work);
1899 static ssize_t set_fg_mode(struct device *dev,
1900 struct device_attribute *attr, const char *buf, size_t count)
1905 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1907 if ((strict_strtol(buf, 10, &val) < 0) || (val > 3))
1909 di->fuelgauge_mode = val;
1910 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, (val << 6) | CC_CAL_EN,
1914 twl6030_current_mode_changed(di);
1918 static ssize_t show_fg_mode(struct device *dev,
1919 struct device_attribute *attr, char *buf)
1922 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1924 val = di->fuelgauge_mode;
1925 return sprintf(buf, "%d\n", val);
1928 static ssize_t set_charge_src(struct device *dev,
1929 struct device_attribute *attr, const char *buf, size_t count)
1933 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1935 if ((strict_strtol(buf, 10, &val) < 0) || (val < 2) || (val > 3))
1937 di->vac_priority = val;
1941 static ssize_t show_charge_src(struct device *dev,
1942 struct device_attribute *attr, char *buf)
1945 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1947 val = di->vac_priority;
1948 return sprintf(buf, "%d\n", val);
1951 static ssize_t show_vbus_voltage(struct device *dev,
1952 struct device_attribute *attr, char *buf)
1955 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1957 val = twl6030_get_gpadc_conversion(di, 10);
1959 return sprintf(buf, "%d\n", val);
1962 static ssize_t show_id_level(struct device *dev, struct device_attribute *attr,
1966 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1968 val = twl6030_get_gpadc_conversion(di, 14);
1970 return sprintf(buf, "%d\n", val);
1973 static ssize_t set_watchdog(struct device *dev,
1974 struct device_attribute *attr, const char *buf, size_t count)
1979 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1981 if ((strict_strtol(buf, 10, &val) < 0) || (val < 1) || (val > 127))
1983 ret = twl6030_set_watchdog(di, val);
1990 static ssize_t show_watchdog(struct device *dev,
1991 struct device_attribute *attr, char *buf)
1994 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
1996 val = di->watchdog_duration;
1997 return sprintf(buf, "%d\n", val);
2000 static ssize_t show_fg_counter(struct device *dev,
2001 struct device_attribute *attr, char *buf)
2006 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_counter,
2010 return sprintf(buf, "%d\n", fg_counter);
2013 static ssize_t show_fg_accumulator(struct device *dev,
2014 struct device_attribute *attr, char *buf)
2019 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_accum,
2024 return sprintf(buf, "%ld\n", fg_accum);
2027 static ssize_t show_fg_offset(struct device *dev,
2028 struct device_attribute *attr, char *buf)
2033 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_offset,
2037 fg_offset = ((s16)(fg_offset << 6) >> 6);
2039 return sprintf(buf, "%d\n", fg_offset);
2042 static ssize_t set_fg_clear(struct device *dev, struct device_attribute *attr,
2043 const char *buf, size_t count)
2049 if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2051 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_AUTOCLEAR,
2059 static ssize_t set_fg_cal(struct device *dev, struct device_attribute *attr,
2060 const char *buf, size_t count)
2066 if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2068 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
2075 static ssize_t set_charging(struct device *dev, struct device_attribute *attr,
2076 const char *buf, size_t count)
2079 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2081 if (strncmp(buf, "startac", 7) == 0) {
2082 if (di->charger_source == POWER_SUPPLY_TYPE_USB)
2083 twl6030_stop_usb_charger(di);
2084 twl6030_start_ac_charger(di);
2085 } else if (strncmp(buf, "startusb", 8) == 0) {
2086 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
2087 twl6030_stop_ac_charger(di);
2088 di->charger_source = POWER_SUPPLY_TYPE_USB;
2089 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
2090 twl6030_start_usb_charger(di);
2091 } else if (strncmp(buf, "stop" , 4) == 0)
2092 twl6030_stop_charger(di);
2099 static ssize_t set_regulation_voltage(struct device *dev,
2100 struct device_attribute *attr, const char *buf, size_t count)
2104 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2106 if ((strict_strtol(buf, 10, &val) < 0) || (val < 3500)
2107 || (val > di->platform_data->max_charger_voltagemV))
2109 di->platform_data->max_bat_voltagemV = val;
2110 twl6030_config_voreg_reg(di, val);
2115 static ssize_t show_regulation_voltage(struct device *dev,
2116 struct device_attribute *attr, char *buf)
2119 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2121 val = di->platform_data->max_bat_voltagemV;
2122 return sprintf(buf, "%u\n", val);
2125 static ssize_t set_termination_current(struct device *dev,
2126 struct device_attribute *attr, const char *buf, size_t count)
2130 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2132 if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 400))
2134 di->platform_data->termination_currentmA = val;
2135 twl6030_config_iterm_reg(di, val);
2140 static ssize_t show_termination_current(struct device *dev,
2141 struct device_attribute *attr, char *buf)
2144 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2146 val = di->platform_data->termination_currentmA;
2147 return sprintf(buf, "%u\n", val);
2150 static ssize_t set_cin_limit(struct device *dev,
2151 struct device_attribute *attr, const char *buf, size_t count)
2155 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2157 if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 1500))
2159 di->charger_incurrentmA = val;
2160 twl6030_config_cinlimit_reg(di, val);
2165 static ssize_t show_cin_limit(struct device *dev, struct device_attribute *attr,
2169 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2171 val = di->charger_incurrentmA;
2172 return sprintf(buf, "%u\n", val);
2175 static ssize_t set_charge_current(struct device *dev,
2176 struct device_attribute *attr, const char *buf, size_t count)
2180 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2182 if ((strict_strtol(buf, 10, &val) < 0) || (val < 300)
2183 || (val > di->platform_data->max_charger_currentmA))
2185 di->charger_outcurrentmA = val;
2186 twl6030_config_vichrg_reg(di, val);
2191 static ssize_t show_charge_current(struct device *dev,
2192 struct device_attribute *attr, char *buf)
2195 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2197 val = di->charger_outcurrentmA;
2198 return sprintf(buf, "%u\n", val);
2201 static ssize_t set_min_vbus(struct device *dev, struct device_attribute *attr,
2202 const char *buf, size_t count)
2206 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2208 if ((strict_strtol(buf, 10, &val) < 0) || (val < 4200) || (val > 4760))
2211 twl6030_config_min_vbus_reg(di, val);
2216 static ssize_t show_min_vbus(struct device *dev, struct device_attribute *attr,
2220 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2223 return sprintf(buf, "%u\n", val);
2226 static ssize_t set_current_avg_interval(struct device *dev,
2227 struct device_attribute *attr, const char *buf, size_t count)
2231 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2233 if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2235 di->current_avg_interval = val;
2236 twl6030_current_mode_changed(di);
2241 static ssize_t show_current_avg_interval(struct device *dev,
2242 struct device_attribute *attr, char *buf)
2245 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2247 val = di->current_avg_interval;
2248 return sprintf(buf, "%u\n", val);
2251 static ssize_t set_wakelock_enable(struct device *dev,
2252 struct device_attribute *attr, const char *buf, size_t count)
2256 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2258 if ((strict_strtol(buf, 10, &val) < 0) || (val < 0) || (val > 1))
2261 if ((val) && (di->charger_source == POWER_SUPPLY_TYPE_MAINS))
2262 wake_lock(&chrg_lock);
2264 wake_unlock(&chrg_lock);
2266 di->wakelock_enabled = val;
2270 static ssize_t show_wakelock_enable(struct device *dev,
2271 struct device_attribute *attr, char *buf)
2274 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2276 val = di->wakelock_enabled;
2277 return sprintf(buf, "%u\n", val);
2280 static ssize_t set_monitoring_interval(struct device *dev,
2281 struct device_attribute *attr, const char *buf, size_t count)
2285 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2287 if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2289 di->monitoring_interval = val;
2290 twl6030_work_interval_changed(di);
2295 static ssize_t show_monitoring_interval(struct device *dev,
2296 struct device_attribute *attr, char *buf)
2299 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2301 val = di->monitoring_interval;
2302 return sprintf(buf, "%u\n", val);
2305 static ssize_t show_bsi(struct device *dev,
2306 struct device_attribute *attr, char *buf)
2309 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2311 val = twl6030_get_gpadc_conversion(di, 0);
2312 return sprintf(buf, "%d\n", val);
2315 static ssize_t show_stat1(struct device *dev,
2316 struct device_attribute *attr, char *buf)
2319 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2322 return sprintf(buf, "%u\n", val);
2325 static ssize_t show_status_int1(struct device *dev,
2326 struct device_attribute *attr, char *buf)
2329 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2331 val = di->status_int1;
2332 return sprintf(buf, "%u\n", val);
2335 static ssize_t show_status_int2(struct device *dev,
2336 struct device_attribute *attr, char *buf)
2339 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2341 val = di->status_int2;
2342 return sprintf(buf, "%u\n", val);
2345 static DEVICE_ATTR(fg_mode, S_IWUSR | S_IRUGO, show_fg_mode, set_fg_mode);
2346 static DEVICE_ATTR(charge_src, S_IWUSR | S_IRUGO, show_charge_src,
2348 static DEVICE_ATTR(vbus_voltage, S_IRUGO, show_vbus_voltage, NULL);
2349 static DEVICE_ATTR(id_level, S_IRUGO, show_id_level, NULL);
2350 static DEVICE_ATTR(watchdog, S_IWUSR | S_IRUGO, show_watchdog, set_watchdog);
2351 static DEVICE_ATTR(fg_counter, S_IRUGO, show_fg_counter, NULL);
2352 static DEVICE_ATTR(fg_accumulator, S_IRUGO, show_fg_accumulator, NULL);
2353 static DEVICE_ATTR(fg_offset, S_IRUGO, show_fg_offset, NULL);
2354 static DEVICE_ATTR(fg_clear, S_IWUSR, NULL, set_fg_clear);
2355 static DEVICE_ATTR(fg_cal, S_IWUSR, NULL, set_fg_cal);
2356 static DEVICE_ATTR(charging, S_IWUSR | S_IRUGO, NULL, set_charging);
2357 static DEVICE_ATTR(regulation_voltage, S_IWUSR | S_IRUGO,
2358 show_regulation_voltage, set_regulation_voltage);
2359 static DEVICE_ATTR(termination_current, S_IWUSR | S_IRUGO,
2360 show_termination_current, set_termination_current);
2361 static DEVICE_ATTR(cin_limit, S_IWUSR | S_IRUGO, show_cin_limit,
2363 static DEVICE_ATTR(charge_current, S_IWUSR | S_IRUGO, show_charge_current,
2364 set_charge_current);
2365 static DEVICE_ATTR(min_vbus, S_IWUSR | S_IRUGO, show_min_vbus, set_min_vbus);
2366 static DEVICE_ATTR(monitoring_interval, S_IWUSR | S_IRUGO,
2367 show_monitoring_interval, set_monitoring_interval);
2368 static DEVICE_ATTR(current_avg_interval, S_IWUSR | S_IRUGO,
2369 show_current_avg_interval, set_current_avg_interval);
2370 static DEVICE_ATTR(wakelock_enable, S_IWUSR | S_IRUGO,
2371 show_wakelock_enable, set_wakelock_enable);
2372 static DEVICE_ATTR(bsi, S_IRUGO, show_bsi, NULL);
2373 static DEVICE_ATTR(stat1, S_IRUGO, show_stat1, NULL);
2374 static DEVICE_ATTR(status_int1, S_IRUGO, show_status_int1, NULL);
2375 static DEVICE_ATTR(status_int2, S_IRUGO, show_status_int2, NULL);
2377 static struct attribute *twl6030_bci_attributes[] = {
2378 &dev_attr_fg_mode.attr,
2379 &dev_attr_charge_src.attr,
2380 &dev_attr_vbus_voltage.attr,
2381 &dev_attr_id_level.attr,
2382 &dev_attr_watchdog.attr,
2383 &dev_attr_fg_counter.attr,
2384 &dev_attr_fg_accumulator.attr,
2385 &dev_attr_fg_offset.attr,
2386 &dev_attr_fg_clear.attr,
2387 &dev_attr_fg_cal.attr,
2388 &dev_attr_charging.attr,
2389 &dev_attr_regulation_voltage.attr,
2390 &dev_attr_termination_current.attr,
2391 &dev_attr_cin_limit.attr,
2392 &dev_attr_charge_current.attr,
2393 &dev_attr_min_vbus.attr,
2394 &dev_attr_monitoring_interval.attr,
2395 &dev_attr_current_avg_interval.attr,
2397 &dev_attr_stat1.attr,
2398 &dev_attr_status_int1.attr,
2399 &dev_attr_status_int2.attr,
2400 &dev_attr_wakelock_enable.attr,
2404 static const struct attribute_group twl6030_bci_attr_group = {
2405 .attrs = twl6030_bci_attributes,
2408 static char *twl6030_bci_supplied_to[] = {
2412 static int __devinit twl6030_bci_battery_probe(struct platform_device *pdev)
2414 struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
2415 struct twl6030_bci_device_info *di;
2418 u8 controller_stat = 0;
2419 u8 chargerusb_ctrl1 = 0;
2424 dev_dbg(&pdev->dev, "platform_data not available\n");
2428 di = kzalloc(sizeof(*di), GFP_KERNEL);
2432 di->platform_data = kmemdup(pdata, sizeof(*pdata), GFP_KERNEL);
2433 if (!di->platform_data) {
2438 if (pdata->monitoring_interval == 0) {
2439 di->monitoring_interval = 10;
2440 di->current_avg_interval = 10;
2442 di->monitoring_interval = pdata->monitoring_interval;
2443 di->current_avg_interval = pdata->monitoring_interval;
2446 di->platform_data = pdata;
2447 di->features = pdata->features;
2448 di->dev = &pdev->dev;
2450 if (di->features & TWL6032_SUBCLASS) {
2451 ret = twl_i2c_read_u8(TWL_MODULE_RTC, ®, CHARGER_MODE_REG);
2453 goto temp_setup_fail;
2455 if (reg & CHARGER_MODE_POWERPATH) {
2456 dev_dbg(di->dev, "Charger: PowerPath\n");
2457 di->use_power_path = 1;
2459 dev_dbg(di->dev, "Charger: NON PowerPath\n");
2460 di->use_power_path = 0;
2463 if (reg & CHARGER_MODE_AUTOCHARGE) {
2464 dev_dbg(di->dev, "Charger: AutoCharge\n");
2465 di->use_hw_charger = 1;
2467 dev_dbg(di->dev, "Charger: NON AutoCharge\n");
2468 di->use_hw_charger = 0;
2471 di->use_power_path = 0;
2472 di->use_hw_charger = 0;
2475 if (di->use_hw_charger) {
2476 di->platform_data->max_charger_currentmA =
2477 twl6030_get_limit2_reg(di);
2478 di->platform_data->max_charger_voltagemV =
2479 twl6030_get_limit1_reg(di);
2480 di->platform_data->termination_currentmA =
2481 twl6030_get_iterm_reg(di);
2482 di->platform_data->max_bat_voltagemV =
2483 twl6030_get_voreg_reg(di);
2486 di->bat.name = "twl6030_battery";
2487 di->bat.supplied_to = twl6030_bci_supplied_to;
2488 di->bat.num_supplicants = ARRAY_SIZE(twl6030_bci_supplied_to);
2489 di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
2490 di->bat.properties = twl6030_bci_battery_props;
2491 di->bat.num_properties = ARRAY_SIZE(twl6030_bci_battery_props);
2492 di->bat.get_property = twl6030_bci_battery_get_property;
2493 di->bat.external_power_changed =
2494 twl6030_bci_battery_external_power_changed;
2495 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
2497 di->usb.name = "twl6030_usb";
2498 di->usb.type = POWER_SUPPLY_TYPE_USB;
2499 di->usb.properties = twl6030_usb_props;
2500 di->usb.num_properties = ARRAY_SIZE(twl6030_usb_props);
2501 di->usb.get_property = twl6030_usb_get_property;
2503 di->ac.name = "twl6030_ac";
2504 di->ac.type = POWER_SUPPLY_TYPE_MAINS;
2505 di->ac.properties = twl6030_ac_props;
2506 di->ac.num_properties = ARRAY_SIZE(twl6030_ac_props);
2507 di->ac.get_property = twl6030_ac_get_property;
2509 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
2511 di->bk_bat.name = "twl6030_bk_battery";
2512 di->bk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
2513 di->bk_bat.properties = twl6030_bk_bci_battery_props;
2514 di->bk_bat.num_properties = ARRAY_SIZE(twl6030_bk_bci_battery_props);
2515 di->bk_bat.get_property = twl6030_bk_bci_battery_get_property;
2517 di->vac_priority = 2;
2519 di->capacity_debounce_count = 0;
2520 di->ac_next_refresh = jiffies - 1;
2521 platform_set_drvdata(pdev, di);
2523 /* calculate current max scale from sense */
2524 if (pdata->sense_resistor_mohm) {
2525 di->current_max_scale = (62000) / pdata->sense_resistor_mohm;
2527 /* Set sensible defaults if platform data is missing */
2528 if (di->features & TWL6032_SUBCLASS)
2529 di->current_max_scale = 3100;
2531 di->current_max_scale = 6200;
2534 wake_lock_init(&chrg_lock, WAKE_LOCK_SUSPEND, "ac_chrg_wake_lock");
2535 /* settings for temperature sensing */
2536 ret = twl6030battery_temp_setup(true);
2538 goto temp_setup_fail;
2540 /* request charger fault interruption choosing between sw/hw mode */
2541 irq = platform_get_irq(pdev, 1);
2542 if (!di->use_hw_charger)
2543 ret = request_threaded_irq(irq, NULL,
2544 twl6030charger_fault_interrupt,
2545 0, "twl_bci_fault", di);
2547 ret = request_threaded_irq(irq, NULL,
2548 twl6032charger_fault_interrupt_hw,
2549 0, "twl_bci_fault", di);
2552 dev_dbg(&pdev->dev, "could not request irq %d, status %d\n",
2554 goto temp_setup_fail;
2557 /* request charger ctrl interruption choosing between sw/hw mode */
2558 irq = platform_get_irq(pdev, 0);
2559 if (!di->use_hw_charger)
2560 ret = request_threaded_irq(irq, NULL,
2561 twl6030charger_ctrl_interrupt,
2562 0, "twl_bci_ctrl", di);
2564 ret = request_threaded_irq(irq, NULL,
2565 twl6032charger_ctrl_interrupt_hw,
2566 0, "twl_bci_ctrl", di);
2569 dev_dbg(&pdev->dev, "could not request irq %d, status %d\n",
2574 ret = power_supply_register(&pdev->dev, &di->bat);
2576 dev_dbg(&pdev->dev, "failed to register main battery\n");
2580 ret = power_supply_register(&pdev->dev, &di->usb);
2582 dev_dbg(&pdev->dev, "failed to register usb power supply\n");
2586 ret = power_supply_register(&pdev->dev, &di->ac);
2588 dev_dbg(&pdev->dev, "failed to register ac power supply\n");
2592 ret = power_supply_register(&pdev->dev, &di->bk_bat);
2594 dev_dbg(&pdev->dev, "failed to register backup battery\n");
2595 goto bk_batt_failed;
2600 INIT_DELAYED_WORK_DEFERRABLE(&di->twl6030_bci_monitor_work,
2601 twl6030_bci_battery_work);
2602 schedule_delayed_work(&di->twl6030_bci_monitor_work, 0);
2604 INIT_DELAYED_WORK_DEFERRABLE(&di->twl6030_current_avg_work,
2605 twl6030_current_avg);
2606 schedule_delayed_work(&di->twl6030_current_avg_work, 500);
2608 ret = twl6030battery_voltage_setup(di);
2610 dev_dbg(&pdev->dev, "voltage measurement setup failed\n");
2612 ret = twl6030battery_current_setup(true);
2614 dev_dbg(&pdev->dev, "current measurement setup failed\n");
2616 /* initialize for USB charging */
2617 if (!di->use_hw_charger) {
2618 twl6030_config_limit1_reg(di, pdata->max_charger_voltagemV);
2619 twl6030_config_limit2_reg(di,
2620 di->platform_data->max_charger_currentmA);
2622 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
2623 CONTROLLER_INT_MASK);
2625 goto bk_batt_failed;
2627 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MASK_MCHARGERUSB_THMREG,
2628 CHARGERUSB_INT_MASK);
2630 goto bk_batt_failed;
2632 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &controller_stat,
2635 goto bk_batt_failed;
2637 di->stat1 = controller_stat;
2638 di->charger_outcurrentmA = di->platform_data->max_charger_currentmA;
2640 twl6030_set_watchdog(di, 32);
2642 INIT_WORK(&di->usb_work, twl6030_usb_charger_work);
2643 di->nb.notifier_call = twl6030_usb_notifier_call;
2644 di->otg = otg_get_transceiver();
2646 ret = otg_register_notifier(di->otg, &di->nb);
2648 dev_err(&pdev->dev, "otg register notifier"
2649 " failed %d\n", ret);
2651 dev_err(&pdev->dev, "otg_get_transceiver failed %d\n", ret);
2653 if (di->features & TWL6032_SUBCLASS) {
2654 di->charger_incurrentmA = 100;
2655 di->gpadc_vbat_chnl = TWL6032_GPADC_VBAT_CHNL;
2657 di->charger_incurrentmA = twl6030_get_usb_max_power(di->otg);
2658 di->gpadc_vbat_chnl = TWL6030_GPADC_VBAT_CHNL;
2661 di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
2662 dev_info(&pdev->dev, "Battery Voltage at Bootup is %d mV\n",
2665 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
2667 goto bk_batt_failed;
2668 if (!is_battery_present(di)) {
2669 if (!(hw_state & STS_USB_ID)) {
2670 dev_dbg(di->dev, "Put USB in HZ mode\n");
2671 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
2672 &chargerusb_ctrl1, CHARGERUSB_CTRL1);
2674 goto bk_batt_failed;
2676 chargerusb_ctrl1 |= HZ_MODE;
2677 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
2678 chargerusb_ctrl1, CHARGERUSB_CTRL1);
2680 goto bk_batt_failed;
2682 } else if (!di->use_hw_charger) {
2683 if (controller_stat & VAC_DET) {
2684 di->ac_online = POWER_SUPPLY_TYPE_MAINS;
2685 twl6030_start_ac_charger(di);
2686 } else if (controller_stat & VBUS_DET) {
2688 * In HOST mode (ID GROUND) with a device connected,
2689 * do no enable usb charging
2691 if (!(hw_state & STS_USB_ID)) {
2692 di->usb_online = POWER_SUPPLY_TYPE_USB;
2693 di->charger_source = POWER_SUPPLY_TYPE_USB;
2695 POWER_SUPPLY_STATUS_CHARGING;
2696 di->event = USB_EVENT_VBUS;
2697 schedule_work(&di->usb_work);
2701 int fault, charge_usb, charge_ac;
2703 twl_i2c_read_u8(TWL6032_MODULE_CHARGER, ®,
2704 CHARGERUSB_INT_STATUS);
2706 fault = !(di->stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
2707 !(di->stat1 & CONTROLLER_STAT1_FAULT_WDG);
2708 charge_usb = (di->stat1 & VBUS_DET) &&
2709 !(reg & CHARGERUSB_FAULT);
2710 charge_ac = (di->stat1 & VAC_DET) &&
2711 !(di->stat1 & CONTROLLER_STAT1_EXTCHRG_STATZ);
2713 dev_dbg(di->dev, "boot charge state fault %d, usb %d, ac %d\n",
2714 fault, charge_usb, charge_ac);
2716 if (fault && (charge_usb || charge_ac))
2717 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
2719 if (di->stat1 & (VBUS_DET | VAC_DET))
2721 POWER_SUPPLY_STATUS_NOT_CHARGING;
2724 POWER_SUPPLY_STATUS_DISCHARGING;
2728 ret = twl6030backupbatt_setup();
2730 dev_dbg(&pdev->dev, "Backup Bat charging setup failed\n");
2732 twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
2733 REG_INT_MSK_LINE_C);
2734 twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
2736 twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
2737 REG_INT_MSK_LINE_C);
2738 twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
2741 ret = sysfs_create_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
2743 dev_dbg(&pdev->dev, "could not create sysfs files\n");
2748 cancel_delayed_work(&di->twl6030_bci_monitor_work);
2749 power_supply_unregister(&di->ac);
2751 power_supply_unregister(&di->usb);
2753 power_supply_unregister(&di->bat);
2757 irq = platform_get_irq(pdev, 1);
2760 wake_lock_destroy(&chrg_lock);
2761 platform_set_drvdata(pdev, NULL);
2767 static int __devexit twl6030_bci_battery_remove(struct platform_device *pdev)
2769 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
2772 twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
2773 REG_INT_MSK_LINE_C);
2774 twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
2776 twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
2777 REG_INT_MSK_LINE_C);
2778 twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
2781 irq = platform_get_irq(pdev, 0);
2784 irq = platform_get_irq(pdev, 1);
2787 otg_unregister_notifier(di->otg, &di->nb);
2788 sysfs_remove_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
2789 cancel_delayed_work(&di->twl6030_bci_monitor_work);
2790 cancel_delayed_work(&di->twl6030_current_avg_work);
2791 flush_scheduled_work();
2792 power_supply_unregister(&di->bat);
2793 power_supply_unregister(&di->usb);
2794 power_supply_unregister(&di->ac);
2795 power_supply_unregister(&di->bk_bat);
2796 wake_lock_destroy(&chrg_lock);
2797 platform_set_drvdata(pdev, NULL);
2798 kfree(di->platform_data);
2805 static int twl6030_bci_battery_suspend(struct device *dev)
2807 struct platform_device *pdev = to_platform_device(dev);
2808 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
2813 /* mask to prevent wakeup due to 32s timeout from External charger */
2814 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
2815 CONTROLLER_INT_MASK);
2819 rd_reg |= MVAC_FAULT;
2820 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
2821 CONTROLLER_INT_MASK);
2825 cancel_delayed_work(&di->twl6030_bci_monitor_work);
2826 cancel_delayed_work(&di->twl6030_current_avg_work);
2828 /* We cannot tolarate a sleep longer than 30 seconds
2829 * while on ac charging we have to reset the BQ watchdog timer.
2831 if ((di->charger_source == POWER_SUPPLY_TYPE_MAINS) &&
2832 ((wakeup_timer_seconds > 25) || !wakeup_timer_seconds)) {
2833 wakeup_timer_seconds = 25;
2836 /*reset the BQ watch dog*/
2837 events = BQ2415x_RESET_TIMER;
2838 blocking_notifier_call_chain(¬ifier_list, events, NULL);
2840 ret = twl6030battery_temp_setup(false);
2842 pr_err("%s: Temp measurement setup failed (%d)!\n",
2847 ret = twl6030battery_current_setup(false);
2849 pr_err("%s: Current measurement setup failed (%d)!\n",
2856 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
2860 static int twl6030_bci_battery_resume(struct device *dev)
2862 struct platform_device *pdev = to_platform_device(dev);
2863 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
2868 ret = twl6030battery_temp_setup(true);
2870 pr_err("%s: Temp measurement setup failed (%d)!\n",
2875 ret = twl6030battery_current_setup(true);
2877 pr_err("%s: Current measurement setup failed (%d)!\n",
2882 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg, CONTROLLER_INT_MASK);
2886 rd_reg &= ~(0xFF & MVAC_FAULT);
2887 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
2888 CONTROLLER_INT_MASK);
2892 schedule_delayed_work(&di->twl6030_bci_monitor_work, 0);
2893 schedule_delayed_work(&di->twl6030_current_avg_work, 50);
2895 events = BQ2415x_RESET_TIMER;
2896 blocking_notifier_call_chain(¬ifier_list, events, NULL);
2900 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
2904 #define twl6030_bci_battery_suspend NULL
2905 #define twl6030_bci_battery_resume NULL
2906 #endif /* CONFIG_PM */
2908 static const struct dev_pm_ops pm_ops = {
2909 .suspend = twl6030_bci_battery_suspend,
2910 .resume = twl6030_bci_battery_resume,
2913 static struct platform_driver twl6030_bci_battery_driver = {
2914 .probe = twl6030_bci_battery_probe,
2915 .remove = __devexit_p(twl6030_bci_battery_remove),
2917 .name = "twl6030_bci",
2922 static int __init twl6030_battery_init(void)
2924 return platform_driver_register(&twl6030_bci_battery_driver);
2926 module_init(twl6030_battery_init);
2928 static void __exit twl6030_battery_exit(void)
2930 platform_driver_unregister(&twl6030_bci_battery_driver);
2932 module_exit(twl6030_battery_exit);
2934 MODULE_LICENSE("GPL");
2935 MODULE_ALIAS("platform:twl6030_bci");
2936 MODULE_AUTHOR("Texas Instruments Inc");