mn80pub2.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

/* DENRYUU start ************************************************************/
unsigned char	RssiBerStat;
unsigned char	ClcOnStat;
unsigned char	BatTimCount;
/* DENRYUU end **************************************************************/


void Mn_PCallSet(void)
{
	U1	fmode;

	M_MSB	*pMsg;

	pMsg = MN_IN_EVT(PM_MN_EVT)->msg_adr;

	fmode = !phs_mode;

	if (Mn_InfChk((MN_INFTBL*)&CHKTBL[2+phs_mode] , (U1*)&pMsg->msg[4] , (BYTE)(pMsg->msg[2] - 1)))
	{

		ReaVal = PRIERR;

		err_dsp(pMsg);
		return;
	}

	CCHFact[phs_mode] = CCHCAL;
	MaxLCHCnt = 4;
	CallSetInfo = pMsg ;
	CallKind = pMsg->msg[3] ;

	Mn_BearCapaSet((U1*)&pMsg->msg[4], (BYTE)(pMsg->msg[2] - 1));

	if ( (pMsg->msg[6] & 0x1F) == 0x00 )
		CallProt = 0x00;							//Sound
	else if ( (pMsg->msg[6] & 0x1F) == 0x10 )
		CallProt = 0x01;							// 3.1k audio
	else if ( (pMsg->msg[6] & 0x1F) == 0x08 )
		CallProt = 0x02;
	CallChanel = phs_mode;
	CallMode = CALLMODE_OUT;

	CallSts |= ((U1)MN_IN_EVT(PM_MN_EVT)->add_dat+1);

	Mn_SysCsInfSet();
	Mn_PCCHTimStp(phs_mode);
	Mn_settim(TICCHSHT);

	Sleep_Control(BSLPREL);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x09,0x00,0x00);
	#endif
	In_AreaMonitor = ON;
	moni_cnt = 0;
	Mn_PPBSReSelect();
}



void Mn_PIncomCall(void)
{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("Mn_PIncomCallP\n",sizeof("Mn_PIncomCall\n"));
#endif

#ifdef PROT_TEST
HisOut(0x00,0xff,0x02,SLEEP_STS[phs_mode],0x00);
#endif
	Mn_PCHRssiChk();

	if (CCHEstTim[PHS_PUBLIC_STS])
	{
		m_stptim(T100MS, TICCHEST, PHS_PUBLIC_STS);

		CCHEstTim[PHS_PUBLIC_STS] = OFF;
		Mn_PCsyncCountStart();
	}

	if ( SLEEP_STS[phs_mode] == OFF )
	{
		switch(CCHFact[phs_mode])
		{
		case	CCHINC:
		case	CCHCAL:
		case	CCHLOC:
			if(Mn_PCCHReEstComp())
				return;
		}
	}

	if ( Mn_PPsnoCmp() )
	{
		move_up_b(Mn_Pch, Sys_cch, 7);
		if(Mn_state.public_mod == ST_PP_REPORT)
		{
			Short_chakko = ON;
			return;
		}

		Mn_IncomCallDsp();
		if(CCHFact[phs_mode] == CCHINC)
		{
			Mn_PCCHEstComp();
		}
	}
	else
	{
		if (RadioFlag[PHS_PUBLIC_STS])
		{
			return;
		}



		if(Mn_state.public_mod == ST_PP_WAIT)
		{
			Mn_CCHQualDsp();
		}

		if ((SysInfFlag[PHS_PUBLIC_STS][0] > ON)
		 || (SysInfFlag[PHS_PUBLIC_STS][1] > ON)
		 || (SysInfFlag[PHS_PUBLIC_STS][2] > ON))
		{
			;
		}
		else
		{
			Sleep_Control(BSLPFORV);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x0a,0x00,0x00);
	#endif

			if ( Mn_PBCCHRcvChk() == OK )
			{
				Mn_PCCHReEstComp();
			}
		}
	}
}



