sky2le.h

这是Marvell Technology Group Ltd. 4355 (rev 12)网卡在linux下的驱动程序源代码

/******************************************************************************
 *
 * Name:	sky2le.h
 * Project:	Gigabit Ethernet Adapters, Common Modules
 * Version:	$Revision: 1.14 $
 * Date:	$Date: 2007/09/10 13:04:00 $
 * Purpose:	Common list element definitions and access macros.
 *
 ******************************************************************************/

/******************************************************************************
 *
 *	LICENSE:
 *	(C)Copyright Marvell.
 *	
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *	
 *	The information in this file is provided "AS IS" without warranty.
 *	/LICENSE
 *
 ******************************************************************************/

#ifndef __INC_SKY2LE_H
#define __INC_SKY2LE_H

#ifdef __cplusplus
extern "C" {
#endif	/* __cplusplus */

/* defines ********************************************************************/

#define MIN_LEN_OF_LE_TAB	128
#define MAX_LEN_OF_LE_TAB	4096
#ifdef USE_POLLING_UNIT
#define NUM_LE_POLLING_UNIT	2
#endif
#define MAX_FRAG_OVERHEAD	10

/* Macro for aligning a given value */
#define SK_ALIGN_SIZE(Value, Alignment, AlignedVal) {					\
	(AlignedVal) = (((Value) + (Alignment) - 1) & (~((Alignment) - 1)));\
}

/******************************************************************************
 *
 * LE2DWord() - Converts the given Little Endian value to machine order value
 *
 * Description:
 *	This function converts the Little Endian value received as an argument to
 *	the machine order value.
 *
 * Returns:
 *	The converted value
 *
 */

#ifdef SK_LITTLE_ENDIAN

#ifndef	SK_USE_REV_DESC
#define LE2DWord(value)	(value)
#else	/* SK_USE_REV_DESC */
#define LE2DWord(value)					\
	((((value)<<24L) & 0xff000000L) +	\
	 (((value)<< 8L) & 0x00ff0000L) +	\
	 (((value)>> 8L) & 0x0000ff00L) +	\
	 (((value)>>24L) & 0x000000ffL))
#endif	/* SK_USE_REV_DESC */

#else	/* !SK_LITTLE_ENDIAN */

#ifndef	SK_USE_REV_DESC
#define LE2DWord(value)					\
	((((value)<<24L) & 0xff000000L) +	\
	 (((value)<< 8L) & 0x00ff0000L) +	\
	 (((value)>> 8L) & 0x0000ff00L) +	\
	 (((value)>>24L) & 0x000000ffL))
#else	/* SK_USE_REV_DESC */
#define LE2DWord(value)	(value)
#endif	/* SK_USE_REV_DESC */

#endif	/* !SK_LITTLE_ENDIAN */

/******************************************************************************
 *
 * DWord2LE() - Converts the given value to a Little Endian value
 *
 * Description:
 *	This function converts the value received as an argument to a Little Endian
 *	value on Big Endian machines. If the machine running the code is Little
 *	Endian, then no conversion is done.
 *
 * Returns:
 *	The converted value
 *
 */

#ifdef SK_LITTLE_ENDIAN

#ifndef	SK_USE_REV_DESC
#define DWord2LE(value) (value)
#else	/* SK_USE_REV_DESC */
#define DWord2LE(value)					\
	((((value)<<24L) & 0xff000000L) +	\
	 (((value)<< 8L) & 0x00ff0000L) +	\
	 (((value)>> 8L) & 0x0000ff00L) +	\
	 (((value)>>24L) & 0x000000ffL))
#endif	/* SK_USE_REV_DESC */

#else	/* !SK_LITTLE_ENDIAN */

#ifndef	SK_USE_REV_DESC
#define DWord2LE(value)					\
	((((value)<<24L) & 0xff000000L) +	\
	 (((value)<< 8L) & 0x00ff0000L) +	\
	 (((value)>> 8L) & 0x0000ff00L) +	\
	 (((value)>>24L) & 0x000000ffL))
