lcc_handle_message.c

是一个手机功能的模拟程序

		error = ffs_fwrite("/mmi/pwr/bsie.cfg", &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr, "Wrote %d bytes = %d" NL, error));
		break;
	case PWR_I2V_CAL :
		// Write the /pwr/i2v.cal file
		error = ffs_fwrite("/pwr/i2v.cal", &msg->data[2], PWR_I2V_CAL_SIZE);
		ttw(ttr(TTrTmpwr,"Wrote %d bytes" NL, PWR_I2V_CAL_SIZE));
		break;
	case PWR_VBAT_CAL:
		// Write the /pwr/vbat.cal file
		error = ffs_fwrite("/pwr/vbat.cal", &msg->data[2], PWR_VBAT_CAL_SIZE);
		ttw(ttr(TTrTmpwr,"Wrote %d bytes" NL, PWR_VBAT_CAL_SIZE));
		break;
	case PWR_MMI_TEST :
		break;
	case PWR_TRACE_MASK:
		// Write the trace mask of the PWR module 
		memcpy(&pwr_ctrl->tmask, &msg->data[2], sizeof(pwr_ctrl->tmask));
		ttw(ttr(TTrTmpwr,"Wrote tmask %d" NL, pwr_ctrl->tmask));
		pwr_ttr_init(pwr_ctrl->tmask);
		break;
	default :
		{
			// Unknown index
			error = PWR_INDEX;
			ttr(TTrWarning, "Unknown index! %d" NL, index);
		}
	}

	msg->size = 1; // Size of write message reply is always 1

	if (error < 0)
		msg->status = -error;

	// Pack - re-use the buffer allocated in ETM
	// De-allocate in ETM
	msg->header.msg_id        = PWR_TM_WRITE_IND;
	msg->header.src_addr_id   = pwr_ctrl->addr_id;
	msg->header.dest_addr_id  = etm_env_ctrl_blk->addr_id;
	msg->header.callback_func = NULL;

	// Send indication with status & data to ETM task
	if (error = rvf_send_msg(etm_env_ctrl_blk->addr_id, msg) != RV_OK)
	{
		ttr(TTrFatal, "PWR FATAL: Send failed! %d" NL, error);
		return PWR_RV_FATAL;
	}
	ttw(ttr(TTrTmpwr,"pwtw (%d)" NL, 0xFF));
	return RV_OK;
}


T_RV_RET process_abb_chg_unplugged_ind       (T_PWR_REQ *request)
{

	charger_unplug_house_keeping(); 
	// Disable charger interrupts - they where enabled when the CI charger was connected
#if (LCC_ALWAYS_MMI_INFO == 0)	/* Robert.Chen added, 2004-05-28 */
	ABB_Write_Register_on_page(PAGE0, ITMASK, CHARGER_IT_MSK);
#endif

	// A charger can be unplugged in any state
	switch (pwr_ctrl->state)
	{
	case SUP :
	case CCI :
	case CCV :
		// Change state - T3 is running
		pwr_ctrl->state = SUP;
		break;
#if (LCC_ALWAYS_MMI_INFO == 1)	/* Robert.Chen added, 2004-05-28 */
	case PRE :
		pwr_ctrl->state = INI;
		break;
#endif
		
	default :
		{
			// Exception Handling - Unknown State
			ttr(TTrFatal, "process_abb_chg_unplugged_ind: Unknown State: %d" NL, pwr_ctrl->state);
		}
	}
	pwr_free(request);
	return RV_OK;
}

void pwr_send_msg(uint32 msg_id, T_RVF_ADDR_ID src_addr_id, T_RVF_ADDR_ID  dest_addr_id) {
	struct pwr_req_s *msg;

	if ((msg = pwr_malloc(sizeof(struct pwr_req_s))) == NULL)
	{
		return;
	}
	msg->header.msg_id        = msg_id;
	msg->header.src_addr_id   = src_addr_id;
	msg->header.dest_addr_id  = dest_addr_id;
	msg->header.callback_func = NULL;
	if (rvf_send_msg(dest_addr_id, msg) != RV_OK)
	{
		ttr(TTrFatal, "PWR FATAL: Send failed! %d" NL, 0xFF);
	}
}

