fei82557end.c

INTEL IXP425的VXWORKS BSP

    char *      initString              /* parameter string */
    )


    {
    char *  tok;                /* an initString token */
    char *  holder = NULL;      /* points to initString fragment beyond tok */

    tok = strtok_r (initString, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->unit = atoi (tok);


    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->pClusterBase = (char *)strtoul (tok, NULL, 16);


    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->clMemSize = strtoul (tok, NULL, 16);


    /* passing nCFDs is optional. The default is 64 */     
    pDrvCtrl->nCFDs = 64;
    tok = strtok_r (NULL, ":", &holder);
    if ((tok != NULL) && (tok != (char *)-1))
        pDrvCtrl->nCFDs = strtoul (tok, NULL, 16);


    /* passing nRFDs is optional. The default is 128 */     
    pDrvCtrl->nRFDs = 128;
    tok = strtok_r (NULL, ":", &holder);
    if ((tok != NULL) && (tok != (char *)-1))
        pDrvCtrl->nRFDs = strtoul (tok, NULL, 16);
    pDrvCtrl->nRBDs = pDrvCtrl->nRFDs;


    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->flags = atoi (tok);


    /* offset value is optional, default is zero */
    pDrvCtrl->offset = 0;
    tok = strtok_r (NULL, ":", &holder);
    if (tok != NULL)
        pDrvCtrl->offset = atoi (tok);


    /* device ID is optional, default is zero */
    pDrvCtrl->deviceId = 0;
    tok = strtok_r (NULL, ":", &holder);
    if (tok != NULL)
        pDrvCtrl->deviceId = atoi (tok);


    /* passing maxRxFrames is optional. The default is 128  */
    pDrvCtrl->maxRxFrames = pDrvCtrl->nRFDs * 2;   
    tok = strtok_r (NULL, ":", &holder);
    if ((tok != NULL) && (tok != (char *)-1))
        pDrvCtrl->maxRxFrames = strtoul (tok, NULL, 16);


    /* passing clToRfdRatio is optional. The default is 5  */
    pDrvCtrl->clToRfdRatio = 5;
    tok = strtok_r (NULL, ":", &holder);
    if ((tok != NULL) && (tok != (char *)-1))
        pDrvCtrl->clToRfdRatio = strtoul (tok, NULL, 16);


    if (pDrvCtrl->clToRfdRatio < 2 )
        pDrvCtrl->clToRfdRatio = 2;


    /* passing nClusters is optional. The default is  nRFDs * clToRfdRatio */
    pDrvCtrl->nClusters = pDrvCtrl->nRFDs * pDrvCtrl->clToRfdRatio;
    tok = strtok_r (NULL, ":", &holder);
    if ((tok != NULL) && (tok != (char *)-1))
        pDrvCtrl->nClusters = strtoul (tok, NULL, 16);


    if (!pDrvCtrl->nCFDs || pDrvCtrl->nCFDs <= 2)
        {
        FEI_FLAG_SET (FEI_INV_NCFD);
        pDrvCtrl->nCFDs = DEF_NUM_CFDS;
        }


    if (!pDrvCtrl->nRFDs || pDrvCtrl->nRFDs <= 2)
        {
        FEI_FLAG_SET (FEI_INV_NRFD);
        pDrvCtrl->nRFDs = DEF_NUM_RFDS;
        }


    if (pDrvCtrl->nClusters < (pDrvCtrl->nRFDs * 2))
        pDrvCtrl->nClusters = pDrvCtrl->nRFDs * 2;


    DRV_LOG (DRV_DEBUG_LOAD,
            "fei82557EndLoad: unit=%d pClusterBase=0x%x memSize=0x%x\n",
            pDrvCtrl->unit, (int) pDrvCtrl->pClusterBase,
            (int) pDrvCtrl->clMemSize, 0,0,0);
    DRV_LOG (DRV_DEBUG_LOAD,
            "fei82557EndLoad: nCFDs=%d nRFDs=%d flags=%d offset=%d\n",
            pDrvCtrl->nCFDs, pDrvCtrl->nRFDs, pDrvCtrl->flags,
            pDrvCtrl->offset, 0, 0);


    return (OK);
    }


/*******************************************************************************
*
* fei82557InitMem - initialize memory
*
* RETURNS: OK or ERROR
*/


LOCAL STATUS fei82557InitMem
    (
    DRV_CTRL *  pDrvCtrl       /* pointer to DRV_CTRL structure */
    )
    {
    CFD_ID              pCFD;           /* pointer to CFDs */
    RFD_ID              pRFD;           /* pointer to RFDs */
    RFD_TAG *           pRfdTag;
    RBD_ID              pRBD;           /* pointer to RFDs */
    RBD_TAG *           pRbdTag;
    UINT32              clSize;         /* size of allocation for clusters */
    UINT32              clusterSize;    /* size of allocation for clusters */
    UINT32              memSize;        /* size of allocation passed by BSP */
    UINT32              nSubtract = 1;  /* number of RFDs to subtract */
    UINT32              rfdSize;        /* size of allocation for RFDs */
    UINT32              rbdSize;        /* size of allocation for RBDs */
    UINT32              cfdSize;        /* size of allocation for CFDs */
    int                 ix;             /* index counter */
    BOOL                firstCFD = TRUE;/* the first CFD? */
    int                 firstOrLast;
     


    M_CL_CONFIG  fei82557MclBlkConfig =
    {
        /*
         *  mBlkNum     clBlkNum        memArea     memSize
         *  -----------         ----            -------     -------
         */
            0,          0,              NULL,       0
    };


    CL_DESC      fei82557ClDescTbl [] =
    {
        /*
         *  clusterSize                 num     memArea     memSize
         *  -----------                 ----    -------     -------
         */


        {CLUSTER_SIZE,                  0,      NULL,       0}    


    };


    int fei82557ClDescTblNumEnt = (NELEMENTS (fei82557ClDescTbl));


    /* initialize the netPool */


    if ((pDrvCtrl->endObj.pNetPool = malloc (sizeof (NET_POOL))) == NULL)
        return (ERROR);


   /* this driver can't handle write incoherent caches */


    if (!CACHE_DMA_IS_WRITE_COHERENT ()) 
        {
        DRV_LOG (DRV_DEBUG_LOAD, ("fei82557EndLoad: shared 
                                  memory not cache coherent\n"),
                                  1, 2, 3, 4, 5, 6);
        return (ERROR);
        }


    switch ((int) pDrvCtrl->pClusterBase)
        {
        case NONE :                          /* we must obtain it */


            clSize = (pDrvCtrl->nClusters * CLUSTER_SIZE);


            /* Add one to rfdSize, rbdSize, & cfdSize to accomodate alignment */
            rfdSize = ((pDrvCtrl->nRFDs + 1) * RFD_DESC_SIZE);
            rbdSize = ((pDrvCtrl->nRBDs + 1) * RBD_SIZE);
            cfdSize = ((pDrvCtrl->nCFDs + 1) * CFD_SIZE);


            /* Align on 32 byte boundries */
            if ((pDrvCtrl->pRfdBase = cacheDmaMalloc (rfdSize + rbdSize + 
                                                      cfdSize)) == NULL)
                {
                return (ERROR);
                }


            memset (pDrvCtrl->pRfdBase, 0, (rfdSize + rbdSize + cfdSize));


            pDrvCtrl->pRfdBase = (char *)ROUND_UP((UINT32) pDrvCtrl->pRfdBase, 
                                                  32);


            pDrvCtrl->rfdTags = (RFD_TAG *)pDrvCtrl->pRfdBase;
            pDrvCtrl->pRFD = (RFD_ID)pDrvCtrl->pRfdBase;


            pDrvCtrl->pRbdBase = (char *)((int)pDrvCtrl->pRfdBase + rfdSize);
            pDrvCtrl->rbdTags = (RBD_TAG *)pDrvCtrl->pRbdBase;


            pDrvCtrl->pCfdBase = (char *)((int)pDrvCtrl->pRbdBase + rbdSize);


            pDrvCtrl->pClusterBase = memalign (_CACHE_ALIGN_SIZE, clSize); 


            if (pDrvCtrl->pClusterBase == NULL)      /* no memory available */
                {
                DRV_LOG (DRV_DEBUG_LOAD, ("fei82557EndLoad: could not 
                                            obtain memory\n"),
                                            1, 2, 3, 4, 5, 6);
                return (ERROR);
                }
            /* zero the shared memory */
            memset(pDrvCtrl->pClusterBase,0,clSize);


            pDrvCtrl->clMemSize = clSize;


            FEI_FLAG_SET (FEI_OWN_MEM);


            pDrvCtrl->cacheDmaFuncs = cacheDmaFuncs;
            pDrvCtrl->cacheFuncs = cacheUserFuncs;


            pDrvCtrl->pSendRtn = (FUNCPTR)fei82557GatherSend; 


            break;


        default :                              /* the user provided an area */


            if (pDrvCtrl->clMemSize == 0) 
                {
                DRV_LOG (DRV_DEBUG_LOAD, ("fei82557EndLoad: not enough 
                                           memory\n"),
                                           1, 2, 3, 4, 5, 6);
                return (ERROR);
                }


            /* 
             * check the user provided enough memory with reference
             * to the given number of receive/transmit frames, if any.
             */


           while ((pDrvCtrl->nRBDs * RBD_SIZE) > (nSubtract * CLUSTER_SIZE))
               {
               nSubtract++;
               }
            rfdSize = ((pDrvCtrl->nRFDs + 1) * RFD_DESC_SIZE);
            rbdSize = ((pDrvCtrl->nRBDs + 1) * RBD_SIZE);
            cfdSize = (pDrvCtrl->nCFDs * (CFD_SIZE + CLUSTER_SIZE)); 
            clusterSize = (((pDrvCtrl->nRFDs + 1) * 2) * CLUSTER_SIZE); 


            memSize = rfdSize + rbdSize + cfdSize + clusterSize;


            if (pDrvCtrl->clMemSize < memSize) 
                {
                DRV_LOG (DRV_DEBUG_LOAD, ("fei82557EndLoad: not enough 
                                          memory\n"), 1, 2, 3, 4, 5, 6);
                return (ERROR);
                }


            /* zero the shared memory */
            memset(pDrvCtrl->pClusterBase,0,pDrvCtrl->clMemSize);


            memSize = pDrvCtrl->clMemSize - (rfdSize + rbdSize + cfdSize);


            pDrvCtrl->nClusters = ((memSize / CLUSTER_SIZE) - nSubtract); 


            pDrvCtrl->pRfdBase = pDrvCtrl->pClusterBase;
            pDrvCtrl->rfdTags = (RFD_TAG *)pDrvCtrl->pRfdBase; 
            pDrvCtrl->pRFD = (RFD_ID)pDrvCtrl->pRfdBase;


            pDrvCtrl->pRbdBase = (char *)((int)pDrvCtrl->pRfdBase + rfdSize);
            pDrvCtrl->rbdTags = (RBD_TAG *)pDrvCtrl->pRbdBase; 


            pDrvCtrl->pClusterBase = (char *)((int)pDrvCtrl->pRbdBase + 
                                                   rbdSize);


            pDrvCtrl->pCfdBase = (char *)((int)pDrvCtrl->pClusterBase + 
                                (pDrvCtrl->nClusters * CLUSTER_SIZE));  


            FEI_FLAG_CLEAR (FEI_OWN_MEM);
            pDrvCtrl->cacheDmaFuncs = cacheNullFuncs; 
            pDrvCtrl->cacheFuncs = cacheDmaFuncs;


            pDrvCtrl->pSendRtn = (FUNCPTR)fei82557CopySend; 


            break;
        }


    /* pool of mblks */


    if (fei82557MclBlkConfig.mBlkNum == 0)
        fei82557MclBlkConfig.mBlkNum = pDrvCtrl->nClusters * 10;


    /* pool of clusters */


    if (fei82557ClDescTbl[0].clNum == 0)
        {
        fei82557ClDescTbl[0].clNum = pDrvCtrl->nClusters;
        fei82557ClDescTbl[0].clSize = CLUSTER_SIZE;
        }


    fei82557ClDescTbl[0].memSize = pDrvCtrl->clMemSize;  
    fei82557ClDescTbl[0].memArea = pDrvCtrl->pClusterBase;


    DRV_LOG (DRV_DEBUG_LOAD, ("fei82557EndLoad: pClusterBase %p nClusters %d 
                              cluster size %x\n"),
                              (int)pDrvCtrl->pClusterBase,pDrvCtrl->nClusters,
                              CLUSTER_SIZE,0,0,0); 


    /* pool of cluster blocks */


    if (fei82557MclBlkConfig.clBlkNum == 0)
        fei82557MclBlkConfig.clBlkNum = (fei82557ClDescTbl[0].clNum * 2);


    /* get memory for mblks */