mottsecdrv.c

freescale mottsec 千兆单元驱动源码

    pDrvCtrl->initParms = (ZXR10_MOT_TSEC_PARAMS *) NULL;
    pDrvCtrl->initParmsExt = (ZXR10_MOT_TSEC_EXT_PARAMS *) NULL;
    pDrvCtrl->userFlags = ZXR10_MOT_TSEC_USR_STAT_ENABLE | ZXR10_MOT_TSEC_USR_MODE_GMII;

    /* Parse InitString */
    if (zxr10_motTsecInitParse (pDrvCtrl, initString) == ERROR)
        goto errorExit;

    if (zxr10_motTsecPhyPreInit (pDrvCtrl) == ERROR)
        goto errorExit;

    /* Init BSP function and driver callbacks */
    if (zxr10_motTsecInitFunc (pDrvCtrl) == ERROR)
        goto errorExit;

    if(pDrvCtrl->initMacAddrGet)
        pDrvCtrl->initMacAddrGet(pDrvCtrl->enetAddr);

    /* memory initialization */
    if (zxr10_motTsecInitMem (pDrvCtrl) == ERROR)
        goto errorExit;

    /* Init TSEC hardware parameters */
    if (zxr10_motTsecInitParm (pDrvCtrl) == ERROR)
        goto errorExit;

    /* drvCtrl initializations */
    zxr10_motTsecInitVirCtrl(pDrvCtrl);

    pDrvCtrl->state = ZXR10_MOT_TSEC_STATE_LOADED;
#ifdef ZXR10_MOT_TSEC_DBG    
    zxr10_motTsecDrv[zxr10_motTsecDrvCnt++] = pDrvCtrl;
#endif
    return(&pDrvCtrl->drvCtrl);

    errorExit:
    zxr10_motTsecUnload (pDrvCtrl);
    return NULL;
}

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

    if (pDrvCtrl == NULL)
        goto errorExit;

    if (!(pDrvCtrl->state & ZXR10_MOT_TSEC_STATE_LOADED))
        goto errorExit;

    /* must stop the device before unloading it */

    if (pDrvCtrl->state & ZXR10_MOT_TSEC_STATE_RUNNING)
    {
        zxr10_motTsecStop(pDrvCtrl);
    }
    if ((ZXR10_MOT_TSEC_FLAG_ISSET (ZXR10_MOT_TSEC_OWN_BD_MEM)) &&
        (pDrvCtrl->pBdBase != NULL))
    {
        free (pDrvCtrl->pBdBase);
    }

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

    if ((char *) pDrvCtrl->phyInfo != NULL)
    {
        zxr10_motTsecPhyUnLoad(pDrvCtrl->phyInfo);
    }

    if (pDrvCtrl->drvSem != NULL)
    {
        semDelete (pDrvCtrl->drvSem);
    }

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

errorExit:
    return ERROR;
}
/**************************************************************************
*
* zxr10_motTsecStart - start the device
*
* This routine starts the TSEC device and brings it up to an operational
* state.  The driver must have already been loaded with the zxr10_motTsecEndLoad()
* routine.
*
* INTERNAL
* The speed field inthe phyInfo structure is only set after the call
* to the physical layer init routine. On the other hand, the mib2
* interface is initialized in the zxr10_motTsecEndLoad() routine, and the default
* value of 10Mbit assumed there is not always correct. We need to
* correct it here.
*
* RETURNS: OK, or ERROR if the device could not be started.
*
*/
STATUS zxr10_motTsecStart
    (
    TSEC_DRV_CTRL *pDrvCtrl
    )
{
    int    retVal;
    UINT32 value;

    ZXR10_MOT_TSEC_FRAME_SET(pDrvCtrl);

    ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart\n", 1, 2, 3, 4, 5, 6);

    /* must have been loaded */
    if (!(pDrvCtrl->state & ZXR10_MOT_TSEC_STATE_LOADED))
        return ERROR;

    semTake(pDrvCtrl->drvSem, WAIT_FOREVER);
    /* check if already running */
    if (pDrvCtrl->state & ZXR10_MOT_TSEC_STATE_RUNNING)
    {
        goto TSEC_OK;
    }
    /* restore some mac register for endToOam */
    zxr10_motTsecRestorParam(pDrvCtrl);
    
    /* call the BSP to do any other initialization (MII interface) */
    if (pDrvCtrl->enetEnable != NULL)
    {
        pDrvCtrl->enetEnable();
    }
    
    /* Initialize some fields in the PHY info structure */
    if (pDrvCtrl->phyInfo->preInit && ((pDrvCtrl->phyInfo->preInit(pDrvCtrl->phyInfo)) != OK))
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart phy preInit failed\n", 1, 2, 3, 4, 5, 6);
    }
    if(OK != pDrvCtrl->phyInfo->ioctl(pDrvCtrl->phyInfo, PHY_GET_LINK_STATE,
                                      &value))
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart phy ioctl failed\n", 1, 2, 3, 4, 5, 6);
    }
    else if(PHY_LINK_UP == value)
    {
        zxr10_motTsecSetMacMode(pDrvCtrl);        
    }
    /* Initialize the transmit buffer descripters */

    if (zxr10_motTsecTbdInit(pDrvCtrl) == ERROR)
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart init tbd failed\n", 1, 2, 3, 4, 5, 6);
        goto TSEC_ERROR;
    }

    /* Initialize the receive buffer descripters */
    if (zxr10_motTsecRbdInit(pDrvCtrl) == ERROR)
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart init rbd failed\n", 1, 2, 3, 4, 5, 6);
        goto TSEC_ERROR;
    }

    pDrvCtrl->intConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecRxNum),
                          (VOIDFUNCPTR)zxr10_motTsecRxInt, (int)pDrvCtrl);
    /*
    pDrvCtrl->intConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecTxNum),
                    (VOIDFUNCPTR)zxr10_motTsecErrInt, (int)pDrvCtrl);                    
    */
    pDrvCtrl->intConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecErrNum),
                          (VOIDFUNCPTR)zxr10_motTsecErrInt, (int)pDrvCtrl);
    retVal = pDrvCtrl->intEnable(pDrvCtrl->vecRxNum);
    if ((ERROR) == retVal)
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart int Enable failed\n", 1, 2, 3, 4, 5, 6);
        goto TSEC_ERROR;
    }
    /*
    retVal = pDrvCtrl->intEnable(pDrvCtrl->vecTxNum);
    */
    retVal = pDrvCtrl->intEnable(pDrvCtrl->vecErrNum);
    if ((ERROR) == retVal)
    {
        ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart int Enable failed\n", 1, 2, 3, 4, 5, 6);
        goto TSEC_ERROR;
    }


    /* clear all events */
    ZXR10_MOT_TSEC_IEVENT_REG = 0xffffffff;

    /* unmask events */
    ZXR10_MOT_TSEC_IMASK_REG = pDrvCtrl->intMask;

    /* unmask error events */
    ZXR10_MOT_TSEC_EDIS_REG = pDrvCtrl->intErrorMask;

    zxr10_motTsecRestart(pDrvCtrl);

    pDrvCtrl->state |= ZXR10_MOT_TSEC_STATE_RUNNING;
    
    if (pDrvCtrl->phyInfo->init)
    {
        pDrvCtrl->phyInfo->init(pDrvCtrl->phyInfo);
    }
