motfccend.h

IXP425的BSP代码

    UINT32		numRXFHandlerErrQuits;
    UINT32		numRXFHandlerEmptyLoopBreaks;
    UINT32		numRXFHandlerFramesProcessed;
    UINT32		numRXFHandlerFramesRejected;
    UINT32		numRXFramesLostToBufferReuse;

    UINT32		numLSCHandlerEntries;
    UINT32		numLSCHandlerExits;

    UINT32		numStallsEntered;
    UINT32		numStallsCleared;

    UINT32		motFccTxErr;
    UINT32		motFccHbFailErr;
    UINT32		motFccTxLcErr;
    UINT32		motFccTxUrErr;
    UINT32		motFccTxCslErr;
    UINT32		motFccTxRlErr;

    UINT32		motFccRxBsyErr;
    UINT32		motFccRxLgErr;
    UINT32		motFccRxNoErr;
    UINT32		motFccRxCrcErr;
    UINT32		motFccRxOvErr;
    UINT32		motFccRxShErr;
    UINT32		motFccRxLcErr;
    UINT32		motFccRxMemErr;
}FCC_DRIVER_STATS;


/*---------------------------------------------------------------------*/
/*       F C C   E T H E R N E T   P A R A M E T E R S                 */
/*---------------------------------------------------------------------*/
typedef volatile unsigned long VULONG;
typedef volatile unsigned short VUSHORT;
typedef volatile unsigned char VUCHAR;

#pragma pack(1)

typedef struct {
    VULONG    stat_bus;       /* Internal use buffer. */
    VULONG    cam_ptr;        /* CAM address. */
    VULONG    c_mask;         /* CRC constant mask*/
    VULONG    c_pres;	      /* CRC preset */
    VULONG    crcec;          /* CRC error counter */
    VULONG    alec;           /* alignment error counter */
    VULONG    disfc;          /* discarded frame counter */
    VUSHORT   ret_lim;        /* Retry limit threshold. */
    VUSHORT   ret_cnt;        /* Retry limit counter. */
    VUSHORT   p_per;          /* persistence */
    VUSHORT   boff_cnt;       /* back-off counter */
    VULONG    gaddr_h;        /* group address filter, high */
    VULONG    gaddr_l;        /* group address filter, low */
    VUSHORT   tfcstat;        /* out of sequece Tx BD staus. */
    VUSHORT   tfclen;         /* out of sequece Tx BD length. */
    VULONG    tfcptr;         /* out of sequece Tx BD data pointer. */
    VUSHORT   maxflr;         /* maximum frame length reg */
    VUSHORT   paddr_h;        /* physical address (MSB) */
    VUSHORT   paddr_m;        /* physical address */
    VUSHORT   paddr_l;        /* physical address (LSB) */
    VUSHORT   ibd_cnt;        /* internal BD counter. */
    VUSHORT   ibd_start;      /* internal BD start pointer. */
    VUSHORT   ibd_end;        /* internal BD end pointer. */
    VUSHORT   tx_len;         /* tx frame length counter */
    VUCHAR    ibd_base[0x20]; /* internal micro code usage. */
    VULONG    iaddr_h;        /* individual address filter, high */
    VULONG    iaddr_l;        /* individual address filter, low */
    VUSHORT   minflr;         /* minimum frame length reg */
    VUSHORT   taddr_h;        /* temp address (MSB) */
    VUSHORT   taddr_m;        /* temp address */
    VUSHORT   taddr_l;        /* temp address (LSB) */
    VUSHORT   pad_ptr;        /* pad_ptr. */
    VUSHORT   cf_type;        /* flow control frame type coding. */
    VUSHORT   cf_range;       /* flow control frame range. */
    VUSHORT   max_b;          /* max buffer descriptor byte count. */
    VUSHORT   maxd1;          /* max DMA1 length register. */
    VUSHORT   maxd2;          /* max DMA2 length register. */
    VUSHORT   maxd;           /* Rx max DMA. */
    VUSHORT   dma_cnt;        /* Rx DMA counter. */

    /* counter: */
    VULONG    octc;           /* received octets counter. */
    VULONG    colc;           /* estimated number of collisions */
    VULONG    broc;           /* received good packets of broadcast address */
    VULONG    mulc;           /* received good packets of multicast address */
    VULONG    uspc;           /* received packets shorter then 64 octets. */
    VULONG    frgc;           /* as uspc + bad packets */
    VULONG    ospc;           /* received packets longer then 1518 octets. */
    VULONG    jbrc;           /* as ospc + bad packets  */
    VULONG    p64c;           /* received packets of 64 octets.. */
    VULONG    p65c;           /* received packets of 65-128 octets.. */
    VULONG    p128c;          /* received packets of 128-255 octets.. */
    VULONG    p256c;          /* received packets of 256-511 octets.. */
    VULONG    p512c;          /* received packets of 512-1023 octets.. */
    VULONG    p1024c;         /* received packets of 1024-1518 octets.. */
    VULONG    cam_buf;        /* cam respond internal buffer. */
    VUSHORT   rfthr;          /* received frames threshold */
    VUSHORT   rfcnt;          /* received frames count */
} FCC_ETH_PARAM_T;
#pragma pack()