void Mn_PIncomRs(void)
{
	U1	fmode;
	M_MSB*	pMsg;

	pMsg = MN_IN_EVT(PM_MN_EVT)->msg_adr;

	fmode = !phs_mode;

	if (IncFlg[phs_mode] != ON)
	{
		ReaVal = SEQERR;
		err_dsp(pMsg);
		return;
	}

	if(!pMsg->msg[2])
	{
		ReaVal = PRIERR;
		err_dsp(pMsg);
		return;
	}


	if (Mn_InfChk(&CHKTBL[1] , (U1*)&pMsg->msg[3] , pMsg->msg[2]))
	{

		ReaVal = PRIERR;
		err_dsp(pMsg);
		return;
	}

	CCHFact[phs_mode] = CCHINC;

	if(ti_page)
		m_stptim(T100MS , TIPAGE , PHS_PUBLIC_STS);
	Mn_settim(TIPAGE);
	CallSetInfo = pMsg;
	CallChanel = phs_mode;
	CallMode = CALLMODE_IN;;
	IncFlg[phs_mode] = 0xFF;

	Mn_SysCsInfSet();

	Mn_PCCHTimStp(phs_mode);
	In_AreaMonitor = ON;
	moni_cnt = 0;
	Mn_PPBSReSelect();
}



void Mn_PReRadioInfo(void)
{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("Mn_PReRadioInfo\n",sizeof("Mn_PReRadioInfo\n"));
#endif

	Mn_PCsyncRssiChk();

	if (CCHEstTim[phs_mode])
	{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("Est T STP\n",sizeof("Est T STP\n"));
#endif


		m_stptim(T100MS, TICCHEST, phs_mode);

		CCHEstTim[phs_mode] = OFF;
		Mn_PCsyncCountStart();
	}

	if( L1_BCCHB == Mn_InEvtCod[1])
	{
		if ( SLEEP_STS[phs_mode] != OFF )
		{
			Mn_CCHQualDsp();
		}
	}

	if ( SLEEP_STS[phs_mode] == OFF )
	{
		switch(CCHFact[phs_mode])
		{
		case	CCHINC:
		case	CCHCAL:
		case	CCHLOC:
			if(Mn_PCCHReEstComp())
				return;
		}

		Mn_PCsyncCountStart();

	}
	else
	{
		if(Mn_InEvtCod[1] == L1_BCCHB)
		{
			Sleep_Control(BSLPFORV);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x0b,0x00,0x00);
	#endif
			return;
		}


		CCHFact[phs_mode] = CCHEST;
		ReaVal = 0x08;
		Mn_PCCHFail();
	}
}


void Mn_PReSysInfo(void)
{
#ifdef  _DEBUG_TC6_
		_SendStringToUart("Mn_PReSysInfo\n",sizeof("Mn_PReSysInfo\n"));
#endif

	Mn_PCsyncRssiChk();

	if (CCHEstTim[phs_mode])
	{
		m_stptim(T100MS, TICCHEST, phs_mode);
		CCHEstTim[phs_mode] = OFF;
		Mn_PCsyncCountStart();
	}

	if(Mn_InEvtCod[1] == L1_BCCHB)
	{
		if ( SLEEP_STS[phs_mode] != OFF )
		{
			Mn_CCHQualDsp();
		}
	}

	if ( SLEEP_STS[phs_mode] == OFF )
	{
		switch(CCHFact[phs_mode])
		{
		case	CCHINC:
		case	CCHCAL:
		case	CCHLOC:
			if(Mn_PCCHReEstComp())
				return;
		}

		Mn_PCsyncCountStart();
	}
	else
	{
		if(Mn_InEvtCod[1] == L1_BCCHB)
		{
			Sleep_Control(BSLPFORV);
	#ifdef PROT_TEST
		HisOut(0x00,0xfe,0x0c,0x00,0x00);
	#endif
			return;
		}


		CCHFact[phs_mode] = CCHEST;
		ReaVal = 0x08;
		Mn_PCCHFail();
	}
}