TSEC_OK:
    semGive(pDrvCtrl->drvSem);
    ZXR10_MOT_TSEC_LOG (ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStart done\n", 1, 2, 3, 4, 5, 6);
    return OK;

TSEC_ERROR:
    semGive(pDrvCtrl->drvSem);
    pDrvCtrl->intDisable(pDrvCtrl->vecRxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecTxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecErrNum);
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecRxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecTxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecErrNum));
    return ERROR;
}

/**************************************************************************
*
* zxr10_motTsecStop - stop the 'zxr10_mottsec' interface
*
* This routine marks the interface as inactive, disables interrupts and
* the Ethernet Controller. As a result, reception is stopped immediately,
* and transmission is stopped after a bad CRC is appended to any frame
* currently being transmitted. The reception/transmission control logic
* (FIFO pointers, buffer descriptors, etc.) is reset. To bring the
* interface back up, zxr10_motTsecStart() must be called.
*
* RETURNS: OK, always.
*/

LOCAL STATUS zxr10_motTsecStop
    (
    TSEC_DRV_CTRL *pDrvCtrl
    )
{
    int             intLevel;
    TSEC_BD       * pRbd  = NULL;   /* generic rbd pointer */
    TSEC_BD       * pTbd  = NULL;   /* generic tbd pointer */
    char          * pFree = NULL;
    UINT16          ix;            /* a counter */

    ZXR10_MOT_TSEC_FRAME_SET(pDrvCtrl);

    ZXR10_MOT_TSEC_LOG ( ZXR10_MOT_TSEC_DBG_START,"zxr10_motTsecStop\n", 1, 2, 3, 4, 5, 6);

    semTake(pDrvCtrl->drvSem, WAIT_FOREVER);
    /* check if already stopped */
    if (!(pDrvCtrl->state & ZXR10_MOT_TSEC_STATE_RUNNING))
    {
        semGive(pDrvCtrl->drvSem);
       return OK;
    }

    if (pDrvCtrl->phyInfo->unInit != NULL)
    {
        pDrvCtrl->phyInfo->unInit(pDrvCtrl->phyInfo);
    }
    pDrvCtrl->intDisable(pDrvCtrl->vecRxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecTxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecErrNum);

    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecRxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecTxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecErrNum));

    zxr10_motTsecGracefulStop (pDrvCtrl);

    intLevel = intLock();

    /* mask chip interrupts */
    ZXR10_MOT_TSEC_IMASK_REG = 0;

    pDrvCtrl->intDisable(pDrvCtrl->vecRxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecTxNum);
    pDrvCtrl->intDisable(pDrvCtrl->vecErrNum);

    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecRxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecTxNum));
    pDrvCtrl->intDisConnect ((VOIDFUNCPTR *)((int)pDrvCtrl->vecErrNum));

    intUnlock (intLevel);

    /* call the BSP to disable the MII interface */
    if(pDrvCtrl->enetDisable != NULL)
    {
        pDrvCtrl->enetDisable();
    }    
    /* free buffer descriptors */

    pRbd = pDrvCtrl->pRbdBase;
    for (ix = 0; ix < pDrvCtrl->rbdNum; ix++)
    {
        if(pRbd->bdAddr)
        {
            endPktFree((char *)pRbd->bdAddr);
            pRbd->bdAddr = 0;
        }
        pRbd++;
    }

    pTbd = pDrvCtrl->pTbdBase;
    for (ix = 0; ix < pDrvCtrl->tbdNum; ix++)
    {
        pFree = pDrvCtrl->tBufList[ix];
        if (pFree != NULL)
        {
            endPktFree(pFree);
            pDrvCtrl->tBufList[ix] = NULL;
        }
        pTbd->bdAddr = 0;
        pTbd++;
    }
    
    /* bakeup some mac register for endToRos */    
    zxr10_motTsecBakeupParam(pDrvCtrl);
    
    pDrvCtrl->state &= ~ZXR10_MOT_TSEC_STATE_RUNNING;
    semGive(pDrvCtrl->drvSem);

    return OK;
}

/*******************************************************************************
*
* zxr10_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.