int charger_init(unsigned char bus)
{
int usb_charger_type = dwc_otg_check_dpdm();
debug("%s, charger_type = %d, dc_is_charging= %d\n",__func__,usb_charger_type,is_charging());
if(1){
pmic_rk808_charger_setting(3);
}else if(usb_charger_type){
pmic_rk808_charger_setting(usb_charger_type);
}
return 0;
}
static int get_usb_charge_state(struct cw_battery *cw_bat)
{
int charge_time;
int time_from_boot;
struct timespec ts;
int gadget_status = get_gadget_connect_flag();
int usb_status = dwc_vbus_status();
get_monotonic_boottime(&ts);
time_from_boot = ts.tv_sec;
if (cw_bat->charger_init_mode) {
if (usb_status == 1 || usb_status == 2) {
cw_bat->charger_init_mode = 0;
} else if (time_from_boot < 8) {
usb_status = cw_bat->charger_init_mode;
} else if (strstr(saved_command_line,"charger")) {
cw_bat->charger_init_mode = dwc_otg_check_dpdm();
usb_status = cw_bat->charger_init_mode;
}
}
#ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
if (cw_bat->usb_online == 1) {
charge_time = time_from_boot - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
if (charge_time > 3) {
if (gadget_status == 0 && dwc_vbus_status() == 1) {
usb_status = 2;
}
}
}
#endif
return usb_status;
dev_dbg(&cw_bat->client->dev, "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",__func__,usb_status,cw_bat->charger_mode,gadget_status, cw_bat->charger_init_mode);
}
/*
get battery status, contain capacity, voltage, status
struct battery *batt_status:
voltage_uV. battery voltage
capacity. battery capacity
state_of_chrg: 0. no charger; 1. usb charging; 2. AC charging
*/
int get_power_bat_status(struct battery *batt_status)
{
int i2c_buf[2];
int read_buffer = 0;
int temperature = 280;
i2c_set_bus_num(0);
i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_BQ27541_I2C_ADDR);
i2c_set_bus_speed(CONFIG_SYS_I2C_SPEED);
i2c_buf[0] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x08);// BQ27x00_REG_VOLT
i2c_buf[1] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x09);// BQ27x00_REG_VOLT+1
read_buffer = (i2c_buf[1] << 8) | i2c_buf[0];
batt_status->voltage_uV = read_buffer*1000;
i2c_buf[0] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x2c);// BQ27500_REG_SOC
i2c_buf[1] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x2d);// BQ27500_REG_SOC+1
read_buffer = (i2c_buf[1] << 8) | i2c_buf[0];
if(read_buffer==0 && batt_status->voltage_uV>3400000)
batt_status->capacity=1;
else if(read_buffer>=2) batt_status->capacity = (read_buffer-2)*100/98;
else batt_status->capacity = 0;
i2c_buf[0] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x06);// BQ27x00_REG_TEMP
i2c_buf[1] = i2c_reg_read(CONFIG_BQ27541_I2C_ADDR,0x07);// BQ27x00_REG_TEMP+1
temperature = ((i2c_buf[1] << 8) | i2c_buf[0]) - TEMP_K;
if(!state_of_chrg)state_of_chrg = dwc_otg_check_dpdm();
if((temperature<MIN_CHARGE_TEMPERATURE)||(temperature>MAX_CHARGE_TEMPERATURE)) //over temperature
{
batt_status->state_of_chrg = 0;
printf("%s, over temperature = %d, usb type=%d\n ",__func__, temperature, state_of_chrg);
}
else batt_status->state_of_chrg = state_of_chrg;
return 0;
}
static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct cw_battery *cw_bat;
int ret;
int irq;
int irq_flags;
int loop = 0;
cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
if (!cw_bat) {
dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
return -ENOMEM;
}
i2c_set_clientdata(client, cw_bat);
cw_bat->plat_data = client->dev.platform_data;
ret = cw_bat_gpio_init(cw_bat);
if (ret) {
dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
return ret;
}
cw_bat->client = client;
ret = cw_init(cw_bat);
while ((loop++ < 200) && (ret != 0)) {
ret = cw_init(cw_bat);
}
if (ret)
return ret;
cw_bat->rk_bat.name = "rk-bat";
cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
cw_bat->rk_bat.properties = rk_battery_properties;
cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
cw_bat->rk_bat.get_property = rk_battery_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
goto rk_bat_register_fail;
}
cw_bat->rk_ac.name = "rk-ac";
cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
cw_bat->rk_ac.properties = rk_ac_properties;
cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
cw_bat->rk_ac.get_property = rk_ac_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
goto rk_ac_register_fail;
}
cw_bat->rk_usb.name = "rk-usb";
cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
cw_bat->rk_usb.properties = rk_usb_properties;
cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
cw_bat->rk_usb.get_property = rk_usb_get_property;
ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
if(ret < 0) {
dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
goto rk_usb_register_fail;
}
cw_bat->charger_init_mode = dwc_otg_check_dpdm();
cw_bat->dc_online = 0;
cw_bat->usb_online = 0;
cw_bat->charger_mode = 0;
cw_bat->capacity = 2;
cw_bat->voltage = 0;
cw_bat->status = 0;
cw_bat->time_to_empty = 0;
cw_bat->bat_change = 0;
cw_update_time_member_capacity_change(cw_bat);
cw_update_time_member_charge_start(cw_bat);
cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
irq_flags = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "usb_detect", cw_bat);
if (ret < 0) {
pr_err("%s: request_irq(%d) failed\n", __func__, irq);
}
enable_irq_wake(irq);
}
#ifdef BAT_LOW_INTERRUPT
INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect");
if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
irq = gpio_to_irq(cw_bat->plat_data->bat_low_pin);
ret = request_irq(irq, bat_low_detect_irq_handler, IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
if (ret < 0) {
gpio_free(cw_bat->plat_data->bat_low_pin);
}
enable_irq_wake(irq);
}
#endif
dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe sucess\n");
return 0;
rk_usb_register_fail:
power_supply_unregister(&cw_bat->rk_bat);
rk_ac_register_fail:
power_supply_unregister(&cw_bat->rk_ac);
rk_bat_register_fail:
dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
return ret;
}
