/*
************************************************************
*                         TEST1.C
*                      uCOS EXAMPLE
************************************************************
*/
#include "INCLUDES.H"
#include "trsocket.h"
#include <trmpc860.h>

#define          STK_SIZE       4096
OS_TCB           OSTCBTbl[OS_MAX_TASKS];
UWORD            OSIdleTaskStk[STK_SIZE];
UWORD            Stk1[STK_SIZE];
UWORD            Stk2[STK_SIZE];
UWORD            Stk3[STK_SIZE];
UWORD            Stk4[STK_SIZE];
UWORD            Stk5[STK_SIZE];
UWORD            Stk6[STK_SIZE];
UWORD            Stk7[STK_SIZE];
UWORD            Stk8[STK_SIZE];
UWORD            Stk9[STK_SIZE];
char             Data1;
char             Data2;
char             Data3;
char             Data4;
char             Data5;
char             Data6;
char             Data7;
char             Data8;
char             Data9;

void             treckTask(void *data);
void             timerTask(void *data);
void             recvTask(void *interfaceHandle);
void             serverTask(void *interfaceHandle);
/* void             sendTask(void *interfaceHandle); */
void             OSSetUpTimer(void);
extern           unsigned char tvUdpChecksumOn;

typedef int (*ttFreeRecvBufferFuncPtr)(ttUserInterface interfaceHandle,
             char TM_FAR    *dataPtr);


/*
 * Test Driver
 */

int sendSmallCopy(int sd, struct sockaddr_in *toAddress, char *testPtr);
int sendLargeCopy(int sd, struct sockaddr_in *toAddress, char *testPtr);
int sendSmallNoCopy(int sd, struct sockaddr_in *toAddress);
int sendLargeNoCopy(int sd, struct sockaddr_in *toAddress);
int sendTcpSmallCopy(int sd, char *testPtr);
int sendTcpLargeCopy(int sd, char *testPtr);

static unsigned long testBuf[2000];
static unsigned long testInBuf[2000];
volatile int treckError;
void main(void)
{
    Data1 = '1';
    Data2 = '2';
    Data3 = '3';
    Data4 = '4';
    Data5 = '5';
    Data6 = '6';
    Data7 = '7';
    Data8 = '8';
    Data9 = '9';
    

    OSInit();
    OSTaskCreate(treckTask, (void *)&Data9, (void *)&Stk9[STK_SIZE], 9);
    OSStart();
}
volatile int masterError;
volatile int testType;
volatile unsigned long dataCount;
void treckTask(void *data)
{
    int sd;
    int tsd;
    int errorCode;
    ttUserIpAddress ipAddress;
    ttUserIpAddress netMask;
    ttUserLinkLayer linkLayerHandle;
    ttUserInterface interfaceHandle;
    struct sockaddr_in toAddress;
    char TM_FAR *testBufPtr;
    int         portNumber;
    int         toPortNumber;
    
/* Start Treck */
    tfStartTreck();
/* Use the Ethernet Link Layer (Including ARP) */
    linkLayerHandle=tfUseEthernet();
/* We have to start the timer before we init the SCC because we init the mpc860 in the timer */
    OSSetUpTimer();
/* Add the Interface */
    interfaceHandle=tfAddInterface(
            "MPC860.SCC1",
            linkLayerHandle,
            tfMpc860EtherOpen,
            tfMpc860EtherClose,
            tfMpc860Send,
            tfMpc860Receive,
            (ttFreeRecvBufferFuncPtr)0,
            tfMpc860Ioctl,
            tfMpc860GetPhyAddr,
            &errorCode);

    portNumber=5050;    
/*    toPortNumber=2081;  */
/*    toPortNumber=7; */
    toPortNumber=9; 

/* Start the tasks */
    OSTaskCreate(timerTask, (void *)&interfaceHandle, (void *)&Stk1[STK_SIZE],1);
    OSTaskCreate(recvTask, (void *)&interfaceHandle, (void *)&Stk2[STK_SIZE], 2);
/*    OSTaskCreate(sendTask, (void *)&interfaceHandle, (void *)&Stk3[STK_SIZE], 3); */
/*    OSTaskCreate(serverTask, (void *)&portNumber, (void *)&Stk4[STK_SIZE], 4); */

    ipAddress=inet_addr("208.229.201.110");
/* 255.255.255.192 */    
    netMask=htonl(0xffffffc0);
/* Config the Interface */    
    errorCode=tfConfigInterface(
            interfaceHandle,
            ipAddress,
            netMask,
            TM_DEV_SCATTER_SEND_ENB,  
            5,  
            0);
/* Open a socket */
    toAddress.sin_family=PF_INET;
    toAddress.sin_addr.s_addr=inet_addr("208.229.201.80");
    toAddress.sin_port=htons(toPortNumber);
    tvUdpChecksumOn=0;
   
    testBufPtr=(char *)testBuf;
/* Test Type */
    testType=2;
    dataCount=4;
    sd=socket(PF_INET,SOCK_DGRAM,0);
    tsd=socket(PF_INET,SOCK_STREAM,0);
    switch (testType)
    {
        case 0:
            while (1)
            {
                errorCode=sendSmallCopy(sd, &toAddress,testBufPtr);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(sd);
                }
            }
            break;
        case 1:
            while (1)
            {
                errorCode=sendLargeCopy(sd, &toAddress,testBufPtr);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(sd);
                }
            }
            break;
        case 2:
            while (1)
            {
                errorCode=sendSmallNoCopy(sd, &toAddress);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(sd);
                }
            }
            break;
        case 3:
            while (1)
            {
                errorCode=sendLargeNoCopy(sd, &toAddress);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(sd);
                }
            }
            break;
        case 4:
            while (1)
            {
                errorCode=connect(tsd,
                         (const struct sockaddr TM_FAR *)&toAddress,
                         sizeof(toAddress));
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(tsd);
                }
                errorCode=sendTcpSmallCopy(tsd,testBufPtr);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(tsd);
                }
            }
            break;
        case 5:
            while (1)
            {
                errorCode=connect(tsd,
                         (const struct sockaddr TM_FAR *)&toAddress,
                         sizeof(toAddress));
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(tsd);
                }
                errorCode=sendTcpLargeCopy(tsd,testBufPtr);
                if (errorCode!=TM_ENOERROR)
                {
                    treckError=tfGetSocketError(tsd);
                }
            }
            break;
        case 9:
            while (1)
            {
                ;
            }
        default:
            break;
    }
    masterError=errorCode;
}

