dec21x40end.c

Tornado 2.0.2 source code!vxworks的源代码

#define DRV_DEBUG_MII		0x0080
#define DRV_DEBUG_POLL_REDIR	0x10000
#define	DRV_DEBUG_LOG_NVRAM	0x20000
#define DRV_DEBUG_ALL		0xffffffff 

int	decDebug = DRV_DEBUG_LOAD;
int     decTxInts=0;
int     decRxInts=0;
int	decTxErrors = 0;
int	decRxErrors = 0;
int	decTxTpsErrors = 0;
int	decTxBufErrors = 0;
int	decTxTjtErrors = 0;
int	decTxUnfErrors = 0;
int	decTxLcErrors = 0;
int	decRxBufErrors = 0;
int	decRxRpsErrors = 0;
int	decRxWtErrors = 0;
int	decDescErrors = 0;

IMPORT	int dataDump();
IMPORT	int eAdrsDisplay();

#define DRV_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)                        \
	if (decDebug & FLG)                                             \
            logMsg(X0, X1, X2, X3, X4, X5, X6);

#else /*DRV_DEBUG*/

#define DRV_LOG(DBG_SW, X0, X1, X2, X3, X4, X5, X6)

#endif /*DRV_DEBUG*/

#define END_FLAGS_ISSET(pEnd, setBits)                                  \
            ((pEnd)->flags & (setBits))

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

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

#define DEC_SPEED_10	10000000             /* 10 Mbps */
#define DEC_SPEED_100	100000000            /* 100 Mbps */
#define	DEC_SPEED_DEF	DEC_SPEED_10
#define EADDR_LEN	6                    /* ethernet address length */
#define DEC_PKT_SIZE	(ETHERMTU + SIZEOF_ETHERHEADER + EADDR_LEN)

#define	DEC_LOOPS_PER_NS	4
#define DEC_NSDELAY(nsec) do {						\
			volatile int nx = 0;                            \
			volatile int loop = ((nsec)*dec21x40Loops);	\
			for (nx = 0; nx < loop; nx++)			\
				;                  			\
			} while (0)

#define DEC_BUF_ALLOC_ROUTINE                                           \
	(FUNCPTR) (DRV_FLAGS_ISSET(DEC_MEMOWN) ?                        \
                   cacheDmaMalloc : NULL)

#define DEC_BUF_POOL_ADRS                                               \
	(char *)(DRV_FLAGS_ISSET(DEC_MEMOWN) ?                          \
                  NULL:(pDrvCtrl->txRing + pDrvCtrl->numTds))

/* DRV_CTRL flags access macros */
#define DRV_FLAGS_SET(setBits)                                          \
	(pDrvCtrl->flags |= (setBits))

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

#define DRV_FLAGS_CLR(clrBits)                                          \
	(pDrvCtrl->flags &= ~(clrBits))

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

/* DRV_CTRL user flags access macros */
#define DRV_USR_FLAGS_SET(setBits)                                          \
	(pDrvCtrl->usrFlags |= (setBits))

#define DRV_USR_FLAGS_ISSET(setBits)                                        \
	(pDrvCtrl->usrFlags & (setBits))

#define DRV_USR_FLAGS_CLR(clrBits)                                          \
	(pDrvCtrl->usrFlags &= ~(clrBits))

#define DRV_USR_FLAGS_GET()                                                 \
        (pDrvCtrl->usrFlags)

#define DRV_PHY_FLAGS_ISSET(setBits)                                        \
	(pDrvCtrl->miiPhyFlags & (setBits))

/* Cache macros */
#define DEC_CACHE_INVALIDATE(address, len)                              \
        CACHE_DRV_INVALIDATE (&pDrvCtrl->cacheFuncs, (address), (len))

#define DEC_CACHE_VIRT_TO_PHYS(address)                                 \
        CACHE_DRV_VIRT_TO_PHYS (&pDrvCtrl->cacheFuncs, (address))

#define DEC_CACHE_PHYS_TO_VIRT(address)                                 \
        CACHE_DRV_PHYS_TO_VIRT (&pDrvCtrl->cacheFuncs, (address))

/* memory to PCI address translation macros */
#define PCI_TO_MEM_PHYS(pciAdrs)                                        \
	(((ULONG)(pciAdrs)) - (pDrvCtrl->pciMemBase))
	
#define MEM_TO_PCI_PHYS(memAdrs)                                        \
	(((ULONG)(memAdrs)) + (pDrvCtrl->pciMemBase))

