m5200fecend.c

MPC5200 BSP 支持ATA,USB, I2C,扩展网口

/* m5200FecEnd.c - END style MPC5200 FEC Ethernet network interface driver */

#include "copyright_wrs.h"
#include "vxWorks.h"
#include "wdLib.h"
#include "iv.h"
#include "vme.h"
#include "net/mbuf.h"
#include "net/unixLib.h"
#include "net/protosw.h"
#include "sys/socket.h"
#include "sys/ioctl.h"
#include "errno.h"
#include "memLib.h"
#include "intLib.h"
#include "net/route.h"
#include "iosLib.h"
#include "errnoLib.h"
#include "vxLib.h"

#include "cacheLib.h"
#include "logLib.h"
#include "netLib.h"
#include "stdio.h"
#include "stdlib.h"
#include "sysLib.h"
#include "taskLib.h"

#include "net/systm.h"
#include "sys/times.h"
#include "net/if_subr.h"

#undef ETHER_MAP_IP_MULTICAST
#include "etherMultiLib.h"
#include "end.h"
#include "semLib.h"

#define    END_MACROS
#include "endLib.h"
#include "lstLib.h"

#include "lite5200b.h"
#include "drv/end/m5200FecEnd.h"
#include "capi/ppctypes.h"
#include "arch/ppc/m5200.h"
#include "capi/mgt5200/sdma.h"
#include "capi/bestcomm_api.h"
#include "drv/intrCtl/m5200Intr.h"

/* defines */

/* Driver debug control */
#undef MOT_FEC_DBG

static TaskId rxTaskId;	/* SDMA RX task ID */
static TaskId txTaskId;	/* SDMA TX task ID */

/* Task number assignment */
#define FEC_RECV_TASK_NO            TASK_FEC_RX
#define FEC_XMIT_TASK_NO            TASK_FEC_TX


/* Driver debug control */
DRV_CTRL *  pDrvCtrlDbg = NULL;

#define MOT_FEC_DBG     /* 调试开关 */
#define PLINE logMsg("%d\n", __LINE__, 0, 0, 0, 0, 0)

#ifdef MOT_FEC_DBG
#define MOT_FEC_DBG_OFF           0x0000
#define MOT_FEC_DBG_RX            0x0001
#define MOT_FEC_DBG_TX            0x0002
#define MOT_FEC_DBG_POLL          0x0004
#define MOT_FEC_DBG_MII           0x0008
#define MOT_FEC_DBG_LOAD          0x0010
#define MOT_FEC_DBG_IOCTL         0x0020
#define MOT_FEC_DBG_INT           0x0040
#define MOT_FEC_DBG_START         0x0080
#define MOT_FEC_DBG_ANY           0xffff

UINT32  motFecEndDbg = MOT_FEC_DBG_OFF;

UINT32  motFecBabRxErr = 0x0;
UINT32  motFecBabTxErr = 0x0;
UINT32  motFecHbFailErr = 0x0;
UINT32  motFecTxLcErr = 0x0;
UINT32  motFecTxUrErr = 0x0;
UINT32  motFecTxRlErr = 0x0;
UINT32  motFecRxLgErr = 0x0;
UINT32  motFecRxNoErr = 0x0;
UINT32  motFecRxCrcErr = 0x0;
UINT32  motFecRxOvErr = 0x0;
UINT32  motFecRxTrErr = 0x0;
UINT32  motFecRxLsErr = 0x0;
UINT32  motFecRxMemErr = 0x0;

#define MOT_FEC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)            \
    {                                    \
    if (motFecEndDbg & FLG)                        \
        logMsg (X0, (int)(X1), (int)(X2), (int)(X3),            \
        (int)(X4), (int)(X5), (int)(X6) );                \
    }

#else /* MOT_FEC_DBG */

#define MOT_FEC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)

#endif /* MOT_FEC_DBG */

#define MOT_FEC_BD_CACHE_INVAL(address, len)                        \
        CACHE_DRV_INVALIDATE (&pDrvCtrl->bdCacheFuncs, (address), (len))

#define MOT_FEC_CACHE_INVAL(address, len)                                   \
    CACHE_DRV_INVALIDATE (&pDrvCtrl->bufCacheFuncs, (address), (len))

#define MOT_FEC_CACHE_FLUSH(address, len)                                   \
    CACHE_DRV_FLUSH (&pDrvCtrl->bufCacheFuncs, (address), (len))

/* driver flags */

