razzor/uboot-1.1.4-kirkwood
1
0
Fork 0
Code
qnap_qts
uboot-1.1.4-kirkwood/drivers/sk98lin/h/sky2le.h

894 lines
31 KiB
C
Raw Permalink Normal View History

GPL_TS-20110526-3.4.x
2024-01-07 23:58:22 +01:00
/******************************************************************************
*
* Name: sky2le.h
* Project: Gigabit Ethernet Adapters, Common Modules
* Version: $Revision: 1.1.1.1 $
GPL_QTS_4.1.1_1003
2024-01-08 00:07:02 +01:00
* Date: $Date: 2008/12/15 11:39:21 $
GPL_TS-20110526-3.4.x
2024-01-07 23:58:22 +01:00
* Purpose: Common list element definitions and access macros.
*
******************************************************************************/
/******************************************************************************
*
* LICENSE:
* (C)Copyright 2003-2004 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)
/******************************************************************************
*
* 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)
#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_IPBIT(pLE) ((pLE)->St.Stat.Rss.FlagField & RSS_IP_FLAG)
#define STLE_GET_TCPBIT(pLE) ((pLE)->St.Stat.Rss.FlagField & RSS_TCP_FLAG)
/* I always take both values as a paramter 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
*
*/
#ifdef USE_POLLING_UNIT
#define POLE_SET_OPC(pLE, Opc) ((pLE)->Sa.Opcode = (Opc))
#define POLE_SET_LINK(pLE, Port) ((pLE)->Sa.Link = (Port))
#define POLE_SET_RXIDX(pLE, Idx) ((pLE)->Sa.RxIdxVld = Word2LE(Idx))
#define POLE_SET_TXAIDX(pLE, Idx) ((pLE)->Sa.TxAIdxVld = Word2LE(Idx))
#define POLE_SET_TXSIDX(pLE, Idx) ((pLE)->Sa.TxSIdxVld = Word2LE(Idx))
#define POLE_GET_OPC(pLE) ((pLE)->Sa.Opcode)
#define POLE_GET_LINK(pLE) ((pLE)->Sa.Link)
#define POLE_GET_RXIDX(pLE) LE2Word((pLE)->Sa.RxIdxVld)
#define POLE_GET_TXAIDX(pLE) LE2Word((pLE)->Sa.TxAIdxVld)
#define POLE_GET_TXSIDX(pLE) LE2Word((pLE)->Sa.TxSIdxVld)
#endif /* USE_POLLING_UNIT */
/******************************************************************************
*
* Debug macros for list elements
*
*/
#ifdef DEBUG
#define SK_DBG_DUMP_RX_LE(pLE) { \
SK_U8 Opcode; \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=== RX_LIST_ELEMENT @addr: %p cont: %02x %02x %02x %02x %02x %02x %02x %02x\n", \
pLE, ((SK_U8 *) pLE)[0], ((SK_U8 *) pLE)[1], ((SK_U8 *) pLE)[2],\
((SK_U8 *) pLE)[3], ((SK_U8 *) pLE)[4], ((SK_U8 *) pLE)[5], \
((SK_U8 *) pLE)[6], ((SK_U8 *) pLE)[7])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (16bit) %04x %04x %04x %04x\n", \
((SK_U16 *) pLE)[0], ((SK_U16 *) pLE)[1], ((SK_U16 *) pLE)[2], \
((SK_U16 *) pLE)[3])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (32bit) %08x %08x\n", \
((SK_U32 *) pLE)[0], ((SK_U32 *) pLE)[1])); \
Opcode = RXLE_GET_OPC(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOwn belongs to %s\n", ((Opcode & HW_OWNER) == HW_OWNER) ? \
"Hardware" : "Software")); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOpc: 0x%x ",Opcode)); \
switch (Opcode & (~HW_OWNER)) { \
case OP_BUFFER: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_BUFFER\n")); \
break; \
case OP_PACKET: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_PACKET\n")); \
break; \
case OP_ADDR64: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_ADDR64\n")); \
break; \
case OP_TCPSTART: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPPAR\n")); \
break; \
case SW_OWNER: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunused LE\n")); \
break; \
default: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunknown Opcode!!!\n")); \
break; \
} \
if ((Opcode & OP_BUFFER) == OP_BUFFER) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tControl: 0x%x\n", RXLE_GET_CTRL(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tBufLen: 0x%x\n", RXLE_GET_LEN(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tLowAddr: 0x%x\n", RXLE_GET_ADDR(pLE))); \
} \
if ((Opcode & OP_ADDR64) == OP_ADDR64) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tHighAddr: 0x%x\n", RXLE_GET_ADDR(pLE))); \
} \
if ((Opcode & OP_TCPSTART) == OP_TCPSTART) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Start 1 : 0x%x\n", RXLE_GET_STACS1(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Start 2 : 0x%x\n", RXLE_GET_STACS2(pLE))); \
} \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=====================\n")); \
}
#define SK_DBG_DUMP_TX_LE(pLE) { \
SK_U8 Opcode; \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=== TX_LIST_ELEMENT @addr: %p cont: %02x %02x %02x %02x %02x %02x %02x %02x\n", \
pLE, ((SK_U8 *) pLE)[0], ((SK_U8 *) pLE)[1], ((SK_U8 *) pLE)[2],\
((SK_U8 *) pLE)[3], ((SK_U8 *) pLE)[4], ((SK_U8 *) pLE)[5], \
((SK_U8 *) pLE)[6], ((SK_U8 *) pLE)[7])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (16bit) %04x %04x %04x %04x\n", \
((SK_U16 *) pLE)[0], ((SK_U16 *) pLE)[1], ((SK_U16 *) pLE)[2], \
((SK_U16 *) pLE)[3])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (32bit) %08x %08x\n", \
((SK_U32 *) pLE)[0], ((SK_U32 *) pLE)[1])); \
Opcode = TXLE_GET_OPC(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOwn belongs to %s\n", ((Opcode & HW_OWNER) == HW_OWNER) ? \
"Hardware" : "Software")); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOpc: 0x%x ",Opcode)); \
switch (Opcode & (~HW_OWNER)) { \
case OP_TCPCHKSUM: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPCHKSUM\n")); \
break; \
case OP_TCPIS: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPIS\n")); \
break; \
case OP_TCPLCK: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPLCK\n")); \
break; \
case OP_TCPLW: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPLW\n")); \
break; \
case OP_TCPLSW: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPLSW\n")); \
break; \
case OP_TCPLISW: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TCPLISW\n")); \
break; \
case OP_ADDR64: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_ADDR64\n")); \
break; \
case OP_VLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_VLAN\n")); \
break; \
case OP_ADDR64VLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_ADDR64VLAN\n")); \
break; \
case OP_LRGLEN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_LRGLEN\n")); \
break; \
case OP_LRGLENVLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_LRGLENVLAN\n")); \
break; \
case OP_BUFFER: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_BUFFER\n")); \
break; \
case OP_PACKET: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_PACKET\n")); \
break; \
case OP_LARGESEND: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_LARGESEND\n")); \
break; \
case SW_OWNER: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunused LE\n")); \
break; \
default: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunknown Opcode!!!\n")); \
break; \
} \
if ((Opcode & OP_BUFFER) == OP_BUFFER) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tControl: 0x%x\n", TXLE_GET_CTRL(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tBufLen: 0x%x\n", TXLE_GET_LEN(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tLowAddr: 0x%x\n", TXLE_GET_ADDR(pLE))); \
} \
if ((Opcode & OP_ADDR64) == OP_ADDR64) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tHighAddr: 0x%x\n", TXLE_GET_ADDR(pLE))); \
} \
if ((Opcode & OP_VLAN) == OP_VLAN) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tVLAN Id: 0x%x\n", TXLE_GET_VLAN(pLE))); \
} \
if ((Opcode & OP_LRGLEN) == OP_LRGLEN) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tLarge send length: 0x%x\n", TXLE_GET_LSLEN(pLE))); \
} \
if ((Opcode &(~HW_OWNER)) <= OP_ADDR64) { \
if ((Opcode & OP_TCPWRITE) == OP_TCPWRITE) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Write: 0x%x\n", TXLE_GET_WRICS(pLE))); \
} \
if ((Opcode & OP_TCPSTART) == OP_TCPSTART) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Start: 0x%x\n", TXLE_GET_STACS(pLE))); \
} \
if ((Opcode & OP_TCPINIT) == OP_TCPINIT) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Init: 0x%x\n", TXLE_GET_INICS(pLE))); \
} \
if ((Opcode & OP_TCPLCK) == OP_TCPLCK) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP Sum Lock: 0x%x\n", TXLE_GET_LCKCS(pLE))); \
} \
} \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=====================\n")); \
}
#define SK_DBG_DUMP_ST_LE(pLE) { \
SK_U8 Opcode; \
SK_U16 HighVal; \
SK_U32 LowVal; \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=== ST_LIST_ELEMENT @addr: %p contains: %02x %02x %02x %02x %02x %02x %02x %02x\n",\
pLE, ((SK_U8 *) pLE)[0], ((SK_U8 *) pLE)[1], ((SK_U8 *) pLE)[2],\
((SK_U8 *) pLE)[3], ((SK_U8 *) pLE)[4], ((SK_U8 *) pLE)[5], \
((SK_U8 *) pLE)[6], ((SK_U8 *) pLE)[7])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (16bit) %04x %04x %04x %04x\n", \
((SK_U16 *) pLE)[0], ((SK_U16 *) pLE)[1], ((SK_U16 *) pLE)[2], \
((SK_U16 *) pLE)[3])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (32bit) %08x %08x\n", \
((SK_U32 *) pLE)[0], ((SK_U32 *) pLE)[1])); \
Opcode = STLE_GET_OPC(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOwn belongs to %s\n", ((Opcode & HW_OWNER) == SW_OWNER) ? \
"Hardware" : "Software")); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOpc: 0x%x", Opcode)); \
Opcode &= (~HW_OWNER); \
switch (Opcode) { \
case OP_RXSTAT: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXSTAT\n")); \
break; \
case OP_RXTIMESTAMP: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXTIMESTAMP\n")); \
break; \
case OP_RXVLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXVLAN\n")); \
break; \
case OP_RXCHKS: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXCHKS\n")); \
break; \
case OP_RXCHKSVLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXCHKSVLAN\n")); \
break; \
case OP_RXTIMEVLAN: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RXTIMEVLAN\n")); \
break; \
case OP_RSS_HASH: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_RSS_HASH\n")); \
break; \
case OP_TXINDEXLE: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_TXINDEXLE\n")); \
break; \
case HW_OWNER: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunused LE\n")); \
break; \
default: \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunknown status list element!!!\n")); \
break; \
} \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tPort: %c\n", 'A' + STLE_GET_LINK(pLE))); \
if (Opcode == OP_RXSTAT) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tFrameLen: 0x%x\n", STLE_GET_LEN(pLE))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tFrameStat: 0x%x\n", STLE_GET_FRSTATUS(pLE))); \
} \
if ((Opcode & OP_RXVLAN) == OP_RXVLAN) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tVLAN Id: 0x%x\n", STLE_GET_VLAN(pLE))); \
} \
if ((Opcode & OP_RXTIMESTAMP) == OP_RXTIMESTAMP) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTimestamp: 0x%x\n", STLE_GET_TIST(pLE))); \
} \
if ((Opcode & OP_RXCHKS) == OP_RXCHKS) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTCP: 0x%x 0x%x\n", STLE_GET_TCP1(pLE), \
STLE_GET_TCP2(pLE))); \
} \
if (Opcode == OP_TXINDEXLE) { \
STLE_GET_DONE_IDX(pLE, LowVal, HighVal); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTx Index TxA1: 0x%x\n", \
STLE_GET_DONE_IDX_TXA1(LowVal,HighVal))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTx Index TxS1: 0x%x\n", \
STLE_GET_DONE_IDX_TXS1(LowVal,HighVal))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTx Index TxA2: 0x%x\n", \
STLE_GET_DONE_IDX_TXA2(LowVal,HighVal))); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTx Index TxS2: 0x%x\n", \
STLE_GET_DONE_IDX_TXS2(LowVal,HighVal))); \
} \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=====================\n")); \
}
#ifdef USE_POLLING_UNIT
#define SK_DBG_DUMP_PO_LE(pLE) { \
SK_U8 Opcode; \
SK_U16 Idx; \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=== PO_LIST_ELEMENT @addr: %p cont: %02x %02x %02x %02x %02x %02x %02x %02x\n", \
pLE, ((SK_U8 *) pLE)[0], ((SK_U8 *) pLE)[1], ((SK_U8 *) pLE)[2],\
((SK_U8 *) pLE)[3], ((SK_U8 *) pLE)[4], ((SK_U8 *) pLE)[5], \
((SK_U8 *) pLE)[6], ((SK_U8 *) pLE)[7])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (16bit) %04x %04x %04x %04x\n", \
((SK_U16 *) pLE)[0], ((SK_U16 *) pLE)[1], ((SK_U16 *) pLE)[2], \
((SK_U16 *) pLE)[3])); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\t (32bit) %08x %08x\n", \
((SK_U32 *) pLE)[0], ((SK_U32 *) pLE)[1])); \
Opcode = POLE_GET_OPC(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOwn belongs to %s\n", ((Opcode & HW_OWNER) == HW_OWNER) ? \
"Hardware" : "Software")); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOpc: 0x%x ",Opcode)); \
if ((Opcode & ~HW_OWNER) == OP_PUTIDX) { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tOP_PUTIDX\n")); \
} \
else { \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tunknown Opcode!!!\n")); \
} \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tPort %c\n", 'A' + POLE_GET_LINK(pLE))); \
Idx = POLE_GET_TXAIDX(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTxA Index is 0x%X and %svalid\n", Idx, \
(Idx & PU_PUTIDX_VALID) ? "" : "not ")); \
Idx = POLE_GET_TXSIDX(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tTxS Index is 0x%X and %svalid\n", Idx, \
(Idx & PU_PUTIDX_VALID) ? "" : "not ")); \
Idx = POLE_GET_RXIDX(pLE); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("\tRx Index is 0x%X and %svalid\n", Idx, \
(Idx & PU_PUTIDX_VALID) ? "" : "not ")); \
SK_DBG_MSG(pAc, SK_DBGMOD_HWM, SK_DBGCAT_INIT, \
("=====================\n")); \
}
#endif /* USE_POLLING_UNIT */
#else /* !DEBUG */
#define SK_DBG_DUMP_RX_LE(pLE)
#define SK_DBG_DUMP_TX_LE(pLE)
#define SK_DBG_DUMP_ST_LE(pLE)
#define SK_DBG_DUMP_PO_LE(pLE)
#endif /* !DEBUG */
/******************************************************************************
*
* Macros for listelement tables
*
*
*/
#define LE_SIZE sizeof(SK_HWLE)
#define LE_TAB_SIZE(NumElements) ((NumElements) * LE_SIZE)
/* Number of unused list elements in table
* this macro always returns the number of free listelements - 1
* this way we want to guarantee that always one LE remains unused
*/
#define NUM_FREE_LE_IN_TABLE(pTable) \
( ((pTable)->Put >= (pTable)->Done) ? \
(NUM_LE_IN_TABLE(pTable) - (pTable)->Put + (pTable)->Done - 1) :\
((pTable)->Done - (pTable)->Put - 1) )
/* total number of list elements in table */
#define NUM_LE_IN_TABLE(pTable) ((pTable)->Num)
/* get next unused Rx list element */
#define GET_RX_LE(pLE, pTable) { \
pLE = &(pTable)->pLETab[(pTable)->Put]; \
(pTable)->Put = ((pTable)->Put + 1) & (NUM_LE_IN_TABLE(pTable) - 1);\
}
/* get next unused Tx list element */
#define GET_TX_LE(pLE, pTable) GET_RX_LE(pLE, pTable)
/* get next status list element expected to be finished by hw */
#define GET_ST_LE(pLE, pTable) { \
pLE = &(pTable)->pLETab[(pTable)->Done]; \
(pTable)->Done = ((pTable)->Done +1) & (NUM_LE_IN_TABLE(pTable) - 1);\
}
#ifdef USE_POLLING_UNIT
/* get next polling unit list element for port */
#define GET_PO_LE(pLE, pTable, Port) { \
pLE = &(pTable)->pLETab[(Port)]; \
}
#endif /* USE_POLLING_UNIT */
#define GET_PUT_IDX(pTable) ((pTable)->Put)
#define UPDATE_HWPUT_IDX(pTable) {(pTable)->HwPut = (pTable)->Put; }
/*
* get own bit of next status LE
* if the result is != 0 there has been at least one status LE finished
*/
#define OWN_OF_FIRST_LE(pTable) \
(STLE_GET_OPC(&(pTable)->pLETab[(pTable)->Done]) & HW_OWNER)
#define SET_DONE_INDEX(pTable, Idx) (pTable)->Done = (Idx);
#define GET_DONE_INDEX(pTable) ((pTable)->Done)
#ifdef SAFE_BUT_SLOW
/* check own bit of LE before current done idx */
#define CHECK_STLE_OVERFLOW(pTable, IsOk) { \
unsigned i; \
if ((i = (pTable)->Done) == 0) { \
i = NUM_LE_IN_TABLE(pTable); \
} \
else { \
i = i - 1; \
} \
if (STLE_GET_OPC(&(pTable)->pLETab[i]) == HW_OWNER) { \
(IsOk) = SK_TRUE; \
} \
else { \
(IsOk) = SK_FALSE; \
} \
}
/*
* for Yukon-2 the hardware is not polling the list elements, so it
* is not necessary to change the own-bit of Rx or Tx LEs before
* reusing them
* but it might make debugging easier if one simply can see whether
* a LE has been worked on
*/
#define CLEAR_LE_OWN(pTable, Idx) \
STLE_SET_OPC(&(pTable)->pLETab[(Idx)], SW_OWNER)
/*
* clear all own bits starting from old done index up to the LE before
* the new done index
*/
#define CLEAR_LE_OWN_FROM_DONE_TO(pTable, To) { \
int i; \
i = (pTable)->Done; \
while (i != To) { \
CLEAR_LE_OWN(pTable, i); \
i = (i + 1) & (NUM_LE_IN_TABLE(pTable) - 1); \
} \
}
#else /* !SAFE_BUT_SLOW */
#define CHECK_STLE_OVERFLOW(pTable, IsOk)
#define CLEAR_LE_OWN(pTable, Idx)
#define CLEAR_LE_OWN_FROM_DONE_TO(pTable, To)
#endif /* !SAFE_BUT_SLOW */
/* typedefs *******************************************************************/
typedef struct s_LetRxTx {
SK_U16 VlanId; /* VLAN Id given down last time */
SK_U16 TcpWp; /* TCP Checksum Write Position */
SK_U16 TcpSp1; /* TCP Checksum Calculation Start Position 1 */
SK_U16 TcpSp2; /* TCP Checksum Calculation Start Position 2 */
SK_U16 MssValue; /* Maximum Segment Size */
SK_U16 Reserved1; /* reserved word for furture extensions */
SK_U16 Reserved2; /* reserved word for furture extensions */
SK_U16 Reserved3; /* reserved word for furture extensions */
} SK_LET_RX_TX;
typedef struct s_LetStat {
SK_U32 RxTimeStamp; /* Receive Timestamp */
SK_U32 RssHashValue; /* RSS Hash Value */
SK_BOOL RssIsIp; /* RSS Hash Value: IP packet detected */
SK_BOOL RssIsTcp; /* RSS Hash Value: IP+TCP packet detected */
SK_U16 VlanId; /* VLAN Id given received by Status BMU */
SK_U16 TcpSum1; /* TCP checksum 1 (status BMU) */
SK_U16 TcpSum2; /* TCP checksum 2 (status BMU) */
} SK_LET_STAT;
typedef union s_LetBmuSpec {
SK_LET_RX_TX RxTx; /* Rx/Tx BMU specific variables */
SK_LET_STAT Stat; /* Status BMU specific variables */
} SK_LET_BMU_S;
typedef struct s_le_table {
/* all LE's between Done and HWPut are owned by the hardware */
/* all LE's between Put and Done can be used from Software */
/* all LE's between HWPut and Put are currently processed in DriverSend */
unsigned Done; /* done index - consumed from HW and available */
unsigned Put; /* put index - to be given to hardware */
unsigned HwPut; /* put index actually given to hardware */
unsigned Num; /* total number of list elements */
SK_HWLE *pLETab; /* virtual address of list element table */
SK_U32 pPhyLETABLow; /* physical address of list element table */
SK_U32 pPhyLETABHigh; /* physical address of list element table */
/* values to remember in order to save some LEs */
SK_U32 BufHighAddr; /* high addr given down last time */
SK_LET_BMU_S Bmu; /* contains BMU specific information */
SK_U32 private; /* driver private variable free usable */
SK_U16 TcpInitCsum; /* Init. Checksum */
} SK_LE_TABLE;
/* function prototypes ********************************************************/
#ifndef SK_KR_PROTO
/*
* public functions in sky2le.c
*/
extern void SkGeY2SetPutIndex(
SK_AC *pAC,
SK_IOC IoC,
SK_U32 StartAddrPrefetchUnit,
SK_LE_TABLE *pLETab);
extern void SkGeY2InitPrefetchUnit(
SK_AC *pAC,
SK_IOC IoC,
unsigned int Queue,
SK_LE_TABLE *pLETab);
extern void SkGeY2InitStatBmu(
SK_AC *pAC,
SK_IOC IoC,
SK_LE_TABLE *pLETab);
extern void SkGeY2InitPollUnit(
SK_AC *pAC,
SK_IOC IoC,
SK_LE_TABLE *pLETab);
extern void SkGeY2InitSingleLETable(
SK_AC *pAC,
SK_LE_TABLE *pLETab,
unsigned int NumLE,
void *pVMem,
SK_U32 PMemLowAddr,
SK_U32 PMemHighAddr);
#else /* SK_KR_PROTO */
extern void SkGeY2SetPutIndex();
extern void SkGeY2InitPrefetchUnit();
extern void SkGeY2InitStatBmu();
extern void SkGeY2InitPollUnit();
extern void SkGeY2InitSingleLETable();
#endif /* SK_KR_PROTO */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __INC_SKY2LE_H */
Copy Permalink