static void change_cable_status(int status,
struct charger_device_info *di)
{
sec_bci->charger.prev_cable_status = sec_bci->charger.cable_status;
sec_bci->charger.cable_status = status;
_charger_state_change_(STATUS_CATEGORY_CABLE, status);
switch (status) {
case POWER_SUPPLY_TYPE_BATTERY:
/*Diable charging */
change_charge_status(POWER_SUPPLY_STATUS_DISCHARGING);
break;
case POWER_SUPPLY_TYPE_MAINS:
case POWER_SUPPLY_TYPE_USB:
/*Enable charging */
change_charge_status(POWER_SUPPLY_STATUS_CHARGING);
break;
default:
break;
}
}
static void change_cable_status( int status,
struct charger_driver_info *di,
bool is_sleep )
// ----------------------------------------------------------------------------
// Description :
// Input Argument :
// Return Value :
{
sec_bci->charger.prev_cable_status = sec_bci->charger.cable_status;
sec_bci->charger.cable_status = status;
_charger_state_change_( STATUS_CATEGORY_CABLE, status, is_sleep );
switch ( status )
{
case POWER_SUPPLY_TYPE_BATTERY :
/*Diable charging*/
change_charge_status( POWER_SUPPLY_STATUS_DISCHARGING, is_sleep );
break;
case POWER_SUPPLY_TYPE_MAINS :
case POWER_SUPPLY_TYPE_USB :
/*Enable charging*/
change_charge_status( POWER_SUPPLY_STATUS_CHARGING, is_sleep );
break;
default :
;
}
}
int _check_full_charge_dur_sleep_( void )
// ----------------------------------------------------------------------------
// Description :
// Input Argument :
// Return Value :
{
int ret = 0;
#if 0 //me change
int chg_ing_level = 0;
int i;
unsigned char confirm_full = 0x0;
for ( i = 0; i < 8; i++ )
{
chg_ing_level = gpio_get_value( KCHG_ING_GPIO );
confirm_full |= chg_ing_level << i;
msleep( 3 );
}
//printk( "<ta> %x\n", confirm_full );
if ( confirm_full == 0xFF )
{
printk( "<ta> Charged!\n" );
ret = 1;
}
#else
struct charger_driver_info *di;
struct platform_device *pdev;
int is_chg_pin_wakeup = 0;
is_chg_pin_wakeup = omap34xx_pad_get_wakeup_status( KCHG_ING_GPIO );
//if ( is_chg_pin_wakeup && sec_bci->battery.battery_level_vol >= 4100 )
if (sec_bci->battery.battery_level_ptg >= 100 )
{
pdev = to_platform_device( this_dev );
di = platform_get_drvdata( pdev );
change_charge_status( POWER_SUPPLY_STATUS_FULL, CHARGE_DUR_SLEEP );
ret = 1;
}
else
{
//omap34xx_pad_set_padoff( KCHG_ING_GPIO, 1 );
}
#endif
return ret;
}
static void twl6030charger_fault_work_handler(struct work_struct *work)
{
struct charger_device_info *di = container_of(work,
struct charger_device_info,
twl6030charger_fault_work.work);
int charger_fault = 0;
int ret;
u8 usb_charge_sts = 0, usb_charge_sts1 = 0, usb_charge_sts2 = 0;
ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts,
CHARGERUSB_INT_STATUS);
ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts1,
CHARGERUSB_STATUS_INT1);
ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &usb_charge_sts2,
CHARGERUSB_STATUS_INT2);
di->status_int1 = usb_charge_sts1;
di->status_int2 = usb_charge_sts2;
if (usb_charge_sts & CURRENT_TERM_INT)
dev_dbg(di->dev, "USB CURRENT_TERM_INT\n");
if (usb_charge_sts & CHARGERUSB_THMREG)
dev_dbg(di->dev, "USB CHARGERUSB_THMREG\n");
if (usb_charge_sts & CHARGERUSB_FAULT)
dev_dbg(di->dev, "USB CHARGERUSB_FAULT\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TMREG)
dev_dbg(di->dev, "USB CHARGER Thermal regulation activated\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_NO_BAT)
dev_dbg(di->dev, "No Battery Present\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BST_OCP)
dev_dbg(di->dev, "USB CHARGER Boost Over current protection\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_TH_SHUTD) {
// charger_fault = 1;
dev_dbg(di->dev, "USB CHARGER Thermal Shutdown\n");
}
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_BAT_OVP)
dev_dbg(di->dev, "USB CHARGER Bat Over Voltage Protection\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_POOR_SRC)
dev_dbg(di->dev, "USB CHARGER Poor input source\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_SLP_MODE)
dev_dbg(di->dev, "USB CHARGER Sleep mode\n");
if (usb_charge_sts1 & CHARGERUSB_STATUS_INT1_VBUS_OVP)
dev_dbg(di->dev, "USB CHARGER VBUS over voltage\n");
if (usb_charge_sts2 & CHARGE_DONE)
dev_dbg(di->dev, "CHARGE DONE\n");
if (usb_charge_sts2 & CURRENT_TERM){
// change_charge_status(POWER_SUPPLY_STATUS_FULL_END);
dev_dbg(di->dev, "[TA] Charge FULL\n");
}
if (usb_charge_sts2 & ICCLOOP)
dev_dbg(di->dev, "USB ICCLOOP\n");
if (usb_charge_sts2 & ANTICOLLAPSE)
dev_dbg(di->dev, "USB ANTICOLLAPSE\n");
if (charger_fault) {
change_charge_status(POWER_SUPPLY_STATUS_NOT_CHARGING);
dev_err(di->dev, "Charger Fault stop charging\n");
}
dev_dbg(di->dev, "Charger fault detected STS, INT1, INT2 %x %x %x\n",
usb_charge_sts, usb_charge_sts1, usb_charge_sts2);
}
static void twl6030charger_ctrl_work_handler(struct work_struct *work)
{
struct charger_device_info *di = container_of(work,
struct charger_device_info,
twl6030charger_ctrl_work.work);
int ret;
int n_usbic_state;
int charger_fault = 0;
long int events;
u8 stat_toggle, stat_reset, stat_set = 0;
u8 charge_state = 0;
u8 present_charge_state = 0;
u8 ac_or_vbus, no_ac_and_vbus = 0;
u8 hw_state = 0, temp = 0;
dev_dbg(di->dev, "[TA] %s start\n",__func__);
clear_charge_start_time();
/* read charger controller_stat1 */
ret = twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &present_charge_state,
CONTROLLER_STAT1);
if (ret)
return 0;
twl_i2c_read_u8(TWL6030_MODULE_ID0, &hw_state, STS_HW_CONDITIONS);
charge_state = di->stat1;
stat_toggle = charge_state ^ present_charge_state;
stat_set = stat_toggle & present_charge_state;
stat_reset = stat_toggle & charge_state;
no_ac_and_vbus = !((present_charge_state) & (VBUS_DET | VAC_DET));
ac_or_vbus = charge_state & (VBUS_DET | VAC_DET);
if (no_ac_and_vbus && ac_or_vbus) {
dev_dbg(di->dev, "[TA] No Charging source\n");
/* disable charging when no source present */
}
charge_state = present_charge_state;
di->stat1 = present_charge_state;
if (stat_reset & VBUS_DET) {
/* On a USB detach, UNMASK VBUS OVP if masked*/
twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &temp,
CHARGERUSB_INT_MASK);
if (temp & MASK_MCHARGERUSB_FAULT)
twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
(temp & ~MASK_MCHARGERUSB_FAULT),
CHARGERUSB_INT_MASK);
dev_dbg(di->dev, "[TA] Charging source removed\n");
change_cable_status(POWER_SUPPLY_TYPE_BATTERY, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(0);
#endif
}
if (stat_set & VBUS_DET) {
/* In HOST mode (ID GROUND) when a device is connected, Mask
* VBUS OVP interrupt and do no enable usb charging
*/
if (hw_state & STS_USB_ID) {
twl_i2c_read_u8(TWL6030_MODULE_CHARGER, &temp,
CHARGERUSB_INT_MASK);
if (!(temp & MASK_MCHARGERUSB_FAULT))
twl_i2c_write_u8(TWL6030_MODULE_CHARGER,
(temp | MASK_MCHARGERUSB_FAULT),
CHARGERUSB_INT_MASK);
} else {
n_usbic_state = get_real_usbic_state();
dev_dbg(di->dev,
"[TA] cable_detection_isr handler. usbic_state: %d\n",
n_usbic_state);
switch (n_usbic_state) {
case MICROUSBIC_5W_CHARGER:
case MICROUSBIC_TA_CHARGER:
case MICROUSBIC_USB_CHARGER:
case MICROUSBIC_PHONE_USB:
case MICROUSBIC_USB_CABLE:
case MICROUSBIC_MHL_CHARGER:
case MICROUSBIC_JIG_USB_ON:
if (sec_bci->charger.cable_status == POWER_SUPPLY_TYPE_USB
|| sec_bci->charger.cable_status == POWER_SUPPLY_TYPE_MAINS ){
dev_dbg(di->dev,
"[TA] Already Plugged\n");
break;
}
/*Check VF */
sec_bci->battery.battery_vf_ok = check_battery_vf();
/*TA or USB or MHL is inserted */
if (n_usbic_state == MICROUSBIC_USB_CABLE) {
//current : 395mA
dev_dbg(di->dev,"[TA] USB CABLE PLUGGED\n");
change_cable_status(POWER_SUPPLY_TYPE_USB, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(1);
#endif
} else if (n_usbic_state == MICROUSBIC_MHL_CHARGER) {
//current : 395mA
dev_dbg(di->dev,"[TA] MHL CABLE PLUGGED\n");
change_cable_status(POWER_SUPPLY_TYPE_USB, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(1);
#endif
} else if (n_usbic_state == MICROUSBIC_JIG_USB_ON) {
//current : 1000mA
dev_dbg(di->dev,"[TA] JIG_USB_ON CABLE PLUGGED\n");
change_cable_status(POWER_SUPPLY_TYPE_MAINS, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(1);
#endif
} else {
//current : 1000mA
dev_dbg(di->dev,"[TA] CHARGER CABLE PLUGGED\n");
change_cable_status(POWER_SUPPLY_TYPE_MAINS, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(1);
#endif
}
break;
default:
;
}
}
}
if (sec_bci->charger.prev_cable_status == -1
&& sec_bci->charger.cable_status == -1) {
dev_dbg(di->dev,"[TA] Fisrt time after bootig.\n");
change_cable_status(POWER_SUPPLY_TYPE_BATTERY, di);
#ifdef CONFIG_DYNAMIC_TSP_SETTINGS_FOR_CHARGER_STATE
set_tsp_for_ta_detect(0);
#endif
}
if (stat_set & CONTROLLER_STAT1_FAULT_WDG) {
// charger_fault = 1;
dev_dbg(di->dev, "Fault watchdog fired\n");
}
if (stat_reset & CONTROLLER_STAT1_FAULT_WDG)
dev_dbg(di->dev, "Fault watchdog recovered\n");
if (stat_set & CONTROLLER_STAT1_BAT_REMOVED)
dev_dbg(di->dev, "Battery removed\n");
if (stat_reset & CONTROLLER_STAT1_BAT_REMOVED)
dev_dbg(di->dev, "Battery inserted\n");
if (stat_set & CONTROLLER_STAT1_BAT_TEMP_OVRANGE)
dev_dbg(di->dev, "Battery temperature overrange\n");
if (stat_reset & CONTROLLER_STAT1_BAT_TEMP_OVRANGE)
dev_dbg(di->dev, "Battery temperature within range\n");
if (charger_fault) {
change_charge_status(POWER_SUPPLY_STATUS_NOT_CHARGING);
dev_err(di->dev, "Charger Fault stop charging\n");
}
}
int _battery_state_change_(int category, int value)
{
struct charger_device_info *di;
struct platform_device *pdev;
int state;
pdev = to_platform_device(this_dev);
di = platform_get_drvdata(pdev);
printk( KERN_INFO "[TA] cate: %d, value: %d, %s\n", category, value, di->dev->kobj.name );
switch (category) {
case STATUS_CATEGORY_TEMP:
switch (value) {
case BATTERY_TEMPERATURE_NORMAL:
printk( KERN_INFO "[TA] Charging re start normal TEMP!!\n");
change_charge_status(POWER_SUPPLY_STATUS_RECHARGING_FOR_TEMP);
break;
case BATTERY_TEMPERATURE_LOW:
printk( KERN_INFO "[TA] Charging stop LOW TEMP!!\n");
change_charge_status(POWER_SUPPLY_STATUS_NOT_CHARGING);
break;
case BATTERY_TEMPERATURE_HIGH:
printk( KERN_INFO "[TA] Charging stop HI TEMP!!\n");
change_charge_status(POWER_SUPPLY_STATUS_NOT_CHARGING);
break;
#ifdef HIGH_TEMP_GAURD_FOR_CAMCORDER
case BATTERY_TEMPERATURE_ETC:
if(sec_bci->charger.camera_recording
&& sec_bci->charger.camera_recording_inout){
printk( KERN_INFO "[TA] Charger is set to the USB mode\n");
state = sec_bci->charger.cable_status;
sec_bci->charger.cable_status = POWER_SUPPLY_TYPE_USB;
enable_charging();
sec_bci->charger.cable_status = state;
break;
} else {
printk( KERN_INFO "[TA] Charger is set to the original mode\n");
enable_charging();
break;
}
#endif
default:
break;
}
break;
case STATUS_CATEGORY_CHARGING:
switch (value) {
case POWER_SUPPLY_STATUS_FULL:
printk( KERN_INFO "[TA] Charge FULL(#1)! (monitoring charge current)\n");
change_charge_status(POWER_SUPPLY_STATUS_FULL);
break;
case POWER_SUPPLY_STATUS_FULL_END:
printk( KERN_INFO "[TA] Charge FULL(#2)! (monitoring charge current)\n");
change_charge_status(POWER_SUPPLY_STATUS_FULL_END);
break;
case POWER_SUPPLY_STATUS_CHARGING_OVERTIME:
printk( KERN_INFO "[TA] CHARGING TAKE OVER 6 hours !!\n");
change_charge_status(POWER_SUPPLY_STATUS_FULL_END);
break;
case POWER_SUPPLY_STATUS_FULL_DUR_SLEEP:
printk( KERN_INFO "[TA] Charge FULL!\n");
change_charge_status(POWER_SUPPLY_STATUS_FULL);
break;
case POWER_SUPPLY_STATUS_RECHARGING_FOR_FULL:
printk( KERN_INFO "[TA] Re-Charging Start!!\n");
change_charge_status(POWER_SUPPLY_STATUS_RECHARGING_FOR_FULL);
break;
default:
break;
}
break;
case STATUS_CATEGORY_ETC:
switch (value) {
case ETC_CABLE_IS_DISCONNECTED:
printk( KERN_INFO "[TA] CABLE IS NOT CONNECTED.... Charge Stop!!\n");
change_cable_status(POWER_SUPPLY_TYPE_BATTERY, di);
break;
default:
break;
}
break;
default:
printk( KERN_INFO "[TA] Invalid category!!!!!\n");
break;
}
return 0;
}
static void full_charge_work_handler( struct work_struct *work )
// ----------------------------------------------------------------------------
// Description :
// Input Argument :
// Return Value : None
{
struct charger_driver_info *di;
int count;
int n_usbic_state;
if ( !sec_bci->charger.is_charging )
goto Enable_IRQ_Full_Det;
#ifndef CONFIG_USB_SWITCH_FSA9480
n_usbic_state = get_real_usbic_state();
switch ( n_usbic_state )
{
case MICROUSBIC_5W_CHARGER :
case MICROUSBIC_TA_CHARGER :
case MICROUSBIC_USB_CHARGER :
case MICROUSBIC_USB_CABLE :
case MICROUSBIC_PHONE_USB :
break;
default :
//not conn
goto Enable_IRQ_Full_Det;
}
#endif
count = 0;
while ( count < 10 )
{
if ( !gpio_get_value( KCHG_ING_GPIO ) )
{
goto Enable_IRQ_Full_Det;
break;
}
msleep( 10 );
count++;
}
di = container_of( work, struct charger_driver_info, full_charge_work.work );
// check VF INVALID
sec_bci->battery.battery_vf_ok = check_battery_vf();
if ( sec_bci->battery.battery_vf_ok )
{
if ( device_config->SUPPORT_CHG_ING_IRQ )
{
if ( gpio_get_value( KCHG_ING_GPIO ) && sec_bci->charger.is_charging )
{
printk( "[TA] Charge FULL!\n" );
change_charge_status( POWER_SUPPLY_STATUS_FULL, CHARGE_DUR_ACTIVE );
}
}
}
else
{
// VF OPEN
printk( "[TA] VF OPEN !!\n Stop charging !!\n" );
sec_bci->battery.battery_health = POWER_SUPPLY_HEALTH_DEAD;
change_charge_status( POWER_SUPPLY_STATUS_NOT_CHARGING, CHARGE_DUR_ACTIVE );
}
// int n_usbic_state;
// n_usbic_state = get_real_usbic_state();
// switch ( n_usbic_state )
// {
// case MICROUSBIC_5W_CHARGER :
// case MICROUSBIC_TA_CHARGER :
// case MICROUSBIC_USB_CHARGER :
// case MICROUSBIC_USB_CABLE :
// if ( gpio_get_value( KCHG_ING_GPIO ) && sec_bci->charger.is_charging )
// {
// printk( "[TA] Charge FULL!\n" );
// change_charge_status( POWER_SUPPLY_STATUS_FULL, CHARGE_DUR_ACTIVE );
// }
// break;
// default :
// ;
// }
Enable_IRQ_Full_Det :
enable_irq( KCHG_ING_IRQ );
}
int _battery_state_change_( int category, int value, bool is_sleep )
// ----------------------------------------------------------------------------
// Description :
// Input Argument :
// Return Value :
{
struct charger_driver_info *di;
struct platform_device *pdev;
pdev = to_platform_device( this_dev );
di = platform_get_drvdata( pdev );
//printk( "[TA] cate: %d, value: %d, %s\n", category, value, di->dev->kobj.name );
if ( category == STATUS_CATEGORY_TEMP )
{
switch ( value )
{
case BATTERY_TEMPERATURE_NORMAL :
printk( "[TA] Charging re start normal TEMP!!\n" );
change_charge_status( POWER_SUPPLY_STATUS_RECHARGING_FOR_TEMP, is_sleep );
break;
case BATTERY_TEMPERATURE_LOW :
printk( "[TA] Charging stop LOW TEMP!!\n" );
change_charge_status( POWER_SUPPLY_STATUS_NOT_CHARGING, is_sleep );
break;
case BATTERY_TEMPERATURE_HIGH :
printk( "[TA] Charging stop HI TEMP!!\n" );
change_charge_status( POWER_SUPPLY_STATUS_NOT_CHARGING, is_sleep );
break;
default :
;
}
}
else if ( category == STATUS_CATEGORY_CHARGING )
{
switch ( value )
{
case POWER_SUPPLY_STATUS_FULL :
printk( "[TA] Charge FULL! (monitoring charge current)\n" );
change_charge_status( POWER_SUPPLY_STATUS_FULL, is_sleep );
break;
case POWER_SUPPLY_STATUS_CHARGING_OVERTIME :
printk( "[TA] CHARGING TAKE OVER 5 hours !!\n" );
change_charge_status( POWER_SUPPLY_STATUS_FULL, is_sleep );
break;
case POWER_SUPPLY_STATUS_FULL_DUR_SLEEP :
printk( "<ta> Charge FULL!\n" );
change_charge_status( POWER_SUPPLY_STATUS_FULL, is_sleep );
break;
case POWER_SUPPLY_STATUS_RECHARGING_FOR_FULL :
printk( "[TA] Re-Charging Start!!\n" );
change_charge_status( POWER_SUPPLY_STATUS_RECHARGING_FOR_FULL, is_sleep );
break;
default :
break;
}
}
else if ( category == STATUS_CATEGORY_ETC )
{
switch ( value )
{
case ETC_CABLE_IS_DISCONNECTED :
printk( "[TA] CABLE IS NOT CONNECTED.... Charge Stop!!\n" );
change_cable_status( POWER_SUPPLY_TYPE_BATTERY, di, is_sleep );
break;
default :
;
}
}
else
{
;
}
return 0;
}
