Skip to content

Commit 5a6a99b

Browse files
LeoCX-Tsaikiram9
LeoCX-Tsai
authored and
kiram9
committed
fwk: set charge limit control and percentage control to common
all project use same code common it for future project TEST=zmake build marigold pass BRANCH=marigold Signed-off-by: LeoCX_Tsai <LeoCX_Tsai@compal.com>
1 parent 9b59e86 commit 5a6a99b

File tree

4 files changed

+113
-178
lines changed

4 files changed

+113
-178
lines changed

‎zephyr/program/framework/CMakeLists.txt‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,9 @@ zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_LED_COMMON
2626
zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_CHARGE_MANAGER
2727
"src/battery_extender.c")
2828

29+
zephyr_library_sources_ifdef(CONFIG_PLATFORM_EC_CHARGE_MANAGER
30+
"src/charge_limit_control.c")
31+
2932
if(DEFINED CONFIG_BOARD_LOTUS)
3033
project(lotus)
3134
cros_ec_library_include_directories_ifdef(CONFIG_BOARD_LOTUS include)

‎zephyr/program/framework/azalea/src/battery.c‎

Lines changed: 0 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,6 @@
2424
#define CACHE_INVALIDATION_TIME_US (3 * SECOND)
2525

2626
static enum battery_present batt_pres_prev = BP_NOT_SURE;
27-
static uint8_t charging_maximum_level = EC_CHARGE_LIMIT_RESTORE;
2827
static int old_btp;
2928

3029
enum battery_present battery_is_present(void)
@@ -65,50 +64,6 @@ uint32_t get_system_percentage(void)
6564
return pre_os_percentage;
6665
}
6766

