static int __devinit isl9519q_init_adapter(struct isl9519q_struct *isl_chg)
{
int ret;
struct i2c_client *client = isl_chg->client;
struct isl_platform_data *pdata = client->dev.platform_data;
isl_chg->adapter_hw_chg.type = CHG_TYPE_AC;
isl_chg->adapter_hw_chg.rating = 2;
isl_chg->adapter_hw_chg.name = "isl-adapter";
isl_chg->adapter_hw_chg.start_charging = isl_adapter_start_charging;
isl_chg->adapter_hw_chg.stop_charging = isl_adapter_stop_charging;
isl_chg->adapter_hw_chg.charging_switched = isl9519q_charging_switched;
ret = gpio_request(pdata->valid_n_gpio, "isl_charger_valid");
if (ret) {
dev_err(&client->dev, "%s gpio_request failed "
"for %d ret=%d\n",
__func__, pdata->valid_n_gpio, ret);
goto out;
}
ret = msm_charger_register(&isl_chg->adapter_hw_chg);
if (ret) {
dev_err(&client->dev,
"%s msm_charger_register failed for ret =%d\n",
__func__, ret);
goto free_gpio;
}
ret = request_threaded_irq(client->irq, NULL,
isl_valid_handler,
IRQF_TRIGGER_FALLING |
IRQF_TRIGGER_RISING,
"isl_charger_valid", client);
if (ret) {
dev_err(&client->dev,
"%s request_threaded_irq failed "
"for %d ret =%d\n",
__func__, client->irq, ret);
goto unregister;
}
irq_set_irq_wake(client->irq, 1);
ret = gpio_get_value_cansleep(isl_chg->valid_n_gpio);
if (ret < 0) {
dev_err(&client->dev,
"%s gpio_get_value failed for %d ret=%d\n",
__func__, pdata->valid_n_gpio, ret);
/* assume absent */
ret = 1;
}
if (!ret) {
msm_charger_notify_event(&isl_chg->adapter_hw_chg,
CHG_INSERTED_EVENT);
isl_chg->present = 1;
}
return 0;
unregister:
msm_charger_unregister(&isl_chg->adapter_hw_chg);
free_gpio:
gpio_free(pdata->valid_n_gpio);
out:
return ret;
}
static int __devinit max8903_probe(struct platform_device *pdev)
{
struct max8903_struct *max_chg;
struct device *dev = &pdev->dev;
struct max8903_platform_data *pdata = pdev->dev.platform_data;
struct pm8058_chip *chip;
int ret = 0;
//printk("%s\n", __func__);
max_chg = kzalloc(sizeof(struct max8903_struct), GFP_KERNEL);
if (max_chg == NULL) {
dev_err(dev, "Cannot allocate memory.\n");
return -ENOMEM;
}
saved_msm_chg = max_chg;
if (pdata == NULL) {
dev_err(&pdev->dev, "%s no platform data\n", __func__);
ret = -EINVAL;
goto out;
}
INIT_DELAYED_WORK(&max_chg->charge_work, max8903_charge);
INIT_DELAYED_WORK(&max_chg->ac_charger, ac_charger_detect);
wake_lock_init(&max_chg->wl, WAKE_LOCK_SUSPEND, "max8903");
max_chg->dev = &pdev->dev;;
max_chg->irq = pdata->irq;
max_chg->cen = pdata->cen;
max_chg->chg = pdata->chg;
max_chg->flt = pdata->flt;
max_chg->usus = pdata->usus;
max_chg->dock_det = pdata->dock_det;
max_chg->usb_chg_enable = 1; /* enable usb charge */
if (BOARD_NUM(hw_ver) == BOARD_NUM_V11)
max_chg->adapter_hw_chg.type = CHG_TYPE_AC;
else
max_chg->adapter_hw_chg.type = CHG_TYPE_USB;
max_chg->adapter_hw_chg.rating = 2;
max_chg->adapter_hw_chg.name = "max8903-charger";
max_chg->adapter_hw_chg.start_charging = max8903_start_charging;
max_chg->adapter_hw_chg.stop_charging = max8903_stop_charging;
max_chg->adapter_hw_chg.charging_switched = max8903_charging_switched;
platform_set_drvdata(pdev, max_chg);
ret = gpio_request(max_chg->cen, "CHARGER_CEN_N");
if (ret) {
dev_err(max_chg->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, max_chg->cen, ret);
goto free_max_chg;
}
ret = gpio_request(max_chg->chg, "CHARGER_STATUS");
if (ret) {
dev_err(max_chg->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, max_chg->chg, ret);
goto free_cen;
}
gpio_direction_input(max_chg->chg);
ret = gpio_request(max_chg->flt, "CHARGER_FAULT_N");
if (ret) {
dev_err(max_chg->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, max_chg->flt, ret);
goto free_chg;
}
gpio_direction_input(max_chg->flt);
ret = request_threaded_irq(gpio_to_irq(max_chg->flt),
NULL, max8903_fault,
IRQF_TRIGGER_FALLING ,"MAX8903 Fault", pdev);
if (ret) {
dev_err(dev, "Cannot request irq %d for Fault (%d)\n",
gpio_to_irq(max_chg->flt), ret);
goto free_flt;
}
ret = gpio_request(max_chg->usus, "USUS_CTRL");
if (ret) {
dev_err(max_chg->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, max_chg->usus, ret);
goto err_flt_irq;
}
ret = gpio_request(max_chg->dock_det, "DOCK_DET");
if (ret) {
dev_err(max_chg->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, max_chg->dock_det, ret);
goto free_usus;
}
gpio_direction_input(max_chg->dock_det);
ret = msm_charger_register(&max_chg->adapter_hw_chg);
if (ret) {
dev_err(max_chg->dev,
"%s msm_charger_register failed for ret =%d\n",
__func__, ret);
goto free_dock_det;
}
ret = device_create_file(max_chg->dev, &usb_chg_enable_attr);
if (ret) {
dev_err(max_chg->dev, "failed: create usb_chg_enable file\n");
}
ret = request_threaded_irq(max_chg->irq, NULL,
max_valid_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"max_valid_handler", pdev);
if (ret) {
dev_err(max_chg->dev,
"%s request_threaded_irq failed for %d ret =%d\n",
__func__, max_chg->irq, ret);
goto unregister;
}
set_irq_wake(max_chg->irq, 1);
chip = get_irq_data(max_chg->irq);
ret = pm8058_irq_get_rt_status(chip, max_chg->irq);
if (ret) {
#if 0
if (!gpio_get_value_cansleep(max_chg->dock_det)) /* Dock insert, think it as AC charger */
max_chg->adapter_hw_chg.type = CHG_TYPE_AC;
msm_charger_notify_event(&max_chg->adapter_hw_chg,
CHG_INSERTED_EVENT);
#else
/* Charger inserted, but not a valid USB charger
* think it as a AC charger
*/
if (USB_CHG_TYPE__INVALID == cur_chg_type)
max_chg->adapter_hw_chg.type = CHG_TYPE_AC;
msm_charger_notify_event(&max_chg->adapter_hw_chg,
CHG_INSERTED_EVENT);
#endif
max_chg->present = 1;
wake_lock(&max_chg->wl);
}
msm_register_usb_charger_state(max8903_usb_charger_state);
pr_info("%s OK chg_present=%d\n", __func__, max_chg->present);
return 0;
unregister:
msm_charger_unregister(&max_chg->adapter_hw_chg);
free_dock_det:
gpio_free(max_chg->dock_det);
free_usus:
gpio_free(max_chg->usus);
err_flt_irq:
free_irq(gpio_to_irq(max_chg->flt), pdev);
free_flt:
gpio_free(max_chg->flt);
free_chg:
gpio_free(max_chg->chg);
free_cen:
gpio_free(max_chg->cen);
free_max_chg:
kfree(max_chg);
out:
return ret;
}
static int __devinit isl9519q_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct isl_platform_data *pdata;
struct isl9519q_struct *isl_chg;
int ret;
ret = 0;
pdata = client->dev.platform_data;
if (pdata == NULL) {
dev_err(&client->dev, "%s no platform data\n", __func__);
ret = -EINVAL;
goto out;
}
if (!i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_WORD_DATA)) {
ret = -EIO;
goto out;
}
isl_chg = kzalloc(sizeof(*isl_chg), GFP_KERNEL);
if (!isl_chg) {
ret = -ENOMEM;
goto out;
}
INIT_DELAYED_WORK(&isl_chg->charge_work, isl9519q_charge);
isl_chg->client = client;
isl_chg->chgcurrent = pdata->chgcurrent;
isl_chg->term_current = pdata->term_current;
isl_chg->input_current = pdata->input_current;
isl_chg->max_system_voltage = pdata->max_system_voltage;
isl_chg->min_system_voltage = pdata->min_system_voltage;
isl_chg->valid_n_gpio = pdata->valid_n_gpio;
/* h/w ignores lower 7 bits of charging current and input current */
isl_chg->chgcurrent &= ~0x7F;
isl_chg->input_current &= ~0x7F;
isl_chg->adapter_hw_chg.type = CHG_TYPE_AC;
isl_chg->adapter_hw_chg.rating = 2;
isl_chg->adapter_hw_chg.name = "isl-adapter";
isl_chg->adapter_hw_chg.start_charging = isl9519q_start_charging;
isl_chg->adapter_hw_chg.stop_charging = isl9519q_stop_charging;
isl_chg->adapter_hw_chg.charging_switched = isl9519q_charging_switched;
if (pdata->chg_detection_config) {
ret = pdata->chg_detection_config();
if (ret) {
dev_err(&client->dev, "%s valid config failed ret=%d\n",
__func__, ret);
goto free_isl_chg;
}
}
ret = gpio_request(pdata->valid_n_gpio, "isl_charger_valid");
if (ret) {
dev_err(&client->dev, "%s gpio_request failed for %d ret=%d\n",
__func__, pdata->valid_n_gpio, ret);
goto free_isl_chg;
}
i2c_set_clientdata(client, isl_chg);
ret = msm_charger_register(&isl_chg->adapter_hw_chg);
if (ret) {
dev_err(&client->dev,
"%s msm_charger_register failed for ret =%d\n",
__func__, ret);
goto free_gpio;
}
ret = request_threaded_irq(client->irq, NULL,
isl_valid_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
"isl_charger_valid", client);
if (ret) {
dev_err(&client->dev,
"%s request_threaded_irq failed for %d ret =%d\n",
__func__, client->irq, ret);
goto unregister;
}
set_irq_wake(client->irq, 1);
isl_chg->max_system_voltage &= MAX_VOLTAGE_REG_MASK;
isl_chg->min_system_voltage &= MIN_VOLTAGE_REG_MASK;
if (isl_chg->max_system_voltage == 0)
isl_chg->max_system_voltage = DEFAULT_MAX_VOLTAGE_REG_VALUE;
if (isl_chg->min_system_voltage == 0)
isl_chg->min_system_voltage = DEFAULT_MIN_VOLTAGE_REG_VALUE;
ret = isl9519q_write_reg(isl_chg->client, MAX_SYS_VOLTAGE_REG,
isl_chg->max_system_voltage);
if (ret) {
dev_err(&client->dev,
"%s couldnt write to MAX_SYS_VOLTAGE_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
ret = isl9519q_write_reg(isl_chg->client, MIN_SYS_VOLTAGE_REG,
isl_chg->min_system_voltage);
if (ret) {
dev_err(&client->dev,
"%s couldnt write to MIN_SYS_VOLTAGE_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
if (isl_chg->input_current) {
ret = isl9519q_write_reg(isl_chg->client,
INPUT_CURRENT_REG,
isl_chg->input_current);
if (ret) {
dev_err(&client->dev,
"%s couldnt write INPUT_CURRENT_REG ret=%d\n",
__func__, ret);
goto free_irq;
}
}
ret = gpio_get_value_cansleep(isl_chg->valid_n_gpio);
if (ret < 0) {
dev_err(&client->dev,
"%s gpio_get_value failed for %d ret=%d\n", __func__,
pdata->valid_n_gpio, ret);
/* assume absent */
ret = 1;
}
if (!ret) {
msm_charger_notify_event(&isl_chg->adapter_hw_chg,
CHG_INSERTED_EVENT);
isl_chg->present = 1;
}
pr_debug("%s OK chg_present=%d\n", __func__, isl_chg->present);
return 0;
free_irq:
free_irq(client->irq, NULL);
unregister:
msm_charger_unregister(&isl_chg->adapter_hw_chg);
free_gpio:
gpio_free(pdata->valid_n_gpio);
free_isl_chg:
kfree(isl_chg);
out:
return ret;
}
static int __devinit pm8058_charger_probe(struct platform_device *pdev)
{
int ret;
struct pm8058_charger_platform_data *pdata;
struct msm_hardware_charger *pchg;
pdata = pdev->dev.platform_data;
if(!pdata) {
pr_err("%s: no platform_data passed in. \n", __func__);
return -EFAULT;
}
pchg = kzalloc(sizeof *pchg, GFP_KERNEL);
if (pchg == NULL) {
pr_err("%s kzalloc failed\n", __func__);
return -ENOMEM;
}
pchg->chg_detection_config = pdata->chg_detection_config;
pchg->get_charger_status = pdata->get_charger_status;
pchg->pdev = pdev;
pchg->gpio_num = pdata->gpio_num;
pchg->rating = pdata->rating;
pchg->charger.name = pdata->name;
if(pdata->rating == 2) {
pchg->charger.type = POWER_SUPPLY_TYPE_MAINS;
} else if(pdata->rating == 1) {
pchg->charger.type = POWER_SUPPLY_TYPE_USB;
} else {
goto error_type;
}
pchg->charger.supplied_to = msm_power_supplied_to;
pchg->charger.num_supplicants = ARRAY_SIZE(msm_power_supplied_to);
pchg->charger.properties = msm_power_props;
pchg->charger.num_properties = ARRAY_SIZE(msm_power_props);
pchg->charger.get_property = charger_get_property_s7pro;
//
//#ifdef CONFIG_HAS_EARLYSUSPEND
// pchg->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
// pchg->early_suspend.suspend = s7pro_charger_early_suspend;
// pchg->early_suspend.resume = s7pro_charger_late_resume;
// register_early_suspend(&pchg->early_suspend);
//#endif
//
dev_set_drvdata(&pdev->dev, pchg);
if(pchg->chg_detection_config(1, pchg->gpio_num)) {
pr_err("%s, init config fail. \n", __func__);
goto error_type;
}
ret = request_irqs(pchg);
if (ret) {
pr_err("%s: couldnt register interrupts\n", __func__);
goto error_type;
}
ret = msm_charger_register(pchg);
if(ret) {
pr_err("%s register charger failed ret=%d\n",
__func__, ret);
goto register_fail;
}
/* determine what state the charger is in */
pm8058_chg_determine_initial_state(pchg);
return 0;
register_fail:
free_irqs(pchg);
error_type:
kfree(pchg);
return -EFAULT;
}
