From patchwork Fri Mar 7 05:29:33 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jenny TC X-Patchwork-Id: 3787721 Return-Path: X-Original-To: patchwork-linux-omap@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 8D0459F35F for ; Fri, 7 Mar 2014 05:30:54 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 4BAFA20272 for ; Fri, 7 Mar 2014 05:30:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0763D200FE for ; Fri, 7 Mar 2014 05:30:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751987AbaCGFa1 (ORCPT ); Fri, 7 Mar 2014 00:30:27 -0500 Received: from mga02.intel.com ([134.134.136.20]:13730 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751820AbaCGFaW (ORCPT ); Fri, 7 Mar 2014 00:30:22 -0500 Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga101.jf.intel.com with ESMTP; 06 Mar 2014 21:30:22 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.97,605,1389772800"; d="scan'208";a="468199454" Received: from jenny-desktop.iind.intel.com ([10.223.107.44]) by orsmga001.jf.intel.com with ESMTP; 06 Mar 2014 21:30:14 -0800 From: Jenny TC To: linux-kernel@vger.kernel.org, Dmitry Eremin-Solenikov Cc: Anton Vorontsov , Anton Vorontsov , Jenny TC , Kim Milo , Lee Jones , Jingoo Han , Chanwoo Choi , Sachin Kamat , Lars-Peter Clausen , =?UTF-8?q?Pali=20Roh=C3=A1r?= , Rhyland Klein , Pavel Machek , "Rafael J. Wysocki" , David Woodhouse , Tony Lindgren , Russell King , Sebastian Reichel , aaro.koskinen@iki.fi, Pallala Ramakrishna , freemangordon@abv.bg, linux-omap@vger.kernel.org Subject: [PATCHv8 3/4] power_supply: Introduce PSE compliant algorithm Date: Fri, 7 Mar 2014 10:59:33 +0530 Message-Id: <1394170174-21959-4-git-send-email-jenny.tc@intel.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1394170174-21959-1-git-send-email-jenny.tc@intel.com> References: <1394170174-21959-1-git-send-email-jenny.tc@intel.com> Sender: linux-omap-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-omap@vger.kernel.org X-Spam-Status: No, score=-6.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_HI, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP As per Product Safety Engineering (PSE) specification for battery charging, the battery characteristics and thereby the charging rates can vary on different temperature zones. This patch introduces a PSE compliant charging algorithm with maintenance charging support. The algorithm can be selected by the power supply charging driver based on the type of the battery charging profile. Signed-off-by: Jenny TC --- drivers/power/Kconfig | 15 ++ drivers/power/Makefile | 1 + drivers/power/charging_algo_pse.c | 204 ++++++++++++++++++++++++++++ include/linux/power/power_supply_charger.h | 63 +++++++++ 4 files changed, 283 insertions(+) create mode 100644 drivers/power/charging_algo_pse.c diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index f679f82..54a0321 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig @@ -22,6 +22,21 @@ config POWER_SUPPLY_CHARGER drivers to keep the charging logic outside and the charger driver just need to abstract the charger hardware. +config POWER_SUPPLY_CHARGING_ALGO_PSE + bool "PSE compliant charging algorithm" + depends on POWER_SUPPLY_CHARGER + help + Say Y here to select Product Safety Engineering (PSE) compliant + charging algorithm. As per PSE standard the battery characteristics + and thereby the charging rates can vary on different temperature + zones. Select this if your charging algorithm need to change the + charging parameters based on the battery temperature and the battery + charging profile follows the struct psy_pse_chrg_prof definition. + This config will enable PSE compliant charging algorithm with + maintenance charging support. At runtime the algorithm will be + selected by the psy charger driver based on the type of the battery + charging profile. + config PDA_POWER tristate "Generic PDA/phone power driver" depends on !S390 diff --git a/drivers/power/Makefile b/drivers/power/Makefile index 405f0f4..77535fd 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_POWER_SUPPLY) += power_supply.o obj-$(CONFIG_GENERIC_ADC_BATTERY) += generic-adc-battery.o obj-$(CONFIG_POWER_SUPPLY_CHARGER) += power_supply_charger.o +obj-$(CONFIG_POWER_SUPPLY_CHARGING_ALGO_PSE) += charging_algo_pse.o obj-$(CONFIG_PDA_POWER) += pda_power.o obj-$(CONFIG_APM_POWER) += apm_power.o obj-$(CONFIG_MAX8925_POWER) += max8925_power.o diff --git a/drivers/power/charging_algo_pse.c b/drivers/power/charging_algo_pse.c new file mode 100644 index 0000000..ac95885 --- /dev/null +++ b/drivers/power/charging_algo_pse.c @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2012 Intel Corporation + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * Author: Jenny TC + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "power_supply.h" +#include "power_supply_charger.h" + +/* 98% of CV is considered as voltage to detect Full */ +#define FULL_CV_MIN 98 + +/* + * Offset to exit from maintenance charging. In maintenance charging + * if the volatge is less than the (maintenance_lower_threshold - + * MAINT_EXIT_OFFSET) then system can switch to normal charging + */ + +#define MAINT_EXIT_OFFSET 50 /* mV */ + +static int get_tempzone(struct psy_pse_chrg_prof *pse_mod_bprof, + int temp) +{ + int i = 0; + int temp_range_cnt = min_t(u16, pse_mod_bprof->temp_mon_ranges, + BATT_TEMP_NR_RNG); + + if ((temp < pse_mod_bprof->temp_low_lim) || + (temp > pse_mod_bprof->temp_mon_range[0].temp_up_lim)) + return -EINVAL; + + for (i = 0; i < temp_range_cnt; ++i) + if (temp > pse_mod_bprof->temp_mon_range[i].temp_up_lim) + break; + return i-1; +} + +static inline bool is_charge_terminated(long volt, long cur, + long iterm, unsigned long cv) +{ + pr_devel("%s:current=%ld pse_mod_bprof->chrg_term_mA =%ld voltage_now=%ld full_cond=%ld", + __func__, cur, iterm, volt * 100, (FULL_CV_MIN * cv)); + + return (cur > 0) && (cur <= iterm) && + ((volt * 100) >= (FULL_CV_MIN * cv)); + +} + +static inline bool is_battery_full(struct psy_batt_props bat_prop, + struct psy_pse_chrg_prof *pse_mod_bprof, unsigned long cv) +{ + + int i; + + /* + * Software full detection. Check the battery charge current to detect + * battery Full. The voltage also verified to avoid false charge + * full detection. + */ + pr_devel("%s:current=%ld pse_mod_bprof->chrg_term_mA =%d bat_prop.voltage_now=%ld full_cond=%ld", + __func__, bat_prop.current_now, (pse_mod_bprof->chrg_term_mA), + bat_prop.voltage_now * 100, (FULL_CV_MIN * cv)); + + for (i = (MAX_CUR_VOLT_SAMPLES - 1); i >= 0; --i) { + + if (!(is_charge_terminated(bat_prop.voltage_now_cache[i], + bat_prop.current_now_cache[i], + pse_mod_bprof->chrg_term_mA, cv))) + return false; + } + + return true; +} + +static int pse_get_bat_thresholds(struct psy_batt_chrg_prof bprof, + struct psy_batt_thresholds *bat_thresh) +{ + struct psy_pse_chrg_prof *pse_mod_bprof = + (struct psy_pse_chrg_prof *) bprof.batt_prof; + + if ((bprof.chrg_prof_type != PSY_CHRG_PROF_PSE) || (!pse_mod_bprof)) + return -EINVAL; + + bat_thresh->iterm = pse_mod_bprof->chrg_term_mA; + bat_thresh->temp_min = pse_mod_bprof->temp_low_lim; + bat_thresh->temp_max = pse_mod_bprof->temp_mon_range[0].temp_up_lim; + + return 0; +} + +static enum psy_algo_stat pse_get_next_cc_cv(struct psy_batt_props bat_prop, + struct psy_batt_chrg_prof bprof, + unsigned long *cc, unsigned long *cv) +{ + int tzone; + struct psy_pse_chrg_prof *pse_mod_bprof = + (struct psy_pse_chrg_prof *) bprof.batt_prof; + enum psy_algo_stat algo_stat = bat_prop.algo_stat; + int maint_exit_volt; + + *cc = *cv = 0; + + /* + * If STATUS is discharging, assume that charger is not connected. + * If charger is not connected, no need to take any action. + * If charge profile type is not PSY_CHRG_PROF_PSE or the charge profile + * is not present, no need to take any action. + */ + + pr_devel("%s:battery status = %ld algo_status=%d\n", + __func__, bat_prop.status, algo_stat); + + if ((bprof.chrg_prof_type != PSY_CHRG_PROF_PSE) || (!pse_mod_bprof)) + return PSY_ALGO_STAT_NOT_CHARGE; + + tzone = get_tempzone(pse_mod_bprof, bat_prop.temperature); + + if (tzone < 0) + return PSY_ALGO_STAT_NOT_CHARGE; + + /* + * Change the algo status to not charging, if battery is + * not really charging or less than maintenance exit threshold. + * This way algorithm can switch to normal charging if current + * status is full/maintenance. + */ + maint_exit_volt = pse_mod_bprof-> + temp_mon_range[tzone].maint_chrg_vol_ll - + MAINT_EXIT_OFFSET; + + if ((bat_prop.status == POWER_SUPPLY_STATUS_DISCHARGING) || + (bat_prop.status == POWER_SUPPLY_STATUS_NOT_CHARGING) || + bat_prop.voltage_now < maint_exit_volt) { + + algo_stat = PSY_ALGO_STAT_NOT_CHARGE; + + } + + /* read cc and cv based on temperature and algorithm status */ + if (algo_stat == PSY_ALGO_STAT_FULL || + algo_stat == PSY_ALGO_STAT_MAINT) { + + /* + * if status is full and voltage is lower than maintenance lower + * threshold change status to maintenance + */ + + if (algo_stat == PSY_ALGO_STAT_FULL && (bat_prop.voltage_now <= + pse_mod_bprof->temp_mon_range[tzone].maint_chrg_vol_ll)) + algo_stat = PSY_ALGO_STAT_MAINT; + + /* Read maintenance CC and CV */ + if (algo_stat == PSY_ALGO_STAT_MAINT) { + *cv = pse_mod_bprof->temp_mon_range + [tzone].maint_chrg_vol_ul; + *cc = pse_mod_bprof->temp_mon_range + [tzone].maint_chrg_cur; + } + } else { + *cv = pse_mod_bprof->temp_mon_range[tzone].full_chrg_vol; + *cc = pse_mod_bprof->temp_mon_range[tzone].full_chrg_cur; + algo_stat = PSY_ALGO_STAT_CHARGE; + } + + if (is_battery_full(bat_prop, pse_mod_bprof, *cv)) { + *cc = *cv = 0; + algo_stat = PSY_ALGO_STAT_FULL; + } + + return algo_stat; +} + +static int __init pse_algo_init(void) +{ + struct psy_charging_algo pse_algo; + pse_algo.chrg_prof_type = PSY_CHRG_PROF_PSE; + pse_algo.name = "pse_algo"; + pse_algo.get_next_cc_cv = pse_get_next_cc_cv; + pse_algo.get_batt_thresholds = pse_get_bat_thresholds; + power_supply_register_charging_algo(&pse_algo); + return 0; +} + +module_init(pse_algo_init); diff --git a/include/linux/power/power_supply_charger.h b/include/linux/power/power_supply_charger.h index a26ad4d..b7a56f1 100644 --- a/include/linux/power/power_supply_charger.h +++ b/include/linux/power/power_supply_charger.h @@ -91,8 +91,71 @@ enum battery_events { enum psy_batt_chrg_prof_type { PSY_CHRG_PROF_NONE = 0, + PSY_CHRG_PROF_PSE, }; +/* Product Safety Engineering (PSE) compliant charging profile */ + +/** + * struct psy_ps_temp_chg_table - charging temperature zones definition + * @temp_up_lim: upper temperature limit for each zone in Degree Celsius + * @full_chrg_vol: charge voltage till battery full in mV + * @full_chrg_cur: charge current till battery full in mA + * @maint_chrg_vol_ll: voltage at which maintenance charging should start in mV + * @maint_chrg_vol_ul: voltage at which maintenance charging should stop in mV. + * This is the charging voltage in maintenance charging mode + * @maint_chrg_cur: charge current in maintenance charging mode + * + * Charging temperature zone definition to decide the charging parameters on + * each zone. An array of the structure is used to define multiple temperature + * zones + */ + +struct psy_ps_temp_chg_table { + short int temp_up_lim; + short int full_chrg_vol; + short int full_chrg_cur; + short int maint_chrg_vol_ll; + short int maint_chrg_vol_ul; + short int maint_chrg_cur; +} __packed; + +#define BATTID_STR_LEN 8 +#define BATT_TEMP_NR_RNG 6 + +/** + * struct psy_pse_chrg_prof - PSE charging profile structure + * @batt_id: battery identifier + * @battery_type: as defined in POWER_SUPPLY_TECHNOLOGY_* + * @capacity: battery capacity in mAh + * @voltage_max: maximum battery volatge in mV + * @chrg_term_ma: charge termination current in mA + * @low_batt_mv: Low battery level voltage in mV + * @disch_temp_ul: maximum operating temperature when battery is discharging + * @disch_temp_ll: lowest operating temperature when battery is discharging + * @temp_mon_ranges: number of temperature zones + * @psy_ps_temp_chg_table: temperature zone table array + * @temp_low_lim: minimum charging temperature + * + * PSE compliant charging profile which can be stored in battery EEPROM + * (if digital battery interface like MIPI BIF/SDQ supported) or in secondary + * storage to support analog battery (with BSI sensing support) + */ + +struct psy_pse_chrg_prof { + char batt_id[BATTID_STR_LEN]; + u16 battery_type; + u16 capacity; + u16 voltage_max; + u16 chrg_term_mA; + u16 low_batt_mV; + s8 disch_temp_ul; + s8 disch_temp_ll; + u16 temp_mon_ranges; + struct psy_ps_temp_chg_table temp_mon_range[BATT_TEMP_NR_RNG]; + s8 temp_low_lim; +} __packed; + /** * struct psy_batt_chrg_prof - power supply charging profile structure * @chrg_prof_type: charging profile type