void mmi_send_msg(struct mmi_info_ind_s *event) 
{
	ttw(ttr(TTrInit,"mmi_send_msg(%d)" NL, 0));
	if (pwr_ctrl->rpath.callback_func)
	{
		ttw(ttr(TTrInit,"Using callback (0x%x)" NL, pwr_ctrl->rpath.callback_func));
		(pwr_ctrl->rpath.callback_func) (event);
	}
	else
	{
		if (pwr_ctrl->rpath.addr_id)
		{
			// TESTME
			rvf_send_msg(pwr_ctrl->rpath.addr_id, event);
		}
		else
		{
			ttr(TTrFatal,"PWR FATAL: mmi_send_msg(%d) No return path" NL, 0xFF);
			return;
		}
	}
	ttw(ttr(TTrInit,"mmi_send_msg(%d)" NL, 0xFF));
}

void start_pre_charge(void) {
	unsigned short	reg; 
	ttw(ttr(TTrInitLow,"start_pre_charge" NL, 0x00));
#if (USE_Q401_CHG_CIRCUIT == 1)
	/* Program the DAC with the constant current value */
	// Value is hardcoded!! No configuration exist for state PRE
	#if 0
	ABB_Write_Register_on_page(PAGE0,BCICTL2,0); 
	ABB_Write_Register_on_page(PAGE0,BCICTL2,0x4); 
	ABB_Write_Register_on_page(PAGE0,BCICTL2,0x25);
	reg = ABB_Read_Register_on_page(PAGE0, BCICTL2);
	ttr(0xffffffff, "BCICTL2=0x%2X" NL, reg);
	return;
	#endif
	/* Robert.Chen add */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0002);
	
	ABB_Write_Register_on_page(PAGE0, CHGREG, ICHG_PRECHG);

	/* Enable the charger  */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003);
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
	pwr_modulate_init();
#endif
	ttw(ttr(TTrInitLow,"start_pre_charge" NL, 0xFF));

}

void start_q401_charge(void) {

	ttw(ttr(TTrInitLow,"start_q401_charge" NL, 0x00));
	if (pwr_ctrl->flag_mmi_registered == 1)
	{
		pwr_ctrl->mmi_ptr->header.msg_id = MMI_CHG_START_IND;
		mmi_send_msg(pwr_ctrl->mmi_ptr);
	}

	/* Robert.Chen add */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0002);
	
	/* Program the DAC with the constant current value taken from /pwr/chg/chg<N>.cfg */
	ABB_Write_Register_on_page(PAGE0, CHGREG, pwr_cfg->chg.ichg_max);

	/* Enable the CI charger  */
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003);

	/* If not already started - start the overall charger timer T1 */
	if (pwr_ctrl->time_begin_T1 == 0)
	{
		pwr_start_timer(&pwr_ctrl->time_begin_T1);
		ttw(ttr(TTrTimerLow,"T1 started(%d)" NL, 0));
	}
	ttw(ttr(TTrInitLow,"start_q401_charge" NL, 0xFF));

}

void start_q402_charge(void) {

	ttw(ttr(TTrInitLow,"start_q402_charge(%d)" NL, 0x00));
	if (pwr_ctrl->flag_mmi_registered == 1)
	{
		pwr_ctrl->mmi_ptr->header.msg_id = MMI_CHG_START_IND;
		mmi_send_msg(pwr_ctrl->mmi_ptr);
	}

	// Needed if we want Ichg measurements - else they are disabled!!
	ABB_Write_Register_on_page(PAGE0, CHGREG, pwr_cfg->chg.ichg_max);
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0x0003);

	pwr_modulate_init();

	/* If not already started - start the overall charger timer T1 */
	if (pwr_ctrl->time_begin_T1 == 0)
	{
		pwr_start_timer(&pwr_ctrl->time_begin_T1);
		ttw(ttr(TTrTimerLow,"T1 started(%d)" NL, 0));
	}
	ttw(ttr(TTrInitLow,"start_q402_charge(%d)" NL, 0xFF));

}

void stop_q401_charge(void) {

	ttw(ttr(TTrInitLow,"stop_q401_charge(%d)" NL, 0x00));
	if (pwr_ctrl->flag_mmi_registered == 1)
	{
		pwr_ctrl->mmi_ptr->header.msg_id = MMI_CHG_STOP_IND;
		mmi_send_msg(pwr_ctrl->mmi_ptr);
	}
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);
	ttw(ttr(TTrInitLow,"stop_q401_charge(%d)" NL, 0xFF));

}

