maclib.c

一个运行在PIC上的WEB服务器

/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/*      maclib.c                   		 KS32C50100   : version 1.0 */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*                                                                       */
/* AUTHOR                                                                */
/*                                                                       */
/*                                                                       */
/* DATA STRUCTURES                                                       */
/*                                                                       */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*          Library For MAC Test Program                                 */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                                                       */
/*************************************************************************/
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
#include "string.h"
#include "uart.h"
#include "pollio.h"
#include "timer.h"
#include "isr.h"
#include "iic.h"
#include "memory.h"
#include "mac.h"

// Global variables  used for MAC driver
extern volatile U32 gMacCon,gMacTxCon,gBdmaTxCon ;
extern volatile U32 gMacRxCon,gBdmaRxCon,gCamCon ;

extern volatile U32 gCTxFDPtr, gWTxFDPtr ;
extern volatile U32 gCRxFDPtr, gPreviousFdp ;
extern volatile U32 gCam0_Addr0, gCam0_Addr1 ;
extern volatile U8 MyMacSrcAddr[6] ;
extern volatile int WatchDogTime, gErrorPacketCnt ;
extern volatile int BdmaRxDoneFlagForLoopBackCheck ;
extern volatile int MacTxDoneFlagForLoopBackCheck ;

U32 LoopCheckRxFD ;

// Global variable structure for store status
extern pMACTxStatus gsMacTxStatus ;
extern pMACRxStatus gsMacRxStatus ;
extern pBDMATxStatus gsBdmaTxStatus ;
extern pBDMARxStatus gsBdmaRxStatus ;

extern TIME tm0 ;

// variable for capture frame
extern volatile U32 gCapture_Addr0 , gCapture_Addr1 ;


/* --------------------------------------------------------------------*/
/* Frame buffer definition for restore received buffer                 */
/* In this diagonostic code, use unused area for received frame buffer */
/* --------------------------------------------------------------------*/
//#define RxFrameDataPreamble	0xCCCCCCCC	// Rx Frame Data Preamble 

sMACFrame PktBuff ;  //ren


volatile UserBuff UserReceiveBuff;
//清缓冲区
void ReceiveBuffer_init(void)
   {UserReceiveBuff.head=0;
    UserReceiveBuff.rear=0;
  } 
   
int  ReceiveBuffer_empty(void)    //判断缓冲区是否空
 {if (UserReceiveBuff.head==UserReceiveBuff.rear)
    return(1);   //头尾相等，缓冲区空
  else
    return(0);
 };
      
int ReceiveBuffer_full(void)     //缓冲区是否满
  {int i; 
   i=(UserReceiveBuff.rear-UserReceiveBuff.head)%UserBuffSize;
   if(i==(UserBuffSize-1))  //头尾指针差UserBuffSize-1，缓冲区满
     return(1);
   else  
     return(0);
   };  
sMACFrame * ReceiveBuffer_read(void)   //读一个数据,有可能出错，要注意 
 { //sMACFrame  *pt; 
 /*  if (ReceiveBuffer_empty())
     return(NULL);
   else
     { pt = &(UserReceiveBuff.frame[UserReceiveBuff.head]); 
       UserReceiveBuff.head=(UserReceiveBuff.head+1)%UserBuffSize; //头指针加1
       return(pt);
     }*/
 };
        
void ReceiveBuffer_write (const sMACFrame *frame,U16 length) //缓冲区增加一个数据
  {if (ReceiveBuffer_full())
     { printf("the receive buff is full");
       return;// 如果满，放弃当前数据包
     } 
   UserReceiveBuff.frame[UserReceiveBuff.rear] =*frame;
   UserReceiveBuff.length[UserReceiveBuff.rear] =length;
   UserReceiveBuff.rear=(UserReceiveBuff.rear+1)%UserBuffSize;//尾指针加1，
  };      

//  打印数据包
void ShowFrame(sMACFrame *frame)
  { int i,j;
    Print(" Now show the MacFrame the first 200 bytes: \n");
    Print("DestinationAddr:");
    for (i=0;i<6;i++)
      Print(" %x",frame->Header.DestinationAddr[i]);
    Print("\n SourceAddr:");
    for (i=0;i<6;i++)
      Print(" %x",frame->Header.SourceAddr[i]); 
    j=frame->Header.LengthOrType[1]+256*frame->Header.LengthOrType[0];
    Print("\n LengthOrType:%d\n",j);
    if(j>1518)
      j=1518;
    j=200;  
    for (i=0;i<(j-18);i++)
      Print(" %x",frame->LLCData[i]); //打印数据
    Print("\n");
   } 