#else	/* SK_USE_REV_DESC */
#define DWord2LE(value) (value)
#endif	/* SK_USE_REV_DESC */
#endif	/* !SK_LITTLE_ENDIAN */

/******************************************************************************
 *
 * LE2Word() - Converts the given Little Endian value to machine order value
 *
 * Description:
 *	This function converts the Little Endian value received as an argument to
 *	the machine order value.
 *
 * Returns:
 *	The converted value
 *
 */

#ifdef SK_LITTLE_ENDIAN
#ifndef	SK_USE_REV_DESC
#define LE2Word(value) (value)
#else	/* SK_USE_REV_DESC */
#define LE2Word(value)				\
	((((value)<< 8L) & 0xff00) +	\
	 (((value)>> 8L) & 0x00ff))
#endif	/* SK_USE_REV_DESC */

#else	/* !SK_LITTLE_ENDIAN */
#ifndef	SK_USE_REV_DESC
#define LE2Word(value)				\
	((((value)<< 8L) & 0xff00) +	\
	 (((value)>> 8L) & 0x00ff))
#else	/* SK_USE_REV_DESC */
#define LE2Word(value) (value)
#endif	/* SK_USE_REV_DESC */
#endif	/* !SK_LITTLE_ENDIAN */

/******************************************************************************
 *
 * Word2LE() - Converts the given value to a Little Endian value
 *
 * Description:
 *	This function converts the value received as an argument to a Little Endian
 *	value on Big Endian machines. If the machine running the code is Little
 *	Endian, then no conversion is done.
 *
 * Returns:
 *	The converted value
 *
 */

#ifdef SK_LITTLE_ENDIAN
#ifndef	SK_USE_REV_DESC
#define Word2LE(value) (value)
#else	/* SK_USE_REV_DESC */
#define Word2LE(value)				\
	((((value)<< 8L) & 0xff00) +	\
	 (((value)>> 8L) & 0x00ff))
#endif	/* SK_USE_REV_DESC */

#else	/* !SK_LITTLE_ENDIAN */
#ifndef	SK_USE_REV_DESC
#define Word2LE(value)				\
	((((value)<< 8L) & 0xff00) +	\
	 (((value)>> 8L) & 0x00ff))
#else	/* SK_USE_REV_DESC */
#define Word2LE(value) (value)
#endif	/* SK_USE_REV_DESC */
#endif	/* !SK_LITTLE_ENDIAN */

/******************************************************************************
 *
 * Transmit list element macros
 *
 */

#define TXLE_SET_ADDR(pLE, Addr)	\
	((pLE)->Tx.TxUn.BufAddr = DWord2LE(Addr))
#define TXLE_SET_LSLEN(pLE, Len)	\
	((pLE)->Tx.TxUn.LargeSend.Length = Word2LE(Len))
#define TXLE_SET_STACS(pLE, Start)	\
	((pLE)->Tx.TxUn.ChkSum.TxTcpSp = Word2LE(Start))
#define TXLE_SET_WRICS(pLE, Write)	\
	((pLE)->Tx.TxUn.ChkSum.TxTcpWp = Word2LE(Write))
#define TXLE_SET_INICS(pLE, Ini)	((pLE)->Tx.Send.InitCsum = Word2LE(Ini))
#define TXLE_SET_LEN(pLE, Len)		((pLE)->Tx.Send.BufLen = Word2LE(Len))
#define TXLE_SET_VLAN(pLE, Vlan)	((pLE)->Tx.Send.VlanTag = Word2LE(Vlan))
#define TXLE_SET_LCKCS(pLE, Lock)	((pLE)->Tx.ControlFlags = (Lock))
#define TXLE_SET_CTRL(pLE, Ctrl)	((pLE)->Tx.ControlFlags = (Ctrl))
#define TXLE_SET_OPC(pLE, Opc)		((pLE)->Tx.Opcode = (Opc))

