fwk: main: combine charger limit and battery extender

We have two functions to control the charger mode to save battery life,
combine two functions to avoid the race condition, we will all use sustainer_set.
when extender is not triggered yet, it will execute battery_percentage_control
after trigger uses battery_extender.

BRANCH=fwk-main
BUG=https://app.clickup.com/t/86eqxq8c1
TEST= verify on marigold, condition 1, set charger limit(70%) first and
trigger it to make sure percentage is down to 70%,
use cmd battextender timeext 3 m and battextender timeext2 4 m
check if stage 1 trigger percentage still keep at 70%
when stage 2 trigger also keep at 70%. (battery LED keep White)

TEST= verify on marigold, condition 2, after condition 1 setting charger limit(60%) again
after 5 Sec check battery start discharge and stop at 60%. (battery LED keep White)

TEST= verify on marigold, condition 3, disable charger limit(100%) check battextender will
set default range and star charging until trigger stage1(95-90) and stage2(87-85).
(battery LED will be charge LED(60%~95% amber), after trigger stage1 will be white)

Signed-off-by: LeoCX_Tsai <[email protected]>
(cherry picked from commit d18a2aaa230f0f59265983ab277e716d3558c67f)

Author: LeoCX-Tsai

zephyr/program/framework/CMakeLists.txt

@@ -38,9 +38,6 @@ zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_TOUCHPAD_CUSTOMIZED
 zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_CHARGE_MANAGER
 	"src/battery_extender.c")
 
-zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_CHARGE_MANAGER
-	"src/charge_limit_control.c")
-
 if(DEFINED CONFIG_BOARD_LOTUS)
 	project(lotus)
 	cros_ec_library_include_directories_ifdef(CONFIG_BOARD_LOTUS include)

zephyr/program/framework/src/battery_extender.c

@@ -5,17 +5,25 @@
  */
 
 #include "battery.h"
+#include "battery_smart.h"
 #include "board_host_command.h"
+#include "board_charger.h"
+#include "battery_fuel_gauge.h"
+#include "board_function.h"
 #include "charge_state.h"
+#include "charger.h"
 #include "console.h"
+#include "customized_shared_memory.h"
 #include "ec_commands.h"
 #include "extpower.h"
+#include "factory.h"
+#include "host_command.h"
+#include "system.h"
 #include "timer.h"
 #include "util.h"
 #include "hooks.h"
 
 
-
 #define CPRINTS(format, args...) cprints(CC_SYSTEM, format, ## args)
 #define CPRINTF(format, args...) cprintf(CC_SYSTEM, format, ## args)
 
@@ -41,7 +49,11 @@ static timestamp_t batt_extender_deadline;
 static timestamp_t batt_extender_deadline_stage2;
 
 static timestamp_t reset_deadline;
+static int sustainer_lower = 100;
+static int sustainer_upper = 100;
 
+static uint8_t charging_maximum_level = EC_CHARGE_LIMIT_RESTORE;
+static uint8_t old_charger_limit;
 
 static void extender_init(void)
 {
@@ -55,12 +67,44 @@ static void extender_init(void)
 }
 DECLARE_HOOK(HOOK_INIT, extender_init, HOOK_PRIO_DEFAULT);
 