U1	Mn_PBCCHRcvChk(void)
{
	U1	n;

	if ( SLEEP_STS[phs_mode] )
	{
		for (n = 0; n < 3; n++)
		{
			if((SysInfFlag[phs_mode][n] == ON) && SysStsTim[phs_mode][n])
			{
				SysStsTim[phs_mode][n] --;
				if(SysStsTim[phs_mode][n] == 0)
				{
					CCHFact[phs_mode] = CCHEST;
					ReaVal = 0x1F;
					Mn_PCCHFail();
					return ( NG );
				}
			}
		}
	}


	if ( Sys_cch[7] & 0x01 )
	{
		switch (Sys_cch[7] & 0x07)
		{
		case 0x01:
			n = 0;
		break;
		case 0x03:
			n = 1;
		break;
		case 0x05:
			return(OK);
		default:
			return ( NG );
		}
		if (SysInfFlag[phs_mode][n] == OFF)
		{
			SysStsTim[phs_mode][n] = 0xff;
			CCHFact[phs_mode] = CCHEST;
			ReaVal = 0x1F;
			Mn_PCCHFail();
			return ( NG );
		}
		else if((Sys_bcch[n+1][phs_mode][6] & 0x38) != (Sys_cch[7] & 0x38))
		{
			SysStsTim[phs_mode][n] = 0xff;
			CCHFact[phs_mode] = CCHEST;
			ReaVal = 0x1F;
			Mn_PCCHFail();
			return ( NG );
		}

		SysStsTim[phs_mode][n] = 50;
		return ( OK );
	}
	else
	{

		if ((phs_mode == PHS_PUBLIC_STS)
			&& (Sys_bcch[0][phs_mode][7] & 0x10) != (Sys_cch[7] & 0x10))
		{
			CCHFact[phs_mode] = CCHEST;
			ReaVal = 0x1F;
			Mn_PCCHFail();
			return ( NG );
		}

		else if ((Sys_bcch[0][phs_mode][7] & 0x0F) != (Sys_cch[7] & 0x0F))
		{
			CCHFact[phs_mode] = CCHEST;
			ReaVal = 0x1F;
			Mn_PCCHFail();
			return ( NG );
		}
		else
		{
			if (SysInfFlag[phs_mode][0] > ON
			 ||	SysInfFlag[phs_mode][1] > ON
			 ||	SysInfFlag[phs_mode][2] > ON)
			{
				CCHFact[phs_mode] = CCHEST;
				ReaVal = 0x1F;
				Mn_PCCHFail();
				return ( NG );
			}
			return ( OK );
		}
	}
}