68-
static void battery_percentage_control(void)
69-
{
70-
enum ec_charge_control_mode new_mode;
71-
static int in_percentage_control;
72-
uint32_t batt_os_percentage = get_system_percentage();
73-
int rv;
74-
75-
/**
76-
* If the host command EC_CMD_CHARGE_CONTROL set control mode to CHARGE_CONTROL_DISCHARGE
77-
* or CHARGE_CONTROL_IDLE, ignore the battery_percentage_control();
78-
*/
79-
if (!in_percentage_control && get_chg_ctrl_mode() != CHARGE_CONTROL_NORMAL)
80-
return;
81-
82-
if (charging_maximum_level == EC_CHARGE_LIMIT_RESTORE)
83-
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
84-
85-
if (charging_maximum_level & CHG_LIMIT_OVERRIDE) {
86-
new_mode = CHARGE_CONTROL_NORMAL;
87-
if (batt_os_percentage == 1000)
88-
charging_maximum_level = charging_maximum_level | 0x64;
89-
} else if (charging_maximum_level < 20)
90-
new_mode = CHARGE_CONTROL_NORMAL;
91-
else if (batt_os_percentage > charging_maximum_level * 10) {
92-
new_mode = CHARGE_CONTROL_DISCHARGE;
93-
in_percentage_control = 1;
94-
} else if (batt_os_percentage == charging_maximum_level * 10) {
95-
new_mode = CHARGE_CONTROL_IDLE;
96-
in_percentage_control = 1;
97-
} else {
98-
new_mode = CHARGE_CONTROL_NORMAL;
99-
in_percentage_control = 0;
100-
}
101-
102-
set_chg_ctrl_mode(new_mode);
103-
#ifdef CONFIG_PLATFORM_EC_CHARGER_DISCHARGE_ON_AC
104-
rv = charger_discharge_on_ac(new_mode == CHARGE_CONTROL_DISCHARGE);
105-
#endif
106-
if (rv != EC_SUCCESS)
107-
CPRINTS("Failed to discharge.");
108-
}
109-
DECLARE_HOOK(HOOK_AC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
110-
DECLARE_HOOK(HOOK_BATTERY_SOC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
111-
11267
enum battery_present board_batt_is_present(void)
11368
{
11469
/*
@@ -308,41 +263,3 @@ __override void board_battery_compensate_params(struct batt_params *batt)
308263
batt->flags |= BATT_FLAG_RESPONSIVE;
309264
batt_cache.flags |= BATT_FLAG_RESPONSIVE;
310265
}
311-
312-
/*****************************************************************************/
313-
/* Host command */
314-
315-
static enum ec_status cmd_charging_limit_control(struct host_cmd_handler_args *args)
316-
{
317-
318-
const struct ec_params_ec_chg_limit_control *p = args->params;
319-
struct ec_response_chg_limit_control *r = args->response;
320-
321-
if (p->modes & CHG_LIMIT_DISABLE) {
322-
charging_maximum_level = 0;
323-
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, 0);
324-
}
325-
326-
if (p->modes & CHG_LIMIT_SET_LIMIT) {
327-
if (p->max_percentage < 20)
328-
return EC_RES_ERROR;
329-
330-
charging_maximum_level = p->max_percentage;
331-
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, charging_maximum_level);
332-
}
333-
334-
if (p->modes & CHG_LIMIT_OVERRIDE)
335-
charging_maximum_level = charging_maximum_level | CHG_LIMIT_OVERRIDE;
336-
337-
if (p->modes & CHG_LIMIT_GET_LIMIT) {
338-
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
339-
r->max_percentage = charging_maximum_level;
340-
args->response_size = sizeof(*r);
341-
}
342-
343-
battery_percentage_control();
344-
345-
return EC_RES_SUCCESS;
346-
}
347-
DECLARE_HOST_COMMAND(EC_CMD_CHARGE_LIMIT_CONTROL, cmd_charging_limit_control,
348-
EC_VER_MASK(0));

‎zephyr/program/framework/lotus/src/battery.c‎

Lines changed: 0 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,6 @@
2929
#define CACHE_INVALIDATION_TIME_US (3 * SECOND)
3030

3131
static int battery_current_array[4];
32-
static uint8_t charging_maximum_level = EC_CHARGE_LIMIT_RESTORE;
3332
static int old_btp;
3433
static int power_on_check_batt;
3534

@@ -107,50 +106,6 @@ uint32_t get_system_percentage(void)
107106
return pre_os_percentage;
108107
}
109108

