motfcc2end.c

vxworks MPC8541 BSP

#define MOT_FCC_POLLING     0x08    /* polling mode */
#define MOT_FCC_PROM        0x20    /* promiscuous mode */
#define MOT_FCC_MCAST       0x40    /* multicast addressing mode */
#define MOT_FCC_FD          0x80    /* full duplex mode */
#define MOT_FCC_OWN_BD_MEM  0x10    /* internally provided memory for BDs */

/* Flag Macros */

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

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

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

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

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

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

/* some BDs definitions */

/*
 * the total is 0x630 and it accounts for the required alignment
 * of receive data buffers, and the cluster overhead.
 */
#define XXX_FCC_MAX_CL_LEN      ((MII_ETH_MAX_PCK_SZ            \
                 + (MOT_FCC_BUF_ALIGN - 1)      \
                 + MOT_FCC_BUF_ALIGN            \
                 + (CL_OVERHEAD - 1))           \
                 & (~ (CL_OVERHEAD - 1)))

#define MOT_FCC_MAX_CL_LEN     ROUND_UP(XXX_FCC_MAX_CL_LEN,MOT_FCC_BUF_ALIGN)

#define MOT_FCC_RX_CL_SZ       (MOT_FCC_MAX_CL_LEN)
#define MOT_FCC_TX_CL_SZ       (MOT_FCC_MAX_CL_LEN)

/* read/write macros to access internal memory */

#define MOT_FCC_REG_LONG_WR(regAddr, regVal)                \
    MOT_FCC_LONG_WR ((UINT32 *) (regAddr), (regVal));

#define MOT_FCC_REG_LONG_RD(regAddr, regVal)                \
    MOT_FCC_LONG_RD ((UINT32 *) (regAddr), (regVal));

#define MOT_FCC_REG_WORD_WR(regAddr, regVal)                \
    MOT_FCC_WORD_WR ((UINT16 *) (regAddr), (regVal));

#define MOT_FCC_REG_WORD_RD(regAddr, regVal)                \
    MOT_FCC_WORD_RD ((UINT16 *) (regAddr), (regVal));

#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

#ifdef INCLUDE_RFC_1213_OLD
#undef INCLUDE_RFC_1213_OLD
#endif

#undef INCLUDE_RFC_1213_OLD
/* RFC 1213 mib2 interface */

#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 */


/* Inter-borads communication defines and specific interfaces */

#ifdef __BOOTROM__
#undef INTER_BOARDS_COMM
#else
#define INTER_BOARDS_COMM
#endif

#ifdef INTER_BOARDS_COMM

LOCAL DRV_CTRL * ibcDrvCtrl = NULL;
LOCAL DRV_CTRL * mbcDrvCtrl = NULL;

#define INTER_BRDCOMM_UNIT      0   /* FCC0 */
#define MB_BRDCOMM_UNIT	        1		/* FCC1 */
#define MAC_HEADER_SIZE         12
#define INTER_BRDCOMM_ID        0x6666

STATUS CommSendFrameToPhy(UINT8 *pucFrame, UINT16 wFrameLen);
STATUS MBCommSendFrameToPhy(UINT8 *pFrame,UINT16 frameLen);
IMPORT STATUS CommPhyFrameRecv(UINT8 *pCell, UINT16 wCellLen);

#endif /* INTER_BOARDS_COMM */


/* locals */

/* Function declarations not in any header files */

/* forward function declarations */

