Merge "power: fg-alg: Add support for TTF and TTE calculation" (5faec11e) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/power/supply/qcom/fg-alg.c

+531 −0

Original line number	Diff line number	Diff line
		@@ -16,11 +16,37 @@
		#include <linux/kernel.h>
		#include <linux/mutex.h>
		#include <linux/power_supply.h>
		#include <linux/slab.h>
		#include <linux/sort.h>
		#include "fg-alg.h"

		#define FULL_SOC_RAW 255
		#define CAPACITY_DELTA_DECIPCT 500

		#define CENTI_ICORRECT_C0 105
		#define CENTI_ICORRECT_C1 20

		#define HOURS_TO_SECONDS 3600
		#define OCV_SLOPE_UV 10869
		#define MILLI_UNIT 1000
		#define MICRO_UNIT 1000000
		#define NANO_UNIT 1000000000

		#define DEFAULT_TTF_RUN_PERIOD_MS 10000
		#define DEFAULT_TTF_ITERM_DELTA_MA 200

		static const struct ttf_pt ttf_ln_table[] = {
		{ 1000, 0 },
		{ 2000, 693 },
		{ 4000, 1386 },
		{ 6000, 1792 },
		{ 8000, 2079 },
		{ 16000, 2773 },
		{ 32000, 3466 },
		{ 64000, 4159 },
		{ 128000, 4852 },
		};

		/* Cycle counter APIs */

		/**
		@@ -670,3 +696,508 @@ int cap_learning_init(struct cap_learning *cl)
		mutex_init(&cl->lock);
		return 0;
		}

		/* Time to full/empty algorithm helper functions */

		static void ttf_circ_buf_add(struct ttf_circ_buf *buf, int val)
		{
		buf->arr[buf->head] = val;
		buf->head = (buf->head + 1) % ARRAY_SIZE(buf->arr);
		buf->size = min(++buf->size, (int)ARRAY_SIZE(buf->arr));
		}

		static void ttf_circ_buf_clr(struct ttf_circ_buf *buf)
		{
		buf->size = 0;
		buf->head = 0;
		memset(buf->arr, 0, sizeof(buf->arr));
		}

		static int cmp_int(const void a, const void b)
		{
		return (int )a - (int )b;
		}

		static int ttf_circ_buf_median(struct ttf_circ_buf buf, int median)
		{
		int *temp;

		if (buf->size == 0)
		return -ENODATA;

		if (buf->size == 1) {
		*median = buf->arr[0];
		return 0;
		}

		temp = kmalloc_array(buf->size, sizeof(*temp), GFP_KERNEL);
		if (!temp)
		return -ENOMEM;

		memcpy(temp, buf->arr, buf->size * sizeof(*temp));
		sort(temp, buf->size, sizeof(*temp), cmp_int, NULL);

		if (buf->size % 2)
		*median = temp[buf->size / 2];
		else
		*median = (temp[buf->size / 2 - 1] + temp[buf->size / 2]) / 2;

		kfree(temp);
		return 0;
		}

		static int ttf_lerp(const struct ttf_pt *pts, size_t tablesize,
		s32 input, s32 *output)
		{
		int i;
		s64 temp;

		if (pts == NULL) {
		pr_err("Table is NULL\n");
		return -EINVAL;
		}

		if (tablesize < 1) {
		pr_err("Table has no entries\n");
		return -ENOENT;
		}

		if (tablesize == 1) {
		*output = pts[0].y;
		return 0;
		}

		if (pts[0].x > pts[1].x) {
		pr_err("Table is not in acending order\n");
		return -EINVAL;
		}

		if (input <= pts[0].x) {
		*output = pts[0].y;
		return 0;
		}

		if (input >= pts[tablesize - 1].x) {
		*output = pts[tablesize - 1].y;
		return 0;
		}

		for (i = 1; i < tablesize; i++) {
		if (input >= pts[i].x)
		continue;

		temp = ((s64)pts[i].y - pts[i - 1].y) *
		((s64)input - pts[i - 1].x);
		temp = div_s64(temp, pts[i].x - pts[i - 1].x);
		*output = temp + pts[i - 1].y;
		return 0;
		}

		return -EINVAL;
		}

		static int get_time_to_full_locked(struct ttf ttf, int val)
		{
		int rc, ibatt_avg, vbatt_avg, rbatt = 0, msoc = 0, act_cap_mah = 0,
		i_cc2cv = 0, soc_cc2cv, tau, divisor, iterm = 0, ttf_mode = 0,
		i, soc_per_step, msoc_this_step, msoc_next_step,
		ibatt_this_step, t_predicted_this_step, ttf_slope,
		t_predicted_cv, t_predicted = 0, charge_type = 0,
		float_volt_uv = 0;
		s64 delta_ms;

		rc = ttf->get_ttf_param(ttf->data, TTF_MSOC, &msoc);
		if (rc < 0) {
		pr_err("failed to get msoc rc=%d\n", rc);
		return rc;
		}
		pr_debug("TTF: msoc=%d\n", msoc);

		/* the battery is considered full if the SOC is 100% */
		if (msoc >= 100) {
		*val = 0;
		return 0;
		}

		rc = ttf->get_ttf_param(ttf->data, TTF_MODE, &ttf_mode);

		/* when switching TTF algorithms the TTF needs to be reset */
		if (ttf->mode != ttf_mode) {
		ttf_circ_buf_clr(&ttf->ibatt);
		ttf_circ_buf_clr(&ttf->vbatt);
		ttf->last_ttf = 0;
		ttf->last_ms = 0;
		ttf->mode = ttf_mode;
		}

		/* at least 10 samples are required to produce a stable IBATT */
		if (ttf->ibatt.size < MAX_TTF_SAMPLES) {
		*val = -1;
		return 0;
		}

		rc = ttf_circ_buf_median(&ttf->ibatt, &ibatt_avg);
		if (rc < 0) {
		pr_err("failed to get IBATT AVG rc=%d\n", rc);
		return rc;
		}

		rc = ttf_circ_buf_median(&ttf->vbatt, &vbatt_avg);
		if (rc < 0) {
		pr_err("failed to get VBATT AVG rc=%d\n", rc);
		return rc;
		}

		ibatt_avg = -ibatt_avg / MILLI_UNIT;
		vbatt_avg /= MILLI_UNIT;

		rc = ttf->get_ttf_param(ttf->data, TTF_ITERM, &iterm);
		if (rc < 0) {
		pr_err("failed to get iterm rc=%d\n", rc);
		return rc;
		}
		/* clamp ibatt_avg to iterm */
		if (ibatt_avg < abs(iterm))
		ibatt_avg = abs(iterm);

		rc = ttf->get_ttf_param(ttf->data, TTF_RBATT, &rbatt);
		if (rc < 0) {
		pr_err("failed to get battery resistance rc=%d\n", rc);
		return rc;
		}
		rbatt /= MILLI_UNIT;

		rc = ttf->get_ttf_param(ttf->data, TTF_FCC, &act_cap_mah);
		if (rc < 0) {
		pr_err("failed to get ACT_BATT_CAP rc=%d\n", rc);
		return rc;
		}

		pr_debug(" TTF: ibatt_avg=%d vbatt_avg=%d rbatt=%d act_cap_mah=%d\n",
		ibatt_avg, vbatt_avg, rbatt, act_cap_mah);

		rc = ttf->get_ttf_param(ttf->data, TTF_VFLOAT, &float_volt_uv);
		if (rc < 0) {
		pr_err("failed to get float_volt_uv rc=%d\n", rc);
		return rc;
		}

		rc = ttf->get_ttf_param(ttf->data, TTF_CHG_TYPE, &charge_type);
		if (rc < 0) {
		pr_err("failed to get charge_type rc=%d\n", rc);
		return rc;
		}
		/* estimated battery current at the CC to CV transition */
		switch (ttf->mode) {
		case TTF_MODE_NORMAL:
		i_cc2cv = ibatt_avg * vbatt_avg /
		max(MILLI_UNIT, float_volt_uv / MILLI_UNIT);
		break;
		case TTF_MODE_QNOVO:
		i_cc2cv = min(
		ttf->cc_step.arr[MAX_CC_STEPS - 1] / MILLI_UNIT,
		ibatt_avg * vbatt_avg /
		max(MILLI_UNIT, float_volt_uv / MILLI_UNIT));
		break;
		default:
		pr_err("TTF mode %d is not supported\n", ttf->mode);
		break;
		}
		pr_debug("TTF: i_cc2cv=%d\n", i_cc2cv);

		/* if we are already in CV state then we can skip estimating CC */
		if (charge_type == POWER_SUPPLY_CHARGE_TYPE_TAPER)
		goto cv_estimate;

		/* estimated SOC at the CC to CV transition */
		soc_cc2cv = DIV_ROUND_CLOSEST(rbatt * i_cc2cv, OCV_SLOPE_UV);
		soc_cc2cv = 100 - soc_cc2cv;
		pr_debug("TTF: soc_cc2cv=%d\n", soc_cc2cv);

		switch (ttf->mode) {
		case TTF_MODE_NORMAL:
		if (soc_cc2cv - msoc <= 0)
		goto cv_estimate;

		divisor = max(100, (ibatt_avg + i_cc2cv) / 2 * 100);
		t_predicted = div_s64((s64)act_cap_mah * (soc_cc2cv - msoc) *
		HOURS_TO_SECONDS, divisor);
		break;
		case TTF_MODE_QNOVO:
		soc_per_step = 100 / MAX_CC_STEPS;
		for (i = msoc / soc_per_step; i < MAX_CC_STEPS - 1; ++i) {
		msoc_next_step = (i + 1) * soc_per_step;
		if (i == msoc / soc_per_step)
		msoc_this_step = msoc;
		else
		msoc_this_step = i * soc_per_step;

		/* scale ibatt by 85% to account for discharge pulses */
		ibatt_this_step = min(
		ttf->cc_step.arr[i] / MILLI_UNIT,
		ibatt_avg) * 85 / 100;
		divisor = max(100, ibatt_this_step * 100);
		t_predicted_this_step = div_s64((s64)act_cap_mah *
		(msoc_next_step - msoc_this_step) *
		HOURS_TO_SECONDS, divisor);
		t_predicted += t_predicted_this_step;
		pr_debug("TTF: [%d, %d] ma=%d t=%d\n",
		msoc_this_step, msoc_next_step,
		ibatt_this_step, t_predicted_this_step);
		}
		break;
		default:
		pr_err("TTF mode %d is not supported\n", ttf->mode);
		break;
		}

		cv_estimate:
		pr_debug("TTF: t_predicted_cc=%d\n", t_predicted);

		iterm = max(100, abs(iterm) + ttf->iterm_delta);
		pr_debug("TTF: iterm=%d\n", iterm);

		if (charge_type == POWER_SUPPLY_CHARGE_TYPE_TAPER)
		tau = max(MILLI_UNIT, ibatt_avg * MILLI_UNIT / iterm);
		else
		tau = max(MILLI_UNIT, i_cc2cv * MILLI_UNIT / iterm);

		rc = ttf_lerp(ttf_ln_table, ARRAY_SIZE(ttf_ln_table), tau, &tau);
		if (rc < 0) {
		pr_err("failed to interpolate tau rc=%d\n", rc);
		return rc;
		}

		/* tau is scaled linearly from 95% to 100% SOC */
		if (msoc >= 95)
		tau = tau * 2 * (100 - msoc) / 10;

		pr_debug("TTF: tau=%d\n", tau);
		t_predicted_cv = div_s64((s64)act_cap_mah * rbatt * tau *
		HOURS_TO_SECONDS, NANO_UNIT);
		pr_debug("TTF: t_predicted_cv=%d\n", t_predicted_cv);
		t_predicted += t_predicted_cv;

		pr_debug("TTF: t_predicted_prefilter=%d\n", t_predicted);
		if (ttf->last_ms != 0) {
		delta_ms = ktime_ms_delta(ktime_get_boottime(),
		ms_to_ktime(ttf->last_ms));
		if (delta_ms > 10000) {
		ttf_slope = div64_s64(
		((s64)t_predicted - ttf->last_ttf) *
		MICRO_UNIT, delta_ms);
		if (ttf_slope > -100)
		ttf_slope = -100;
		else if (ttf_slope < -2000)
		ttf_slope = -2000;

		t_predicted = div_s64(
		(s64)ttf_slope * delta_ms, MICRO_UNIT) +
		ttf->last_ttf;
		pr_debug("TTF: ttf_slope=%d\n", ttf_slope);
		} else {
		t_predicted = ttf->last_ttf;
		}
		}

		/* clamp the ttf to 0 */
		if (t_predicted < 0)
		t_predicted = 0;

		pr_debug("TTF: t_predicted_postfilter=%d\n", t_predicted);
		*val = t_predicted;
		return 0;
		}

		/**
		* ttf_get_time_to_full -
		* @ttf: ttf object
		* @val: Average time to full returned to the caller
		*
		* Get Average time to full the battery based on current soc, rbatt
		* battery voltage and charge current etc.
		*/
		int ttf_get_time_to_full(struct ttf ttf, int val)
		{
		int rc;

		mutex_lock(&ttf->lock);
		rc = get_time_to_full_locked(ttf, val);
		mutex_unlock(&ttf->lock);

		return rc;
		}

		static void ttf_work(struct work_struct *work)
		{
		struct ttf *ttf = container_of(work,
		struct ttf, ttf_work.work);
		int rc, ibatt_now, vbatt_now, ttf_now, charge_status;
		ktime_t ktime_now;

		mutex_lock(&ttf->lock);
		rc = ttf->get_ttf_param(ttf->data, TTF_CHG_STATUS, &charge_status);
		if (rc < 0) {
		pr_err("failed to get charge_status rc=%d\n", rc);
		goto end_work;
		}
		if (charge_status != POWER_SUPPLY_STATUS_CHARGING &&
		charge_status != POWER_SUPPLY_STATUS_DISCHARGING)
		goto end_work;

		rc = ttf->get_ttf_param(ttf->data, TTF_IBAT, &ibatt_now);
		if (rc < 0) {
		pr_err("failed to get battery current, rc=%d\n", rc);
		goto end_work;
		}

		rc = ttf->get_ttf_param(ttf->data, TTF_VBAT, &vbatt_now);
		if (rc < 0) {
		pr_err("failed to get battery voltage, rc=%d\n", rc);
		goto end_work;
		}

		ttf_circ_buf_add(&ttf->ibatt, ibatt_now);
		ttf_circ_buf_add(&ttf->vbatt, vbatt_now);

		if (charge_status == POWER_SUPPLY_STATUS_CHARGING) {
		rc = get_time_to_full_locked(ttf, &ttf_now);
		if (rc < 0) {
		pr_err("failed to get ttf, rc=%d\n", rc);
		goto end_work;
		}

		/* keep the wake lock and prime the IBATT and VBATT buffers */
		if (ttf_now < 0) {
		/* delay for one FG cycle */
		schedule_delayed_work(&ttf->ttf_work,
		msecs_to_jiffies(1000));
		mutex_unlock(&ttf->lock);
		return;
		}

		/* update the TTF reference point every minute */
		ktime_now = ktime_get_boottime();
		if (ktime_ms_delta(ktime_now,
		ms_to_ktime(ttf->last_ms)) > 60000 \|\|
		ttf->last_ms == 0) {
		ttf->last_ttf = ttf_now;
		ttf->last_ms = ktime_to_ms(ktime_now);
		}
		}

		/* recurse every 10 seconds */
		schedule_delayed_work(&ttf->ttf_work, msecs_to_jiffies(ttf->period_ms));
		end_work:
		ttf->awake_voter(ttf->data, false);
		mutex_unlock(&ttf->lock);
		}

		/**
		* ttf_get_time_to_empty -
		* @ttf: ttf object
		* @val: Average time to empty returned to the caller
		*
		* Get Average time to empty the battery based on current soc
		* and average battery current.
		*/
		int ttf_get_time_to_empty(struct ttf ttf, int val)
		{
		int rc, ibatt_avg, msoc, act_cap_mah, divisor;

		rc = ttf_circ_buf_median(&ttf->ibatt, &ibatt_avg);
		if (rc < 0) {
		/* try to get instantaneous current */
		rc = ttf->get_ttf_param(ttf->data, TTF_IBAT, &ibatt_avg);
		if (rc < 0) {
		pr_err("failed to get battery current, rc=%d\n", rc);
		return rc;
		}
		}

		ibatt_avg /= MILLI_UNIT;
		/* clamp ibatt_avg to 100mA */
		if (ibatt_avg < 100)
		ibatt_avg = 100;

		rc = ttf->get_ttf_param(ttf->data, TTF_MSOC, &msoc);
		if (rc < 0) {
		pr_err("Error in getting capacity, rc=%d\n", rc);
		return rc;
		}

		rc = ttf->get_ttf_param(ttf->data, TTF_FCC, &act_cap_mah);
		if (rc < 0) {
		pr_err("Error in getting ACT_BATT_CAP, rc=%d\n", rc);
		return rc;
		}

		divisor = CENTI_ICORRECT_C0 * 100 + CENTI_ICORRECT_C1 * msoc;
		divisor = ibatt_avg * divisor / 100;
		divisor = max(100, divisor);
		val = act_cap_mah msoc * HOURS_TO_SECONDS / divisor;
		return 0;
		}

		/**
		* ttf_update -
		* @ttf: ttf object
		* @input_present: Indicator for input presence
		*
		* Called by FG/QG driver when there is a state change (Charging status, SOC)
		*
		*/
		void ttf_update(struct ttf *ttf, bool input_present)
		{
		int delay_ms;

		if (ttf->input_present == input_present)
		return;

		ttf->input_present = input_present;
		if (input_present)
		/* wait 35 seconds for the input to settle */
		delay_ms = 35000;
		else
		/* wait 5 seconds for current to settle during discharge */
		delay_ms = 5000;

		ttf->awake_voter(ttf->data, true);
		cancel_delayed_work_sync(&ttf->ttf_work);
		mutex_lock(&ttf->lock);
		ttf_circ_buf_clr(&ttf->ibatt);
		ttf_circ_buf_clr(&ttf->vbatt);
		ttf->last_ttf = 0;
		ttf->last_ms = 0;
		mutex_unlock(&ttf->lock);
		schedule_delayed_work(&ttf->ttf_work, msecs_to_jiffies(delay_ms));
		}

		/**
		* ttf_tte_init -
		* @ttf: Time to full object
		*
		* FG/QG have to call this during driver probe to validate the required
		* parameters after allocating ttf object.
		*
		*/
		int ttf_tte_init(struct ttf *ttf)
		{
		if (!ttf)
		return -ENODEV;

		if (!ttf->awake_voter \|\| !ttf->get_ttf_param) {
		pr_err("Insufficient functions for supporting ttf\n");
		return -EINVAL;
		}

		if (!ttf->iterm_delta)
		ttf->iterm_delta = DEFAULT_TTF_ITERM_DELTA_MA;
		if (!ttf->period_ms)
		ttf->period_ms = DEFAULT_TTF_RUN_PERIOD_MS;

		mutex_init(&ttf->lock);
		INIT_DELAYED_WORK(&ttf->ttf_work, ttf_work);

		return 0;
		}

