mn80pub4.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"
#include   "stephi.h"
//  #pragma	section	code mp_code
extern	void	rt_tm_stop(U2);
extern	void	rt_rdbak(void);


void Mn_PZoneInfo(void)
{
	U1	n;

	if (!(Sys_rtfunc[7] & BIT1))
	{
		if( MN_IN_EVT(L3_MN_EVT)->buf_adr)
			m_frebuf( MN_IN_EVT(L3_MN_EVT)->buf_adr);
		return;
	}

	n = 0;

	if( MN_IN_EVT(L3_MN_EVT)->inf_adr[0] == IAREAINF)
	{
		Sys_pbsid[7] = MN_IN_EVT(L3_MN_EVT)->inf_adr[1];
		move_up_b(&Sys_pbsid[8] , &MN_IN_EVT(L3_MN_EVT)->inf_adr[2] , 6);
		Areainfbak[0] = MN_IN_EVT(L3_MN_EVT)->inf_adr[1];
		Areainfbak[1] = MN_IN_EVT(L3_MN_EVT)->inf_adr[2];
		Areainfbak[2] = MN_IN_EVT(L3_MN_EVT)->inf_adr[3];
		Areainfbak[3] = MN_IN_EVT(L3_MN_EVT)->inf_adr[4];

		Sys_ccsinf[12] = MN_IN_EVT(L3_MN_EVT)->inf_adr[1];
		move_up_b(&Sys_ccsinf[13] , &MN_IN_EVT(L3_MN_EVT)->inf_adr[2] , 6);
#ifdef SIMU_ON_PC
		SendUart2L1(SIMTSKDTW , SYSCCSINF , 12 , &Sys_ccsinf[12] , 7);
#endif

		Sys_thresh[0] = MN_IN_EVT(L3_MN_EVT)->inf_adr[1];
		Sys_thresh[1] = MN_IN_EVT(L3_MN_EVT)->inf_adr[2];
#ifdef SIMU_ON_PC
		SendUart2L1( SIMTSKDTW , SYSTHRESH , 0 , Sys_thresh , 2);
#endif
		n = 8;
	}

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



void Mn_PDLinkRDsp(void)
{

	DLEstab &= ~(MN_IN_EVT(L3C_MN_EVT)->add_dat[1]);

	if (InfSFlg)
	{
		if (!TC309PTim)
		{
			Mn_settim(TITC309P);
		}
		set_up_b((BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
		SYS_WORK->tsk_id = TASKL3;
		MN_OUT_EVT(L3C_MN_EVT)->evt_cod = EL3SETRQ;
		MN_OUT_EVT(L3C_MN_EVT)->add_dat[1] = MN_IN_EVT(L3C_MN_EVT)->add_dat[1];

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



	Mn_DLDsp();
}


void Mn_PTchChange(void)	// L1->MN
{
	U1	ho_start_level;

	if(*Mn_GetSpecState(phs_mode) != ST_PP_COMMUNCATING)
	{
		return;
	}
#ifdef SIMU_ON_PC
     ProtocolTrace(10,"!!!mn tch change %d %d %d\n",0,(U1)MN_IN_EVT(L1_MN_EVT)->add_dat,0);
#endif

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

	switch((U1)MN_IN_EVT(L1_MN_EVT)->add_dat)
	{
	case 0x81:
		Mn_PRadioInit();
		return;
	break;
	case 0x82:
		if ( !(Sys_rtfunc[4] & BIT1)
			&& !(Sys_rtfunc[4] & BIT2))
		{
			return;
		}
		ho_start_level = Sys_ccsinf[14] + Sys_initdl1[5];

		if (t_rssi > ho_start_level)
		{

			if (TCHCngReg)
			{
				if (Sys_hodat[6] && phs_mode == PHS_PUBLIC_STS)
				{
					Mn_PHOTimOut();
				}
				return;
			}
			MN_OUT_EVT(L3_MN_EVT)->add_dat = 0x2A;
			*Mn_GetSpecState(phs_mode) = ST_PP_TCH_SWT;
#ifdef SIMU_ON_PC
			if(PHS_PUBLIC_STS == phs_mode)
				SendUart2L1( SIMTSKDTW , MNSTATE , 0 ,(BYTE*)&Mn_state.public_mod , 1);
#endif

			break;
		}

	case 0x83:
		if ( !(Sys_rtfunc[4] & BIT3)
			&& !(Sys_rtfunc[4] & BIT5))
		{
			return;
		}
		if (!HndOvrReg && Sys_hodat[6] && phs_mode == PHS_PUBLIC_STS)
		{

			Mn_PHOTimOut();
			return;
		}
		return;
	break;
	case 0x84:
		if ( !(Sys_rtfunc[4] & BIT4)
			&& !(Sys_rtfunc[4] & BIT6))
		{
			return;
		}
		if (TCHCngReg)
		{
			return;
		}
		MN_OUT_EVT(L3_MN_EVT)->add_dat = 0x29;
		*Mn_GetSpecState(phs_mode) = ST_PP_TCH_SWT;
#ifdef SIMU_ON_PC
		if(PHS_PUBLIC_STS == phs_mode)
			SendUart2L1( SIMTSKDTW , MNSTATE , 0 ,(BYTE*)&Mn_state.public_mod , 1);
#endif

	break;
	default:
		return;
	break;
	}


	SYS_WORK->tsk_id = TASKRT;
	MN_OUT_EVT(L3_MN_EVT)->evt_cod = ERT;
	MN_OUT_EVT(L3_MN_EVT)->pri_cod = PRTCHCNG;
	MN_OUT_EVT(L3_MN_EVT)->dmy3 = (BYTE)MN_IN_EVT(L1_MN_EVT)->null2;	//why? the null2 must be 0x0000.

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

}



void Mn_PTchChgIns(void)	//RT->MN
{
	M_MSB *pBuf;

	pBuf = (M_MSB*)MN_IN_EVT(L3_MN_EVT)->buf_adr;	//The buffer has been alloced in RT.

	pBuf->msg[0] = NONE;
	pBuf->msg[1] = MTCHSTAT;
	pBuf->msg[2] = 0x02;
	if(0 == MN_IN_EVT(L3_MN_EVT)->add_dat)
	{

		pBuf->msg[3] = MN_IN_EVT(L3_MN_EVT)->add_dat;

		if(ST_PP_COMMUNCATING == *Mn_GetSpecState(phs_mode))
		{

			pBuf->msg[3] |= 0x10;
		}
		pBuf->msg[4] = 0xFF;
	}
	else
	{

		pBuf->msg[3] = 0x01;

		pBuf->msg[4] = 0x01;

		if(ST_PP_COMMUNCATING == *Mn_GetSpecState(phs_mode))
		{

			pBuf->msg[3] |= 0x10;

			pBuf->msg[4] |= 0x10;
		}
	}
	exec_uap(pBuf);


	if( MN_IN_EVT(L3_MN_EVT)->add_dat )
	{
		*Mn_GetSpecState(phs_mode) = ST_PP_HANDOVER;
		TCHflg = OFF;
	}
	else
	{
		*Mn_GetSpecState(phs_mode) = ST_PP_TCH_SWT;
	}
#ifdef SIMU_ON_PC
		if(PHS_PUBLIC_STS == phs_mode)
			SendUart2L1( SIMTSKDTW , MNSTATE , 0 , (BYTE*)&Mn_state.public_mod , 1);
#endif
}



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

	if( MN_IN_EVT(L3_MN_EVT)->add_dat)
	{
		TCHCngReg = ON;
		goto  comm_lab;
	}

	if(ST_PP_HANDOVER == *Mn_GetSpecState(phs_mode))
	{
		goto  comm_lab;
	}

	if (!HndOvrReg && Sys_hodat[6] && phs_mode == PHS_PUBLIC_STS)
	{

		SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
		SYS_WORK->msg_adr->msg[0] = 0x00;
		SYS_WORK->msg_adr->msg[1] = MTCHSTAT;
		SYS_WORK->msg_adr->msg[2] = 0x02;

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

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

		exec_uap(SYS_WORK->msg_adr);

		Mn_PHOTimOut();
		return;
	}

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



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

	if( MN_IN_EVT(L3_MN_EVT)->add_dat & 0x01)
	{
		TCHCngReg = OFF;
	}


	if(MN_IN_EVT(L3_MN_EVT)->add_dat & 0x02)
	{
		HndOvrReg = OFF;
	}
}



void Mn_PTchChgRegul(void)
{


	if(MN_IN_EVT(L3_MN_EVT)->add_dat & 0x01)
	{
		TCHCngReg = ON;
	}


	if(MN_IN_EVT(L3_MN_EVT)->add_dat & 0x02)
	{
		HndOvrReg = ON;
	}
}



void Mn_PTchChgSync(void)	//RT->MN
{
	U1 *p ;

	if (HoTim)
	{

		m_stptim(T1S, TIHANDOV, phs_mode);
		HoTim = OFF;
	}

	if ( TCHflg == OFF )
	{

		TCHflg = MN_IN_EVT(RT_MN_LCHEVT)->msg_dat[5];
	}


	if(TCH2 == MN_IN_EVT(RT_MN_LCHEVT)->dmy[5])
	{
		return;
	}


	set_up_b((BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
	SYS_WORK->tsk_id = TASKL3;
	MN_OUT_EVT(L3C_MN_EVT)->evt_cod = EL3SETRQ;  /* zch for protocol simulator */

	p = Mn_GetSpecState(phs_mode);

	if(TCHflg || ST_PP_TCH_SWT == *p || ST_PP_TCH_ALR_O == *p)
	{
		MN_OUT_EVT(L3C_MN_EVT)->add_dat[1] = SACCH;    /* zch for protocol simulator */
	}
	else
	{
		MN_OUT_EVT(L3C_MN_EVT)->add_dat[1] = SFACCH;    /* zch for protocol simulator */
	}



	m_excreq((WORD*)&SYS_WORK->tsk_id);
	DLEstab = 0;

}


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

	DLEstab |= (U1)MN_IN_EVT(L3C_MN_EVT)->add_dat[1];
	Mn_PTchModori();
	Mn_DLDsp();
}



void Mn_PTchChgNG(void)
{
	Mn_PTchSyncNG();
}



void Mn_PSyncBstrcv(void)	//RT->MN
{
	switch( MN_IN_EVT(RT_MN_LCHEVT)->msg_dat[5])
	{
	case 1 :
		if(TCH2 == MN_IN_EVT(RT_MN_LCHEVT)->dmy[5])
		{
			break;
		}
		if (!HndOvrReg && Sys_hodat[6] && phs_mode == PHS_PUBLIC_STS)
		{

			Mn_settim(TIHANDOV);
		}
	break;

	case 2 :
	case 3 :

		if(TCH2 == MN_IN_EVT(RT_MN_LCHEVT)->dmy[5])
		{
			break;
		}
	break;

	case 4 :
	case 5 :
		if(ST_PP_COMMUNCATING == *Mn_GetSpecState(phs_mode))
		{
			*Mn_GetSpecState(phs_mode) = ST_PP_TCH_SWT;
		#ifdef SIMU_ON_PC
			if(PHS_PUBLIC_STS == phs_mode)
				SendUart2L1( SIMTSKDTW , MNSTATE , 0,(BYTE*)&Mn_state.public_mod , 1);
		#endif
			if (!HndOvrReg && Sys_hodat[6] && phs_mode == PHS_PUBLIC_STS)
			{

				Mn_settim(TIHANDOV);
			}
		}

		SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();
		SYS_WORK->msg_adr->msg[0] = NONE;
		SYS_WORK->msg_adr->msg[1] = MTCHSTAT;
		SYS_WORK->msg_adr->msg[2] = 0x02;
		SYS_WORK->msg_adr->msg[3] = 0x02;
		SYS_WORK->msg_adr->msg[4] = 0xFF;
		exec_uap(SYS_WORK->msg_adr);
	break;
	}
}



void Mn_PHORCall(void)//L3C->MN
{
	U1	*buf, len;
	U1	*bufp;								/* #J01-MNG02			*/

	M_MSB*	pBuf;

	U1 Encryption_Algorithm_Select;					/*Encryption Algorithm Select Flag */

	DLEstab |= MN_IN_EVT(L3C_MN_EVT)->add_dat[1];

	if (TCHflg)
	{
		Mn_PTchModori();
	}
	else
	{
		if (DLEstab != (SACCH | FACCH))
			return;
		set_up_b( (BYTE*)SYS_WORK->out_evt , 0 , sizeof(SYS_WORK->out_evt));
		SYS_WORK->tsk_id = TASKCC;
		MN_OUT_EVT(L3_MN_EVT)->evt_cod = ECC;

		MN_OUT_EVT(L3_MN_EVT)->pri_cod = PRCALSET;
		MN_OUT_EVT(L3_MN_EVT)->buf_adr = m_hntbuf();
		pBuf = (M_MSB*)MN_OUT_EVT(L3_MN_EVT)->buf_adr;
		pBuf->msg[0] = IBEARCAP;
		move_up_b((U1*)&pBuf->msg[1] , bear_capa , (WORD)(bear_capa[0]+1));
		MN_OUT_EVT(L3_MN_EVT)->inf_len = pBuf->msg[1]+2;
		buf = (U1*)pBuf->msg + MN_OUT_EVT(L3_MN_EVT)->inf_len;

		move_up_b(buf, FCINFDEF, 39);



		Encryption_Algorithm_Select = Sys_initdl1[37];	/*Get Encryption Algorithm Select Flag from EEPROM*/
		if(Encryption_Algorithm_Select)				/* STEPHI */
		{
			Mm_STEPHIenc(Sys_pin, AnsRslt, &buf[26]);
			// Modified by Yang Yajiang
		}
		else										/* FEAL32 */
		{
			/*Add by Qian Aidong for supporting FEAL32 Encryption Algorithm 2001-11-26*/
			Mm_FEAL32enc(Sys_pin, AnsRslt, &buf[26]);
		}


		move_up_b(AnsRslt, &buf[26], 8);


		len = Mn_PsnoBcdToIa5(Sys_psno, &buf[39], buf[38]);

		buf[37] = len + 1;
		buf[35] = buf[37] + 2;
		buf[20] = buf[35] + 15;
		buf[4]  = buf[20] + 16;
		buf[1]  = buf[4]  + 3;
		MN_OUT_EVT(L3_MN_EVT)->inf_len += (buf[1]+2);
		buf = (U1*)pBuf->msg + MN_OUT_EVT(L3_MN_EVT)->inf_len;

		buf[0] = ICALLNUM;
		if ((Sys_initdl1[9] == 0x04) && (Sys_initdl1[10] == 0x4A))
		{
			buf[2] = 0x80;
		}
		else
		{
			if ( Sys_initdl1[7] & BIT2 )
			{
				buf[2] = 0xA1;
			}
			else
			{
				buf[2] = 0x80;
			}
		}
		len = Mn_PsnoBcdToIa5(Sys_psno, &buf[3], buf[2]);

		buf[1] = len + 1;
		buf[buf[1] + 2] = IINCONUM;
		move_up_b(&buf[buf[1] + 3], &buf[1], (WORD)(buf[1] + 1));

		MN_OUT_EVT(L3_MN_EVT)->inf_len += ((buf[1]+2)*2);
		if ( LLCInfo[0] )
		{
			bufp = (U1*)pBuf->msg + MN_OUT_EVT(L3_MN_EVT)->inf_len;
			bufp[0] = ILOLAYER;
			move_up_b(&bufp[1], LLCInfo, (WORD)(LLCInfo[0]+1));

			MN_OUT_EVT(L3_MN_EVT)->inf_len += LLCInfo[0]+2;
		}
		MN_OUT_EVT(L3_MN_EVT)->inf_adr = (U1*)pBuf->msg;

		MN_OUT_EVT(L3_MN_EVT)->add_dat = 0x80|CallProt;

		MN_OUT_EVT(L3_MN_EVT)->dmy3 = CallSts - 1;


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

		ReCall = ON;

		CallMode = CALLMODE_OUT;
		ScrKey = OFF;
		Certify = OFF;
		CCSetup = MesSnd = ON;

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


U1	Mn_PsnoBcdToIa5(U1 *psno_bcd, U1 *psno_ia5, U1 kind)
{
	U1	i, cnt, psno;

	if ((Sys_initdl1[9] == 0x04) && (Sys_initdl1[10] == 0x4A))
	{
		if ((kind & 0x70) == 0x20)
			i = 1;
		else
			i = 0;
	}
	else
	{
		i = 0;
	}

	for (cnt = 0; i < 7; i++)
	{
		if (i != 0)
		{
			if ((psno = ((psno_bcd[i] >> 4) & 0x0F)) == 0)
				break;

			psno_ia5[cnt++] = ((psno == 0x0A) ? '0' : (psno + '0'));
		}

		if ((psno = (psno_bcd[i] & 0x0F)) == 0)
			break;

		psno_ia5[cnt++] = ((psno == 0x0A) ? '0' : (psno + '0'));
	}

	return (cnt);
}


void Mn_PHOTimOut(void)
{
	HoTim = OFF;

	TCHflg = OFF;


	MaxLCHCnt = 4;
	Mn_LCHMsgSet(CALLMODE_OUT);


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


	if(ST_PP_COMMUNCATING == *Mn_GetSpecState(phs_mode))
	{


		SYS_WORK->msg_adr = (M_MSB*)m_hntbuf();

		SYS_WORK->msg_adr->msg[0] =NONE;

		SYS_WORK->msg_adr->msg[1] = MTCHSTAT;

		SYS_WORK->msg_adr->msg[2] = 0x02;

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

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

		exec_uap(SYS_WORK->msg_adr);
	}


	*Mn_GetSpecState(phs_mode) = ST_PP_HANDOVER;

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

}



void Mn_PTchSyncOK(void)
{
	if (HoTim)
	{

		m_stptim(T1S, TIHANDOV, phs_mode);
		HoTim = OFF;
	}

	TCHflg = 0x00;

	Mn_TCHEndDsp();
}



void Mn_PTchSyncNG(void)//RT->MN
{
	if (HoTim)
	{

		m_stptim(T1S, TIHANDOV, phs_mode);
		HoTim = OFF;
	}


	if(TCH2 == MN_IN_EVT(L3_MN_EVT)->dmy3)
	{
		return;
	}

	Mn_PRadioInit();
}



void	Mn_PTchModori(void)
{
	Mn_TCHEndDsp();

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

	TCHflg = OFF;
}



void Mn_PCutReq(void)	//PM->MN
{
	M_MSB*	pMsg ;
	U1*		pSts;

	pMsg = MN_IN_EVT(PM_MN_EVT)->msg_adr;


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


	if( Mn_InfChk(&CHKTBL[4] , (U1*)&pMsg->msg[3] , pMsg->msg[2]) )
	{
		ReaVal = PRIERR;
		err_dsp(pMsg);
		return;
	}

	RetryCount = OFF;
	EstRetry = OFF;