mottsecend.c

vxworks MPC8541 BSP

#endif  /* INCLUDE_RFC_2233 */

    MOT_TSEC_LOG (MOT_TSEC_DBG_ANY, "MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
                  pDrvCtrl->enetAddr.ether_addr_octet[0],
                  pDrvCtrl->enetAddr.ether_addr_octet[1],
                  pDrvCtrl->enetAddr.ether_addr_octet[2],
                  pDrvCtrl->enetAddr.ether_addr_octet[3],
                  pDrvCtrl->enetAddr.ether_addr_octet[4],
                  pDrvCtrl->enetAddr.ether_addr_octet[5]
                  );

/* connect the interrupt handler */
    if (pDrvCtrl->unit == 0)
        {
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC1TX_INT_VEC),  
                    (VOIDFUNCPTR)motTsecTxInt, (int)pDrvCtrl);
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC1RX_INT_VEC), 
                    (VOIDFUNCPTR)motTsecRxInt, (int)pDrvCtrl);
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC1ERR_INT_VEC), 
                    (VOIDFUNCPTR)motTsecTxInt,(int)pDrvCtrl);
        }
    else if (pDrvCtrl->unit == 1)
        {
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC2TX_INT_VEC),  
                    (VOIDFUNCPTR)motTsecTxInt, (int)pDrvCtrl);
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC2RX_INT_VEC), 
                    (VOIDFUNCPTR)motTsecRxInt, (int)pDrvCtrl);
        intConnect ((VOIDFUNCPTR *)((int)EPIC_TSEC2ERR_INT_VEC), 
                    (VOIDFUNCPTR)motTsecTxInt,(int)pDrvCtrl);
        }
    else
        goto errorExit;

    pDrvCtrl->state = MOT_TSEC_STATE_LOADED;

    return(&pDrvCtrl->endObj);

    errorExit:
    motTsecUnload (pDrvCtrl);
    return NULL;
    }

/*******************************************************************************
*
* motTsecUnload - unload a driver from the system
*
* This routine unloads the driver pointed to by <pDrvCtrl> from the system.
*
* RETURNS: OK, always.
*
* ERRNO
*
* SEE ALSO: motTsecLoad()
*/
LOCAL STATUS motTsecUnload
    (
    TSEC_DRV_CTRL * pDrvCtrl       /* pointer to TSEC_DRV_CTRL structure */
    )
    {

    if (pDrvCtrl == NULL)
        return (ERROR);

    if ((pDrvCtrl->state & MOT_TSEC_STATE_LOADED) == MOT_TSEC_STATE_NOT_LOADED)
        return (ERROR);

    /* must stop the device before unloading it */

    if ((pDrvCtrl->state & MOT_TSEC_STATE_RUNNING) == MOT_TSEC_STATE_RUNNING)
        motTsecStop(pDrvCtrl);

    /* free allocated memory if necessary */

    if ((MOT_TSEC_FLAG_ISSET (MOT_TSEC_OWN_BUF_MEM)) && 
        (pDrvCtrl->pBufBase != NULL))
        {
        free (pDrvCtrl->pBufBase);
        }

    if ((MOT_TSEC_FLAG_ISSET (MOT_TSEC_OWN_BD_MEM)) && 
        (pDrvCtrl->pBdBase != NULL))
        {
        cacheDmaFree (pDrvCtrl->pBdBase);
        }

    /* free allocated memory if necessary */

    if ((pDrvCtrl->pMBlkArea) != NULL)
        free (pDrvCtrl->pMBlkArea);

#ifdef INCLUDE_RFC_2233
    /* Free MIB-II entries */

    m2IfFree(pDrvCtrl->endObj.pMib2Tbl);

    pDrvCtrl->endObj.pMib2Tbl = NULL;

#endif /* INCLUDE_RFC_2233 */

    /* free misc resources */

    if (pDrvCtrl->pMblkList)
        free(pDrvCtrl->pMblkList);

    pDrvCtrl->pMblkList = NULL;

    if (pDrvCtrl->tBufList)
        free(pDrvCtrl->tBufList);

    pDrvCtrl->tBufList = NULL;

    END_OBJECT_UNLOAD (&pDrvCtrl->endObj);

    if ((char *) pDrvCtrl->phyInfo != NULL)
        cfree ((char *) pDrvCtrl->phyInfo);

    pDrvCtrl->state = MOT_TSEC_STATE_INIT;

#ifdef MOT_TSEC_DBG
    pTsecDrvCtrlDbg[pDrvCtrl->unit] = NULL;

    free (pDrvCtrl->stats);
#endif /* MOT_TSEC_DBG */

    /* free driver control structure */
    free (pDrvCtrl);

    return (OK);
    }

