ge_protoreceive.c

程序是一个vxworks下对PMC公司3386千兆MAC芯片的驱动和配置

/**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-**-
*	GE_ProtoReceive.c - Ethernet 1000M code. . 
*
*	Copyright 2001-12 by GDT, Inc
*
*	modification history
*	--------------------
*       2001-12-14,yxy created.
*
*/

#include <string.h>
#include <msgQlib.h>
#include <errno.h>
#include "GE_Global.h"
#include "GE_GlobalP.h"
#include "GE_EventStatistic.h"
#include "GE_ProtoReceive.h"
#include "SBSL_Monitor.h"
#include "bdcom_860.h"
#include "GE_Utility.h"


MSG_Q_ID          GE_ProtoReceiveMsgQId;

unsigned int      COUNT=0;
unsigned int      GE_PRO_REV_DEBUG=0;

/********************************************************************************************
 * GE_ProtoReceiveInit: initlize the GE_ProtoReceive 
 */
STATUS	GE_ProtoReceiveInit(void)
{
	if (SBSL_TaskFlagGet(GE_PROTO_RECEIVE_TASK_CODE)!=SBSL_TASK_UNREGISTER)
	{
		if(GE_PRO_REV_DEBUG)		
			GE_printf(GE_ALARM,"GE_ProtoReceiveInit:the task has REGISTER!\n");
		return ERROR;
	}	
	if ((GE_ProtoReceiveMsgQId = msgQCreate(MAX_MSG_NUM,sizeof(TASK_MSG),MSG_Q_FIFO)) == NULL)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_ProtoReceiveInit:Creating MsgQ failed!\n");
		return ERROR;
	}
	if(SBSL_TaskRegister( 	GE_PROTO_RECEIVE_TASK_CODE,
				GE_ProtoReceiveMsgQId,
			        GE_ProtoReceiveReinit,
				GE_ProtoReceiveDel)==ERROR)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_ProtoReceiveInit:task register failed!\n");
		return ERROR;	
	}
	if(taskSpawn (	TASK_NAME[GE_PROTO_RECEIVE_TASK_CODE],
			GE_PROTORECEIVE_TASK_PRI,
			0,
			100000,
			(FUNCPTR)GE_ProtoReceive,
			0,0,0,0,0,0,0,0,0,0)==ERROR)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_ProtoReceiveInit:Creating task failed!\n");
		return ERROR;
	}			
	if(GE_PRO_REV_DEBUG)
		GE_printf(GE_EVENT,"GE_ProtoReceiveInit: init succeed!\n");
        return OK;
}
/********************************************************************************************
 * ProtoGroup_DEL: DEL the GE_ProtoReceiveTask 
 */
STATUS  GE_ProtoReceiveDel (void)
{
        if (SBSL_TaskFlagGet(GE_PROTO_RECEIVE_TASK_CODE) != SBSL_TASK_STARTED)
    	{
        	if(GE_PRO_REV_DEBUG)
        		GE_printf(GE_EVENT,"GE_ProtoReceiveTaskDel:task not start\n");
       	 	return ERROR;
    	}

        if(taskDelete (SBSL_TaskIdGet(GE_PROTO_RECEIVE_TASK_CODE))==ERROR )
        {
      		if(GE_PRO_REV_DEBUG)
      			GE_printf(GE_ALARM,"GE_ProtoReceiveDel:Delete GE_ProtoReceiveTask failed!");
       	     	return ERROR; 
        }
        if (SBSL_TaskMemClear(GE_PROTO_RECEIVE_TASK_CODE) == ERROR)
   	{
        	if(GE_PRO_REV_DEBUG)
        		GE_printf(GE_ALARM,"GE_ProtoReceiveDel:Mem clear failed!\n");        
        }/*continue run and may cause mem block lost*/ 
        if (SBSL_TaskStop(GE_PROTO_RECEIVE_TASK_CODE) == ERROR)
	{
	    	if(GE_PRO_REV_DEBUG)
	    		GE_printf(GE_ALARM,"GE_ProtoReceiveDel:TaskStop failed!\n");
	}
	return OK;	    	
 }