#define TXLE_GET_ADDR(pLE)		LE2DWord((pLE)->Tx.TxUn.BufAddr)
#define TXLE_GET_LSLEN(pLE)		LE2Word((pLE)->Tx.TxUn.LargeSend.Length)
#define TXLE_GET_STACS(pLE)		LE2Word((pLE)->Tx.TxUn.ChkSum.TxTcpSp)
#define TXLE_GET_WRICS(pLE)		LE2Word((pLE)->Tx.TxUn.ChkSum.TxTcpWp)
#define TXLE_GET_INICS(pLE)		LE2Word((pLE)->Tx.Send.InitCsum)
#define TXLE_GET_LEN(pLE) 		LE2Word((pLE)->Tx.Send.BufLen)
#define TXLE_GET_VLAN(pLE)		LE2Word((pLE)->Tx.Send.VlanTag)
#define TXLE_GET_LCKCS(pLE)		((pLE)->Tx.ControlFlags)
#define TXLE_GET_CTRL(pLE)		((pLE)->Tx.ControlFlags)
#define TXLE_GET_OPC(pLE)		((pLE)->Tx.Opcode)

	/* Yukon-Extreme only */
#define TXLE_SET_LSOV2(pLE, Len)	\
	((pLE)->Tx.TxUn.LsoV2Len = DWord2LE(Len))
#define TXLE_SET_MSSVAL(pLE, Val)	\
((pLE)->Tx.TxUn.Mss.TxMssVal = Word2LE(Val))

#define TXLE_GET_LSOV2(pLE)		LE2DWord((pLE)->Tx.TxUn.LsoV2Len)
#define TXLE_GET_MSSVAL(pLE)	LE2Word((pLE)->Tx.TxUn.Mss.TxMssVal)

/******************************************************************************
 *
 * Receive list element macros
 *
 */

#define RXLE_SET_ADDR(pLE, Addr)	\
	((pLE)->Rx.RxUn.BufAddr = (SK_U32)DWord2LE(Addr))
#define RXLE_SET_STACS2(pLE, Offs)	\
	((pLE)->Rx.RxUn.ChkSum.RxTcpSp2 = Word2LE(Offs))
#define RXLE_SET_STACS1(pLE, Offs)	\
	((pLE)->Rx.RxUn.ChkSum.RxTcpSp1 = Word2LE(Offs))
#define RXLE_SET_LEN(pLE, Len)		((pLE)->Rx.BufferLength = Word2LE(Len))
#define RXLE_SET_CTRL(pLE, Ctrl)	((pLE)->Rx.ControlFlags = (Ctrl))
#define RXLE_SET_OPC(pLE, Opc)		((pLE)->Rx.Opcode = (Opc))

#define RXLE_GET_ADDR(pLE)		LE2DWord((pLE)->Rx.RxUn.BufAddr)
#define RXLE_GET_STACS2(pLE)	LE2Word((pLE)->Rx.RxUn.ChkSum.RxTcpSp2)
#define RXLE_GET_STACS1(pLE)	LE2Word((pLE)->Rx.RxUn.ChkSum.RxTcpSp1)
#define RXLE_GET_LEN(pLE) 		LE2Word((pLE)->Rx.BufferLength)
#define RXLE_GET_CTRL(pLE)		((pLE)->Rx.ControlFlags)
#define RXLE_GET_OPC(pLE)		((pLE)->Rx.Opcode)

/******************************************************************************
 *
 * Status list element macros
 *
 */

#define STLE_SET_OPC(pLE, Opc)		((pLE)->St.Opcode = (Opc))

#define STLE_GET_FRSTATUS(pLE)	LE2DWord((pLE)->St.StUn.StRxStatWord)
#define STLE_GET_TIST(pLE)		LE2DWord((pLE)->St.StUn.StRxTimeStamp)
#define STLE_GET_TCP1(pLE)		LE2Word((pLE)->St.StUn.StRxTCPCSum.RxTCPSum1)
#define STLE_GET_TCP2(pLE)		LE2Word((pLE)->St.StUn.StRxTCPCSum.RxTCPSum2)
#define STLE_GET_LEN(pLE)		LE2Word((pLE)->St.Stat.BufLen)
#define STLE_GET_VLAN(pLE)		LE2Word((pLE)->St.Stat.VlanTag)

