ppp_framer.c

8032底层驱动部分。因为可以移植 所以单独来拿出来

	is_complete = KAL_FALSE;
	src_d.data_ptr = decode_src;
	src_d.cur_ptr = decode_src;	
	src_d.used = 100;
	src_d.end_ptr = decode_src+4096;
	src_d.protocol = 0xAA;
	src_d.size = 4096;

	dst_d.data_ptr = decode_dst;
	dst_d.cur_ptr = decode_dst;
	dst_d.used = 0;
	dst_d.end_ptr = decode_dst;
	dst_d.protocol = 0xAA;
	dst_d.size = BUF_LENGTH;

	state_d.is_acfc_rx = KAL_FALSE;
	state_d.is_pfc_rx = KAL_FALSE;
	state_d.is_update = KAL_TRUE;
	state_d.mru = SRC_LENGTH;
	state_d.xaccm = 0x1AC;
	state_d.raccm = DONT_CARE;	
	state_d.rfcs = DONT_CARE;
	state_d.xfcs = DONT_CARE;
	state_d.mtu = DONT_CARE;	
	while(is_complete == KAL_FALSE)
	{	
		is_complete = ppp_frame_decode(&dst_d ,&src_d,&state_d);
		src_d.used = 100;
		if(pfc_dcb.status == PFC_STAT_FCS_ERR)
		{
			kal_uint8 *ptr;
			ptr = (kal_uint8*)(src_d.cur_ptr-1);
			if(*ptr != 0x7E)
			{
				ASSERT(0);
				//PFC_FAIL_INDICATION();
			}
			else
			{
				//PFC_PASS_INDICATION();
			}
		}
	}	
	/*
	while(is_complete == KAL_FALSE)
	{		
		is_complete = ppp_frame_decode(&dst_d ,&src_d,&state_d);
		src_d.used = 100;
	}
	*/
	if(compare(decode_dst, encode_src, SRC_LENGTH))
		while(0);			
}
/*
1.	construct a invalid frame(control error ) + valid frame (the control field is
	escaped 03 -> 7D 23)
2. decoder should decode until the valid frame is finished.
*/
// fail PFC can not detect the escaped control field (7D 23)
void test_case_5(void)
{
	kal_bool is_complete;
	
	PFC_test_init();
	src_e.data_ptr = encode_src;
	src_e.cur_ptr = encode_src;	
	src_e.used = SRC_LENGTH;
	src_e.end_ptr = encode_src+SRC_LENGTH;
	src_e.protocol = 0xAA;
	src_e.size = BUF_LENGTH;

	dst_e.data_ptr = encode_dst;
	dst_e.cur_ptr = encode_dst;
	dst_e.used = 0;
	dst_e.end_ptr = encode_dst;
	dst_e.protocol = 0xAA;
	dst_e.size = BUF_LENGTH;

	state_e.is_acfc_tx = KAL_FALSE;
	state_e.is_pfc_tx = KAL_FALSE;
	state_e.is_update = KAL_TRUE;
	state_e.mru = SRC_LENGTH;
	state_e.xaccm = 0x1AC;
	state_e.raccm = DONT_CARE;	
	state_e.rfcs = DONT_CARE;
	state_e.xfcs = DONT_CARE;
	state_e.mtu = DONT_CARE;
	ppp_frame_encode(&dst_e, &src_e, &state_e);
	memcpy(decode_src , encode_dst, dst_e.used);
	decode_src[3] = 0x24; // address field (0xff)
	memcpy(decode_src+dst_e.used, encode_dst, dst_e.used);
	
	// decode 
	is_complete = KAL_FALSE;
	src_d.data_ptr = decode_src;
	src_d.cur_ptr = decode_src;	
	src_d.used = 100;
	src_d.end_ptr = decode_src+4096;
	src_d.protocol = 0xAA;
	src_d.size = 4096;

	dst_d.data_ptr = decode_dst;
	dst_d.cur_ptr = decode_dst;
	dst_d.used = 0;
	dst_d.end_ptr = decode_dst;
	dst_d.protocol = 0xAA;
	dst_d.size = BUF_LENGTH;

	state_d.is_acfc_rx = KAL_FALSE;
	state_d.is_pfc_rx = KAL_FALSE;
	state_d.is_update = KAL_TRUE;
	state_d.mru = SRC_LENGTH;
	state_d.xaccm = 0x1AC;
	state_d.raccm = DONT_CARE;	
	state_d.rfcs = DONT_CARE;
	state_d.xfcs = DONT_CARE;
	state_d.mtu = DONT_CARE;	
	while(is_complete == KAL_FALSE)
	{	
		is_complete = ppp_frame_decode(&dst_d ,&src_d,&state_d);
		src_d.used = 377;
		if(pfc_dcb.status == PFC_STAT_FCS_ERR)
		{
			kal_uint8 *ptr;
			ptr = (kal_uint8*)(src_d.cur_ptr-1);
			if(*ptr != 0x7E)
			{
				ASSERT(0);
				//PFC_FAIL_INDICATION();
			}
			else
			{
				//PFC_PASS_INDICATION();
			}
		}
	}	
	if(compare(decode_dst, encode_src, SRC_LENGTH))
		while(0);			
}
/*
1.	construct a invalid frame(control error ) + valid frame (the control field is not
	escaped 03 -> 7D 23)
2. decoder should decode until the valid frame is finished.
*/
// fail PFC can not detect the escaped control field (7D 23)
void test_case_6(void)
{
	kal_bool is_complete;
	
	PFC_test_init();
	src_e.data_ptr = encode_src;
	src_e.cur_ptr = encode_src;	
	src_e.used = SRC_LENGTH;
	src_e.end_ptr = encode_src+SRC_LENGTH;
	src_e.protocol = 0xAA;
	src_e.size = BUF_LENGTH;

	dst_e.data_ptr = encode_dst;
	dst_e.cur_ptr = encode_dst;
	dst_e.used = 0;
	dst_e.end_ptr = encode_dst;
	dst_e.protocol = 0xAA;
	dst_e.size = BUF_LENGTH;

	state_e.is_acfc_tx = KAL_FALSE;
	state_e.is_pfc_tx = KAL_FALSE;
	state_e.is_update = KAL_TRUE;
	state_e.mru = SRC_LENGTH;
	state_e.xaccm = 0x1A3;
	state_e.raccm = DONT_CARE;	
	state_e.rfcs = DONT_CARE;
	state_e.xfcs = DONT_CARE;
	state_e.mtu = DONT_CARE;
	ppp_frame_encode(&dst_e, &src_e, &state_e);
	memcpy(decode_src , encode_dst, dst_e.used);
	decode_src[2] = 0x4; // address field (0xff)
	memcpy(decode_src+dst_e.used, encode_dst, dst_e.used);
	
	// decode 
	is_complete = KAL_FALSE;
	src_d.data_ptr = decode_src;
	src_d.cur_ptr = decode_src;	
	src_d.used = 100;
	src_d.end_ptr = decode_src+4096;
	src_d.protocol = 0xAA;
	src_d.size = 4096;

	dst_d.data_ptr = decode_dst;
	dst_d.cur_ptr = decode_dst;
	dst_d.used = 0;
	dst_d.end_ptr = decode_dst;
	dst_d.protocol = 0xAA;
	dst_d.size = BUF_LENGTH;

	state_d.is_acfc_rx = KAL_FALSE;
	state_d.is_pfc_rx = KAL_FALSE;
	state_d.is_update = KAL_TRUE;
	state_d.mru = SRC_LENGTH;
	state_d.xaccm = 0x1AC;
	state_d.raccm = DONT_CARE;	
	state_d.rfcs = DONT_CARE;
	state_d.xfcs = DONT_CARE;
	state_d.mtu = DONT_CARE;	
	while(is_complete == KAL_FALSE)
	{	
		is_complete = ppp_frame_decode(&dst_d ,&src_d,&state_d);
		src_d.used = 377;
		if(pfc_dcb.status == PFC_STAT_FCS_ERR)
		{
			kal_uint8 *ptr;
			ptr = (kal_uint8*)(src_d.cur_ptr-1);
			if(*ptr != 0x7E)
			{
				ASSERT(0);
				//PFC_FAIL_INDICATION();
			}
			else
			{
				//PFC_PASS_INDICATION();
			}
		}
	}	
	if(compare(decode_dst, encode_src, SRC_LENGTH))
		while(0);			
}

