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 #include <mach/gpio.h>
34 #define CONTROLLER_INT_MASK 0x00
35 #define CONTROLLER_CTRL1 0x01
36 #define CONTROLLER_WDG 0x02
37 #define CONTROLLER_STAT1 0x03
38 #define CHARGERUSB_INT_STATUS 0x04
39 #define CHARGERUSB_INT_MASK 0x05
40 #define CHARGERUSB_STATUS_INT1 0x06
41 #define CHARGERUSB_STATUS_INT2 0x07
42 #define CHARGERUSB_CTRL1 0x08
43 #define CHARGERUSB_CTRL2 0x09
44 #define CHARGERUSB_CTRL3 0x0A
45 #define CHARGERUSB_STAT1 0x0B
46 #define CHARGERUSB_VOREG 0x0C
47 #define CHARGERUSB_VICHRG 0x0D
48 #define CHARGERUSB_CINLIMIT 0x0E
49 #define CHARGERUSB_CTRLLIMIT1 0x0F
50 #define CHARGERUSB_CTRLLIMIT2 0x10
51 #define ANTICOLLAPSE_CTRL1 0x11
52 #define ANTICOLLAPSE_CTRL2 0x12
54 /* TWL6032 registers 0xDA to 0xDE - TWL6032_MODULE_CHARGER */
55 #define CONTROLLER_CTRL2 0x00
56 #define CONTROLLER_VSEL_COMP 0x01
57 #define CHARGERUSB_VSYSREG 0x02
58 #define CHARGERUSB_VICHRG_PC 0x03
59 #define LINEAR_CHRG_STS 0x04
61 /* TWL6032 Charger Mode Register */
62 #define CHARGER_MODE_REG 0xD4
63 #define CHARGER_MODE_POWERPATH BIT(3)
64 #define CHARGER_MODE_AUTOCHARGE BIT(6)
66 #define LINEAR_CHRG_STS_CRYSTL_OSC_OK 0x40
67 #define LINEAR_CHRG_STS_END_OF_CHARGE 0x20
68 #define LINEAR_CHRG_STS_VBATOV 0x10
69 #define LINEAR_CHRG_STS_VSYSOV 0x08
70 #define LINEAR_CHRG_STS_DPPM_STS 0x04
71 #define LINEAR_CHRG_STS_CV_STS 0x02
72 #define LINEAR_CHRG_STS_CC_STS 0x01
74 #define FG_REG_00 0x00
75 #define FG_REG_01 0x01
76 #define FG_REG_02 0x02
77 #define FG_REG_03 0x03
78 #define FG_REG_04 0x04
79 #define FG_REG_05 0x05
80 #define FG_REG_06 0x06
81 #define FG_REG_07 0x07
82 #define FG_REG_08 0x08
83 #define FG_REG_09 0x09
84 #define FG_REG_10 0x0A
85 #define FG_REG_11 0x0B
87 /* CONTROLLER_INT_MASK */
88 #define MVAC_FAULT (1 << 7)
89 #define MAC_EOC (1 << 6)
90 #define LINCH_GATED (1 << 5)
91 #define MBAT_REMOVED (1 << 4)
92 #define MFAULT_WDG (1 << 3)
93 #define MBAT_TEMP (1 << 2)
94 #define MVBUS_DET (1 << 1)
95 #define MVAC_DET (1 << 0)
97 /* CONTROLLER_CTRL1 */
98 #define CONTROLLER_CTRL1_EN_LINCH (1 << 5)
99 #define CONTROLLER_CTRL1_EN_CHARGER (1 << 4)
100 #define CONTROLLER_CTRL1_SEL_CHARGER (1 << 3)
102 /* CONTROLLER_STAT1 */
103 #define CONTROLLER_STAT1_EXTCHRG_STATZ (1 << 7)
104 #define CONTROLLER_STAT1_LINCH_GATED (1 << 6)
105 #define CONTROLLER_STAT1_CHRG_DET_N (1 << 5)
106 #define CONTROLLER_STAT1_FAULT_WDG (1 << 4)
107 #define CONTROLLER_STAT1_VAC_DET (1 << 3)
108 #define VAC_DET (1 << 3)
109 #define CONTROLLER_STAT1_VBUS_DET (1 << 2)
110 #define VBUS_DET (1 << 2)
111 #define CONTROLLER_STAT1_BAT_REMOVED (1 << 1)
112 #define CONTROLLER_STAT1_BAT_TEMP_OVRANGE (1 << 0)
114 /* CHARGERUSB_INT_STATUS */
115 #define EN_LINCH (1 << 4)
116 #define CURRENT_TERM_INT (1 << 3)
117 #define CHARGERUSB_STAT (1 << 2)
118 #define CHARGERUSB_THMREG (1 << 1)
119 #define CHARGERUSB_FAULT (1 << 0)
121 /* CHARGERUSB_INT_MASK */
122 #define MASK_MCURRENT_TERM (1 << 3)
123 #define MASK_MCHARGERUSB_STAT (1 << 2)
124 #define MASK_MCHARGERUSB_THMREG (1 << 1)
125 #define MASK_MCHARGERUSB_FAULT (1 << 0)
127 /* CHARGERUSB_STATUS_INT1 */
128 #define CHARGERUSB_STATUS_INT1_TMREG (1 << 7)
129 #define CHARGERUSB_STATUS_INT1_NO_BAT (1 << 6)
130 #define CHARGERUSB_STATUS_INT1_BST_OCP (1 << 5)
131 #define CHARGERUSB_STATUS_INT1_TH_SHUTD (1 << 4)
132 #define CHARGERUSB_STATUS_INT1_BAT_OVP (1 << 3)
133 #define CHARGERUSB_STATUS_INT1_POOR_SRC (1 << 2)
134 #define CHARGERUSB_STATUS_INT1_SLP_MODE (1 << 1)
135 #define CHARGERUSB_STATUS_INT1_VBUS_OVP (1 << 0)
137 /* CHARGERUSB_STATUS_INT2 */
138 #define ICCLOOP (1 << 3)
139 #define CURRENT_TERM (1 << 2)
140 #define CHARGE_DONE (1 << 1)
141 #define ANTICOLLAPSE (1 << 0)
143 /* CHARGERUSB_CTRL1 */
144 #define SUSPEND_BOOT (1 << 7)
145 #define OPA_MODE (1 << 6)
146 #define HZ_MODE (1 << 5)
147 #define TERM (1 << 4)
149 /* CHARGERUSB_CTRL2 */
150 #define CHARGERUSB_CTRL2_VITERM_50 (0 << 5)
151 #define CHARGERUSB_CTRL2_VITERM_100 (1 << 5)
152 #define CHARGERUSB_CTRL2_VITERM_150 (2 << 5)
153 #define CHARGERUSB_CTRL2_VITERM_400 (7 << 5)
155 /* CHARGERUSB_CTRL3 */
156 #define VBUSCHRG_LDO_OVRD (1 << 7)
157 #define CHARGE_ONCE (1 << 6)
158 #define BST_HW_PR_DIS (1 << 5)
159 #define AUTOSUPPLY (1 << 3)
160 #define BUCK_HSILIM (1 << 0)
162 /* CHARGERUSB_VOREG */
163 #define CHARGERUSB_VOREG_3P52 0x01
164 #define CHARGERUSB_VOREG_4P0 0x19
165 #define CHARGERUSB_VOREG_4P2 0x23
166 #define CHARGERUSB_VOREG_4P76 0x3F
168 /* CHARGERUSB_VICHRG */
169 #define CHARGERUSB_VICHRG_300 0x0
170 #define CHARGERUSB_VICHRG_500 0x4
171 #define CHARGERUSB_VICHRG_1500 0xE
173 /* CHARGERUSB_CINLIMIT */
174 #define CHARGERUSB_CIN_LIMIT_100 0x1
175 #define CHARGERUSB_CIN_LIMIT_300 0x5
176 #define CHARGERUSB_CIN_LIMIT_500 0x9
177 #define CHARGERUSB_CIN_LIMIT_NONE 0xF
179 /* CHARGERUSB_CTRLLIMIT1 */
180 #define VOREGL_4P16 0x21
181 #define VOREGL_4P56 0x35
183 /* CHARGERUSB_CTRLLIMIT2 */
184 #define CHARGERUSB_CTRLLIMIT2_1500 0x0E
185 #define LOCK_LIMIT (1 << 4)
187 /* ANTICOLLAPSE_CTRL2 */
188 #define BUCK_VTH_SHIFT 5
191 #define CC_ACTIVE_MODE_SHIFT 6
192 #define CC_AUTOCLEAR (1 << 2)
193 #define CC_CAL_EN (1 << 1)
194 #define CC_PAUSE (1 << 0)
196 #define REG_TOGGLE1 0x90
197 #define FGDITHS (1 << 7)
198 #define FGDITHR (1 << 6)
202 /* TWL6030_GPADC_CTRL */
203 #define GPADC_CTRL_TEMP1_EN (1 << 0) /* input ch 1 */
204 #define GPADC_CTRL_TEMP2_EN (1 << 1) /* input ch 4 */
205 #define GPADC_CTRL_SCALER_EN (1 << 2) /* input ch 2 */
206 #define GPADC_CTRL_SCALER_DIV4 (1 << 3)
207 #define GPADC_CTRL_SCALER_EN_CH11 (1 << 4) /* input ch 11 */
208 #define GPADC_CTRL_TEMP1_EN_MONITOR (1 << 5)
209 #define GPADC_CTRL_TEMP2_EN_MONITOR (1 << 6)
210 #define GPADC_CTRL_ISOURCE_EN (1 << 7)
212 #define GPADC_ISOURCE_22uA 22
213 #define GPADC_ISOURCE_7uA 7
215 /* TWL6030/6032 BATTERY VOLTAGE GPADC CHANNELS */
217 #define TWL6030_GPADC_VBAT_CHNL 0x07
218 #define TWL6032_GPADC_VBAT_CHNL 0x12
220 /* TWL6030_GPADC_CTRL2 */
221 #define GPADC_CTRL2_CH18_SCALER_EN BIT(2)
223 #define ENABLE_ISOURCE 0x80
225 #define REG_MISC1 0xE4
226 #define VAC_MEAS 0x04
227 #define VBAT_MEAS 0x02
230 #define REG_USB_VBUS_CTRL_SET 0x04
231 #define VBUS_MEAS 0x01
232 #define REG_USB_ID_CTRL_SET 0x06
235 #define BBSPOR_CFG 0xE6
236 #define BB_CHG_EN (1 << 3)
238 #define STS_HW_CONDITIONS 0x21
239 #define STS_USB_ID (1 << 2) /* Level status of USB ID */
241 #define BATTERY_RESISTOR 10000
242 #define SIMULATOR_RESISTOR 5000
243 #define BATTERY_DETECT_THRESHOLD ((BATTERY_RESISTOR + SIMULATOR_RESISTOR) / 2) //battery voltage threshold divided by 22uA
244 #define CHARGING_CAPACITY_UPDATE_PERIOD (1000 * 60 * 1)
248 /************************************************************/
249 #define TIMER_MS_COUNTS 1000
250 #define NUM_DISCHARGE_MIN_SAMPLE 30
251 #define NUM_CHARGE_MIN_SAMPLE 30
252 /**************************************************************/
254 /* To get VBUS input limit from twl6030_usb */
255 #if CONFIG_TWL6030_USB
256 extern unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x);
258 static inline unsigned int twl6030_get_usb_max_power(struct otg_transceiver *x)
264 /* Ptr to thermistor table */
265 static const unsigned int fuelgauge_rate[4] = {1, 4, 16, 64};
266 static struct wake_lock chrg_lock;
269 struct twl6030_bci_device_info {
296 u8 watchdog_duration;
297 u16 current_avg_interval;
298 u16 monitoring_interval;
299 unsigned int min_vbus;
301 struct twl4030_bci_platform_data *platform_data;
303 unsigned int charger_incurrentmA;
304 unsigned int charger_outcurrentmA;
305 unsigned long usb_max_power;
308 unsigned int capacity;
309 unsigned int capacity_debounce_count;
310 unsigned long ac_next_refresh;
311 unsigned int prev_capacity;
312 unsigned int wakelock_enabled;
314 struct power_supply bat;
315 struct power_supply usb;
316 struct power_supply ac;
317 struct power_supply bk_bat;
319 struct otg_transceiver *otg;
320 struct notifier_block nb;
321 struct work_struct usb_work;
323 struct workqueue_struct *freezable_work;
325 struct delayed_work twl6030_bci_monitor_work;
326 struct delayed_work twl6030_current_avg_work;
328 unsigned long features;
333 /* max scale current based on sense resitor */
334 int current_max_scale;
335 struct delayed_work work;
336 unsigned int interval;
338 int gBatCapacityDisChargeCnt;
342 int gBatCapacityChargeCnt;
343 int suspend_capacity;
347 static BLOCKING_NOTIFIER_HEAD(notifier_list);
348 extern u32 wakeup_timer_seconds;
350 static void twl6030_config_min_vbus_reg(struct twl6030_bci_device_info *di,
356 /* not required on TWL6032 */
357 if (di->features & TWL6032_SUBCLASS)
360 if (value > 4760 || value < 4200) {
361 dev_err(di->dev, "invalid min vbus\n");
365 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
369 rd_reg = rd_reg & 0x1F;
370 rd_reg = rd_reg | (((value - 4200)/80) << BUCK_VTH_SHIFT);
371 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, rd_reg,
377 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
380 static void twl6030_config_iterm_reg(struct twl6030_bci_device_info *di,
381 unsigned int term_currentmA)
385 if ((term_currentmA > 400) || (term_currentmA < 50)) {
386 dev_err(di->dev, "invalid termination current\n");
390 term_currentmA = ((term_currentmA - 50)/50) << 5;
391 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, term_currentmA,
394 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
397 static unsigned int twl6030_get_iterm_reg(struct twl6030_bci_device_info *di)
400 unsigned int currentmA;
403 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_CTRL2);
405 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
408 currentmA = 50 + (val >> 5) * 50;
413 static void twl6030_config_voreg_reg(struct twl6030_bci_device_info *di,
414 unsigned int voltagemV)
418 if ((voltagemV < 3500) || (voltagemV > 4760)) {
419 dev_err(di->dev, "invalid charger_voltagemV\n");
423 voltagemV = (voltagemV - 3500) / 20;
424 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
427 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
430 static unsigned int twl6030_get_voreg_reg(struct twl6030_bci_device_info *di)
433 unsigned int voltagemV;
436 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val, CHARGERUSB_VOREG);
438 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
441 voltagemV = 3500 + (val * 20);
446 static void twl6030_config_vichrg_reg(struct twl6030_bci_device_info *di,
447 unsigned int currentmA)
451 if ((currentmA >= 300) && (currentmA <= 450))
452 currentmA = (currentmA - 300) / 50;
453 else if ((currentmA >= 500) && (currentmA <= 1500))
454 currentmA = (currentmA - 500) / 100 + 4;
456 dev_err(di->dev, "invalid charger_currentmA\n");
460 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
463 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
466 static void twl6030_config_cinlimit_reg(struct twl6030_bci_device_info *di,
467 unsigned int currentmA)
471 if ((currentmA >= 50) && (currentmA <= 750))
472 currentmA = (currentmA - 50) / 50;
473 else if ((currentmA > 750) && (currentmA <= 1500) &&
474 (di->features & TWL6032_SUBCLASS)) {
475 currentmA = ((currentmA % 100) ? 0x30 : 0x20) +
476 ((currentmA - 100) / 100);
477 } else if (currentmA < 50) {
478 dev_err(di->dev, "invalid input current limit\n");
481 /* This is no current limit */
485 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
486 CHARGERUSB_CINLIMIT);
488 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
491 static void twl6030_config_limit1_reg(struct twl6030_bci_device_info *di,
492 unsigned int voltagemV)
496 if ((voltagemV < 3500) || (voltagemV > 4760)) {
497 dev_err(di->dev, "invalid max_charger_voltagemV\n");
501 voltagemV = (voltagemV - 3500) / 20;
502 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, voltagemV,
503 CHARGERUSB_CTRLLIMIT1);
505 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
508 static unsigned int twl6030_get_limit1_reg(struct twl6030_bci_device_info *di)
511 unsigned int voltagemV;
514 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
515 CHARGERUSB_CTRLLIMIT1);
517 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
520 voltagemV = 3500 + (val * 20);
525 static void twl6030_config_limit2_reg(struct twl6030_bci_device_info *di,
526 unsigned int currentmA)
530 if ((currentmA >= 300) && (currentmA <= 450))
531 currentmA = (currentmA - 300) / 50;
532 else if ((currentmA >= 500) && (currentmA <= 1500))
533 currentmA = (currentmA - 500) / 100 + 4;
535 dev_err(di->dev, "invalid max_charger_currentmA\n");
539 currentmA |= LOCK_LIMIT;
540 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, currentmA,
541 CHARGERUSB_CTRLLIMIT2);
543 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
546 static const int vichrg[] = {
547 300, 350, 400, 450, 500, 600, 700, 800,
548 900, 1000, 1100, 1200, 1300, 1400, 1500, 300
551 static unsigned int twl6030_get_limit2_reg(struct twl6030_bci_device_info *di)
554 unsigned int currentmA;
557 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &val,
558 CHARGERUSB_CTRLLIMIT2);
560 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
563 currentmA = vichrg[val & 0xF];
569 * Return channel value
572 static int twl6030_get_gpadc_conversion(struct twl6030_bci_device_info *di,
575 struct twl6030_gpadc_request req;
579 req.channels = (1 << channel_no);
580 req.method = TWL6030_GPADC_SW2;
583 ret = twl6030_gpadc_conversion(&req);
587 if (req.rbuf[channel_no] > 0)
588 temp = req.rbuf[channel_no];
593 static int is_battery_present(struct twl6030_bci_device_info *di)
596 static unsigned int current_src_val;
599 * Prevent charging on batteries were id resistor is
602 val = twl6030_get_gpadc_conversion(di,di->gpadc_vbat_chnl);
605 * twl6030_get_gpadc_conversion for
606 * 6030 return resistance, for 6032 - voltage and
607 * it should be converted to resistance before
610 if (!current_src_val) {
613 if (twl_i2c_read_u8(TWL_MODULE_MADC, ®,
615 pr_err("%s: Error reading TWL6030_GPADC_CTRL\n",
618 current_src_val = (reg & GPADC_CTRL_ISOURCE_EN) ?
623 val = (val * 1000) / current_src_val;
625 if (val < BATTERY_DETECT_THRESHOLD)
631 static void twl6030_stop_usb_charger(struct twl6030_bci_device_info *di)
635 //printk("*************twl6030_stop_usb_charger***************\n");
636 if (di->use_hw_charger) {
637 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, ®,
642 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
650 di->charger_source = 0;
651 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
653 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
657 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
660 static void twl6030_start_usb_charger(struct twl6030_bci_device_info *di)
666 //printk("***************twl6030_start_usb_charger*****************************************\n");
668 if (di->use_hw_charger) {
669 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, ®,
675 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
683 if (!is_battery_present(di)) {
684 dev_info(di->dev, "BATTERY NOT DETECTED!\n");
688 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
691 dev_dbg(di->dev, "USB input current limit %dmA\n",
692 di->charger_incurrentmA);
693 if (di->charger_incurrentmA < 50) {
694 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
695 0, CONTROLLER_CTRL1);
702 twl6030_config_vichrg_reg(di, di->charger_outcurrentmA);
703 twl6030_config_cinlimit_reg(di, di->charger_incurrentmA);
704 twl6030_config_voreg_reg(di, di->platform_data->max_bat_voltagemV);
705 twl6030_config_iterm_reg(di, di->platform_data->termination_currentmA);
707 if (di->charger_incurrentmA >= 50) {
708 reg = CONTROLLER_CTRL1_EN_CHARGER;
710 if (di->use_power_path)
711 reg |= CONTROLLER_CTRL1_EN_LINCH;
713 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, reg,
718 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
722 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
725 static void twl6030_stop_ac_charger(struct twl6030_bci_device_info *di)
730 di->charger_source = 0;
731 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
732 events = BQ2415x_STOP_CHARGING;
734 if (di->use_hw_charger)
737 blocking_notifier_call_chain(¬ifier_list, events, NULL);
739 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0, CONTROLLER_CTRL1);
741 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
743 if (di->wakelock_enabled)
744 wake_unlock(&chrg_lock);
747 static void twl6030_start_ac_charger(struct twl6030_bci_device_info *di)
752 if (!is_battery_present(di)) {
753 dev_info(di->dev, "BATTERY NOT DETECTED!\n");
756 dev_dbg(di->dev, "AC charger detected\n");
757 di->charger_source = POWER_SUPPLY_TYPE_MAINS;
758 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
759 events = BQ2415x_START_CHARGING;
761 if (di->use_hw_charger)
764 blocking_notifier_call_chain(¬ifier_list, events, NULL);
766 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
767 CONTROLLER_CTRL1_EN_CHARGER |
768 CONTROLLER_CTRL1_SEL_CHARGER,
771 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
773 if (di->wakelock_enabled)
774 wake_lock(&chrg_lock);
777 static void twl6030_stop_charger(struct twl6030_bci_device_info *di)
779 //printk("$$$$$$$$$$$$twl6030_stop_charger$$$$$$$$$$$$\n");
780 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
781 twl6030_stop_ac_charger(di);
782 else if (di->charger_source == POWER_SUPPLY_TYPE_USB)
783 twl6030_stop_usb_charger(di);
786 static void twl6032_charger_ctrl_interrupt(struct twl6030_bci_device_info *di)
788 u8 stat_toggle, stat_reset, stat_set = 0;
789 u8 present_state = 0, linear_state;
790 u8 present_status = 0;
793 err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_state,
796 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
801 err = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &present_status,
802 CHARGERUSB_INT_STATUS);
804 dev_err(di->dev, "%s: Error access to TWL6030 (%d)\n",
809 linear_state = di->linear_stat;
811 stat_toggle = linear_state ^ present_state;
812 stat_set = stat_toggle & present_state;
813 stat_reset = stat_toggle & linear_state;
814 di->linear_stat = present_state;
816 if (stat_set & LINEAR_CHRG_STS_CRYSTL_OSC_OK)
817 dev_dbg(di->dev, "Linear status: CRYSTAL OSC OK\n");
818 if (present_state & LINEAR_CHRG_STS_END_OF_CHARGE) {
819 dev_dbg(di->dev, "Linear status: END OF CHARGE\n");
820 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
822 if (present_status & EN_LINCH) {
823 dev_dbg(di->dev, "Linear status: START OF CHARGE\n");
824 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
827 if (stat_set & LINEAR_CHRG_STS_VBATOV) {
828 dev_dbg(di->dev, "Linear Status: VBATOV\n");
829 di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
831 if (stat_reset & LINEAR_CHRG_STS_VBATOV) {
832 dev_dbg(di->dev, "Linear Status: VBATOV\n");
833 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
836 if (stat_set & LINEAR_CHRG_STS_VSYSOV)
837 dev_dbg(di->dev, "Linear Status: VSYSOV\n");
838 if (stat_set & LINEAR_CHRG_STS_DPPM_STS)
839 dev_dbg(di->dev, "Linear Status: DPPM STS\n");
840 if (stat_set & LINEAR_CHRG_STS_CV_STS)
841 dev_dbg(di->dev, "Linear Status: CV STS\n");
842 if (stat_set & LINEAR_CHRG_STS_CC_STS)
843 dev_dbg(di->dev, "Linear Status: CC STS\n");
847 * Interrupt service routine
849 * Attends to TWL 6030 power module interruptions events, specifically
850 * USB_PRES (USB charger presence) CHG_PRES (AC charger presence) events
853 static irqreturn_t twl6030charger_ctrl_interrupt(int irq, void *_di)
855 // printk("%s\n", __func__);
857 struct twl6030_bci_device_info *di = _di;
859 int charger_fault = 0;
861 u8 stat_toggle, stat_reset, stat_set = 0;
863 u8 present_charge_state = 0;
864 u8 ac_or_vbus, no_ac_and_vbus = 0;
865 u8 hw_state = 0, temp = 0;
867 /* read charger controller_stat1 */
868 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &present_charge_state,
872 * Since present state read failed, charger_state is no
873 * longer valid, reset to zero inorder to detect next events
879 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
883 charge_state = di->stat1;
885 stat_toggle = charge_state ^ present_charge_state;
886 stat_set = stat_toggle & present_charge_state;
887 stat_reset = stat_toggle & charge_state;
889 no_ac_and_vbus = !((present_charge_state) & (VBUS_DET | VAC_DET));
890 ac_or_vbus = charge_state & (VBUS_DET | VAC_DET);
891 if (no_ac_and_vbus && ac_or_vbus) {
892 di->charger_source = 0;
893 dev_dbg(di->dev, "No Charging source\n");
894 /* disable charging when no source present */
897 charge_state = present_charge_state;
898 di->stat1 = present_charge_state;
899 if ((charge_state & VAC_DET) &&
900 (charge_state & CONTROLLER_STAT1_EXTCHRG_STATZ)) {
901 events = BQ2415x_CHARGER_FAULT;
902 blocking_notifier_call_chain(¬ifier_list, events, NULL);
905 if (stat_reset & VBUS_DET) {
906 /* On a USB detach, UNMASK VBUS OVP if masked*/
907 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &temp,
908 CHARGERUSB_INT_MASK);
912 if (temp & MASK_MCHARGERUSB_FAULT) {
913 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
914 (temp & ~MASK_MCHARGERUSB_FAULT),
915 CHARGERUSB_INT_MASK);
920 dev_info(di->dev, "usb removed\n");
921 twl6030_stop_usb_charger(di);
922 if (present_charge_state & VAC_DET)
923 twl6030_start_ac_charger(di);
927 if (stat_set & VBUS_DET) {
928 /* In HOST mode (ID GROUND) when a device is connected,
929 * Mask VBUS OVP interrupt and do no enable usb
932 if (hw_state & STS_USB_ID) {
933 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
935 CHARGERUSB_INT_MASK);
939 if (!(temp & MASK_MCHARGERUSB_FAULT)) {
940 ret = twl_i2c_write_u8(
941 TWL6030_MODULE_CHARGER,
942 (temp | MASK_MCHARGERUSB_FAULT),
943 CHARGERUSB_INT_MASK);
948 di->usb_online = POWER_SUPPLY_TYPE_USB;
949 if ((present_charge_state & VAC_DET) &&
950 (di->vac_priority == 2))
951 dev_info(di->dev, "USB charger detected"
952 ", continue with VAC\n");
955 POWER_SUPPLY_TYPE_USB;
957 POWER_SUPPLY_STATUS_CHARGING;
959 dev_info(di->dev, "vbus detect\n");
963 if (stat_reset & VAC_DET) {
965 dev_info(di->dev, "vac removed\n");
966 twl6030_stop_ac_charger(di);
967 if (present_charge_state & VBUS_DET) {
968 di->charger_source = POWER_SUPPLY_TYPE_USB;
970 POWER_SUPPLY_STATUS_CHARGING;
971 twl6030_start_usb_charger(di);
974 if (stat_set & VAC_DET) {
975 di->ac_online = POWER_SUPPLY_TYPE_MAINS;
976 if ((present_charge_state & VBUS_DET) &&
977 (di->vac_priority == 3))
979 "AC charger detected"
980 ", continue with VBUS\n");
982 twl6030_start_ac_charger(di);
985 if (stat_set & CONTROLLER_STAT1_FAULT_WDG) {
987 dev_info(di->dev, "Fault watchdog fired\n");
989 if (stat_reset & CONTROLLER_STAT1_FAULT_WDG)
990 dev_err(di->dev, "Fault watchdog recovered\n");
991 if (stat_set & CONTROLLER_STAT1_BAT_REMOVED)
992 dev_err(di->dev, "Battery removed\n");
993 if (stat_reset & CONTROLLER_STAT1_BAT_REMOVED)
994 dev_err(di->dev, "Battery inserted\n");
995 if (stat_set & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
996 dev_err(di->dev, "Battery temperature overrange\n");
997 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
999 if (stat_reset & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
1000 dev_dbg(di->dev, "Battery temperature within range\n");
1001 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1003 if (di->features & TWL6032_SUBCLASS)
1004 twl6032_charger_ctrl_interrupt(di);
1006 if (charger_fault) {
1007 twl6030_stop_usb_charger(di);
1008 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1009 dev_dbg(di->dev, "Charger Fault stop charging\n");
1012 if (di->capacity != -1)
1013 power_supply_changed(&di->bat);
1015 cancel_delayed_work(&di->twl6030_bci_monitor_work);
1016 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
1022 static irqreturn_t twl6030charger_fault_interrupt(int irq, void *_di)
1024 struct twl6030_bci_device_info *di = _di;
1025 int charger_fault = 0;
1028 u8 usb_charge_sts = 0, usb_charge_sts1 = 0, usb_charge_sts2 = 0;
1030 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts,
1031 CHARGERUSB_INT_STATUS);
1035 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts1,
1036 CHARGERUSB_STATUS_INT1);
1040 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts2,
1041 CHARGERUSB_STATUS_INT2);
1045 di->status_int1 = usb_charge_sts1;
1046 di->status_int2 = usb_charge_sts2;
1047 if (usb_charge_sts & CURRENT_TERM_INT)
1048 dev_dbg(di->dev, "USB CURRENT_TERM_INT\n");
1049 if (usb_charge_sts & CHARGERUSB_THMREG)
1050 dev_dbg(di->dev, "USB CHARGERUSB_THMREG\n");
1051 if (usb_charge_sts & CHARGERUSB_FAULT)
1052 dev_dbg(di->dev, "USB CHARGERUSB_FAULT\n");
1054 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TMREG)
1055 dev_dbg(di->dev, "USB CHARGER Thermal regulation activated\n");
1056 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_NO_BAT)
1057 dev_dbg(di->dev, "No Battery Present\n");
1058 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BST_OCP)
1059 dev_dbg(di->dev, "USB CHARGER Boost Over current protection\n");
1060 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1062 dev_dbg(di->dev, "USB CHARGER Thermal Shutdown\n");
1064 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BAT_OVP)
1065 dev_dbg(di->dev, "USB CHARGER Bat Over Voltage Protection\n");
1066 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_POOR_SRC)
1067 dev_dbg(di->dev, "USB CHARGER Poor input source\n");
1068 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1069 dev_dbg(di->dev, "USB CHARGER Sleep mode\n");
1070 if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_VBUS_OVP)
1071 dev_dbg(di->dev, "USB CHARGER VBUS over voltage\n");
1073 if (usb_charge_sts2 & CHARGE_DONE) {
1074 di->charge_status = POWER_SUPPLY_STATUS_FULL;
1075 dev_dbg(di->dev, "USB charge done\n");
1077 if (usb_charge_sts2 & CURRENT_TERM)
1078 dev_dbg(di->dev, "USB CURRENT_TERM\n");
1079 if (usb_charge_sts2 & ICCLOOP)
1080 dev_dbg(di->dev, "USB ICCLOOP\n");
1081 if (usb_charge_sts2 & ANTICOLLAPSE)
1082 dev_dbg(di->dev, "USB ANTICOLLAPSE\n");
1084 if (charger_fault) {
1085 twl6030_stop_usb_charger(di);
1086 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1087 dev_dbg(di->dev, "Charger Fault stop charging\n");
1089 dev_info(di->dev, "Charger fault detected STS, INT1, INT2 %x %x %x\n",
1090 usb_charge_sts, usb_charge_sts1, usb_charge_sts2);
1092 power_supply_changed(&di->bat);
1098 * In HW charger mode on 6032 irq routines must only deal with updating
1099 * state of charger. The hardware deals with start/stop conditions
1102 static irqreturn_t twl6032charger_ctrl_interrupt_hw(int irq, void *_di)
1104 struct twl6030_bci_device_info *di = _di;
1106 int charger_stop = 0, end_of_charge = 0;
1109 //printk("xxxxxxxxxxxxxxxxxxxxxxxx twl6032charger_ctrl_interrupt_hw xxxxxxxxxxxxxx\n");
1110 /* read charger controller_stat1 */
1111 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1116 ret = twl_i2c_read_u8(TWL6032_MODULE_CHARGER, &linear,
1121 if (!(stat1 & (VBUS_DET | VAC_DET))) {
1123 di->ac_online = di->usb_online = 0;
1124 //printk("%%%%%%%%%%%%%%charger_stop = 1%%%%%%%%%%%%%\n");
1127 if (!(di->usb_online || di->ac_online)) {
1128 if (stat1 & VBUS_DET) {
1130 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1131 // printk("%%%%%%%%%%%%%%di->usb_online = 1%%%%%%%%%%%%%\n");
1133 //schedule_work(&di->usb_work);
1134 } else if (stat1 & VAC_DET) {
1136 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1137 // printk("%%%%%%%%%%%%%%di->ac_online = 1%%%%%%%%%%%%%\n");
1141 if (stat1 & CONTROLLER_STAT1_FAULT_WDG) {
1143 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1144 dev_err(di->dev, "Charger error : Fault watchdog\n");
1146 if (stat1 & CONTROLLER_STAT1_BAT_REMOVED) {
1148 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1149 dev_info(di->dev, "Battery removed\n");
1151 if (stat1 & CONTROLLER_STAT1_BAT_TEMP_OVRANGE) {
1154 "Charger error : Battery temperature overrange\n");
1155 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1158 if ((stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
1159 di->use_power_path) {
1163 if (linear & LINEAR_CHRG_STS_CRYSTL_OSC_OK) {
1164 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1165 dev_dbg(di->dev, "Charger error: CRYSTAL OSC OK\n");
1168 if (linear & LINEAR_CHRG_STS_END_OF_CHARGE) {
1170 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1171 dev_dbg(di->dev, "Charger: Full charge\n");
1174 if (linear & LINEAR_CHRG_STS_VBATOV) {
1175 di->bat_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1177 "Charger error : Linear Status: VBATOV\n");
1180 if (linear & LINEAR_CHRG_STS_VSYSOV) {
1181 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1183 "Charger error : Linear Status: VSYSOV\n");
1188 if (!(stat1 & (VBUS_DET | VAC_DET))) {
1189 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1193 POWER_SUPPLY_STATUS_FULL;
1196 POWER_SUPPLY_STATUS_NOT_CHARGING;
1199 //printk("%%%%%%%%%%%%%%%%%%twl6032charger_ctrl_interrupt_hw end xxxxxxxxxxxxxx\n");
1201 power_supply_changed(&di->bat);
1207 static irqreturn_t twl6032charger_fault_interrupt_hw(int irq, void *_di)
1209 struct twl6030_bci_device_info *di = _di;
1210 int charger_stop = 0, charger_start = 0;
1212 u8 sts, sts_int1, sts_int2, stat1;
1214 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts,
1215 CHARGERUSB_INT_STATUS);
1219 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int1,
1220 CHARGERUSB_STATUS_INT1);
1224 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &sts_int2,
1225 CHARGERUSB_STATUS_INT2);
1229 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
1234 if (sts & EN_LINCH) {
1236 dev_dbg(di->dev, "Charger: EN_LINCH\n");
1240 if ((sts & CURRENT_TERM_INT) && !di->use_power_path) {
1241 dev_dbg(di->dev, "Charger: CURRENT_TERM_INT\n");
1243 if (sts_int2 & CURRENT_TERM) {
1245 dev_dbg(di->dev, "Charger error: CURRENT_TERM\n");
1249 if (sts & CHARGERUSB_STAT) {
1250 dev_dbg(di->dev, "Charger: CHARGEUSB_STAT\n");
1252 if (sts_int2 & ANTICOLLAPSE)
1253 dev_dbg(di->dev, "Charger error: ANTICOLLAPSE\n");
1256 if (sts & CHARGERUSB_THMREG) {
1257 dev_dbg(di->dev, "Charger: CHARGERUSB_THMREG\n");
1259 if (sts_int1 & CHARGERUSB_STATUS_INT1_TMREG)
1260 dev_dbg(di->dev, "Charger error: TMREG\n");
1263 if (sts & CHARGERUSB_FAULT) {
1264 dev_dbg(di->dev, "Charger: CHARGERUSB_FAULT\n");
1268 if (!di->use_power_path) {
1269 if (sts_int1 & CHARGERUSB_STATUS_INT1_NO_BAT) {
1270 di->bat_health = POWER_SUPPLY_HEALTH_DEAD;
1272 "Charger error : NO_BAT\n");
1274 if (sts_int1 & CHARGERUSB_STATUS_INT1_BAT_OVP) {
1276 POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1277 dev_dbg(di->dev, "Charger error : BAT_OVP\n");
1281 if (sts_int1 & CHARGERUSB_STATUS_INT1_BST_OCP) {
1282 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1283 printk(KERN_ERR "Charger error : BST_OCP\n");
1285 if (sts_int1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
1286 di->bat_health = POWER_SUPPLY_HEALTH_OVERHEAT;
1287 printk(KERN_ERR "Charger error : TH_SHUTD\n");
1289 if (sts_int1 & CHARGERUSB_STATUS_INT1_POOR_SRC) {
1290 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1291 printk(KERN_ERR "Charger error : POOR_SRC\n");
1293 if (sts_int1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
1294 dev_dbg(di->dev, "Charger error: SLP_MODE\n");
1296 if (sts_int1 & CHARGERUSB_STATUS_INT1_VBUS_OVP) {
1297 di->bat_health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1298 printk(KERN_ERR "Charger error : VBUS_OVP\n");
1303 if (!(stat1 & (VBUS_DET | VAC_DET)))
1304 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1306 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1310 if (charger_start) {
1311 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1312 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
1315 power_supply_changed(&di->bat);
1320 static void twl6030battery_current(struct twl6030_bci_device_info *di)
1325 int current_now = 0;
1327 /* FG_REG_10, 11 is 14 bit signed instantaneous current sample value */
1328 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *)&read_value,
1331 dev_info(di->dev, "failed to read FG_REG_10: current_now\n");
1335 temp = ((s16)(read_value << 2) >> 2);
1336 current_now = temp - di->cc_offset;
1338 /* current drawn per sec */
1339 current_now = current_now * fuelgauge_rate[di->fuelgauge_mode];
1340 /* current in mAmperes */
1341 current_now = (current_now * di->current_max_scale) >> 13;
1342 /* current in uAmperes */
1343 current_now = current_now * 1000;
1344 di->current_uA = current_now;
1350 * Setup the twl6030 BCI module to enable backup
1353 static int twl6030backupbatt_setup(void)
1358 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, BBSPOR_CFG);
1362 rd_reg |= BB_CHG_EN;
1363 ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, BBSPOR_CFG);
1369 * Setup the twl6030 BCI module to measure battery
1372 static int twl6030battery_temp_setup(bool enable)
1377 ret = twl_i2c_read_u8(TWL_MODULE_MADC, &rd_reg, TWL6030_GPADC_CTRL);
1382 rd_reg |= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1383 GPADC_CTRL_TEMP1_EN_MONITOR |
1384 GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1386 rd_reg ^= (GPADC_CTRL_TEMP1_EN | GPADC_CTRL_TEMP2_EN |
1387 GPADC_CTRL_TEMP1_EN_MONITOR |
1388 GPADC_CTRL_TEMP2_EN_MONITOR | GPADC_CTRL_SCALER_DIV4);
1390 ret = twl_i2c_write_u8(TWL_MODULE_MADC, rd_reg, TWL6030_GPADC_CTRL);
1395 static int twl6030battery_voltage_setup(struct twl6030_bci_device_info *di)
1400 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &rd_reg, REG_MISC1);
1404 rd_reg = rd_reg | VAC_MEAS | VBAT_MEAS | BB_MEAS;
1405 ret = twl_i2c_write_u8(TWL6030_MODULE_ID0, rd_reg, REG_MISC1);
1409 ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_VBUS_CTRL_SET);
1413 rd_reg = rd_reg | VBUS_MEAS;
1414 ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_VBUS_CTRL_SET);
1418 ret = twl_i2c_read_u8(TWL_MODULE_USB, &rd_reg, REG_USB_ID_CTRL_SET);
1422 rd_reg = rd_reg | ID_MEAS;
1423 ret = twl_i2c_write_u8(TWL_MODULE_USB, rd_reg, REG_USB_ID_CTRL_SET);
1427 if (di->features & TWL6032_SUBCLASS)
1428 ret = twl_i2c_write_u8(TWL_MODULE_MADC,
1429 GPADC_CTRL2_CH18_SCALER_EN,
1430 TWL6030_GPADC_CTRL2);
1435 static int twl6030battery_current_setup(bool enable)
1441 * Writing 0 to REG_TOGGLE1 has no effect, so
1442 * can directly set/reset FG.
1445 reg = FGDITHS | FGS;
1447 reg = FGDITHR | FGR;
1449 ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, reg, REG_TOGGLE1);
1453 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
1458 static enum power_supply_property twl6030_bci_battery_props[] = {
1459 POWER_SUPPLY_PROP_STATUS,
1460 POWER_SUPPLY_PROP_HEALTH,
1461 POWER_SUPPLY_PROP_ONLINE,
1462 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1463 POWER_SUPPLY_PROP_CURRENT_NOW,
1464 POWER_SUPPLY_PROP_CURRENT_AVG,
1465 POWER_SUPPLY_PROP_CAPACITY,
1466 POWER_SUPPLY_PROP_TEMP,
1469 static enum power_supply_property twl6030_usb_props[] = {
1470 POWER_SUPPLY_PROP_ONLINE,
1471 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1474 static enum power_supply_property twl6030_ac_props[] = {
1475 POWER_SUPPLY_PROP_ONLINE,
1476 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1479 static enum power_supply_property twl6030_bk_bci_battery_props[] = {
1480 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1483 static void twl6030_current_avg(struct work_struct *work)
1485 // printk("%s\n", __func__);
1489 int current_avg_uA = 0;
1491 struct twl6030_bci_device_info *di = container_of(work,
1492 struct twl6030_bci_device_info,
1493 twl6030_current_avg_work.work);
1495 di->charge_n2 = di->charge_n1;
1496 di->timer_n2 = di->timer_n1;
1498 /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1499 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1504 * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1505 * accumulates instantaneous current value
1507 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1511 /* FG_REG_08, 09 is 10 bit signed calibration offset value */
1512 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &cc_offset,
1516 cc_offset = ((s16)(cc_offset << 6) >> 6);
1517 di->cc_offset = cc_offset;
1519 samples = di->timer_n1 - di->timer_n2;
1520 /* check for timer overflow */
1521 if (di->timer_n1 < di->timer_n2)
1522 samples = samples + (1 << 24);
1524 /* offset is accumulative over number of samples */
1525 cc_offset = cc_offset * samples;
1527 current_avg_uA = ((di->charge_n1 - di->charge_n2 - cc_offset)
1528 * di->current_max_scale) /
1529 fuelgauge_rate[di->fuelgauge_mode];
1530 /* clock is a fixed 32Khz */
1531 current_avg_uA >>= 15;
1533 /* Correct for the fuelguage sampling rate */
1534 samples /= fuelgauge_rate[di->fuelgauge_mode] * 4;
1537 * Only update the current average if we have had a valid number
1538 * of samples in the accumulation.
1541 current_avg_uA = current_avg_uA / samples;
1542 di->current_avg_uA = current_avg_uA * 1000;
1545 queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work,
1546 msecs_to_jiffies(1000 * di->current_avg_interval));
1549 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1552 struct batt_vol_cal{
1557 static struct batt_vol_cal batt_table[BATT_NUM] = {
1558 {0,3571,3730},//{1,3420,3525},{2,3420,3575},{3,3475,3600},{5,3505,3620},{7,3525,3644},
1559 {9,3628,3770},//{11,3557,3670},{13,3570,3684},{15,3580,3700},{17,3610,3715},
1560 {19,3670,3878},//{21,3640,3748},{23,3652,3756},{25,3662,3775},{27,3672,3790},
1561 {29,3719,3895},//{31,3687,3814},{33,3693,3818},{35,3699,3822},{37,3705,3825},
1562 {39,3770,3941},//{41,3714,3832},{43,3718,3834},{45,3722,3836},{47,3726,3837},
1563 {49,3801,3980},//{51,3734,3841},{53,3738,3842},{55,3742,3844},{57,3746,3844},
1564 {59,3849,4010},//{61,3756,3860},{63,3764,3864},{65,3774,3871},{67,3786,3890},
1565 {69,3864,4024},//{71,3808,3930},{73,3817,3977},{75,3827,3977},{77,3845,3997},
1566 {79,3884,4040},//{81,3964,4047},{83,3982,4064},{85,4002,4080},{87,4026,4096},
1567 {89,4001,4050},//{91,4034,4144},{93,4055,4150},{95,4085,4195},{97,4085,4195},
1571 static int capacity_changed(struct twl6030_bci_device_info *di)
1573 int curr_capacity = di->capacity;
1574 int charger_source = di->charger_source;
1575 int charging_disabled = 0;
1576 struct batt_vol_cal *p;
1580 /* Because system load is always greater than
1581 * termination current, we will never get a CHARGE DONE
1582 * int from BQ. And charging will alwys be in progress.
1583 * We consider Vbat>3900 to be a full battery.
1584 * Since Voltage measured during charging is Voreg ~4.2v,
1585 * we dont update capacity if we are charging.
1588 /* if it has been more than 10 minutes since our last update
1589 * and we are charging we force a update.
1591 if (time_after(jiffies, di->ac_next_refresh)
1592 && (di->charger_source != POWER_SUPPLY_TYPE_BATTERY)) {
1593 charging_disabled = 1;
1594 di->ac_next_refresh = jiffies +
1595 msecs_to_jiffies(CHARGING_CAPACITY_UPDATE_PERIOD);
1598 /* We have to disable charging to read correct
1601 twl6030_stop_charger(di);
1602 /*voltage setteling time*/
1604 di->voltage_mV = twl6030_get_gpadc_conversion(di,
1605 di->gpadc_vbat_chnl);
1609 /* Setting the capacity level only makes sense when on
1610 * the battery is powering the board.
1612 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){ //charge
1613 if(di->voltage_mV >= p[BATT_NUM - 1].charge_vol){
1614 curr_capacity = 100;
1617 if(di->voltage_mV <= p[0].charge_vol){
1621 for(i = 0; i < BATT_NUM - 1; i++){
1623 if((p[i].charge_vol <= di->voltage_mV) && (di->voltage_mV < (p[i+1].charge_vol))){
1624 curr_capacity = p[i].disp_cal ;
1632 else if (di->charge_status == POWER_SUPPLY_STATUS_DISCHARGING){ //discharge
1633 if(di->voltage_mV >= p[BATT_NUM - 1].dis_charge_vol){
1634 curr_capacity = 100;
1637 if(di->voltage_mV <= p[0].dis_charge_vol){
1641 for(i = 0; i < BATT_NUM - 1; i++){
1642 if(((p[i].dis_charge_vol) <= di->voltage_mV) && (di->voltage_mV < (p[i+1].dis_charge_vol))){
1643 curr_capacity = p[i].disp_cal ;
1655 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING) {
1656 if (di->voltage_mV < 3520)
1658 else if (di->voltage_mV < 3600 && di->voltage_mV >= 3500)
1660 else if (di->voltage_mV < 3700 && di->voltage_mV >= 3600)
1662 else if (di->voltage_mV < 3800 && di->voltage_mV >= 3700)
1664 else if (di->voltage_mV < 3900 && di->voltage_mV >= 3800)
1666 else if (di->voltage_mV >= 3900)
1667 curr_capacity = 100;
1673 /* if we disabled charging to check capacity,
1674 * enable it again after we read the
1677 if (charging_disabled) {
1678 if (charger_source == POWER_SUPPLY_TYPE_MAINS)
1679 twl6030_start_ac_charger(di);
1680 else if (charger_source == POWER_SUPPLY_TYPE_USB)
1681 twl6030_start_usb_charger(di);
1684 /* if battery is not present we assume it is on battery simulator and
1685 * current capacity is set to 100%
1687 if (!is_battery_present(di))
1688 curr_capacity = 100;
1691 /* Debouncing of voltage change. */
1692 if (di->capacity == -1) {
1693 di->capacity = curr_capacity;
1694 di->capacity_debounce_count = 0;
1698 if (curr_capacity != di->prev_capacity) {
1699 di->prev_capacity = curr_capacity;
1700 di->capacity_debounce_count = 0;
1701 } else if (++di->capacity_debounce_count >= 4) {
1702 di->capacity = curr_capacity;
1703 di->capacity_debounce_count = 0;
1710 static int twl6030_batt_vol_to_capacity (struct twl6030_bci_device_info *di)
1718 struct batt_vol_cal *p;
1721 BatVoltage = di ->voltage_mV;
1723 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){ //charge
1724 if(BatVoltage >= (p[BATT_NUM - 1].charge_vol)){
1728 if(BatVoltage <= (p[0].charge_vol)){
1732 for(i = 0; i < BATT_NUM - 1; i++){
1734 if(((p[i].charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].charge_vol))){
1735 // capacity = p[i].disp_cal ;
1736 capacity = i * 10 + ((BatVoltage - p[i].charge_vol) * 10) / (p[i+1] .charge_vol- p[i].charge_vol);
1747 if(BatVoltage >= (p[BATT_NUM - 1].dis_charge_vol)){
1751 if(BatVoltage <= (p[0].dis_charge_vol)){
1755 for(i = 0; i < BATT_NUM - 1; i++){
1756 if(((p[i].dis_charge_vol) <= BatVoltage) && (BatVoltage < (p[i+1].dis_charge_vol))){
1757 // capacity = p[i].disp_cal ;
1758 capacity = i * 10 + ((BatVoltage - p[i].dis_charge_vol) * 10) / (p[i+1] .dis_charge_vol- p[i].dis_charge_vol);
1775 static void twl6030_batt_capacity_samples(struct twl6030_bci_device_info *di)
1778 capacity = twl6030_batt_vol_to_capacity (di);
1779 twl6030battery_current(di);
1781 if( 1 == di->resume_status ){
1782 di->resume_status = 0;
1783 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){\
1784 if (di->suspend_capacity > capacity){
1786 di->capacity = di->suspend_capacity;
1788 di->capacity = capacity;
1791 if (di->suspend_capacity > capacity){
1792 di->capacity = capacity;
1794 di->capacity = di->suspend_capacity;
1802 if (di->charge_status == POWER_SUPPLY_STATUS_FULL){
1803 if (capacity < di->capacity){
1804 if (di ->gBatCapacityChargeCnt >= NUM_CHARGE_MIN_SAMPLE){
1805 di ->gBatCapacityChargeCnt = 0;
1806 if (di -> capacity < 99){
1816 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING){
1817 if (capacity > di->capacity){
1818 //ʵ¼Ê²ÉÑùµ½µÄÈÝÁ¿±ÈÏÔʾµÄÈÝÁ¿´ó£¬Öð¼¶ÉÏÉý
1819 if (++(di->gBatCapacityChargeCnt) >= NUM_CHARGE_MIN_SAMPLE){
1820 di ->gBatCapacityChargeCnt = 0;
1821 if (di -> capacity < 99){
1826 di->gBatCapacityDisChargeCnt = 0; //·ÅµçµÄ¼ÆÊýֵΪ0
1830 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
1831 if ((di->charge_status == POWER_SUPPLY_STATUS_DISCHARGING)||(di->charge_status == POWER_SUPPLY_STATUS_NOT_CHARGING)){
1833 //·Åµçʱ,Ö»ÔÊÐíµçѹϽµ
1834 if (capacity < di -> capacity){
1835 if (++(di->gBatCapacityDisChargeCnt) >= NUM_DISCHARGE_MIN_SAMPLE){
1836 di ->gBatCapacityDisChargeCnt = 0;
1837 if (di -> capacity > 0){
1839 //bat->bat_change = 1;
1844 di ->gBatCapacityDisChargeCnt = 0;
1846 //di ->gBatCapacityChargeCnt = 0;
1848 di ->capacitytmp = capacity;
1851 static int twl6030_set_watchdog(struct twl6030_bci_device_info *di, int val)
1853 di->watchdog_duration = val;
1855 dev_dbg(di->dev, "Watchdog reset %d", val);
1857 return twl_i2c_write_u8(TWL6030_MODULE_CHARGER, val, CONTROLLER_WDG);
1861 static void twl6030_bci_adc_set(struct twl6030_bci_device_info *di)
1863 struct twl6030_gpadc_request req;
1869 /* Kick the charger watchdog */
1870 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING)
1871 twl6030_set_watchdog(di, di->watchdog_duration);
1873 req.method = TWL6030_GPADC_SW2;
1874 req.channels = (1 << 1) | (1 << di->gpadc_vbat_chnl) | (1 << 8);
1877 ret = twl6030_gpadc_conversion(&req);
1881 dev_dbg(di->dev, "gpadc conversion failed: %d\n", ret);
1885 if (req.rbuf[di->gpadc_vbat_chnl] > 0)
1886 di->voltage_mV = req.rbuf[di->gpadc_vbat_chnl];
1888 if (req.rbuf[8] > 0)
1889 di->bk_voltage_mV = req.rbuf[8];
1891 if (di->platform_data->battery_tmp_tbl == NULL)
1894 adc_code = req.rbuf[1];
1895 for (temp = 0; temp < di->platform_data->tblsize; temp++) {
1896 if (adc_code >= di->platform_data->
1897 battery_tmp_tbl[temp])
1900 //printk("twl6030_bci_adc_set---di->voltage_mV-=-%d,di->capacity = %d \n",di->voltage_mV,di->capacity);
1901 /* first 2 values are for negative temperature */
1905 static void twl6030_bci_battery_work(struct work_struct *work)
1908 struct twl6030_bci_device_info *di = container_of(work,
1909 struct twl6030_bci_device_info, twl6030_bci_monitor_work.work);
1910 struct twl6030_gpadc_request req;
1916 /* Kick the charger watchdog */
1917 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING)
1918 twl6030_set_watchdog(di, di->watchdog_duration);
1920 req.method = TWL6030_GPADC_SW2;
1921 req.channels = (1 << 1) | (1 << di->gpadc_vbat_chnl) | (1 << 8);
1924 ret = twl6030_gpadc_conversion(&req);
1926 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work,
1927 msecs_to_jiffies(TIMER_MS_COUNTS)); //* di->monitoring_interval
1930 dev_dbg(di->dev, "gpadc conversion failed: %d\n", ret);
1934 if (req.rbuf[di->gpadc_vbat_chnl] > 0)
1935 di->voltage_mV = req.rbuf[di->gpadc_vbat_chnl];
1937 if (req.rbuf[8] > 0)
1938 di->bk_voltage_mV = req.rbuf[8];
1940 if (di->platform_data->battery_tmp_tbl == NULL)
1943 adc_code = req.rbuf[1];
1944 for (temp = 0; temp < di->platform_data->tblsize; temp++) {
1945 if (adc_code >= di->platform_data->
1946 battery_tmp_tbl[temp])
1949 //printk("workxxxxx---di->voltage_mV-=-%d,di->capacity = %d \n",di->voltage_mV,di->capacity);
1950 /* first 2 values are for negative temperature */
1951 di->temp_C = (temp - 2); /* in degrees Celsius */
1952 // if (capacity_changed(di)) //xsf
1954 twl6030_batt_capacity_samples(di);
1955 // di->capacity = level;
1956 power_supply_changed(&di->bat);
1960 static void twl6030_current_mode_changed(struct twl6030_bci_device_info *di)
1963 //printk("%s\n", __func__);
1965 /* FG_REG_01, 02, 03 is 24 bit unsigned sample counter value */
1966 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->timer_n1,
1971 * FG_REG_04, 5, 6, 7 is 32 bit signed accumulator value
1972 * accumulates instantaneous current value
1974 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &di->charge_n1,
1979 cancel_delayed_work(&di->twl6030_current_avg_work);
1980 queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work,
1981 msecs_to_jiffies(1000 * di->current_avg_interval));
1984 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
1987 static void twl6030_work_interval_changed(struct twl6030_bci_device_info *di)
1989 //printk("%s\n", __func__);
1991 cancel_delayed_work(&di->twl6030_bci_monitor_work);
1992 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work,
1993 msecs_to_jiffies(1000 * di->monitoring_interval));
1996 #define to_twl6030_bci_device_info(x) container_of((x), \
1997 struct twl6030_bci_device_info, bat);
1999 static void twl6030_bci_battery_external_power_changed(struct power_supply *psy)
2000 {// printk("%s\n", __func__);
2002 struct twl6030_bci_device_info *di = to_twl6030_bci_device_info(psy);
2004 cancel_delayed_work(&di->twl6030_bci_monitor_work);
2005 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
2009 #define to_twl6030_ac_device_info(x) container_of((x), \
2010 struct twl6030_bci_device_info, ac);
2012 static int twl6030_ac_get_property(struct power_supply *psy,
2013 enum power_supply_property psp,
2014 union power_supply_propval *val)
2017 struct twl6030_bci_device_info *di = to_twl6030_ac_device_info(psy);
2019 case POWER_SUPPLY_PROP_ONLINE:
2020 twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
2023 if (stat1 & VAC_DET) {
2029 ///printk("&&&&&&&&&&&&ac---charge ac->intval = %d &&&&&&&&&&&&&&&\n" ,val->intval);
2032 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2033 val->intval = twl6030_get_gpadc_conversion(di, 9) * 1000;
2043 #define to_twl6030_usb_device_info(x) container_of((x), \
2044 struct twl6030_bci_device_info, usb);
2046 static int twl6030_usb_get_property(struct power_supply *psy,
2047 enum power_supply_property psp,
2048 union power_supply_propval *val)
2051 struct twl6030_bci_device_info *di = to_twl6030_usb_device_info(psy);
2053 case POWER_SUPPLY_PROP_ONLINE:
2055 twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &stat1,
2058 if (stat1 & VBUS_DET) {
2064 //val->intval = di->usb_online; //xsf
2066 //printk("&&&&&&&&&&&&usb---charge val->intval = %d &&&&&&&&&&&&&&&\n" ,val->intval);
2068 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2069 val->intval = twl6030_get_gpadc_conversion(di, 10) * 1000;
2070 //printk("&&&&&&&&&&&&usb-voltage = &&&&&&&&&&&&&&&%d\n", val->intval);
2079 #define to_twl6030_bk_bci_device_info(x) container_of((x), \
2080 struct twl6030_bci_device_info, bk_bat);
2082 static int twl6030_bk_bci_battery_get_property(struct power_supply *psy,
2083 enum power_supply_property psp,
2084 union power_supply_propval *val)
2086 struct twl6030_bci_device_info *di = to_twl6030_bk_bci_device_info(psy);
2089 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2090 val->intval = di->bk_voltage_mV * 1000;
2099 static int twl6030_bci_battery_get_property(struct power_supply *psy,
2100 enum power_supply_property psp,
2101 union power_supply_propval *val)
2103 struct twl6030_bci_device_info *di;
2105 di = to_twl6030_bci_device_info(psy);
2108 case POWER_SUPPLY_PROP_STATUS:
2109 val->intval = di->charge_status;
2111 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2112 di->voltage_mV = twl6030_get_gpadc_conversion(di,
2113 di->gpadc_vbat_chnl);
2114 val->intval = di->voltage_mV * 1000;
2116 case POWER_SUPPLY_PROP_CURRENT_NOW:
2117 twl6030battery_current(di);
2118 val->intval = di->current_uA;
2120 case POWER_SUPPLY_PROP_TEMP:
2121 val->intval = di->temp_C;
2123 case POWER_SUPPLY_PROP_ONLINE:
2124 val->intval = di->charger_source;
2126 case POWER_SUPPLY_PROP_CURRENT_AVG:
2127 val->intval = di->current_avg_uA;
2129 case POWER_SUPPLY_PROP_HEALTH:
2130 val->intval = di->bat_health;
2132 case POWER_SUPPLY_PROP_CAPACITY:
2133 val->intval = di->capacity;
2141 int twl6030_register_notifier(struct notifier_block *nb,
2142 unsigned int events)
2144 return blocking_notifier_chain_register(¬ifier_list, nb);
2146 EXPORT_SYMBOL_GPL(twl6030_register_notifier);
2148 int twl6030_unregister_notifier(struct notifier_block *nb,
2149 unsigned int events)
2151 return blocking_notifier_chain_unregister(¬ifier_list, nb);
2153 EXPORT_SYMBOL_GPL(twl6030_unregister_notifier);
2155 static void twl6030_usb_charger_work(struct work_struct *work)
2157 struct twl6030_bci_device_info *di =
2158 container_of(work, struct twl6030_bci_device_info, usb_work);
2159 switch (di->event) {
2160 case USB_EVENT_CHARGER:
2161 /* POWER_SUPPLY_TYPE_USB_DCP */
2162 di->usb_online = POWER_SUPPLY_TYPE_USB_DCP;
2163 di->charger_incurrentmA = 1800;
2165 case USB_EVENT_VBUS:
2166 switch (di->usb_online) {
2167 case POWER_SUPPLY_TYPE_USB_CDP:
2169 * Only 500mA here or high speed chirp
2170 * handshaking may break
2172 di->charger_incurrentmA = 500;
2173 case POWER_SUPPLY_TYPE_USB:
2177 case USB_EVENT_NONE:
2179 di->charger_incurrentmA = 0;
2181 case USB_EVENT_ENUMERATED:
2182 if (di->usb_online == POWER_SUPPLY_TYPE_USB_CDP)
2183 di->charger_incurrentmA = 560;
2185 di->charger_incurrentmA = di->usb_max_power;
2190 twl6030_start_usb_charger(di);
2192 power_supply_changed(&di->usb);
2195 static int twl6030_usb_notifier_call(struct notifier_block *nb,
2196 unsigned long event, void *data)
2198 struct twl6030_bci_device_info *di =
2199 container_of(nb, struct twl6030_bci_device_info, nb);
2202 case USB_EVENT_VBUS:
2203 di->usb_online = *((unsigned int *) data);
2205 case USB_EVENT_ENUMERATED:
2206 di->usb_max_power = *((unsigned int *) data);
2208 case USB_EVENT_CHARGER:
2209 case USB_EVENT_NONE:
2216 schedule_work(&di->usb_work);
2221 static ssize_t set_fg_mode(struct device *dev,
2222 struct device_attribute *attr, const char *buf, size_t count)
2227 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2229 if ((strict_strtol(buf, 10, &val) < 0) || (val > 3))
2231 di->fuelgauge_mode = val;
2232 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, (val << 6) | CC_CAL_EN,
2236 twl6030_current_mode_changed(di);
2240 static ssize_t show_fg_mode(struct device *dev,
2241 struct device_attribute *attr, char *buf)
2244 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2246 val = di->fuelgauge_mode;
2247 return sprintf(buf, "%d\n", val);
2250 static ssize_t set_charge_src(struct device *dev,
2251 struct device_attribute *attr, const char *buf, size_t count)
2255 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2257 if ((strict_strtol(buf, 10, &val) < 0) || (val < 2) || (val > 3))
2259 di->vac_priority = val;
2263 static ssize_t show_charge_src(struct device *dev,
2264 struct device_attribute *attr, char *buf)
2267 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2269 val = di->vac_priority;
2270 return sprintf(buf, "%d\n", val);
2273 static ssize_t show_vbus_voltage(struct device *dev,
2274 struct device_attribute *attr, char *buf)
2277 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2279 val = twl6030_get_gpadc_conversion(di, 10);
2281 return sprintf(buf, "%d\n", val);
2284 static ssize_t show_id_level(struct device *dev, struct device_attribute *attr,
2288 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2290 val = twl6030_get_gpadc_conversion(di, 14);
2292 return sprintf(buf, "%d\n", val);
2295 static ssize_t set_watchdog(struct device *dev,
2296 struct device_attribute *attr, const char *buf, size_t count)
2301 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2303 if ((strict_strtol(buf, 10, &val) < 0) || (val < 1) || (val > 127))
2305 ret = twl6030_set_watchdog(di, val);
2312 static ssize_t show_watchdog(struct device *dev,
2313 struct device_attribute *attr, char *buf)
2316 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2318 val = di->watchdog_duration;
2319 return sprintf(buf, "%d\n", val);
2322 static ssize_t show_fg_counter(struct device *dev,
2323 struct device_attribute *attr, char *buf)
2328 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_counter,
2332 return sprintf(buf, "%d\n", fg_counter);
2335 static ssize_t show_fg_accumulator(struct device *dev,
2336 struct device_attribute *attr, char *buf)
2341 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_accum,
2346 return sprintf(buf, "%ld\n", fg_accum);
2349 static ssize_t show_fg_offset(struct device *dev,
2350 struct device_attribute *attr, char *buf)
2355 ret = twl_i2c_read(TWL6030_MODULE_GASGAUGE, (u8 *) &fg_offset,
2359 fg_offset = ((s16)(fg_offset << 6) >> 6);
2361 return sprintf(buf, "%d\n", fg_offset);
2364 static ssize_t set_fg_clear(struct device *dev, struct device_attribute *attr,
2365 const char *buf, size_t count)
2371 if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2373 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_AUTOCLEAR,
2381 static ssize_t set_fg_cal(struct device *dev, struct device_attribute *attr,
2382 const char *buf, size_t count)
2388 if ((strict_strtol(buf, 10, &val) < 0) || (val != 1))
2390 ret = twl_i2c_write_u8(TWL6030_MODULE_GASGAUGE, CC_CAL_EN, FG_REG_00);
2397 static ssize_t set_charging(struct device *dev, struct device_attribute *attr,
2398 const char *buf, size_t count)
2401 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2403 if (strncmp(buf, "startac", 7) == 0) {
2404 if (di->charger_source == POWER_SUPPLY_TYPE_USB)
2405 twl6030_stop_usb_charger(di);
2406 twl6030_start_ac_charger(di);
2407 } else if (strncmp(buf, "startusb", 8) == 0) {
2408 if (di->charger_source == POWER_SUPPLY_TYPE_MAINS)
2409 twl6030_stop_ac_charger(di);
2410 di->charger_source = POWER_SUPPLY_TYPE_USB;
2411 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
2412 twl6030_start_usb_charger(di);
2413 } else if (strncmp(buf, "stop" , 4) == 0)
2414 twl6030_stop_charger(di);
2421 static ssize_t set_regulation_voltage(struct device *dev,
2422 struct device_attribute *attr, const char *buf, size_t count)
2426 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2428 if ((strict_strtol(buf, 10, &val) < 0) || (val < 3500)
2429 || (val > di->platform_data->max_charger_voltagemV))
2431 di->platform_data->max_bat_voltagemV = val;
2432 twl6030_config_voreg_reg(di, val);
2437 static ssize_t show_regulation_voltage(struct device *dev,
2438 struct device_attribute *attr, char *buf)
2441 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2443 val = di->platform_data->max_bat_voltagemV;
2444 return sprintf(buf, "%u\n", val);
2447 static ssize_t set_termination_current(struct device *dev,
2448 struct device_attribute *attr, const char *buf, size_t count)
2452 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2454 if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 400))
2456 di->platform_data->termination_currentmA = val;
2457 twl6030_config_iterm_reg(di, val);
2462 static ssize_t show_termination_current(struct device *dev,
2463 struct device_attribute *attr, char *buf)
2466 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2468 val = di->platform_data->termination_currentmA;
2469 return sprintf(buf, "%u\n", val);
2472 static ssize_t set_cin_limit(struct device *dev,
2473 struct device_attribute *attr, const char *buf, size_t count)
2477 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2479 if ((strict_strtol(buf, 10, &val) < 0) || (val < 50) || (val > 1500))
2481 di->charger_incurrentmA = val;
2482 twl6030_config_cinlimit_reg(di, val);
2487 static ssize_t show_cin_limit(struct device *dev, struct device_attribute *attr,
2491 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2493 val = di->charger_incurrentmA;
2494 return sprintf(buf, "%u\n", val);
2497 static ssize_t set_charge_current(struct device *dev,
2498 struct device_attribute *attr, const char *buf, size_t count)
2502 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2504 if ((strict_strtol(buf, 10, &val) < 0) || (val < 300)
2505 || (val > di->platform_data->max_charger_currentmA))
2507 di->charger_outcurrentmA = val;
2508 twl6030_config_vichrg_reg(di, val);
2513 static ssize_t show_charge_current(struct device *dev,
2514 struct device_attribute *attr, char *buf)
2517 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2519 val = di->charger_outcurrentmA;
2520 return sprintf(buf, "%u\n", val);
2523 static ssize_t set_min_vbus(struct device *dev, struct device_attribute *attr,
2524 const char *buf, size_t count)
2528 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2530 if ((strict_strtol(buf, 10, &val) < 0) || (val < 4200) || (val > 4760))
2533 twl6030_config_min_vbus_reg(di, val);
2538 static ssize_t show_min_vbus(struct device *dev, struct device_attribute *attr,
2542 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2545 return sprintf(buf, "%u\n", val);
2548 static ssize_t set_current_avg_interval(struct device *dev,
2549 struct device_attribute *attr, const char *buf, size_t count)
2553 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2555 if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2557 di->current_avg_interval = val;
2558 twl6030_current_mode_changed(di);
2563 static ssize_t show_current_avg_interval(struct device *dev,
2564 struct device_attribute *attr, char *buf)
2567 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2569 val = di->current_avg_interval;
2570 return sprintf(buf, "%u\n", val);
2573 static ssize_t set_wakelock_enable(struct device *dev,
2574 struct device_attribute *attr, const char *buf, size_t count)
2578 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2580 if ((strict_strtol(buf, 10, &val) < 0) || (val < 0) || (val > 1))
2583 if ((val) && (di->charger_source == POWER_SUPPLY_TYPE_MAINS))
2584 wake_lock(&chrg_lock);
2586 wake_unlock(&chrg_lock);
2588 di->wakelock_enabled = val;
2592 static ssize_t show_wakelock_enable(struct device *dev,
2593 struct device_attribute *attr, char *buf)
2596 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2598 val = di->wakelock_enabled;
2599 return sprintf(buf, "%u\n", val);
2602 static ssize_t set_monitoring_interval(struct device *dev,
2603 struct device_attribute *attr, const char *buf, size_t count)
2607 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2609 if ((strict_strtol(buf, 10, &val) < 0) || (val < 10) || (val > 3600))
2611 di->monitoring_interval = val;
2612 twl6030_work_interval_changed(di);
2617 static ssize_t show_monitoring_interval(struct device *dev,
2618 struct device_attribute *attr, char *buf)
2621 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2623 val = di->monitoring_interval;
2624 return sprintf(buf, "%u\n", val);
2627 static ssize_t show_bsi(struct device *dev,
2628 struct device_attribute *attr, char *buf)
2631 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2633 val = twl6030_get_gpadc_conversion(di, 0);
2634 return sprintf(buf, "%d\n", val);
2637 static ssize_t show_stat1(struct device *dev,
2638 struct device_attribute *attr, char *buf)
2641 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2644 return sprintf(buf, "%u\n", val);
2647 static ssize_t show_status_int1(struct device *dev,
2648 struct device_attribute *attr, char *buf)
2651 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2653 val = di->status_int1;
2654 return sprintf(buf, "%u\n", val);
2657 static ssize_t show_status_int2(struct device *dev,
2658 struct device_attribute *attr, char *buf)
2661 struct twl6030_bci_device_info *di = dev_get_drvdata(dev);
2663 val = di->status_int2;
2664 return sprintf(buf, "%u\n", val);
2667 static DEVICE_ATTR(fg_mode, S_IWUSR | S_IRUGO, show_fg_mode, set_fg_mode);
2668 static DEVICE_ATTR(charge_src, S_IWUSR | S_IRUGO, show_charge_src,
2670 static DEVICE_ATTR(vbus_voltage, S_IRUGO, show_vbus_voltage, NULL);
2671 static DEVICE_ATTR(id_level, S_IRUGO, show_id_level, NULL);
2672 static DEVICE_ATTR(watchdog, S_IWUSR | S_IRUGO, show_watchdog, set_watchdog);
2673 static DEVICE_ATTR(fg_counter, S_IRUGO, show_fg_counter, NULL);
2674 static DEVICE_ATTR(fg_accumulator, S_IRUGO, show_fg_accumulator, NULL);
2675 static DEVICE_ATTR(fg_offset, S_IRUGO, show_fg_offset, NULL);
2676 static DEVICE_ATTR(fg_clear, S_IWUSR, NULL, set_fg_clear);
2677 static DEVICE_ATTR(fg_cal, S_IWUSR, NULL, set_fg_cal);
2678 static DEVICE_ATTR(charging, S_IWUSR | S_IRUGO, NULL, set_charging);
2679 static DEVICE_ATTR(regulation_voltage, S_IWUSR | S_IRUGO,
2680 show_regulation_voltage, set_regulation_voltage);
2681 static DEVICE_ATTR(termination_current, S_IWUSR | S_IRUGO,
2682 show_termination_current, set_termination_current);
2683 static DEVICE_ATTR(cin_limit, S_IWUSR | S_IRUGO, show_cin_limit,
2685 static DEVICE_ATTR(charge_current, S_IWUSR | S_IRUGO, show_charge_current,
2686 set_charge_current);
2687 static DEVICE_ATTR(min_vbus, S_IWUSR | S_IRUGO, show_min_vbus, set_min_vbus);
2688 static DEVICE_ATTR(monitoring_interval, S_IWUSR | S_IRUGO,
2689 show_monitoring_interval, set_monitoring_interval);
2690 static DEVICE_ATTR(current_avg_interval, S_IWUSR | S_IRUGO,
2691 show_current_avg_interval, set_current_avg_interval);
2692 static DEVICE_ATTR(wakelock_enable, S_IWUSR | S_IRUGO,
2693 show_wakelock_enable, set_wakelock_enable);
2694 static DEVICE_ATTR(bsi, S_IRUGO, show_bsi, NULL);
2695 static DEVICE_ATTR(stat1, S_IRUGO, show_stat1, NULL);
2696 static DEVICE_ATTR(status_int1, S_IRUGO, show_status_int1, NULL);
2697 static DEVICE_ATTR(status_int2, S_IRUGO, show_status_int2, NULL);
2699 static struct attribute *twl6030_bci_attributes[] = {
2700 &dev_attr_fg_mode.attr,
2701 &dev_attr_charge_src.attr,
2702 &dev_attr_vbus_voltage.attr,
2703 &dev_attr_id_level.attr,
2704 &dev_attr_watchdog.attr,
2705 &dev_attr_fg_counter.attr,
2706 &dev_attr_fg_accumulator.attr,
2707 &dev_attr_fg_offset.attr,
2708 &dev_attr_fg_clear.attr,
2709 &dev_attr_fg_cal.attr,
2710 &dev_attr_charging.attr,
2711 &dev_attr_regulation_voltage.attr,
2712 &dev_attr_termination_current.attr,
2713 &dev_attr_cin_limit.attr,
2714 &dev_attr_charge_current.attr,
2715 &dev_attr_min_vbus.attr,
2716 &dev_attr_monitoring_interval.attr,
2717 &dev_attr_current_avg_interval.attr,
2719 &dev_attr_stat1.attr,
2720 &dev_attr_status_int1.attr,
2721 &dev_attr_status_int2.attr,
2722 &dev_attr_wakelock_enable.attr,
2726 static const struct attribute_group twl6030_bci_attr_group = {
2727 .attrs = twl6030_bci_attributes,
2730 static char *twl6030_bci_supplied_to[] = {
2734 extern int dwc_vbus_status(void);
2736 static void twl6030_battery_update_status(struct twl6030_bci_device_info *di)
2738 power_supply_changed(&di->bat);
2739 power_supply_changed(&di->usb);
2740 power_supply_changed(&di->ac);
2743 static void twl6030_battery_work(struct work_struct *work)
2746 struct twl6030_bci_device_info *di = container_of(work, struct twl6030_bci_device_info, work.work);
2747 twl6030_battery_update_status(di);
2748 //set charging current
2749 twl_i2c_write_u8(TWL6030_MODULE_CHARGER,0x00,CHARGERUSB_CTRL1);
2750 if(2 == dwc_vbus_status()){
2751 twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x2e,CHARGERUSB_CINLIMIT); //set vbus input current is 1.5A
2752 twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x0b,CHARGERUSB_VICHRG); //set mos output current is 1A
2754 else if(1 == dwc_vbus_status()){
2755 twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x2e,CHARGERUSB_CINLIMIT);//set vbus input current is 500ma
2756 twl_i2c_write_u8(TWL6030_MODULE_CHARGER, 0x09,CHARGERUSB_VICHRG); //set mos output current is 500ma
2758 /* reschedule for the next time */
2759 queue_delayed_work(di->freezable_work, &di->work, di->interval);
2762 static int __devinit twl6030_bci_battery_probe(struct platform_device *pdev)
2764 struct twl4030_bci_platform_data *pdata = pdev->dev.platform_data;
2765 struct twl6030_bci_device_info *di;
2768 u8 controller_stat = 0;
2769 u8 chargerusb_ctrl1 = 0;
2772 //printk("%s\n", __func__);
2774 dev_info(&pdev->dev, "platform_data not available\n");
2778 di = kzalloc(sizeof(*di), GFP_KERNEL);
2782 di->platform_data = kmemdup(pdata, sizeof(*pdata), GFP_KERNEL);
2783 if (!di->platform_data) {
2788 if (pdata->monitoring_interval == 0) {
2789 di->monitoring_interval = 10;
2790 di->current_avg_interval = 10;
2792 di->monitoring_interval = pdata->monitoring_interval;
2793 di->current_avg_interval = pdata->monitoring_interval;
2796 di->platform_data = pdata;
2797 di->features = pdata->features;
2798 di->dev = &pdev->dev;
2801 // printk("di->feature = %d, TWL6032_SUBCLASS = %d\n",di->features,TWL6032_SUBCLASS);
2802 if (di->features & TWL6032_SUBCLASS) {
2803 ret = twl_i2c_read_u8(TWL_MODULE_RTC, ®, CHARGER_MODE_REG);
2805 goto temp_setup_fail;
2807 if (reg & CHARGER_MODE_POWERPATH) {
2808 dev_dbg(di->dev, "Charger: PowerPath\n");
2809 di->use_power_path = 1;
2811 dev_dbg(di->dev, "Charger: NON PowerPath\n");
2812 di->use_power_path = 0;
2815 if (reg & CHARGER_MODE_AUTOCHARGE) {
2816 dev_dbg(di->dev, "Charger: AutoCharge\n");
2817 di->use_hw_charger = 1;
2819 dev_dbg(di->dev, "Charger: NON AutoCharge\n");
2820 di->use_hw_charger = 0;
2823 di->use_power_path = 0;
2824 di->use_hw_charger = 0;
2826 // printk("di->feature = %d, TWL6032_SUBCLASS = %d,di->use_hw_charger =%d \n",di->features,TWL6032_SUBCLASS,di->use_hw_charger );
2829 if (di->use_hw_charger) {
2830 di->platform_data->max_charger_currentmA =
2831 twl6030_get_limit2_reg(di);
2832 di->platform_data->max_charger_voltagemV =
2833 twl6030_get_limit1_reg(di);
2834 di->platform_data->termination_currentmA =
2835 twl6030_get_iterm_reg(di);
2836 di->platform_data->max_bat_voltagemV =
2837 twl6030_get_voreg_reg(di);
2839 // printk("max_charger_currentmA = %d, max_charger_voltagemV = %d\n,termination_currentmA =%d, max_bat_voltagemV =%d \n",di->platform_data->max_charger_currentmA ,
2840 // di->platform_data->max_charger_voltagemV,di->platform_data->termination_currentmA, di->platform_data->max_bat_voltagemV);
2841 di->bat.name = "twl6030_battery";
2842 di->bat.supplied_to = twl6030_bci_supplied_to;
2843 di->bat.num_supplicants = ARRAY_SIZE(twl6030_bci_supplied_to);
2844 di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
2845 di->bat.properties = twl6030_bci_battery_props;
2846 di->bat.num_properties = ARRAY_SIZE(twl6030_bci_battery_props);
2847 di->bat.get_property = twl6030_bci_battery_get_property;
2848 //di->bat.external_power_changed =
2849 // twl6030_bci_battery_external_power_changed;
2850 di->bat_health = POWER_SUPPLY_HEALTH_GOOD;
2852 di->usb.name = "twl6030_usb";
2853 di->usb.type = POWER_SUPPLY_TYPE_USB;
2854 di->usb.properties = twl6030_usb_props;
2855 di->usb.num_properties = ARRAY_SIZE(twl6030_usb_props);
2856 di->usb.get_property = twl6030_usb_get_property;
2858 di->ac.name = "twl6030_ac";
2859 di->ac.type = POWER_SUPPLY_TYPE_MAINS;
2860 di->ac.properties = twl6030_ac_props;
2861 di->ac.num_properties = ARRAY_SIZE(twl6030_ac_props);
2862 di->ac.get_property = twl6030_ac_get_property;
2864 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
2866 di->bk_bat.name = "twl6030_bk_battery";
2867 di->bk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
2868 di->bk_bat.properties = twl6030_bk_bci_battery_props;
2869 di->bk_bat.num_properties = ARRAY_SIZE(twl6030_bk_bci_battery_props);
2870 di->bk_bat.get_property = twl6030_bk_bci_battery_get_property;
2872 di->vac_priority = 2;
2874 di->capacity_debounce_count = 0;
2875 di->ac_next_refresh = jiffies - 1;
2876 platform_set_drvdata(pdev, di);
2878 /* calculate current max scale from sense */
2879 if (pdata->sense_resistor_mohm) {
2880 di->current_max_scale = (62000) / pdata->sense_resistor_mohm;
2882 /* Set sensible defaults if platform data is missing */
2883 if (di->features & TWL6032_SUBCLASS)
2884 di->current_max_scale = 3100;
2886 di->current_max_scale = 6200;
2889 wake_lock_init(&chrg_lock, WAKE_LOCK_SUSPEND, "ac_chrg_wake_lock");
2890 /* settings for temperature sensing */
2891 ret = twl6030battery_temp_setup(true);
2893 goto temp_setup_fail;
2895 /* request charger fault interruption choosing between sw/hw mode */
2896 irq = platform_get_irq(pdev, 1);
2897 if (!di->use_hw_charger)
2898 ret = request_threaded_irq(irq, NULL,
2899 twl6030charger_fault_interrupt,
2900 0, "twl_bci_fault", di);
2902 ret = request_threaded_irq(irq, NULL,
2903 twl6032charger_fault_interrupt_hw,
2904 0, "twl_bci_fault", di);
2907 dev_info(&pdev->dev, "could not request irq %d, status %d\n",
2909 goto temp_setup_fail;
2912 /* request charger ctrl interruption choosing between sw/hw mode */
2913 irq = platform_get_irq(pdev, 0);
2914 if (!di->use_hw_charger)
2915 ret = request_threaded_irq(irq, NULL,
2916 twl6030charger_ctrl_interrupt,
2917 0, "twl_bci_ctrl", di);
2919 ret = request_threaded_irq(irq, NULL,
2920 twl6032charger_ctrl_interrupt_hw,
2921 0, "twl_bci_ctrl", di); // Ò»Ö±ÔÚ¼ì²âµç³ØµÄ״̬
2924 dev_info(&pdev->dev, "could not request irq %d, status %d\n",
2929 ret = power_supply_register(&pdev->dev, &di->bat);
2931 dev_info(&pdev->dev, "failed to register main battery\n");
2935 ret = power_supply_register(&pdev->dev, &di->usb);
2937 dev_info(&pdev->dev, "failed to register usb power supply\n");
2941 ret = power_supply_register(&pdev->dev, &di->ac);
2943 dev_info(&pdev->dev, "failed to register ac power supply\n");
2947 ret = power_supply_register(&pdev->dev, &di->bk_bat);
2949 dev_info(&pdev->dev, "failed to register backup battery\n");
2950 goto bk_batt_failed;
2955 //di->freezable_work = create_freezable_workqueue("battery");
2957 if (di->features & TWL6032_SUBCLASS) {
2958 di->charger_incurrentmA = 1000;
2959 di->gpadc_vbat_chnl = TWL6032_GPADC_VBAT_CHNL;
2961 di->charger_incurrentmA = twl6030_get_usb_max_power(di->otg);
2962 di->gpadc_vbat_chnl = TWL6030_GPADC_VBAT_CHNL;
2967 ret = twl6030battery_voltage_setup(di);
2969 dev_info(&pdev->dev, "voltage measurement setup failed\n");
2971 ret = twl6030battery_current_setup(true);
2973 dev_info(&pdev->dev, "current measurement setup failed\n");
2976 di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
2977 di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
2978 di->capacity = twl6030_batt_vol_to_capacity( di);
2979 twl6030battery_current(di);
2981 di->freezable_work = system_freezable_wq;
2982 INIT_DELAYED_WORK(&di->twl6030_bci_monitor_work,
2983 twl6030_bci_battery_work);
2984 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
2986 INIT_DELAYED_WORK_DEFERRABLE(&di->twl6030_current_avg_work,
2987 twl6030_current_avg);
2988 queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work, 500);
2991 ret = twl6030battery_voltage_setup(di);
2993 dev_info(&pdev->dev, "voltage measurement setup failed\n");
2995 ret = twl6030battery_current_setup(true);
2997 dev_info(&pdev->dev, "current measurement setup failed\n");
3000 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3001 /* initialize for USB charging */
3002 if (!di->use_hw_charger) {
3003 twl6030_config_limit1_reg(di, pdata->max_charger_voltagemV);
3004 twl6030_config_limit2_reg(di,
3005 di->platform_data->max_charger_currentmA);
3007 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
3008 CONTROLLER_INT_MASK);
3010 goto bk_batt_failed;
3012 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MASK_MCHARGERUSB_THMREG,
3013 CHARGERUSB_INT_MASK);
3015 goto bk_batt_failed;
3017 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &controller_stat,
3020 goto bk_batt_failed;
3022 di->stat1 = controller_stat;
3023 di->charger_outcurrentmA = di->platform_data->max_charger_currentmA;
3025 twl6030_set_watchdog(di, 32);
3027 INIT_WORK(&di->usb_work, twl6030_usb_charger_work);
3028 di->nb.notifier_call = twl6030_usb_notifier_call;
3029 di->otg = otg_get_transceiver();
3031 ret = otg_register_notifier(di->otg, &di->nb);
3033 dev_err(&pdev->dev, "otg register notifier"
3034 " failed %d\n", ret);
3036 dev_err(&pdev->dev, "otg_get_transceiver failed %d\n", ret);
3039 if (di->features & TWL6032_SUBCLASS) {
3040 di->charger_incurrentmA = 1000;
3041 di->gpadc_vbat_chnl = TWL6032_GPADC_VBAT_CHNL;
3043 di->charger_incurrentmA = twl6030_get_usb_max_power(di->otg);
3044 di->gpadc_vbat_chnl = TWL6030_GPADC_VBAT_CHNL;
3047 di->voltage_mV = twl6030_get_gpadc_conversion(di, di->gpadc_vbat_chnl);
3048 dev_info(&pdev->dev, "Battery Voltage at Bootup is %d mV\n",
3051 ret = twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
3053 goto bk_batt_failed;
3054 if (!is_battery_present(di)) {
3055 if (!(hw_state & STS_USB_ID)) {
3056 dev_dbg(di->dev, "Put USB in HZ mode\n");
3057 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER,
3058 &chargerusb_ctrl1, CHARGERUSB_CTRL1);
3060 goto bk_batt_failed;
3062 chargerusb_ctrl1 |= HZ_MODE; // high-impedance
3063 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
3064 chargerusb_ctrl1, CHARGERUSB_CTRL1);
3066 goto bk_batt_failed;
3068 } else if (!di->use_hw_charger) {
3069 if (controller_stat & VAC_DET) {
3070 di->ac_online = POWER_SUPPLY_TYPE_MAINS;
3071 twl6030_start_ac_charger(di);
3072 } else if (controller_stat & VBUS_DET) {
3074 * In HOST mode (ID GROUND) with a device connected,
3075 * do no enable usb charging
3077 if (!(hw_state & STS_USB_ID)) {
3078 di->usb_online = POWER_SUPPLY_TYPE_USB;
3079 di->charger_source = POWER_SUPPLY_TYPE_USB;
3081 POWER_SUPPLY_STATUS_CHARGING;
3082 di->event = USB_EVENT_VBUS;
3083 schedule_work(&di->usb_work);
3087 int fault, charge_usb, charge_ac;
3089 twl_i2c_read_u8(TWL6032_MODULE_CHARGER, ®,
3090 CHARGERUSB_INT_STATUS);
3092 fault = !(di->stat1 & CONTROLLER_STAT1_LINCH_GATED) &&
3093 !(di->stat1 & CONTROLLER_STAT1_FAULT_WDG);
3094 charge_usb = (di->stat1 & VBUS_DET) &&
3095 !(reg & CHARGERUSB_FAULT);
3096 charge_ac = (di->stat1 & VAC_DET) &&
3097 !(di->stat1 & CONTROLLER_STAT1_EXTCHRG_STATZ);
3099 dev_dbg(di->dev, "boot charge state fault %d, usb %d, ac %d\n",
3100 fault, charge_usb, charge_ac);
3102 if (fault && (charge_usb || charge_ac))
3103 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
3105 if (di->stat1 & (VBUS_DET | VAC_DET))
3107 POWER_SUPPLY_STATUS_NOT_CHARGING;
3110 POWER_SUPPLY_STATUS_DISCHARGING;
3114 di->interval = msecs_to_jiffies(1 * 1000);
3115 INIT_DELAYED_WORK(&di->work, twl6030_battery_work);
3116 queue_delayed_work(di->freezable_work, &di->work, 1*HZ);
3118 ret = twl6030backupbatt_setup();
3120 dev_info(&pdev->dev, "Backup Bat charging setup failed\n");
3122 twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
3123 REG_INT_MSK_LINE_C);
3124 twl6030_interrupt_unmask(TWL6030_CHARGER_CTRL_INT_MASK,
3126 twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
3127 REG_INT_MSK_LINE_C);
3128 twl6030_interrupt_unmask(TWL6030_CHARGER_FAULT_INT_MASK,
3131 ret = sysfs_create_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
3133 dev_info(&pdev->dev, "could not create sysfs files\n");
3138 cancel_delayed_work(&di->twl6030_bci_monitor_work);
3139 power_supply_unregister(&di->ac);
3141 power_supply_unregister(&di->usb);
3143 power_supply_unregister(&di->bat);
3147 irq = platform_get_irq(pdev, 1);
3150 wake_lock_destroy(&chrg_lock);
3151 platform_set_drvdata(pdev, NULL);
3157 static int __devexit twl6030_bci_battery_remove(struct platform_device *pdev)
3159 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3162 twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
3163 REG_INT_MSK_LINE_C);
3164 twl6030_interrupt_mask(TWL6030_CHARGER_CTRL_INT_MASK,
3166 twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
3167 REG_INT_MSK_LINE_C);
3168 twl6030_interrupt_mask(TWL6030_CHARGER_FAULT_INT_MASK,
3171 irq = platform_get_irq(pdev, 0);
3174 irq = platform_get_irq(pdev, 1);
3177 otg_unregister_notifier(di->otg, &di->nb);
3178 sysfs_remove_group(&pdev->dev.kobj, &twl6030_bci_attr_group);
3179 cancel_delayed_work(&di->twl6030_bci_monitor_work);
3180 cancel_delayed_work(&di->twl6030_current_avg_work);
3181 flush_scheduled_work();
3182 power_supply_unregister(&di->bat);
3183 power_supply_unregister(&di->usb);
3184 power_supply_unregister(&di->ac);
3185 power_supply_unregister(&di->bk_bat);
3186 wake_lock_destroy(&chrg_lock);
3187 platform_set_drvdata(pdev, NULL);
3188 kfree(di->platform_data);
3195 static int twl6030_bci_battery_suspend(struct device *dev)
3197 struct platform_device *pdev = to_platform_device(dev);
3198 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3203 /* mask to prevent wakeup due to 32s timeout from External charger */
3204 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg,
3205 CONTROLLER_INT_MASK);
3209 rd_reg |= MVAC_FAULT;
3210 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
3211 CONTROLLER_INT_MASK);
3215 //cancel_delayed_work(&di->work);
3216 cancel_delayed_work(&di->twl6030_bci_monitor_work);
3217 //cancel_delayed_work(&di->twl6030_current_avg_work);
3219 di->suspend_capacity = di->capacity;
3221 /* We cannot tolarate a sleep longer than 30 seconds
3222 * while on ac charging we have to reset the BQ watchdog timer.
3224 // if ((di->charger_source == POWER_SUPPLY_TYPE_MAINS) &&
3225 // ((wakeup_timer_seconds > 25) || !wakeup_timer_seconds)) {
3226 // wakeup_timer_seconds = 25;
3229 /*reset the BQ watch dog*/
3230 events = BQ2415x_RESET_TIMER;
3231 blocking_notifier_call_chain(¬ifier_list, events, NULL);
3233 ret = twl6030battery_temp_setup(false);
3235 pr_err("%s: Temp measurement setup failed (%d)!\n",
3240 ret = twl6030battery_current_setup(false);
3242 pr_err("%s: Current measurement setup failed (%d)!\n",
3249 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
3253 static int twl6030_bci_battery_resume(struct device *dev)
3255 struct platform_device *pdev = to_platform_device(dev);
3256 struct twl6030_bci_device_info *di = platform_get_drvdata(pdev);
3261 di->resume_status =1;
3262 ret = twl6030battery_temp_setup(true);
3264 pr_err("%s: Temp measurement setup failed (%d)!\n",
3269 ret = twl6030battery_current_setup(true);
3271 pr_err("%s: Current measurement setup failed (%d)!\n",
3276 ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &rd_reg, CONTROLLER_INT_MASK);
3280 rd_reg &= ~(0xFF & MVAC_FAULT);
3281 ret = twl_i2c_write_u8(TWL6030_MODULE_CHARGER, MBAT_TEMP,
3282 CONTROLLER_INT_MASK);
3286 queue_delayed_work(di->freezable_work, &di->twl6030_bci_monitor_work, 0);
3287 //queue_delayed_work(di->freezable_work, &di->twl6030_current_avg_work, 50);
3288 //queue_delayed_work(di->freezable_work, &di->work, di->interval);
3290 events = BQ2415x_RESET_TIMER;
3291 blocking_notifier_call_chain(¬ifier_list, events, NULL);
3295 pr_err("%s: Error access to TWL6030 (%d)\n", __func__, ret);
3299 #define twl6030_bci_battery_suspend NULL
3300 #define twl6030_bci_battery_resume NULL
3301 #endif /* CONFIG_PM */
3303 static const struct dev_pm_ops pm_ops = {
3304 .suspend = twl6030_bci_battery_suspend,
3305 .resume = twl6030_bci_battery_resume,
3308 static struct platform_driver twl6030_bci_battery_driver = {
3309 .probe = twl6030_bci_battery_probe,
3310 .remove = __devexit_p(twl6030_bci_battery_remove),
3312 .name = "twl6030_bci",
3317 static int __init twl6030_battery_init(void)
3319 return platform_driver_register(&twl6030_bci_battery_driver);
3321 module_init(twl6030_battery_init);
3323 static void __exit twl6030_battery_exit(void)
3325 platform_driver_unregister(&twl6030_bci_battery_driver);
3327 module_exit(twl6030_battery_exit);
3329 MODULE_LICENSE("GPL");
3330 MODULE_ALIAS("platform:twl6030_bci");
3331 MODULE_AUTHOR("Texas Instruments Inc");