mn80pub5.c

phs 源代码 小灵通协议源代码 phs source code

#ifndef PM_ONPC
#ifdef __cplusplus
extern "C"{
#endif

#include	"phs_def.h"

//  #pragma	section	area m_data

#include	"mn80.h"
#include	"mn80ext.h"

//  #pragma	section	code mp_code


void Mn_PLocReg(void) // PM->MN
{
	U1	fmode;

	fmode = !phs_mode;

#ifdef EXT_IO
    HisOut(0,0xda,0x02,0,0);
#endif

	if(1 != MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2])
	{
		ReaVal = PRIERR;
		err_dsp(MN_IN_EVT(PM_MN_EVT)->msg_adr);
		return;
	}

	Ich_end_monF = BIT2;
	RetryCount = 0;

	if ( Mn_PLocReglChk() == NG )
	{
		ReaVal = 0x37;
	}
	else if ( (MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[3] == 0)
			&& LocInf[phs_mode].CompFlg )
	{
		ReaVal = 0x1F;
	}
	else
	{
		ReaVal = 0;
	}
	if ( ReaVal )
	{
		m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);
		CCHFact[phs_mode] = CCHEST;
		Mn_PRadioInit();
		return;
	}
	loc_reg_reason = MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[3];

	if( (MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[3] == 0x02) && (phs_mode == PHS_PUBLIC_STS))
	{

		m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);
		CCHFact[phs_mode] = CCHEST;
		ReaVal = 0x1F;
		Ich_Fail = ON;
		Mn_PRadioInit();
		return;
	}
	MaxLCHCnt = 4;
	CallChanel = phs_mode;
	CallMode = CALLMODE_LOCREG;

	Mn_SysCsInfSet();

	m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);

	WReMonTimN |= BIT8;
	Mn_PCCHTimStp(phs_mode);
	WReMonTimN &= ~BIT8;

	Sleep_Control(BSLPREL);
#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x0f,0x00,0x00);
#endif
	CCHFact[PHS_PUBLIC_STS] = CCHLOC;
	Mn_PFstPBSCCHEstReqInit();

}



