* published by the Free Software Foundation.
**/
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
#include <linux/io.h>
#include <linux/module.h>
#include <linux/irq.h>
cm->charger_stat[i],
POWER_SUPPLY_PROP_ONLINE, &val);
if (ret) {
- dev_warn(cm->dev, "Cannot read ONLINE value from %s.\n",
- cm->desc->psy_charger_stat[i]);
+ dev_warn(cm->dev, "Cannot read ONLINE value from %s\n",
+ cm->desc->psy_charger_stat[i]);
continue;
}
if (val.intval == 0)
cm->charger_stat[i],
POWER_SUPPLY_PROP_STATUS, &val);
if (ret) {
- dev_warn(cm->dev, "Cannot read STATUS value from %s.\n",
- cm->desc->psy_charger_stat[i]);
+ dev_warn(cm->dev, "Cannot read STATUS value from %s\n",
+ cm->desc->psy_charger_stat[i]);
continue;
}
if (val.intval == POWER_SUPPLY_STATUS_FULL ||
return is_charging(cm);
default:
dev_warn(cm->dev, "Incorrect polling_mode (%d)\n",
- cm->desc->polling_mode);
+ cm->desc->polling_mode);
}
return false;
err = regulator_enable(desc->charger_regulators[i].consumer);
if (err < 0) {
- dev_warn(cm->dev,
- "Cannot enable %s regulator\n",
- desc->charger_regulators[i].regulator_name);
+ dev_warn(cm->dev, "Cannot enable %s regulator\n",
+ desc->charger_regulators[i].regulator_name);
}
}
} else {
err = regulator_disable(desc->charger_regulators[i].consumer);
if (err < 0) {
- dev_warn(cm->dev,
- "Cannot disable %s regulator\n",
- desc->charger_regulators[i].regulator_name);
+ dev_warn(cm->dev, "Cannot disable %s regulator\n",
+ desc->charger_regulators[i].regulator_name);
}
}
desc->charger_regulators[i].consumer)) {
regulator_force_disable(
desc->charger_regulators[i].consumer);
- dev_warn(cm->dev,
- "Disable regulator(%s) forcibly.\n",
- desc->charger_regulators[i].regulator_name);
+ dev_warn(cm->dev, "Disable regulator(%s) forcibly\n",
+ desc->charger_regulators[i].regulator_name);
}
}
}
strncpy(env_str, event, UEVENT_BUF_SIZE);
kobject_uevent(&cm->dev->kobj, KOBJ_CHANGE);
- dev_info(cm->dev, event);
+ dev_info(cm->dev, "%s\n", event);
}
/**
err = get_batt_uV(cm, &batt_uV);
if (err) {
- dev_err(cm->dev, "%s: get_batt_uV error(%d).\n", __func__, err);
+ dev_err(cm->dev, "%s: get_batt_uV error(%d)\n", __func__, err);
return;
}
if (diff < 0)
return;
- dev_info(cm->dev, "VBATT dropped %duV after full-batt.\n", diff);
+ dev_info(cm->dev, "VBATT dropped %duV after full-batt\n", diff);
if (diff > desc->fullbatt_vchkdrop_uV) {
try_charger_restart(cm);
duration = curr - cm->charging_start_time;
if (duration > desc->charging_max_duration_ms) {
- dev_info(cm->dev, "Charging duration exceed %lldms",
+ dev_info(cm->dev, "Charging duration exceed %lldms\n",
desc->charging_max_duration_ms);
uevent_notify(cm, "Discharging");
try_charger_enable(cm, false);
if (duration > desc->charging_max_duration_ms &&
is_ext_pwr_online(cm)) {
- dev_info(cm->dev, "DisCharging duration exceed %lldms",
+ dev_info(cm->dev, "Discharging duration exceed %lldms\n",
desc->discharging_max_duration_ms);
- uevent_notify(cm, "Recharing");
+ uevent_notify(cm, "Recharging");
try_charger_enable(cm, true);
ret = true;
}
*/
} else if (!cm->emergency_stop && check_charging_duration(cm)) {
dev_dbg(cm->dev,
- "Charging/Discharging duration is out of range");
+ "Charging/Discharging duration is out of range\n");
/*
* Check dropped voltage of battery. If battery voltage is more
* dropped than fullbatt_vchkdrop_uV after fully charged state,
*/
} else if (!cm->emergency_stop && is_full_charged(cm) &&
cm->charger_enabled) {
- dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged.\n");
+ dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged\n");
uevent_notify(cm, default_event_names[CM_EVENT_BATT_FULL]);
try_charger_enable(cm, false);
cm->fullbatt_vchk_jiffies_at = 1;
out:
- dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged.\n");
+ dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged\n");
uevent_notify(cm, default_event_names[CM_EVENT_BATT_FULL]);
}
mutex_unlock(&cm_list_mtx);
if (wakeup_ms < UINT_MAX && wakeup_ms > 0) {
- pr_info("Charger Manager wakeup timer: %u ms.\n", wakeup_ms);
+ pr_info("Charger Manager wakeup timer: %u ms\n", wakeup_ms);
if (rtc_dev) {
struct rtc_wkalrm tmp;
unsigned long time, now;
ret = false;
}
- pr_info("Waking up after %lu secs.\n",
- time - now);
+ pr_info("Waking up after %lu secs\n", time - now);
rtc_time_to_tm(time, &tmp.time);
rtc_set_alarm(rtc_dev, &tmp);
g_desc = NULL;
if (!gd->rtc_only_wakeup) {
- pr_err("The callback rtc_only_wakeup is not given.\n");
+ pr_err("The callback rtc_only_wakeup is not given\n");
return -EINVAL;
}
/* Retry at probe. RTC may be not registered yet */
}
} else {
- pr_warn("No wakeup timer is given for charger manager."
+ pr_warn("No wakeup timer is given for charger manager. "
"In-suspend monitoring won't work.\n");
}
cable->min_uA, cable->max_uA);
if (ret < 0) {
pr_err("Cannot set current limit of %s (%s)\n",
- cable->charger->regulator_name, cable->name);
+ cable->charger->regulator_name, cable->name);
return;
}
pr_info("Set current limit of %s : %duA ~ %duA\n",
- cable->charger->regulator_name,
- cable->min_uA, cable->max_uA);
+ cable->charger->regulator_name,
+ cable->min_uA, cable->max_uA);
}
try_charger_enable(cable->cm, cable->attached);
ret = extcon_register_interest(&cable->extcon_dev,
cable->extcon_name, cable->name, &cable->nb);
if (ret < 0) {
- pr_info("Cannot register extcon_dev for %s(cable: %s).\n",
- cable->extcon_name,
- cable->name);
+ pr_info("Cannot register extcon_dev for %s(cable: %s)\n",
+ cable->extcon_name, cable->name);
ret = -EINVAL;
}
charger->consumer = regulator_get(cm->dev,
charger->regulator_name);
- if (charger->consumer == NULL) {
- dev_err(cm->dev, "Cannot find charger(%s)n",
- charger->regulator_name);
- ret = -EINVAL;
- goto err;
+ if (IS_ERR(charger->consumer)) {
+ dev_err(cm->dev, "Cannot find charger(%s)\n",
+ charger->regulator_name);
+ return PTR_ERR(charger->consumer);
}
charger->cm = cm;
ret = charger_extcon_init(cm, cable);
if (ret < 0) {
- dev_err(cm->dev, "Cannot initialize charger(%s)n",
- charger->regulator_name);
+ dev_err(cm->dev, "Cannot initialize charger(%s)\n",
+ charger->regulator_name);
goto err;
}
cable->charger = charger;
}
} else {
dev_warn(cm->dev,
- "'%s' regulator should be controlled "
- "in charger-manager because charger-manager "
- "must need at least one charger for charging\n",
- charger->regulator_name);
+ "'%s' regulator should be controlled in charger-manager because charger-manager must need at least one charger for charging\n",
+ charger->regulator_name);
}
return count;
snprintf(buf, 10, "charger.%d", i);
str = kzalloc(sizeof(char) * (strlen(buf) + 1), GFP_KERNEL);
if (!str) {
- dev_err(cm->dev, "Cannot allocate memory: %s\n",
- charger->regulator_name);
ret = -ENOMEM;
goto err;
}
!chargers_externally_control)
chargers_externally_control = 0;
- dev_info(cm->dev, "'%s' regulator's externally_control"
- "is %d\n", charger->regulator_name,
- charger->externally_control);
+ dev_info(cm->dev, "'%s' regulator's externally_control is %d\n",
+ charger->regulator_name, charger->externally_control);
ret = sysfs_create_group(&cm->charger_psy.dev->kobj,
&charger->attr_g);
if (ret < 0) {
- dev_err(cm->dev, "Cannot create sysfs entry"
- "of %s regulator\n",
- charger->regulator_name);
+ dev_err(cm->dev, "Cannot create sysfs entry of %s regulator\n",
+ charger->regulator_name);
ret = -EINVAL;
goto err;
}
}
if (chargers_externally_control) {
- dev_err(cm->dev, "Cannot register regulator because "
- "charger-manager must need at least "
- "one charger for charging battery\n");
-
+ dev_err(cm->dev, "Cannot register regulator because charger-manager must need at least one charger for charging battery\n");
ret = -EINVAL;
goto err;
}
rtc_dev = rtc_class_open(g_desc->rtc_name);
if (IS_ERR_OR_NULL(rtc_dev)) {
rtc_dev = NULL;
- dev_err(&pdev->dev, "Cannot get RTC %s.\n",
+ dev_err(&pdev->dev, "Cannot get RTC %s\n",
g_desc->rtc_name);
ret = -ENODEV;
goto err_alloc;
}
if (!desc) {
- dev_err(&pdev->dev, "No platform data (desc) found.\n");
+ dev_err(&pdev->dev, "No platform data (desc) found\n");
ret = -ENODEV;
goto err_alloc;
}
cm = kzalloc(sizeof(struct charger_manager), GFP_KERNEL);
if (!cm) {
- dev_err(&pdev->dev, "Cannot allocate memory.\n");
ret = -ENOMEM;
goto err_alloc;
}
cm->dev = &pdev->dev;
cm->desc = kmemdup(desc, sizeof(struct charger_desc), GFP_KERNEL);
if (!cm->desc) {
- dev_err(&pdev->dev, "Cannot allocate memory.\n");
ret = -ENOMEM;
goto err_alloc_desc;
}
* Users may intentionally ignore those two features.
*/
if (desc->fullbatt_uV == 0) {
- dev_info(&pdev->dev, "Ignoring full-battery voltage threshold"
- " as it is not supplied.");
+ dev_info(&pdev->dev, "Ignoring full-battery voltage threshold as it is not supplied\n");
}
if (!desc->fullbatt_vchkdrop_ms || !desc->fullbatt_vchkdrop_uV) {
- dev_info(&pdev->dev, "Disabling full-battery voltage drop "
- "checking mechanism as it is not supplied.");
+ dev_info(&pdev->dev, "Disabling full-battery voltage drop checking mechanism as it is not supplied\n");
desc->fullbatt_vchkdrop_ms = 0;
desc->fullbatt_vchkdrop_uV = 0;
}
if (desc->fullbatt_soc == 0) {
- dev_info(&pdev->dev, "Ignoring full-battery soc(state of"
- " charge) threshold as it is not"
- " supplied.");
+ dev_info(&pdev->dev, "Ignoring full-battery soc(state of charge) threshold as it is not supplied\n");
}
if (desc->fullbatt_full_capacity == 0) {
- dev_info(&pdev->dev, "Ignoring full-battery full capacity"
- " threshold as it is not supplied.");
+ dev_info(&pdev->dev, "Ignoring full-battery full capacity threshold as it is not supplied\n");
}
if (!desc->charger_regulators || desc->num_charger_regulators < 1) {
ret = -EINVAL;
- dev_err(&pdev->dev, "charger_regulators undefined.\n");
+ dev_err(&pdev->dev, "charger_regulators undefined\n");
goto err_no_charger;
}
if (!desc->psy_charger_stat || !desc->psy_charger_stat[0]) {
- dev_err(&pdev->dev, "No power supply defined.\n");
+ dev_err(&pdev->dev, "No power supply defined\n");
ret = -EINVAL;
goto err_no_charger_stat;
}
cm->charger_stat[i] = power_supply_get_by_name(
desc->psy_charger_stat[i]);
if (!cm->charger_stat[i]) {
- dev_err(&pdev->dev, "Cannot find power supply "
- "\"%s\"\n",
- desc->psy_charger_stat[i]);
+ dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n",
+ desc->psy_charger_stat[i]);
ret = -ENODEV;
goto err_chg_stat;
}
cm->fuel_gauge = power_supply_get_by_name(desc->psy_fuel_gauge);
if (!cm->fuel_gauge) {
dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n",
- desc->psy_fuel_gauge);
+ desc->psy_fuel_gauge);
ret = -ENODEV;
goto err_chg_stat;
}
if (!desc->charging_max_duration_ms ||
!desc->discharging_max_duration_ms) {
- dev_info(&pdev->dev, "Cannot limit charging duration "
- "checking mechanism to prevent overcharge/overheat "
- "and control discharging duration");
+ dev_info(&pdev->dev, "Cannot limit charging duration checking mechanism to prevent overcharge/overheat and control discharging duration\n");
desc->charging_max_duration_ms = 0;
desc->discharging_max_duration_ms = 0;
}
NUM_CHARGER_PSY_OPTIONAL),
GFP_KERNEL);
if (!cm->charger_psy.properties) {
- dev_err(&pdev->dev, "Cannot allocate for psy properties.\n");
ret = -ENOMEM;
goto err_chg_stat;
}
ret = power_supply_register(NULL, &cm->charger_psy);
if (ret) {
- dev_err(&pdev->dev, "Cannot register charger-manager with"
- " name \"%s\".\n", cm->charger_psy.name);
+ dev_err(&pdev->dev, "Cannot register charger-manager with name \"%s\"\n",
+ cm->charger_psy.name);
goto err_register;
}
charger = &desc->charger_regulators[i];
for (j = 0; j < charger->num_cables; j++) {
struct charger_cable *cable = &charger->cables[j];
- extcon_unregister_interest(&cable->extcon_dev);
+ /* Remove notifier block if only edev exists */
+ if (cable->extcon_dev.edev)
+ extcon_unregister_interest(&cable->extcon_dev);
}
regulator_put(desc->charger_regulators[i].consumer);
uevent_notify(cm, msg ? msg : default_event_names[type]);
break;
default:
- dev_err(cm->dev, "%s type not specified.\n", __func__);
+ dev_err(cm->dev, "%s: type not specified\n", __func__);
break;
}
}
#include <linux/mfd/tps65090.h>
#define TPS65090_REG_INTR_STS 0x00
+#define TPS65090_REG_INTR_MASK 0x02
#define TPS65090_REG_CG_CTRL0 0x04
#define TPS65090_REG_CG_CTRL1 0x05
#define TPS65090_REG_CG_CTRL2 0x06
return 0;
}
-static int tps65090_enable_charging(struct tps65090_charger *charger,
- uint8_t enable)
+static int tps65090_enable_charging(struct tps65090_charger *charger)
{
int ret;
uint8_t ctrl0 = 0;
ret = tps65090_write(charger->dev->parent, TPS65090_REG_CG_CTRL0,
(ctrl0 | TPS65090_CHARGER_ENABLE));
if (ret < 0) {
- dev_err(charger->dev, "%s(): error reading in register 0x%x\n",
+ dev_err(charger->dev, "%s(): error writing in register 0x%x\n",
__func__, TPS65090_REG_CG_CTRL0);
return ret;
}
static int tps65090_config_charger(struct tps65090_charger *charger)
{
+ uint8_t intrmask = 0;
int ret;
if (charger->pdata->enable_low_current_chrg) {
}
}
+ /* Enable the VACG interrupt for AC power detect */
+ ret = tps65090_read(charger->dev->parent, TPS65090_REG_INTR_MASK,
+ &intrmask);
+ if (ret < 0) {
+ dev_err(charger->dev, "%s(): error reading in register 0x%x\n",
+ __func__, TPS65090_REG_INTR_MASK);
+ return ret;
+ }
+
+ ret = tps65090_write(charger->dev->parent, TPS65090_REG_INTR_MASK,
+ (intrmask | TPS65090_VACG));
+ if (ret < 0) {
+ dev_err(charger->dev, "%s(): error writing in register 0x%x\n",
+ __func__, TPS65090_REG_CG_CTRL0);
+ return ret;
+ }
+
return 0;
}
}
if (intrsts & TPS65090_VACG) {
- ret = tps65090_enable_charging(charger, 1);
+ ret = tps65090_enable_charging(charger);
if (ret < 0)
return IRQ_HANDLED;
charger->ac_online = 1;
charger->ac_online = 0;
}
+ /* Clear interrupts. */
+ ret = tps65090_write(charger->dev->parent, TPS65090_REG_INTR_STS, 0x00);
+ if (ret < 0) {
+ dev_err(charger->dev, "%s(): Error in writing reg 0x%x\n",
+ __func__, TPS65090_REG_INTR_STS);
+ }
+
if (charger->prev_ac_online != charger->ac_online)
power_supply_changed(&charger->ac);
return -ENOMEM;
}
- dev_set_drvdata(&pdev->dev, cdata);
+ platform_set_drvdata(pdev, cdata);
cdata->dev = &pdev->dev;
cdata->pdata = pdata;
cdata->ac.num_properties = ARRAY_SIZE(tps65090_ac_props);
cdata->ac.supplied_to = pdata->supplied_to;
cdata->ac.num_supplicants = pdata->num_supplicants;
+ cdata->ac.of_node = pdev->dev.of_node;
ret = power_supply_register(&pdev->dev, &cdata->ac);
if (ret) {
}
if (status1 != 0) {
- ret = tps65090_enable_charging(cdata, 1);
+ ret = tps65090_enable_charging(cdata);
if (ret < 0) {
dev_err(cdata->dev, "error enabling charger\n");
goto fail_free_irq;
static int tps65090_charger_remove(struct platform_device *pdev)
{
- struct tps65090_charger *cdata = dev_get_drvdata(&pdev->dev);
+ struct tps65090_charger *cdata = platform_get_drvdata(pdev);
devm_free_irq(cdata->dev, cdata->irq, cdata);
power_supply_unregister(&cdata->ac);
projects / cascardo / linux.git / commitdiff