#define MOT_FEC_OWN_MEM        0x01    /* internally provided memory */
#define MOT_FEC_INV_TBD_NUM    0x02    /* invalid tbdNum provided */
#define MOT_FEC_INV_RBD_NUM    0x04    /* invalid rbdNum provided */
#define MOT_FEC_POLLING        0x08    /* polling mode */
#define MOT_FEC_PROM           0x20    /* promiscuous mode */
#define MOT_FEC_MCAST          0x40    /* multicast addressing mode */
#define MOT_FEC_FD             0x80    /* full duplex mode */

/* shortcuts */

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

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

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

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

#define MOT_FEC_PHY_FLAGS_SET(setBits)                    \
    (pDrvCtrl->phyInfo->phyFlags |= (setBits))

#define MOT_FEC_PHY_FLAGS_ISSET(setBits)                \
    (pDrvCtrl->phyInfo->phyFlags & (setBits))

#define MOT_FEC_PHY_FLAGS_GET(setBits)                    \
    (pDrvCtrl->phyInfo->phyFlags)

#define MOT_FEC_PHY_FLAGS_CLEAR(clearBits)                \
    (pDrvCtrl->phyInfo->phyFlags &= ~(clearBits))

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

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

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

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

/* some BDs definitions */

/*
 * the total is 0x600 and it accounts for the required alignment
 * of receive data buffers, and the cluster overhead.
 */

#define MOT_FEC_MAX_CL_LEN      ((MOT_FEC_MAX_PCK_SZ            \
                 + (MOT_FEC_BD_ALIGN - 1)        \
                 + (CL_OVERHEAD - 1))            \
                 & (~ (CL_OVERHEAD - 1)))

#define MOT_FEC_MAX_RX_BUF    ((MOT_FEC_MAX_PCK_SZ + MOT_FEC_BD_ALIGN - 1) \
                & (~(MOT_FEC_BD_ALIGN - 1)))

#define MOT_FEC_BUF_V_LEN    (MOT_FEC_MAX_RX_BUF + 16)

#define MOT_FEC_RX_BUF_SZ       (MOT_FEC_MAX_CL_LEN)
#define MOT_FEC_TX_BUF_SZ       (MOT_FEC_MAX_CL_LEN)

#define MOT_FEC_MEM_SZ(pDrvCtrl)                    \
    ((pDrvCtrl)->bufSize)

#define MOT_FEC_LOAN_SZ                            \
    (MOT_FEC_RX_BUF_SZ * MOT_FEC_BD_LOAN_NUM)

#define MOT_FEC_RX_MEM(pDrvCtrl)                    \
    (MOT_FEC_RX_BUF_SZ * ((pDrvCtrl)->rbdNum + MOT_FEC_BD_LOAN_NUM))

#define MOT_FEC_TX_MEM(pDrvCtrl)                    \
    (MOT_FEC_TX_BUF_SZ * (MOT_FEC_TBD_POLL_NUM + MOT_FEC_TX_CL_NUM))

#define MOT_FEC_TBD_MEM(pDrvCtrl)                    \
    (MOT_FEC_TBD_SZ * (pDrvCtrl)->tbdNum)

#define MOT_FEC_RBD_MEM(pDrvCtrl)                    \
    (MOT_FEC_RBD_SZ * (pDrvCtrl)->rbdNum)

#define MOT_FEC_BD_MEM(pDrvCtrl)                    \
    (MOT_FEC_TBD_MEM (pDrvCtrl) + MOT_FEC_RBD_MEM (pDrvCtrl))

/* Control/Status Registers (CSR) definitions */

#define MOT_FEC_CSR_WR(csrOff, csrVal)                    \
    {                                    \
    UINT32 temp = 0;                            \
                                    \
    temp = (UINT32) ((pDrvCtrl->MBARAddr) + (csrOff));     \
                                    \
    MOT_FEC_LONG_WR ((UINT32 *) (temp), (csrVal));            \
    }                                    

#define MOT_FEC_CSR_WR_2(csrOff, csrVal)                    \
    {                                    \
    UINT32 temp = 0;                            \
                                    \
    temp = (UINT32) ((pDrvCtrlDbg->MBARAddr)     \
                      + (csrOff));            \
                                    \
    MOT_FEC_LONG_WR ((UINT32 *) (temp), (csrVal));            \
    }                                    

#define MOT_FEC_CSR_RD(csrOff, csrVal)                    \
    {                                    \
    UINT32 temp = 0;                            \
                                    \
    temp = (UINT32) ((pDrvCtrl->MBARAddr)     \
                      + (csrOff));            \
                                    \
    MOT_FEC_LONG_RD ((UINT32 *) (temp), (csrVal));            \
    }                                    