110-
static void battery_percentage_control(void)
111-
{
112-
enum ec_charge_control_mode new_mode;
113-
static int in_percentage_control;
114-
uint32_t batt_os_percentage = get_system_percentage();
115-
int rv;
116-
117-
/**
118-
* If the host command EC_CMD_CHARGE_CONTROL set control mode to CHARGE_CONTROL_DISCHARGE
119-
* or CHARGE_CONTROL_IDLE, ignore the battery_percentage_control();
120-
*/
121-
if (!in_percentage_control && get_chg_ctrl_mode() != CHARGE_CONTROL_NORMAL)
122-
return;
123-
124-
if (charging_maximum_level == EC_CHARGE_LIMIT_RESTORE)
125-
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
126-
127-
if (charging_maximum_level & CHG_LIMIT_OVERRIDE) {
128-
new_mode = CHARGE_CONTROL_NORMAL;
129-
if (batt_os_percentage == 1000)
130-
charging_maximum_level = charging_maximum_level | 0x64;
131-
} else if (charging_maximum_level < 20)
132-
new_mode = CHARGE_CONTROL_NORMAL;
133-
else if (batt_os_percentage > charging_maximum_level * 10) {
134-
new_mode = CHARGE_CONTROL_DISCHARGE;
135-
in_percentage_control = 1;
136-
} else if (batt_os_percentage == charging_maximum_level * 10) {
137-
new_mode = CHARGE_CONTROL_IDLE;
138-
in_percentage_control = 1;
139-
} else {
140-
new_mode = CHARGE_CONTROL_NORMAL;
141-
in_percentage_control = 0;
142-
}
143-
144-
set_chg_ctrl_mode(new_mode);
145-
#ifdef CONFIG_PLATFORM_EC_CHARGER_DISCHARGE_ON_AC
146-
rv = charger_discharge_on_ac(new_mode == CHARGE_CONTROL_DISCHARGE);
147-
#endif
148-
if (rv != EC_SUCCESS)
149-
CPRINTS("Failed to discharge.");
150-
}
151-
DECLARE_HOOK(HOOK_AC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
152-
DECLARE_HOOK(HOOK_BATTERY_SOC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
153-
154109
int get_average_battery_current(void)
155110
{
156111
int idx;
@@ -404,53 +359,3 @@ __override int board_cut_off_battery(void)
404359

405360
return EC_RES_ERROR;
406361
}
407-
408-
/*****************************************************************************/
409-
/* Host command */
410-
411-
static enum ec_status cmd_charging_limit_control(struct host_cmd_handler_args *args)
412-
{
413-
414-
const struct ec_params_ec_chg_limit_control *p = args->params;
415-
struct ec_response_chg_limit_control *r = args->response;
416-
417-
if (p->modes & CHG_LIMIT_DISABLE) {
418-
charging_maximum_level = 0;
419-
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, 0);
420-
}
421-
422-
if (p->modes & CHG_LIMIT_SET_LIMIT) {
423-
if (p->max_percentage < 20)
424-
return EC_RES_ERROR;
425-
426-
charging_maximum_level = p->max_percentage;
427-
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, charging_maximum_level);
428-
}
429-
430-
if (p->modes & CHG_LIMIT_OVERRIDE)
431-
charging_maximum_level = charging_maximum_level | CHG_LIMIT_OVERRIDE;
432-
433-
if (p->modes & CHG_LIMIT_GET_LIMIT) {
434-
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
435-
r->max_percentage = charging_maximum_level;
436-
args->response_size = sizeof(*r);
437-
}
438-
439-
battery_percentage_control();
440-
441-
return EC_RES_SUCCESS;
442-
}
443-
DECLARE_HOST_COMMAND(EC_CMD_CHARGE_LIMIT_CONTROL, cmd_charging_limit_control,
444-
EC_VER_MASK(0));
445-
446-
static enum ec_status cmd_get_cutoff_status(struct host_cmd_handler_args *args)
447-
{
448-
struct ec_response_get_cutoff_status *r = args->response;
449-
450-
r->status = battery_is_cut_off();
451-
args->response_size = sizeof(*r);
452-
453-
return EC_RES_SUCCESS;
454-
}
455-
DECLARE_HOST_COMMAND(EC_CMD_GET_CUTOFF_STATUS, cmd_get_cutoff_status,
456-
EC_VER_MASK(0));

‎zephyr/program/framework/src/charge_limit_control.c‎