// generate 10 ppp framer which separated by one 0x7e
// decode them continuously
void test_case_7(void)
{
	kal_uint32 i = 0;
	kal_uint8 *r,*w;
	
	PFC_test_init();
	src_e.data_ptr = encode_src;
	//src_e.cur_ptr = encode_src;	
	//src_e.used = SRC_LENGTH;
	src_e.end_ptr = encode_src+SRC_LENGTH;
	src_e.protocol = 0xAA;
	src_e.size = BUF_LENGTH;

	dst_e.data_ptr = encode_dst;
	dst_e.cur_ptr = encode_dst;
	dst_e.used = 0;
	//dst_e.end_ptr = encode_dst;
	dst_e.protocol = 0xAA;
	//dst_e.size = BUF_LENGTH;
	dst_e.size = BUF_LENGTH;
	state_e.is_acfc_tx = KAL_TRUE;
	state_e.is_pfc_tx = KAL_TRUE;
	state_e.is_update = KAL_TRUE;
	state_e.mru = SRC_LENGTH;
	//state_e.xaccm = 0x1AC;
	state_e.xaccm = 0;
	state_e.raccm = DONT_CARE;	
	state_e.rfcs = DONT_CARE;
	state_e.xfcs = DONT_CARE;
	state_e.mtu = DONT_CARE;
	r = encode_src;
	w = dst_e.data_ptr;
	for(i=0;i<10;i++)
	{
		src_e.used = 16;
		src_e.cur_ptr = r;	
		dst_e.end_ptr = w;
		dst_e.cur_ptr = w;
		ppp_frame_encode(&dst_e, &src_e, &state_e);
		r += 16;
		w +=  (dst_e.used-1);

	}

	src_d.data_ptr = encode_dst;
	//src_d.cur_ptr = encode_dst;	
	src_d.used = BUF_LENGTH;
	src_d.end_ptr = encode_dst+BUF_LENGTH;
	src_d.protocol = 0xAA;
	src_d.size = BUF_LENGTH;

	dst_d.data_ptr = decode_dst;
	dst_d.cur_ptr = decode_dst;
	dst_d.used = 0;
	dst_d.end_ptr = decode_dst;
	dst_d.protocol = 0xAA;
	dst_d.size = BUF_LENGTH;

	state_d.is_acfc_rx = KAL_TRUE;
	state_d.is_pfc_rx = KAL_TRUE;
	state_d.is_update = KAL_TRUE;
	state_d.mru = SRC_LENGTH;
	state_d.xaccm = 0x1AC;
	state_d.raccm = DONT_CARE;	
	state_d.rfcs = DONT_CARE;
	state_d.xfcs = DONT_CARE;
	state_d.mtu = DONT_CARE;

	r = src_d.data_ptr;
	w = dst_d.data_ptr;
	for(i=0;i<10;i++)
	{
		src_d.cur_ptr = r;			
		dst_d.cur_ptr = w;
		dst_d.end_ptr = w;
		dst_d.used = 0;
		ppp_frame_decode(&dst_d ,&src_d,&state_d);
		src_d.used = BUF_LENGTH;
		r = src_d.cur_ptr;
		w +=  dst_d.used;
		
	}
	if(compare(decode_dst, encode_src, SRC_LENGTH))
		while(0);	
}