/* macros to read/write tx/rx buffer descriptors */

#define MOT_FEC_BD_WORD_WR(bdAddr, bdOff, bdVal)            \
    {                                    \
    UINT32 temp = 0;                            \
                                    \
    temp = (UINT32) ((bdAddr) + (bdOff));        \
                                    \
    MOT_FEC_WORD_WR ((UINT16 *) (temp), (bdVal));            \
    }                                    

/* here we're writing the data pointer, so it's a physical address */

#define MOT_FEC_BD_LONG_WR(bdAddr, bdOff, bdVal)            \
    {                                    \
    UINT32 temp1 = 0;                            \
    UINT32 temp2 = 0;                            \
                                    \
    temp1 = (UINT32) ((bdAddr) + (bdOff));        \
    temp2 = (UINT32) (bdVal);            \
                                    \
    MOT_FEC_LONG_WR ((UINT32 *) (temp1), (temp2));            \
    }                                    

#define MOT_FEC_BD_WORD_RD(bdAddr, bdOff, bdVal)            \
    {                                    \
    UINT32 temp = 0;                            \
                                    \
    temp = (UINT32) ((bdAddr) + (bdOff));        \
                                    \
    MOT_FEC_WORD_RD ((UINT16 *) (temp), (bdVal));                    \
    }                                    

#define MOT_FEC_BD_LONG_RD(bdAddr, bdOff, bdVal)            \
    {                                    \
    UINT32 temp1 = 0;                            \
    UINT32 temp2 = 0;                            \
                                    \
    temp1 = (UINT32) ((bdAddr) + (bdOff));        \
                                    \
    MOT_FEC_LONG_RD ((UINT32 *) (temp1), (temp2));            \
                                    \
    bdVal = (char *) (temp2);            \
    }                                    

#define MOT_FEC_NEXT_TBD(pDrvCtrl, pTbd)                \
    (pTbd) = (MOT_FEC_TBD_ID) ((pDrvCtrl)->tbdBase +   \
                   ((pDrvCtrl)->tbdIndex * MOT_FEC_TBD_SZ))

#define MOT_FEC_USED_TBD(pDrvCtrl, pTbd)                   \
    (pTbd) = (MOT_FEC_TBD_ID) ((pDrvCtrl)->tbdBase +        \
                   ((pDrvCtrl)->usedTbdIndex * MOT_FEC_TBD_SZ))

#define MOT_FEC_NEXT_RBD(pDrvCtrl, pRbd)                   \
    (pRbd) = (MOT_FEC_RBD_ID) ((pDrvCtrl)->rbdBase +        \
                   (((pDrvCtrl)->rbdIndex) * MOT_FEC_RBD_SZ))

#define MOT_FEC_ETH_ENABLE                        \
    MOT_FEC_CSR_WR (MOT_FEC_CTRL_OFF, MOT_FEC_ETH_EN | MOT_FEC_ETH_FOE);

#define MOT_FEC_ETH_DISABLE                        \
    MOT_FEC_CSR_WR (MOT_FEC_CTRL_OFF, MOT_FEC_ETH_DIS);

#define MOT_FEC_RX_ACTIVATE                        \
    MOT_FEC_CSR_WR (MOT_FEC_RX_ACT_OFF, MOT_FEC_RX_ACT);

#define MOT_FEC_TX_ACTIVATE                        \
    MOT_FEC_CSR_WR (MOT_FEC_TX_ACT_OFF, MOT_FEC_TX_ACT);

#define MOT_FEC_INT_DISABLE                        \
    MOT_FEC_CSR_WR (MOT_FEC_MASK_OFF, 0);

#define MOT_FEC_INT_ENABLE                        \
    MOT_FEC_CSR_WR (MOT_FEC_MASK_OFF, (pDrvCtrl->intMask));

#define MOT_FEC_VECTOR(pDrvCtrl)                    \
    ((pDrvCtrl)->ilevel)

/* more shortcuts */

#define MOT_FEC_GRA_SEM_CREATE                        \
    if ((pDrvCtrl->graSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY))     \
    == NULL)                            \
    goto errorExit

#define MOT_FEC_GRA_SEM_DELETE                        \
    if ((pDrvCtrl->graSem) != NULL)                     \
    semDelete (pDrvCtrl->graSem)

#define MOT_FEC_GRA_SEM_GIVE                        \
    (semGive (pDrvCtrl->graSem))