/********************************************************************************************
 * GE_ProtoReceiveReinit: reinit the GE_ProtoReceiveTask 
 */
STATUS  GE_ProtoReceiveReinit (void)
{
    	if (SBSL_TaskFlagGet(GE_PROTO_RECEIVE_TASK_CODE)== SBSL_TASK_STARTED)
     	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"The GE_ProtoReceiveTaskReInit:the task has started!\n");
		return ERROR;
     	}   
  	if (taskSpawn (	TASK_NAME[GE_PROTO_RECEIVE_TASK_CODE],
			GE_PROTORECEIVE_TASK_PRI,
			0,
			100000,
			(FUNCPTR)GE_ProtoReceive,
			0,0,0,0,0,0,0,0,0,0)== ERROR)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_ProtoReceiveReinit:Creating task failed!\n");
		return ERROR;
	}
   	if(GE_PRO_REV_DEBUG)
   		GE_printf(GE_EVENT,"GE_ProtoReceiveReinit:Creating Task success!\n");
	return OK;      	   	
}
/****************************************************************************************/
STATUS GE_ProtoReceive()
{
   	TASK_MSG  		ProtoReceiveMsg;
   	
    	while(BOARD_STATE != BOARD_STATE_NORMAL)
    	{
		taskDelay(30);
    	} 
    	SBSL_TaskStart(GE_PROTO_RECEIVE_TASK_CODE,taskIdSelf());
    	if(GE_PRO_REV_DEBUG)
    		GE_printf(GE_EVENT,"GE_ProtoReceiveTask is running...\n");   	
	while(1)
	{	
		if(++COUNT==75)
		{
			taskDelay(1);
			COUNT=0;
		}
		if(SBSL_TaskMsgIdGet(GE_PROTO_RECEIVE_TASK_CODE)==NULL)
       		{
       			return  ERROR;
       		}		
		while(msgQNumMsgs(GE_ProtoReceiveMsgQId)>0)
		{
	  		if(msgQReceive(	GE_ProtoReceiveMsgQId, 
	       				(char*) &ProtoReceiveMsg, 
	       				sizeof(TASK_MSG),
	       				NO_WAIT)==ERROR)
			{
				if(GE_PRO_REV_DEBUG)
					GE_printf(GE_ALARM,"GE_ProtoReceive:msgQNumMsgs>0,but not receive msg,ERROR!\n");
				break;
			}
	  	    	switch (ProtoReceiveMsg.type)
	   	    	{
				case 	MONITOR_MSG:
				if(GE_PRO_REV_DEBUG)
					GE_printf(GE_EVENT,"GE_ProtoReceive:Receive MONITOR_MSG !\n");
				ProtoReceiveMsg.taskCode = GE_PROTO_RECEIVE_TASK_CODE;
				ProtoReceiveMsg.type = MONITOR_MSG_ACK;
				ProtoReceiveMsg.length = 0;
				memset(ProtoReceiveMsg.msgBuf, 0, 128);
			
				if(msgQSend(	SBSL_TaskMsgIdGet(MONITOR_TASK_CODE), 
						(char *)&ProtoReceiveMsg, 
						140, 
						NO_WAIT, 
						MSG_PRI_URGENT) == ERROR)
				{
					if(GE_PRO_REV_DEBUG)
						GE_printf(GE_ALARM,"GE_ProtoReceive: send MONITOR_MSG_ACK  failed!\n");
					break;
				}  
				else
				{
					if(GE_PRO_REV_DEBUG)
						GE_printf(GE_EVENT,"GE_ProtoReceive:Send MONITOR_MSG_ACK  succeed!\n");	
				}	
				break;
				default:
					if(GE_PRO_REV_DEBUG)
						GE_printf(GE_ALARM,"GE_ProtoReceive:received type %d invalid!\n",ProtoReceiveMsg.type);
				break;
		     	}
		}
		GE_ReadProtoFifo();
	}
	return OK;
}
/***********************************************************************************
*
*	read infpga proto fifo.
*/
STATUS 	GE_ReadProtoFifo()
{    
    	ULONG	 	 	arpInBuf[32];
    	unsigned char	 	unit;
    	ULONG	 	 	InBuf[512];
    	ULONG	         	type; 
    	ULONG                	flag;
    	MSG_STRUCTURE        	*pktMsg;
    	ULONG        		pktLen,ipInBufLen,mplsInBufLen,arpInBufLen;
    	ULONG        		i;
    
	for(i=0;i<10;i++)
	{
    		taskLock();  
    		flag  = *(ULONG*)(0x13020014);  
    		taskUnlock();
    		
    		if((flag & 0x10) == 0x10)
    			break;
    	}
    	if(i==10)
    		return ERROR;

   	for(i=0;i<500;i++)
   	{
   		taskLock();
   		InBuf[i] = *(ULONG *)0x1302000C;
   		taskLock();
   		if(InBuf[i]==0xE25C4B89)
   			break;
   	} 
   	if(InBuf[i]==0xE25C4B89)  
   	{		
    		InBuf[0]=0xE25C4B89;
		for(i=1;i<500;i++)
		{
			
   			taskLock();
   			InBuf[i] = *(ULONG *)0x1302000C;
   			taskLock();
	    		if (InBuf[i-1]==0x1DA3B476 && InBuf[i]==0x1DA3B476)
		 	{
	 			pktLen=(i-2)*4;
	 			break;
	 		}
	 	}
	 	if(i>=500)
	 	{
 			if(GE_PRO_REV_DEBUG)
 				GE_printf(GE_ALARM,"GE_ReadProtoFifo:receive too long pkt!\n");
 			return ERROR;
 	 	}
 	}
 	else
 	{
 	 	if(GE_PRO_REV_DEBUG)
 			GE_printf(GE_ALARM,"GE_ReadProtoFifo:not receive pkt header!\n");
 		return ERROR;
 	}	
	 	 
 	type=(InBuf[1] & 0x0000FFFF);
	switch (type)
        {	  	
	 	/*ip protocol type ,0x0001 is selfDefined protocol type*/
		case 0x0001:
	 
         		unit=(unsigned char)((InBuf[1]&0x00FF0000)>>16);
	 		ipInBufLen=pktLen-4;
         		if(((void*)pktMsg = malloc(12+8+2+ipInBufLen))==NULL)
    			{
         			if(GE_PRO_REV_DEBUG)
         				GE_printf(GE_ALARM,"GE_ReadProtoFifo:memory allocation failed!\n");
         			return ERROR;
    			}
    			memset(&pktMsg->blank[0],0,SYS_BDCOM_HEAD_SIZE);
    			
         		pktMsg->type=IP_PKT_UPRECEIVE;
    			pktMsg->length = 2+ipInBufLen;   
			pktMsg->data[0]=GE_swiport;
			pktMsg->data[1]=unit;
			bcopy(((char*)&InBuf[2]),(char*)&pktMsg->data[2],ipInBufLen);
			
			if (BDCOM_UpReceive ( 	BDCOM_STREAM,
						NO_WAIT,
         					MSG_PRI_NORMAL,
         					SYS_BDCOM_HEAD_SIZE + 8+ 2+ ipInBufLen,
         					(UCHAR *) pktMsg,
         					SYS_BDCOM_HEAD_SIZE,
         					8+ 2+ ipInBufLen)   ==ERROR)
			{
       				if(GE_PRO_REV_DEBUG)
       					GE_printf(GE_ALARM,"GE_ReadProtoFifo: sending IP_PKT to BDCOM failed!\n");
       				free(pktMsg);
       				return ERROR;
			}
			else
    			{
			 	if(GE_PRO_REV_DEBUG)
        				GE_printf(GE_EVENT,"GE_ReadProtoFifo:sending IP_PKT to BDCOM succeed!\n");
    			}
         	break;		    	
    	 	/*arp protocol type ,0x0002 is selfDefined protocol type*/
    	 	case 0x0002:
	 		bcopy((char *)(&InBuf[1]),(char *)(&arpInBuf[0]),pktLen);
	 		arpInBufLen=pktLen;
	 		unit=(unsigned char)((InBuf[1]&0x00FF0000)>>16);
	 		GE_Arp_packet_receive(unit,arpInBuf);		
	 	break;
         	
         	/*impls protocol type ,0x0004 is selfDefined protocol type*/
	 	case 0x0004:
	 
         		unit=(unsigned char)((InBuf[1]&0x00FF0000)>>16);
	 		mplsInBufLen=pktLen-4;
         		if(((void*)pktMsg = malloc(12+8+2+mplsInBufLen))==NULL)
    			{
         			if(GE_PRO_REV_DEBUG)
         				GE_printf(GE_ALARM,"GE_ReadProtoFifo:memory allocation failed!\n");
         			return ERROR;
    			}
    			memset(&pktMsg->blank[0],0,SYS_BDCOM_HEAD_SIZE);
    			
         		pktMsg->type=MPLS_PKT_UPRECEIVE;
    			pktMsg->length = 2+mplsInBufLen;   
			pktMsg->data[0]=GE_swiport;
			pktMsg->data[1]=unit;
			bcopy(((char*)&InBuf[2]),(char*)&pktMsg->data[2],mplsInBufLen);
			
			if (BDCOM_UpReceive ( 	BDCOM_STREAM,
						NO_WAIT,
         					MSG_PRI_NORMAL,
         					SYS_BDCOM_HEAD_SIZE + 8+ 2+ mplsInBufLen,
         					(UCHAR *) pktMsg,
         					SYS_BDCOM_HEAD_SIZE,
         					8+ 2+ mplsInBufLen)   ==ERROR)
			{
       				if(GE_PRO_REV_DEBUG)
       					GE_printf(GE_ALARM,"GE_ReadProtoFifo: sending MPLS_PKT_UPRECEIVE to BDCOM failed!\n");
       				free(pktMsg);
       				return ERROR;
			}
			else
    			{
				printf("GE_ProtoRev:Send MPLS_PKT_UPRECEIVE to BDCOM succeed!\n");
        			if(GE_PRO_REV_DEBUG)
        				GE_printf(GE_EVENT,"GE_ReadProtoFifo:sending MPLS_PKT_UPRECEIVE to BDCOM succeed!\n");
    			}
         	break;	
 	}
   	return OK;	
}

/******************************************************************************************
*/
STATUS GE_SuspendProtoReceive()
{
	if(taskSuspend((SBSL_TaskIdGet(GE_PROTO_RECEIVE_TASK_CODE)))==ERROR)
	{
		return  ERROR;	
	}
	if(SBSL_TaskStop(GE_PROTO_RECEIVE_TASK_CODE)==ERROR)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_SuspendProtoReceive:suspendTask failed!\n");
		return ERROR;	
	}
	return OK;
}

STATUS GE_ResumeProtoReceive()
{
	if(taskResume((SBSL_TaskIdGet(GE_PROTO_RECEIVE_TASK_CODE)))==ERROR)
	{
		return ERROR;
	}
	if(SBSL_TaskStart(GE_PROTO_RECEIVE_TASK_CODE,SBSL_TaskIdGet(GE_PROTO_RECEIVE_TASK_CODE))==ERROR)
	{
		if(GE_PRO_REV_DEBUG)
			GE_printf(GE_ALARM,"GE_ResumeProtoReceive:resumTask failed!\n");
		return  ERROR;
	}
	return  OK;
}

/*end of file GE_PriotoReceive.c*/