/*******************************************************************************
*
* motTsecInitParse - parse parameter values from initString
*
* This routine parses parameter values from initString and stores them in
* the related fields of the driver control structure.
*
* RETURNS: OK or ERROR
*
* ERRNO
*/
LOCAL STATUS motTsecInitParse
    (
    TSEC_DRV_CTRL *  pDrvCtrl,   /* pointer to TSEC_DRV_CTRL structure */
    char          *  initString  /* parameter string */
    )
    {
    char *  tok;            /* an initString token */
    char *  holder = NULL;  /* points to initString fragment beyond tok */
    UINT32     i;

    /* unit number */

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

    /* Device Address */

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

    /* tsec number */

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

   /* MAC Address xx-xx-xx-xx-xx-xx:*/

    for (i = 0; i < sizeof (pDrvCtrl->enetAddr.ether_addr_octet) - 2; i++)
        {
        tok = strtok_r (NULL, "-", &holder);
        if (tok == NULL)
          return ERROR;

        pDrvCtrl->enetAddr.ether_addr_octet[i] = (int) strtoul (tok, NULL, 16);
        }

    tok = strtok_r (NULL, "-", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->enetAddr.ether_addr_octet[i++] = (int) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->enetAddr.ether_addr_octet[i] = (int) strtoul (tok, NULL, 16);

    /* USR Init FLAGS */
    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
        pDrvCtrl->userFlags = (UINT32) strtoul (tok, NULL, 16);

    /* Phy init parameters */
    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->phyInit = (MOT_TSEC_PHY_PARAMS *) strtoul (tok, NULL, 16);

    /* call back function table */
    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->initFuncs = (MOT_TSEC_FUNC_TABLE *) strtoul (tok, NULL, 16);

    /* Init parameters */
    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;
    pDrvCtrl->initParms = (MOT_TSEC_PARAMS *) strtoul (tok, NULL, 16);

    tok = strtok_r (NULL, ":", &holder);
    if (tok == NULL)
        return ERROR;

    /* Extended init parameters */
    pDrvCtrl->initParmsExt = (MOT_TSEC_EXT_PARAMS *) strtoul (tok, NULL, 16);

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

    return (OK);
    }

/*******************************************************************************
*
* motTsecFuncInit - parse functions from initString
*
* This routine parses the function pointers from initString.
*
* RETURNS: OK or ERROR
*
* ERRNO
*/
LOCAL STATUS motTsecFuncInit
    (
    TSEC_DRV_CTRL *  pDrvCtrl
    )
    {
    if (pDrvCtrl->initFuncs != NULL)
        {
        /* set up BSP call backs passed in the initString */
        pDrvCtrl->phyInitFunc   = pDrvCtrl->initFuncs->miiPhyInit;
        pDrvCtrl->phyStatusFunc = pDrvCtrl->initFuncs->miiPhyStatusGet;
        pDrvCtrl->enetEnable    = pDrvCtrl->initFuncs->enetEnable;
        pDrvCtrl->enetDisable   = pDrvCtrl->initFuncs->enetDisable;
        pDrvCtrl->enetAddrGet   = pDrvCtrl->initFuncs->enetAddrGet;
        pDrvCtrl->enetAddrSet   = pDrvCtrl->initFuncs->enetAddrSet;
        pDrvCtrl->extWriteL2AllocFunc   = pDrvCtrl->initFuncs->extWriteL2AllocFunc;

        /* BSP call backs to driver */
        pDrvCtrl->initFuncs->miiPhyInt   = (FUNCPTR) motTsecPhyLSCInt;
        pDrvCtrl->initFuncs->miiPhyRead  = (FUNCPTR) motTsecMiiPhyRead;
        pDrvCtrl->initFuncs->miiPhyWrite = (FUNCPTR) motTsecMiiPhyWrite;
        }
    else
        {
        /* use default funcs */
        pDrvCtrl->phyInitFunc   = NULL;
        pDrvCtrl->phyStatusFunc = NULL;
        pDrvCtrl->enetEnable    = NULL;
        pDrvCtrl->enetDisable   = NULL;
        pDrvCtrl->enetAddrGet   = NULL;
        pDrvCtrl->enetAddrSet   = NULL;
        pDrvCtrl->extWriteL2AllocFunc = NULL;
        }

    return (OK);
    }

/*******************************************************************************
*
* motTsecGracefulStop - Gracefully stops the device 
*
* This routine gracefully stops the device so MAC registers can be changed.
*
* RETURNS:
*
* ERRNO
*/
LOCAL void motTsecGracefulStop
    (
    TSEC_DRV_CTRL * pDrvCtrl
    )
    {
    TSEC_REG_T *tsecReg = pDrvCtrl->tsecRegsPtr;
    int count = 0;
    int intLevel;
    volatile int ieventVal,tstatVal,rstatVal;

    intLevel = intLock();
    
    tstatVal = MOT_TSEC_TSTAT_REG;
    MOT_TSEC_TSTAT_REG = tstatVal;

    rstatVal = MOT_TSEC_RSTAT_REG;
    MOT_TSEC_RSTAT_REG = rstatVal;

    ieventVal = MOT_TSEC_IEVENT_REG;
    MOT_TSEC_IEVENT_REG = ieventVal;

    MOT_TSEC_DMACTRL_REG |= (MOT_TSEC_DMACTRL_GTS);

    CACHE_PIPE_FLUSH();

    while (MOT_TSEC_IEVENT_REG & (MOT_TSEC_IEVENT_GTSC))
        {
        if (count < 100000)
            count++;
        else
            break;  
        }
    MOT_TSEC_MACCFG1_REG &= (~(MOT_TSEC_MACCFG1_TX_EN | MOT_TSEC_MACCFG1_RX_EN));

    /* This delay is required by the hardware */
    MOT_TSEC_MS_DELAY(16);

    MOT_TSEC_DMACTRL_REG |= ( MOT_TSEC_DMACTRL_GRS);

    count = 0;

    while (MOT_TSEC_IEVENT_REG & (MOT_TSEC_IEVENT_GRSC))
        {
        if (count < 100000)
            count++;
        else
            break;
        }

    /* This delay is required by the hardware */
    MOT_TSEC_MS_DELAY(32);

    MOT_TSEC_MACCFG1_REG |= ( MOT_TSEC_MACCFG1_SOFT_RESET   | 
                              MOT_TSEC_MACCFG1_RESET_RX_MC  | 
                              MOT_TSEC_MACCFG1_RESET_TX_MC  | 
                              MOT_TSEC_MACCFG1_RESET_RX_FUN | 
                              MOT_TSEC_MACCFG1_RESET_TX_FUN );

    MOT_TSEC_MS_DELAY(32);

    MOT_TSEC_MACCFG1_REG &= ~( MOT_TSEC_MACCFG1_SOFT_RESET   |