drivers/power/supply/qcom/fg-alg.h

+57 −0

Original line number	Diff line number	Diff line
		@@ -15,6 +15,8 @@

		#define BUCKET_COUNT 8
		#define BUCKET_SOC_PCT (256 / BUCKET_COUNT)
		#define MAX_CC_STEPS 20
		#define MAX_TTF_SAMPLES 10

		struct cycle_counter {
		void *data;
		@@ -58,6 +60,57 @@ struct cap_learning {
		int (prime_cc_soc)(void data, u32 cc_soc_sw);
		};

		enum ttf_mode {
		TTF_MODE_NORMAL = 0,
		TTF_MODE_QNOVO,
		};

		enum ttf_param {
		TTF_MSOC = 0,
		TTF_VBAT,
		TTF_IBAT,
		TTF_FCC,
		TTF_MODE,
		TTF_ITERM,
		TTF_RBATT,
		TTF_VFLOAT,
		TTF_CHG_TYPE,
		TTF_CHG_STATUS,
		};

		struct ttf_circ_buf {
		int arr[MAX_TTF_SAMPLES];
		int size;
		int head;
		};

		struct ttf_cc_step_data {
		int arr[MAX_CC_STEPS];
		int sel;
		};

		struct ttf_pt {
		s32 x;
		s32 y;
		};

		struct ttf {
		void *data;
		struct ttf_circ_buf ibatt;
		struct ttf_circ_buf vbatt;
		struct ttf_cc_step_data cc_step;
		struct mutex lock;
		int mode;
		int last_ttf;
		int input_present;
		int iterm_delta;
		int period_ms;
		s64 last_ms;
		struct delayed_work ttf_work;
		int (get_ttf_param)(void data, enum ttf_param, int *val);
		int (awake_voter)(void data, bool vote);
		};

		int restore_cycle_count(struct cycle_counter *counter);
		void clear_cycle_count(struct cycle_counter *counter);
		void cycle_count_update(struct cycle_counter *counter, int batt_soc,
		@@ -72,5 +125,9 @@ void cap_learning_update(struct cap_learning *cl, int batt_temp,
		int cap_learning_init(struct cap_learning *cl);
		int cap_learning_post_profile_init(struct cap_learning *cl,
		int64_t nom_cap_uah);
		void ttf_update(struct ttf *ttf, bool input_present);
		int ttf_get_time_to_empty(struct ttf ttf, int val);
		int ttf_get_time_to_full(struct ttf ttf, int val);
		int ttf_tte_init(struct ttf *ttf);

		#endif