cregit-Linux how code gets into the kernel

Release 4.11 drivers/power/supply/charger-manager.c

/*
 * Copyright (C) 2011 Samsung Electronics Co., Ltd.
 * MyungJoo Ham <myungjoo.ham@samsung.com>
 *
 * This driver enables to monitor battery health and control charger
 * during suspend-to-mem.
 * Charger manager depends on other devices. register this later than
 * the depending devices.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * 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>
#include <linux/interrupt.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/power/charger-manager.h>
#include <linux/regulator/consumer.h>
#include <linux/sysfs.h>
#include <linux/of.h>
#include <linux/thermal.h>

/*
 * Default termperature threshold for charging.
 * Every temperature units are in tenth of centigrade.
 */

#define CM_DEFAULT_RECHARGE_TEMP_DIFF	50

#define CM_DEFAULT_CHARGE_TEMP_MAX	500


static const char * const default_event_names[] = {
	[CM_EVENT_UNKNOWN] = "Unknown",
	[CM_EVENT_BATT_FULL] = "Battery Full",
	[CM_EVENT_BATT_IN] = "Battery Inserted",
	[CM_EVENT_BATT_OUT] = "Battery Pulled Out",
	[CM_EVENT_BATT_OVERHEAT] = "Battery Overheat",
	[CM_EVENT_BATT_COLD] = "Battery Cold",
	[CM_EVENT_EXT_PWR_IN_OUT] = "External Power Attach/Detach",
	[CM_EVENT_CHG_START_STOP] = "Charging Start/Stop",
	[CM_EVENT_OTHERS] = "Other battery events"
};

/*
 * Regard CM_JIFFIES_SMALL jiffies is small enough to ignore for
 * delayed works so that we can run delayed works with CM_JIFFIES_SMALL
 * without any delays.
 */

#define	CM_JIFFIES_SMALL	(2)

/* If y is valid (> 0) and smaller than x, do x = y */

#define CM_MIN_VALID(x, y)	x = (((y > 0) && ((x) > (y))) ? (y) : (x))

/*
 * Regard CM_RTC_SMALL (sec) is small enough to ignore error in invoking
 * rtc alarm. It should be 2 or larger
 */

#define CM_RTC_SMALL		(2)


#define UEVENT_BUF_SIZE		32

static LIST_HEAD(cm_list);
static DEFINE_MUTEX(cm_list_mtx);

/* About in-suspend (suspend-again) monitoring */

static struct alarm *cm_timer;


static bool cm_suspended;

static bool cm_timer_set;

static unsigned long cm_suspend_duration_ms;

/* About normal (not suspended) monitoring */

static unsigned long polling_jiffy = ULONG_MAX; 
/* ULONG_MAX: no polling */

static unsigned long next_polling; 
/* Next appointed polling time */

static struct workqueue_struct *cm_wq; 
/* init at driver add */

static struct delayed_work cm_monitor_work; 
/* init at driver add */

/**
 * is_batt_present - See if the battery presents in place.
 * @cm: the Charger Manager representing the battery.
 */

static bool is_batt_present(struct charger_manager *cm) { union power_supply_propval val; struct power_supply *psy; bool present = false; int i, ret; switch (cm->desc->battery_present) { case CM_BATTERY_PRESENT: present = true; break; case CM_NO_BATTERY: break; case CM_FUEL_GAUGE: psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!psy) break; ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_PRESENT, &val); if (ret == 0 && val.intval) present = true; power_supply_put(psy); break; case CM_CHARGER_STAT: for (i = 0; cm->desc->psy_charger_stat[i]; i++) { psy = power_supply_get_by_name( cm->desc->psy_charger_stat[i]); if (!psy) { dev_err(cm->dev, "Cannot find power supply \"%s\"\n", cm->desc->psy_charger_stat[i]); continue; } ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_PRESENT, &val); power_supply_put(psy); if (ret == 0 && val.intval) { present = true; break; } } break; } return present; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim12460.49%116.67%
Krzysztof Kozlowski6933.66%466.67%
Chanwoo Choi125.85%116.67%
Total205100.00%6100.00%

/** * is_ext_pwr_online - See if an external power source is attached to charge * @cm: the Charger Manager representing the battery. * * Returns true if at least one of the chargers of the battery has an external * power source attached to charge the battery regardless of whether it is * actually charging or not. */
static bool is_ext_pwr_online(struct charger_manager *cm) { union power_supply_propval val; struct power_supply *psy; bool online = false; int i, ret; /* If at least one of them has one, it's yes. */ for (i = 0; cm->desc->psy_charger_stat[i]; i++) { psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]); if (!psy) { dev_err(cm->dev, "Cannot find power supply \"%s\"\n", cm->desc->psy_charger_stat[i]); continue; } ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_ONLINE, &val); power_supply_put(psy); if (ret == 0 && val.intval) { online = true; break; } } return online; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim8264.06%125.00%
Krzysztof Kozlowski4635.94%375.00%
Total128100.00%4100.00%

/** * get_batt_uV - Get the voltage level of the battery * @cm: the Charger Manager representing the battery. * @uV: the voltage level returned. * * Returns 0 if there is no error. * Returns a negative value on error. */
static int get_batt_uV(struct charger_manager *cm, int *uV) { union power_supply_propval val; struct power_supply *fuel_gauge; int ret; fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!fuel_gauge) return -ENODEV; ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_VOLTAGE_NOW, &val); power_supply_put(fuel_gauge); if (ret) return ret; *uV = val.intval; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim5466.67%120.00%
Krzysztof Kozlowski2227.16%360.00%
Axel Lin56.17%120.00%
Total81100.00%5100.00%

/** * is_charging - Returns true if the battery is being charged. * @cm: the Charger Manager representing the battery. */
static bool is_charging(struct charger_manager *cm) { int i, ret; bool charging = false; struct power_supply *psy; union power_supply_propval val; /* If there is no battery, it cannot be charged */ if (!is_batt_present(cm)) return false; /* If at least one of the charger is charging, return yes */ for (i = 0; cm->desc->psy_charger_stat[i]; i++) { /* 1. The charger sholuld not be DISABLED */ if (cm->emergency_stop) continue; if (!cm->charger_enabled) continue; psy = power_supply_get_by_name(cm->desc->psy_charger_stat[i]); if (!psy) { dev_err(cm->dev, "Cannot find power supply \"%s\"\n", cm->desc->psy_charger_stat[i]); continue; } /* 2. The charger should be online (ext-power) */ ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_ONLINE, &val); if (ret) { dev_warn(cm->dev, "Cannot read ONLINE value from %s\n", cm->desc->psy_charger_stat[i]); power_supply_put(psy); continue; } if (val.intval == 0) { power_supply_put(psy); continue; } /* * 3. The charger should not be FULL, DISCHARGING, * or NOT_CHARGING. */ ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, &val); power_supply_put(psy); if (ret) { 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 || val.intval == POWER_SUPPLY_STATUS_DISCHARGING || val.intval == POWER_SUPPLY_STATUS_NOT_CHARGING) continue; /* Then, this is charging. */ charging = true; break; } return charging; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim18874.90%120.00%
Krzysztof Kozlowski6124.30%360.00%
Joe Perches20.80%120.00%
Total251100.00%5100.00%