Lines changed: 110 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,110 @@
1+
/*
2+
* Copyright 2024 The Chromium OS Authors. All rights reserved.
3+
* Use of this source code is governed by a BSD-style license that can be
4+
* found in the LICENSE file.
5+
*/
6+
7+
#include <zephyr/drivers/gpio.h>
8+
9+
#include "adc.h"
10+
#include "battery.h"
11+
#include "battery_smart.h"
12+
#include "battery_fuel_gauge.h"
13+
#include "board_adc.h"
14+
#include "board_host_command.h"
15+
#include "board_function.h"
16+
#include "charger.h"
17+
#include "charge_state.h"
18+
#include "console.h"
19+
#include "customized_shared_memory.h"
20+
#include "hooks.h"
21+
#include "host_command.h"
22+
#include "system.h"
23+
#include "util.h"
24+
25+
#define CPRINTS(format, args...) cprints(CC_CHARGER, format, ##args)
26+
#define CPRINTF(format, args...) cprintf(CC_CHARGER, format, ##args)
27+
28+
static uint8_t charging_maximum_level = EC_CHARGE_LIMIT_RESTORE;
29+
30+
static void battery_percentage_control(void)
31+
{
32+
enum ec_charge_control_mode new_mode;
33+
static int in_percentage_control;
34+
uint32_t batt_os_percentage = get_system_percentage();
35+
int rv;
36+
37+
/**
38+
* If the host command EC_CMD_CHARGE_CONTROL set control mode to CHARGE_CONTROL_DISCHARGE
39+
* or CHARGE_CONTROL_IDLE, ignore the battery_percentage_control();
40+
*/
41+
if (!in_percentage_control && get_chg_ctrl_mode() != CHARGE_CONTROL_NORMAL)
42+
return;
43+
44+
if (charging_maximum_level == EC_CHARGE_LIMIT_RESTORE)
45+
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
46+
47+
if (charging_maximum_level & CHG_LIMIT_OVERRIDE) {
48+
new_mode = CHARGE_CONTROL_NORMAL;
49+
if (batt_os_percentage == 1000)
50+
charging_maximum_level = charging_maximum_level | 0x64;
51+
} else if (charging_maximum_level < 20)
52+
new_mode = CHARGE_CONTROL_NORMAL;
53+
else if (batt_os_percentage > charging_maximum_level * 10) {
54+
new_mode = CHARGE_CONTROL_DISCHARGE;
55+
in_percentage_control = 1;
56+
} else if (batt_os_percentage == charging_maximum_level * 10) {
57+
new_mode = CHARGE_CONTROL_IDLE;
58+
in_percentage_control = 1;
59+
} else {
60+
new_mode = CHARGE_CONTROL_NORMAL;
61+
in_percentage_control = 0;
62+
}
63+
64+
set_chg_ctrl_mode(new_mode);
65+
#ifdef CONFIG_PLATFORM_EC_CHARGER_DISCHARGE_ON_AC
66+
rv = charger_discharge_on_ac(new_mode == CHARGE_CONTROL_DISCHARGE);
67+
#endif
68+
if (rv != EC_SUCCESS)
69+
CPRINTS("Failed to discharge.");
70+
}
71+
DECLARE_HOOK(HOOK_AC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
72+
DECLARE_HOOK(HOOK_BATTERY_SOC_CHANGE, battery_percentage_control, HOOK_PRIO_DEFAULT);
73+
74+
/*****************************************************************************/
75+
/* Host command */
76+
77+
static enum ec_status cmd_charging_limit_control(struct host_cmd_handler_args *args)
78+
{
79+
80+
const struct ec_params_ec_chg_limit_control *p = args->params;
81+
struct ec_response_chg_limit_control *r = args->response;
82+
83+
if (p->modes & CHG_LIMIT_DISABLE) {
84+
charging_maximum_level = 0;
85+
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, 0);
86+
}
87+
88+
if (p->modes & CHG_LIMIT_SET_LIMIT) {
89+
if (p->max_percentage < 20)
90+
return EC_RES_ERROR;
91+
92+
charging_maximum_level = p->max_percentage;
93+
system_set_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, charging_maximum_level);
94+
}
95+
96+
if (p->modes & CHG_LIMIT_OVERRIDE)
97+
charging_maximum_level = charging_maximum_level | CHG_LIMIT_OVERRIDE;
98+
99+
if (p->modes & CHG_LIMIT_GET_LIMIT) {
100+
system_get_bbram(SYSTEM_BBRAM_IDX_CHARGE_LIMIT_MAX, &charging_maximum_level);
101+
r->max_percentage = charging_maximum_level;
102+
args->response_size = sizeof(*r);
103+
}
104+
105+
battery_percentage_control();
106+
107+
return EC_RES_SUCCESS;
108+
}
109+
DECLARE_HOST_COMMAND(EC_CMD_CHARGE_LIMIT_CONTROL, cmd_charging_limit_control,
110+
EC_VER_MASK(0));

0 commit comments

Comments
 (0)