mottsecdrv.c

freescale mottsec 千兆单元驱动源码

#define ZXR10_MOT_TSEC_FLAG_CLEAR(clearBits)       \
    (pDrvCtrl->flags &= ~(clearBits))

#define ZXR10_MOT_TSEC_FLAG_SET(setBits)           \
    (pDrvCtrl->flags |= (setBits))

#define ZXR10_MOT_TSEC_FLAG_GET()                  \
    (pDrvCtrl->flags)

#define ZXR10_MOT_TSEC_FLAG_ISSET(setBits)         \
    (pDrvCtrl->flags & (setBits))

#define ZXR10_MOT_TSEC_USR_FLAG_ISSET(setBits)     \
    (pDrvCtrl->userFlags & (setBits))

#define END_FLAGS_ISSET(setBits)
    /*((&pDrvCtrl->endObj)->flags & (setBits))*/

#ifdef INCLUDE_RFC_2233
#define END_HADDR(pEnd)                                                  \
        ((pEnd).pMib2Tbl->m2Data.mibIfTbl.ifPhysAddress.phyAddress)

#define END_HADDR_LEN(pEnd)                                              \
        ((pEnd).pMib2Tbl->m2Data.mibIfTbl.ifPhysAddress.addrLength)

#define END_INC_IN_UCAST(mData, mLen)  \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)      \
            {                                       \
            pDrvCtrl->endObj.pMib2Tbl->m2PktCountRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                    M2_PACKET_IN,           \
                                    mData,   \
                                    mLen );  \
            }

#define END_INC_IN_NUCAST(mData, mLen)  \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)      \
            {                                       \
            pDrvCtrl->endObj.pMib2Tbl->m2PktCountRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                    M2_PACKET_IN,           \
                                    mData,   \
                                    mLen );  \
            }

#define END_INC_IN_ERRS()  \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)  \
            {                                    \
            pDrvCtrl->endObj.pMib2Tbl->m2CtrUpdateRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                     M2_ctrId_ifInErrors, 1);  \
            }

#define END_INC_IN_DISCARDS() \
         if (pDrvCtrl->endObj.pMib2Tbl != NULL)  \
             {                                    \
             pDrvCtrl->endObj.pMib2Tbl->m2CtrUpdateRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                             M2_ctrId_ifInDiscards, 1);  \
             }

#define END_INC_IN_OCTETS(mLen)

#define END_INC_OUT_UCAST(mData, mLen) \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)  \
            {                                    \
            pDrvCtrl->endObj.pMib2Tbl->m2PktCountRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                    M2_PACKET_OUT,           \
                                    mData,   \
                                    mLen );  \
            }

#define END_INC_OUT_NUCAST(mData, mLen) \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)  \
            {                                    \
            pDrvCtrl->endObj.pMib2Tbl->m2PktCountRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                    M2_PACKET_OUT,           \
                                    mData,   \
                                    mLen );  \
            }


#define END_INC_OUT_ERRS()                         \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)      \
            {                                       \
            pDrvCtrl->endObj.pMib2Tbl->m2CtrUpdateRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                     M2_ctrId_ifOutErrors, 1);  \
            }

#define END_INC_OUT_DISCARDS()                      \
        if (pDrvCtrl->endObj.pMib2Tbl != NULL)      \
            {                                       \
            pDrvCtrl->endObj.pMib2Tbl->m2CtrUpdateRtn (pDrvCtrl->endObj.pMib2Tbl, \
                                    M2_ctrId_ifOutDiscards, 1);  \
            }

#define END_INC_OUT_OCTETS(mLen)

#else

#define END_HADDR(pEnd)                                             \
        ((pEnd).mib2Tbl.ifPhysAddress.phyAddress)

#define END_HADDR_LEN(pEnd)                                         \
        ((pEnd).mib2Tbl.ifPhysAddress.addrLength)

#ifdef  INCLUDE_RFC_1213_OLD
#define END_INC_IN_ERRS()                                              \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_IN_ERRS, +1)
#define END_INC_IN_DISCARDS()                                          \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_IN_ERRS, +1)
#define END_INC_IN_UCAST(mData, mLen)                                  \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_IN_UCAST, +1)