extern unsigned long     tvMpc860SendPacketCount;
unsigned long tvSocketSendCount;
int sendSmallCopy(int sd, struct sockaddr_in *toAddress, char *testPtr)
{
   int errorCode;
   
   tvSocketSendCount=0UL;
   
   while (1) {
        errorCode = sendto(sd,testPtr,18,0,
            (const struct sockaddr TM_FAR *)toAddress,(int)sizeof(struct sockaddr)); 
        tvSocketSendCount++;
        if (errorCode == -1)
        {
            treckError=tfGetSocketError(sd);
            break;
        }
    }
    return errorCode;
}

int sendTcpSmallCopy(int sd, char *testPtr)
{
   int errorCode;
   
   tvSocketSendCount=0UL;
   while (1) {
        *((unsigned long *)testPtr)=htonl(dataCount++);
        errorCode = send(sd,testPtr,18,0);
        tvSocketSendCount++;
        if (errorCode == -1)
        {
            treckError=tfGetSocketError(sd);
            break;
        }
    }
    return errorCode;
}

int sendTcpLargeCopy(int sd, char *testPtr)
{
   int errorCode;
   int bytes;
   
   tvSocketSendCount=0UL;
   while (1) {
        *((unsigned long *)testPtr)=htonl(dataCount++);
        errorCode = send(sd,testPtr,1900,0);
        tvSocketSendCount++;
        if (errorCode == -1)
        {
            treckError=tfGetSocketError(sd);
            break;
        }
        bytes=recv(sd,testPtr,3000,0);
        if (bytes < 0)
        {
            treckError=tfGetSocketError(sd);
        }
    }
    return errorCode;
}

static unsigned long tlSendCount;
static unsigned long tlRecvCount;

int sendLargeCopy(int sd, struct sockaddr_in *toAddress, char *testPtr)
{
   int errorCode;
   struct sockaddr_in fromAddress;
   int    recvFromLen;
   int    bytes;
   int    count;
   
   tlSendCount=0UL;
   tlRecvCount=0UL;
   while (1) 
   {
        errorCode = sendto(sd,testPtr,1472,0,
            (const struct sockaddr TM_FAR *)toAddress,(int)sizeof(struct sockaddr)); 
        if (errorCode == -1)
        {
            treckError=tfGetSocketError(sd);
            break;
        }
        else
        {
            tlSendCount++;
            for (count=0; count<10000;count++)
            {
                recvFromLen=sizeof(fromAddress);
                bytes=recvfrom(sd,(char TM_FAR *)testInBuf,1472,MSG_DONTWAIT,
                     (struct sockaddr TM_FAR *)&fromAddress,
                     (int TM_FAR *)&recvFromLen);
                if (bytes < 0)
                {
                    treckError=tfGetSocketError(sd);
                    if (treckError!=235)
                    {
                        while(1);
                    }
                }
                else
                {
                    tlRecvCount++;
                    break;
                }
            }
        }
    }
    return errorCode;
}