/** * is_full_charged - Returns true if the battery is fully charged. * @cm: the Charger Manager representing the battery. */
static bool is_full_charged(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; union power_supply_propval val; struct power_supply *fuel_gauge; bool is_full = false; int ret = 0; int uV; /* If there is no battery, it cannot be charged */ if (!is_batt_present(cm)) return false; fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!fuel_gauge) return false; if (desc->fullbatt_full_capacity > 0) { val.intval = 0; /* Not full if capacity of fuel gauge isn't full */ ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CHARGE_FULL, &val); if (!ret && val.intval > desc->fullbatt_full_capacity) { is_full = true; goto out; } } /* Full, if it's over the fullbatt voltage */ if (desc->fullbatt_uV > 0) { ret = get_batt_uV(cm, &uV); if (!ret && uV >= desc->fullbatt_uV) { is_full = true; goto out; } } /* Full, if the capacity is more than fullbatt_soc */ if (desc->fullbatt_soc > 0) { val.intval = 0; ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CAPACITY, &val); if (!ret && val.intval >= desc->fullbatt_soc) { is_full = true; goto out; } } out: power_supply_put(fuel_gauge); return is_full; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi16472.57%240.00%
Krzysztof Kozlowski6227.43%360.00%
Total226100.00%5100.00%

/** * is_polling_required - Return true if need to continue polling for this CM. * @cm: the Charger Manager representing the battery. */
static bool is_polling_required(struct charger_manager *cm) { switch (cm->desc->polling_mode) { case CM_POLL_DISABLE: return false; case CM_POLL_ALWAYS: return true; case CM_POLL_EXTERNAL_POWER_ONLY: return is_ext_pwr_online(cm); case CM_POLL_CHARGING_ONLY: return is_charging(cm); default: dev_warn(cm->dev, "Incorrect polling_mode (%d)\n", cm->desc->polling_mode); } return false; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim70100.00%1100.00%
Total70100.00%1100.00%

/** * try_charger_enable - Enable/Disable chargers altogether * @cm: the Charger Manager representing the battery. * @enable: true: enable / false: disable * * Note that Charger Manager keeps the charger enabled regardless whether * the charger is charging or not (because battery is full or no external * power source exists) except when CM needs to disable chargers forcibly * bacause of emergency causes; when the battery is overheated or too cold. */
static int try_charger_enable(struct charger_manager *cm, bool enable) { int err = 0, i; struct charger_desc *desc = cm->desc; /* Ignore if it's redundent command */ if (enable == cm->charger_enabled) return 0; if (enable) { if (cm->emergency_stop) return -EAGAIN; /* * Save start time of charging to limit * maximum possible charging time. */ cm->charging_start_time = ktime_to_ms(ktime_get()); cm->charging_end_time = 0; for (i = 0 ; i < desc->num_charger_regulators ; i++) { if (desc->charger_regulators[i].externally_control) continue; 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); } } } else { /* * Save end time of charging to maintain fully charged state * of battery after full-batt. */ cm->charging_start_time = 0; cm->charging_end_time = ktime_to_ms(ktime_get()); for (i = 0 ; i < desc->num_charger_regulators ; i++) { if (desc->charger_regulators[i].externally_control) continue; 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); } } /* * Abnormal battery state - Stop charging forcibly, * even if charger was enabled at the other places */ for (i = 0; i < desc->num_charger_regulators; i++) { if (regulator_is_enabled( 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); } } } if (!err) cm->charger_enabled = enable; return err; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi16452.73%457.14%
Donggeun Kim14546.62%114.29%
Joe Perches10.32%114.29%
Axel Lin10.32%114.29%
Total311100.00%7100.00%