/*---------------------------------------------------------------------*/
/*               F C C     P A R A M E T E R S                         */
/*---------------------------------------------------------------------*/
#pragma pack(1)
typedef struct {

    VUSHORT   riptr;      /* Rx internal temporary data pointer. */
    VUSHORT   tiptr;      /* Tx internal temporary data pointer. */
    VUSHORT   RESERVED0;  /* Reserved */
    VUSHORT   mrblr;      /* Rx buffer length */
    VULONG    rstate;     /* Rx internal state */
    VULONG    rbase;      /* RX BD base address */
    VUSHORT   rbdstat;    /* Rx BD status and control */
    VUSHORT   rbdlen;     /* Rx BD data length */
    VULONG    rdptr;      /* rx BD data pointer */
    VULONG    tstate;     /* Tx internal state */
    VULONG    tbase;      /* TX BD base address */
    VUSHORT   tbdstat;    /* Tx BD status and control */
    VUSHORT   tbdlen;     /* Tx BD data length */
    VULONG    tdptr;      /* Tx  data pointer */
    VULONG    rbptr;      /* rx BD pointer */
    VULONG    tbptr;      /* Tx BD pointer */
    VULONG    rcrc;       /* Temp receive CRC */
    VULONG    tcrc;       /* Temp transmit CRC */
  VULONG foo;

    /*-----------------------------------------------------------------*/
    /*                   Protocol Specific Parameters                  */
    /*-----------------------------------------------------------------*/
    union {

	/* Force this union to be 256 bytes - 0x34 bytes big.
		The 0x34 is the size of the protocol independent part
		of the structure.
	*/
	    UCHAR		pads[0xc4];
	    FCC_ETH_PARAM_T     e;

    } prot;      

} FCC_PARAM_T;
#pragma pack()


/*-----------------------------------------------------------------*/
/*                   FCC registers                                 */
/*-----------------------------------------------------------------*/
#pragma pack(1)
typedef struct {
    VULONG	fcc_gmr;		/* General Mode Register */
    VULONG	fcc_psmr;		/* Protocol Specific Mode Reg */
    VUSHORT	fcc_todr;		/* Transmit On Demand Reg */
    VUCHAR	reserved22[0x2];
    VUSHORT	fcc_dsr;		/* Data Sync Register */
    VUCHAR	reserved23[0x2];
    VUSHORT	fcc_fcce;		/* Event Register */
    VUSHORT	unused1;		
    VUSHORT	fcc_fccm;		/* Mask Register */
    VUSHORT	unused2;	
    VUCHAR	fcc_fccs;		/* Status Register */
    VUCHAR	reserved24[0x3];
    VULONG	fcc_tirr;		/* Transmit Partial Rate Reg */
} FCC_REG_T;

#pragma pack()

typedef struct {
    VUSHORT	word1;
    VUSHORT	bdLen;
    VULONG	bdAddr;
}FCC_BD;

typedef struct _pool {
    FCC_BD		desc;
    void		*pBuf;
    struct _pool	*next;
}BPOOL;

typedef struct fcc_tbd_list {
    void		*pBuf;
    VULONG		info;

#define PKT_TYPE_MULTI		0x10	/* packet with a multicast address */
#define PKT_TYPE_UNI		0x20	/* packet with a unicast address */
#define PKT_TYPE_NONE		0x40	/* address type is not meaningful */
#define BUF_TYPE_CL		0x01	/* this's a cluster pointer */
#define BUF_TYPE_MBLK		0x02	/* this's a mblk pointer */
} FCC_TBD_LIST;

typedef struct
    {
    FUNCPTR routine;    /* routine to be called */
    int param1;         /* arg to routine */
    int param2;
    int param3;
    int param4;
    int param5;
    } TODO_NODE;

typedef struct tx_job_node 
    {
    NODE  	node; 		/* linked list node */
    TODO_NODE   todo; 			/* to do node */
    } TX_JOB_NODE;

/* The definition of the driver control structure */
 
