motfcc2end.c

vxWorks MPC82xx系列CPU FCC网口驱动

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

/* 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 *pDrvCtrl);

/* END Specific interfaces. */

END_OBJ *       motFccEndLoad (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_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);                    \
    }

#define MOT_FCC_STAT_INCR(i) (i++)

FUNCPTR _func_netJobAdd;
FUNCPTR _func_txRestart;
FUNCPTR _func_error;

UINT32 motFccEndDbg = 0;     /* global debug level flag */
    
DRV_CTRL * pDrvCtrlDbg;
#else /* MOT_FCC_DBG */
#define MOT_FCC_LOG(FLG, X0, X1, X2, X3, X4, X5, X6)
#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

/*
 * 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. */
    (FUNCPTR) motFccMCastAddrAdd,       /* multicast add func. */
    (FUNCPTR) motFccMCastAddrDel,       /* multicast delete func. */
    (FUNCPTR) motFccMCastAddrGet,       /* multicast get fun. */
    (FUNCPTR) motFccPollSend,       /* polling send func. */
    (FUNCPTR) motFccPollReceive,        /* polling receive func. */
    endEtherAddressForm,        /* put address info into a NET_BUFFER */
    (FUNCPTR) endEtherPacketDataGet,    /* get pointer to data in NET_BUFFER */
    (FUNCPTR) endEtherPacketAddrGet     /* Get packet addresses */
    };



/*******************************************************************************
*
* motFccEndLoad - 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:
*
* "<immrVal>:<ivec>:<bufBase>:<bufSize>:<fifoTxBase>:<fifoRxBase>
* :<tbdNum>:<rbdNum>:<phyAddr>:<phyDefMode>:<pAnOrderTbl>:<userFlags>"
*
* The FCC 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.
*