void stop_q402_charge(void) {

	ttw(ttr(TTrInitLow,"stop_q402_charge(%d)" NL, 0x00));
	if (pwr_ctrl->flag_mmi_registered == 1)
	{
		pwr_ctrl->mmi_ptr->header.msg_id = MMI_CHG_STOP_IND;
		mmi_send_msg(pwr_ctrl->mmi_ptr);
	}
	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);

	pwr_modulate_off();
	ttw(ttr(TTrInitLow,"stop_q402_charge(%d)" NL, 0xFF));

}

void stop_pre_charge(void) {

	ABB_Write_Register_on_page(PAGE0, BCICTL2, 0);

}

int check_chg_unplug() {
	int i;

#if (USE_Q401_CHG_CIRCUIT == 1)
	// Check that the latest values of charger status confirm that we have a charger unplug
	// Search through the vector - charger is only assumed unplugged when ALL CONSECUTIVE_CHG_UNPLUGS elements are 0
	// Returns 1 (TRUE) if the charger is assumed unplugged
	// Returns 0 (FALSE) if the charger is assumed plugged
	// Assume that the charger unplug was true if the battery voltage is sufficiently high
	if (pwr_cfg->data.Vbat_avg_mV < VBAT_PRECHG_STOP)
	{
		for (i=0;i<= CONSECUTIVE_CHG_UNPLUGS-1 ;i++)
		{
			ttw(ttr(TTrTimerLow,"chg_unplug_vec(%d)" NL, pwr_ctrl->chg_unplug_vec[i]));
			if (pwr_ctrl->chg_unplug_vec[i] != 0)
				return 0;
		}
	}
	return 1;
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
	// Assume that the charger unplug was true if BOTH the charger voltage & charger current 
	// are below configurable Vchg & Ichg threshold values
	if ((pwr_cfg->data.Vchg < VCHG_Q402_THR) && (pwr_cfg->data.Ichg < ICHG_Q402_THR))
	{
		ttw(ttr(TTrInitLow,"check_chg_unplug: Vchg=(%d)" NL, pwr_cfg->data.Vchg));
		ttw(ttr(TTrInitLow,"check_chg_unplug: Ichg=(%d)" NL, pwr_cfg->data.Ichg));
		return 1;
	}
	return 0;
#endif
}

void charger_unplug_house_keeping(void) {
	// Flag the charger unplug
	pwr_ctrl->flag_chg_plugged = 0;
	pwr_ctrl->flag_chg_prev_plugged = 0;

	// Read charger configuration next time charger is inserted
	pwr_ctrl->flag_chg_cfg_read = 0;

	// We must have more charger id measurements if the charger is re-connected
	pwr_ctrl->count_chg_type = 0;

	if (pwr_ctrl->flag_mmi_registered == 1)
	{
		// Send charger unplug to the MMI
		pwr_ctrl->mmi_ptr->header.msg_id = MMI_CHG_UNPLUG_IND;
		mmi_send_msg(pwr_ctrl->mmi_ptr);

		// Re-start the mmi info repetition timer
	#if (LCC_ALWAYS_MMI_INFO == 0)	/* Robert.Chen add, 2004-05-28 */
		pwr_start_timer(&pwr_ctrl->time_begin_mmi_rep);
	#endif
	}

	// if T1 or T2 is running (which mean we have NOT had a normal charging stop)
	if ((pwr_ctrl->time_begin_T1 != 0) || (pwr_ctrl->time_begin_T2 != 0))
	{
		// Start T3 timer if not already started
		if (pwr_ctrl->time_begin_T3 == 0)
		{
			pwr_start_timer(&pwr_ctrl->time_begin_T3);
			ttw(ttr(TTrTimerLow,"T3 started(%d)" NL, 0));
		}
		// Switch of charging circuit

#if (USE_Q401_CHG_CIRCUIT == 1)
		stop_q401_charge();
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
		stop_q402_charge();
#endif
	}
}

