lcc_handle_message.c

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

				#endif

				#if (USE_Q402_CHG_CIRCUIT == 1)
					start_q402_charge();
				#endif

					// Stop the mmi info repetition timer
				#if (LCC_ALWAYS_MMI_INFO == 0)	/* Robert.Chen add, 2004-05-28 */
					pwr_stop_timer(&pwr_ctrl->time_begin_mmi_rep);
				#endif
				}
			}
			else
			{
				pwr_ctrl->count_chg_type++;
				ttw(ttr(TTrEventLow,"count_chg_type=%d" NL, pwr_ctrl->count_chg_type));
			}
		}
		break;
	case CCI :
		MI_dbgPrintf("zhq: we entered CCI state.");
		pwr_check_timers();
		// We are in the middle of a CI charging process - check stop criterias
		//
		if (pwr_chg_stop(pwr_temp_lookup(pwr_cfg->data.Tbat_avg, 0x01), pwr_cfg->data.Vbat_avg_mV) == FALSE)
		{
			// Continue to charge - change state?
			/* Robert.Chen modified, 2004-05-29 */
			if ((pwr_cfg->bat.type == LITHIUM) && (pwr_chg_ci_cv_transition(pwr_cfg->data.Vbat_avg_mV)== TRUE))
			//if ((pwr_cfg->bat.type == LITHIUM) && (pwr_chg_ci_cv_transition(ADC_to_mV(pwr_cfg->data.Vbat))== TRUE))
			{
				// Change state to CCV
				// Calculate k value
				// Start T2 timer
				// Start DC timer
				// Start T4 timer based on k value
				// Modulation ON
				pwr_ctrl->state = CCV;
				cv_stage = 0;
				cv_charging_house_keeping();
			}
		}
		else
		{
			// Change state
			pwr_ctrl->state = SUP;
			end_charging_house_keeping();

		}
		break;
	case LCI :
		// Poll ABB for charger unplug - Linear - unregulated chargers ONLY
		status = ind->data[State];
		pwr_ctrl->chg_unplug_vec[index] = (status & CHGPRES);
		if (status & CHGPRES)
		{
			// Charger is still plugged - continue
			ttw(ttr(TTrEventLow,"Polled - chg plugged (%d)" NL, status));
		}
		else
		{
			if (check_chg_unplug() == 1)
			{
				// Charger is not plugged anymore - stop!!
				ttw(ttr(TTrEventLow,"Verdict - chg not plugged (%d)" NL, status));
				// Change state
				pwr_ctrl->state = SUP;
				charger_unplug_house_keeping(); 
				pwr_free(request);
				return;
			}
			else
			{
				// False alarm - don't set flags
				ttw(ttr(TTrEventLow,"Polled - chg not plugged - FALSE alarm? (%d)" NL, status));
#if (USE_Q401_CHG_CIRCUIT == 1)
				if ((ind->data[Ichg] == 0) && (pwr_cfg->data.Vchg > 0))
				{
					// Charging current has disappeared due to a fast unplug??? Bug in IOTA ABB?
					pwr_ctrl->state = SUP;
					charger_unplug_house_keeping(); 
					pwr_free(request);
					return;
				}
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
				// FIXME: Really no false alarm code for Q402??
#endif

			}
		}
		pwr_check_timers();

		// We are in the middle of a CI charging process - check stop criterias
		if (pwr_chg_stop(pwr_temp_lookup(pwr_cfg->data.Tbat_avg, 0x01), pwr_cfg->data.Vbat_avg_mV) == FALSE)
		{
			// Continue to charge - change state?
			if ((pwr_cfg->bat.type == LITHIUM) && (pwr_chg_ci_cv_transition(pwr_cfg->data.Vbat_avg_mV)== TRUE))
			{
				// Change state to LCV
				// Calculate k value
				// Start T2 timer
				// Start DC timer
				// Start T4 timer based on k value
				// Modulation ON
				pwr_ctrl->state = LCV;
				cv_charging_house_keeping();
			}
		}
		else
		{

			// Change state
			pwr_ctrl->state = SUP;
			end_charging_house_keeping();

		}
		break;
	case CCV :
		MI_dbgPrintf("zhq: we entered CCV state.");
		pwr_check_timers();
		// We are in the middle of a CV charging process - check stop criterias
		if (pwr_chg_stop(pwr_temp_lookup(pwr_cfg->data.Tbat_avg, 0x01), pwr_cfg->data.Vbat_avg_mV) == FALSE)
		{
			// EMPTY - waiting for T4 and DC timeouts OR T2 timeout
		}
		else
		{
			// Change state
			pwr_ctrl->state = SUP;
			end_charging_house_keeping();
		}
		break;
	case LCV :
		// Poll ABB for charger unplug - Linear - unregulated chargers ONLY
		status = ind->data[State];
		pwr_ctrl->chg_unplug_vec[index] = (status & CHGPRES);
		if (status & CHGPRES)
		{
			// Charger is still plugged - continue
			ttw(ttr(TTrEventLow,"Polled - chg plugged (%d)" NL, status));
		}
		else
		{
#if (USE_Q401_CHG_CIRCUIT == 1)
			// Charger is not plugged anymore - stop!!
			ttw(ttr(TTrEventLow,"Verdict - chg not plugged (%d)" NL, status));
			// Change state
			pwr_ctrl->state = SUP;
			charger_unplug_house_keeping(); 
			pwr_free(request);
			return;
#endif
#if (USE_Q402_CHG_CIRCUIT == 1)
			if (check_chg_unplug() == 1)
			{
				// Charger is not plugged anymore - stop!!
				ttw(ttr(TTrEventLow,"Verdict - chg not plugged (%d)" NL, status));
				// Change state
				pwr_ctrl->state = SUP;
				charger_unplug_house_keeping(); 
				pwr_free(request);
				return;
			}
#endif
		}
		pwr_check_timers();

		// We are in the middle of a CV charging process - check stop criterias
		if (pwr_chg_stop(pwr_temp_lookup(pwr_cfg->data.Tbat_avg, 0x01), pwr_cfg->data.Vbat_avg_mV) == FALSE)
		{
			// EMPTY - waiting for T4 and DC timeouts OR T2 timeout
		}
		else
		{
			// Change state
			pwr_ctrl->state = SUP;
			end_charging_house_keeping();
		}
		break;
	default :
		{
			// Exception Handling - Unknown State
			ttr(TTrFatal, "process_spi_adc_indication: Unknown State: %d" NL, pwr_ctrl->state);
		}
	}
	pwr_free(request);
	return RV_OK;
}