#define END_INC_IN_NUCAST(mData, mLen)                                 \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_IN_UCAST, +1)
#define END_INC_IN_OCTETS(mLen)

#define END_INC_OUT_ERRS()                                             \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1)

#define END_INC_OUT_DISCARDS()                                         \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1)

#define END_INC_OUT_UCAST(mData, mLen)                                 \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1)
#define END_INC_OUT_NUCAST(mData, mLen)                                \
            END_ERR_ADD(&pDrvCtrl->endObj, MIB2_OUT_UCAST, +1)
#define END_INC_OUT_OCTETS(mLen)
#else
#define END_INC_IN_DISCARDS()           (pDrvCtrl->endObj.mib2Tbl.ifInDiscards++)
#define END_INC_IN_ERRS()               (pDrvCtrl->endObj.mib2Tbl.ifInErrors++)
#define END_INC_IN_UCAST(mData, mLen)   (pDrvCtrl->endObj.mib2Tbl.ifInUcastPkts++)
#define END_INC_IN_NUCAST(mData, mLen)  (pDrvCtrl->endObj.mib2Tbl.ifInNUcastPkts++)
#define END_INC_IN_OCTETS(mLen)         (pDrvCtrl->endObj.mib2Tbl.ifInOctets += mLen)

#define END_INC_OUT_DISCARDS()          (pDrvCtrl->endObj.mib2Tbl.ifOutDiscards++)
#define END_INC_OUT_ERRS()              (pDrvCtrl->endObj.mib2Tbl.ifOutErrors++)
#define END_INC_OUT_UCAST(mData, mLen)  (pDrvCtrl->endObj.mib2Tbl.ifOutUcastPkts++)
#define END_INC_OUT_NUCAST(mData, mLen) (pDrvCtrl->endObj.mib2Tbl.ifOutNUcastPkts++)
#define END_INC_OUT_OCTETS(mLen)        (pDrvCtrl->endObj.mib2Tbl.ifOutOctets += mLen)
#endif

#endif /* INCLUDE_RFC_2233 */


/* locals */

/* Function declarations not in any header files */

/* forward function declarations */