void cv_charging_house_keeping(void) {
	// Calculate k value
	// Start DC timer
	// Start T4 timer based on k value
	// Modulation ON
	ttw(ttr(TTrTimerLow,"Vbat_avg, chg_start_thr, chg_stop_thr (%d), (%d), (%d)" NL, pwr_cfg->data.Vbat_avg_mV, pwr_cfg->bat.chg_start_thr, pwr_cfg->bat.chg_stop_thr));
#if 0	/* Robert.Chen replaced, 2004-05-28 */
	if ((pwr_cfg->data.Vbat_avg_mV - pwr_cfg->bat.chg_start_thr) <= 0)
	{
		// Assign k to max value if Vbat_avg value is below start value
		pwr_cfg->data.k = PWR_MAX_K;
	}
	else
	{
		pwr_cfg->data.k = (255 * (pwr_cfg->bat.chg_stop_thr - pwr_cfg->data.Vbat_avg_mV) / (pwr_cfg->bat.chg_stop_thr - pwr_cfg->bat.chg_start_thr));
		if (pwr_cfg->data.k <= PWR_MIN_K)
			pwr_cfg->data.k = PWR_MIN_K;
	}
#else
	if(pwr_cfg->data.Vbat_avg_mV >= pwr_cfg->bat.chg_stop_thr || cv_overflow)
	//if(ADC_to_mV(pwr_cfg->data.Vbat) >= pwr_cfg->bat.chg_stop_thr)
	{

		cv_overflow = 0;
		if(pwr_cfg->data.k >= pwr_cfg->bat.chg_ctrl_thr)
		{
		#if 0
			pwr_cfg->data.k = PWR_MAX_K / (1 + cv_stage); 
			cv_stage ++;
		#else
			cv_stage++;
			pwr_cfg->data.k = PWR_MAX_K - 100 * cv_stage;
			if(pwr_cfg->data.k <= pwr_cfg->bat.chg_ctrl_thr)
			{
				pwr_cfg->data.k = pwr_cfg->bat.chg_ctrl_thr - 1;
				cv_stage--;
			}	
		#endif			
		}
	}	
	else if(pwr_cfg->data.Vbat_avg_mV <= (pwr_cfg->bat.chg_start_thr - 100))
	{
		if(cv_stage > 0)
			cv_stage--;
	#if 0	 
		pwr_cfg->data.k = PWR_MAX_K / (1 + cv_stage);
	#else
		pwr_cfg->data.k = PWR_MAX_K - 100 * cv_stage;
	#endif
	}
	else if(cv_stage == 0)	/* first cv stage */
	{
		pwr_cfg->data.k = PWR_MAX_K;
	}
	
#endif	

	/* Robert.Chen added, 2004-05-29, fix TI bug, ensure start the CV timer only once during CV charging */
	if(pwr_ctrl->time_begin_T2 == 0)
	/* add end */
		pwr_start_timer(&pwr_ctrl->time_begin_T2);
		
	ttw(ttr(TTrTimerLow,"T2 started(%d)" NL, 0));

	//ttw(ttr(TTrTimerLow, "k=%d" NL, pwr_cfg->data.k));
	ttw(ttr(0xff000000, "k=%d" NL, pwr_cfg->data.k));	//Robert.Chen modified
	pwr_cfg->data.T4 = pwr_cfg->data.k * pwr_cfg->common.mod_cycle/255;
	ttw(ttr(TTrTimerLow,"T4 timer (%d)" NL, pwr_cfg->data.T4));

	ttw(ttr(TTrTimerLow,"DC started(%d)" NL, 0));
	pwr_start_timer(&pwr_ctrl->time_begin_mod_cycle);

	ttw(ttr(TTrTimerLow,"T4 started(%d)" NL, 0));
	pwr_start_timer(&pwr_ctrl->time_begin_T4);

	pwr_modulate_on();
}

void end_charging_house_keeping(void) {
	// Stop & reset timers
	pwr_stop_timers();

	// Stop charging
#if (USE_Q401_CHG_CIRCUIT == 1)
	stop_q401_charge();
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
	stop_q402_charge();
#endif

	// Start the mmi info repetition timer
#if (LCC_ALWAYS_MMI_INFO == 0)	/* Robert.Chen add, 2004-05-28 */
	if (pwr_ctrl->flag_mmi_registered == 1)
		pwr_start_timer(&pwr_ctrl->time_begin_mmi_rep);
#endif

	// Read charger configuration next time charger is inserted
	pwr_ctrl->flag_chg_cfg_read = 0;
}

#if (TEST_PWR_MMI_INTERFACE == 1)
// Callback function used for testing MMI reporting
static void mmi_test_cb_function(void *ptr) {
	T_PWR_MMI_INFO_IND_EVENT *event;


	event = (T_PWR_MMI_INFO_IND_EVENT *)ptr;

	ttw(ttr(TTrInit, "mmi_test_cb_function (%d)" NL, 0));
	ttw(ttr(TTrInit, "MMI event: (%d)" NL, event->header.msg_id));
	ttw(ttr(TTrInit, "mmi_test_cb_function (%d)" NL, 0xFF));
}
#endif