#define DEC_VIRT_TO_PCI(vAdrs)                                          \
	MEM_TO_PCI_PHYS (DEC_CACHE_VIRT_TO_PHYS (vAdrs))

#define DEC_PCI_TO_VIRT(pciAdrs)                                        \
	DEC_CACHE_PHYS_TO_VIRT (PCI_TO_MEM_PHYS (pciAdrs))

#ifndef TCP_MSS
#define TCP_MSS		536		/* TCP maximum segment size */
#endif
#define RWIN		(TCP_MSS * 4)	/* Receive window size */

/*
 * CSR access macros
 *
 * To optimize CSR accesses, redefine DEC_CSR_READ and
 * DEC_CSR_WRITE macros in a wrapper file.
 */
#ifndef DEC_CSR_READ
#define DEC_CSR_READ(csr)                                               \
	dec21x40CsrRead(pDrvCtrl->devAdrs, (csr))
#endif /* DEC_CSR_READ */

#ifndef DEC_CSR_WRITE
#define DEC_CSR_WRITE(csr,val)                                          \
	dec21x40CsrWrite(pDrvCtrl->devAdrs, (csr), (val))
#endif /* DEC_CSR_WRITE */

#define DEC_CSR_UPDATE(csr,val)                                         \
	DEC_CSR_WRITE((csr), DEC_CSR_READ(csr) | (val))
    
#define DEC_CSR_RESET(csr,val)                                          \
	DEC_CSR_WRITE((csr), DEC_CSR_READ(csr) & ~(val))
    
#define DEC_SROM_CMD_WRITE(adrs,delay)                                  \
	do {                                                               \
        DEC_CSR_WRITE(CSR9, CSR9_21140_SR | CSR9_21140_WR | (adrs));    \
        DEC_NSDELAY (delay);						\
        } while (0)

#define DEC_SROM_CMD_READ()                                             \
	((DEC_CSR_READ(CSR9) & 0x8) >> 3)

/* MII read/write access macros */
   
#define CSR9_MII_WR 0x00000000

#define DEC_MII_BIT_READ(pBData)                                        \
        do {                                                               \
        DEC_CSR_WRITE (CSR9, CSR9_21140_MII | CSR9_21140_RD);           \
        DEC_NSDELAY (100);						\
        DEC_CSR_WRITE (CSR9, CSR9_21140_MII | CSR9_21140_RD | CSR9_21140_MDC);\
        DEC_NSDELAY (100);						\
        *(pBData) |= CSR9_MII_DBIT_RD (DEC_CSR_READ (CSR9));		\
        } while (0)

#define DEC_MII_BIT_WRITE(data)                                      \
        do {                                                            \
        DEC_CSR_WRITE (CSR9, CSR9_MII_DBIT_WR(data) |                \
                      CSR9_MII_WR | CSR9_21140_WR);                  \
        DEC_NSDELAY (100);                                           \
        DEC_CSR_WRITE (CSR9, CSR9_MII_DBIT_WR(data) |                \
                      CSR9_MII_WR | CSR9_21140_WR | CSR9_21140_MDC); \
        DEC_NSDELAY (100);                                           \
        } while (0)

#define DEC_MII_RTRISTATE           \
        do {                        \
        int retVal;                 \
        DEC_MII_BIT_READ (&retVal); \
        } while (0)

#define DEC_MII_WTRISTATE           \
        do {                        \
        DEC_MII_BIT_WRITE(0x1);     \
        DEC_MII_BIT_WRITE(0x0);     \
        } while (0)

#define DEC_MII_WRITE(data, bitCount)                \
        do {                                         \
        int i=(bitCount);                            \
                                                     \
        while (i--)                                  \
            DEC_MII_BIT_WRITE (((data) >> i) & 0x1); \
        } while (0)

#define DEC_MII_READ(pData, bitCount) \
        do {                          \
        int i=(bitCount);             \
                                      \
        while (i--)                   \
            {                         \
            *(pData) <<= 1;           \
            DEC_MII_BIT_READ (pData); \
            }                         \
        } while (0)

/*
 * Default macro definitions for BSP interface.
 * These macros can be redefined in a wrapper file, to generate
 * a new module with an optimized interface.
 */