/*
 * SKLE_GET_LINK() returns the link field including TCP checksum information.
 * To select the port from the link field use (STLE_GET_LINK(pLe) & 1)
 */
#define STLE_GET_LINK(pLE)		((pLE)->St.Link)
#define STLE_GET_OPC(pLE)		((pLE)->St.Opcode)
#define STLE_GET_DONE_IDX(pLE,LowVal,HighVal) {			\
	(LowVal) = LE2DWord((pLE)->St.StUn.StTxStatLow);	\
	(HighVal) = LE2Word((pLE)->St.Stat.StTxStatHi);		\
}

#define STLE_GET_RSS(pLE)		LE2DWord((pLE)->St.StUn.StRxRssValue)
#define STLE_GET_IPV6BIT(pLE)	((pLE)->St.Stat.Rss.FlagField & RSS_IPV6_FLAG)
#define STLE_GET_IPBIT(pLE)		((pLE)->St.Stat.Rss.FlagField & RSS_IP_FLAG)
#define STLE_GET_TCPBIT(pLE)	((pLE)->St.Stat.Rss.FlagField & RSS_TCP_FLAG)

/* Yukon-Extreme only */
#define STLE_GET_MX_STAT(pLE)	((pLE)->St.StUn.StMacSecWord)

/* Yukon-Ext CSum Status defines (Rx Status, Link field) */
#define CSS_GET_PORT(Link)			(Link & CSS_LINK_BIT)
#define CSS_IS_IPV4(Link)			(Link & CSS_ISIPV4)
#define CSS_IPV4_CSUM_OK(Link)		(Link & CSS_IPV4CSUMOK)
#define CSS_IS_IPV6(Link)			(Link & CSS_ISIPV6)
#define CSS_IS_IPFRAG(Link)			(Link & CSS_ISIPFRAG)
#define CSS_IS_TCP(Link)			(Link & CSS_ISTCP)
#define CSS_IS_UDP(Link)			(Link & CSS_ISUDP)
#define CSS_TCPUDP_CSUM_OK(Link)	(Link & CSS_TCPUDPCSOK)

/* always take both values as a parameter to avoid typos */
#define STLE_GET_DONE_IDX_TXA1(LowVal,HighVal)			\
	(((LowVal) & STLE_TXA1_MSKL) >> STLE_TXA1_SHIFTL)
#define STLE_GET_DONE_IDX_TXS1(LowVal,HighVal)			\
	((LowVal & STLE_TXS1_MSKL) >> STLE_TXS1_SHIFTL)
#define STLE_GET_DONE_IDX_TXA2(LowVal,HighVal)			\
	(((LowVal & STLE_TXA2_MSKL) >> STLE_TXA2_SHIFTL) +	\
	((HighVal & STLE_TXA2_MSKH) << STLE_TXA2_SHIFTH))
#define STLE_GET_DONE_IDX_TXS2(LowVal,HighVal)			\
	((HighVal & STLE_TXS2_MSKH) >> STLE_TXS2_SHIFTH)


#define SK_Y2_RXSTAT_CHECK_PKT(Len, RxStat, IsOk) {			\
	(IsOk) = (((RxStat) & GMR_FS_RX_OK) != 0) &&			\
			 (((RxStat) & GMR_FS_ANY_ERR) == 0);			\
															\
	if ((IsOk) && ((SK_U16)(((RxStat) & GMR_FS_LEN_MSK) >>	\
		GMR_FS_LEN_SHIFT) != (Len))) {						\
		/* length in MAC status differs from length in LE */\
		(IsOk) = SK_FALSE;									\
	}														\
}


/******************************************************************************
 *
 * Polling unit list element macros
 *
 * NOTE: the Idx must be <= 0xfff and PU_PUTIDX_VALID makes them valid