/*
 * In this module we are going to implement the main process functions
 * for FCHG.
 */

#include "fchg/fchg_env.h"
#include "fchg/fchg_func_i.h"
#include "rv/rv_general.h"
#include "rvf/rvf_api.h"
#include "rvm/rvm_use_id_list.h"
#include "abb/abb.h"
#include "fc-target.h"
#include <string.h>
#include <stdio.h>

extern UINT16 madc_vbat_2_physical(UINT16 adc_val);
extern UINT16 madc_vbat_inverse(UINT16 mv);

#if defined(CONFIG_TARGET_C155) || defined(CONFIG_TARGET_J100)
#define	LEDC	0x20
#else
#define	LEDC	0
#endif

#define	CHARGER_PLUG_DEBOUNCE_MS	200

/*
 * The following global variable captures the initial battery voltage
 * at the time of system boot - it is intended to be used for various
 * system start-up decisions.
 */
UINT16 fchg_first_vbat;

void pwr_init_discharge(void)
{
	pwr_ctrl->curr_disch_thresh = 0;
}

static void handle_discharge(void)
{
	UINT16 i;
	char trace[64];

	/* first we need to find the current threshold we are at */
	i = pwr_ctrl->curr_disch_thresh;
	/* are we at the bottom? */
	if ((i + 1) == pwr_ctrl->nb_percent_thresh)
		return;
	/* are we crossing our current threshold? */
	if (pwr_ctrl->batt_mv >= pwr_ctrl->batt.percent_thresh[i].bat_voltage)
		return;
	/* yes, we crossed it - see if we fell even further down */
	while (i < pwr_ctrl->nb_percent_thresh-1 &&
	       pwr_ctrl->batt_mv < pwr_ctrl->batt.percent_thresh[i].bat_voltage)
		i++;
	/* the last one was it */
	pwr_ctrl->curr_disch_thresh = i;
	sprintf(trace, "Battery fell through %u%% mark",
		pwr_ctrl->batt.percent_thresh[i-1].remain_capa);
	rvf_send_trace(trace, strlen(trace), NULL_PARAM,
			RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
	if (pwr_ctrl->event_handler)
		pwr_ctrl->event_handler(FCHG_EVENT_DISCHARGE);
}

static void capture_first_vbat(void)
{
	char trace[64];

	fchg_first_vbat = pwr_ctrl->batt_mv;
	sprintf(trace, "System boot: Vbat=%u", pwr_ctrl->batt_mv);
	rvf_send_trace(trace, strlen(trace), NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
}

static void start_i2v_cal(void)
{
	UINT16 bciconf;

	rvf_send_trace("Calibrating i2v offset", 22, NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
	pwr_ctrl->state = FCHG_STATE_I2V_CAL_2;
	bciconf = ABB_Read_Register_on_page(PAGE1, BCICONF);
	bciconf &= 0x3E0;
	bciconf |= pwr_ctrl->config.bciconf;
	ABB_Write_Register_on_page(PAGE1, BCICONF, bciconf);
	/*
	 * Set the CHDISPA bit and start the zero calibration routine
	 * of the I to V converter
	 */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0010);
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0019 | LEDC);
}

static void start_ci_charging(void)
{
	rvf_send_trace("Start CI charging", 17, NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
	pwr_ctrl->state = FCHG_STATE_CI_CHARGING;
	/* Select constant current charging. The charger is disabled */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0002);
	/* Program the DAC with the constant current value */
	ABB_Write_Register_on_page(PAGE0, CHGREG,
			pwr_ctrl->config.ci_current + pwr_ctrl->i2v_offset);
	/* Enable the charger */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003 | LEDC);
	/* The total charging time starts now */
	pwr_ctrl->start_time = rvf_get_tick_count();
	if (pwr_ctrl->event_handler)
		pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_START);
}