static long tlTicks;
static unsigned long tlTocks;
void tfKernelSetCritical();
void tfKernelReleaseCritical();
void OSNoInterrupt(void);
int sendSmallNoCopy(int sd, struct sockaddr_in *toAddress)
{
   char         *testPtr;
   int           errorCode;
   ttUserMessage bufferHandle;

   tlTocks=0UL;
   while (1) 
   {
        bufferHandle=tfGetZeroCopyBuffer(18,&testPtr);
        errorCode = tfZeroCopySendTo(sd,bufferHandle,18,0,
            (const struct sockaddr TM_FAR *)toAddress,(int)sizeof(struct sockaddr)); 

        tlTocks++;
        if (errorCode == -1)
        {
            break;
        }
    }
    return errorCode;
}

int sendLargeNoCopy(int sd, struct sockaddr_in *toAddress)
{
   char         *testPtr;
   int           errorCode;
   ttUserMessage bufferHandle;

   while (1) {
        bufferHandle=tfGetZeroCopyBuffer(1472,&testPtr);
        errorCode = tfZeroCopySendTo(sd,bufferHandle,1472,0,
            (const struct sockaddr TM_FAR *)toAddress,(int)sizeof(struct sockaddr)); 
        if (errorCode == -1)
        {
            break;
        }
    }
    return errorCode;
}

void timerTask(void *interfaceHandle)
{
    tlTicks=0;
    while (1) 
    {
        tlTicks++;
        tfTimerUpdate();
        tfTimerExecute(); 
        OSTimeDly(1);
        (void)tfIoctlInterface(*(ttUserInterface *)interfaceHandle,
                               TM_MPC860_REFILL_SCC1|TM_MPC860_SEND_COMPLETE,
                               (void TM_FAR *)0, 0);

    }
}

void recvTask(void *interfaceHandle)
{
    while (1) 
    {
        (void)tfWaitReceiveInterface(*(ttUserInterface *)interfaceHandle);
        (void)tfRecvInterface(*(ttUserInterface *)interfaceHandle); 
    }
}


void serverTask(void *dataPortPtr)
{
    int errorCode;
    int bytes;
    int sd;
    struct sockaddr_in fromAddress;
    struct sockaddr_in ourAddress;
    int    recvFromLen;
    
    sd=socket(PF_INET,SOCK_DGRAM,0);
    if (sd<0)
    {
        treckError=tfGetSocketError(sd);
    }
/* Open a socket */
    ourAddress.sin_family=PF_INET;
    ourAddress.sin_addr.s_addr=inet_addr("127.0.0.1");
    ourAddress.sin_port=htons(*(int *)dataPortPtr);
    errorCode=bind(sd,(const struct sockaddr TM_FAR *)&ourAddress,sizeof(ourAddress));
    if (errorCode!= TM_ENOERROR)
    {
        treckError=tfGetSocketError(sd);
    }
    while (1) 
    {
        recvFromLen=sizeof(fromAddress);
        bytes=recvfrom(sd,(char TM_FAR *)testInBuf,1472,0,
             (struct sockaddr TM_FAR *)&fromAddress,
             (int TM_FAR *)&recvFromLen);
        if (bytes > 0)
        {
            errorCode = sendto(sd,(char TM_FAR *)testInBuf,bytes,0,
                (const struct sockaddr TM_FAR *)&fromAddress,(int)sizeof(struct sockaddr)); 
            if (errorCode <= 0)
            {
                treckError=tfGetSocketError(sd);
            }
        }
        else
        {
            treckError=tfGetSocketError(sd);
        }
             
    }
}
#if 0
void sendTask(void *interfaceHandle)
{
    int errorCode;
    while (1) 
    {
        errorCode=tfWaitSentInterface(*(ttUserInterface *)interfaceHandle);
        if (errorCode==TM_ENOERROR)
        {
            tfSendCompleteInterface(*(ttUserInterface *)interfaceHandle,
                TM_DEV_SEND_COMPLETE_APP);
        }
    }
}
#endif