#define MOT_FEC_GRA_SEM_TAKE                        \
    (semTake (pDrvCtrl->graSem, WAIT_FOREVER))

#define MOT_FEC_MII_SEM_CREATE                        \
    if ((pDrvCtrl->miiSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY))     \
    == NULL)                            \
    goto errorExit

#define MOT_FEC_MII_SEM_DELETE                        \
    if ((pDrvCtrl->miiSem) != NULL)                     \
    semDelete (pDrvCtrl->miiSem)

#define MOT_FEC_MII_SEM_GIVE                        \
    (semGive (pDrvCtrl->miiSem))

#define MOT_FEC_MII_SEM_TAKE                        \
    (semTake (pDrvCtrl->miiSem, WAIT_FOREVER))

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

#define NET_TO_MOT_FEC_BUF(netBuf)                                  \
    (((UINT32) (netBuf) + MOT_FEC_BD_ALIGN - 1)             \
      & ~(MOT_FEC_BD_ALIGN - 1))

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

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

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

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

#define NET_CL_BLK_FREE(pClBlock)                                       \
    netClBlkFree (pDrvCtrl->endObj.pNetPool, (CL_BLK_ID) (pClBlock))

#define NET_MBLK_BUF_FREE(pMblock)                                      \
    netMblkClFree ((M_BLK_ID) (pMblock))

#define NET_MBLK_CL_JOIN(pMblock, pClBlock, ret)                        \
    ret = netMblkClJoin ((pMblock), (pClBlock))

#define NET_CL_BLK_JOIN(pClBlock, pBuffer, length, ret)                 \
    ret = netClBlkJoin ((pClBlock), (pBuffer), (length), NULL, 0, 0, 0)

/* globals */

/* locals */

/* Function declarations not in any header files */

/* forward function declarations */

LOCAL STATUS    motFecInitParse (DRV_CTRL *pDrvCtrl, char *initString);
LOCAL STATUS    motFecInitMem (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecSend (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);

LOCAL STATUS    motFecPhyInit (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecPhyPreInit (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecReset (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecBdFree (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecRbdInit (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecTbdInit (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecRxCtrlRegValGet (DRV_CTRL *pDrvCtrl, UINT32 * rxCtrlVal);
LOCAL STATUS    motFecTxCtrlRegValGet (DRV_CTRL *pDrvCtrl, UINT32 * txCtrlVal);
LOCAL STATUS    motFecHashRegValGet (DRV_CTRL *pDrvCtrl, UINT32  crcVal,
                 UINT32 * csrVal, UINT16 * offset);
LOCAL STATUS    motFecAddrRegValGet (DRV_CTRL *pDrvCtrl, UINT32  * csr0Val,
                 UINT32 * csr1Val);
LOCAL UINT32    motFecCrcGet (char * pAddr);
LOCAL STATUS    motFecHashTblPopulate (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFecHashTblAdd (DRV_CTRL * pDrvCtrl, char * pAddr);

LOCAL STATUS    motFecPrePhyConfig (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecPostPhyConfig (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFecMblkWalk (M_BLK * pMblk, UINT8 * pFragNum,
                UINT16 *    pPktType);
LOCAL STATUS    motFecPktTransmit (DRV_CTRL *pDrvCtrl, M_BLK * pMblk,
                   UINT8  fragNum, UINT16     pktType);
LOCAL STATUS    motFecPktCopyTransmit (DRV_CTRL *pDrvCtrl, M_BLK * pMblk,
                   UINT8  fragNum, UINT16     pktType);
LOCAL void      motFecTbdClean (DRV_CTRL *pDrvCtrl);
LOCAL UINT32    motFecTbdCheck (DRV_CTRL *pDrvCtrl, MOT_FEC_TBD_ID pUsedTbd);
LOCAL MOT_FEC_TBD_LIST_ID motFecTbdListSet (DRV_CTRL *pDrvCtrl, UINT8 tbdNum);
LOCAL MOT_FEC_TBD_ID    motFecTbdGet (DRV_CTRL *pDrvCtrl);
LOCAL void      motFecInt (DRV_CTRL *pDrvCtrl);
LOCAL void 			sdmaFecRecInt(DRV_CTRL *  pDrvCtrl);
LOCAL void 			sdmaFecTransInt(DRV_CTRL *  pDrvCtrl);
LOCAL void      motFecRxHandle (DRV_CTRL *pDrvCtrl);
LOCAL void      motFecTxHandle (DRV_CTRL *pDrvCtrl);