U1 Mn_PLocReglChk(void)
{
	U1	PriPS;

	PriPS = Sys_pri;
	if (!cmp_up_b((U1*)WaitCS[phs_mode].Csid, (U1*)RegulCS[phs_mode].Csid, 6)
		&& (RegulCS[phs_mode].Kind & 0x06) )
	{
		if (RegulCS[phs_mode].Kind & 0x02)
		{
			if (!(PriPS & BIT1) && ACCYCINT(phs_mode))
			{

				Mn_settim(TIACLOC);
				RegulCS[phs_mode].Kind |= 0x04;
			}
		}
		return ( NG );
	}

	return ( OK );
}


 void Mn_PAccTimer(void)
{

	switch(Mn_InEvtCod[0])
	{
	case TIACLOC:
		AccTimLoc[phs_mode] = OFF;
		RegulCS[phs_mode].Kind &= ~0x04;
		if (RegulCS[phs_mode].Kind & 0x02)
		{
			;
		}
		else
		{
			SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
			SYS_WORK->msg_adr->msg[0] = OPUBLIC;
			SYS_WORK->msg_adr->msg[1] = MREGUL;
			SYS_WORK->msg_adr->msg[2] = 0x02;
			SYS_WORK->msg_adr->msg[3] = IRGLINF;
			SYS_WORK->msg_adr->msg[4] = 0;
			if (RegulCS[phs_mode].Kind & 0x07)
			{
				SYS_WORK->msg_adr->msg[4] = (BIT8 | (RegulCS[phs_mode].Kind & 0x07));
			}
			exec_uap(SYS_WORK->msg_adr);
		}
	break;

	case TIACCALL:
		AccTimCall[phs_mode] = OFF;
		RegulCS[phs_mode].Kind &= ~0x10;
	break;
	}
}



 void Mn_PLocSyncNG(void)//RT->MN
{

	if(Mn_InEvtCod[1] == PSLCHREF)
	{
		if(0x0A == MN_IN_EVT(RT_MN_LCHEVT)->msg_dat[0])
		{
			move_up_b(Sys_napbs[PHS_PUBLIC_STS], SYS_CSID_P, 7);
		}
	}
	if ( (PHS_PUBLIC_STS == phs_mode)
		&& ( Call_Loc_flg == OFF ))
	{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("PLocSync\n",sizeof("PLocSync\n"));
#endif
		if ( Mn_PBSSelReTry(CCHLOC) != NG )
		{
			return;
		}
	}

	if ( (PHS_PUBLIC_STS == phs_mode) && (Call_Loc_flg == ON) && Sys_initdl1[17])
	{
		Loc_LnkNG = ON;
	}

	Mn_PRadioInit();
}



 void Mn_PLocDLSet(void)	//L3C->MN
{

	DLEstab |= (U1)MN_IN_EVT(L3C_MN_EVT)->add_dat[1];
#ifdef SIMU_ON_PC
     ProtocolTrace(2,"!!!PLoc set %d %d %d\n",DLEstab,MesSnd,(U1)MN_IN_EVT(L3C_MN_EVT)->add_dat[1]);
#endif
	if (MesSnd)
	{
		if (TC309PTim)
		{
			m_stptim(T1S, TITC309P, phs_mode);
			TC309PTim = OFF;
		}
	}
	else
	{

		if (DLEstab == FACCH)
		{
			set_up_b( (BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
			SYS_WORK->tsk_id = TASKMM;
			MN_OUT_EVT(L3_MN_EVT)->evt_cod = EMM;

			MN_OUT_EVT(L3_MN_EVT)->pri_cod = MNMM_LOCATION_REGISTRATION_REQ;
			if(loc_reg_reason==3)
			{
				/*Power off registration*/
				MN_OUT_EVT(L3_MN_EVT)->add_dat = 2;
				MN_OUT_EVT(L3_MN_EVT)->dmy3 = 2;
			}

			m_excreq((WORD*)&SYS_WORK->tsk_id);
			MesSnd = ON;



			if (!cmp_up_b(SYS_AREA_P, CLSAREA, 7))
			{
				move_up_b(SYS_AREA_P, &Sys_pbsid[7], 7);
			}
			move_up_b(Sys_rtfunc, RTFUNCDEF, sizeof(RTFUNCDEF));
			move_up_b(Sys_mmfunc, MMFUNCDEF, sizeof(MMFUNCDEF));

			if (ExLCH  & 0x04)
			{

				set_up_b( (BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
				SYS_WORK->tsk_id = TASKRT;
				MN_OUT_EVT(L3_MN_EVT)->evt_cod = ERT;
				MN_OUT_EVT(L3_MN_EVT)->pri_cod = PRDEFINF;
				MN_OUT_EVT(L3_MN_EVT)->add_dat = 0x01;

				m_excreq((WORD*)&SYS_WORK->tsk_id);
				DefInfo_Rcvf = OFF;
			}
			else
			{

				Mn_PCallDefInfo();
			}
		}
	}
#ifdef EXT_IO
   HisOut(0,0xda,0x09,0,0);
#endif
	Mn_DLDsp();

}



void Mn_PLocAcpt(void) //MM->MN
{
	move_up_b(Sys_pbsid, SYS_CSID_P, 7);

	Ich_end_monF = 0;
	reg_fail = OFF;

	SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
	SYS_WORK->msg_adr->msg[0] = OPUBLIC;
	if(!Call_Loc_flg)
	{

		SYS_WORK->msg_adr->msg[1] = MLOCOK;
	}
	else
	{

		SYS_WORK->msg_adr->msg[1] = MALOCOK;
	}
	LocInf[phs_mode].GrpFlg = WaitCS[phs_mode].GrpFlg;
	LocInf[phs_mode].FrqNo = WaitCS[phs_mode].CCHno;
	SYS_WORK->msg_adr->msg[2] = 0x0C;

	move_up_b((U1*)&SYS_WORK->msg_adr->msg[3] , SYS_CSID_P , 7);
	exec_uap(SYS_WORK->msg_adr);

	if(MN_IN_EVT(L3_MN_EVT)->buf_adr)
		m_frebuf(MN_IN_EVT(L3_MN_EVT)->buf_adr);



	Mn_PAreaBitMask();
	LocInf[phs_mode].CompFlg = ON;
	LocInf[phs_mode].Retry = OFF;
	*Mn_GetSpecState(phs_mode) = ST_PP_LOC_REG_END;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0, (BYTE*)&Mn_state.public_mod , 1);
#endif
}


 void Mn_PLocNG(void)	//MM->MN
{
	LocInf[phs_mode].CompFlg = OFF;
	LocInf[phs_mode].Retry = ON;
	Ich_end_monF = BIT3;


	if(MN_IN_EVT(L3_MN_EVT)->add_dat)
	{
		LocInf[phs_mode].Retry = OFF;

		PubNgAreaSet(SYS_CSID_P , (BYTE)(Sys_ccsinf[11] & 0x0f));
	}

	Source = 0x52;
	ReaVal = (BIT8 | MN_IN_EVT(L3_MN_EVT)->add_dat);

	*Mn_GetSpecState(phs_mode) = ST_PP_LOC_REG_END;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
}



void Mn_PLocDLNG(void)
{
	if(Mn_Rtdeffunc())
		return;
	LocInf[phs_mode].CompFlg = OFF;
	LocInf[phs_mode].Retry = ON;


	switch ( Mn_InEvtCod[1] )
	{
	case PSDEFING :
	case PSRTFUNG :
	case MMMN_FUNCTION_REQ_FAIL:
		ReaVal = 0xEF;
	break;
	case MMMN_LOCATION_REGISTRATION_FAIL :
		Source = 0x53;
		ReaVal =  0xFF;
	break;
	}

	Mn_PRadioRelease();
	*Mn_GetSpecState(phs_mode) = ST_PP_LOC_REG_END;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
}



void Mn_PLocRRel(void)
{

	if(PSRCHDIS == Mn_InEvtCod[1])
	{
		if (RchDis)
		{
			m_stptim(T100MS, TITCHFRE, phs_mode);
			RchDis = OFF;
		}
	}

	if(ST_PP_LOC_REG_STR == *Mn_GetSpecState(phs_mode))
	{
		LocInf[phs_mode].CompFlg = OFF;
		LocInf[phs_mode].Retry = ON;
	}
	Mn_PRadioInit();
}



void Mn_PLocFrcRel(void)
{

	if( MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2] )
	{
		ReaVal = PRIERR;
		err_dsp(MN_IN_EVT(PM_MN_EVT)->msg_adr);
		return;
	}
	m_frebuf((U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr);

	Mn_PRadioRelease();

	*Mn_GetSpecState(phs_mode) = ST_PP_LOC_REG_END;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
}


void Mn_PLocFrcInit(void) //PM->MN
{

	if( MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2] )
	{
		ReaVal = PRIERR;
		err_dsp(MN_IN_EVT(PM_MN_EVT)->msg_adr);
		return;
	}
	m_frebuf( (U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr );

	Mn_PRadioInit();

}

BYTE Mn_PCallReLoc(void)
{
	if ( Mn_PLocReglChk() == NG )
	{
		return(2);
	}
	Mn_SysCsInfSet();
	Mn_PCCHTimStp(phs_mode);
	Sleep_Control(BSLPREL);
#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x10,0x00,0x00);
#endif
	MaxLCHCnt = 4;
	CallChanel = phs_mode;
	CallMode = CALLMODE_LOCREG;
	Mn_LCHMsgSet(CALLMODE_LOCREG );

	m_excreq((WORD*)&SYS_WORK->tsk_id);
	CCHFact[phs_mode] = 0xFF;

	*Mn_GetSpecState(phs_mode) = ST_PP_LCH_EST_L;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 ,  (BYTE*)&Mn_state.public_mod , 1);
#endif
	move_up_b(LocNgCS, (U1*)WaitCS[phs_mode].Csid, 6);
	Ich_end_monF = BIT2;

	return(0);
}


 BYTE Mn_EstCallLoc(void)
{
	if( Sys_initdl1[17] && Call_Loc_flg == OFF && PHS_PUBLIC_STS == phs_mode)
	{
		if( ((Mn_AreaNoCmp((U1*)WaitCS[PHS_PUBLIC_STS].Csid) == OFF) || (reg_fail == ON))
			&& (CCHFact[PHS_PUBLIC_STS] == CCHCAL) && !(time_id & 0x01))
		{
			LocInf[PHS_PUBLIC_STS].CompFlg = 0;
			switch(Mn_PCallReLoc())
			{
			case 0:
				Call_Loc_Cnt++;
				Call_Loc_flg = ON;
				return(1);
			break;
			case 1:
				return(1);
			break;
			}
			Call_Loc_NG = ON;
		}
		else
		{
			if((CCHFact[PHS_PUBLIC_STS] == CCHCAL) && (time_id & 0x01))
			{

				Call_Loc_NG = ON;
			}
		}
	}
	return(0);
}


 BYTE Mn_RInitCallLoc(BYTE pm_req)
{
	if(Call_Loc_flg == ON && phs_mode == PHS_PUBLIC_STS && pm_req == OFF
		&& CallMode == CALLMODE_LOCREG )
	{
		if(Mn_HakLocCut())
			return(0);
 		if(LocInf[PHS_PUBLIC_STS].CompFlg == ON)
		{
			Call_Loc_NG = OFF;
		}
		else
		{
			if(Loc_LnkNG == ON)
			{
				Loc_LnkNG = OFF;
				if(Call_Loc_Cnt < (Sys_initdl1[17] & 0x0F))
				{

					if (((pbs_sel_retry + 1) < CCHMonReg)
						&& ((pbs_sel_retry + 1) < PBS_RETRY13))
					{
						CallChanel = PHS_PUBLIC_STS;
						CallMode = CALLMODE_OUT;
						CCHFact[PHS_PUBLIC_STS] = CCHCAL;
						MesSnd = OFF;
						Call_Loc_flg = OFF;
						return(0);
					}
				}
				Call_Loc_NG = ON;

			}
			else
			{
				Call_Loc_NG = ON;


				SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
				SYS_WORK->msg_adr->msg[0] = OPUBLIC;

				SYS_WORK->msg_adr->msg[1] = MALOCOK;
				SYS_WORK->msg_adr->msg[2] = 0x03;

				SYS_WORK->msg_adr->msg[3] = 0x77;
				SYS_WORK->msg_adr->msg[4] = 0x01;
				SYS_WORK->msg_adr->msg[5] = BIT3;
				exec_uap( SYS_WORK->msg_adr );
				reg_fail = ON;
				Ich_end_monF = OFF;
				if( !PubNgAreaChk((U1*)WaitCS[PHS_PUBLIC_STS].Csid) )
				{
					CallChanel = PHS_PUBLIC_STS;
					CallMode =  CALLMODE_OUT;
					CCHFact[PHS_PUBLIC_STS] = CCHCAL;
					MesSnd = OFF;
					Call_Loc_flg = OFF;
					RetryCount = 20;
					return(0);
				}
			}
		}
		Call_Loc_flg = ON;
		CallChanel = PHS_PUBLIC_STS;
		CallMode = CALLMODE_OUT;
		MesSnd = OFF;
#ifdef  _DEBUG_TC6_
		_SendStringToUart("Rinitl\n",sizeof("Rinitl\n"));
#endif
		Mn_PNextPBSCCHEstReq(CCHCAL, ON);
		RetryCount = 20;
		return(1);
	}
	return(0);
}


 void Mn_PBSRetryCheck(void)
{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("PBSReCheck\n",sizeof("PBSReCheck\n"));
#endif
	switch ( CCHFact[PHS_PUBLIC_STS] )
	{
	case CCHEST:
		if(Mn_PBSSelReTry(CCHFact[PHS_PUBLIC_STS]) == NG)
		{
			if (ReaVal == 0)
				ReaVal = 0x1F;
			Mn_PCCHFail();
		}
	break;
	case CCHCAL:
		switch(Mn_PBSSelReTry(CCHFact[PHS_PUBLIC_STS]))
		{
		case NG:
			Mn_RetryNgSet();
		break;
		case 2:
			if(Call_Loc_Cnt < Sys_initdl1[17])
				Call_Loc_flg = OFF;
		break;
		}
	break;
	case CCHINC:
		if(Mn_PBSSelReTry(CCHFact[PHS_PUBLIC_STS]) == NG)
		{
			Mn_RetryNgSet();
		}
	break;

	}
}


void Mn_PLocHakInit(void)	//PM->MN
{

	if( !MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2] )
	{
		ReaVal = PRIERR;
		err_dsp( MN_IN_EVT(PM_MN_EVT)->msg_adr );
		return;
	}
	m_frebuf( (U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr );

	Mn_PRadioInit();

}


void Mn_PLocHakRel(void)
{
	if( !MN_IN_EVT(PM_MN_EVT)->msg_adr->msg[2] )
	{
		ReaVal = PRIERR;
		err_dsp( MN_IN_EVT(PM_MN_EVT)->msg_adr );
		return;
	}

	m_frebuf( (U1*)MN_IN_EVT(PM_MN_EVT)->msg_adr );

	HakLoc_Cut = ON;

	Mn_PRadioRelease();

	*Mn_GetSpecState(phs_mode) = ST_PP_LOC_REG_END;
#ifdef SIMU_ON_PC
	if(PHS_PUBLIC_STS == phs_mode)
		SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
}


BYTE Mn_HakLocCut(void)
{
	if(HakLoc_Cut == ON)
	{
		HakLoc_Cut = OFF;
		RetryCount = 0;
 		if(LocInf[PHS_PUBLIC_STS].CompFlg == OFF)
		{

			SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
			SYS_WORK->msg_adr->msg[0] = OPUBLIC;
			SYS_WORK->msg_adr->msg[1] = MALOCOK;
			SYS_WORK->msg_adr->msg[2] = 0x03;

			SYS_WORK->msg_adr->msg[3] = 0x77;
			SYS_WORK->msg_adr->msg[4] = 0x01;

			SYS_WORK->msg_adr->msg[5] = BIT3;
			exec_uap(SYS_WORK->msg_adr);
			reg_fail = ON;
			Ich_end_monF = OFF;
		}
		return(1);
	}
	return(0);
}


 void Mn_RetryNgSet(void)
{
	moni_cnt = 0;
	if (ReaVal == 0)
		ReaVal = 0x1F;
	Mn_PCCHFail();
	RetryCount = 1;
}


void Mn_HTxComp(void)
{

	if ( (ExLCH  & 0x04)
		&& (ST_PP_TCH_EST_T == *Mn_GetSpecState(phs_mode) )
		&& (CCSetup == ON)
		&& (InfSFlg == OFF) )
	{

		set_up_b( (BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
		SYS_WORK->tsk_id = TASKRT;
		MN_OUT_EVT(L3_MN_EVT)->evt_cod = ERT;

		MN_OUT_EVT(L3_MN_EVT)->pri_cod = PRDEFINF;
		MN_OUT_EVT(L3_MN_EVT)->add_dat = 0x01;

		m_excreq( (WORD*)&SYS_WORK->tsk_id );
		DefInfo_Rcvf = OFF;
		return;
	}

	SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
	SYS_WORK->msg_adr->msg[0] = NONE;
	SYS_WORK->msg_adr->msg[1] = MDATCNF;
	SYS_WORK->msg_adr->msg[2] = 0 ;

	if( (Mn_state.public_mod == ST_PP_DISC_COMM) && (p_mail_flg == 1) )
	{
		SYS_WORK->msg_adr->msg[2] = 1;
		SYS_WORK->msg_adr->msg[3] = PMMN_COMM_DIS;
	}
	exec_uap(SYS_WORK->msg_adr);
	InfSFlg = OFF;
}


#ifdef __cplusplus
}
#endif

#endif