static void start_cv_charging(void)
{
	UINT16 code;

	rvf_send_trace("Start CV charging", 17, NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
	pwr_ctrl->state = FCHG_STATE_CV_CHARGING;
	/* Select constant voltage charging. The charger is disabled */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
	/* figure out the DAC code */
	code = madc_vbat_inverse(pwr_ctrl->config.cv_init_set);
	rvf_send_trace("Voltage (DAC code) ", 19, code,
			RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
	/* Program the DAC with the constant voltage value */
	ABB_Write_Register_on_page(PAGE0, CHGREG, code);
	/* Enable the charger */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0001 | LEDC);
	/* CV control loop state init */
	pwr_ctrl->cv_dac_init = code;
	pwr_ctrl->cv_dac_curr = code;
	pwr_ctrl->cv_high_vbat_count = 0;
	pwr_ctrl->cv_low_vbat_count = 0;
	/* Ichg averaging state init */
	pwr_ctrl->ichg_fill_level = 0;
	pwr_ctrl->ichg_ring_ptr = 0;
	pwr_ctrl->ichg_low_count = 0;
}

static void start_charge_condition_met(void)
{
	rvf_send_trace("Charge start condition met", 26, NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
	if (pwr_ctrl->config.bciconf)
		start_i2v_cal();
	else {
		pwr_ctrl->i2v_offset = 0;
		start_ci_charging();
	}
}

static void ci_progress_trace(UINT16 ichg)
{
	char trace[64];

	pwr_ctrl->ci_ichg = ichg;
	sprintf(trace, "CI charging: Vbat=%u Ichg=%u i2v=%u",
		pwr_ctrl->batt_mv, ichg, pwr_ctrl->i2v_offset);
	rvf_send_trace(trace, strlen(trace), NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
}

static int cv_ichg_process(UINT16 ichg_new)
{
	UINT16 ichg_clip, ichg_entry;
	UINT32 ichg_accum;
	UINT16 i;
	char trace[64];

	if (pwr_ctrl->ichg_fill_level < ICHG_AVG_WINDOW)
		pwr_ctrl->ichg_avg_buf[pwr_ctrl->ichg_fill_level++] = ichg_new;
	else {
		ichg_clip = pwr_ctrl->ichg_average +
				pwr_ctrl->config.ichg_max_spike;
		if (ichg_new > ichg_clip)
			ichg_entry = ichg_clip;
		else
			ichg_entry = ichg_new;
		pwr_ctrl->ichg_avg_buf[pwr_ctrl->ichg_ring_ptr++] = ichg_entry;
		if (pwr_ctrl->ichg_ring_ptr >= ICHG_AVG_WINDOW)
			pwr_ctrl->ichg_ring_ptr = 0;
	}
	ichg_accum = 0;
	for (i = 0; i < pwr_ctrl->ichg_fill_level; i++)
		ichg_accum += pwr_ctrl->ichg_avg_buf[i];
	pwr_ctrl->ichg_average = ichg_accum / pwr_ctrl->ichg_fill_level;
	sprintf(trace, "CV charging: Vbat=%u Ichg=%u Ichg_avg=%u i2v=%u",
		pwr_ctrl->batt_mv, ichg_new, pwr_ctrl->ichg_average,
		pwr_ctrl->i2v_offset);
	rvf_send_trace(trace, strlen(trace), NULL_PARAM,
			RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
	if (pwr_ctrl->ichg_average >
	    (pwr_ctrl->config.end_current + pwr_ctrl->i2v_offset)) {
		pwr_ctrl->ichg_low_count = 0;
		return 0;
	}
	pwr_ctrl->ichg_low_count++;
	if (pwr_ctrl->ichg_low_count < pwr_ctrl->config.ichg_samples_needed)
		return 0;
	rvf_send_trace("Stopping charge by low current condition", 40,
			NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH, FCHG_USE_ID);
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
	pwr_init_discharge();
	pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
	if (pwr_ctrl->event_handler)
		pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_COMPLETE);
	return 1;
}

static int overvoltage_end_charge_check(void)
{
	if (pwr_ctrl->batt_mv < pwr_ctrl->config.overvoltage)
		return 0;
	if (pwr_ctrl->cv_dac_curr !=
	    (pwr_ctrl->cv_dac_init - pwr_ctrl->config.cv_dac_max_decr))
		return 0;
	rvf_send_trace("Stopping charge by overvoltage condition", 40,
			NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
	pwr_init_discharge();
	pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
	if (pwr_ctrl->event_handler)
		pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_COMPLETE);
	return 1;
}

static void cv_ctrl_loop_high_check(void)
{
	if (pwr_ctrl->batt_mv < pwr_ctrl->config.cv_ctrl_loop_high) {
		pwr_ctrl->cv_high_vbat_count = 0;
		return;
	}
	pwr_ctrl->cv_high_vbat_count++;
	if (pwr_ctrl->cv_high_vbat_count < pwr_ctrl->config.cv_samples_needed)
		return;
	if (pwr_ctrl->cv_dac_curr ==
	    (pwr_ctrl->cv_dac_init - pwr_ctrl->config.cv_dac_max_decr))
		return;
	pwr_ctrl->cv_dac_curr--;
	ABB_Write_Register_on_page(PAGE0, CHGREG, pwr_ctrl->cv_dac_curr);
	rvf_send_trace("Sub CV DAC", 10, pwr_ctrl->cv_dac_curr,
			RV_TRACE_LEVEL_DEBUG_MEDIUM, FCHG_USE_ID);
	pwr_ctrl->cv_high_vbat_count = 0;
}

static void cv_ctrl_loop_low_check(void)
{
	if (pwr_ctrl->batt_mv >= pwr_ctrl->config.cv_ctrl_loop_low) {
		pwr_ctrl->cv_low_vbat_count = 0;
		return;
	}
	pwr_ctrl->cv_low_vbat_count++;
	if (pwr_ctrl->cv_low_vbat_count < pwr_ctrl->config.cv_samples_needed)
		return;
	if (pwr_ctrl->cv_dac_curr ==
	    (pwr_ctrl->cv_dac_init + pwr_ctrl->config.cv_dac_max_incr))
		return;
	pwr_ctrl->cv_dac_curr++;
	ABB_Write_Register_on_page(PAGE0, CHGREG, pwr_ctrl->cv_dac_curr);
	rvf_send_trace("Add CV DAC", 10, pwr_ctrl->cv_dac_curr,
			RV_TRACE_LEVEL_DEBUG_MEDIUM, FCHG_USE_ID);
	pwr_ctrl->cv_low_vbat_count = 0;
}

static int charging_time_limit_check(void)
{
	if ((rvf_get_tick_count() - pwr_ctrl->start_time) <
	    RVF_SECS_TO_TICKS(pwr_ctrl->config.charge_time_limit))
		return 0;
	rvf_send_trace("Stopping charge by time exceeded condition", 42,
			NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
	pwr_init_discharge();
	pwr_ctrl->state = FCHG_STATE_RECHARGE_TIMER;
	pwr_ctrl->start_time = rvf_get_tick_count();
	if (pwr_ctrl->event_handler)
		pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_TIMEOUT);
	return 1;
}

static void process_adc_regular(struct pwr_adc_ind_s *msg)
{
	switch (pwr_ctrl->state) {
	case FCHG_STATE_NO_EXT_PWR:
	case FCHG_STATE_PWR_PLUG_TIMER:
	case FCHG_STATE_NO_CHARGING:
		handle_discharge();
		return;
	case FCHG_STATE_READY_TO_CHARGE:
		handle_discharge();
		if (!(msg->data[9] & CHGPRES)) {
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			return;
		}
		if (pwr_ctrl->batt_mv < pwr_ctrl->config.start_thresh)
			start_charge_condition_met();
		return;
	case FCHG_STATE_READY_TO_RECHARGE:
		handle_discharge();
		if (!(msg->data[9] & CHGPRES)) {
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			return;
		}
		if (pwr_ctrl->batt_mv < pwr_ctrl->config.restart_thresh)
			start_charge_condition_met();
		return;
	case FCHG_STATE_I2V_CAL_1:
		if (!(msg->data[9] & CHGPRES)) {
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			return;
		}
		if (pwr_ctrl->config.bciconf)
			start_i2v_cal();
		else {
			pwr_ctrl->i2v_offset = 0;
			start_ci_charging();
		}
		return;
	case FCHG_STATE_I2V_CAL_2:
		pwr_ctrl->i2v_offset = msg->data[2];
		ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
		rvf_send_trace("i2v offset (MADC code) ", 23,
				pwr_ctrl->i2v_offset,
				RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
		if (!(msg->data[9] & CHGPRES)) {
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			pwr_init_discharge();
			return;
		}
		start_ci_charging();
		return;
	case FCHG_STATE_CI_CHARGING:
		ci_progress_trace(msg->data[2]);
		if (!(msg->data[9] & CHGPRES)) {
			ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			pwr_init_discharge();
			return;
		}
		if (charging_time_limit_check())
			return;
		if (pwr_ctrl->batt_mv >= pwr_ctrl->config.ci2cv_thresh)
			start_cv_charging();
		return;
	case FCHG_STATE_CV_CHARGING:
		if (!(msg->data[9] & CHGPRES)) {
			ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
			pwr_init_discharge();
			return;
		}
		if (cv_ichg_process(msg->data[2]))
			return;
		if (overvoltage_end_charge_check())
			return;
		if (charging_time_limit_check())
			return;
		cv_ctrl_loop_high_check();
		cv_ctrl_loop_low_check();
		return;
	case FCHG_STATE_RECHARGE_TIMER:
		handle_discharge();
		if ((rvf_get_tick_count() - pwr_ctrl->start_time) <
		    RVF_SECS_TO_TICKS(pwr_ctrl->config.recharge_delay))
			return;
		rvf_send_trace("Restart time met, allowing new charging", 39,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_READY_TO_RECHARGE;
		return;
	default:
		rvf_send_trace("Invalid state in pwr_process_adc()", 34,
				pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
				FCHG_USE_ID);
	}
}

static void process_adc_bsim(struct pwr_adc_ind_s *msg)
{
	switch (pwr_ctrl->state) {
	case FCHG_STATE_READY_TO_CHARGE:
		if (!pwr_ctrl->bsim.start_enable)
			return;
		rvf_send_trace("BSIM: simulated charging auto-start", 35,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_MEDIUM,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_I2V_CAL_1;
		return;
	case FCHG_STATE_I2V_CAL_1:
		rvf_send_trace("BSIM: advancing from I2V_CAL_1 to I2V_CAL_2",
				43, NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_I2V_CAL_2;
		return;
	case FCHG_STATE_I2V_CAL_2:
		rvf_send_trace("BSIM: advancing from I2V_CAL_2 to CI charging",
				45, NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_CI_CHARGING;
		if (pwr_ctrl->event_handler)
			pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_START);
		return;
	default:
		/* remaining states require no action in BSIM */
		return;
	}
}

void pwr_process_adc(struct pwr_adc_ind_s *msg)
{
	pwr_ctrl->batt_mv = madc_vbat_2_physical(msg->data[0]);
	if (!fchg_first_vbat)
		capture_first_vbat();
	if (pwr_ctrl->bsim_mode)
		process_adc_bsim(msg);
	else
		process_adc_regular(msg);
}

void pwr_charger_plug_unplug_ind(void)
{
	switch (pwr_ctrl->state) {
	case FCHG_STATE_NO_EXT_PWR:
		rvf_send_trace("Charger plug interrupt, beginning debounce",
				42, NULL_PARAM, RV_TRACE_LEVEL_DEBUG_LOW,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_PWR_PLUG_TIMER;
		break;
	case FCHG_STATE_PWR_PLUG_TIMER:
		/* debouncing in action - nothing to do here */
		break;
	case FCHG_STATE_READY_TO_CHARGE:
	case FCHG_STATE_READY_TO_RECHARGE:
	case FCHG_STATE_I2V_CAL_1:
	case FCHG_STATE_RECHARGE_TIMER:
	case FCHG_STATE_NO_CHARGING:
		rvf_send_trace("Charger unplug", 14, NULL_PARAM,
				RV_TRACE_LEVEL_DEBUG_LOW, FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_PWR_PLUG_TIMER;
		if (pwr_ctrl->event_handler)
			pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_UNPLUG);
		break;
	case FCHG_STATE_I2V_CAL_2:
	case FCHG_STATE_CI_CHARGING:
	case FCHG_STATE_CV_CHARGING:
		ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
		rvf_send_trace("Charger unplug, charging stopped", 32,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_PWR_PLUG_TIMER;
		pwr_init_discharge();
		if (pwr_ctrl->event_handler)
			pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_UNPLUG);
		break;
	default:
		rvf_send_trace("Invalid state in pwr_charger_plug_unplug_ind()",
				46, pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
				FCHG_USE_ID);
	}
	rvf_start_timer(FCHG_TIMER, RVF_MS_TO_TICKS(CHARGER_PLUG_DEBOUNCE_MS),
			FALSE);
	/* unmask further charger interrupts */
	ABB_Write_Register_on_page(PAGE0, ITMASK, 0);
}

void pwr_handle_timer(void)
{
	SYS_UWORD16 abb_status;

	if (pwr_ctrl->state != FCHG_STATE_PWR_PLUG_TIMER) {
		rvf_send_trace(
			"Charger debounce timer expired in unexpected state",
				50, pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
				FCHG_USE_ID);
		return;
	}
	/* so was it a plug or an unplug after all? */
	abb_status = ABB_Read_Status();
	if (abb_status & CHGPRES) {
		/* charger plug */
		if (pwr_ctrl->config_present || pwr_ctrl->bsim_mode) {
			rvf_send_trace("Charger plug, ready to charge", 29,
					NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
					FCHG_USE_ID);
			pwr_ctrl->state = FCHG_STATE_READY_TO_CHARGE;
			if (pwr_ctrl->event_handler)
			    pwr_ctrl->event_handler(FCHG_EVENT_CHARGER_PLUG);
		} else {
			rvf_send_trace(
			"Charger plugged in, but no config: won't charge", 47,
				NULL_PARAM, RV_TRACE_LEVEL_ERROR, FCHG_USE_ID);
			pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
		}
	} else {
		/* charger unplug, already handled */
		pwr_ctrl->state = FCHG_STATE_NO_EXT_PWR;
	}
}

void pwr_charge_start_req(void)
{
	switch (pwr_ctrl->state) {
	case FCHG_STATE_NO_EXT_PWR:
	case FCHG_STATE_PWR_PLUG_TIMER:
		rvf_send_trace("Cannot charge without a power source", 36,
				NULL_PARAM, RV_TRACE_LEVEL_ERROR, FCHG_USE_ID);
		return;
	case FCHG_STATE_NO_CHARGING:
		if (!pwr_ctrl->config_present && !pwr_ctrl->bsim_mode) {
			rvf_send_trace("No config set, cannot charge", 28,
					NULL_PARAM, RV_TRACE_LEVEL_ERROR,
					FCHG_USE_ID);
			return;
		}
		/* FALL THRU */
	case FCHG_STATE_READY_TO_CHARGE:
	case FCHG_STATE_READY_TO_RECHARGE:
	case FCHG_STATE_RECHARGE_TIMER:
		rvf_send_trace("Starting charge on user request", 31,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_I2V_CAL_1;
		return;
	case FCHG_STATE_I2V_CAL_1:
	case FCHG_STATE_I2V_CAL_2:
	case FCHG_STATE_CI_CHARGING:
	case FCHG_STATE_CV_CHARGING:
		rvf_send_trace(
			"Charging already in progress, start request ignored",
			51, NULL_PARAM, RV_TRACE_LEVEL_WARNING, FCHG_USE_ID);
		return;
	default:
		rvf_send_trace("Invalid state in pwr_charge_start_req()", 39,
				pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
				FCHG_USE_ID);
	}
}

void pwr_charge_stop_req(void)
{
	switch (pwr_ctrl->state) {
	case FCHG_STATE_NO_EXT_PWR:
	case FCHG_STATE_PWR_PLUG_TIMER:
	case FCHG_STATE_NO_CHARGING:
		/* nothing to do */
		return;
	case FCHG_STATE_READY_TO_CHARGE:
	case FCHG_STATE_READY_TO_RECHARGE:
	case FCHG_STATE_I2V_CAL_1:
	case FCHG_STATE_RECHARGE_TIMER:
		rvf_send_trace("Charging disabled by user request", 33,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
		return;
	case FCHG_STATE_I2V_CAL_2:
	case FCHG_STATE_CI_CHARGING:
	case FCHG_STATE_CV_CHARGING:
		ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
		rvf_send_trace("Charging stopped by user request", 32,
				NULL_PARAM, RV_TRACE_LEVEL_DEBUG_HIGH,
				FCHG_USE_ID);
		pwr_ctrl->state = FCHG_STATE_NO_CHARGING;
		pwr_init_discharge();
		if (pwr_ctrl->event_handler)
			pwr_ctrl->event_handler(FCHG_EVENT_CHARGING_STOPPED);
		return;
	default:
		rvf_send_trace("Invalid state in pwr_charge_stop_req()", 38,
				pwr_ctrl->state, RV_TRACE_LEVEL_ERROR,
				FCHG_USE_ID);
	}
}