/* secEnd.c - END style ATMEL AAT91RM9200 Ethernet network interface driver  */#include "vxWorks.h"#include "intLib.h"#include "errno.h"#include "net/mbuf.h"#include "net/unixLib.h"#include "net/protosw.h"#include "sys/socket.h"#include "sys/ioctl.h"#include "net/route.h"#include "cacheLib.h"#include "logLib.h"#include "netLib.h"#include "stdio.h"#include "stdlib.h"#include "sysLib.h"#include "taskLib.h"#include "net/systm.h"#include "sys/times.h"#include "net/if_subr.h"#undef  ETHER_MAP_IP_MULTICAST#include "etherMultiLib.h"#include "end.h"#include "semLib.h"#define END_MACROS#include "endLib.h"#include "miiLib.h"#include "lstLib.h"#include "config.h"#include "drv/end/secEnd.h"/* Defines */#undef  DEBUG_TRACE/*#define DEBUG_LOG(x, p1, p2, p3, p4, p5, p6) \        logMsg(x, (int)(UINT32)(p1), (int)(UINT32)(p2), (int)(UINT32)(p3), (int)(UINT32)(p4), (int)(UINT32)(p5), (int)(UINT32)(p6))*//* Forward Function Declarations */LOCAL STATUS    secEndInitParse(DRV_CTRL *pDrvCtrl, char *initString);LOCAL STATUS    secEndInitMem(DRV_CTRL *pDrvCtrl);LOCAL STATUS    secEndUnload(DRV_CTRL *pDrvCtrl);LOCAL STATUS    secEndStart(DRV_CTRL *pDrvCtrl);LOCAL STATUS    secEndStop(DRV_CTRL *pDrvCtrl);LOCAL int       secEndIoctl(DRV_CTRL *pDrvCtrl, int cmd, caddr_t data);LOCAL STATUS    secEndSend(DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);LOCAL STATUS    secEndMCastAddrAdd(DRV_CTRL *pDrvCtrl, UCHAR *pAddr);LOCAL STATUS    secEndMCastAddrDel(DRV_CTRL *pDrvCtrl, UCHAR *pAddr);LOCAL STATUS    secEndMCastAddrGet(DRV_CTRL *pDrvCtrl, MULTI_TABLE *pTable);LOCAL STATUS    secEndPollSend(DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);LOCAL STATUS    secEndPollReceive(DRV_CTRL *pDrvCtrl, M_BLK_ID pMblk);/* Declare our function table. This is static across all driver instances. */LOCAL NET_FUNCS endFuncTable = {    (FUNCPTR)secEndStart,                                   /* start func. */    (FUNCPTR)secEndStop,                                    /* stop func. */    (FUNCPTR)secEndUnload,                                  /* unload func. */    (FUNCPTR)secEndIoctl,                                   /* ioctl func. */    (FUNCPTR)secEndSend,                                    /* send func. */    (FUNCPTR)secEndMCastAddrAdd,                            /* multicast add func. */    (FUNCPTR)secEndMCastAddrDel,                            /* multicast delete func. */    (FUNCPTR)secEndMCastAddrGet,                            /* multicast get fun. */    (FUNCPTR)secEndPollSend,                                /* polling send func. */    (FUNCPTR)secEndPollReceive,                             /* polling receive func. */    endEtherAddressForm,                                    /* put address info into a NET_BUFFER */    (FUNCPTR)endEtherPacketDataGet,                         /* get pointer to data in NET_BUFFER */    (FUNCPTR)endEtherPacketAddrGet                          /* Get packet addresses */};/********************************************************************************* secEndLoad - initialize the driver and device** This routine initializes the driver and the device to the operational state.* All of the device specific parameters are passed in the initString.** The string contains the target specific parameters like this:** "unit number:"** RETURNS: An END object pointer or NULL on error.*/END_OBJ* secEndLoad(    char *initString                                        /* parameter string */    ){    DRV_CTRL *pDrvCtrl;                                     /* pointer to DRV_CTRL structure */    UCHAR enetAddr[SEC_END_ADDR_LEN];                       /* ethernet address */#ifdef  DEBUG_TRACE    printf("secEnd Load, %s\n", initString);#endif  /* DEBUG_TRACE */    if (initString == NULL)    {        printf("secEnd Error: NULL parameter string\n");        return NULL;    }    if (initString[0] == 0)    {        bcopy((char *)SEC_END_DEV_NAME, (char *)initString, SEC_END_DEV_NAME_LEN);#ifdef  DEBUG_TRACE        printf("secEnd Load, %s\n", initString);#endif  /* DEBUG_TRACE */        return NULL;    }    /* Allocate the device structure. */    pDrvCtrl = (DRV_CTRL *)calloc(sizeof(DRV_CTRL), 1);    if (pDrvCtrl == NULL)    {        printf("secEnd Error: Failed to allocate DRV_CTRL\n");        return (NULL);    }    while (1)    {        /* Parse InitString. */        if (secEndInitParse(pDrvCtrl, initString) != OK)        {            break;        }        /* Memory initialization. */        if (secEndInitMem(pDrvCtrl) != OK)        {            break;        }        /* Initialize physical device. */        if (DRV_INIT(pDrvCtrl) != OK)        {            break;        }        /* Initialize END object. */        if (END_OBJ_INIT(                &pDrvCtrl->endObj,                (DEV_OBJ *)pDrvCtrl,                SEC_END_DEV_NAME,                pDrvCtrl->unit,                &endFuncTable,                SEC_END_DEV_DESCRIPTION                ) == ERROR)        {            printf("secEnd%d Error: Failed to initialize END_OBJ\n", pDrvCtrl->unit);            break;        }        /* Get ethernet hardware address. */        sysSecEnetAddrGet(pDrvCtrl->unit, enetAddr);        /* Initialize MIB. */        if (END_MIB_INIT(                &pDrvCtrl->endObj,                M2_ifType_ethernet_csmacd,                 enetAddr,                SEC_END_ADDR_LEN,                ETHERMTU,                pDrvCtrl->phyInfo.phySpeed                ) == ERROR)        {            printf("secEnd%d Error: Failed to initialize END_MIB\n", pDrvCtrl->unit);            break;        }        /* Mark the device ready. */        END_OBJ_READY(&pDrvCtrl->endObj, IFF_NOTRAILERS | IFF_MULTICAST | IFF_BROADCAST);        return (&pDrvCtrl->endObj);    }    secEndUnload(pDrvCtrl);    return NULL;}/******************************************************************************** secEndUnload - unload a driver from the system** This function first brings down the device, and then frees any stuff that was* allocated by the driver in the load function.** RETURNS: OK or ERROR.*/STATUS secEndUnload(    DRV_CTRL *pDrvCtrl                                      /* pointer to DRV_CTRL structure */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d Unload\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    if (pDrvCtrl == NULL)    {        return ERROR;    }    /* Uninitialize END object. */    END_OBJ_UNLOAD(&pDrvCtrl->endObj);    /* Free buffer descriptor pool if necessary. */  /*  if (pDrvCtrl->pBdArea != NULL)    {        cacheDmaFree(pDrvCtrl->pBdArea);    }*/    /* Free cluster pool if necessary. */    if (pDrvCtrl->pClArea != NULL)    {        cacheDmaFree(pDrvCtrl->pClArea);        pDrvCtrl->pClArea = 0 ;    }    /* Free mBlk/clBlk pool if necessary. */    if (pDrvCtrl->pMblkArea != NULL)    {        free(pDrvCtrl->pMblkArea);        pDrvCtrl->pMblkArea = 0 ;    }    /* Free netPool if necessary. */    if (pDrvCtrl->endObj.pNetPool != NULL)    {        free(pDrvCtrl->endObj.pNetPool);    }    /* Free the device structure. */    cfree((char *)pDrvCtrl);    return OK;}/********************************************************************************* secEndStart - start the device** This function calls BSP functions to connect interrupts and start the device* running in interrupt mode.** RETURNS: OK or ERROR**/LOCAL STATUS secEndStart(    DRV_CTRL *pDrvCtrl                                      /* pointer to DRV_CTRL structure */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d Start\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Mark the interface as up. */    END_FLAGS_SET(&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING));    return DRV_START(pDrvCtrl);}/********************************************************************************* secEndStop - stop the device** This function calls BSP functions to disconnect interrupts and stop the device* from operating in interrupt mode.** RETURNS: OK or ERROR.*/LOCAL STATUS secEndStop(    DRV_CTRL *pDrvCtrl                                      /* pointer to DRV_CTRL structure */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d Stop\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Mark the interface as down. */    END_FLAGS_CLR(&pDrvCtrl->endObj, (IFF_UP | IFF_RUNNING));    return DRV_STOP(pDrvCtrl);}/********************************************************************************* secEndIoctl - the driver I/O control routine** Process an ioctl request.** RETURNS: A command specific response, usually OK or ERROR.*/LOCAL int secEndIoctl(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    int cmd,                                                /* command to process */    caddr_t data                                            /* pointer to data */    ){    int error = OK;    END_OBJ *pEndObj = &pDrvCtrl->endObj;    long value;#ifdef  DEBUG_TRACE    printf("secEnd%d Ioctl: ", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    switch (cmd)    {    case EIOCSADDR:#ifdef  DEBUG_TRACE        printf("EIOCSADDR\n");#endif  /* DEBUG_TRACE */        /* Stop the device. */        DRV_STOP(pDrvCtrl);        /* Save the enet address. */        bcopy ((char *)data, END_HADDR(pEndObj), SEC_END_ADDR_LEN);        /* Program the individual enet address. */        error = DRV_ADDR_SET(pDrvCtrl);        /* Restart the device. */        DRV_START(pDrvCtrl);        break;    case EIOCGADDR:#ifdef  DEBUG_TRACE        printf("EIOCGADDR\n");#endif  /* DEBUG_TRACE */        /* Retrieve the enet address. */        bcopy (END_HADDR(pEndObj), (char *)data, SEC_END_ADDR_LEN);        break;    case EIOCSFLAGS:#ifdef  DEBUG_TRACE        printf("EIOCSFLAGS\n");#endif  /* DEBUG_TRACE */        value = (long)data;        if (value < 0)        {            value = -value;            value--;            END_FLAGS_CLR(pEndObj, value);        }        else        {            END_FLAGS_SET(pEndObj, value);        }        /* Set device flags. */        error = DRV_FLAGS_SET(pDrvCtrl);        break;    case EIOCGFLAGS:#ifdef  DEBUG_TRACE        printf("EIOCGFLAGS\n");#endif  /* DEBUG_TRACE */        /* Get device flags. */        *(long *)data = END_FLAGS_GET(pEndObj);        break;    case EIOCMULTIADD:#ifdef  DEBUG_TRACE        printf("EIOCMULTIADD\n");#endif  /* DEBUG_TRACE */        /* Add multicast address. */        error = secEndMCastAddrAdd(pDrvCtrl, (UCHAR *)data);        break;    case EIOCMULTIDEL:#ifdef  DEBUG_TRACE        printf("EIOCMULTIDEL\n");#endif  /* DEBUG_TRACE */        /* Delete multicast address. */        error = secEndMCastAddrDel(pDrvCtrl, (UCHAR *)data);        break;    case EIOCMULTIGET:#ifdef  DEBUG_TRACE        printf("EIOCMULTIGET\n");#endif  /* DEBUG_TRACE */        /* Retrieve a table of multicast addresses. */        error = secEndMCastAddrGet(pDrvCtrl, (MULTI_TABLE *)data);        break;    case EIOCPOLLSTART:#ifdef  DEBUG_TRACE        printf("EIOCPOLLSTART\n");#endif  /* DEBUG_TRACE */        /* Start polling mode. */        error = DRV_POLL_START(pDrvCtrl);        break;    case EIOCPOLLSTOP:#ifdef  DEBUG_TRACE        printf("EIOCPOLLSTOP\n");#endif  /* DEBUG_TRACE */