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;
}
int main(int argc,char**argv)
{
char*help[]={"help",NULL};
char*help_all[]={"help","all",NULL};
char*help_you[]={"help","you",NULL};
char*list[]={"list",NULL};
char*list_all[]={"list","all",NULL};
char*list_all_but[]={"list","all","but",NULL};
char*list_show[]={"list","show",NULL};
char*list_show_all[]={"list","show","all",NULL};
char*play[]={"play",NULL};
char*play_list[]={"play","list",NULL};
char*play_mode[]={"play","mode",NULL};
char*play_all[]={"play","all",NULL};
//init CmdWise
cw_init();
cw_register_cmd(help,ARG_N,"help command",help_cb);
cw_register_cmd(help_all,ARG_0,"help all command",help_all_cb);
cw_register_cmd(help_you,ARG_0,"help you command",NULL);
cw_register_cmd(list,ARG_0,"list command",list_cb);
cw_register_cmd(list_all,ARG_0,"list all command",list_all_cb);
cw_register_cmd(list_all_but,ARG_1,"list all but command",list_all_but_cb);
cw_register_cmd(list_show,ARG_N,"list show command",list_show_cb);
cw_register_cmd(list_show_all,ARG_0,"list show all command",list_show_all_cb);
cw_register_cmd(play,ARG_N,"play command",NULL);
cw_register_cmd(play_list,ARG_1,"play list command",NULL);
cw_register_cmd(play_mode,ARG_1,"play mode command",NULL);
cw_register_cmd(play_all,ARG_0,"play all command",NULL);
cw_print_cmds_tree();
// printf("-----\n\n");
// cw_unregister_cmd(&RCMDs.heads,list_all);
// cw_unregister_cmd(play_all);
// cw_print_cmds_tree();
printf("==================\n\n");
char**argvs;
char linebuf[1024];
while(fgets(linebuf,1024,stdin)){
argvs=cw_parse_line(linebuf);
cw_print_argvs(argvs);
cw_invoke_cmd(argvs);
cw_free_argvs(argvs);
printf("-=-=-=-=-=-=-=-=-=-\n");
}
return 0;
}
static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct cw_bat_platform_data *pdata = client->dev.platform_data;
struct cw_battery *cw_bat;
int ret;
int loop = 0;
printk("\ncw2015/cw2013 driver v1.2 probe start, battery_type_id is %d\n", battery_type_id);
cw_bat = kzalloc(sizeof(struct cw_battery), GFP_KERNEL);
if (!cw_bat) {
dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
return -ENOMEM;
}
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct cw_bat_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev,
"GTP Failed to allocate memory for pdata\n");
return -ENOMEM;
}
ret = cw_bat_parse_dt(&client->dev, pdata);
if (ret)
return ret;
} else {
pdata = client->dev.platform_data;
}
if (!pdata) {
dev_err(&client->dev, "Invalid pdata\n");
return -EINVAL;
}
if (battery_type_id == 0) {
pdata->cw_bat_config_info = config_info_desai ;
} else if (battery_type_id == 1) {
pdata->cw_bat_config_info = config_info_feimaotui ;
} else if (battery_type_id == 2) {
pdata->cw_bat_config_info = config_info_guanyu ;
} else if (battery_type_id == 3) {
pdata->cw_bat_config_info = config_info_xinwangda;
} else {
pdata->cw_bat_config_info = config_info;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "I2C not supported\n");
return -ENODEV;
}
cw_bat->client = client;
i2c_set_clientdata(client, cw_bat);
cw_bat->plat_data = pdata;
ret = cw_check_ic(cw_bat);
while ((loop++ < 5) && (ret != 0)) {
pr_debug(" check ret is %d, loop is %d \n" , ret, loop);
ret = cw_check_ic(cw_bat);
}
if (ret != 0) {
pr_debug(" wc_check_ic fail , return ENODEV \n");
return -ENODEV;
}
ret = cw_init(cw_bat);
while ((loop++ < 2000) && (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");
printk("rk_bat_register_fail\n");
goto rk_bat_register_fail;
}
cw_bat->charger_mode = 0;
cw_bat->capacity = 0;
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);
queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
#ifdef BAT_LOW_INTERRUPT
ret = cw_bat_regulator_configure(cw_bat, true);
if (ret < 0) {
dev_err(&client->dev, "%s Failed to configure regulators\n", __func__);
goto err_reg_configure;
}
ret = cw_bat_power_on(cw_bat, true);
if (ret < 0) {
dev_err(&client->dev, "%s Failed to power on\n", __func__);
goto err_power_device;
}
ret = cw_bat_pinctrl_init(cw_bat);
if (!ret && cw_bat->ts_pinctrl) {
ret = pinctrl_select_state(cw_bat->ts_pinctrl,
cw_bat->pinctrl_state_active);
if (ret < 0)
goto err_pinctrl_select;
}
ret = cw_bat_gpio_configure(cw_bat, true);
if (ret < 0) {
dev_err(&client->dev, "%s Failed to configure gpios\n", __func__);
goto err_gpio_config;
}
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");
cw_bat->client->irq = gpio_to_irq(pdata->bat_low_pin);
ret = request_threaded_irq(client->irq, NULL,
bat_low_detect_irq_handler, pdata->irq_flags,
"bat_low_detect", cw_bat);
if (ret) {
dev_err(&client->dev, "request irq failed\n");
gpio_free(cw_bat->plat_data->bat_low_pin);
}
/*Chaman add for charger detect*/
charge_psy = power_supply_get_by_name("usb");
err_gpio_config:
if (cw_bat->ts_pinctrl) {
ret = cw_bat_pinctrl_select(cw_bat, false);
if (ret < 0)
pr_err("Cannot get idle pinctrl state\n");
}
err_pinctrl_select:
if (cw_bat->ts_pinctrl) {
pinctrl_put(cw_bat->ts_pinctrl);
}
err_power_device:
cw_bat_power_on(cw_bat, false);
err_reg_configure:
cw_bat_regulator_configure(cw_bat, false);
#endif
printk("\ncw2015/cw2013 driver v1.2 probe sucess\n");
return 0;
rk_bat_register_fail:
dev_dbg(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
return ret;
}