+int charger_sustainer_percentage(void)
+{
+	if (!charging_maximum_level)
+		return 100;
+	return charging_maximum_level;
+}
+
+static void battery_percentage_control(void)
+{
+	if (charging_maximum_level == EC_CHARGE_LIMIT_RESTORE) {
+		system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
+		if (charging_maximum_level & CHG_LIMIT_OVERRIDE)
+			charging_maximum_level = charging_maximum_level & 0x64;
+	}
+
+	if (charging_maximum_level & CHG_LIMIT_OVERRIDE ||
+		!charging_maximum_level) {
+		battery_sustainer_set(-1, -1);
+		set_chg_ctrl_mode(CHARGE_CONTROL_NORMAL);
+		return;
+	}
+
+	if (old_charger_limit != charging_maximum_level) {
+		old_charger_limit = charging_maximum_level;
+		battery_sustainer_set(MAX(20, (charging_maximum_level - 5)),
+			MAX(20, charging_maximum_level));
+	}
+}
 
 void battery_extender(void)
 {
 	timestamp_t now = get_time();
 
-	if (batt_extender_disable) {
+	if (stage == BATT_EXTENDER_STAGE_0)
+		battery_percentage_control();
+
+	/* don't runnig extender when unit in factory mode */
+	if (batt_extender_disable || factory_status()) {
 		stage = BATT_EXTENDER_STAGE_0;
 		reset_deadline.val = 0;
 		batt_extender_deadline.val = 0;
@@ -73,6 +117,16 @@ void battery_extender(void)
 		reset_deadline.val = now.val + battery_extender_reset;
 	}
 
+	if (sustainer_upper != charger_sustainer_percentage()) {
+		sustainer_upper = charger_sustainer_percentage();
+		sustainer_lower = sustainer_upper - 5;
+		/* if we already trigger stage, set 5 SECOND to update the sustainer again */
+		if (stage == BATT_EXTENDER_STAGE_1) {
+			batt_extender_deadline.val = now.val + 5 * SECOND;
+		} else if (stage == BATT_EXTENDER_STAGE_2)
+			batt_extender_deadline_stage2.val = now.val + 5 * SECOND;
+	}
+
 	if (reset_deadline.val &&
 			timestamp_expired(reset_deadline, &now)) {
 		reset_deadline.val = 0;
@@ -90,14 +144,12 @@ void battery_extender(void)
 			timestamp_expired(batt_extender_deadline_stage2, &now)) {
 		batt_extender_deadline_stage2.val = 0;
 		stage = BATT_EXTENDER_STAGE_2;
-		battery_sustainer_set(85, 87);
-	}
-
-	else if (batt_extender_deadline.val &&
+		battery_sustainer_set(MIN(85, sustainer_lower), MIN(87, sustainer_upper));
+	} else if (batt_extender_deadline.val &&
 			timestamp_expired(batt_extender_deadline, &now)) {
 		batt_extender_deadline.val = 0;
 		stage = BATT_EXTENDER_STAGE_1;
-		battery_sustainer_set(90, 95);
+		battery_sustainer_set(MIN(90, sustainer_lower), MIN(95, sustainer_upper));
 	}
 }
 DECLARE_HOOK(HOOK_SECOND, battery_extender, HOOK_PRIO_DEFAULT);
@@ -173,6 +225,44 @@ static enum ec_status battery_extender_hc(struct host_cmd_handler_args *args)
 }
 DECLARE_HOST_COMMAND(EC_CMD_BATTERY_EXTENDER, battery_extender_hc, EC_VER_MASK(0));
 
+/*****************************************************************************/
+/* Host command */
+
+static enum ec_status cmd_charging_limit_control(struct host_cmd_handler_args *args)
+{
+
+	const struct ec_params_ec_chg_limit_control *p = args->params;
+	struct ec_response_chg_limit_control *r = args->response;
+
+	if (p->modes & CHG_LIMIT_DISABLE) {
+		charging_maximum_level = 0;
+		system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, 0);
+	}
+
+	if (p->modes & CHG_LIMIT_SET_LIMIT) {
+		if (p->max_percentage < 20)
+			return EC_RES_ERROR;
+
+		charging_maximum_level = p->max_percentage;
+		system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, charging_maximum_level);
+	}
+
+	if (p->modes & CHG_LIMIT_OVERRIDE)
+		charging_maximum_level = charging_maximum_level | CHG_LIMIT_OVERRIDE;
+
+	if (p->modes & CHG_LIMIT_GET_LIMIT) {
+		system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
+		r->max_percentage = charging_maximum_level;
+		args->response_size = sizeof(*r);
+	}
+
+	battery_percentage_control();
+
+	return EC_RES_SUCCESS;
+}
+DECLARE_HOST_COMMAND(EC_CMD_CHARGE_LIMIT_CONTROL, cmd_charging_limit_control,
+			EC_VER_MASK(0));
+
 static uint64_t cmd_parse_timestamp(int argc, const char **argv)
 {
 	uint64_t time_val = 0;
@@ -291,6 +381,9 @@ static int cmd_batt_extender(int argc, const char **argv)
 			CPRINTF("\t - expires in: ");
 			print_time_offset(reset_deadline.val, now.val);
 		}
+		CPRINTF("\tsustainer percentage:\n");
+		CPRINTF("\tlower: %d, upper: %d\n", sustainer_lower, sustainer_upper);
+		CPRINTF("\tUser charge limit:%d\n", charging_maximum_level);
 	}
 
 	return EC_SUCCESS;