/* Stop polling mode. */        error = DRV_POLL_STOP(pDrvCtrl);        break;    case EIOCGMIB2:  #ifdef  DEBUG_TRACE        printf("EIOCGMIB2\n");#endif  /* DEBUG_TRACE */        /* Get MIB2 table. */        bcopy ((char *)&pEndObj->mib2Tbl, (char *)data, sizeof(pEndObj->mib2Tbl));        break;    case EIOCGNPT:#ifdef  DEBUG_TRACE        printf("EIOCGNPT\n");#endif  /* DEBUG_TRACE */        error = EINVAL;        break;    case EIOCGHDRLEN:#ifdef  DEBUG_TRACE        printf("EIOCGHDRLEN\n");#endif  /* DEBUG_TRACE */        *(long *)data = ENET_HDR_REAL_SIZ;        break;    default:#ifdef  DEBUG_TRACE        printf("\n");#endif  /* DEBUG_TRACE */        printf("secEnd%d Error: Unknown IOCTL command(0x%08X)\n", pDrvCtrl->unit, cmd);        error = EINVAL;        break;    }    return (error);}/********************************************************************************* secEndSend - the driver send routine** This routine takes a M_BLK_ID sends off the data in the M_BLK_ID. The buffer* must already have the addressing information properly installed in it. This is* done by a higher layer. The last arguments are a free routine to be called* when the device is done with the buffer and a pointer to the argument to pass* to the free routine.** RETURNS: OK, ERROR, or END_ERR_BLOCK.*/LOCAL STATUS secEndSend(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    M_BLK_ID pMblk                                          /* pointer to the mBlk/cluster pair */    ){    STATUS status;#ifdef  DEBUG_TRACE    printf("secEnd%d Send\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    END_TX_SEM_TAKE(&pDrvCtrl->endObj, WAIT_FOREVER);    /* Send data. */    status = DRV_SEND(pDrvCtrl, pMblk);    END_TX_SEM_GIVE(&pDrvCtrl->endObj);    return (status);}/******************************************************************************* secEndMCastAddrAdd - add a multicast address for the device** This routine adds a multicast address to whatever the driver is already* listening for. It then resets the address filter.** RETURNS: OK or ERROR.*/LOCAL STATUS secEndMCastAddrAdd(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    UCHAR *pAddr                                            /* address to be added */    ){    int retVal;#ifdef  DEBUG_TRACE    printf("secEnd%d MCastAddrAdd\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Add multicast address to a multicast address list. */    retVal = etherMultiAdd(&pDrvCtrl->endObj.multiList, pAddr);    if (retVal == ENETRESET)    {        /* Program multicast address. */        retVal = DRV_MCAST_ADD(pDrvCtrl, pAddr);    }    return (retVal);}/******************************************************************************* secEndMCastAddrDel - delete a multicast address for the device** This routine removes a multicast address from whatever the driver is* listening for. It then resets the address filter.** RETURNS: OK or ERROR.*/LOCAL STATUS secEndMCastAddrDel(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    UCHAR *pAddr                                            /* address to be deleted */    ){    int retVal;#ifdef  DEBUG_TRACE    printf("secEnd%d MCastAddrDel\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Delete multicast address from a multicast address list. */    retVal = etherMultiDel(&pDrvCtrl->endObj.multiList, pAddr);    while (retVal == ENETRESET)    {        /* Stop the device. */        DRV_STOP(pDrvCtrl);        /* Program multicast address. */        retVal = DRV_MCAST_DEL(pDrvCtrl, pAddr);        /* Restart the device. */        DRV_START(pDrvCtrl);    }    return (retVal);}/******************************************************************************* secEndMCastAddrGet - get the multicast address list for the device** This routine gets the multicast list of whatever the driver is already* listening for.** RETURNS: OK or ERROR.*/LOCAL STATUS secEndMCastAddrGet(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    MULTI_TABLE *pTable                                     /* table into which to copy addresses */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d MCastAddrGet\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Retrieve a table of multicast addresses from a driver. */    return (etherMultiGet(&pDrvCtrl->endObj.multiList, pTable));}/********************************************************************************* secEndPollSend - routine to send a packet in polled mode** This routine is called by a user to try and send a packet on the device.** RETURNS: OK upon success.  EAGAIN if device is busy.*/LOCAL STATUS secEndPollSend(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    M_BLK_ID pMblk                                          /* pointer to the mBlk/cluster pair */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d PollSend\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    while (1)    {        if (pMblk == NULL)        {            printf("secEnd%d Error: NULL tansmit M_BLK\n", pDrvCtrl->unit);            break;        }        /* Send data. */        return DRV_POLL_SEND(pDrvCtrl, pMblk);    }    END_ERR_ADD(&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);    return EAGAIN;}/********************************************************************************* secEndPollReceive - routine to receive a packet in polled mode** This routine is called by a user to try and get a packet from the device.** RETURNS: OK upon success.  EAGAIN is returned when no packet is available.*/LOCAL STATUS secEndPollReceive(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    M_BLK_ID pMblk                                          /* pointer to the mBlk/cluster pair */    ){#ifdef  DEBUG_TRACE    printf("secEnd%d PollReceive\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    while (1)    {        if (pMblk == NULL)        {            printf("secEnd%d Error: NULL receive M_BLK\n", pDrvCtrl->unit);            break;        }        /* If not has an associated cluster, avoid operation. */        if (!(pMblk->mBlkHdr.mFlags & M_EXT))        {            printf("secEnd%d Error: Invalid receive M_BLK\n", pDrvCtrl->unit);            break;        }        /* Receive data if available. */        return DRV_POLL_RECEIVE(pDrvCtrl, pMblk);    }    END_ERR_ADD(&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);    return EAGAIN;}/********************************************************************************* secEndInitParse - parse the init string** Parse the input string. Fill in values in the driver control structure.** The muxLib.o module automatically prepends the unit number to the user's* initialization string from the BSP (configNet.h).** RETURNS: OK or ERROR for invalid arguments.*/LOCAL STATUS secEndInitParse(    DRV_CTRL *pDrvCtrl,                                     /* pointer to DRV_CTRL structure */    char *initString                                        /* parameter string */    ){    char *tok;    char *holder = NULL;#ifdef  DEBUG_TRACE    printf("secEnd InitParse, %s\n", initString);#endif  /* DEBUG_TRACE */    tok = strtok_r(initString, ":", &holder);    if (tok == NULL)    {        return ERROR;    }    pDrvCtrl->unit = 0 ; /* (int)strtoul(tok, NULL, 16);*/    /* Sanity check the unit number. */    if (pDrvCtrl->unit < 0)    {        printf("secEnd Error: Invalid unit number, %d\n", pDrvCtrl->unit);        return ERROR;    }    return OK;}/********************************************************************************* secEndInitMem - initialize memory for the chip** This routine is highly specific to the device.** RETURNS: OK or ERROR.*/    LOCAL STATUS secEndInitMem(    DRV_CTRL *pDrvCtrl                                      /* pointer to DRV_CTRL structure */    ){    M_CL_CONFIG mClBlkConfig;                               /* mBlk, clBlk pool configuration table. */    CL_DESC clDescTbl[SEC_END_NUM_CL_TYPE];                 /* cluster pool configuration table. */#ifdef  DEBUG_TRACE    printf("secEnd%d InitMem\n", pDrvCtrl->unit);#endif  /* DEBUG_TRACE */    /* Allocate the netPool. */    if ((pDrvCtrl->endObj.pNetPool = malloc(sizeof(NET_POOL))) == NULL)    {        return (ERROR);    }    /* Initialize mBlk/clBlk pool. */    mClBlkConfig.mBlkNum    = DRV_NUM_MBLK;    mClBlkConfig.clBlkNum   = DRV_NUM_CLUSTER ;//DRV_NUM_MBLK;    mClBlkConfig.memSize    = mClBlkConfig.mBlkNum * (M_BLK_SZ + sizeof(long)) +                              mClBlkConfig.clBlkNum * (CL_BLK_SZ+ sizeof(long));    mClBlkConfig.memArea    = (char *)memalign(MBLK_ALIGNMENT, mClBlkConfig.memSize);    if (mClBlkConfig.memArea == NULL)    {        printf("secEnd%d Error: Failed to allocate mBlk/clBlk pool\n", pDrvCtrl->unit);        return (ERROR);    }    /* Save the pointer to the mBlock/cBlk pool area. */    pDrvCtrl->pMblkArea = (void *)mClBlkConfig.memArea;    /* Initialize cluster pool. */    clDescTbl[0].clSize     =  SIZE_ETH_MDMA ;  /*SIZE_FB - CL_OVERHEAD;*/    clDescTbl[0].clNum      =   DRV_NUM_CLUSTER;    clDescTbl[0].memSize    =   (clDescTbl[0].clNum *                               (clDescTbl[0].clSize + 8))      						  + sizeof(int);        /* +8 is for proper alignment */	/* SIZE_FB * DRV_NUM_CLUSTER;*//*    clDescTbl[0].memArea    = (char *)(DRV_CLUSTER_MEM_BASE );*/    clDescTbl[0].memArea =    (char *) cacheDmaMalloc (clDescTbl[0].memSize);    if (clDescTbl[0].memArea == NULL)    {		;    	return (ERROR);    }   pDrvCtrl->pClArea = clDescTbl[0].memArea ;#ifdef  DEBUG_TRACE    printf("    mBlk/clBlk pool     : 0x%08X\n", (UINT32)mClBlkConfig.memArea);    printf("    cluster pool        : 0x%08X\n", (UINT32)clDescTbl[0].memArea);#endif  /* DEBUG_TRACE */    /* Initialize the netPool. */    if (netPoolInit(pDrvCtrl->endObj.pNetPool, &mClBlkConfig, &clDescTbl[0], SEC_END_NUM_CL_TYPE, NULL) == ERROR)    {        printf("secEnd%d Error: Failed to initialize netPool\n", pDrvCtrl->unit);        return (ERROR);    }    /* Save cluster pool. */ /*   if ((pDrvCtrl->pClPool = netClPoolIdGet(pDrvCtrl->endObj.pNetPool, DRV_SIZE_CLUSTER, FALSE)) == NULL)    {        printf("secEnd%d Error: Failed to get clPool\n", pDrvCtrl->unit);        return (ERROR);    }*/#ifdef  DEBUG_TRACE    printf("    pNetPool->mBlkCnt   : %d\n", pDrvCtrl->endObj.pNetPool->mBlkCnt);    printf("    pNetPool->mBlkFree  : %d\n", pDrvCtrl->endObj.pNetPool->mBlkFree);    printf("    pNetPool->clLg2Max  : %d\n", pDrvCtrl->endObj.pNetPool->clLg2Max);    printf("    pNetPool->clSizeMax : %d\n", pDrvCtrl->endObj.pNetPool->clSizeMax);    printf("    pNetPool->clLg2Min  : %d\n", pDrvCtrl->endObj.pNetPool->clLg2Min);    printf("    pNetPool->clSizeMin : %d\n", pDrvCtrl->endObj.pNetPool->clSizeMin);/*  printf("    pClPool->clSize     : %d\n", pDrvCtrl->pClPool->clSize);    printf("    pClPool->clLg2      : %d\n", pDrvCtrl->pClPool->clLg2);    printf("    pClPool->clNum      : %d\n", pDrvCtrl->pClPool->clNum);    printf("    pClPool->clNumFree  : %d\n", pDrvCtrl->pClPool->clNumFree);*/#endif  /* DEBUG_TRACE */    /* Change cluster size to real size. *//*    pDrvCtrl->pClPool->clSize = DRV_SIZE_CLUSTER;*/    return OK;}LOCAL unsigned char sysSecEnetAddr[][6] = {#if 1    {0x08, 0x00, 0x01, 0x01, 0x01, 0x01},    {0x08, 0x00, 0x01, 0x01, 0x01, 0x02},    {0x08, 0x00, 0x01, 0x01, 0x01, 0x03},    {0x08, 0x00, 0x01, 0x01, 0x01, 0x04},    {0x08, 0x00, 0x01, 0x01, 0x01, 0x05},    {0x08, 0x00, 0x01, 0x01, 0x01, 0x06}#else    {0x08, 0x00, 0x02, 0x02, 0x02, 0x01},    {0x08, 0x00, 0x02, 0x02, 0x02, 0x02},    {0x08, 0x00, 0x02, 0x02, 0x02, 0x03},    {0x08, 0x00, 0x02, 0x02, 0x02, 0x04},    {0x08, 0x00, 0x02, 0x02, 0x02, 0x05},    {0x08, 0x00, 0x02, 0x02, 0x02, 0x06}#endif};STATUS sysSecEnetAddrGet(    int unit,                                               /* unit number of device being used */    UCHAR* addr                                             /* where to copy the ethernet address */    ){    bcopy((char*)sysSecEnetAddr[unit], (char*)addr, 6);    return (OK);}