typedef struct drv_ctrl {
    END_OBJ             endObj;         /* base class */
    int                 unit;           /* unit number */

    FCC_DRIVER_STATS	*Stats;

    FCC_REG_T		*fccReg;
    FCC_ETH_PARAM_T     *fccEthPar;
    FCC_PARAM_T		*fccPar;

    BPOOL		*RxContainers, *RxEmpty, *RxFree, *RxHead, *RxTail;
    volatile int	RxBufCount;
    volatile int	rxHandling;
    volatile int	lscHandling;

    UINT8		fccNum;		/* FCC being used */
    UINT32              immrVal;  	/* internal RAM base address */
    UINT32              fifoTxBase;     /* address of Tx FIFO in internal RAM */
    UINT32              fifoRxBase;     /* address of Rx FIFO in internal RAM */
    char *              pBufBase;       /* FCC memory pool base */
    ULONG               bufSize;        /* FCC memory pool size */
    char *              pBdBase;        /* FCC BDs base */
    ULONG               bdSize;         /* FCC BDs size */

    UINT16              rbdNum;         /* number of RBDs */
    FCC_BD		*rbdBase;	/* RBD ring */
    volatile UINT16	rbdIndex;       /* RBD index */
    void		*rBufList[MOT_FCC_RBD_MAX];

    UINT32		mblkMult;
    UINT32		clMult;

    UINT16              tbdNum;         /* number of TBDs */
    FCC_BD		*tbdBase;	/* TBD ring */
    volatile UINT16	tbdIndex;       /* TBD index */
    volatile UINT16	usedTbdIndex;   /* used TBD index */
    volatile UINT16	cleanTbdNum;    /* number of clean TBDs */
    volatile BOOL	txStall;        /* tx handler stalled - no Tbd */
    UINT16		unStallThresh;	/* a threshold */

    FCC_TBD_LIST	pTbdList[MOT_FCC_TBD_MAX];	/* list of TBDs */

    ULONG               userFlags;      /* some user flags */
    BOOL		zeroBufFlag;
    INT8                flags;          /* driver state */
    BOOL                loaded;         /* interface has been loaded */
    BOOL                intrConnect;    /* interrupt has been connected */
    UINT32		intMask;	/* interrupt mask register */
    UINT32		fccIramAddr;	/* base addr of this fcc */
    UINT32		fccPramAddr;	/* parameter RAM addr of this fcc */
    UCHAR *		pTxPollBuf;	/* cluster pointer for poll mode */

    SEM_ID		graSem;		/* synch semaphore for graceful */
					/* transmit command */
    char *              pClBlkArea;     /* cluster block pointer */
    UINT32              clBlkSize;     	/* clusters block memory size */
    char *              pMBlkArea;     	/* mBlock area pointer */
    UINT32              mBlkSize;     	/* mBlocks area memory size */
    CACHE_FUNCS         bdCacheFuncs;   /* cache descriptor */
    CACHE_FUNCS         bufCacheFuncs;  /* cache descriptor */
    CL_POOL_ID          pClPoolId;      /* cluster pool identifier */
    PHY_INFO		*phyInfo;	/* info on a MII-compliant PHY */
    int                 offset;         /* Alignment offset */
    UINT                deviceId;       /* PCI device ID */
    END_ERR             lastError;      /* Last error passed to muxError */
    UINT                errorNoBufs;    /* cluster exhaustion */
    MSG_Q_ID		txJobMsgQId;  /* message queue for defering tx jobs */
    int         	txJobMsgQLen;   /* tx message queue length */
    BOOL		txJobQState;   /* handshake for tx message queue */
} DRV_CTRL;

/* 
 * this cache functions descriptors is used to flush/invalidate
 * the FCC's data buffers. They are set to the system's cache
 * flush and invalidate routine. This will allow proper operation
 * of the driver if data cache are turned on.
 */

IMPORT STATUS   cacheArchInvalidate (CACHE_TYPE, void *, size_t);
 
IMPORT STATUS   cacheArchFlush (CACHE_TYPE, void *, size_t);
 
LOCAL   CACHE_FUNCS     motFccBufCacheFuncs;
#if FALSE
LOCAL	FUNCPTR motFccBufInvRtn = cacheArchInvalidate;
LOCAL	FUNCPTR motFccBufFlushRtn = cacheArchFlush;
#endif /* FALSE */

FUNCPTR _func_motFccIntDisc = NULL;	/* assign a proper disc routine */

IMPORT STATUS   sysFccEnetAddrGet (int unit,UCHAR *address);
IMPORT STATUS	sysFccEnetEnable (UINT32 immrVal, UINT8 fccNum);
IMPORT STATUS	sysFccEnetDisable (UINT32 immrVal, UINT8 fccNum);
IMPORT STATUS	sysFccMiiBitWr (UINT32 immrVal, UINT8 fccNum,
				INT32 bit);
IMPORT STATUS	sysFccMiiBitRd (UINT32 immrVal, UINT8 fccNum,
				INT8 * bit);
IMPORT STATUS	miiPhyInit (PHY_INFO * phyInfo);
IMPORT FUNCPTR  _func_motFccPhyInit;
IMPORT FUNCPTR  _func_motFccHbFail;

#ifdef __cplusplus
}
#endif

#endif /* __INCsbcMotFccEndh */