LOCAL STATUS    zxr10_motTsecInitParse (TSEC_DRV_CTRL * pDrvCtrl, char *initString);
LOCAL STATUS    zxr10_motTsecInitFunc (TSEC_DRV_CTRL *);
LOCAL STATUS    zxr10_motTsecInitParm (TSEC_DRV_CTRL *);
LOCAL STATUS    zxr10_motTsecInitMem (TSEC_DRV_CTRL *pDrvCtrl);
LOCAL STATUS    zxr10_motTsecInitVirCtrl(TSEC_DRV_CTRL *pDrvCtrl);
LOCAL STATUS    zxr10_motTsecRbdInit (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecTbdInit (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecPhyPreInit (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecSend (void *pCookie, char *pBuf, int len, char *pOrig);
IMPORT int zxr10_motTsecCapacity(void *pCookie);
/*LOCAL STATUS    zxr10_motTsecSend (TSEC_DRV_CTRL *pDrvCtrl, M_BLK *pMblk);*/
LOCAL void      zxr10_motTsecRestart (TSEC_DRV_CTRL *pDrvCtrl);
LOCAL void      zxr10_motTsecGracefulStop (TSEC_DRV_CTRL *pDrvCtrl);
LOCAL STATUS    zxr10_motTsecHashTblPopulate (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL int       zxr10_motTsecTbdClean (TSEC_DRV_CTRL * pDrvCtrl);

LOCAL STATUS    zxr10_motTsecMiiPhyRead (UINT8 phyAddr,UINT8 regAddr, 
                        UINT16 *retVal,TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecMiiPhyWrite (UINT8 phyAddr, UINT8 regAddr, 
                        UINT16 writeData,TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecAddrSet (TSEC_DRV_CTRL * pDrvCtrl, unsigned char * pAddr);
LOCAL void      zxr10_motTsecErrInt (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL void      zxr10_motTsecRxInt (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL void      zxr10_motTsecHandleRXFrames(TSEC_DRV_CTRL *pDrvCtrl);
LOCAL void      zxr10_motTsecSetMacMode(TSEC_DRV_CTRL * pDrvCtrl);
LOCAL void      zxr10_motTsecPhyIntHandle(TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecPhyIntCallback(void * pCookie);

LOCAL void      zxr10_motTsecBakeupParam (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL void      zxr10_motTsecRestorParam (TSEC_DRV_CTRL * pDrvCtrl);

/* END Specific interfaces. */

DRV_VIR_CTRL *  zxr10_motTsecEndLoad (char *initString);
LOCAL STATUS    zxr10_motTsecStart (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecUnload (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecStop (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecIoctl (void * pCookie, int cmd, caddr_t data);
LOCAL STATUS    zxr10_motTsecMCastAddrAdd (TSEC_DRV_CTRL * pDrvCtrl, UCHAR * pAddress);
LOCAL STATUS    zxr10_motTsecMCastAddrDel (TSEC_DRV_CTRL * pDrvCtrl, UCHAR * pAddress);
LOCAL STATUS    zxr10_motTsecMCastAddrGet (TSEC_DRV_CTRL * pDrvCtrl,
                                        MOT_MULTI_TABLE *pTable);
#if 0
LOCAL STATUS    zxr10_motTsecPollSend (TSEC_DRV_CTRL * pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    zxr10_motTsecPollReceive (TSEC_DRV_CTRL * pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    zxr10_motTsecPollStart (TSEC_DRV_CTRL * pDrvCtrl);
LOCAL STATUS    zxr10_motTsecPollStop (TSEC_DRV_CTRL * pDrvCtrl);
#endif
/* globals */

IMPORT FUNCPTR         ffsMsb;
IMPORT STATUS Drv_FunctionMacAddrGet(unsigned char * pAddr);
IMPORT int zxr10_motTsecCapacity(void *pCookie);

#ifdef ZXR10_MOT_TSEC_DBG

void zxr10_motTsecMiiShow (int, int, int);
void zxr10_motTsecMibShow (int);
void zxr10_motTsecRegsShow (int);

#define ZXR10_MOT_TSEC_DBG_OFF        0x0000
#define ZXR10_MOT_TSEC_DBG_RX         0x0001
#define ZXR10_MOT_TSEC_DBG_TX         0x0002
#define ZXR10_MOT_TSEC_DBG_POLL       0x0004
#define ZXR10_MOT_TSEC_DBG_MII        0x0008
#define ZXR10_MOT_TSEC_DBG_LOAD       0x0010
#define ZXR10_MOT_TSEC_DBG_IOCTL      0x0020
#define ZXR10_MOT_TSEC_DBG_INT        0x0040
#define ZXR10_MOT_TSEC_DBG_START      0x0080
#define ZXR10_MOT_TSEC_DBG_INT_RX_ERR 0x0100
#define ZXR10_MOT_TSEC_DBG_INT_TX_ERR 0x0200
#define ZXR10_MOT_TSEC_DBG_RX_ERR     0x0400
#define ZXR10_MOT_TSEC_DBG_TX_ERR     0x0800
#define ZXR10_MOT_TSEC_DBG_TRACE      0x1000
#define ZXR10_MOT_TSEC_DBG_TRACE_RX   0x2000
#define ZXR10_MOT_TSEC_DBG_TRACE_TX   0x4000
#define ZXR10_MOT_TSEC_DBG_MONITOR    0x8000
#define ZXR10_MOT_TSEC_DBG_ANY        0xffff
#define ZXR10_MOT_TSEC_DBG_REG      0x10000


#define ZXR10_MOT_TSEC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)            \
    {                                   \
    if (zxr10_motTsecEndDbg & FLG)                   \
        logMsg (X0, X1, X2, X3, X4, X5, X6);                    \
    }
int  zxr10_motTsecDrvCnt = 0;
DRV_VIR_CTRL * zxr10_motTsecDrv[10];
/*
void zxr10_motTsecLog (int, char *,...);

#define ZXR10_MOT_TSEC_LOG    zxr10_motTsecLog
*/

#define ZXR10_MOT_TSEC_STAT_INCR(i) (i++)

FUNCPTR _func_netJobAdd;
FUNCPTR _func_txRestart;
FUNCPTR _func_error;

/* global debug level flag */
#if 0
UINT32 zxr10_motTsecEndDbg = (ZXR10_MOT_TSEC_DBG_RX_ERR | ZXR10_MOT_TSEC_DBG_TX_ERR | ZXR10_MOT_TSEC_DBG_INT_RX_ERR | ZXR10_MOT_TSEC_DBG_INT_TX_ERR );
#endif
/* UINT32 zxr10_motTsecEndDbg = (ZXR10_MOT_TSEC_DBG_ANY) & (~ZXR10_MOT_TSEC_DBG_MII); */
UINT32 zxr10_motTsecEndDbg = (ZXR10_MOT_TSEC_DBG_REG);

TSEC_DRV_CTRL * pTsecDrvCtrlDbg[ZXR10_MOT_TSEC_MAX_DEVS];

#else /* ZXR10_MOT_TSEC_DBG */
#define ZXR10_MOT_TSEC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
#define ZXR10_MOT_TSEC_STAT_INCR(i)
#endif


#define INSTALL_MOTTSEC_88E1111PHY (1)
#if INSTALL_MOTTSEC_88E1111PHY
#include "88E1111phy.c"

LOCAL DRV_VIR_PHY* (*zxr10_motTsecPhyLoad)() = _88E1111PhyLoad;
LOCAL void (*zxr10_motTsecPhyUnLoad)(DRV_VIR_PHY *) = _88E1111PhyUnLoad;

#else

#error "motTsec must install one phy"

#endif

/*******************************************************************************
*
* zxr10_motTsecEndLoad - initialize the driver and device
*
* This routine initializes both driver and device to an operational state
* using device specific parameters specified by <initString>.
*
* The parameter string, <initString>, is an ordered list of parameters each
* separated by a colon. The format of <initString> is:
*
* "<CCSVal>:<ivec>:<bufBase>:<bufSize>:<fifoTxBase>:<fifoRxBase>
* :<tbdNum>:<rbdNum>:<phyAddr>:<phyDefMode>:<pAnOrderTbl>:<userFlags>
*
*
* The TSEC shares a region of memory with the driver.  The caller of this
* routine can specify the address of this memory region, or can specify that
* the driver must obtain this memory region from the system resources.
*
* A default number of transmit/receive buffer descriptors of 32 can be
* selected by passing zero in the parameters <tbdNum> and <rbdNum>.
* In other cases, the number of buffers selected should be greater than two.
*
* The <bufBase> parameter is used to inform the driver about the shared
* memory region.  If this parameter is set to the constant "NONE," then this
* routine will attempt to allocate the shared memory from the system.  Any
* other value for this parameter is interpreted by this routine as the address
* of the shared memory region to be used. The <bufSize> parameter is used
* to check that this region is large enough with respect to the provided
* values of both transmit/receive buffer descriptors.
*
* If the caller provides the shared memory region, then the driver assumes
* that this region does not require cache coherency operations, nor does it
* require conversions between virtual and physical addresses.
*
* If the caller indicates that this routine must allocate the shared memory
* region, then this routine will use cacheDmaMalloc() to obtain
* some  cache-safe memory.  The attributes of this memory will be checked,
* and if the memory is not write coherent, this routine will abort and
* return NULL.
*
* RETURNS: an END object pointer, or NULL on error.
*
* SEE ALSO: ifLib,
* .I "MPC8260 Power QUICC II User's Manual"
*/

DRV_VIR_CTRL* zxr10_motTsecEndLoad
    (
    char *initString
    )
{
    TSEC_DRV_CTRL * pDrvCtrl = NULL;  /* pointer to TSEC_DRV_CTRL structure */

    if (initString == NULL)
        return NULL;
    /* allocate the device structure */

    pDrvCtrl = (TSEC_DRV_CTRL *) calloc (sizeof (TSEC_DRV_CTRL), 1);
    if (NULL == pDrvCtrl)
        return NULL;

    /* get memory for the phyInfo structure */
    pDrvCtrl->phyInfo = zxr10_motTsecPhyLoad();
    if (pDrvCtrl->phyInfo == NULL)
        goto errorExit;

    pDrvCtrl->drvSem = semMCreate(SEM_Q_PRIORITY|SEM_DELETE_SAFE|SEM_INVERSION_SAFE);
    if(NULL == pDrvCtrl->drvSem)
        goto errorExit;