/** * try_charger_restart - Restart charging. * @cm: the Charger Manager representing the battery. * * Restart charging by turning off and on the charger. */
static int try_charger_restart(struct charger_manager *cm) { int err; if (cm->emergency_stop) return -EAGAIN; err = try_charger_enable(cm, false); if (err) return err; return try_charger_enable(cm, true); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi48100.00%1100.00%
Total48100.00%1100.00%

/** * uevent_notify - Let users know something has changed. * @cm: the Charger Manager representing the battery. * @event: the event string. * * If @event is null, it implies that uevent_notify is called * by resume function. When called in the resume function, cm_suspended * should be already reset to false in order to let uevent_notify * notify the recent event during the suspend to users. While * suspended, uevent_notify does not notify users, but tracks * events so that uevent_notify can notify users later after resumed. */
static void uevent_notify(struct charger_manager *cm, const char *event) { static char env_str[UEVENT_BUF_SIZE + 1] = ""; static char env_str_save[UEVENT_BUF_SIZE + 1] = ""; if (cm_suspended) { /* Nothing in suspended-event buffer */ if (env_str_save[0] == 0) { if (!strncmp(env_str, event, UEVENT_BUF_SIZE)) return; /* status not changed */ strncpy(env_str_save, event, UEVENT_BUF_SIZE); return; } if (!strncmp(env_str_save, event, UEVENT_BUF_SIZE)) return; /* Duplicated. */ strncpy(env_str_save, event, UEVENT_BUF_SIZE); return; } if (event == NULL) { /* No messages pending */ if (!env_str_save[0]) return; strncpy(env_str, env_str_save, UEVENT_BUF_SIZE); kobject_uevent(&cm->dev->kobj, KOBJ_CHANGE); env_str_save[0] = 0; return; } /* status not changed */ if (!strncmp(env_str, event, UEVENT_BUF_SIZE)) return; /* save the status and notify the update */ strncpy(env_str, event, UEVENT_BUF_SIZE); kobject_uevent(&cm->dev->kobj, KOBJ_CHANGE); dev_info(cm->dev, "%s\n", event); }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim19698.99%133.33%
Joe Perches10.51%133.33%
Kees Cook10.51%133.33%
Total198100.00%3100.00%

/** * fullbatt_vchk - Check voltage drop some times after "FULL" event. * @work: the work_struct appointing the function * * If a user has designated "fullbatt_vchkdrop_ms/uV" values with * charger_desc, Charger Manager checks voltage drop after the battery * "FULL" event. It checks whether the voltage has dropped more than * fullbatt_vchkdrop_uV by calling this function after fullbatt_vchkrop_ms. */
static void fullbatt_vchk(struct work_struct *work) { struct delayed_work *dwork = to_delayed_work(work); struct charger_manager *cm = container_of(dwork, struct charger_manager, fullbatt_vchk_work); struct charger_desc *desc = cm->desc; int batt_uV, err, diff; /* remove the appointment for fullbatt_vchk */ cm->fullbatt_vchk_jiffies_at = 0; if (!desc->fullbatt_vchkdrop_uV || !desc->fullbatt_vchkdrop_ms) return; err = get_batt_uV(cm, &batt_uV); if (err) { dev_err(cm->dev, "%s: get_batt_uV error(%d)\n", __func__, err); return; } diff = desc->fullbatt_uV - batt_uV; if (diff < 0) return; dev_info(cm->dev, "VBATT dropped %duV after full-batt\n", diff); if (diff > desc->fullbatt_vchkdrop_uV) { try_charger_restart(cm); uevent_notify(cm, "Recharging"); } }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi14898.67%583.33%
Joe Perches21.33%116.67%
Total150100.00%6100.00%

/** * check_charging_duration - Monitor charging/discharging duration * @cm: the Charger Manager representing the battery. * * If whole charging duration exceed 'charging_max_duration_ms', * cm stop charging to prevent overcharge/overheat. If discharging * duration exceed 'discharging _max_duration_ms', charger cable is * attached, after full-batt, cm start charging to maintain fully * charged state for battery. */
static int check_charging_duration(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; u64 curr = ktime_to_ms(ktime_get()); u64 duration; int ret = false; if (!desc->charging_max_duration_ms && !desc->discharging_max_duration_ms) return ret; if (cm->charger_enabled) { duration = curr - cm->charging_start_time; if (duration > desc->charging_max_duration_ms) { dev_info(cm->dev, "Charging duration exceed %ums\n", desc->charging_max_duration_ms); uevent_notify(cm, "Discharging"); try_charger_enable(cm, false); ret = true; } } else if (is_ext_pwr_online(cm) && !cm->charger_enabled) { duration = curr - cm->charging_end_time; if (duration > desc->charging_max_duration_ms && is_ext_pwr_online(cm)) { dev_info(cm->dev, "Discharging duration exceed %ums\n", desc->discharging_max_duration_ms); uevent_notify(cm, "Recharging"); try_charger_enable(cm, true); ret = true; } } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi9753.59%120.00%
Donggeun Kim7843.09%120.00%
Axel Lin31.66%120.00%
Jonghwa Lee21.10%120.00%
Joe Perches10.55%120.00%
Total181100.00%5100.00%


static int cm_get_battery_temperature_by_psy(struct charger_manager *cm, int *temp) { struct power_supply *fuel_gauge; int ret; fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!fuel_gauge) return -ENODEV; ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_TEMP, (union power_supply_propval *)temp); power_supply_put(fuel_gauge); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Krzysztof Kozlowski67100.00%3100.00%
Total67100.00%3100.00%


static int cm_get_battery_temperature(struct charger_manager *cm, int *temp) { int ret; if (!cm->desc->measure_battery_temp) return -ENODEV; #ifdef CONFIG_THERMAL if (cm->tzd_batt) { ret = thermal_zone_get_temp(cm->tzd_batt, temp); if (!ret) /* Calibrate temperature unit */ *temp /= 100; } else #endif { /* if-else continued from CONFIG_THERMAL */ ret = cm_get_battery_temperature_by_psy(cm, temp); } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee6680.49%133.33%
Krzysztof Kozlowski1518.29%133.33%
Chanwoo Choi11.22%133.33%
Total82100.00%3100.00%


static int cm_check_thermal_status(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; int temp, upper_limit, lower_limit; int ret = 0; ret = cm_get_battery_temperature(cm, &temp); if (ret) { /* FIXME: * No information of battery temperature might * occur hazadous result. We have to handle it * depending on battery type. */ dev_err(cm->dev, "Failed to get battery temperature\n"); return 0; } upper_limit = desc->temp_max; lower_limit = desc->temp_min; if (cm->emergency_stop) { upper_limit -= desc->temp_diff; lower_limit += desc->temp_diff; } if (temp > upper_limit) ret = CM_EVENT_BATT_OVERHEAT; else if (temp < lower_limit) ret = CM_EVENT_BATT_COLD; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee8774.36%133.33%
Chanwoo Choi1613.68%133.33%
Donggeun Kim1411.97%133.33%
Total117100.00%3100.00%

/** * _cm_monitor - Monitor the temperature and return true for exceptions. * @cm: the Charger Manager representing the battery. * * Returns true if there is an event to notify for the battery. * (True if the status of "emergency_stop" changes) */
static bool _cm_monitor(struct charger_manager *cm) { int temp_alrt; temp_alrt = cm_check_thermal_status(cm); /* It has been stopped already */ if (temp_alrt && cm->emergency_stop) return false; /* * Check temperature whether overheat or cold. * If temperature is out of range normal state, stop charging. */ if (temp_alrt) { cm->emergency_stop = temp_alrt; if (!try_charger_enable(cm, false)) uevent_notify(cm, default_event_names[temp_alrt]); /* * Check whole charging duration and discharing duration * after full-batt. */ } else if (!cm->emergency_stop && check_charging_duration(cm)) { dev_dbg(cm->dev, "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, * charger-manager have to recharge battery. */ } else if (!cm->emergency_stop && is_ext_pwr_online(cm) && !cm->charger_enabled) { fullbatt_vchk(&cm->fullbatt_vchk_work.work); /* * Check whether fully charged state to protect overcharge * if charger-manager is charging for battery. */ } else if (!cm->emergency_stop && is_full_charged(cm) && cm->charger_enabled) { 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); fullbatt_vchk(&cm->fullbatt_vchk_work.work); } else { cm->emergency_stop = 0; if (is_ext_pwr_online(cm)) { if (!try_charger_enable(cm, true)) uevent_notify(cm, "CHARGING"); } } return true; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi13361.57%444.44%
Donggeun Kim5525.46%222.22%
Jonghwa Lee2511.57%111.11%
Joe Perches20.93%111.11%
Anton Vorontsov10.46%111.11%
Total216100.00%9100.00%

/** * cm_monitor - Monitor every battery. * * Returns true if there is an event to notify from any of the batteries. * (True if the status of "emergency_stop" changes) */
static bool cm_monitor(void) { bool stop = false; struct charger_manager *cm; mutex_lock(&cm_list_mtx); list_for_each_entry(cm, &cm_list, entry) { if (_cm_monitor(cm)) stop = true; } mutex_unlock(&cm_list_mtx); return stop; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim2750.00%133.33%
Chanwoo Choi2037.04%133.33%
Axel Lin712.96%133.33%
Total54100.00%3100.00%

/** * _setup_polling - Setup the next instance of polling. * @work: work_struct of the function _setup_polling. */
static void _setup_polling(struct work_struct *work) { unsigned long min = ULONG_MAX; struct charger_manager *cm; bool keep_polling = false; unsigned long _next_polling; mutex_lock(&cm_list_mtx); list_for_each_entry(cm, &cm_list, entry) { if (is_polling_required(cm) && cm->desc->polling_interval_ms) { keep_polling = true; if (min > cm->desc->polling_interval_ms) min = cm->desc->polling_interval_ms; } } polling_jiffy = msecs_to_jiffies(min); if (polling_jiffy <= CM_JIFFIES_SMALL) polling_jiffy = CM_JIFFIES_SMALL + 1; if (!keep_polling) polling_jiffy = ULONG_MAX; if (polling_jiffy == ULONG_MAX) goto out; WARN(cm_wq == NULL, "charger-manager: workqueue not initialized" ". try it later. %s\n", __func__); /* * Use mod_delayed_work() iff the next polling interval should * occur before the currently scheduled one. If @cm_monitor_work * isn't active, the end result is the same, so no need to worry * about stale @next_polling. */ _next_polling = jiffies + polling_jiffy; if (time_before(_next_polling, next_polling)) { mod_delayed_work(cm_wq, &cm_monitor_work, polling_jiffy); next_polling = _next_polling; } else { if (queue_delayed_work(cm_wq, &cm_monitor_work, polling_jiffy)) next_polling = _next_polling; } out: mutex_unlock(&cm_list_mtx); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi16585.94%250.00%
Tejun Heo2311.98%125.00%
Donggeun Kim42.08%125.00%
Total192100.00%4100.00%

static DECLARE_WORK(setup_polling, _setup_polling); /** * cm_monitor_poller - The Monitor / Poller. * @work: work_struct of the function cm_monitor_poller * * During non-suspended state, cm_monitor_poller is used to poll and monitor * the batteries. */
static void cm_monitor_poller(struct work_struct *work) { cm_monitor(); schedule_work(&setup_polling); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi20100.00%1100.00%
Total20100.00%1100.00%

/** * fullbatt_handler - Event handler for CM_EVENT_BATT_FULL * @cm: the Charger Manager representing the battery. */
static void fullbatt_handler(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; if (!desc->fullbatt_vchkdrop_uV || !desc->fullbatt_vchkdrop_ms) goto out; if (cm_suspended) device_set_wakeup_capable(cm->dev, true); mod_delayed_work(cm_wq, &cm->fullbatt_vchk_work, msecs_to_jiffies(desc->fullbatt_vchkdrop_ms)); cm->fullbatt_vchk_jiffies_at = jiffies + msecs_to_jiffies( desc->fullbatt_vchkdrop_ms); if (cm->fullbatt_vchk_jiffies_at == 0) cm->fullbatt_vchk_jiffies_at = 1; out: dev_info(cm->dev, "EVENT_HANDLE: Battery Fully Charged\n"); uevent_notify(cm, default_event_names[CM_EVENT_BATT_FULL]); }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim6053.10%233.33%
Chanwoo Choi5044.25%116.67%
Joe Perches10.88%116.67%
Linus Torvalds10.88%116.67%
Anton Vorontsov10.88%116.67%
Total113100.00%6100.00%

/** * battout_handler - Event handler for CM_EVENT_BATT_OUT * @cm: the Charger Manager representing the battery. */
static void battout_handler(struct charger_manager *cm) { if (cm_suspended) device_set_wakeup_capable(cm->dev, true); if (!is_batt_present(cm)) { dev_emerg(cm->dev, "Battery Pulled Out!\n"); uevent_notify(cm, default_event_names[CM_EVENT_BATT_OUT]); } else { uevent_notify(cm, "Battery Reinserted?"); } }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi3860.32%150.00%
Donggeun Kim2539.68%150.00%
Total63100.00%2100.00%

/** * misc_event_handler - Handler for other evnets * @cm: the Charger Manager representing the battery. * @type: the Charger Manager representing the battery. */
static void misc_event_handler(struct charger_manager *cm, enum cm_event_types type) { if (cm_suspended) device_set_wakeup_capable(cm->dev, true); if (is_polling_required(cm) && cm->desc->polling_interval_ms) schedule_work(&setup_polling); uevent_notify(cm, default_event_names[type]); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi3459.65%150.00%
Donggeun Kim2340.35%150.00%
Total57100.00%2100.00%


static int charger_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { struct charger_manager *cm = power_supply_get_drvdata(psy); struct charger_desc *desc = cm->desc; struct power_supply *fuel_gauge = NULL; int ret = 0; int uV; switch (psp) { case POWER_SUPPLY_PROP_STATUS: if (is_charging(cm)) val->intval = POWER_SUPPLY_STATUS_CHARGING; else if (is_ext_pwr_online(cm)) val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; else val->intval = POWER_SUPPLY_STATUS_DISCHARGING; break; case POWER_SUPPLY_PROP_HEALTH: if (cm->emergency_stop > 0) val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; else if (cm->emergency_stop < 0) val->intval = POWER_SUPPLY_HEALTH_COLD; else val->intval = POWER_SUPPLY_HEALTH_GOOD; break; case POWER_SUPPLY_PROP_PRESENT: if (is_batt_present(cm)) val->intval = 1; else val->intval = 0; break; case POWER_SUPPLY_PROP_VOLTAGE_NOW: ret = get_batt_uV(cm, &val->intval); break; case POWER_SUPPLY_PROP_CURRENT_NOW: fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!fuel_gauge) { ret = -ENODEV; break; } ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CURRENT_NOW, val); break; case POWER_SUPPLY_PROP_TEMP: case POWER_SUPPLY_PROP_TEMP_AMBIENT: return cm_get_battery_temperature(cm, &val->intval); case POWER_SUPPLY_PROP_CAPACITY: if (!is_batt_present(cm)) { /* There is no battery. Assume 100% */ val->intval = 100; break; } fuel_gauge = power_supply_get_by_name(cm->desc->psy_fuel_gauge); if (!fuel_gauge) { ret = -ENODEV; break; } ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CAPACITY, val); if (ret) break; if (val->intval > 100) { val->intval = 100; break; } if (val->intval < 0) val->intval = 0; /* Do not adjust SOC when charging: voltage is overrated */ if (is_charging(cm)) break; /* * If the capacity value is inconsistent, calibrate it base on * the battery voltage values and the thresholds given as desc */ ret = get_batt_uV(cm, &uV); if (ret) { /* Voltage information not available. No calibration */ ret = 0; break; } if (desc->fullbatt_uV > 0 && uV >= desc->fullbatt_uV && !is_charging(cm)) { val->intval = 100; break; } break; case POWER_SUPPLY_PROP_ONLINE: if (is_ext_pwr_online(cm)) val->intval = 1; else val->intval = 0; break; case POWER_SUPPLY_PROP_CHARGE_FULL: if (is_full_charged(cm)) val->intval = 1; else val->intval = 0; ret = 0; break; case POWER_SUPPLY_PROP_CHARGE_NOW: if (is_charging(cm)) { fuel_gauge = power_supply_get_by_name( cm->desc->psy_fuel_gauge); if (!fuel_gauge) { ret = -ENODEV; break; } ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CHARGE_NOW, val); if (ret) { val->intval = 1; ret = 0; } else { /* If CHARGE_NOW is supplied, use it */ val->intval = (val->intval > 0) ? val->intval : 1; } } else { val->intval = 0; } break; default: return -EINVAL; } if (fuel_gauge) power_supply_put(fuel_gauge); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim30354.89%220.00%
Chanwoo Choi14225.72%330.00%
Krzysztof Kozlowski9517.21%440.00%
Jonghwa Lee122.17%110.00%
Total552100.00%10100.00%

#define NUM_CHARGER_PSY_OPTIONAL (4) static enum power_supply_property default_charger_props[] = { /* Guaranteed to provide */ POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_PRESENT, POWER_SUPPLY_PROP_VOLTAGE_NOW, POWER_SUPPLY_PROP_CAPACITY, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_CHARGE_FULL, /* * Optional properties are: * POWER_SUPPLY_PROP_CHARGE_NOW, * POWER_SUPPLY_PROP_CURRENT_NOW, * POWER_SUPPLY_PROP_TEMP, and * POWER_SUPPLY_PROP_TEMP_AMBIENT, */ }; static const struct power_supply_desc psy_default = { .name = "battery", .type = POWER_SUPPLY_TYPE_BATTERY, .properties = default_charger_props, .num_properties = ARRAY_SIZE(default_charger_props), .get_property = charger_get_property, .no_thermal = true, }; /** * cm_setup_timer - For in-suspend monitoring setup wakeup alarm * for suspend_again. * * Returns true if the alarm is set for Charger Manager to use. * Returns false if * cm_setup_timer fails to set an alarm, * cm_setup_timer does not need to set an alarm for Charger Manager, * or an alarm previously configured is to be used. */
static bool cm_setup_timer(void) { struct charger_manager *cm; unsigned int wakeup_ms = UINT_MAX; int timer_req = 0; if (time_after(next_polling, jiffies)) CM_MIN_VALID(wakeup_ms, jiffies_to_msecs(next_polling - jiffies)); mutex_lock(&cm_list_mtx); list_for_each_entry(cm, &cm_list, entry) { unsigned int fbchk_ms = 0; /* fullbatt_vchk is required. setup timer for that */ if (cm->fullbatt_vchk_jiffies_at) { fbchk_ms = jiffies_to_msecs(cm->fullbatt_vchk_jiffies_at - jiffies); if (time_is_before_eq_jiffies( cm->fullbatt_vchk_jiffies_at) || msecs_to_jiffies(fbchk_ms) < CM_JIFFIES_SMALL) { fullbatt_vchk(&cm->fullbatt_vchk_work.work); fbchk_ms = 0; } } CM_MIN_VALID(wakeup_ms, fbchk_ms); /* Skip if polling is not required for this CM */ if (!is_polling_required(cm) && !cm->emergency_stop) continue; timer_req++; if (cm->desc->polling_interval_ms == 0) continue; CM_MIN_VALID(wakeup_ms, cm->desc->polling_interval_ms); } mutex_unlock(&cm_list_mtx); if (timer_req && cm_timer) { ktime_t now, add; /* * Set alarm with the polling interval (wakeup_ms) * The alarm time should be NOW + CM_RTC_SMALL or later. */ if (wakeup_ms == UINT_MAX || wakeup_ms < CM_RTC_SMALL * MSEC_PER_SEC) wakeup_ms = 2 * CM_RTC_SMALL * MSEC_PER_SEC; pr_info("Charger Manager wakeup timer: %u ms\n", wakeup_ms); now = ktime_get_boottime(); add = ktime_set(wakeup_ms / MSEC_PER_SEC, (wakeup_ms % MSEC_PER_SEC) * NSEC_PER_MSEC); alarm_start(cm_timer, ktime_add(now, add)); cm_suspend_duration_ms = wakeup_ms; return true; } return false; }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim10741.63%250.00%
Chanwoo Choi7830.35%125.00%
Jonghwa Lee7228.02%125.00%
Total257100.00%4100.00%

/** * charger_extcon_work - enable/diable charger according to the state * of charger cable * * @work: work_struct of the function charger_extcon_work. */
static void charger_extcon_work(struct work_struct *work) { struct charger_cable *cable = container_of(work, struct charger_cable, wq); int ret; if (cable->attached && cable->min_uA != 0 && cable->max_uA != 0) { ret = regulator_set_current_limit(cable->charger->consumer, 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); return; } pr_info("Set current limit of %s : %duA ~ %duA\n", cable->charger->regulator_name, cable->min_uA, cable->max_uA); } try_charger_enable(cable->cm, cable->attached); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi7460.66%375.00%
Jonghwa Lee4839.34%125.00%
Total122100.00%4100.00%

/** * charger_extcon_notifier - receive the state of charger cable * when registered cable is attached or detached. * * @self: the notifier block of the charger_extcon_notifier. * @event: the cable state. * @ptr: the data pointer of notifier block. */
static int charger_extcon_notifier(struct notifier_block *self, unsigned long event, void *ptr) { struct charger_cable *cable = container_of(self, struct charger_cable, nb); /* * The newly state of charger cable. * If cable is attached, cable->attached is true. */ cable->attached = event; /* * Setup monitoring to check battery state * when charger cable is attached. */ if (cable->attached && is_polling_required(cable->cm)) { cancel_work_sync(&setup_polling); schedule_work(&setup_polling); } /* * Setup work for controlling charger(regulator) * according to charger cable. */ schedule_work(&cable->wq); return NOTIFY_DONE; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi81100.00%2100.00%
Total81100.00%2100.00%

/** * charger_extcon_init - register external connector to use it * as the charger cable * * @cm: the Charger Manager representing the battery. * @cable: the Charger cable representing the external connector. */
static int charger_extcon_init(struct charger_manager *cm, struct charger_cable *cable) { int ret = 0; /* * Charger manager use Extcon framework to identify * the charger cable among various external connector * cable (e.g., TA, USB, MHL, Dock). */ INIT_WORK(&cable->wq, charger_extcon_work); cable->nb.notifier_call = charger_extcon_notifier; 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); ret = -EINVAL; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi9198.91%150.00%
Joe Perches11.09%150.00%
Total92100.00%2100.00%

/** * charger_manager_register_extcon - Register extcon device to recevie state * of charger cable. * @cm: the Charger Manager representing the battery. * * This function support EXTCON(External Connector) subsystem to detect the * state of charger cables for enabling or disabling charger(regulator) and * select the charger cable for charging among a number of external cable * according to policy of H/W board. */
static int charger_manager_register_extcon(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; struct charger_regulator *charger; int ret = 0; int i; int j; for (i = 0; i < desc->num_charger_regulators; i++) { charger = &desc->charger_regulators[i]; charger->consumer = regulator_get(cm->dev, charger->regulator_name); 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; for (j = 0; j < charger->num_cables; j++) { struct charger_cable *cable = &charger->cables[j]; ret = charger_extcon_init(cm, cable); if (ret < 0) { dev_err(cm->dev, "Cannot initialize charger(%s)\n", charger->regulator_name); goto err; } cable->charger = charger; cable->cm = cm; } } err: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi18393.37%133.33%
Jonghwa Lee115.61%133.33%
Joe Perches21.02%133.33%
Total196100.00%3100.00%

/* help function of sysfs node to control charger(regulator) */
static ssize_t charger_name_show(struct device *dev, struct device_attribute *attr, char *buf) { struct charger_regulator *charger = container_of(attr, struct charger_regulator, attr_name); return sprintf(buf, "%s\n", charger->regulator_name); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi3574.47%266.67%
Donggeun Kim1225.53%133.33%
Total47100.00%3100.00%


static ssize_t charger_state_show(struct device *dev, struct device_attribute *attr, char *buf) { struct charger_regulator *charger = container_of(attr, struct charger_regulator, attr_state); int state = 0; if (!charger->externally_control) state = regulator_is_enabled(charger->consumer); return sprintf(buf, "%s\n", state ? "enabled" : "disabled"); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi6085.71%375.00%
Donggeun Kim1014.29%125.00%
Total70100.00%4100.00%


static ssize_t charger_externally_control_show(struct device *dev, struct device_attribute *attr, char *buf) { struct charger_regulator *charger = container_of(attr, struct charger_regulator, attr_externally_control); return sprintf(buf, "%d\n", charger->externally_control); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi4391.49%266.67%
Donggeun Kim48.51%133.33%
Total47100.00%3100.00%


static ssize_t charger_externally_control_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct charger_regulator *charger = container_of(attr, struct charger_regulator, attr_externally_control); struct charger_manager *cm = charger->cm; struct charger_desc *desc = cm->desc; int i; int ret; int externally_control; int chargers_externally_control = 1; ret = sscanf(buf, "%d", &externally_control); if (ret == 0) { ret = -EINVAL; return ret; } if (!externally_control) { charger->externally_control = 0; return count; } for (i = 0; i < desc->num_charger_regulators; i++) { if (&desc->charger_regulators[i] != charger && !desc->charger_regulators[i].externally_control) { /* * At least, one charger is controlled by * charger-manager */ chargers_externally_control = 0; break; } } if (!chargers_externally_control) { if (cm->charger_enabled) { try_charger_enable(charger->cm, false); charger->externally_control = externally_control; try_charger_enable(charger->cm, true); } else { charger->externally_control = externally_control; } } 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); } return count; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi16672.49%240.00%
Donggeun Kim6026.20%120.00%
Axel Lin20.87%120.00%
Joe Perches10.44%120.00%
Total229100.00%5100.00%

/** * charger_manager_register_sysfs - Register sysfs entry for each charger * @cm: the Charger Manager representing the battery. * * This function add sysfs entry for charger(regulator) to control charger from * user-space. If some development board use one more chargers for charging * but only need one charger on specific case which is dependent on user * scenario or hardware restrictions, the user enter 1 or 0(zero) to '/sys/ * class/power_supply/battery/charger.[index]/externally_control'. For example, * if user enter 1 to 'sys/class/power_supply/battery/charger.[index]/ * externally_control, this charger isn't controlled from charger-manager and * always stay off state of regulator. */
static int charger_manager_register_sysfs(struct charger_manager *cm) { struct charger_desc *desc = cm->desc; struct charger_regulator *charger; int chargers_externally_control = 1; char buf[11]; char *str; int ret = 0; int i; /* Create sysfs entry to control charger(regulator) */ for (i = 0; i < desc->num_charger_regulators; i++) { charger = &desc->charger_regulators[i]; snprintf(buf, 10, "charger.%d", i); str = devm_kzalloc(cm->dev, sizeof(char) * (strlen(buf) + 1), GFP_KERNEL); if (!str) { ret = -ENOMEM; goto err; } strcpy(str, buf); charger->attrs[0] = &charger->attr_name.attr; charger->attrs[1] = &charger->attr_state.attr; charger->attrs[2] = &charger->attr_externally_control.attr; charger->attrs[3] = NULL; charger->attr_g.name = str; charger->attr_g.attrs = charger->attrs; sysfs_attr_init(&charger->attr_name.attr); charger->attr_name.attr.name = "name"; charger->attr_name.attr.mode = 0444; charger->attr_name.show = charger_name_show; sysfs_attr_init(&charger->attr_state.attr); charger->attr_state.attr.name = "state"; charger->attr_state.attr.mode = 0444; charger->attr_state.show = charger_state_show; sysfs_attr_init(&charger->attr_externally_control.attr); charger->attr_externally_control.attr.name = "externally_control"; charger->attr_externally_control.attr.mode = 0644; charger->attr_externally_control.show = charger_externally_control_show; charger->attr_externally_control.store = charger_externally_control_store; if (!desc->charger_regulators[i].externally_control || !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); 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); 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"); ret = -EINVAL; goto err; } err: return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi35681.46%660.00%
Donggeun Kim7116.25%110.00%
Jonghwa Lee51.14%110.00%
Joe Perches30.69%110.00%
Krzysztof Kozlowski20.46%110.00%
Total437100.00%10100.00%


static int cm_init_thermal_data(struct charger_manager *cm, struct power_supply *fuel_gauge) { struct charger_desc *desc = cm->desc; union power_supply_propval val; int ret; /* Verify whether fuel gauge provides battery temperature */ ret = power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_TEMP, &val); if (!ret) { cm->charger_psy_desc.properties[cm->charger_psy_desc.num_properties] = POWER_SUPPLY_PROP_TEMP; cm->charger_psy_desc.num_properties++; cm->desc->measure_battery_temp = true; } #ifdef CONFIG_THERMAL if (ret && desc->thermal_zone) { cm->tzd_batt = thermal_zone_get_zone_by_name(desc->thermal_zone); if (IS_ERR(cm->tzd_batt)) return PTR_ERR(cm->tzd_batt); /* Use external thermometer */ cm->charger_psy_desc.properties[cm->charger_psy_desc.num_properties] = POWER_SUPPLY_PROP_TEMP_AMBIENT; cm->charger_psy_desc.num_properties++; cm->desc->measure_battery_temp = true; ret = 0; } #endif if (cm->desc->measure_battery_temp) { /* NOTICE : Default allowable minimum charge temperature is 0 */ if (!desc->temp_max) desc->temp_max = CM_DEFAULT_CHARGE_TEMP_MAX; if (!desc->temp_diff) desc->temp_diff = CM_DEFAULT_RECHARGE_TEMP_DIFF; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee18894.00%125.00%
Krzysztof Kozlowski126.00%375.00%
Total200100.00%4100.00%

static const struct of_device_id charger_manager_match[] = { { .compatible = "charger-manager", }, {}, };
static struct charger_desc *of_cm_parse_desc(struct device *dev) { struct charger_desc *desc; struct device_node *np = dev->of_node; u32 poll_mode = CM_POLL_DISABLE; u32 battery_stat = CM_NO_BATTERY; int num_chgs = 0; desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL); if (!desc) return ERR_PTR(-ENOMEM); of_property_read_string(np, "cm-name", &desc->psy_name); of_property_read_u32(np, "cm-poll-mode", &poll_mode); desc->polling_mode = poll_mode; of_property_read_u32(np, "cm-poll-interval", &desc->polling_interval_ms); of_property_read_u32(np, "cm-fullbatt-vchkdrop-ms", &desc->fullbatt_vchkdrop_ms); of_property_read_u32(np, "cm-fullbatt-vchkdrop-volt", &desc->fullbatt_vchkdrop_uV); of_property_read_u32(np, "cm-fullbatt-voltage", &desc->fullbatt_uV); of_property_read_u32(np, "cm-fullbatt-soc", &desc->fullbatt_soc); of_property_read_u32(np, "cm-fullbatt-capacity", &desc->fullbatt_full_capacity); of_property_read_u32(np, "cm-battery-stat", &battery_stat); desc->battery_present = battery_stat; /* chargers */ of_property_read_u32(np, "cm-num-chargers", &num_chgs); if (num_chgs) { /* Allocate empty bin at the tail of array */ desc->psy_charger_stat = devm_kzalloc(dev, sizeof(char *) * (num_chgs + 1), GFP_KERNEL); if (desc->psy_charger_stat) { int i; for (i = 0; i < num_chgs; i++) of_property_read_string_index(np, "cm-chargers", i, &desc->psy_charger_stat[i]); } else { return ERR_PTR(-ENOMEM); } } of_property_read_string(np, "cm-fuel-gauge", &desc->psy_fuel_gauge); of_property_read_string(np, "cm-thermal-zone", &desc->thermal_zone); of_property_read_u32(np, "cm-battery-cold", &desc->temp_min); if (of_get_property(np, "cm-battery-cold-in-minus", NULL)) desc->temp_min *= -1; of_property_read_u32(np, "cm-battery-hot", &desc->temp_max); of_property_read_u32(np, "cm-battery-temp-diff", &desc->temp_diff); of_property_read_u32(np, "cm-charging-max", &desc->charging_max_duration_ms); of_property_read_u32(np, "cm-discharging-max", &desc->discharging_max_duration_ms); /* battery charger regualtors */ desc->num_charger_regulators = of_get_child_count(np); if (desc->num_charger_regulators) { struct charger_regulator *chg_regs; struct device_node *child; chg_regs = devm_kzalloc(dev, sizeof(*chg_regs) * desc->num_charger_regulators, GFP_KERNEL); if (!chg_regs) return ERR_PTR(-ENOMEM); desc->charger_regulators = chg_regs; for_each_child_of_node(np, child) { struct charger_cable *cables; struct device_node *_child; of_property_read_string(child, "cm-regulator-name", &chg_regs->regulator_name); /* charger cables */ chg_regs->num_cables = of_get_child_count(child); if (chg_regs->num_cables) { cables = devm_kzalloc(dev, sizeof(*cables) * chg_regs->num_cables, GFP_KERNEL); if (!cables) { of_node_put(child); return ERR_PTR(-ENOMEM); } chg_regs->cables = cables; for_each_child_of_node(child, _child) { of_property_read_string(_child, "cm-cable-name", &cables->name); of_property_read_string(_child, "cm-cable-extcon", &cables->extcon_name); of_property_read_u32(_child, "cm-cable-min", &cables->min_uA); of_property_read_u32(_child, "cm-cable-max", &cables->max_uA); cables++; } } chg_regs++; } } return desc; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee52387.02%228.57%
Chanwoo Choi6410.65%228.57%
Julia Lawall71.16%114.29%
Donggeun Kim61.00%114.29%
Anton Vorontsov10.17%114.29%
Total601100.00%7100.00%


static inline struct charger_desc *cm_get_drv_data(struct platform_device *pdev) { if (pdev->dev.of_node) return of_cm_parse_desc(&pdev->dev); return dev_get_platdata(&pdev->dev); }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee40100.00%1100.00%
Total40100.00%1100.00%


static enum alarmtimer_restart cm_timer_func(struct alarm *alarm, ktime_t now) { cm_timer_set = false; return ALARMTIMER_NORESTART; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee22100.00%1100.00%
Total22100.00%1100.00%


static int charger_manager_probe(struct platform_device *pdev) { struct charger_desc *desc = cm_get_drv_data(pdev); struct charger_manager *cm; int ret = 0, i = 0; int j = 0; union power_supply_propval val; struct power_supply *fuel_gauge; struct power_supply_config psy_cfg = {}; if (IS_ERR(desc)) { dev_err(&pdev->dev, "No platform data (desc) found\n"); return -ENODEV; } cm = devm_kzalloc(&pdev->dev, sizeof(struct charger_manager), GFP_KERNEL); if (!cm) return -ENOMEM; /* Basic Values. Unspecified are Null or 0 */ cm->dev = &pdev->dev; cm->desc = desc; psy_cfg.drv_data = cm; /* Initialize alarm timer */ if (alarmtimer_get_rtcdev()) { cm_timer = devm_kzalloc(cm->dev, sizeof(*cm_timer), GFP_KERNEL); alarm_init(cm_timer, ALARM_BOOTTIME, cm_timer_func); } /* * The following two do not need to be errors. * 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\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\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\n"); } if (desc->fullbatt_full_capacity == 0) { 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) { dev_err(&pdev->dev, "charger_regulators undefined\n"); return -EINVAL; } if (!desc->psy_charger_stat || !desc->psy_charger_stat[0]) { dev_err(&pdev->dev, "No power supply defined\n"); return -EINVAL; } if (!desc->psy_fuel_gauge) { dev_err(&pdev->dev, "No fuel gauge power supply defined\n"); return -EINVAL; } /* Counting index only */ while (desc->psy_charger_stat[i]) i++; /* Check if charger's supplies are present at probe */ for (i = 0; desc->psy_charger_stat[i]; i++) { struct power_supply *psy; psy = power_supply_get_by_name(desc->psy_charger_stat[i]); if (!psy) { dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n", desc->psy_charger_stat[i]); return -ENODEV; } power_supply_put(psy); } if (desc->polling_interval_ms == 0 || msecs_to_jiffies(desc->polling_interval_ms) <= CM_JIFFIES_SMALL) { dev_err(&pdev->dev, "polling_interval_ms is too small\n"); return -EINVAL; } 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\n"); desc->charging_max_duration_ms = 0; desc->discharging_max_duration_ms = 0; } platform_set_drvdata(pdev, cm); memcpy(&cm->charger_psy_desc, &psy_default, sizeof(psy_default)); if (!desc->psy_name) strncpy(cm->psy_name_buf, psy_default.name, PSY_NAME_MAX); else strncpy(cm->psy_name_buf, desc->psy_name, PSY_NAME_MAX); cm->charger_psy_desc.name = cm->psy_name_buf; /* Allocate for psy properties because they may vary */ cm->charger_psy_desc.properties = devm_kzalloc(&pdev->dev, sizeof(enum power_supply_property) * (ARRAY_SIZE(default_charger_props) + NUM_CHARGER_PSY_OPTIONAL), GFP_KERNEL); if (!cm->charger_psy_desc.properties) return -ENOMEM; memcpy(cm->charger_psy_desc.properties, default_charger_props, sizeof(enum power_supply_property) * ARRAY_SIZE(default_charger_props)); cm->charger_psy_desc.num_properties = psy_default.num_properties; /* Find which optional psy-properties are available */ fuel_gauge = power_supply_get_by_name(desc->psy_fuel_gauge); if (!fuel_gauge) { dev_err(&pdev->dev, "Cannot find power supply \"%s\"\n", desc->psy_fuel_gauge); return -ENODEV; } if (!power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CHARGE_NOW, &val)) { cm->charger_psy_desc.properties[cm->charger_psy_desc.num_properties] = POWER_SUPPLY_PROP_CHARGE_NOW; cm->charger_psy_desc.num_properties++; } if (!power_supply_get_property(fuel_gauge, POWER_SUPPLY_PROP_CURRENT_NOW, &val)) { cm->charger_psy_desc.properties[cm->charger_psy_desc.num_properties] = POWER_SUPPLY_PROP_CURRENT_NOW; cm->charger_psy_desc.num_properties++; } ret = cm_init_thermal_data(cm, fuel_gauge); if (ret) { dev_err(&pdev->dev, "Failed to initialize thermal data\n"); cm->desc->measure_battery_temp = false; } power_supply_put(fuel_gauge); INIT_DELAYED_WORK(&cm->fullbatt_vchk_work, fullbatt_vchk); cm->charger_psy = power_supply_register(&pdev->dev, &cm->charger_psy_desc, &psy_cfg); if (IS_ERR(cm->charger_psy)) { dev_err(&pdev->dev, "Cannot register charger-manager with name \"%s\"\n", cm->charger_psy_desc.name); return PTR_ERR(cm->charger_psy); } /* Register extcon device for charger cable */ ret = charger_manager_register_extcon(cm); if (ret < 0) { dev_err(&pdev->dev, "Cannot initialize extcon device\n"); goto err_reg_extcon; } /* Register sysfs entry for charger(regulator) */ ret = charger_manager_register_sysfs(cm); if (ret < 0) { dev_err(&pdev->dev, "Cannot initialize sysfs entry of regulator\n"); goto err_reg_sysfs; } /* Add to the list */ mutex_lock(&cm_list_mtx); list_add(&cm->entry, &cm_list); mutex_unlock(&cm_list_mtx); /* * Charger-manager is capable of waking up the systme from sleep * when event is happend through cm_notify_event() */ device_init_wakeup(&pdev->dev, true); device_set_wakeup_capable(&pdev->dev, false); /* * Charger-manager have to check the charging state right after * tialization of charger-manager and then update current charging * state. */ cm_monitor(); schedule_work(&setup_polling); return 0; err_reg_sysfs: for (i = 0; i < desc->num_charger_regulators; i++) { struct charger_regulator *charger; charger = &desc->charger_regulators[i]; sysfs_remove_group(&cm->charger_psy->dev.kobj, &charger->attr_g); } err_reg_extcon: for (i = 0; i < desc->num_charger_regulators; i++) { struct charger_regulator *charger; charger = &desc->charger_regulators[i]; for (j = 0; j < charger->num_cables; j++) { struct charger_cable *cable = &charger->cables[j]; /* 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); } power_supply_unregister(cm->charger_psy); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi50645.26%729.17%
Jonghwa Lee26323.52%520.83%
Donggeun Kim21519.23%28.33%
Krzysztof Kozlowski12711.36%937.50%
Joe Perches70.63%14.17%
Total1118100.00%24100.00%


static int charger_manager_remove(struct platform_device *pdev) { struct charger_manager *cm = platform_get_drvdata(pdev); struct charger_desc *desc = cm->desc; int i = 0; int j = 0; /* Remove from the list */ mutex_lock(&cm_list_mtx); list_del(&cm->entry); mutex_unlock(&cm_list_mtx); cancel_work_sync(&setup_polling); cancel_delayed_work_sync(&cm_monitor_work); for (i = 0 ; i < desc->num_charger_regulators ; i++) { struct charger_regulator *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); } } for (i = 0 ; i < desc->num_charger_regulators ; i++) regulator_put(desc->charger_regulators[i].consumer); power_supply_unregister(cm->charger_psy); try_charger_enable(cm, false); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi11562.16%250.00%
Donggeun Kim7037.84%250.00%
Total185100.00%4100.00%

static const struct platform_device_id charger_manager_id[] = { { "charger-manager", 0 }, { }, }; MODULE_DEVICE_TABLE(platform, charger_manager_id);
static int cm_suspend_noirq(struct device *dev) { int ret = 0; if (device_may_wakeup(dev)) { device_set_wakeup_capable(dev, false); ret = -EAGAIN; } return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi40100.00%1100.00%
Total40100.00%1100.00%


static bool cm_need_to_awake(void) { struct charger_manager *cm; if (cm_timer) return false; mutex_lock(&cm_list_mtx); list_for_each_entry(cm, &cm_list, entry) { if (is_charging(cm)) { mutex_unlock(&cm_list_mtx); return true; } } mutex_unlock(&cm_list_mtx); return false; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee3250.79%150.00%
Donggeun Kim3149.21%150.00%
Total63100.00%2100.00%


static int cm_suspend_prepare(struct device *dev) { struct charger_manager *cm = dev_get_drvdata(dev); if (cm_need_to_awake()) return -EBUSY; if (!cm_suspended) cm_suspended = true; cm_timer_set = cm_setup_timer(); if (cm_timer_set) { cancel_work_sync(&setup_polling); cancel_delayed_work_sync(&cm_monitor_work); cancel_delayed_work(&cm->fullbatt_vchk_work); } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Jonghwa Lee5068.49%133.33%
Donggeun Kim1926.03%133.33%
Chanwoo Choi45.48%133.33%
Total73100.00%3100.00%


static void cm_suspend_complete(struct device *dev) { struct charger_manager *cm = dev_get_drvdata(dev); if (cm_suspended) cm_suspended = false; if (cm_timer_set) { ktime_t remain; alarm_cancel(cm_timer); cm_timer_set = false; remain = alarm_expires_remaining(cm_timer); cm_suspend_duration_ms -= ktime_to_ms(remain); schedule_work(&setup_polling); } _cm_monitor(cm); /* Re-enqueue delayed work (fullbatt_vchk_work) */ if (cm->fullbatt_vchk_jiffies_at) { unsigned long delay = 0; unsigned long now = jiffies + CM_JIFFIES_SMALL; if (time_after_eq(now, cm->fullbatt_vchk_jiffies_at)) { delay = (unsigned long)((long)now - (long)(cm->fullbatt_vchk_jiffies_at)); delay = jiffies_to_msecs(delay); } else { delay = 0; } /* * Account for cm_suspend_duration_ms with assuming that * timer stops in suspend. */ if (delay > cm_suspend_duration_ms) delay -= cm_suspend_duration_ms; else delay = 0; queue_delayed_work(cm_wq, &cm->fullbatt_vchk_work, msecs_to_jiffies(delay)); } device_set_wakeup_capable(cm->dev, false); }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi11160.33%240.00%
Donggeun Kim3921.20%120.00%
Jonghwa Lee3217.39%120.00%
Axel Lin21.09%120.00%
Total184100.00%5100.00%

static const struct dev_pm_ops charger_manager_pm = { .prepare = cm_suspend_prepare, .suspend_noirq = cm_suspend_noirq, .complete = cm_suspend_complete, }; static struct platform_driver charger_manager_driver = { .driver = { .name = "charger-manager", .pm = &charger_manager_pm, .of_match_table = charger_manager_match, }, .probe = charger_manager_probe, .remove = charger_manager_remove, .id_table = charger_manager_id, };
static int __init charger_manager_init(void) { cm_wq = create_freezable_workqueue("charger_manager"); INIT_DELAYED_WORK(&cm_monitor_work, cm_monitor_poller); return platform_driver_register(&charger_manager_driver); }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim1651.61%150.00%
Chanwoo Choi1548.39%150.00%
Total31100.00%2100.00%

late_initcall(charger_manager_init);
static void __exit charger_manager_cleanup(void) { destroy_workqueue(cm_wq); cm_wq = NULL; platform_driver_unregister(&charger_manager_driver); }

Contributors

PersonTokensPropCommitsCommitProp
Donggeun Kim1562.50%150.00%
Chanwoo Choi937.50%150.00%
Total24100.00%2100.00%

module_exit(charger_manager_cleanup); /** * cm_notify_event - charger driver notify Charger Manager of charger event * @psy: pointer to instance of charger's power_supply * @type: type of charger event * @msg: optional message passed to uevent_notify fuction */
void cm_notify_event(struct power_supply *psy, enum cm_event_types type, char *msg) { struct charger_manager *cm; bool found_power_supply = false; if (psy == NULL) return; mutex_lock(&cm_list_mtx); list_for_each_entry(cm, &cm_list, entry) { if (match_string(cm->desc->psy_charger_stat, -1, psy->desc->name) >= 0) { found_power_supply = true; break; } } mutex_unlock(&cm_list_mtx); if (!found_power_supply) return; switch (type) { case CM_EVENT_BATT_FULL: fullbatt_handler(cm); break; case CM_EVENT_BATT_OUT: battout_handler(cm); break; case CM_EVENT_BATT_IN: case CM_EVENT_EXT_PWR_IN_OUT ... CM_EVENT_CHG_START_STOP: misc_event_handler(cm, type); break; case CM_EVENT_UNKNOWN: case CM_EVENT_OTHERS: uevent_notify(cm, msg ? msg : default_event_names[type]); break; default: dev_err(cm->dev, "%s: type not specified\n", __func__); break; } }

Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi14386.14%133.33%
Andy Shevchenko2213.25%133.33%
Joe Perches10.60%133.33%
Total166100.00%3100.00%

EXPORT_SYMBOL_GPL(cm_notify_event); MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>"); MODULE_DESCRIPTION("Charger Manager"); MODULE_LICENSE("GPL");

Overall Contributors

PersonTokensPropCommitsCommitProp
Chanwoo Choi354343.46%1432.56%
Donggeun Kim237629.14%24.65%
Jonghwa Lee153118.78%613.95%
Krzysztof Kozlowski5857.18%1023.26%
Joe Perches320.39%12.33%
Axel Lin280.34%24.65%
Tejun Heo230.28%12.33%
Andy Shevchenko220.27%12.33%
Julia Lawall70.09%12.33%
Anton Vorontsov30.04%24.65%
Linus Torvalds10.01%12.33%
Kees Cook10.01%12.33%
Fabian Frederick10.01%12.33%
Total8153100.00%43100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.