// verify the DACCM, insert some daccm characters into the encoded frame, the deocded
void test_case_8(void)
{
	#define ACCM 0x93251137

	// encode a ppp frame
	src_e.data_ptr = encode_src;
	src_e.cur_ptr = encode_src;	
	src_e.used = SRC_LENGTH;
	src_e.end_ptr = encode_src+SRC_LENGTH;
	src_e.protocol = 0xAA;
	src_e.size = BUF_LENGTH;

	dst_e.data_ptr = encode_dst;
	dst_e.cur_ptr = encode_dst;
	dst_e.used = 0;
	dst_e.end_ptr = encode_dst;
	dst_e.protocol = 0xAA;
	dst_e.size = BUF_LENGTH;

	state_e.is_acfc_tx = KAL_TRUE;
	state_e.is_pfc_tx = KAL_TRUE;
	state_e.is_update = KAL_TRUE;
	state_e.mru = SRC_LENGTH;
	state_e.xaccm = ACCM;
	state_e.raccm = ACCM;	
	state_e.rfcs = DONT_CARE;
	state_e.xfcs = DONT_CARE;
	state_e.mtu = DONT_CARE;
	
	ppp_frame_encode(&dst_e, &src_e, &state_e);	

	// insert some daccm escaped character into generated ppp frame
	{
		#define ADD_ESC_COUNT  100
		kal_uint8 *ptr = encode_dst+1, esc[32],num;
		kal_uint8 *in, *out;
		kal_uint32 i, count,j;

		in = encode_dst;
		out = decode_src;
		
		num = 0;
		for(i=0;i<32;i++)
		{
			if(ACCM & (1<<i))
			{
				esc[num] = i;
				num++;				
			}
		}
		count = ADD_ESC_COUNT; // number of escape character inerted into encoded frame
		i = 0;
		j = 0;
		out[i++] = in[j++];
		while(j<dst_e.used)
		{
			if((count!=0)&&(rand()&1))
			{
				out[i] = esc[rand()%num];
				i++;
				count--;
			}
			else
			{
				out[i] = in[j];
				i++;
				j++;
			}
		}		
	}	
	// decode it.
	src_d.data_ptr = decode_src;
	src_d.cur_ptr = decode_src;	
	src_d.used = BUF_LENGTH;
	src_d.end_ptr = decode_src+BUF_LENGTH;
	src_d.protocol = 0xAA;
	src_d.size = BUF_LENGTH;

	dst_d.data_ptr = decode_dst;
	dst_d.cur_ptr = decode_dst;
	dst_d.used = 0;
	dst_d.end_ptr = decode_dst;
	dst_d.protocol = 0xAA;
	dst_d.size = BUF_LENGTH;

	state_d.is_acfc_rx = KAL_TRUE;
	state_d.is_pfc_rx = KAL_TRUE;
	state_d.is_update = KAL_TRUE;
	state_d.mru = SRC_LENGTH;
	state_d.xaccm = ACCM;
	state_d.raccm = ACCM;	
	state_d.rfcs = DONT_CARE;
	state_d.xfcs = DONT_CARE;
	state_d.mtu = DONT_CARE;	
	ppp_frame_decode(&dst_d ,&src_d,&state_d);
	if(compare(decode_dst, encode_src, SRC_LENGTH))
		while(0);		
}
#else
/* general interface verification*/
kal_bool e[2],d[2],c[2];
kal_uint32 a[2],p[2];
kal_int32 len_e[2],count[2];