LOCAL STATUS    motFccInitParse (DRV_CTRL * pDrvCtrl, char *initString);
LOCAL STATUS    motFccInitMem (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFccSend (DRV_CTRL *pDrvCtrl, M_BLK *pMblk);
LOCAL STATUS    motFccPhyPreInit (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccRbdInit (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccTbdInit (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccFpsmrValSet (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccHashTblPopulate (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccHashTblAdd (DRV_CTRL * pDrvCtrl, UCHAR * pAddr);
LOCAL STATUS    motFccIramInit (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccPramInit (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccCpcrCommand (DRV_CTRL * pDrvCtrl, UINT8 command);
LOCAL int       motFccTbdClean (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccRbdReplenish (DRV_CTRL * pDrvCtrl);
LOCAL void      motFccInt (DRV_CTRL * pDrvCtrl);
LOCAL void      motFccHandleRXFrames(DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFccMiiRead (DRV_CTRL * pDrvCtrl, UINT8 phyAddr,
                   UINT8 regAddr, UINT16 *retVal);
LOCAL STATUS    motFccMiiWrite (DRV_CTRL * pDrvCtrl, UINT8 phyAddr,
                UINT8 regAddr, UINT16 writeData);
LOCAL STATUS    motFccAddrSet (DRV_CTRL * pDrvCtrl, UCHAR * pAddr,
                   UINT32 offset);
LOCAL void      motFccPhyLSCInt (DRV_CTRL *pDrvCtrl);
LOCAL STATUS    motFccPktTransmit (DRV_CTRL *, M_BLK *, int);
LOCAL STATUS    motFccPktCopyTransmit (DRV_CTRL *, M_BLK *, int);
LOCAL void      motFccHandleLSCJob (DRV_CTRL *);
LOCAL STATUS    motFccTbdFree (DRV_CTRL *);
LOCAL STATUS    motFccRbdFree (DRV_CTRL *);
LOCAL void      motFccRbdNext (DRV_CTRL *);
STATUS    mvl6095MacInit (DRV_CTRL * pDrvCtrl);

/* END Specific interfaces. */

END_OBJ *       motFcc2EndLoad (char *initString);
LOCAL STATUS    motFccStart (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccUnload (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccStop (DRV_CTRL * pDrvCtrl);
LOCAL int       motFccIoctl (DRV_CTRL * pDrvCtrl, int cmd, caddr_t data);
LOCAL STATUS    motFccMCastAddrAdd (DRV_CTRL * pDrvCtrl, UCHAR * pAddress);
LOCAL STATUS    motFccMCastAddrDel (DRV_CTRL * pDrvCtrl, UCHAR * pAddress);
LOCAL STATUS    motFccMCastAddrGet (DRV_CTRL * pDrvCtrl,
                                        MULTI_TABLE *pTable);
LOCAL STATUS    motFccPollSend (DRV_CTRL * pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    motFccPollReceive (DRV_CTRL * pDrvCtrl, M_BLK_ID pMblk);
LOCAL STATUS    motFccPollStart (DRV_CTRL * pDrvCtrl);
LOCAL STATUS    motFccPollStop (DRV_CTRL * pDrvCtrl);

/* globals */


#ifdef MOT_FCC_DBG
void motFccIramShow (DRV_CTRL *);
void motFccPramShow (DRV_CTRL *);
void motFccEramShow (DRV_CTRL *);

void motFccDrvShow (DRV_CTRL *);
void motFccMiiShow (DRV_CTRL *);
void motFccMibShow (DRV_CTRL *);

#define MOT_FCC_DBG_OFF     0x0000
#define MOT_FCC_DBG_RX      0x0001
#define MOT_FCC_DBG_TX      0x0002
#define MOT_FCC_DBG_POLL    0x0004
#define MOT_FCC_DBG_MII     0x0008
#define MOT_FCC_DBG_LOAD    0x0010
#define MOT_FCC_DBG_IOCTL   0x0020
#define MOT_FCC_DBG_INT     0x0040
#define MOT_FCC_DBG_START   0x0080
#define MOT_FCC_DBG_INT_RX_ERR  0x0100
#define MOT_FCC_DBG_INT_TX_ERR  0x0200
#define MOT_FCC_DBG_TRACE       0x0400
#define MOT_FCC_DBG_TRACE_RX    0x0800
#define MOT_FCC_DBG_TRACE_TX    0x1000
#define MOT_FCC_DBG_RX_ERR      0x2000
#define MOT_FCC_DBG_TX_ERR      0x4000
#define MOT_FCC_DBG_MONITOR     0x8000
#define MOT_FCC_DBG_TX_COM      0x10000  
#define MOT_FCC_DBG_ANY         0xffff

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


FUNCPTR _func_netJobAdd;
FUNCPTR _func_txRestart;
FUNCPTR _func_error;

/* global debug level flag */
UINT32 motFccEndDbg = MOT_FCC_DBG_MONITOR;

DRV_CTRL * pDrvCtrlDbg;
#else /* MOT_FCC_DBG */
#define MOT_FCC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
#endif

#ifdef MOT_FCC_STAT_MONITOR
#define MOT_FCC_STAT_INCR(i) (i++)
#else
#define MOT_FCC_STAT_INCR(i)
#endif


#ifdef MOT_FCC_DBG
LOCAL const char    *speedStr[2]  = {"10","100"};
LOCAL const char    *linkStr[2]   = {"Down","Up"};
LOCAL const char    *duplexStr[2] = {"Half","Full"};
#endif
LOCAL const char *pErrorStr   = "No Clusters";
LOCAL const char *pIfDescrStr = "Motorola FCC Ethernet Enhanced Network Driver 2.1";
/*
 * Define the device function table.  This is static across all driver
 * instances.
 */

LOCAL NET_FUNCS netFccFuncs =
    {
    (FUNCPTR) motFccStart,      /* start func. */
    (FUNCPTR) motFccStop,       /* stop func. */
    (FUNCPTR) motFccUnload,     /* unload func. */
    (FUNCPTR) motFccIoctl,      /* ioctl func. */
    (FUNCPTR) motFccSend,       /* send func. */