#ifndef SYS_INT_CONNECT
#define SYS_INT_CONNECT(pDrvCtrl,rtn,arg,pResult)                       \
    do {                                                                \
    int vector = pDrvCtrl->ivec;                                        \
    IMPORT STATUS sysIntConnect();                                      \
    if (!pDrvCtrl->intrConnect)                                         \
        {                                                               \
        pDrvCtrl->intrConnect = TRUE;                                   \
        *pResult = intConnect ((VOIDFUNCPTR *)INUM_TO_IVEC (vector),    \
                                (rtn), (int)(arg));                     \
        }                                                               \
    } while (0)
#endif /*SYS_INT_CONNECT*/
 
#ifndef SYS_INT_DISCONNECT
#define SYS_INT_DISCONNECT(pDrvCtrl,rtn,arg,pResult)                    \
    do {                                                                \
    /* set pDrvCtrl->intrConnect to FALSE if appropriate */             \
    *pResult = OK;							\
    } while (0)
#endif /*SYS_INT_DISCONNECT*/

#ifndef SYS_INT_ENABLE
#define SYS_INT_ENABLE(pDrvCtrl)                                        \
    do {                                                                \
    IMPORT void sysLanIntEnable();                                      \
    sysLanIntEnable (pDrvCtrl->ilevel);                                 \
    } while (0)
#endif /*SYS_INT_ENABLE*/

#ifndef SYS_INT_DISABLE
#define SYS_INT_DISABLE(pDrvCtrl)                                       \
    do {                                                                \
    IMPORT void sysLanIntDisable();                                     \
    sysLanIntDisable (pDrvCtrl->ilevel);                                \
    } while (0)
#endif /*SYS_INT_DISABLE*/

#define	END_MIB_SPEED_SET(pEndObj, speed)                               \
	((pEndObj)->mib2Tbl.ifSpeed=speed)

#define NET_BUF_ALLOC()                                                 \
    netClusterGet (pDrvCtrl->endObj.pNetPool, pDrvCtrl->clPoolId)

#define NET_BUF_FREE(pBuf)                                              \
    netClFree (pDrvCtrl->endObj.pNetPool, pBuf)

#define	NET_MBLK_ALLOC()                                                \
    mBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT, MT_DATA)

#define NET_MBLK_FREE(pMblk)                                            \
    netMblkFree (pDrvCtrl->endObj.pNetPool, (M_BLK_ID)pMblk)

#define	NET_CL_BLK_ALLOC()                                              \
    clBlkGet (pDrvCtrl->endObj.pNetPool, M_DONTWAIT)

#define NET_CL_BLK_FREE(pClblk)                                         \
    clBlkFree (pDrvCtrl->endObj.pNetPool, (CL_BLK_ID)pClBlk)
            
#define NET_MBLK_BUF_FREE(pMblk)                                        \
    netMblkClFree ((M_BLK_ID)pMblk)

#define NET_MBLK_CHAIN_FREE(pMblk)                                      \
    do {                                                                \
    M_BLK *pNext;                                                       \
                                                                        \
    pNext=pMblk;                                                        \
    while (pNext)                                                       \
        pNext=NET_MBLK_BUF_FREE (pNext);                                \
    } while (0)
    
#define NET_MBLK_CL_JOIN(pMblk, pClBlk)                              	\
    netMblkClJoin ((pMblk), (pClBlk))

#define NET_CL_BLK_JOIN(pClBlk, pBuf, len)                             	\
    netClBlkJoin ((pClBlk), (pBuf), (len), NULL, 0, 0, 0)
        
#define	DRV_CTRL	DEC21X40_DRV_CTRL

/* structure sizes */
#define DRV_CTRL_SIZ		sizeof(DRV_CTRL)
#define RD_SIZ			sizeof(DEC_RD)
#define TD_SIZ			sizeof(DEC_TD)

/* locals */

/* Default network buffer configuration */

int	dec21x40Loops = DEC_LOOPS_PER_NS;	/* spin loops per nsec */

NET_POOL dec21x40NetPool; 

/* constant data to set PHY control register */

LOCAL const UINT dcForcePhyModes[] = 
    {
    MII_CR_100 | MII_CR_FDX,	/* 100FD */
    MII_CR_100,			/* 100HD */
    MII_CR_FDX,			/* 10FD  */
    0,				/* 10HD  */
    -1
    } ;


/* forward declarations */