void test_case_9(void)
{
	kal_uint8 id1, id2,id ;
	kal_bool status;
	kal_uint32 loop = 0xffffffff;
	
	ppp_frame_initialize_all();
	PFC_test_init();
	id1 = ppp_frame_open(PFC_CSD_OWNER);
	id2 = ppp_frame_open(PFC_GPRS_OWNER);
	dbg_print("start test_case_9 \r\n");
	while(loop--)
	{		
		srand(loop);
		id = (rand()&1)?id1:id2;
		if(e[id] == KAL_FALSE)
		{	// encode a frame
			src_e[id].data_ptr = encode_src[id];
			src_e[id].cur_ptr = encode_src[id];	
			src_e[id].used = SRC_LENGTH;
			src_e[id].end_ptr = encode_src[id]+SRC_LENGTH;
			src_e[id].protocol = rand()&0xffff;
			src_e[id].size = BUF_LENGTH;

			dst_e[id].data_ptr = encode_dst[id];
			dst_e[id].cur_ptr = encode_dst[id];
			dst_e[id].used = 0;
			dst_e[id].end_ptr = encode_dst[id];
			dst_e[id].protocol = DONT_CARE;
			dst_e[id].size = BUF_LENGTH;
			c[id] = ((rand()&1) == 1);
			state_e[id].is_acfc_tx = c[id];
			state_e[id].is_pfc_tx = c[id];
			state_e[id].is_update = KAL_TRUE;
			state_e[id].mru = SRC_LENGTH;

			// disable accm
			//a[id] = rand()&0xffffffff;
			a[id] = 0;
			state_e[id].xaccm = a[id];
			state_e[id].raccm = DONT_CARE;	
			state_e[id].rfcs = DONT_CARE;
			state_e[id].xfcs = DONT_CARE;
			state_e[id].mtu = DONT_CARE;

			if(c[id] == KAL_TRUE)
				src_e[id].protocol &= 0xff;
			if(src_e[id].protocol == 0x7e || src_e[id].protocol == 0x7d ||
				src_e[id].protocol == 0x80 || src_e[id].protocol == 0x00 ||
				src_e[id].protocol == 0xc0 || src_e[id].protocol == 0xc2)
				src_e[id].protocol = 5;
			
			
			time1 = DRV_Reg(0x80100020);
			status = ppp_frame_encode_all(&dst_e[id], &src_e[id], &state_e[id], id);
			time2 = GPT3_TimeDiff(time1);	
			len_e[id] = dst_e[id].used; 
			ASSERT(status == KAL_TRUE);
			e[id] = KAL_TRUE;
		}
		else
		{	// decode a frame	
			src_d[id].used = rand()%0xff+10;
			len_e[id] -= src_d[id].used;
			if(d[id] == KAL_FALSE)
			{
				d[id] = KAL_TRUE;
				src_d[id].data_ptr = encode_dst[id];
				src_d[id].cur_ptr = encode_dst[id];	
				src_d[id].end_ptr = encode_dst[id]+BUF_LENGTH;
				src_d[id].protocol = DONT_CARE;
				src_d[id].size = 4096;

				dst_d[id].data_ptr = decode_dst[id];
				dst_d[id].cur_ptr = decode_dst[id];
				dst_d[id].used = 0;
				dst_d[id].end_ptr = decode_dst[id];
				dst_d[id].protocol = DONT_CARE;
				dst_d[id].size = BUF_LENGTH;

				state_d[id].is_acfc_rx = c[id];
				state_d[id].is_pfc_rx = c[id];
				// state_d[id].is_update = KAL_TRUE;
				state_d[id].mru = SRC_LENGTH;
				state_d[id].xaccm = DONT_CARE;
				state_d[id].raccm = a[id];	
				state_d[id].rfcs = DONT_CARE;
				state_d[id].xfcs = DONT_CARE;
				state_d[id].mtu = DONT_CARE;	
			}
			status = ppp_frame_decode_all(&dst_d[id] ,&src_d[id],&state_d[id], id);
			len_e[id] += src_d[id].used;
			if(status == KAL_TRUE)
			{
				ASSERT(len_e[id] == 0);
				e[id] = KAL_FALSE;
				d[id] = KAL_FALSE;
				count[id]++;
				if(compare(decode_dst[id], encode_src[id], SRC_LENGTH))
					ASSERT(0);					
				dbg_print("id: %d, decode %d frames \r\n", id, count[id]); 
			}		
		}
	}	
	ppp_frame_close(id1);
	ppp_frame_close(id2);
	
}
#endif	// PFC_UNIT_TEST_ALL

void PPPFramer_test()
{	
	
	myGPT3_Init();
	PFC_Initialize();
	PFC_test_init();

#if !defined(PFC_UNIT_TEST_ALL)
	test_case_8();
	test_case_7();
	test_case_6();
	test_case_5();	  // fail
	test_case_3_1(); // fail
	test_case_4();
	test_case_1();
	test_case_2();
	test_case_3();	// fail
#else
	test_case_9();
#endif

			
}
#endif
#endif // unit test 
#endif //__L1_STANDALONE__