T_RV_RET process_pwr_tm_read_request         (T_PWR_REQ *request)
{
	// pwtr - see RD818

	int index, fid;
	T_FFS_SIZE error;
	T_FFS_STAT stat;
	struct etm_tm_ind_s *msg;
	extern T_ETM_ENV_CTRL_BLK *etm_env_ctrl_blk;
	char name[20];
#if (TEST_PWR_MMI_INTERFACE == 1)
	T_RV_RETURN_PATH return_path;
#endif

	ttw(ttr(TTrTmpwr,"pwtr (%d)" NL, 0));
	msg = (struct etm_tm_ind_s *)request;

	fid   = msg->data[0];
	index = msg->data[1];

	ttw(ttr(TTrTmpwr, "data[0]=%d" NL, msg->data[0]));
	ttw(ttr(TTrTmpwr, "data[1]=%d" NL, msg->data[1]));
	ttw(ttr(TTrTmpwr, "data[2]=%d" NL, msg->data[2]));
	ttw(ttr(TTrTmpwr, "data[3]=%d" NL, msg->data[3]));

	name[0] = 0; // FIXME: Really needed?
	msg->status = 0; // Default status is OK

	// All reads start from index 2 since the fid + index is kept
	switch (index)
	{
	case PWR_CFG_ID :
		// We can read different configurations swiching between them using pwtw
		msg->size = PWR_CFG_ID_SIZE;
		msg->data[2] = pwr_ctrl->cfg_id;
		msg->data[3] = pwr_ctrl->chg_cfg_id;
		ttw(ttr(TTrTmpwr,"Using cfg_id %d" NL, msg->data[2]));
		ttw(ttr(TTrTmpwr,"Using chg_cfg_id %d" NL, msg->data[3]));

		// If either the bat.cfg or the chg.cfg lacks object not found is returned

		// If (battery) file can't be stat'ed then the configuration doesn't exist
		build_name("/pwr/bat/bat", &pwr_cfg->data.cfg_id, 12, ".cfg", name);
		error = ffs_stat(name, &stat);

		// If charger file can't be stat'ed then the configuration doesn't exist
		build_name("/pwr/chg/chg", &pwr_cfg->data.chg_cfg_id, 12, ".cfg", name);
		error = ffs_stat(name, &stat);
		break;
	case PWR_COMMON :
		// Read the /pwr/common.cfg file
		// NOTE: sizeof(pwr_cfg->common) = 16 <>  (14 byte alignment)
		msg->size = PWR_COMMON_CFG_SIZE;
		error = ffs_fread("/pwr/common.cfg", &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_CHG :
		// Read the /pwr/chg/chg<cfgid>.cfg file
		msg->size = PWR_CHG_CFG_SIZE;
		build_name("/pwr/chg/chg", &pwr_cfg->data.chg_cfg_id, 12, ".cfg", name);
		error = ffs_fread(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr, "Read %d bytes " NL, error));
		break;
	case PWR_BAT :
		// Read the /pwr/bat/bat<cfgid>.cfg file
		msg->size = PWR_BAT_CFG_SIZE;
		build_name("/pwr/bat/bat", &pwr_cfg->data.cfg_id, 12, ".cfg", name);
		error = ffs_fread(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_TEMP :
		// Read the /pwr/bat/temp<cfgid>.cfg file
		msg->size = PWR_TEMP_CFG_SIZE;
		build_name("/pwr/bat/temp", &pwr_cfg->data.cfg_id, 13, ".cfg", name);
		error = ffs_fread(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_MMI:
		// Read the /mmi/pwr/bsie.cfg file
		msg->size = PWR_MMI_CFG_SIZE;
		error = ffs_fread("/mmi/pwr/bsie.cfg", &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_I2V_CAL :
		// Read the /pwr/i2v.cal file
		msg->size = PWR_I2V_CAL_SIZE;
		error = ffs_fread("/pwr/i2v.cal", &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_VBAT_CAL :
		// Read the /pwr/vbat.cal file
		msg->size = PWR_VBAT_CAL_SIZE;
		error = ffs_fread("/pwr/vbat.cal", &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr,"Read %d bytes" NL, error));
		break;
	case PWR_MMI_TEST :
#if (TEST_PWR_MMI_INTERFACE == 1)
// Trigger MMI registration 
		return_path.callback_func = mmi_test_cb_function;
		ttw(ttr(TTrInit,"before: &mmi_test_cb_function=(0x%x)" NL, return_path.callback_func));
		return_path.addr_id = NULL;	// FIXME??
		ttw(ttr(TTrTmpwr,"MMI testing callback: %d" NL, 0x0));
		msg->size = 1;
		msg->data[2] = 0xBA;
		pwr_register(&return_path, &mmi_data);
		ttw(ttr(TTrInit,"after: &mmi_test_cb_function=(0x%x)" NL, pwr_ctrl->rpath.callback_func));
		ttw(ttr(TTrTmpwr,"MMI testing callback: %d" NL, 0xFF));
#endif
		break;
	case PWR_DYNAMIC :
		// Dump 'dynamic' configuration data to trace
		msg->size = PWR_DYNAMIC_SIZE;
		msg->data[2] = 0xBA;
		ttr(TTrAll,"*PWR Module Version = 0x%x" NL, PWRVERSION );
		ttr(TTrAll,"*bat_id = %d" NL,               pwr_cfg->data.bat_id );
		ttr(TTrAll,"*state = %d" NL,                pwr_ctrl->state);
		ttr(TTrAll,"*chg_id = %d" NL,               pwr_cfg->data.chg_id );
		ttr(TTrAll,"*Vbat = %d" NL,                 pwr_cfg->data.Vbat);
		ttr(TTrAll,"*Vbat_avg = %d" NL,             pwr_cfg->data.Vbat_avg);
		ttr(TTrAll,"*Vbat_avg_mV = %d" NL,          pwr_cfg->data.Vbat_avg_mV);
		ttr(TTrAll,"*Tbat = %d" NL,                 pwr_cfg->data.Tbat);
		ttr(TTrAll,"*Tbat_avg = %d" NL,             pwr_cfg->data.Tbat_avg);
		ttr(TTrAll,"*Vchg = %d" NL,                 pwr_cfg->data.Vchg);
		ttr(TTrAll,"*Ichg = %d" NL,                 pwr_cfg->data.Ichg);
		ttr(TTrAll,"*Cbat = %d" NL,                 pwr_cfg->data.Cbat);
		ttr(TTrAll,"*cfg_id = %d" NL,               pwr_cfg->data.cfg_id);
		ttr(TTrAll,"*chg_cfg_id = %d" NL,           pwr_cfg->data.chg_cfg_id);
		ttr(TTrAll,"*bforce = %d" NL,               pwr_cfg->data.bforce);
		ttr(TTrAll,"*cforce = %d" NL,               pwr_cfg->data.cforce);
		ttr(TTrAll,"*k = %d" NL,                    pwr_cfg->data.k);
		ttr(TTrAll,"*T4 = %d" NL,                   pwr_cfg->data.T4);
		ttr(TTrAll,"*T1 elapsed = %d" NL,           pwr_ctrl->time_elapsed_T1);
		ttr(TTrAll,"*T2 elapsed = %d" NL,           pwr_ctrl->time_elapsed_T2);
		ttr(TTrAll,"*T3 elapsed = %d" NL,           pwr_ctrl->time_elapsed_T3);
		ttr(TTrAll,"*MMI timer elapsed = %d" NL,    pwr_ctrl->time_elapsed_mmi_rep);
		error = PWR_OK;
		break;
	case PWR_TRACE_MASK:
		// Read the trace mask of the PWR module 
		msg->size = PWR_TMASK_SIZE;
		memcpy(&msg->data[2], &pwr_ctrl->tmask, msg->size);
		ttw(ttr(TTrTmpwr,"tmask: 0x%x" NL, pwr_ctrl->tmask));
		break;
	default :
		{
			// Unknown index
			error = PWR_INDEX;
			ttr(TTrWarning, "Unknown index! %d" NL, index);
		}
	}

	ttw(ttr(TTrTmpwr, "data[0]=%d" NL, msg->data[0]));
	ttw(ttr(TTrTmpwr, "data[1]=%d" NL, msg->data[1]));
	ttw(ttr(TTrTmpwr, "data[2]=%d" NL, msg->data[2]));
	ttw(ttr(TTrTmpwr, "data[3]=%d" NL, msg->data[3]));
	ttw(ttr(TTrTmpwr, "data[4]=%d" NL, msg->data[4]));
	ttw(ttr(TTrTmpwr, "data[5]=%d" NL, msg->data[5]));

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

	// Pack - re-use the buffer allocated in ETM
	// De-allocate in ETM
	msg->header.msg_id        = PWR_TM_READ_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 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,"pwtr (%d)" NL, 0xFF));
	return RV_OK;

}


T_RV_RET process_pwr_tm_write_request        (T_PWR_REQ *request)
{
	int fid, index;
	// pwtw - see RD818
	T_FFS_SIZE error;
	struct etm_tm_ind_s *msg;
	extern T_ETM_ENV_CTRL_BLK *etm_env_ctrl_blk;
	char name[20];

	ttw(ttr(TTrTmpwr,"pwtw (%d)" NL, 0));
	msg = (struct etm_tm_ind_s *)request;

	fid   = msg->data[0];
	index = msg->data[1];
	name[0] = 0; // FIXME: Really needed?
	msg->status = 0; // Default status is OK

	ttw(ttr(TTrTmpwr, "data[0]=%d" NL, msg->data[0]));
	ttw(ttr(TTrTmpwr, "data[1]=%d" NL, msg->data[1]));
	ttw(ttr(TTrTmpwr, "data[2]=%d" NL, msg->data[2]));
	ttw(ttr(TTrTmpwr, "data[3]=%d" NL, msg->data[3]));

	switch (index)
	{
	case PWR_CFG_ID :
		// Write the configuration id to be used
		pwr_ctrl->cfg_id = msg->data[2];
		pwr_ctrl->chg_cfg_id = msg->data[3];
		pwr_cfg->data.cfg_id = pwr_ctrl->cfg_id + '0';
		pwr_cfg->data.chg_cfg_id = pwr_ctrl->chg_cfg_id + '0';
		ttw(ttr(TTrTmpwr,"Switched to bat id=%d" NL, pwr_ctrl->cfg_id));
		ttw(ttr(TTrTmpwr,"Switched to chg id=%d" NL, pwr_ctrl->chg_cfg_id));
		break;
	case PWR_COMMON :
		// Write the /pwr/common.cfg file
		// Blocking version of ffs_fwrite is used since this is a test mode command
		error = ffs_fwrite("/pwr/common.cfg", &msg->data[2], PWR_COMMON_CFG_SIZE);
		ttw(ttr(TTrTmpwr,"Wrote %d bytes" NL, error));
		break;
	case PWR_CHG :
		// Write the /pwr/chg/chg<cfgid>.cfg file
		msg->size = PWR_CHG_CFG_SIZE;
		build_name("/pwr/chg/chg", &pwr_cfg->data.chg_cfg_id, 12, ".cfg", name);
		error = ffs_fwrite(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr, "Wrote %d bytes = %d" NL, error));
		break;
	case PWR_BAT :
		// Write the /pwr/bat/bat<cfgid>.cfg file
		msg->size = PWR_BAT_CFG_SIZE;
		build_name("/pwr/bat/bat", &pwr_cfg->data.cfg_id, 12, ".cfg", name);
		error = ffs_fwrite(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr, "Wrote %d bytes = %d" NL, error));
		break;
	case PWR_TEMP :
		// Write the /pwr/bat/temp<cfgid>.cfg file
		msg->size = PWR_TEMP_CFG_SIZE;
		build_name("/pwr/bat/temp", &pwr_cfg->data.cfg_id, 13, ".cfg", name);
		error = ffs_fwrite(name, &msg->data[2], msg->size);
		ttw(ttr(TTrTmpwr, "Wrote %d bytes = %d" NL, error));
		break;
	case PWR_MMI:
		// Write the /mmi/pwr/bsie.cfg file
		msg->size = PWR_MMI_CFG_SIZE;