LOCAL STATUS	dec21x40InitParse (DRV_CTRL *pDrvCtrl, char *InitString);
LOCAL STATUS	dec21x40InitMem (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	dec21x40IASetup (DRV_CTRL *pDrvCtrl);
LOCAL void 	dec21x40ModeSet (DRV_CTRL *pDrvCtrl);
LOCAL int	dec21x40HashIndex (char *eAddr);

LOCAL void 	dec21x40Int (DRV_CTRL *pDrvCtrl);
LOCAL STATUS 	dec21x40Recv (DRV_CTRL *pDrvCtrl, DEC_RD *rmd);
LOCAL STATUS 	dec21x40ChipReset (DRV_CTRL *pDrvCtrl);
LOCAL void	dec21040AuiTpInit (DRV_CTRL *pDrvCtrl);
LOCAL void 	dec21x40CsrWrite (ULONG devAdrs, int reg, ULONG value);
LOCAL ULONG 	dec21x40CsrRead (ULONG devAdrs, int reg);
LOCAL STATUS 	dec21x40EnetAddrGet (DRV_CTRL *pDrvCtrl, char *enetAdrs);
LOCAL STATUS 	dec21040EnetAddrGet (DRV_CTRL *pDrvCtrl, char *enetAdrs);
LOCAL STATUS 	dec21140EnetAddrGet (DRV_CTRL *pDrvCtrl, char *enetAdrs);
LOCAL void	dec21x40Restart (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	dec21x40MediaChange (DRV_CTRL *pDrvCtrl);

LOCAL DEC_TD *	dec21x40TxDGet (DRV_CTRL *pDrvCtrl);
LOCAL DEC_RD *	dec21x40RxDGet (DRV_CTRL *pDrvCtrl);
LOCAL void 	dec21x40TxRingClean (DRV_CTRL *pDrvCtrl);
LOCAL void 	dec21x40RxIntHandle (DRV_CTRL *pDrvCtrl);

LOCAL STATUS 	dec21140MediaSelect (DRV_CTRL *pDrvCtrl, UINT *pCsr6Val);
LOCAL STATUS 	dec21143MediaSelect (DRV_CTRL *pDrvCtrl, UINT *pCsr6Val);
LOCAL STATUS 	dec21x40PhyPreInit  (DRV_CTRL *pDrvCtrl, UCHAR * pInfoBlock);
LOCAL STATUS 	dec21x40MiiInit  (DRV_CTRL *pDrvCtrl, UINT *pCsr6Val,
				  UCHAR * pInfoBlock);

LOCAL STATUS dec21x40MiiRead ( DRV_CTRL *pDrvCtrl, UINT8 phyAdrs, UINT8 phyReg,
	UINT16 *pRetVal);
LOCAL STATUS dec21x40MiiWrite (DRV_CTRL *pDrvCtrl, UINT8 phyAdrs, UINT8 phyReg,
    USHORT data);

/* externals */
IMPORT STATUS	sysDec21x40EnetAddrGet (int unit, char *enetAdrs);

/* globals */
USHORT		dec21140SromWordRead (DRV_CTRL *pDrvCtrl, UCHAR lineCnt);
FUNCPTR		_func_dec21x40MediaSelect = (FUNCPTR) NULL;

#ifdef DRV_DEBUG
#include "netShow.h"
IMPORT void netPoolShow (NET_POOL_ID);
void decCsrShow (int inst);
void decShow (int inst);
#endif /* DRV_DEBUG */

/* END Specific interfaces. */

END_OBJ *	dec21x40EndLoad (char *initString);
LOCAL STATUS	dec21x40Unload (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	dec21x40Start (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	dec21x40Stop (DRV_CTRL *pDrvCtrl);
LOCAL int	dec21x40Ioctl (DRV_CTRL *pDrvCtrl, int cmd, caddr_t data);
LOCAL STATUS	dec21x40Send (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
LOCAL STATUS	dec21x40MCastAddrAdd (DRV_CTRL *pDrvCtrl, char* pAddress);
LOCAL STATUS	dec21x40MCastAddrDel (DRV_CTRL *pDrvCtrl, char* pAddress);
LOCAL STATUS	dec21x40MCastAddrGet (DRV_CTRL *pDrvCtrl, 
                                      MULTI_TABLE *pTable);
LOCAL STATUS	dec21x40PollSend (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
LOCAL STATUS	dec21x40PollReceive (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
LOCAL STATUS	dec21x40PollStart (DRV_CTRL *pDrvCtrl);
LOCAL STATUS	dec21x40PollStop (DRV_CTRL *pDrvCtrl);

/* 
 * Define the device function table.  This is static across all driver
 * instances.
 */