U1 Mn_PCCHReEstComp(void)
{
	U1	fmode;

	fmode = !phs_mode;


	if ((phs_mode != PHS_PUBLIC_STS) || (CCHFact[phs_mode] != CCHINC)
		|| ((CCHFact[phs_mode] == CCHINC) && (Sys_initdl1[18] == 0x00)))
	{
		if (RadioFlag[phs_mode])
		{
			return(0);
		}
		if ((SysInfFlag[phs_mode][0] > ON)
		 || (SysInfFlag[phs_mode][1] > ON)
		 || (SysInfFlag[phs_mode][2] > ON))
		{
		  	return(0);
		}
	}

	switch (CCHFact[phs_mode])
	{
	case CCHCAL:
	case CCHINC:
		Mn_SysCsInfSet();
		if (CCHFact[phs_mode] == CCHCAL)
		{

			if ( Mn_PUBCallReglChk() != OK )
			{

				Mn_PBSRetryCheck();
				return (1);
			}
			if(Mn_EstCallLoc())
				return(1);
			MaxLCHCnt = 4;
			Mn_LCHMsgSet(CALLMODE_OUT);

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

		}
		else
		{
			Mn_LCHMsgSet(CALLMODE_IN);

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

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


		Mn_PCCHTimStp(fmode);


		m_excreq((WORD*)&SYS_WORK->tsk_id);
		CCHFact[phs_mode] = 0xFF;
	break;
	case CCHLOC:
		Mn_SysCsInfSet();
		WReMonTimN |= BIT8;
		Mn_PCCHTimStp(phs_mode);
		WReMonTimN &= ~BIT8;

		MaxLCHCnt = 4;
		Mn_LCHMsgSet(CALLMODE_LOCREG);


		m_excreq((WORD*)&SYS_WORK->tsk_id);

		*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

		*Mn_GetSpecState( (BYTE)(!phs_mode)) = ST_PP_IDLE;

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

		WReMonTimN |= BIT8;
		Mn_PCCHTimStp(fmode);
		WReMonTimN &= ~BIT8;
		CCHFact[phs_mode] = 0xFF;
	break;
	case CCHEST:
	break;
	}
	return(1);
}



void Mn_PLink(void)
{

	ExLCH = MN_IN_EVT(RT_MN_LCHEVT)->msg_dat[0] & 0x07;	//LCH extend protocol type

}


void Mn_PLinkNG(void)
{
	Mn_PRadioInit();
}



void Mn_PSamePeriod(void)
{
	if(CallMode != CALLMODE_OUT && CallMode != CALLMODE_IN)
	{
		RetryCount = 0;
	}
	if (CCHShortTim[phs_mode])
	{
		m_stptim(T1S, TICCHSHT, phs_mode);
		CCHShortTim[phs_mode] = OFF;
	}
	Mn_PCsyncCounterClear();

	set_up_b( (BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));


	switch (CallMode)
	{
	case CALLMODE_OUT:
	case CALLMODE_IN:
		MN_OUT_EVT(L3C_MN_EVT)->add_dat[1] = SFACCH;
	break;

	case CALLMODE_LOCREG:
		MN_OUT_EVT(L3C_MN_EVT)->add_dat[1] = FACCH;
	break;

	default:
		return;
	break;
	}

	SYS_WORK->tsk_id = TASKL3;
	MN_OUT_EVT(L3C_MN_EVT)->evt_cod = EL3SETRQ;
	m_excreq((WORD*)&SYS_WORK->tsk_id);
	DLEstab = 0;

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

}


void Mn_PTchL1Err(void)
{
	U1 *p;

	p = Mn_GetSpecState(phs_mode);

	switch( MN_IN_EVT(L1_MN_EVT)->add_dat )
	{
	case 0x81 :
		if( ST_PP_LOC_REG_STR == *p )
		{
			LocInf[PHS_PUBLIC_STS].CompFlg = OFF;
			LocInf[PHS_PUBLIC_STS].Retry = ON;
			*p = ST_PP_LOC_REG_END;
		}
		else
		{
			*p = ST_PP_DISC_COMM;
		}
#ifdef SIMU_ON_PC
		if(PHS_PUBLIC_STS == phs_mode)
			SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif

	break;
	case 0x82 :
		if( ST_PP_DISC_COMM != *p )
		{
			return;
		}
		if ( !(Sys_rtfunc[4] & BIT1)
			&& !(Sys_rtfunc[4] & BIT2))
		{
			return;
		}
	break;
	case 0x83 :
		if( ST_PP_DISC_COMM != *p )
		{
			return;
		}
		if ( !(Sys_rtfunc[4] & BIT3)
			&& !(Sys_rtfunc[4] & BIT5))
		{
			return;
		}
	break;
	case 0x84 :
		if( ST_PP_DISC_COMM != *p )
		{
			return;
		}
		if ( !(Sys_rtfunc[4] & BIT4)
			&& !(Sys_rtfunc[4] & BIT6))
		{
			return;
		}
	break;
	default	 :
		return;
	break;
	}

	Mn_PRadioRelease();
}



void Mn_PWaitPriCSMonSort(MN_CCHMONREC *Table, U1 tblnum)
{
	U1				i, j, k;
	U1				p1, p2;
	MN_CCHMONREC	CSSort;

	for ( i = 0; i < tblnum - 1; i++ )
	{
		move_up_b((U1*)&CSSort, (U1*)&Table[i], sizeof(MN_CCHMONREC));
		k = i;

		for ( j = i + 1; j < tblnum; j++ )
		{
			p1 = 0;
			p2 = 0;

			if ( Mn_AreaCmp(Sys_pbsid, (U1*)Table[j].Csid) )
			{

				p1 = Sys_initdl1[15];
			}
			if ( Mn_AreaCmp(Sys_pbsid, (U1*)CSSort.Csid) )
			{

				p2 = Sys_initdl1[15];
			}
			if ( (Table[j].Rssi + p1) > (CSSort.Rssi + p2) )
			{
				move_up_b((U1*)&CSSort, (U1*)&Table[j], sizeof(MN_CCHMONREC));
				k = j;
			}
		}

		move_up_b((U1*)&Table[k], (U1*)&Table[i], sizeof(MN_CCHMONREC));
		move_up_b((U1*)&Table[i], (U1*)&CSSort, sizeof(MN_CCHMONREC));
	}
}


U1 Mn_GetCSPowerBit(U1 *csid)
{
	/* No public bit judge. Done in previous stage*/
	U1 area_len, byte_pos, bit_pos, power_bit;
	U1	Np[16] = {0,
			  4,6,8,10,12,14,16,17,18,19,20,21,22,23,24};

	if(Sys_ccsinf[11] == 0)
		area_len = (Sys_pbsid[6] & 0x0F);
	else
		area_len = (Sys_ccsinf[11] & 0x0F);

	power_bit=9 + Np[area_len] + 2 - 1;/*9 is operator id; 2 is power bit offset to paging area*/

	bit_pos=power_bit%8;
	byte_pos=power_bit/8;

	return(csid[byte_pos]&(0x1>>bit_pos));
}

/*--------------------------------------------------------------------------*/
/*                                                                          */
/*      CALL        Mn_LowCSPrefer_Sort(U1)                                   */
/*      PARAM       U1  reg_area_prefer                                                     */
/*      FUNC        sort the CS use the algorithm from the seamless spec    */
/*      RETURN      the result in the global variable                       */
/*      GLOBAL                                                              */
/*                                                                          */
/*--------------------------------------------------------------------------*/

void Mn_LowCSPrefer_Sort(U1 reg_area_prefer)
{
	U1				i, j, k;
	MN_CCHMONREC	CSWork;	 /* Temp working area*/
	U2				current_rssi, ref_rssi;

	for ( i = 0; i < CCHMonReg - 1; i++ )
	{
		move_up_b((U1*)&CSWork, (U1*)&CCHMonTable[i], sizeof(MN_CCHMONREC));
		k = i;

		/* This algorithm is to add a maximum value to prefered CS RSSI and */
		/* make it can be selected first*/
		current_rssi = CSWork.Rssi;
		if(Mn_GetCSPowerBit((U1*)CSWork.Csid))
			current_rssi+=256;

		if(reg_area_prefer)
		{
			if(Mn_AreaCmp(Sys_pbsid, (U1*)CSWork.Csid))
				current_rssi+=Sys_initdl1[15];		/*Registered area prefer when in PCH monitor mode*/
		}

		for ( j = i + 1; j < CCHMonReg; j++ )
		{
			ref_rssi=CCHMonTable[j].Rssi;
			if(Mn_GetCSPowerBit((U1*)CCHMonTable[j].Csid))
				ref_rssi+=256;
			if(reg_area_prefer&&(Mn_AreaCmp(Sys_pbsid, (U1*)CCHMonTable[j].Csid)))
				ref_rssi+=Sys_initdl1[15];

			if ( ref_rssi > current_rssi )
			{
				move_up_b((U1*)&CSWork, (U1*)&CCHMonTable[j],
													sizeof(MN_CCHMONREC));
				k = j;
			}
		}

		move_up_b((U1*)&CCHMonTable[k], (U1*)&CCHMonTable[i],
												 sizeof(MN_CCHMONREC));
		move_up_b((U1*)&CCHMonTable[i], (U1*)&CSWork, sizeof(MN_CCHMONREC));
	}
}


void Mn_PHakkoCSMonSort(void)
{
	MN_CCHMONREC  	LAGroup[20];
	U1				LA1n,
					LA2n,
					LA3n,
					LA4n,
					LA5n,
					LA6n;
	U1				LA2Csid[6];
	U1				LA5Csid[6];