void ReceivePacket( void) //接收数据
  { sMACFrame *PacketPoint;
     U16 i,j, length;
     PacketPoint=ReceiveBuffer_read(); //从缓冲区读一个数据包
     if (PacketPoint!=NULL)
       {ShowFrame(PacketPoint);
         PktBuff=*PacketPoint;
        for(i=0;i<6;i++)
          { j=PktBuff.Header.DestinationAddr[i];
            PktBuff.Header.DestinationAddr[i]=PktBuff.Header.SourceAddr[i];
            PktBuff.Header.SourceAddr[i]=j;
           }
        length=UserReceiveBuff.length[UserReceiveBuff.head] ;   
        if(SendPacket((U8 *)&PktBuff,length)) 
           Print(" the frame is send back.\n");
      }  
  }         

/*
 * Function : Random_Pkt_Transmit
 * Description : Transmit single ramdom packet size
 * Input : seed
 * Output : 1=> ok, 0=> fail
 */
int Random_Pkt_Transmit(void)
{
	int 		i ;
	int		Size ;
//	static int lenval;
//	U8 MyMacDstAddr[6]={0x00,0xe0,0x4c,0x84,0x71,0x58};
        
	// Set destination address
	for (i=0;i<6;i++) PktBuff.Header.DestinationAddr[i] =MyMacSrcAddr[i] ;// MyMacDstAddr[i] ;
	// Set source address
	for (i=0;i<6;i++) PktBuff.Header.SourceAddr[i] = MyMacSrcAddr[i] ;

	// Set length or type fields
  
	Size = rand() & 0x7FF ;
	if (Size > 1500) Size = 1500 ;
	//Size = Size%1501 ;
	if (Size < 46) Size = 46 ;
	//Q = ((Size)/2);
	//Size = 2*Q +2 ; 

	//Size = lenval+46+0 ;  
	//lenval = lenval + 1 ;
	//if(lenval == 1450)lenval = 0;

	//Print("Size : %d ", Size+14);

	PktBuff.Header.LengthOrType[1] = (U8)( (Size+18) & 0xFF ) ;
	PktBuff.Header.LengthOrType[0] = (U8)( ((Size+18) >> 8) & 0xFF ) ;

	// LLC data setup
	for (i=0;i<Size;i++) PktBuff.LLCData[i]  = (U8)(i+1 & 0xFF) ;
    ShowFrame(&PktBuff);  //打印数据包
	if ( SendPacket((U8 *)&PktBuff,Size) )  return 1 ;
	else return 0 ;
}


/*
 * Function : GetRxFrameData
 * Description : Move MAC Received Frame Data
 */
void GetRxFrameData(U8 *pFrameData, U32 FrameLength, U32 RxStatus)
{
//	U32 RxTime ;
//	U16 length;

	/* Receoved Frame Data Store Format */
	/* +------------------+             */
	/* | Preamble         |             */
	/* | Sequence| Time   |             */
	/* | Status  | Length |             */
	/* | Rx Data          |             */
	/* +------------------+             */

//	RxTime = tm0.tm_sec | (tm0.tm_min << 8) ;

    ReceiveBuffer_write ((sMACFrame *)pFrameData,(U16)FrameLength); //缓冲区增加一个数据
}








/*
 * Function : PollingLoopBackTest
 * Description : Send and Check Frame for Loopback Diagnostics (Polling)
 */
int PollingLoopBackTest(void)
{	
	sFrameDescriptor	*psTxFD ;
	U8 			*pTxFrameData ;

	U32 			status, result ;

	Print("\n >>> MAC Internal Loopback Test by Polling mode <<<") ;

	Disable_Int(nMAC_TX_INT);
	Disable_Int(nBDMA_RX_INT);
	MACCON |= MACLoop ;  // set Loopback bit(4)

	psTxFD = (sFrameDescriptor *)gWTxFDPtr ;
	pTxFrameData = (U8 *)psTxFD->FrameDataPtr ;

 	// --- Transmit Frame Data ---
	Random_Pkt_Transmit() ;

	// Wait until MAC Tx Done, by check MAC Tx Status Register
	// Polling Transmit finished
	while(1) {
		status = MACTXSTAT;
		if (status & Comp) break; 
	}

	MAC_Tx_isr() ;
	Print("\r MAC Tx done") ;

	// --- Receive Frame Data ---
	// Wait until BDMA Rx Done, by check BDMA Status Register
	// Polling Received
	while(1) {
		status = BDMASTAT;
		BDMASTAT = status ; 		// Clear Status Register
		if(status & S_BRxRDF) break; 	// Check BDMA Rx Done
	}

	BDMA_Rx_isr() ;
	Print("\r MAC Rx done") ;

   result = 1 ;

	MACCON &= ~MACLoop ; // Disable Loopback bit(4)
	Enable_Int(nMAC_TX_INT);
	Enable_Int(nBDMA_RX_INT);

	return result;
}