From: Bartosz Szczepanek bsz@semihalf.com

This patch introduces an OS-independent library with the configuration routines of new PP2 NIC, whose support will be added in following commits. The library is obtained from Marvell and adjusted to EDK2 coding style.

Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Bartosz Szczepanek bsz@semihalf.com Signed-off-by: Marcin Wojtas mw@semihalf.com --- Drivers/Net/Pp2Dxe/Mvpp2Lib.c | 4237 +++++++++++++++++++++++++++++++++++++++ Drivers/Net/Pp2Dxe/Mvpp2Lib.h | 305 +++ Drivers/Net/Pp2Dxe/Mvpp2LibHw.h | 2043 +++++++++++++++++++ 3 files changed, 6585 insertions(+) create mode 100644 Drivers/Net/Pp2Dxe/Mvpp2Lib.c create mode 100644 Drivers/Net/Pp2Dxe/Mvpp2Lib.h create mode 100644 Drivers/Net/Pp2Dxe/Mvpp2LibHw.h

diff --git a/Drivers/Net/Pp2Dxe/Mvpp2Lib.c b/Drivers/Net/Pp2Dxe/Mvpp2Lib.c new file mode 100644 index 0000000..e06046c --- /dev/null +++ b/Drivers/Net/Pp2Dxe/Mvpp2Lib.c @@ -0,0 +1,4237 @@ +/******************************************************************************** +Copyright (C) 2016 Marvell International Ltd. + +Marvell BSD License Option + +If you received this File from Marvell, you may opt to use, redistribute and/or +modify this File under the following licensing terms. +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of Marvell nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*******************************************************************************/ + +#include "Mvpp2LibHw.h" +#include "Pp2Dxe.h" +#include "Mvpp2Lib.h" + +/* Parser configuration routines */ + +/* Update parser tcam and sram hw entries */ +STATIC INT32 Mvpp2PrsHwWrite(MVPP2_SHARED *priv, MVPP2_PRS_ENTRY *pe) +{ + INT32 i; + + if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1) + return MVPP2_EINVAL; + + /* Clear entry invalidation bit */ + pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] &= ~MVPP2_PRS_TCAM_INV_MASK; + + /* Write tcam index - indirect access */ + Mvpp2Write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index); + for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) + Mvpp2Write(priv, MVPP2_PRS_TCAM_DATA_REG(i), pe->tcam.word[i]); + + /* Write sram index - indirect access */ + Mvpp2Write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index); + for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) + Mvpp2Write(priv, MVPP2_PRS_SRAM_DATA_REG(i), pe->sram.word[i]); + + return 0; +} + +/* Read tcam entry from hw */ +STATIC INT32 Mvpp2PrsHwRead(MVPP2_SHARED *priv, MVPP2_PRS_ENTRY *pe) +{ + INT32 i; + + if (pe->index > MVPP2_PRS_TCAM_SRAM_SIZE - 1) + return MVPP2_EINVAL; + + /* Write tcam index - indirect access */ + Mvpp2Write(priv, MVPP2_PRS_TCAM_IDX_REG, pe->index); + + pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] = Mvpp2Read(priv, + MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD)); + if (pe->tcam.word[MVPP2_PRS_TCAM_INV_WORD] & MVPP2_PRS_TCAM_INV_MASK) + return MVPP2_PRS_TCAM_ENTRY_INVALID; + + for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) + pe->tcam.word[i] = Mvpp2Read(priv, MVPP2_PRS_TCAM_DATA_REG(i)); + + /* Write sram index - indirect access */ + Mvpp2Write(priv, MVPP2_PRS_SRAM_IDX_REG, pe->index); + for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) + pe->sram.word[i] = Mvpp2Read(priv, MVPP2_PRS_SRAM_DATA_REG(i)); + + return 0; +} + +/* Invalidate tcam hw entry */ +STATIC VOID Mvpp2PrsHwInv(MVPP2_SHARED *priv, INT32 index) +{ + /* Write index - indirect access */ + Mvpp2Write(priv, MVPP2_PRS_TCAM_IDX_REG, index); + Mvpp2Write(priv, MVPP2_PRS_TCAM_DATA_REG(MVPP2_PRS_TCAM_INV_WORD), + MVPP2_PRS_TCAM_INV_MASK); +} + +/* Enable shadow table entry and set its lookup ID */ +STATIC VOID Mvpp2PrsShadowSet(MVPP2_SHARED *priv, INT32 index, INT32 lu) +{ + priv->PrsShadow[index].valid = TRUE; + priv->PrsShadow[index].lu = lu; +} + +/* Update ri fields in shadow table entry */ +STATIC VOID Mvpp2PrsShadowRiSet(MVPP2_SHARED *priv, INT32 index, + UINT32 ri, UINT32 RiMask) +{ + priv->PrsShadow[index].RiMask = RiMask; + priv->PrsShadow[index].ri = ri; +} + +/* Update lookup field in tcam sw entry */ +STATIC VOID Mvpp2PrsTcamLuSet(MVPP2_PRS_ENTRY *pe, UINT32 lu) +{ + INT32 EnableOff = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_LU_BYTE); + + pe->tcam.byte[MVPP2_PRS_TCAM_LU_BYTE] = lu; + pe->tcam.byte[EnableOff] = MVPP2_PRS_LU_MASK; +} + +/* Update mask for single port in tcam sw entry */ +STATIC VOID Mvpp2PrsTcamPortSet(MVPP2_PRS_ENTRY *pe, + UINT32 port, BOOLEAN add) +{ + INT32 EnableOff = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE); + + if (add) + pe->tcam.byte[EnableOff] &= ~(1 << port); + else + pe->tcam.byte[EnableOff] |= 1 << port; +} + +/* Update port map in tcam sw entry */ +STATIC VOID Mvpp2PrsTcamPortMapSet(MVPP2_PRS_ENTRY *pe, + UINT32 ports) +{ + UINT8 PortMask = MVPP2_PRS_PORT_MASK; + INT32 EnableOff = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE); + + pe->tcam.byte[MVPP2_PRS_TCAM_PORT_BYTE] = 0; + pe->tcam.byte[EnableOff] &= ~PortMask; + pe->tcam.byte[EnableOff] |= ~ports & MVPP2_PRS_PORT_MASK; +} + +/* Obtain port map from tcam sw entry */ +STATIC UINT32 Mvpp2PrsTcamPortMapGet(MVPP2_PRS_ENTRY *pe) +{ + INT32 EnableOff = MVPP2_PRS_TCAM_EN_OFFS(MVPP2_PRS_TCAM_PORT_BYTE); + + return ~(pe->tcam.byte[EnableOff]) & MVPP2_PRS_PORT_MASK; +} + +/* Set byte of data and its enable bits in tcam sw entry */ +STATIC VOID Mvpp2PrsTcamDataByteSet(MVPP2_PRS_ENTRY *pe, + UINT32 offs, UINT8 byte, + UINT8 enable) +{ + pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)] = byte; + pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)] = enable; +} + +/* Get byte of data and its enable bits from tcam sw entry */ +STATIC VOID Mvpp2PrsTcamDataByteGet(MVPP2_PRS_ENTRY *pe, + UINT32 offs, UINT8 *byte, + UINT8 *enable) +{ + *byte = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(offs)]; + *enable = pe->tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(offs)]; +} + +/* Compare tcam data bytes with a pattern */ +STATIC BOOLEAN Mvpp2PrsTcamDataCmp(MVPP2_PRS_ENTRY *pe, INT32 offs, + UINT16 data) +{ + INT32 off = MVPP2_PRS_TCAM_DATA_BYTE(offs); + UINT16 TcamData; + + TcamData = (8 << pe->tcam.byte[off + 1]) | pe->tcam.byte[off]; + if (TcamData != data) + return FALSE; + return TRUE; +} + +/* Update ai bits in tcam sw entry */ +STATIC VOID Mvpp2PrsTcamAiUpdate(MVPP2_PRS_ENTRY *pe, + UINT32 bits, UINT32 enable) +{ + INT32 i, AiIdx = MVPP2_PRS_TCAM_AI_BYTE; + + for (i = 0; i < MVPP2_PRS_AI_BITS; i++) { + + if (!(enable & BIT(i))) + continue; + + if (bits & BIT(i)) + pe->tcam.byte[AiIdx] |= 1 << i; + else + pe->tcam.byte[AiIdx] &= ~(1 << i); + } + + pe->tcam.byte[MVPP2_PRS_TCAM_EN_OFFS(AiIdx)] |= enable; +} + +/* Get ai bits from tcam sw entry */ +STATIC INT32 Mvpp2PrsTcamAiGet(MVPP2_PRS_ENTRY *pe) +{ + return pe->tcam.byte[MVPP2_PRS_TCAM_AI_BYTE]; +} + +/* Get dword of data and its enable bits from tcam sw entry */ +STATIC VOID Mvpp2PrsTcamDataDwordGet(MVPP2_PRS_ENTRY *pe, + UINT32 offs, UINT32 *word, + UINT32 *enable) +{ + INT32 index, offset; + UINT8 byte, mask; + + for (index = 0; index < 4; index++) { + offset = (offs * 4) + index; + Mvpp2PrsTcamDataByteGet(pe, offset, &byte, &mask); + ((UINT8 *)word)[index] = byte; + ((UINT8 *)enable)[index] = mask; + } +} + +/* Set ethertype in tcam sw entry */ +STATIC VOID Mvpp2PrsMatchEtype(MVPP2_PRS_ENTRY *pe, INT32 offset, + UINT16 ethertype) +{ + Mvpp2PrsTcamDataByteSet(pe, offset + 0, ethertype >> 8, 0xff); + Mvpp2PrsTcamDataByteSet(pe, offset + 1, ethertype & 0xff, 0xff); +} + +/* Set bits in sram sw entry */ +STATIC VOID Mvpp2PrsSramBitsSet(MVPP2_PRS_ENTRY *pe, + INT32 BitNum, INT32 val) +{ + pe->sram.byte[MVPP2_BIT_TO_BYTE(BitNum)] |= (val << (BitNum % 8)); +} + +/* Clear bits in sram sw entry */ +STATIC VOID Mvpp2PrsSramBitsClear(MVPP2_PRS_ENTRY *pe, + INT32 BitNum, INT32 val) +{ + pe->sram.byte[MVPP2_BIT_TO_BYTE(BitNum)] &= ~(val << (BitNum % 8)); +} + +/* Update ri bits in sram sw entry */ +STATIC VOID Mvpp2PrsSramRiUpdate(MVPP2_PRS_ENTRY *pe, + UINT32 bits, UINT32 mask) +{ + UINT32 i; + + for (i = 0; i < MVPP2_PRS_SRAM_RI_CTRL_BITS; i++) { + INT32 RiOff = MVPP2_PRS_SRAM_RI_OFFS; + + if (!(mask & BIT(i))) + continue; + + if (bits & BIT(i)) + Mvpp2PrsSramBitsSet(pe, RiOff + i, 1); + else + Mvpp2PrsSramBitsClear(pe, RiOff + i, 1); + + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_RI_CTRL_OFFS + i, 1); + } +} + +/* Obtain ri bits from sram sw entry */ +STATIC INT32 Mvpp2PrsSramRiGet(MVPP2_PRS_ENTRY *pe) +{ + return pe->sram.word[MVPP2_PRS_SRAM_RI_WORD]; +} + +/* Update ai bits in sram sw entry */ +STATIC VOID Mvpp2PrsSramAiUpdate(MVPP2_PRS_ENTRY *pe, + UINT32 bits, UINT32 mask) +{ + UINT32 i; + INT32 AiOff = MVPP2_PRS_SRAM_AI_OFFS; + + for (i = 0; i < MVPP2_PRS_SRAM_AI_CTRL_BITS; i++) { + + if (!(mask & BIT(i))) + continue; + + if (bits & BIT(i)) + Mvpp2PrsSramBitsSet(pe, AiOff + i, 1); + else + Mvpp2PrsSramBitsClear(pe, AiOff + i, 1); + + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_AI_CTRL_OFFS + i, 1); + } +} + +/* Read ai bits from sram sw entry */ +STATIC INT32 Mvpp2PrsSramAiGet(MVPP2_PRS_ENTRY *pe) +{ + UINT8 bits; + INT32 AiOff = MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_AI_OFFS); + INT32 AiEnOff = AiOff + 1; + INT32 AiShift = MVPP2_PRS_SRAM_AI_OFFS % 8; + + bits = (pe->sram.byte[AiOff] >> AiShift) | + (pe->sram.byte[AiEnOff] << (8 - AiShift)); + + return bits; +} + +/* In sram sw entry set lookup ID field of the tcam key to be used in the next + * lookup INT32eration + */ +STATIC VOID Mvpp2PrsSramNextLuSet(MVPP2_PRS_ENTRY *pe, + UINT32 lu) +{ + INT32 SramNextOff = MVPP2_PRS_SRAM_NEXT_LU_OFFS; + + Mvpp2PrsSramBitsClear(pe, SramNextOff, + MVPP2_PRS_SRAM_NEXT_LU_MASK); + Mvpp2PrsSramBitsSet(pe, SramNextOff, lu); +} + +/* In the sram sw entry set sign and value of the next lookup offset + * and the offset value generated to the classifier + */ +STATIC VOID Mvpp2PrsSramShiftSet(MVPP2_PRS_ENTRY *pe, INT32 shift, + UINT32 op) +{ + /* Set sign */ + if (shift < 0) { + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1); + shift = 0 - shift; + } else { + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_SHIFT_SIGN_BIT, 1); + } + + /* Set value */ + pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_SHIFT_OFFS)] = + (UINT8)shift; + + /* Reset and set operation */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK); + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS, op); + + /* Set base offset as current */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1); +} + +/* In the sram sw entry set sign and value of the user defined offset + * generated to the classifier + */ +STATIC VOID Mvpp2PrsSramOffsetSet(MVPP2_PRS_ENTRY *pe, + UINT32 type, INT32 offset, + UINT32 op) +{ + /* Set sign */ + if (offset < 0) { + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1); + offset = 0 - offset; + } else { + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_UDF_SIGN_BIT, 1); + } + + /* Set value */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_UDF_OFFS, + MVPP2_PRS_SRAM_UDF_MASK); + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_UDF_OFFS, offset); + pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS + + MVPP2_PRS_SRAM_UDF_BITS)] &= + ~(MVPP2_PRS_SRAM_UDF_MASK >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8))); + pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_UDF_OFFS + + MVPP2_PRS_SRAM_UDF_BITS)] |= + (offset >> (8 - (MVPP2_PRS_SRAM_UDF_OFFS % 8))); + + /* Set offset type */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, + MVPP2_PRS_SRAM_UDF_TYPE_MASK); + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_UDF_TYPE_OFFS, type); + + /* Set offset operation */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, + MVPP2_PRS_SRAM_OP_SEL_UDF_MASK); + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS, op); + + pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS + + MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] &= + ~(MVPP2_PRS_SRAM_OP_SEL_UDF_MASK >> + (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8))); + + pe->sram.byte[MVPP2_BIT_TO_BYTE(MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS + + MVPP2_PRS_SRAM_OP_SEL_UDF_BITS)] |= + (op >> (8 - (MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS % 8))); + + /* Set base offset as current */ + Mvpp2PrsSramBitsClear(pe, MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS, 1); +} + +/* Find parser flow entry */ +STATIC MVPP2_PRS_ENTRY *Mvpp2PrsFlowFind(MVPP2_SHARED *priv, + INT32 flow) +{ + MVPP2_PRS_ENTRY *pe; + INT32 tid; + UINT32 dword, enable; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_NULL; + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_FLOWS); + + /* Go through the all entires with MVPP2_PRS_LU_FLOWS */ + for (tid = MVPP2_PRS_TCAM_SRAM_SIZE - 1; tid >= 0; tid--) { + UINT8 bits; + + if (!priv->PrsShadow[tid].valid || + priv->PrsShadow[tid].lu != MVPP2_PRS_LU_FLOWS) + continue; + + pe->index = tid; + Mvpp2PrsHwRead(priv, pe); + + /* Check result info, because there maybe + * several TCAM lines to generate the same flow */ + Mvpp2PrsTcamDataDwordGet(pe, 0, &dword, &enable); + if ((dword != 0) || (enable != 0)) + continue; + + bits = Mvpp2PrsSramAiGet(pe); + + /* Sram store classification lookup ID in AI bits [5:0] */ + if ((bits & MVPP2_PRS_FLOW_ID_MASK) == flow) + return pe; + } + Mvpp2Free(pe); + + return MVPP2_NULL; +} + +/* Return first free tcam index, seeking from start to end */ +STATIC INT32 Mvpp2PrsTcamFirstFree(MVPP2_SHARED *priv, UINT8 start, + UINT8 end) +{ + INT32 tid; + + if (start > end) + Mvpp2Swap(start, end); + + if (end >= MVPP2_PRS_TCAM_SRAM_SIZE) + end = MVPP2_PRS_TCAM_SRAM_SIZE - 1; + + for (tid = start; tid <= end; tid++) { + if (!priv->PrsShadow[tid].valid) + return tid; + } + + return MVPP2_EINVAL; +} + +/* Enable/disable dropping all mac da's */ +STATIC VOID Mvpp2PrsMacDropAllSet(MVPP2_SHARED *priv, INT32 port, + BOOLEAN add) +{ + MVPP2_PRS_ENTRY pe; + + if (priv->PrsShadow[MVPP2_PE_DROP_ALL].valid) { + /* Entry exist - update port only */ + pe.index = MVPP2_PE_DROP_ALL; + Mvpp2PrsHwRead(priv, &pe); + } else { + /* Entry doesn't exist - create new */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_MAC); + pe.index = MVPP2_PE_DROP_ALL; + + /* Non-promiscuous mode for all ports - DROP unknown packets */ + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_DROP_MASK, + MVPP2_PRS_RI_DROP_MASK); + + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + + /* Update shadow table */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MAC); + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, 0); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(&pe, port, add); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Set port to promiscuous mode */ +VOID Mvpp2PrsMacPromiscSet(MVPP2_SHARED *priv, INT32 port, BOOLEAN add) +{ + MVPP2_PRS_ENTRY pe; + + /* Promiscuous mode - Accept unknown packets */ + + if (priv->PrsShadow[MVPP2_PE_MAC_PROMISCUOUS].valid) { + /* Entry exist - update port only */ + pe.index = MVPP2_PE_MAC_PROMISCUOUS; + Mvpp2PrsHwRead(priv, &pe); + } else { + /* Entry doesn't exist - create new */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_MAC); + pe.index = MVPP2_PE_MAC_PROMISCUOUS; + + /* Continue - set next lookup */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_DSA); + + /* Set result info bits */ + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L2_UCAST, + MVPP2_PRS_RI_L2_CAST_MASK); + + /* Shift to ethertype */ + Mvpp2PrsSramShiftSet(&pe, 2 * MV_ETH_ALEN, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, 0); + + /* Update shadow table */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MAC); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(&pe, port, add); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Accept multicast */ +VOID Mvpp2PrsMacMultiSet(MVPP2_SHARED *priv, INT32 port, INT32 index, + BOOLEAN add) +{ + MVPP2_PRS_ENTRY pe; + UINT8 DaMc; + + /* Ethernet multicast address first byte is + * 0x01 for IPv4 and 0x33 for IPv6 + */ + DaMc = (index == MVPP2_PE_MAC_MC_ALL) ? 0x01 : 0x33; + + if (priv->PrsShadow[index].valid) { + /* Entry exist - update port only */ + pe.index = index; + Mvpp2PrsHwRead(priv, &pe); + } else { + /* Entry doesn't exist - create new */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_MAC); + pe.index = index; + + /* Continue - set next lookup */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_DSA); + + /* Set result info bits */ + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L2_MCAST, + MVPP2_PRS_RI_L2_CAST_MASK); + + /* Update tcam entry data first byte */ + Mvpp2PrsTcamDataByteSet(&pe, 0, DaMc, 0xff); + + /* Shift to ethertype */ + Mvpp2PrsSramShiftSet(&pe, 2 * MV_ETH_ALEN, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, 0); + + /* Update shadow table */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MAC); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(&pe, port, add); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Set entry for dsa packets */ +STATIC VOID Mvpp2PrsDsaTagSet(MVPP2_SHARED *priv, INT32 port, + BOOLEAN add, BOOLEAN tagged, + BOOLEAN extend) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid, shift; + + if (extend) { + tid = tagged ? MVPP2_PE_EDSA_TAGGED : MVPP2_PE_EDSA_UNTAGGED; + shift = 8; + } else { + tid = tagged ? MVPP2_PE_DSA_TAGGED : MVPP2_PE_DSA_UNTAGGED; + shift = 4; + } + + if (priv->PrsShadow[tid].valid) { + /* Entry exist - update port only */ + pe.index = tid; + Mvpp2PrsHwRead(priv, &pe); + } else { + /* Entry doesn't exist - create new */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_DSA); + pe.index = tid; + + /* Shift 4 bytes if DSA tag or 8 bytes in case of EDSA tag*/ + Mvpp2PrsSramShiftSet(&pe, shift, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + /* Update shadow table */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_DSA); + + if (tagged) { + /* Set tagged bit in DSA tag */ + Mvpp2PrsTcamDataByteSet(&pe, 0, + MVPP2_PRS_TCAM_DSA_TAGGED_BIT, + MVPP2_PRS_TCAM_DSA_TAGGED_BIT); + /* Clear all ai bits for next iteration */ + Mvpp2PrsSramAiUpdate(&pe, 0, + MVPP2_PRS_SRAM_AI_MASK); + /* If packet is tagged continue check vlans */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_VLAN); + } else { + /* Set result info bits to 'no vlans' */ + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_VLAN_NONE, + MVPP2_PRS_RI_VLAN_MASK); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_L2); + } + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, 0); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(&pe, port, add); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Set entry for dsa ethertype */ +STATIC VOID Mvpp2PrsDsaTagEthertypeSet(MVPP2_SHARED *priv, INT32 port, + BOOLEAN add, BOOLEAN tagged, + BOOLEAN extend) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid, shift, PortMask; + + if (extend) { + tid = tagged ? MVPP2_PE_ETYPE_EDSA_TAGGED : + MVPP2_PE_ETYPE_EDSA_UNTAGGED; + PortMask = 0; + shift = 8; + } else { + tid = tagged ? MVPP2_PE_ETYPE_DSA_TAGGED : + MVPP2_PE_ETYPE_DSA_UNTAGGED; + PortMask = MVPP2_PRS_PORT_MASK; + shift = 4; + } + + if (priv->PrsShadow[tid].valid) { + /* Entry exist - update port only */ + pe.index = tid; + Mvpp2PrsHwRead(priv, &pe); + } else { + /* Entry doesn't exist - create new */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_DSA); + pe.index = tid; + + /* Set ethertype */ + Mvpp2PrsMatchEtype(&pe, 0, MV_ETH_P_EDSA); + Mvpp2PrsMatchEtype(&pe, 2, 0); + + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_DSA_MASK, + MVPP2_PRS_RI_DSA_MASK); + /* Shift ethertype + 2 byte reserved + tag*/ + Mvpp2PrsSramShiftSet(&pe, 2 + MVPP2_ETH_TYPE_LEN + shift, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + /* Update shadow table */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_DSA); + + if (tagged) { + /* Set tagged bit in DSA tag */ + Mvpp2PrsTcamDataByteSet(&pe, + MVPP2_ETH_TYPE_LEN + 2 + 3, + MVPP2_PRS_TCAM_DSA_TAGGED_BIT, + MVPP2_PRS_TCAM_DSA_TAGGED_BIT); + /* Clear all ai bits for next iteration */ + Mvpp2PrsSramAiUpdate(&pe, 0, + MVPP2_PRS_SRAM_AI_MASK); + /* If packet is tagged continue check vlans */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_VLAN); + } else { + /* Set result info bits to 'no vlans' */ + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_VLAN_NONE, + MVPP2_PRS_RI_VLAN_MASK); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_L2); + } + /* Mask/unmask all ports, depending on dsa type */ + Mvpp2PrsTcamPortMapSet(&pe, PortMask); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(&pe, port, add); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Search for existing single/triple vlan entry */ +STATIC MVPP2_PRS_ENTRY *Mvpp2PrsVlanFind(MVPP2_SHARED *priv, + UINT16 tpid, INT32 ai) +{ + MVPP2_PRS_ENTRY *pe; + INT32 tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_NULL; + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_VLAN); + + /* Go through the all entries with MVPP2_PRS_LU_VLAN */ + for (tid = MVPP2_PE_FIRST_FREE_TID; + tid <= MVPP2_PE_LAST_FREE_TID; tid++) { + UINT32 RiBits, AiBits; + BOOLEAN match; + + if (!priv->PrsShadow[tid].valid || + priv->PrsShadow[tid].lu != MVPP2_PRS_LU_VLAN) + continue; + + pe->index = tid; + + Mvpp2PrsHwRead(priv, pe); + match = Mvpp2PrsTcamDataCmp(pe, 0, Mvpp2Swab16(tpid)); + if (!match) + continue; + + /* Get vlan type */ + RiBits = Mvpp2PrsSramRiGet(pe); + RiBits &= MVPP2_PRS_RI_VLAN_MASK; + + /* Get current ai value from tcam */ + AiBits = Mvpp2PrsTcamAiGet(pe); + /* Clear double vlan bit */ + AiBits &= ~MVPP2_PRS_DBL_VLAN_AI_BIT; + + if (ai != AiBits) + continue; + + if (RiBits == MVPP2_PRS_RI_VLAN_SINGLE || + RiBits == MVPP2_PRS_RI_VLAN_TRIPLE) + return pe; + } + Mvpp2Free(pe); + + return MVPP2_NULL; +} + +/* Add/update single/triple vlan entry */ +INT32 Mvpp2PrsVlanAdd(MVPP2_SHARED *priv, UINT16 tpid, INT32 ai, + UINT32 PortMap) +{ + MVPP2_PRS_ENTRY *pe; + INT32 TidAux, tid; + INT32 ret = 0; + + pe = Mvpp2PrsVlanFind(priv, tpid, ai); + + if (!pe) { + /* Create new tcam entry */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_LAST_FREE_TID, + MVPP2_PE_FIRST_FREE_TID); + if (tid < 0) + return tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_ENOMEM; + + /* Get last double vlan tid */ + for (TidAux = MVPP2_PE_LAST_FREE_TID; + TidAux >= MVPP2_PE_FIRST_FREE_TID; TidAux--) { + UINT32 RiBits; + + if (!priv->PrsShadow[TidAux].valid || + priv->PrsShadow[TidAux].lu != MVPP2_PRS_LU_VLAN) + continue; + + pe->index = TidAux; + Mvpp2PrsHwRead(priv, pe); + RiBits = Mvpp2PrsSramRiGet(pe); + if ((RiBits & MVPP2_PRS_RI_VLAN_MASK) == + MVPP2_PRS_RI_VLAN_DOUBLE) + break; + } + + if (tid <= TidAux) { + ret = MVPP2_EINVAL; + goto error; + } + + Mvpp2Memset(pe, 0 , sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_VLAN); + pe->index = tid; + + Mvpp2PrsMatchEtype(pe, 0, tpid); + + Mvpp2PrsSramNextLuSet(pe, MVPP2_PRS_LU_L2); + /* Shift 4 bytes - skip 1 vlan tag */ + Mvpp2PrsSramShiftSet(pe, MVPP2_VLAN_TAG_LEN, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Clear all ai bits for next iteration */ + Mvpp2PrsSramAiUpdate(pe, 0, MVPP2_PRS_SRAM_AI_MASK); + + if (ai == MVPP2_PRS_SINGLE_VLAN_AI) { + Mvpp2PrsSramRiUpdate(pe, MVPP2_PRS_RI_VLAN_SINGLE, + MVPP2_PRS_RI_VLAN_MASK); + } else { + ai |= MVPP2_PRS_DBL_VLAN_AI_BIT; + Mvpp2PrsSramRiUpdate(pe, MVPP2_PRS_RI_VLAN_TRIPLE, + MVPP2_PRS_RI_VLAN_MASK); + } + Mvpp2PrsTcamAiUpdate(pe, ai, MVPP2_PRS_SRAM_AI_MASK); + + Mvpp2PrsShadowSet(priv, pe->index, MVPP2_PRS_LU_VLAN); + } + /* Update ports' mask */ + Mvpp2PrsTcamPortMapSet(pe, PortMap); + + Mvpp2PrsHwWrite(priv, pe); + +error: + Mvpp2Free(pe); + + return ret; +} + +/* Get first free double vlan ai number */ +INT32 Mvpp2PrsDoubleVlanAiFreeGet(MVPP2_SHARED *priv) +{ + INT32 i; + + for (i = 1; i < MVPP2_PRS_DBL_VLANS_MAX; i++) { + if (!priv->PrsDoubleVlans[i]) + return i; + } + + return MVPP2_EINVAL; +} + +/* Search for existing double vlan entry */ +MVPP2_PRS_ENTRY *Mvpp2PrsDoubleVlanFind(MVPP2_SHARED *priv, + UINT16 tpid1, + UINT16 tpid2) +{ + MVPP2_PRS_ENTRY *pe; + INT32 tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_NULL; + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_VLAN); + + /* Go through the all entries with MVPP2_PRS_LU_VLAN */ + for (tid = MVPP2_PE_FIRST_FREE_TID; + tid <= MVPP2_PE_LAST_FREE_TID; tid++) { + UINT32 RiMask; + BOOLEAN match; + + if (!priv->PrsShadow[tid].valid || + priv->PrsShadow[tid].lu != MVPP2_PRS_LU_VLAN) + continue; + + pe->index = tid; + Mvpp2PrsHwRead(priv, pe); + + match = Mvpp2PrsTcamDataCmp(pe, 0, Mvpp2Swab16(tpid1)) + && Mvpp2PrsTcamDataCmp(pe, 4, Mvpp2Swab16(tpid2)); + + if (!match) + continue; + + RiMask = Mvpp2PrsSramRiGet(pe) & MVPP2_PRS_RI_VLAN_MASK; + if (RiMask == MVPP2_PRS_RI_VLAN_DOUBLE) + return pe; + } + Mvpp2Free(pe); + + return MVPP2_NULL; +} + +/* Add or update double vlan entry */ +INT32 Mvpp2PrsDoubleVlanAdd(MVPP2_SHARED *priv, UINT16 tpid1, + UINT16 tpid2, + UINT32 PortMap) +{ + MVPP2_PRS_ENTRY *pe; + INT32 TidAux, tid, ai, ret = 0; + + pe = Mvpp2PrsDoubleVlanFind(priv, tpid1, tpid2); + + if (!pe) { + /* Create new tcam entry */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_ENOMEM; + + /* Set ai value for new double vlan entry */ + ai = Mvpp2PrsDoubleVlanAiFreeGet(priv); + if (ai < 0) { + ret = ai; + goto error; + } + + /* Get first single/triple vlan tid */ + for (TidAux = MVPP2_PE_FIRST_FREE_TID; + TidAux <= MVPP2_PE_LAST_FREE_TID; TidAux++) { + UINT32 RiBits; + + if (!priv->PrsShadow[TidAux].valid || + priv->PrsShadow[TidAux].lu != MVPP2_PRS_LU_VLAN) + continue; + + pe->index = TidAux; + Mvpp2PrsHwRead(priv, pe); + RiBits = Mvpp2PrsSramRiGet(pe); + RiBits &= MVPP2_PRS_RI_VLAN_MASK; + if (RiBits == MVPP2_PRS_RI_VLAN_SINGLE || + RiBits == MVPP2_PRS_RI_VLAN_TRIPLE) + break; + } + + if (tid >= TidAux) { + ret = MVPP2_ERANGE; + goto error; + } + + Mvpp2Memset(pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_VLAN); + pe->index = tid; + + priv->PrsDoubleVlans[ai] = TRUE; + + Mvpp2PrsMatchEtype(pe, 0, tpid1); + Mvpp2PrsMatchEtype(pe, 4, tpid2); + + Mvpp2PrsSramNextLuSet(pe, MVPP2_PRS_LU_VLAN); + /* Shift 8 bytes - skip 2 vlan tags */ + Mvpp2PrsSramShiftSet(pe, 2 * MVPP2_VLAN_TAG_LEN, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + Mvpp2PrsSramRiUpdate(pe, MVPP2_PRS_RI_VLAN_DOUBLE, + MVPP2_PRS_RI_VLAN_MASK); + Mvpp2PrsSramAiUpdate(pe, ai | MVPP2_PRS_DBL_VLAN_AI_BIT, + MVPP2_PRS_SRAM_AI_MASK); + + Mvpp2PrsShadowSet(priv, pe->index, MVPP2_PRS_LU_VLAN); + } + + /* Update ports' mask */ + Mvpp2PrsTcamPortMapSet(pe, PortMap); + Mvpp2PrsHwWrite(priv, pe); + +error: + Mvpp2Free(pe); + return ret; +} + +/* IPv4 header parsing for fragmentation and L4 offset */ +STATIC INT32 Mvpp2PrsIp4Proto(MVPP2_SHARED *priv, UINT16 proto, + UINT32 ri, UINT32 RiMask) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid; + + if ((proto != MV_IPPR_TCP) && (proto != MV_IPPR_UDP) && + (proto != MV_IPPR_IGMP)) + return MVPP2_EINVAL; + + /* Fragmented packet */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP4); + pe.index = tid; + + /* Set next lu to IPv4 */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP4); + Mvpp2PrsSramShiftSet(&pe, 12, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Set L4 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, + sizeof(Mvpp2Iphdr) - 4, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + Mvpp2PrsSramAiUpdate(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, + MVPP2_PRS_IPV4_DIP_AI_BIT); + Mvpp2PrsSramRiUpdate(&pe, ri | MVPP2_PRS_RI_IP_FRAG_MASK, + RiMask | MVPP2_PRS_RI_IP_FRAG_MASK); + + Mvpp2PrsTcamDataByteSet(&pe, 5, proto, MVPP2_PRS_TCAM_PROTO_MASK); + Mvpp2PrsTcamAiUpdate(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + /* Not fragmented packet */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + pe.index = tid; + /* Clear ri before updating */ + pe.sram.word[MVPP2_PRS_SRAM_RI_WORD] = 0x0; + pe.sram.word[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0; + Mvpp2PrsSramRiUpdate(&pe, ri, RiMask); + + Mvpp2PrsTcamDataByteSet(&pe, 2, 0x00, MVPP2_PRS_TCAM_PROTO_MASK_L); + Mvpp2PrsTcamDataByteSet(&pe, 3, 0x00, MVPP2_PRS_TCAM_PROTO_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* IPv4 L3 multicast or broadcast */ +STATIC INT32 Mvpp2PrsIp4Cast(MVPP2_SHARED *priv, UINT16 L3Cast) +{ + MVPP2_PRS_ENTRY pe; + INT32 mask, tid; + + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP4); + pe.index = tid; + + switch (L3Cast) { + case MVPP2_PRS_L3_MULTI_CAST: + Mvpp2PrsTcamDataByteSet(&pe, 0, MVPP2_PRS_IPV4_MC, + MVPP2_PRS_IPV4_MC_MASK); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_MCAST, + MVPP2_PRS_RI_L3_ADDR_MASK); + break; + case MVPP2_PRS_L3_BROAD_CAST: + mask = MVPP2_PRS_IPV4_BC_MASK; + Mvpp2PrsTcamDataByteSet(&pe, 0, mask, mask); + Mvpp2PrsTcamDataByteSet(&pe, 1, mask, mask); + Mvpp2PrsTcamDataByteSet(&pe, 2, mask, mask); + Mvpp2PrsTcamDataByteSet(&pe, 3, mask, mask); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_BCAST, + MVPP2_PRS_RI_L3_ADDR_MASK); + break; + default: + return MVPP2_EINVAL; + } + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, + MVPP2_PRS_IPV4_DIP_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Set entries for protocols over IPv6 */ +STATIC INT32 Mvpp2PrsIp6Proto(MVPP2_SHARED *priv, UINT16 proto, + UINT32 ri, UINT32 RiMask) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid; + + if ((proto != MV_IPPR_TCP) && (proto != MV_IPPR_UDP) && + (proto != MV_IPPR_ICMPV6) && (proto != MV_IPPR_IPIP)) + return MVPP2_EINVAL; + + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = tid; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, ri, RiMask); + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, + sizeof(Mvpp2Ipv6hdr) - 6, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + Mvpp2PrsTcamDataByteSet(&pe, 0, proto, MVPP2_PRS_TCAM_PROTO_MASK); + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, + MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Write HW */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP6); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* IPv6 L3 multicast entry */ +STATIC INT32 Mvpp2PrsIp6Cast(MVPP2_SHARED *priv, UINT16 L3Cast) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid; + + if (L3Cast != MVPP2_PRS_L3_MULTI_CAST) + return MVPP2_EINVAL; + + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = tid; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP6); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_MCAST, + MVPP2_PRS_RI_L3_ADDR_MASK); + Mvpp2PrsSramAiUpdate(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, + MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Shift back to IPv6 NH */ + Mvpp2PrsSramShiftSet(&pe, -18, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + Mvpp2PrsTcamDataByteSet(&pe, 0, MVPP2_PRS_IPV6_MC, + MVPP2_PRS_IPV6_MC_MASK); + Mvpp2PrsTcamAiUpdate(&pe, 0, MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP6); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Parser per-port initialization */ +STATIC VOID Mvpp2PrsHwPortInit(MVPP2_SHARED *priv, INT32 port, + INT32 LuFirst, INT32 LuMax, + INT32 offset) +{ + UINT32 val; + + /* Set lookup ID */ + val = Mvpp2Read(priv, MVPP2_PRS_INIT_LOOKUP_REG); + val &= ~MVPP2_PRS_PORT_LU_MASK(port); + val |= MVPP2_PRS_PORT_LU_VAL(port, LuFirst); + Mvpp2Write(priv, MVPP2_PRS_INIT_LOOKUP_REG, val); + + /* Set maximum number of loops for packet received from port */ + val = Mvpp2Read(priv, MVPP2_PRS_MAX_LOOP_REG(port)); + val &= ~MVPP2_PRS_MAX_LOOP_MASK(port); + val |= MVPP2_PRS_MAX_LOOP_VAL(port, LuMax); + Mvpp2Write(priv, MVPP2_PRS_MAX_LOOP_REG(port), val); + + /* Set initial offset for packet header extraction for the first + * searching loop + */ + val = Mvpp2Read(priv, MVPP2_PRS_INIT_OFFS_REG(port)); + val &= ~MVPP2_PRS_INIT_OFF_MASK(port); + val |= MVPP2_PRS_INIT_OFF_VAL(port, offset); + Mvpp2Write(priv, MVPP2_PRS_INIT_OFFS_REG(port), val); +} + +/* Default flow entries initialization for all ports */ +STATIC VOID Mvpp2PrsDefFlowInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 port; + + for (port = 0; port < MVPP2_MAX_PORTS; port++) { + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_FLOWS); + pe.index = MVPP2_PE_FIRST_DEFAULT_FLOW - port; + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, 0); + + /* Set flow ID*/ + Mvpp2PrsSramAiUpdate(&pe, port, MVPP2_PRS_FLOW_ID_MASK); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsHwWrite(priv, &pe); + } +} + +/* Set default entry for Marvell Header field */ +STATIC VOID Mvpp2PrsMhInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + + pe.index = MVPP2_PE_MH_DEFAULT; + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_MH); + Mvpp2PrsSramShiftSet(&pe, MVPP2_MH_SIZE, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_MAC); + + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MH); + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Set default entires (place holder) for promiscuous, non-promiscuous and + * multicast MAC addresses + */ +STATIC VOID Mvpp2PrsMacInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + + /* Non-promiscuous mode for all ports - DROP unknown packets */ + pe.index = MVPP2_PE_MAC_NON_PROMISCUOUS; + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_MAC); + + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_DROP_MASK, + MVPP2_PRS_RI_DROP_MASK); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MAC); + Mvpp2PrsHwWrite(priv, &pe); + + /* place holders only - no ports */ + Mvpp2PrsMacDropAllSet(priv, 0, FALSE); + Mvpp2PrsMacPromiscSet(priv, 0, FALSE); + Mvpp2PrsMacMultiSet(priv, MVPP2_PE_MAC_MC_ALL, 0, FALSE); + Mvpp2PrsMacMultiSet(priv, MVPP2_PE_MAC_MC_IP6, 0, FALSE); +} + +/* Set default entries for various types of dsa packets */ +STATIC VOID Mvpp2PrsDsaInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + + /* None tagged EDSA entry - place holder */ + Mvpp2PrsDsaTagSet(priv, 0, FALSE, MVPP2_PRS_UNTAGGED, + MVPP2_PRS_EDSA); + + /* Tagged EDSA entry - place holder */ + Mvpp2PrsDsaTagSet(priv, 0, FALSE, MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); + + /* None tagged DSA entry - place holder */ + Mvpp2PrsDsaTagSet(priv, 0, FALSE, MVPP2_PRS_UNTAGGED, + MVPP2_PRS_DSA); + + /* Tagged DSA entry - place holder */ + Mvpp2PrsDsaTagSet(priv, 0, FALSE, MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); + + /* None tagged EDSA ethertype entry - place holder*/ + Mvpp2PrsDsaTagEthertypeSet(priv, 0, FALSE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); + + /* Tagged EDSA ethertype entry - place holder*/ + Mvpp2PrsDsaTagEthertypeSet(priv, 0, FALSE, + MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); + + /* None tagged DSA ethertype entry */ + Mvpp2PrsDsaTagEthertypeSet(priv, 0, TRUE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); + + /* Tagged DSA ethertype entry */ + Mvpp2PrsDsaTagEthertypeSet(priv, 0, TRUE, + MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); + + /* Set default entry, in case DSA or EDSA tag not found */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_DSA); + pe.index = MVPP2_PE_DSA_DEFAULT; + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_VLAN); + + /* Shift 0 bytes */ + Mvpp2PrsSramShiftSet(&pe, 0, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_MAC); + + /* Clear all sram ai bits for next iteration */ + Mvpp2PrsSramAiUpdate(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); + + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + Mvpp2PrsHwWrite(priv, &pe); +} + +/* Match basic ethertypes */ +STATIC INT32 Mvpp2PrsEtypeInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid; + + /* Ethertype: PPPoE */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_ETH_P_PPP_SES); + + Mvpp2PrsSramShiftSet(&pe, MVPP2_PPPOE_HDR_SIZE, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_PPPOE); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_PPPOE_MASK, + MVPP2_PRS_RI_PPPOE_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = FALSE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_PPPOE_MASK, + MVPP2_PRS_RI_PPPOE_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Ethertype: ARP */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_ETH_P_ARP); + + /* Generate flow in the next iteration*/ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_ARP, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = TRUE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_L3_ARP, + MVPP2_PRS_RI_L3_PROTO_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Ethertype: LBTD */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MVPP2_IP_LBDT_TYPE); + + /* Generate flow in the next iteration*/ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_CPU_CODE_RX_SPEC | + MVPP2_PRS_RI_UDF3_RX_SPECIAL, + MVPP2_PRS_RI_CPU_CODE_MASK | + MVPP2_PRS_RI_UDF3_MASK); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = TRUE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_CPU_CODE_RX_SPEC | + MVPP2_PRS_RI_UDF3_RX_SPECIAL, + MVPP2_PRS_RI_CPU_CODE_MASK | + MVPP2_PRS_RI_UDF3_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Ethertype: IPv4 without options */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_ETH_P_IP); + Mvpp2PrsTcamDataByteSet(&pe, MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_IPV4_HEAD | MVPP2_PRS_IPV4_IHL, + MVPP2_PRS_IPV4_HEAD_MASK | + MVPP2_PRS_IPV4_IHL_MASK); + + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP4); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP4, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Skip EthType + 4 bytes of IP header */ + Mvpp2PrsSramShiftSet(&pe, MVPP2_ETH_TYPE_LEN + 4, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = FALSE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_L3_IP4, + MVPP2_PRS_RI_L3_PROTO_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Ethertype: IPv4 with options */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + pe.index = tid; + + /* Clear tcam data before updating */ + pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE(MVPP2_ETH_TYPE_LEN)] = 0x0; + pe.tcam.byte[MVPP2_PRS_TCAM_DATA_BYTE_EN(MVPP2_ETH_TYPE_LEN)] = 0x0; + + Mvpp2PrsTcamDataByteSet(&pe, MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_IPV4_HEAD, + MVPP2_PRS_IPV4_HEAD_MASK); + + /* Clear ri before updating */ + pe.sram.word[MVPP2_PRS_SRAM_RI_WORD] = 0x0; + pe.sram.word[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0; + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP4_OPT, + MVPP2_PRS_RI_L3_PROTO_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = FALSE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_L3_IP4_OPT, + MVPP2_PRS_RI_L3_PROTO_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Ethertype: IPv6 without options */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_ETH_P_IPV6); + + /* Skip DIP of IPV6 header */ + Mvpp2PrsSramShiftSet(&pe, MVPP2_ETH_TYPE_LEN + 8 + + MVPP2_MAX_L3_ADDR_SIZE, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP6); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP6, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = FALSE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_L3_IP6, + MVPP2_PRS_RI_L3_PROTO_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + /* Default entry for MVPP2_PRS_LU_L2 - Unknown ethtype */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_L2); + pe.index = MVPP2_PE_ETH_TYPE_UN; + + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Generate flow in the next iteration*/ + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_UN, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Set L3 offset even it's unknown L3 */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_L2); + priv->PrsShadow[pe.index].udf = MVPP2_PRS_UDF_L2_DEF; + priv->PrsShadow[pe.index].finish = TRUE; + Mvpp2PrsShadowRiSet(priv, pe.index, MVPP2_PRS_RI_L3_UN, + MVPP2_PRS_RI_L3_PROTO_MASK); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Configure vlan entries and detect up to 2 successive VLAN tags. + * Possible options: + * 0x8100, 0x88A8 + * 0x8100, 0x8100 + * 0x8100 + * 0x88A8 + */ +STATIC INT32 Mvpp2PrsVlanInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 err; + + /* Double VLAN: 0x8100, 0x88A8 */ + err = Mvpp2PrsDoubleVlanAdd(priv, MV_ETH_P_8021Q, MV_ETH_P_8021AD, + MVPP2_PRS_PORT_MASK); + if (err) + return err; + + /* Double VLAN: 0x8100, 0x8100 */ + err = Mvpp2PrsDoubleVlanAdd(priv, MV_ETH_P_8021Q, MV_ETH_P_8021Q, + MVPP2_PRS_PORT_MASK); + if (err) + return err; + + /* Single VLAN: 0x88a8 */ + err = Mvpp2PrsVlanAdd(priv, MV_ETH_P_8021AD, + MVPP2_PRS_SINGLE_VLAN_AI, + MVPP2_PRS_PORT_MASK); + if (err) + return err; + + /* Single VLAN: 0x8100 */ + err = Mvpp2PrsVlanAdd(priv, MV_ETH_P_8021Q, MVPP2_PRS_SINGLE_VLAN_AI, + MVPP2_PRS_PORT_MASK); + if (err) + return err; + + /* Set default double vlan entry */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_VLAN); + pe.index = MVPP2_PE_VLAN_DBL; + + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_L2); + /* Clear ai for next iterations */ + Mvpp2PrsSramAiUpdate(&pe, 0, MVPP2_PRS_SRAM_AI_MASK); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_VLAN_DOUBLE, + MVPP2_PRS_RI_VLAN_MASK); + + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_DBL_VLAN_AI_BIT, + MVPP2_PRS_DBL_VLAN_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_VLAN); + Mvpp2PrsHwWrite(priv, &pe); + + /* Set default vlan none entry */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_VLAN); + pe.index = MVPP2_PE_VLAN_NONE; + + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_L2); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_VLAN_NONE, + MVPP2_PRS_RI_VLAN_MASK); + + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_VLAN); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Set entries for PPPoE ethertype */ +STATIC INT32 Mvpp2PrsPppoeInit(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid; + + /* IPv4 over PPPoE with options */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_PPPOE); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_PPP_IP); + + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP4); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP4_OPT, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Skip EthType + 4 bytes of IP header */ + Mvpp2PrsSramShiftSet(&pe, MVPP2_ETH_TYPE_LEN + 4, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_PPPOE); + Mvpp2PrsHwWrite(priv, &pe); + + /* IPv4 over PPPoE without options */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + pe.index = tid; + + Mvpp2PrsTcamDataByteSet(&pe, MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_IPV4_HEAD | MVPP2_PRS_IPV4_IHL, + MVPP2_PRS_IPV4_HEAD_MASK | + MVPP2_PRS_IPV4_IHL_MASK); + + /* Clear ri before updating */ + pe.sram.word[MVPP2_PRS_SRAM_RI_WORD] = 0x0; + pe.sram.word[MVPP2_PRS_SRAM_RI_CTRL_WORD] = 0x0; + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP4, + MVPP2_PRS_RI_L3_PROTO_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_PPPOE); + Mvpp2PrsHwWrite(priv, &pe); + + /* IPv6 over PPPoE */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_PPPOE); + pe.index = tid; + + Mvpp2PrsMatchEtype(&pe, 0, MV_PPP_IPV6); + + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP6); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_IP6, + MVPP2_PRS_RI_L3_PROTO_MASK); + /* Skip EthType + 4 bytes of IPv6 header */ + Mvpp2PrsSramShiftSet(&pe, MVPP2_ETH_TYPE_LEN + 4, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Set L3 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_PPPOE); + Mvpp2PrsHwWrite(priv, &pe); + + /* Non-IP over PPPoE */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_PPPOE); + pe.index = tid; + + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_UN, + MVPP2_PRS_RI_L3_PROTO_MASK); + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + /* Set L3 offset even if it's unknown L3 */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L3, + MVPP2_ETH_TYPE_LEN, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_PPPOE); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Initialize entries for IPv4 */ +STATIC INT32 Mvpp2PrsIp4Init(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 err; + + /* Set entries for TCP, UDP and IGMP over IPv4 */ + err = Mvpp2PrsIp4Proto(priv, MV_IPPR_TCP, MVPP2_PRS_RI_L4_TCP, + MVPP2_PRS_RI_L4_PROTO_MASK); + if (err) + return err; + + err = Mvpp2PrsIp4Proto(priv, MV_IPPR_UDP, MVPP2_PRS_RI_L4_UDP, + MVPP2_PRS_RI_L4_PROTO_MASK); + if (err) + return err; + + err = Mvpp2PrsIp4Proto(priv, MV_IPPR_IGMP, + MVPP2_PRS_RI_CPU_CODE_RX_SPEC | + MVPP2_PRS_RI_UDF3_RX_SPECIAL, + MVPP2_PRS_RI_CPU_CODE_MASK | + MVPP2_PRS_RI_UDF3_MASK); + if (err) + return err; + + /* IPv4 Broadcast */ + err = Mvpp2PrsIp4Cast(priv, MVPP2_PRS_L3_BROAD_CAST); + if (err) + return err; + + /* IPv4 Multicast */ + err = Mvpp2PrsIp4Cast(priv, MVPP2_PRS_L3_MULTI_CAST); + if (err) + return err; + + /* Default IPv4 entry for unknown protocols */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP4); + pe.index = MVPP2_PE_IP4_PROTO_UN; + + /* Set next lu to IPv4 */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP4); + Mvpp2PrsSramShiftSet(&pe, 12, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + /* Set L4 offset */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, + sizeof(Mvpp2Iphdr) - 4, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + Mvpp2PrsSramAiUpdate(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, + MVPP2_PRS_IPV4_DIP_AI_BIT); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L4_OTHER, + MVPP2_PRS_RI_L4_PROTO_MASK); + + Mvpp2PrsTcamAiUpdate(&pe, 0, MVPP2_PRS_IPV4_DIP_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + /* Default IPv4 entry for unicast address */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP4); + pe.index = MVPP2_PE_IP4_ADDR_UN; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_UCAST, + MVPP2_PRS_RI_L3_ADDR_MASK); + + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV4_DIP_AI_BIT, + MVPP2_PRS_IPV4_DIP_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Initialize entries for IPv6 */ +STATIC INT32 Mvpp2PrsIp6Init(MVPP2_SHARED *priv) +{ + MVPP2_PRS_ENTRY pe; + INT32 tid, err; + + /* Set entries for TCP, UDP and ICMP over IPv6 */ + err = Mvpp2PrsIp6Proto(priv, MV_IPPR_TCP, + MVPP2_PRS_RI_L4_TCP, + MVPP2_PRS_RI_L4_PROTO_MASK); + if (err) + return err; + + err = Mvpp2PrsIp6Proto(priv, MV_IPPR_UDP, + MVPP2_PRS_RI_L4_UDP, + MVPP2_PRS_RI_L4_PROTO_MASK); + if (err) + return err; + + err = Mvpp2PrsIp6Proto(priv, MV_IPPR_ICMPV6, + MVPP2_PRS_RI_CPU_CODE_RX_SPEC | + MVPP2_PRS_RI_UDF3_RX_SPECIAL, + MVPP2_PRS_RI_CPU_CODE_MASK | + MVPP2_PRS_RI_UDF3_MASK); + if (err) + return err; + + /* IPv4 is the last header. This is similar case as 6-TCP or 17-UDP */ + /* Result Info: UDF7=1, DS lite */ + err = Mvpp2PrsIp6Proto(priv, MV_IPPR_IPIP, + MVPP2_PRS_RI_UDF7_IP6_LITE, + MVPP2_PRS_RI_UDF7_MASK); + if (err) + return err; + + /* IPv6 multicast */ + err = Mvpp2PrsIp6Cast(priv, MVPP2_PRS_L3_MULTI_CAST); + if (err) + return err; + + /* Entry for checking hop limit */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + MVPP2_PE_LAST_FREE_TID); + if (tid < 0) + return tid; + + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = tid; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_UN | + MVPP2_PRS_RI_DROP_MASK, + MVPP2_PRS_RI_L3_PROTO_MASK | + MVPP2_PRS_RI_DROP_MASK); + + Mvpp2PrsTcamDataByteSet(&pe, 1, 0x00, MVPP2_PRS_IPV6_HOP_MASK); + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, + MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + /* Default IPv6 entry for unknown protocols */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = MVPP2_PE_IP6_PROTO_UN; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L4_OTHER, + MVPP2_PRS_RI_L4_PROTO_MASK); + /* Set L4 offset relatively to our current place */ + Mvpp2PrsSramOffsetSet(&pe, MVPP2_PRS_SRAM_UDF_TYPE_L4, + sizeof(Mvpp2Ipv6hdr) - 4, + MVPP2_PRS_SRAM_OP_SEL_UDF_ADD); + + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, + MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + /* Default IPv6 entry for unknown ext protocols */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = MVPP2_PE_IP6_EXT_PROTO_UN; + + /* Finished: go to flowid generation */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_FLOWS); + Mvpp2PrsSramBitsSet(&pe, MVPP2_PRS_SRAM_LU_GEN_BIT, 1); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L4_OTHER, + MVPP2_PRS_RI_L4_PROTO_MASK); + + Mvpp2PrsTcamAiUpdate(&pe, MVPP2_PRS_IPV6_EXT_AI_BIT, + MVPP2_PRS_IPV6_EXT_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP4); + Mvpp2PrsHwWrite(priv, &pe); + + /* Default IPv6 entry for unicast address */ + Mvpp2Memset(&pe, 0, sizeof(MVPP2_PRS_ENTRY)); + Mvpp2PrsTcamLuSet(&pe, MVPP2_PRS_LU_IP6); + pe.index = MVPP2_PE_IP6_ADDR_UN; + + /* Finished: go to IPv6 again */ + Mvpp2PrsSramNextLuSet(&pe, MVPP2_PRS_LU_IP6); + Mvpp2PrsSramRiUpdate(&pe, MVPP2_PRS_RI_L3_UCAST, + MVPP2_PRS_RI_L3_ADDR_MASK); + Mvpp2PrsSramAiUpdate(&pe, MVPP2_PRS_IPV6_NO_EXT_AI_BIT, + MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Shift back to IPV6 NH */ + Mvpp2PrsSramShiftSet(&pe, -18, MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + Mvpp2PrsTcamAiUpdate(&pe, 0, MVPP2_PRS_IPV6_NO_EXT_AI_BIT); + /* Unmask all ports */ + Mvpp2PrsTcamPortMapSet(&pe, MVPP2_PRS_PORT_MASK); + + /* Update shadow table and hw entry */ + Mvpp2PrsShadowSet(priv, pe.index, MVPP2_PRS_LU_IP6); + Mvpp2PrsHwWrite(priv, &pe); + + return 0; +} + +/* Parser default initialization */ +INT32 Mvpp2PrsDefaultInit(MVPP2_SHARED *priv) +{ + INT32 err, index, i; + + /* Enable tcam table */ + Mvpp2Write(priv, MVPP2_PRS_TCAM_CTRL_REG, MVPP2_PRS_TCAM_EN_MASK); + + /* Clear all tcam and sram entries */ + for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) { + Mvpp2Write(priv, MVPP2_PRS_TCAM_IDX_REG, index); + for (i = 0; i < MVPP2_PRS_TCAM_WORDS; i++) + Mvpp2Write(priv, MVPP2_PRS_TCAM_DATA_REG(i), 0); + + Mvpp2Write(priv, MVPP2_PRS_SRAM_IDX_REG, index); + for (i = 0; i < MVPP2_PRS_SRAM_WORDS; i++) + Mvpp2Write(priv, MVPP2_PRS_SRAM_DATA_REG(i), 0); + } + + /* Invalidate all tcam entries */ + for (index = 0; index < MVPP2_PRS_TCAM_SRAM_SIZE; index++) + Mvpp2PrsHwInv(priv, index); + + /* Always start from lookup = 0 */ + for (index = 0; index < MVPP2_MAX_PORTS; index++) + Mvpp2PrsHwPortInit(priv, index, MVPP2_PRS_LU_MH, + MVPP2_PRS_PORT_LU_MAX, 0); + + Mvpp2PrsDefFlowInit(priv); + + Mvpp2PrsMhInit(priv); + + Mvpp2PrsMacInit(priv); + + Mvpp2PrsDsaInit(priv); + + err = Mvpp2PrsEtypeInit(priv); + if (err) + return err; + + err = Mvpp2PrsVlanInit(priv); + if (err) + return err; + + err = Mvpp2PrsPppoeInit(priv); + if (err) + return err; + + err = Mvpp2PrsIp6Init(priv); + if (err) + return err; + + err = Mvpp2PrsIp4Init(priv); + if (err) + return err; + + return 0; +} + +/* Compare MAC DA with tcam entry data */ +STATIC BOOLEAN Mvpp2PrsMacRangeEquals(MVPP2_PRS_ENTRY *pe, + const UINT8 *da, UINT8 *mask) +{ + UINT8 TcamByte, TcamMask; + INT32 index; + + for (index = 0; index < MV_ETH_ALEN; index++) { + Mvpp2PrsTcamDataByteGet(pe, index, &TcamByte, &TcamMask); + if (TcamMask != mask[index]) + return FALSE; + + if ((TcamMask & TcamByte) != (da[index] & mask[index])) + return FALSE; + } + + return TRUE; +} + +/* Find tcam entry with matched pair <MAC DA, port> */ +STATIC MVPP2_PRS_ENTRY * +Mvpp2PrsMacDaRangeFind(MVPP2_SHARED *priv, INT32 pmap, const UINT8 *da, + UINT8 *mask, INT32 UdfType) +{ + MVPP2_PRS_ENTRY *pe; + INT32 tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_NULL; + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_MAC); + + /* Go through the all entires with MVPP2_PRS_LU_MAC */ + for (tid = MVPP2_PE_FIRST_FREE_TID; + tid <= MVPP2_PE_LAST_FREE_TID; tid++) { + UINT32 EntryPmap; + + if (!priv->PrsShadow[tid].valid || + (priv->PrsShadow[tid].lu != MVPP2_PRS_LU_MAC) || + (priv->PrsShadow[tid].udf != UdfType)) + continue; + + pe->index = tid; + Mvpp2PrsHwRead(priv, pe); + EntryPmap = Mvpp2PrsTcamPortMapGet(pe); + + if (Mvpp2PrsMacRangeEquals(pe, da, mask) && + EntryPmap == pmap) + return pe; + } + Mvpp2Free(pe); + + return MVPP2_NULL; +} + +/* Update parser's mac da entry */ +INT32 Mvpp2PrsMacDaAccept(MVPP2_SHARED *priv, INT32 port, + const UINT8 *da, BOOLEAN add) +{ + MVPP2_PRS_ENTRY *pe; + UINT32 pmap, len, ri; + UINT8 mask[MV_ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; + INT32 tid; + + /* Scan TCAM and see if entry with this <MAC DA, port> already exist */ + pe = Mvpp2PrsMacDaRangeFind(priv, (1 << port), da, mask, + MVPP2_PRS_UDF_MAC_DEF); + + /* No such entry */ + if (!pe) { + if (!add) + return 0; + + /* Create new TCAM entry */ + /* Find first range mac entry*/ + for (tid = MVPP2_PE_FIRST_FREE_TID; + tid <= MVPP2_PE_LAST_FREE_TID; tid++) + if (priv->PrsShadow[tid].valid && + (priv->PrsShadow[tid].lu == MVPP2_PRS_LU_MAC) && + (priv->PrsShadow[tid].udf == + MVPP2_PRS_UDF_MAC_RANGE)) + break; + + /* Go through the all entries from first to last */ + tid = Mvpp2PrsTcamFirstFree(priv, MVPP2_PE_FIRST_FREE_TID, + tid - 1); + if (tid < 0) + return tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return -1; + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_MAC); + pe->index = tid; + + /* Mask all ports */ + Mvpp2PrsTcamPortMapSet(pe, 0); + } + + /* Update port mask */ + Mvpp2PrsTcamPortSet(pe, port, add); + + /* Invalidate the entry if no ports are left enabled */ + pmap = Mvpp2PrsTcamPortMapGet(pe); + if (pmap == 0) { + if (add) { + Mvpp2Free(pe); + return -1; + } + Mvpp2PrsHwInv(priv, pe->index); + priv->PrsShadow[pe->index].valid = FALSE; + Mvpp2Free(pe); + return 0; + } + + /* Continue - set next lookup */ + Mvpp2PrsSramNextLuSet(pe, MVPP2_PRS_LU_DSA); + + /* Set match on DA */ + len = MV_ETH_ALEN; + while (len--) + Mvpp2PrsTcamDataByteSet(pe, len, da[len], 0xff); + + /* Set result info bits */ + if (Mvpp2IsBroadcastEtherAddr(da)) + ri = MVPP2_PRS_RI_L2_BCAST; + else if (Mvpp2IsMulticastEtherAddr(da)) + ri = MVPP2_PRS_RI_L2_MCAST; + else + ri = MVPP2_PRS_RI_L2_UCAST | MVPP2_PRS_RI_MAC_ME_MASK; + + Mvpp2PrsSramRiUpdate(pe, ri, MVPP2_PRS_RI_L2_CAST_MASK | + MVPP2_PRS_RI_MAC_ME_MASK); + Mvpp2PrsShadowRiSet(priv, pe->index, ri, MVPP2_PRS_RI_L2_CAST_MASK | + MVPP2_PRS_RI_MAC_ME_MASK); + + /* Shift to ethertype */ + Mvpp2PrsSramShiftSet(pe, 2 * MV_ETH_ALEN, + MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD); + + /* Update shadow table and hw entry */ + priv->PrsShadow[pe->index].udf = MVPP2_PRS_UDF_MAC_DEF; + Mvpp2PrsShadowSet(priv, pe->index, MVPP2_PRS_LU_MAC); + Mvpp2PrsHwWrite(priv, pe); + + Mvpp2Free(pe); + + return 0; +} + +/* Delete all port's multicast simple (not range) entries */ +VOID Mvpp2PrsMcastDelAll(MVPP2_SHARED *priv, INT32 port) +{ + MVPP2_PRS_ENTRY pe; + INT32 index, tid; + + for (tid = MVPP2_PE_FIRST_FREE_TID; + tid <= MVPP2_PE_LAST_FREE_TID; tid++) { + UINT8 da[MV_ETH_ALEN], DaMask[MV_ETH_ALEN]; + + if (!priv->PrsShadow[tid].valid || + (priv->PrsShadow[tid].lu != MVPP2_PRS_LU_MAC) || + (priv->PrsShadow[tid].udf != MVPP2_PRS_UDF_MAC_DEF)) + continue; + + /* Only simple mac entries */ + pe.index = tid; + Mvpp2PrsHwRead(priv, &pe); + + /* Read mac addr from entry */ + for (index = 0; index < MV_ETH_ALEN; index++) + Mvpp2PrsTcamDataByteGet(&pe, index, &da[index], + &DaMask[index]); + + if (Mvpp2IsMulticastEtherAddr(da) && + !Mvpp2IsBroadcastEtherAddr(da)) + /* Delete this entry */ + Mvpp2PrsMacDaAccept(priv, port, da, FALSE); + } +} + +INT32 Mvpp2PrsTagModeSet(MVPP2_SHARED *priv, INT32 port, INT32 type) +{ + switch (type) { + case MVPP2_TAG_TYPE_EDSA: + /* Add port to EDSA entries */ + Mvpp2PrsDsaTagSet(priv, port, TRUE, + MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); + Mvpp2PrsDsaTagSet(priv, port, TRUE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); + /* Remove port from DSA entries */ + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); + break; + + case MVPP2_TAG_TYPE_DSA: + /* Add port to DSA entries */ + Mvpp2PrsDsaTagSet(priv, port, TRUE, + MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); + Mvpp2PrsDsaTagSet(priv, port, TRUE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); + /* Remove port from EDSA entries */ + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); + break; + + case MVPP2_TAG_TYPE_MH: + case MVPP2_TAG_TYPE_NONE: + /* Remove port form EDSA and DSA entries */ + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_TAGGED, MVPP2_PRS_DSA); + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_DSA); + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_TAGGED, MVPP2_PRS_EDSA); + Mvpp2PrsDsaTagSet(priv, port, FALSE, + MVPP2_PRS_UNTAGGED, MVPP2_PRS_EDSA); + break; + + default: + if ((type < 0) || (type > MVPP2_TAG_TYPE_EDSA)) + return MVPP2_EINVAL; + } + + return 0; +} + +/* Set prs flow for the port */ +INT32 Mvpp2PrsDefFlow(PP2DXE_PORT *port) +{ + MVPP2_PRS_ENTRY *pe; + INT32 tid; + + pe = Mvpp2PrsFlowFind(port->priv, port->id); + + /* Such entry not exist */ + if (!pe) { + /* Go through the all entires from last to first */ + tid = Mvpp2PrsTcamFirstFree(port->priv, + MVPP2_PE_LAST_FREE_TID, + MVPP2_PE_FIRST_FREE_TID); + if (tid < 0) + return tid; + + pe = Mvpp2Alloc(sizeof(*pe)); + if (!pe) + return MVPP2_ENOMEM; + + Mvpp2PrsTcamLuSet(pe, MVPP2_PRS_LU_FLOWS); + pe->index = tid; + + /* Set flow ID*/ + Mvpp2PrsSramAiUpdate(pe, port->id, MVPP2_PRS_FLOW_ID_MASK); + Mvpp2PrsSramBitsSet(pe, MVPP2_PRS_SRAM_LU_DONE_BIT, 1); + + /* Update shadow table */ + Mvpp2PrsShadowSet(port->priv, pe->index, MVPP2_PRS_LU_FLOWS); + } + + Mvpp2PrsTcamPortMapSet(pe, (1 << port->id)); + Mvpp2PrsHwWrite(port->priv, pe); + Mvpp2Free(pe); + + return 0; +} + +/* Classifier configuration routines */ + +/* Update classification flow table registers */ +STATIC VOID Mvpp2ClsFlowWrite(MVPP2_SHARED *priv, + MVPP2_CLS_FLOW_ENTRY *fe) +{ + Mvpp2Write(priv, MVPP2_CLS_FLOW_INDEX_REG, fe->index); + Mvpp2Write(priv, MVPP2_CLS_FLOW_TBL0_REG, fe->data[0]); + Mvpp2Write(priv, MVPP2_CLS_FLOW_TBL1_REG, fe->data[1]); + Mvpp2Write(priv, MVPP2_CLS_FLOW_TBL2_REG, fe->data[2]); +} + +/* Update classification lookup table register */ +VOID Mvpp2ClsLookupWrite(MVPP2_SHARED *priv, + MVPP2_CLS_LOOKUP_ENTRY *le) +{ + UINT32 val; + + val = (le->way << MVPP2_CLS_LKP_INDEX_WAY_OFFS) | le->lkpid; + Mvpp2Write(priv, MVPP2_CLS_LKP_INDEX_REG, val); + Mvpp2Write(priv, MVPP2_CLS_LKP_TBL_REG, le->data); +} + +/* Classifier default initialization */ +VOID Mvpp2ClsInit(MVPP2_SHARED *priv) +{ + MVPP2_CLS_LOOKUP_ENTRY le; + MVPP2_CLS_FLOW_ENTRY fe; + INT32 index; + + /* Enable classifier */ + Mvpp2Write(priv, MVPP2_CLS_MODE_REG, MVPP2_CLS_MODE_ACTIVE_MASK); + + /* Clear classifier flow table */ + Mvpp2Memset(&fe.data, 0, MVPP2_CLS_FLOWS_TBL_DATA_WORDS); + for (index = 0; index < MVPP2_CLS_FLOWS_TBL_SIZE; index++) { + fe.index = index; + Mvpp2ClsFlowWrite(priv, &fe); + } + + /* Clear classifier lookup table */ + le.data = 0; + for (index = 0; index < MVPP2_CLS_LKP_TBL_SIZE; index++) { + le.lkpid = index; + le.way = 0; + Mvpp2ClsLookupWrite(priv, &le); + + le.way = 1; + Mvpp2ClsLookupWrite(priv, &le); + } +} + +VOID Mvpp2ClsPortConfig(PP2DXE_PORT *port) +{ + MVPP2_CLS_LOOKUP_ENTRY le; + UINT32 val; + + /* Set way for the port */ + val = Mvpp2Read(port->priv, MVPP2_CLS_PORT_WAY_REG); + val &= ~MVPP2_CLS_PORT_WAY_MASK(port->id); + Mvpp2Write(port->priv, MVPP2_CLS_PORT_WAY_REG, val); + + /* Pick the entry to be accessed in lookup ID decoding table + * according to the way and lkpid. + */ + le.lkpid = port->id; + le.way = 0; + le.data = 0; + + /* Set initial CPU queue for receiving packets */ + le.data &= ~MVPP2_CLS_LKP_TBL_RXQ_MASK; + le.data |= port->FirstRxq; + + /* Disable classification engines */ + le.data &= ~MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK; + + /* Update lookup ID table entry */ + Mvpp2ClsLookupWrite(port->priv, &le); +} + +/* Set CPU queue number for oversize packets */ +VOID Mvpp2ClsOversizeRxqSet(PP2DXE_PORT *port) +{ + + Mvpp2Write(port->priv, MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port->id), + port->FirstRxq & MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK); + +#ifdef MVPP2_V1 + Mvpp2Write(port->priv, MVPP2_CLS_SWFWD_P2HQ_REG(port->id), + (port->FirstRxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS)); + + val = Mvpp2Read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG); + val |= MVPP2_CLS_SWFWD_PCTRL_MASK(port->id); + Mvpp2Write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val); +#endif +} + +/* BM helper routines */ + + +VOID Mvpp2BmPoolHwCreate(MVPP2_SHARED *priv, + MVPP2_BMS_POOL *BmPool, INT32 size) +{ +#ifdef MVPP2_V1 + UINT32 val; + + Mvpp2Write(priv, MVPP2_BM_POOL_BASE_REG(BmPool->id), + BmPool->PhysAddr); + Mvpp2Write(priv, MVPP2_BM_POOL_SIZE_REG(BmPool->id), size); + + val = Mvpp2Read(priv, MVPP2_BM_POOL_CTRL_REG(BmPool->id)); + val |= MVPP2_BM_START_MASK; + Mvpp2Write(priv, MVPP2_BM_POOL_CTRL_REG(BmPool->id), val); + + BmPool->type = MVPP2_BM_FREE; + BmPool->size = size; + BmPool->PktSize = 0; + BmPool->BufNum = 0; +#else + BmPool->size = size; + + Mvpp2Write(priv, MVPP2_BM_POOL_BASE_REG(BmPool->id), + Lower32Bits(BmPool->PhysAddr)); + + Mvpp2Write(priv, MVPP22_BM_POOL_BASE_HIGH_REG, + (Upper32Bits(BmPool->PhysAddr)& + MVPP22_BM_POOL_BASE_HIGH_REG)); + Mvpp2Write(priv, MVPP2_BM_POOL_SIZE_REG(BmPool->id), + BmPool->size); +#endif +} + +/* Set pool buffer size */ +VOID Mvpp2BmPoolBufsizeSet(MVPP2_SHARED *priv, + MVPP2_BMS_POOL *BmPool, + INT32 BufSize) +{ + UINT32 val; + + BmPool->BufSize = BufSize; + + val = MVPP2_ALIGN(BufSize, 1 << MVPP2_POOL_BUF_SIZE_OFFSET); + Mvpp2Write(priv, MVPP2_POOL_BUF_SIZE_REG(BmPool->id), val); +} + +VOID Mvpp2BmStop(MVPP2_SHARED *priv, INT32 pool) +{ + UINT32 val, i; + + for (i = 0; i < MVPP2_BM_SIZE; i++) + Mvpp2Read(priv, MVPP2_BM_PHY_ALLOC_REG(0)); + + val = Mvpp2Read(priv, MVPP2_BM_POOL_CTRL_REG(pool)); + val |= MVPP2_BM_STOP_MASK; + Mvpp2Write(priv, MVPP2_BM_POOL_CTRL_REG(pool), val); + +} + +VOID Mvpp2BmIrqClear(MVPP2_SHARED *priv, INT32 pool) +{ + /* Mask BM all interrupts */ + Mvpp2Write(priv, MVPP2_BM_INTR_MASK_REG(pool), 0); + /* Clear BM cause register */ + Mvpp2Write(priv, MVPP2_BM_INTR_CAUSE_REG(pool), 0); +} + +/* Attach long pool to rxq */ +VOID Mvpp2RxqLongPoolSet(PP2DXE_PORT *port, + INT32 lrxq, INT32 LongPool) +{ + UINT32 val; + INT32 prxq; + + /* Get queue physical ID */ + prxq = port->rxqs[lrxq].id; + + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq)); + val &= ~MVPP2_RXQ_POOL_LONG_MASK; + val |= ((LongPool << MVPP2_RXQ_POOL_LONG_OFFS) & + MVPP2_RXQ_POOL_LONG_MASK); + + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val); +} + +/* Attach short pool to rxq */ +VOID Mvpp2RxqShortPoolSet(PP2DXE_PORT *port, + INT32 lrxq, INT32 ShortPool) +{ + UINT32 val; + INT32 prxq; + + /* Get queue physical ID */ + prxq = port->rxqs[lrxq].id; + + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq)); + val &= ~MVPP2_RXQ_POOL_SHORT_MASK; + val |= ((ShortPool << MVPP2_RXQ_POOL_SHORT_OFFS) & + MVPP2_RXQ_POOL_SHORT_MASK); + + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val); +} + +/* Release multicast buffer */ +VOID Mvpp2BmPoolMcPut(PP2DXE_PORT *port, INT32 pool, + UINT32 BufPhysAddr, UINT32 BufVirtAddr, + INT32 McId) +{ + UINT32 val = 0; + + val |= (McId & MVPP2_BM_MC_ID_MASK); + Mvpp2Write(port->priv, MVPP2_BM_MC_RLS_REG, val); + + Mvpp2BmPoolPut(port->priv, pool, + BufPhysAddr | MVPP2_BM_PHY_RLS_MC_BUFF_MASK, + BufVirtAddr); +} + +/* Refill BM pool */ +VOID Mvpp2PoolRefill(PP2DXE_PORT *port, UINT32 bm, + UINT32 PhysAddr, UINT32 cookie) +{ + INT32 pool = Mvpp2BmCookiePoolGet(bm); + + Mvpp2BmPoolPut(port->priv, pool, PhysAddr, cookie); +} + +/* Mask the current CPU's Rx/Tx interrupts */ +VOID Mvpp2InterruptsMask(VOID *arg) +{ + PP2DXE_PORT *port = arg; + + Mvpp2Write(port->priv, MVPP2_ISR_RX_TX_MASK_REG(port->id), 0); +} + +/* Unmask the current CPU's Rx/Tx interrupts */ +VOID Mvpp2InterruptsUnmask(VOID *arg) +{ + PP2DXE_PORT *port = arg; + + Mvpp2Write(port->priv, MVPP2_ISR_RX_TX_MASK_REG(port->id), + (MVPP2_CAUSE_MISC_SUM_MASK | + MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK)); +} + +/* Port configuration routines */ + +STATIC VOID Mvpp2PortMiiSet(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_2_REG); + + switch (port->PhyInterface) { + case MV_MODE_SGMII: + val |= MVPP2_GMAC_INBAND_AN_MASK; + break; + case MV_MODE_RGMII: + val |= MVPP2_GMAC_PORT_RGMII_MASK; + default: + val &= ~MVPP2_GMAC_PCS_ENABLE_MASK; + } + + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_2_REG, val); +} + +STATIC VOID Mvpp2PortFcAdvEnable(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_AUTONEG_CONFIG); + val |= MVPP2_GMAC_FC_ADV_EN; + Mvpp2GmacWrite(port, MVPP2_GMAC_AUTONEG_CONFIG, val); +} + +VOID Mvpp2PortEnable(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_0_REG); + val |= MVPP2_GMAC_PORT_EN_MASK; + val |= MVPP2_GMAC_MIB_CNTR_EN_MASK; + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_0_REG, val); +} + +VOID Mvpp2PortDisable(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_0_REG); + val &= ~(MVPP2_GMAC_PORT_EN_MASK); + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_0_REG, val); +} + +/* Set IEEE 802.3x Flow Control Xon Packet Transmission Mode */ +STATIC VOID Mvpp2PortPeriodicXonDisable(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_1_REG) & + ~MVPP2_GMAC_PERIODIC_XON_EN_MASK; + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_1_REG, val); +} + +/* Configure loopback port */ +#ifdef MVPP2_V1 +STATIC VOID Mvpp2PortLoopbackSet(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_1_REG); + + if (port->speed == SPEED_1000) + val |= MVPP2_GMAC_GMII_LB_EN_MASK; + else + val &= ~MVPP2_GMAC_GMII_LB_EN_MASK; + + if (port->PhyInterface == MV_MODE_SGMII) + val |= MVPP2_GMAC_PCS_LB_EN_MASK; + else + val &= ~MVPP2_GMAC_PCS_LB_EN_MASK; + + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_1_REG, val); +} +#endif + +STATIC VOID Mvpp2PortReset(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_2_REG) & + ~MVPP2_GMAC_PORT_RESET_MASK; + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_2_REG, val); + + while (Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_2_REG) & + MVPP2_GMAC_PORT_RESET_MASK) + continue; +} + +/* Set defaults to the MVPP2 port */ +VOID Mvpp2DefaultsSet(PP2DXE_PORT *port) +{ + INT32 TxPortNum, val, queue, ptxq; + +#ifdef MVPP2_V1 + /* Configure port to loopback if needed */ + if (port->flags & MVPP2_F_LOOPBACK) + Mvpp2PortLoopbackSet(port); + + /* Update TX FIFO MIN Threshold */ + val = Mvpp2GmacRead(port, MVPP2_GMAC_PORT_FIFO_CFG_1_REG); + val &= ~MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK; + /* Min. TX threshold must be less than minimal packet length */ + val |= MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(64 - 4 - 2); + Mvpp2GmacWrite(port, MVPP2_GMAC_PORT_FIFO_CFG_1_REG, val); +#endif + + /* Disable Legacy WRR, Disable EJP, Release from reset */ + TxPortNum = Mvpp2EgressPort(port); + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, + TxPortNum); + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_CMD_1_REG, 0); + + /* Close bandwidth for all queues */ + for (queue = 0; queue < MVPP2_MAX_TXQ; queue++) { + ptxq = Mvpp2TxqPhys(port->id, queue); + Mvpp2Write(port->priv, + MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(ptxq), 0); + } + + /* Set refill period to 1 usec, refill tokens + * and bucket size to maximum + */ + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PERIOD_REG, + port->priv->tclk / MVPP2_USEC_PER_SEC); + val = Mvpp2Read(port->priv, MVPP2_TXP_SCHED_REFILL_REG); + val &= ~MVPP2_TXP_REFILL_PERIOD_ALL_MASK; + val |= MVPP2_TXP_REFILL_PERIOD_MASK(1); + val |= MVPP2_TXP_REFILL_TOKENS_ALL_MASK; + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_REFILL_REG, val); + val = MVPP2_TXP_TOKEN_SIZE_MAX; + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val); + + /* Set MaximumLowLatencyPacketSize value to 256 */ + Mvpp2Write(port->priv, MVPP2_RX_CTRL_REG(port->id), + MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK | + MVPP2_RX_LOW_LATENCY_PKT_SIZE(256)); + +#ifdef MVPP2_V1 + /* Enable Rx cache snoop */ + INT32 lrxq; + for (lrxq = 0; lrxq < RxqNumber; lrxq++) { + queue = port->rxqs[lrxq].id; + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(queue)); + val |= MVPP2_SNOOP_PKT_SIZE_MASK | + MVPP2_SNOOP_BUF_HDR_MASK; + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val); + } +#else + /* Mask all interrupts to all present cpus */ + Mvpp2InterruptsDisable(port, 0x1); +#endif + +} + +/* Enable/disable receiving packets */ +VOID Mvpp2IngressEnable(PP2DXE_PORT *port) +{ + UINT32 val; + INT32 lrxq, queue; + + for (lrxq = 0; lrxq < RxqNumber; lrxq++) { + queue = port->rxqs[lrxq].id; + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(queue)); + val &= ~MVPP2_RXQ_DISABLE_MASK; + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val); + } +} + +VOID Mvpp2IngressDisable(PP2DXE_PORT *port) +{ + UINT32 val; + INT32 lrxq, queue; + + for (lrxq = 0; lrxq < RxqNumber; lrxq++) { + queue = port->rxqs[lrxq].id; + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(queue)); + val |= MVPP2_RXQ_DISABLE_MASK; + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(queue), val); + } +} + +/* Enable transmit via physical egress queue + * - HW starts take descriptors from DRAM + */ +VOID Mvpp2EgressEnable(PP2DXE_PORT *port) +{ + UINT32 qmap; + INT32 queue; + INT32 TxPortNum = Mvpp2EgressPort(port); + + /* Enable all initialized TXs. */ + qmap = 0; + for (queue = 0; queue < TxqNumber; queue++) { + MVPP2_TX_QUEUE *txq = &port->txqs[queue]; + + if (txq->descs != MVPP2_NULL) + qmap |= (1 << queue); + } + + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, TxPortNum); + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG, qmap); +} + +/* Disable transmit via physical egress queue + * - HW doesn't take descriptors from DRAM + */ +VOID Mvpp2EgressDisable(PP2DXE_PORT *port) +{ + UINT32 RegData; + INT32 delay; + INT32 TxPortNum = Mvpp2EgressPort(port); + + /* Issue stop command for active channels only */ + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, TxPortNum); + RegData = (Mvpp2Read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG)) & + MVPP2_TXP_SCHED_ENQ_MASK; + if (RegData != 0) + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG, + (RegData << MVPP2_TXP_SCHED_DISQ_OFFSET)); + + /* Wait for all Tx activity to terminate. */ + delay = 0; + do { + if (delay >= MVPP2_TX_DISABLE_TIMEOUT_MSEC) { + Mvpp2Printf("Tx stop timed out, status=0x%08x\n", + RegData); + break; + } + Mvpp2Mdelay(1); + delay++; + + /* Check port TX Command register that all + * Tx queues are stopped + */ + RegData = Mvpp2Read(port->priv, MVPP2_TXP_SCHED_Q_CMD_REG); + } while (RegData & MVPP2_TXP_SCHED_ENQ_MASK); +} + +/* Rx descriptors helper methods */ + +/* Set rx queue offset */ +STATIC VOID Mvpp2RxqOffsetSet(PP2DXE_PORT *port, + INT32 prxq, INT32 offset) +{ + UINT32 val; + + /* Convert offset from bytes to units of 32 bytes */ + offset = offset >> 5; + + val = Mvpp2Read(port->priv, MVPP2_RXQ_CONFIG_REG(prxq)); + val &= ~MVPP2_RXQ_PACKET_OFFSET_MASK; + + /* Offset is in */ + val |= ((offset << MVPP2_RXQ_PACKET_OFFSET_OFFS) & + MVPP2_RXQ_PACKET_OFFSET_MASK); + + Mvpp2Write(port->priv, MVPP2_RXQ_CONFIG_REG(prxq), val); +} + +/* Obtain BM cookie information from descriptor */ +UINT32 Mvpp2BmCookieBuild(MVPP2_RX_DESC *RxDesc, INT32 cpu) +{ + INT32 pool = (RxDesc->status & MVPP2_RXD_BM_POOL_ID_MASK) >> + MVPP2_RXD_BM_POOL_ID_OFFS; + + return ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS) | + ((cpu & 0xFF) << MVPP2_BM_COOKIE_CPU_OFFS); +} + +/* Tx descriptors helper methods */ + +INT32 Mvpp2TxqDrainSet(PP2DXE_PORT *port, INT32 txq, BOOLEAN en) +{ + UINT32 RegVal; + INT32 ptxq = Mvpp2TxqPhys(port->id, txq); + + Mvpp2Write(port->priv, MVPP2_TXQ_NUM_REG, ptxq); + RegVal = Mvpp2Read(port->priv, MVPP2_TXQ_PREF_BUF_REG); + + if (en) + RegVal |= MVPP2_TXQ_DRAIN_EN_MASK; + else + RegVal &= ~MVPP2_TXQ_DRAIN_EN_MASK; + + Mvpp2Write(port->priv, MVPP2_TXQ_PREF_BUF_REG, RegVal); + + return 0; +} + +/* Get number of Tx descriptors waiting to be transmitted by HW */ +INT32 Mvpp2TxqPendDescNumGet(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq) +{ + UINT32 val; + + Mvpp2Write(port->priv, MVPP2_TXQ_NUM_REG, txq->id); + val = Mvpp2Read(port->priv, MVPP2_TXQ_PENDING_REG); + + return val & MVPP2_TXQ_PENDING_MASK; +} + +/* Get number of occupied aggregated Tx descriptors */ +UINT32 Mvpp2AggrTxqPendDescNumGet(MVPP2_SHARED *pp2, int cpu) +{ + UINT32 RegVal; + + RegVal = Mvpp2Read(pp2, MVPP2_AGGR_TXQ_STATUS_REG(cpu)); + + return RegVal & MVPP2_AGGR_TXQ_PENDING_MASK; +} + +/* Get pointer to next Tx descriptor to be processed (send) by HW */ +MVPP2_TX_DESC * +Mvpp2TxqNextDescGet(MVPP2_TX_QUEUE *txq) +{ + INT32 TxDesc = txq->NextDescToProc; + + txq->NextDescToProc = MVPP2_QUEUE_NEXT_DESC(txq, TxDesc); + return txq->descs + TxDesc; +} + +/* Update HW with number of aggregated Tx descriptors to be sent */ +VOID Mvpp2AggrTxqPendDescAdd(PP2DXE_PORT *port, INT32 pending) +{ + /* aggregated access - relevant TXQ number is written in TX desc */ + Mvpp2Write(port->priv, MVPP2_AGGR_TXQ_UPDATE_REG, pending); +} + +/* Check if there are enough free descriptors in aggregated txq. + * If not, update the number of occupied descriptors and repeat the check. + */ +INT32 Mvpp2AggrDescNumCheck(MVPP2_SHARED *priv, + MVPP2_TX_QUEUE *AggrTxq, INT32 num, + INT32 cpu) +{ + if ((AggrTxq->count + num) > AggrTxq->size) { + /* Update number of occupied aggregated Tx descriptors */ + UINT32 val = Mvpp2Read(priv, MVPP2_AGGR_TXQ_STATUS_REG(cpu)); + + AggrTxq->count = val & MVPP2_AGGR_TXQ_PENDING_MASK; + } + + if ((AggrTxq->count + num) > AggrTxq->size) + return MVPP2_ENOMEM; + + return 0; +} + +/* Reserved Tx descriptors allocation request */ +INT32 Mvpp2TxqAllocReservedDesc(MVPP2_SHARED *priv, + MVPP2_TX_QUEUE *txq, INT32 num) +{ + UINT32 val; + + val = (txq->id << MVPP2_TXQ_RSVD_REQ_Q_OFFSET) | num; + Mvpp2Write(priv, MVPP2_TXQ_RSVD_REQ_REG, val); + + val = Mvpp2Read(priv, MVPP2_TXQ_RSVD_RSLT_REG); + + return val & MVPP2_TXQ_RSVD_RSLT_MASK; +} + +/* Release the last allocated Tx descriptor. Useful to handle DMA + * mapping failures in the Tx path. + */ +VOID Mvpp2TxqDescPut(MVPP2_TX_QUEUE *txq) +{ + if (txq->NextDescToProc == 0) + txq->NextDescToProc = txq->LastDesc - 1; + else + txq->NextDescToProc--; +} + +/* Set Tx descriptors fields relevant for CSUM calculation */ +UINT32 Mvpp2TxqDescCsum(INT32 L3Offs, INT32 L3Proto, + INT32 IpHdrLen, INT32 L4Proto) +{ + UINT32 command; + + /* fields: L3_offset, IP_hdrlen, L3_type, G_IPV4Chk, + * G_L4_chk, L4_type required only for checksum calculation + */ + command = (L3Offs << MVPP2_TXD_L3_OFF_SHIFT); + command |= (IpHdrLen << MVPP2_TXD_IP_HLEN_SHIFT); + command |= MVPP2_TXD_IP_CSUM_DISABLE; + + if (L3Proto == Mvpp2Swab16(MV_ETH_P_IP)) { + command &= ~MVPP2_TXD_IP_CSUM_DISABLE; /* enable IPv4 csum */ + command &= ~MVPP2_TXD_L3_IP6; /* enable IPv4 */ + } else { + command |= MVPP2_TXD_L3_IP6; /* enable IPv6 */ + } + + if (L4Proto == MV_IPPR_TCP) { + command &= ~MVPP2_TXD_L4_UDP; /* enable TCP */ + command &= ~MVPP2_TXD_L4_CSUM_FRAG; /* generate L4 csum */ + } else if (L4Proto == MV_IPPR_UDP) { + command |= MVPP2_TXD_L4_UDP; /* enable UDP */ + command &= ~MVPP2_TXD_L4_CSUM_FRAG; /* generate L4 csum */ + } else { + command |= MVPP2_TXD_L4_CSUM_NOT; + } + + return command; +} + +VOID Mvpp2TxqSentCounterClear(VOID *arg) +{ + PP2DXE_PORT *port = arg; + INT32 queue; + + for (queue = 0; queue < TxqNumber; queue++) { + INT32 id = port->txqs[queue].id; + + Mvpp2Read(port->priv, MVPP2_TXQ_SENT_REG(id)); + } +} + +/* Change maximum receive size of the port */ +VOID Mvpp2GmacMaxRxSizeSet(PP2DXE_PORT *port) +{ + UINT32 val; + + val = Mvpp2GmacRead(port, MVPP2_GMAC_CTRL_0_REG); + val &= ~MVPP2_GMAC_MAX_RX_SIZE_MASK; + val |= (((port->PktSize - MVPP2_MH_SIZE) / 2) << + MVPP2_GMAC_MAX_RX_SIZE_OFFS); + Mvpp2GmacWrite(port, MVPP2_GMAC_CTRL_0_REG, val); +} + +/* Set max sizes for Tx queues */ +VOID Mvpp2TxpMaxTxSizeSet(PP2DXE_PORT *port) +{ + UINT32 val, size, mtu; + INT32 txq, TxPortNum; + + mtu = port->PktSize * 8; + if (mtu > MVPP2_TXP_MTU_MAX) + mtu = MVPP2_TXP_MTU_MAX; + + /* WA for wrong Token bucket update: Set MTU value = 3*real MTU value */ + mtu = 3 * mtu; + + /* Indirect access to registers */ + TxPortNum = Mvpp2EgressPort(port); + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, TxPortNum); + + /* Set MTU */ + val = Mvpp2Read(port->priv, MVPP2_TXP_SCHED_MTU_REG); + val &= ~MVPP2_TXP_MTU_MAX; + val |= mtu; + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_MTU_REG, val); + + /* TXP token size and all TXQs token size must be larger that MTU */ + val = Mvpp2Read(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG); + size = val & MVPP2_TXP_TOKEN_SIZE_MAX; + if (size < mtu) { + size = mtu; + val &= ~MVPP2_TXP_TOKEN_SIZE_MAX; + val |= size; + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_TOKEN_SIZE_REG, val); + } + + for (txq = 0; txq < TxqNumber; txq++) { + val = Mvpp2Read(port->priv, + MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq)); + size = val & MVPP2_TXQ_TOKEN_SIZE_MAX; + + if (size < mtu) { + size = mtu; + val &= ~MVPP2_TXQ_TOKEN_SIZE_MAX; + val |= size; + Mvpp2Write(port->priv, + MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq), + val); + } + } +} + +/* Set the number of packets that will be received before Rx INT32errupt + * will be generated by HW. + */ +VOID Mvpp2RxPktsCoalSet(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, UINT32 pkts) +{ + UINT32 val; + + val = (pkts & MVPP2_OCCUPIED_THRESH_MASK); + Mvpp2Write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id); + Mvpp2Write(port->priv, MVPP2_RXQ_THRESH_REG, val); + + rxq->PktsCoal = pkts; +} + +/* Set the time delay in usec before Rx INT32errupt */ +VOID Mvpp2RxTimeCoalSet(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, UINT32 usec) +{ + UINT32 val; + + val = (port->priv->tclk / MVPP2_USEC_PER_SEC) * usec; + Mvpp2Write(port->priv, MVPP2_ISR_RX_THRESHOLD_REG(rxq->id), val); + + rxq->TimeCoal = usec; +} + +/* Rx/Tx queue initialization/cleanup methods */ + +VOID Mvpp2RxqHwInit(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq) +{ + rxq->LastDesc = rxq->size - 1; + + /* Zero occupied and non-occupied counters - direct access */ + Mvpp2Write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0); + + /* Set Rx descriptors queue starting address - indirect access */ + Mvpp2Write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id); +#ifdef MVPP2_V1 + Mvpp2Write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, + rxq->DescsPhys >> MVPP21_DESC_ADDR_SHIFT); +#else + Mvpp2Write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, + rxq->DescsPhys >> MVPP22_DESC_ADDR_SHIFT); +#endif + Mvpp2Write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, rxq->size); + Mvpp2Write(port->priv, MVPP2_RXQ_INDEX_REG, 0); + + /* Set Offset */ + Mvpp2RxqOffsetSet(port, rxq->id, MVPP2_RXQ_OFFSET); + + /* Set coalescing pkts and time */ + Mvpp2RxPktsCoalSet(port, rxq, MVPP2_RX_COAL_PKTS); + Mvpp2RxTimeCoalSet(port, rxq, rxq->TimeCoal); + + /* Add number of descriptors ready for receiving packets */ + Mvpp2RxqStatusUpdate(port, rxq->id, 0, rxq->size); +} + +/* Push packets received by the RXQ to BM pool */ +VOID Mvpp2RxqDropPkts(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, + INT32 cpu) +{ + INT32 RxReceived; + + RxReceived = Mvpp2RxqReceived(port, rxq->id); + if (!RxReceived) + return; + +#ifdef MVPP2_V1 + INT32 i; + for (i = 0; i < RxReceived; i++) { + MVPP2_RX_DESC *RxDesc = Mvpp2RxqNextDescGet(rxq); + UINT32 bm = Mvpp2BmCookieBuild(RxDesc, cpu); + + Mvpp2PoolRefill(port, bm, RxDesc->BufPhysAddr, + RxDesc->BufCookie); + } +#endif + Mvpp2RxqStatusUpdate(port, rxq->id, RxReceived, RxReceived); +} + +VOID Mvpp2RxqHwDeinit(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq) +{ + rxq->descs = MVPP2_NULL; + rxq->LastDesc = 0; + rxq->NextDescToProc = 0; + rxq->DescsPhys = 0; + + /* Clear Rx descriptors queue starting address and size; + * free descriptor number + */ + Mvpp2Write(port->priv, MVPP2_RXQ_STATUS_REG(rxq->id), 0); + Mvpp2Write(port->priv, MVPP2_RXQ_NUM_REG, rxq->id); + Mvpp2Write(port->priv, MVPP2_RXQ_DESC_ADDR_REG, 0); + Mvpp2Write(port->priv, MVPP2_RXQ_DESC_SIZE_REG, 0); +} + +VOID Mvpp2TxqHwInit(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq) +{ + INT32 desc, DescPerTxq, TxPortNum; + UINT32 val; + + txq->LastDesc = txq->size - 1; + + /* Set Tx descriptors queue starting address - indirect access */ + Mvpp2Write(port->priv, MVPP2_TXQ_NUM_REG, txq->id); + Mvpp2Write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, txq->DescsPhys); + Mvpp2Write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, txq->size & + MVPP2_TXQ_DESC_SIZE_MASK); + Mvpp2Write(port->priv, MVPP2_TXQ_INDEX_REG, 0); + Mvpp2Write(port->priv, MVPP2_TXQ_RSVD_CLR_REG, + txq->id << MVPP2_TXQ_RSVD_CLR_OFFSET); + val = Mvpp2Read(port->priv, MVPP2_TXQ_PENDING_REG); + val &= ~MVPP2_TXQ_PENDING_MASK; + Mvpp2Write(port->priv, MVPP2_TXQ_PENDING_REG, val); + + /* Calculate base address in prefetch buffer. We reserve 16 descriptors + * for each existing TXQ. + * TCONTS for PON port must be continuous from 0 to MVPP2_MAX_TCONT + * GBE ports assumed to be continious from 0 to MVPP2_MAX_PORTS + */ + DescPerTxq = 16; + desc = (port->id * MVPP2_MAX_TXQ * DescPerTxq) + + (txq->LogId * DescPerTxq); + + Mvpp2Write(port->priv, MVPP2_TXQ_PREF_BUF_REG, + MVPP2_PREF_BUF_PTR(desc) | MVPP2_PREF_BUF_SIZE_16 | + MVPP2_PREF_BUF_THRESH(DescPerTxq/2)); + + /* WRR / EJP configuration - indirect access */ + TxPortNum = Mvpp2EgressPort(port); + Mvpp2Write(port->priv, MVPP2_TXP_SCHED_PORT_INDEX_REG, TxPortNum); + + val = Mvpp2Read(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->LogId)); + val &= ~MVPP2_TXQ_REFILL_PERIOD_ALL_MASK; + val |= MVPP2_TXQ_REFILL_PERIOD_MASK(1); + val |= MVPP2_TXQ_REFILL_TOKENS_ALL_MASK; + Mvpp2Write(port->priv, MVPP2_TXQ_SCHED_REFILL_REG(txq->LogId), val); + + val = MVPP2_TXQ_TOKEN_SIZE_MAX; + Mvpp2Write(port->priv, MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(txq->LogId), + val); +} + +VOID Mvpp2TxqHwDeinit(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq) +{ + txq->descs = MVPP2_NULL; + txq->LastDesc = 0; + txq->NextDescToProc = 0; + txq->DescsPhys = 0; + + /* Set minimum bandwidth for disabled TXQs */ + Mvpp2Write(port->priv, MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(txq->id), 0); + + /* Set Tx descriptors queue starting address and size */ + Mvpp2Write(port->priv, MVPP2_TXQ_NUM_REG, txq->id); + Mvpp2Write(port->priv, MVPP2_TXQ_DESC_ADDR_REG, 0); + Mvpp2Write(port->priv, MVPP2_TXQ_DESC_SIZE_REG, 0); +} + +/* Allocate and initialize descriptors for aggr TXQ */ +VOID Mvpp2AggrTxqHwInit(MVPP2_TX_QUEUE *AggrTxq, + INT32 DescNum, INT32 cpu, + MVPP2_SHARED *priv) +{ + AggrTxq->LastDesc = AggrTxq->size - 1; + + /* Aggr TXQ no reset WA */ + AggrTxq->NextDescToProc = Mvpp2Read(priv, + MVPP2_AGGR_TXQ_INDEX_REG(cpu)); + + /* Set Tx descriptors queue starting address */ + /* indirect access */ +#ifndef MVPP2_V1 + Mvpp2Write(priv, MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu), AggrTxq->DescsPhys + >> MVPP22_DESC_ADDR_SHIFT); +#else + Mvpp2Write(priv, MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu), AggrTxq->DescsPhys + >> MVPP21_DESC_ADDR_SHIFT); +#endif + Mvpp2Write(priv, MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu), DescNum + & MVPP2_AGGR_TXQ_DESC_SIZE_MASK); + +} + +/* Enable gmac */ +VOID Mvpp2PortPowerUp(PP2DXE_PORT *port) +{ + Mvpp2PortMiiSet(port); + Mvpp2PortPeriodicXonDisable(port); + Mvpp2PortFcAdvEnable(port); + Mvpp2PortReset(port); +} + +/* Initialize Rx FIFO's */ +VOID Mvpp2RxFifoInit(MVPP2_SHARED *priv) +{ + INT32 port; + + for (port = 0; port < MVPP2_MAX_PORTS; port++) { + Mvpp2Write(priv, MVPP2_RX_DATA_FIFO_SIZE_REG(port), + MVPP2_RX_FIFO_PORT_DATA_SIZE); + Mvpp2Write(priv, MVPP2_RX_ATTR_FIFO_SIZE_REG(port), + MVPP2_RX_FIFO_PORT_ATTR_SIZE); + } + + Mvpp2Write(priv, MVPP2_RX_MIN_PKT_SIZE_REG, + MVPP2_RX_FIFO_PORT_MIN_PKT); + Mvpp2Write(priv, MVPP2_RX_FIFO_INIT_REG, 0x1); +} + +VOID MvGop110NetcActivePort(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_1); + reg &= ~(NETC_PORTS_ACTIVE_MASK(port)); + + val <<= NETC_PORTS_ACTIVE_OFFSET(port); + val &= NETC_PORTS_ACTIVE_MASK(port); + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_1, reg); +} + +STATIC VOID MvGop110NetcXauiEnable(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, SD1_CONTROL_1_REG); + reg &= ~SD1_CONTROL_XAUI_EN_MASK; + + val <<= SD1_CONTROL_XAUI_EN_OFFSET; + val &= SD1_CONTROL_XAUI_EN_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, SD1_CONTROL_1_REG, reg); +} + +STATIC VOID MvGop110NetcRxaui0Enable(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, SD1_CONTROL_1_REG); + reg &= ~SD1_CONTROL_RXAUI0_L23_EN_MASK; + + val <<= SD1_CONTROL_RXAUI0_L23_EN_OFFSET; + val &= SD1_CONTROL_RXAUI0_L23_EN_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, SD1_CONTROL_1_REG, reg); +} + +STATIC VOID MvGop110NetcRxaui1Enable(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, SD1_CONTROL_1_REG); + reg &= ~SD1_CONTROL_RXAUI1_L45_EN_MASK; + + val <<= SD1_CONTROL_RXAUI1_L45_EN_OFFSET; + val &= SD1_CONTROL_RXAUI1_L45_EN_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, SD1_CONTROL_1_REG, reg); +} + +STATIC VOID MvGop110NetcMiiMode(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_CONTROL_0); + reg &= ~NETC_GBE_PORT1_MII_MODE_MASK; + + val <<= NETC_GBE_PORT1_MII_MODE_OFFSET; + val &= NETC_GBE_PORT1_MII_MODE_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_CONTROL_0, reg); +} + +STATIC VOID MvGop110NetcGopReset(PP2DXE_PORT *Pp2Port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_GOP_SOFT_RESET_1_REG); + reg &= ~NETC_GOP_SOFT_RESET_MASK; + + val <<= NETC_GOP_SOFT_RESET_OFFSET; + val &= NETC_GOP_SOFT_RESET_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_GOP_SOFT_RESET_1_REG, reg); +} + +STATIC VOID MvGop110NetcGopClockLogicSet(PP2DXE_PORT *Pp2Port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0); + reg &= ~NETC_CLK_DIV_PHASE_MASK; + + val <<= NETC_CLK_DIV_PHASE_OFFSET; + val &= NETC_CLK_DIV_PHASE_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0, reg); +} + +STATIC VOID MvGop110NetcPortRfReset(PP2DXE_PORT *Pp2Port, UINT32 port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_1); + reg &= ~(NETC_PORT_GIG_RF_RESET_MASK(port)); + + val <<= NETC_PORT_GIG_RF_RESET_OFFSET(port); + val &= NETC_PORT_GIG_RF_RESET_MASK(port); + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_1, reg); +} + +STATIC VOID MvGop110NetcGbeSgmiiModeSelect(PP2DXE_PORT *Pp2Port, UINT32 port, + UINT32 val) +{ + UINT32 reg, mask, offset; + + if (port == 2) { + mask = NETC_GBE_PORT0_SGMII_MODE_MASK; + offset = NETC_GBE_PORT0_SGMII_MODE_OFFSET; + } else { + mask = NETC_GBE_PORT1_SGMII_MODE_MASK; + offset = NETC_GBE_PORT1_SGMII_MODE_OFFSET; + } + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_CONTROL_0); + reg &= ~mask; + + val <<= offset; + val &= mask; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_CONTROL_0, reg); +} + +STATIC VOID MvGop110NetcBusWidthSelect(PP2DXE_PORT *Pp2Port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0); + reg &= ~NETC_BUS_WIDTH_SELECT_MASK; + + val <<= NETC_BUS_WIDTH_SELECT_OFFSET; + val &= NETC_BUS_WIDTH_SELECT_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0, reg); +} + +STATIC VOID MvGop110NetcSampleStagesTiming(PP2DXE_PORT *Pp2Port, UINT32 val) +{ + UINT32 reg; + + reg = Mvpp2Rfu1Read(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0); + reg &= ~NETC_GIG_RX_DATA_SAMPLE_MASK; + + val <<= NETC_GIG_RX_DATA_SAMPLE_OFFSET; + val &= NETC_GIG_RX_DATA_SAMPLE_MASK; + + reg |= val; + + Mvpp2Rfu1Write(Pp2Port->priv, MV_NETCOMP_PORTS_CONTROL_0, reg); +} + +STATIC VOID MvGop110NetcMacToXgmii(PP2DXE_PORT *Pp2Port, UINT32 port, + enum MvNetcPhase phase) +{ + switch (phase) { + case MV_NETC_FIRST_PHASE: + /* Set Bus Width to HB mode = 1 */ + MvGop110NetcBusWidthSelect(Pp2Port, 1); + /* Select RGMII mode */ + MvGop110NetcGbeSgmiiModeSelect(Pp2Port, port, + MV_NETC_GBE_XMII); + break; + case MV_NETC_SECOND_PHASE: + /* De-assert the relevant port HB reset */ + MvGop110NetcPortRfReset(Pp2Port, port, 1); + break; + } +} + +STATIC VOID MvGop110NetcMacToSgmii(PP2DXE_PORT *Pp2Port, UINT32 port, + enum MvNetcPhase phase) +{ + switch (phase) { + case MV_NETC_FIRST_PHASE: + /* Set Bus Width to HB mode = 1 */ + MvGop110NetcBusWidthSelect(Pp2Port, 1); + /* Select SGMII mode */ + if (port >= 1) + MvGop110NetcGbeSgmiiModeSelect(Pp2Port, port, + MV_NETC_GBE_SGMII); + + /* Configure the sample stages */ + MvGop110NetcSampleStagesTiming(Pp2Port, 0); + /* Configure the ComPhy Selector */ + /* MvGop110NetcComPhySelectorConfig(netComplex); */ + break; + case MV_NETC_SECOND_PHASE: + /* De-assert the relevant port HB reset */ + MvGop110NetcPortRfReset(Pp2Port, port, 1); + break; + } +} + +STATIC VOID MvGop110NetcMacToRxaui(PP2DXE_PORT *Pp2Port, UINT32 port, + enum MvNetcPhase phase, + enum MvNetcLanes lanes) +{ + /* Currently only RXAUI0 supported */ + if (port != 0) + return; + + switch (phase) { + case MV_NETC_FIRST_PHASE: + /* RXAUI Serdes/s Clock alignment */ + if (lanes == MV_NETC_LANE_23) + MvGop110NetcRxaui0Enable(Pp2Port, port, 1); + else + MvGop110NetcRxaui1Enable(Pp2Port, port, 1); + break; + case MV_NETC_SECOND_PHASE: + /* De-assert the relevant port HB reset */ + MvGop110NetcPortRfReset(Pp2Port, port, 1); + break; + } +} + +STATIC VOID MvGop110NetcMacToXaui(PP2DXE_PORT *Pp2Port, UINT32 port, + enum MvNetcPhase phase) +{ + switch (phase) { + case MV_NETC_FIRST_PHASE: + /* RXAUI Serdes/s Clock alignment */ + MvGop110NetcXauiEnable(Pp2Port, port, 1); + break; + case MV_NETC_SECOND_PHASE: + /* De-assert the relevant port HB reset */ + MvGop110NetcPortRfReset(Pp2Port, port, 1); + break; + } +} + +INT32 MvGop110NetcInit(PP2DXE_PORT *Pp2Port, + UINT32 NetCompConfig, enum MvNetcPhase phase) +{ + UINT32 c = NetCompConfig; + + if (c & MV_NETC_GE_MAC0_RXAUI_L23) + MvGop110NetcMacToRxaui(Pp2Port, 0, phase, MV_NETC_LANE_23); + + if (c & MV_NETC_GE_MAC0_RXAUI_L45) + MvGop110NetcMacToRxaui(Pp2Port, 0, phase, MV_NETC_LANE_45); + + if (c & MV_NETC_GE_MAC0_XAUI) + MvGop110NetcMacToXaui(Pp2Port, 0, phase); + + if (c & MV_NETC_GE_MAC2_SGMII) + MvGop110NetcMacToSgmii(Pp2Port, 2, phase); + else + MvGop110NetcMacToXgmii(Pp2Port, 2, phase); + if (c & MV_NETC_GE_MAC3_SGMII) + MvGop110NetcMacToSgmii(Pp2Port, 3, phase); + else { + MvGop110NetcMacToXgmii(Pp2Port, 3, phase); + if (c & MV_NETC_GE_MAC3_RGMII) + MvGop110NetcMiiMode(Pp2Port, 3, MV_NETC_GBE_RGMII); + else + MvGop110NetcMiiMode(Pp2Port, 3, MV_NETC_GBE_MII); + } + + /* Activate gop ports 0, 2, 3 */ + MvGop110NetcActivePort(Pp2Port, 0, 1); + MvGop110NetcActivePort(Pp2Port, 2, 1); + MvGop110NetcActivePort(Pp2Port, 3, 1); + + if (phase == MV_NETC_SECOND_PHASE) { + /* Enable the GOP internal clock logic */ + MvGop110NetcGopClockLogicSet(Pp2Port, 1); + /* De-assert GOP unit reset */ + MvGop110NetcGopReset(Pp2Port, 1); + } + return 0; +} +UINT32 MvpPp2xGop110NetcCfgCreate(PP2DXE_PORT *Pp2Port) +{ + UINT32 val = 0; + + if (Pp2Port->GopIndex == 0) { + if (Pp2Port->PhyInterface == + MV_MODE_XAUI) + val |= MV_NETC_GE_MAC0_XAUI; + else if (Pp2Port->PhyInterface == + MV_MODE_RXAUI) + val |= MV_NETC_GE_MAC0_RXAUI_L23; + } + if (Pp2Port->GopIndex == 2) { + if (Pp2Port->PhyInterface == + MV_MODE_SGMII) + val |= MV_NETC_GE_MAC2_SGMII; + } + if (Pp2Port->GopIndex == 3) { + if (Pp2Port->PhyInterface == + MV_MODE_SGMII) + val |= MV_NETC_GE_MAC3_SGMII; + else if (Pp2Port->PhyInterface == + MV_MODE_RGMII) + val |= MV_NETC_GE_MAC3_RGMII; + } + + return val; +} + +/* +* MvPortInit +* Init physical port. Configures the port mode and all it's elements +* accordingly. +* Does not verify that the selected mode/port number is valid at the +* core level. +*/ +INT32 MvGop110PortInit(PP2DXE_PORT *Pp2Port) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + MvGop110GmacReset(Pp2Port, RESET); + /* configure PCS */ + MvGop110GpcsModeCfg(Pp2Port, FALSE); + MvGop110BypassClkCfg(Pp2Port, TRUE); + + /* configure MAC */ + MvGop110GmacModeCfg(Pp2Port); + /* pcs unreset */ + MvGop110GpcsReset(Pp2Port, UNRESET); + /* mac unreset */ + MvGop110GmacReset(Pp2Port, UNRESET); + break; + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + /* configure PCS */ + MvGop110GpcsModeCfg(Pp2Port, TRUE); + + /* configure MAC */ + MvGop110GmacModeCfg(Pp2Port); + /* select proper Mac mode */ + MvGop110Xlg2GigMacCfg(Pp2Port); + + /* pcs unreset */ + MvGop110GpcsReset(Pp2Port, UNRESET); + /* mac unreset */ + MvGop110GmacReset(Pp2Port, UNRESET); + break; + default: + return -1; + } + + return 0; +} + +/* Set the MAC to reset or exit from reset */ +INT32 MvGop110GmacReset(PP2DXE_PORT *Pp2Port, enum MvReset reset) +{ + UINT32 RegAddr; + UINT32 val; + + RegAddr = MVPP2_PORT_CTRL2_REG; + + /* read - modify - write */ + val = MvGop110GmacRead(Pp2Port, RegAddr); + if (reset == RESET) + val |= MVPP2_PORT_CTRL2_PORTMACRESET_MASK; + else + val &= ~MVPP2_PORT_CTRL2_PORTMACRESET_MASK; + MvGop110GmacWrite(Pp2Port, RegAddr, val); + + return 0; +} +/* +* MvGop110GpcsModeCfg +*Configure port to working with Gig PCS or don't. +*/ +INT32 MvGop110GpcsModeCfg(PP2DXE_PORT *Pp2Port, BOOLEAN en) +{ + UINT32 val; + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + + if (en) + val |= MVPP2_PORT_CTRL2_PCS_EN_MASK; + else + val &= ~MVPP2_PORT_CTRL2_PCS_EN_MASK; + + /* enable / disable PCS on this port */ + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + return 0; +} + +INT32 MvGop110BypassClkCfg(PP2DXE_PORT *Pp2Port, BOOLEAN en) +{ + UINT32 val; + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + + if (en) + val |= MVPP2_PORT_CTRL2_CLK_125_BYPS_EN_MASK; + else + val &= ~MVPP2_PORT_CTRL2_CLK_125_BYPS_EN_MASK; + + /* enable / disable PCS on this port */ + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + return 0; +} + +INT32 MvGop110GpcsReset(PP2DXE_PORT *Pp2Port, enum MvReset act) +{ + UINT32 RegData; + + RegData = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + if (act == RESET) + U32_SET_FIELD(RegData, MVPP2_PORT_CTRL2_SGMII_MODE_MASK, 0); + else + U32_SET_FIELD(RegData, MVPP2_PORT_CTRL2_SGMII_MODE_MASK, + 1 << MVPP2_PORT_CTRL2_SGMII_MODE_OFFS); + + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, RegData); + return 0; +} + +VOID MvGop110Xlg2GigMacCfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegVal; + + /* relevant only for MAC0 (XLG0 and GMAC0) */ + if (Pp2Port->GopIndex > 0) + return; + + /* configure 1Gig MAC mode */ + RegVal = Mvpp2XlgRead(Pp2Port, + MV_XLG_PORT_MAC_CTRL3_REG); + U32_SET_FIELD(RegVal, MV_XLG_MAC_CTRL3_MACMODESELECT_MASK, + (0 << MV_XLG_MAC_CTRL3_MACMODESELECT_OFFS)); + Mvpp2XlgWrite(Pp2Port, MV_XLG_PORT_MAC_CTRL3_REG, + RegVal); +} +/* Set the internal mux's to the required MAC in the GOP */ +INT32 MvGop110GmacModeCfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegAddr; + UINT32 val; + + /* Set TX FIFO thresholds */ + switch (Pp2Port->PhyInterface) { + case MV_MODE_SGMII: + if (Pp2Port->speed == MV_PORT_SPEED_2500) + MvGop110GmacSgmii25Cfg(Pp2Port); + else + MvGop110GmacSgmiiCfg(Pp2Port); + break; + case MV_MODE_RGMII: + MvGop110GmacRgmiiCfg(Pp2Port); + break; + case MV_MODE_QSGMII: + MvGop110GmacQsgmiiCfg(Pp2Port); + break; + default: + return -1; + } + + /* Jumbo frame support - 0x1400*2= 0x2800 bytes */ + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + U32_SET_FIELD(val, MVPP2_PORT_CTRL0_FRAMESIZELIMIT_MASK, + (0x1400 << MVPP2_PORT_CTRL0_FRAMESIZELIMIT_OFFS)); + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, val); + + /* PeriodicXonEn disable */ + RegAddr = MVPP2_PORT_CTRL1_REG; + val = MvGop110GmacRead(Pp2Port, RegAddr); + val &= ~MVPP2_PORT_CTRL1_EN_PERIODIC_FC_XON_MASK; + MvGop110GmacWrite(Pp2Port, RegAddr, val); + + /* mask all ports interrupts */ + MvGop110GmacPortLinkEventMask(Pp2Port); + +#if MV_PP2x_INTERRUPT + /* unmask link change interrupt */ + val = MvGop110GmacRead(Pp2Port, MVPP2_INTERRUPT_MASK_REG); + val |= MVPP2_INTERRUPT_CAUSE_LINK_CHANGE_MASK; + val |= 1; /* unmask summary bit */ + MvGop110GmacWrite(Pp2Port, MVPP2_INTERRUPT_MASK_REG, val); +#endif + return 0; +} + +VOID MvGop110GmacRgmiiCfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 val, thresh, an; + + /*configure minimal level of the Tx FIFO before the lower part starts to read a packet*/ + thresh = MV_RGMII_TX_FIFO_MIN_TH; + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG); + U32_SET_FIELD(val, MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_MASK, + (thresh << MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS)); + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG, val); + + /* Disable bypass of sync module */ + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL4_REG); + val |= MVPP2_PORT_CTRL4_SYNC_BYPASS_MASK; + /* configure DP clock select according to mode */ + val &= ~MVPP2_PORT_CTRL4_DP_CLK_SEL_MASK; + val |= MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_MASK; + val |= MVPP2_PORT_CTRL4_EXT_PIN_GMII_SEL_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL4_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + val &= ~MVPP2_PORT_CTRL2_DIS_PADING_OFFS; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + /* configure GIG MAC to SGMII mode */ + val &= ~MVPP2_PORT_CTRL0_PORTTYPE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, val); + + /* configure AN 0xb8e8 */ + an = MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_AUTO_NEG_CFG_REG, an); +} +VOID MvGop110GmacSgmii25Cfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 val, thresh, an; + + /*configure minimal level of the Tx FIFO before the lower part starts to read a packet*/ + thresh = MV_SGMII2_5_TX_FIFO_MIN_TH; + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG); + U32_SET_FIELD(val, MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_MASK, + (thresh << MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS)); + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG, val); + + /* Disable bypass of sync module */ + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL4_REG); + val |= MVPP2_PORT_CTRL4_SYNC_BYPASS_MASK; + /* configure DP clock select according to mode */ + val |= MVPP2_PORT_CTRL4_DP_CLK_SEL_MASK; + /* configure QSGMII bypass according to mode */ + val |= MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL4_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + val |= MVPP2_PORT_CTRL2_DIS_PADING_OFFS; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + /* configure GIG MAC to 1000Base-X mode connected to a fiber transceiver */ + val |= MVPP2_PORT_CTRL0_PORTTYPE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, val); + + /* configure AN 0x9268 */ + an = MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_MASK | + MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_MASK | + MVPP2_PORT_AUTO_NEG_CFG_ADV_PAUSE_MASK | + MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_MASK | + MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_AUTO_NEG_CFG_REG, an); +} +VOID MvGop110GmacSgmiiCfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 val, thresh, an; + + /*configure minimal level of the Tx FIFO before the lower part starts to read a packet*/ + thresh = MV_SGMII_TX_FIFO_MIN_TH; + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG); + U32_SET_FIELD(val, MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_MASK, + (thresh << MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS)); + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG, val); + + /* Disable bypass of sync module */ + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL4_REG); + val |= MVPP2_PORT_CTRL4_SYNC_BYPASS_MASK; + /* configure DP clock select according to mode */ + val &= ~MVPP2_PORT_CTRL4_DP_CLK_SEL_MASK; + /* configure QSGMII bypass according to mode */ + val |= MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL4_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + val |= MVPP2_PORT_CTRL2_DIS_PADING_OFFS; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + /* configure GIG MAC to SGMII mode */ + val &= ~MVPP2_PORT_CTRL0_PORTTYPE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, val); + + /* configure AN */ + an = MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_AUTO_NEG_CFG_REG, an); +} + +VOID MvGop110GmacQsgmiiCfg(PP2DXE_PORT *Pp2Port) +{ + UINT32 val, thresh, an; + + /*configure minimal level of the Tx FIFO before the lower part starts to read a packet*/ + thresh = MV_SGMII_TX_FIFO_MIN_TH; + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG); + U32_SET_FIELD(val, MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_MASK, + (thresh << MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS)); + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_FIFO_CFG_1_REG, val); + + /* Disable bypass of sync module */ + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL4_REG); + val |= MVPP2_PORT_CTRL4_SYNC_BYPASS_MASK; + /* configure DP clock select according to mode */ + val &= ~MVPP2_PORT_CTRL4_DP_CLK_SEL_MASK; + val &= ~MVPP2_PORT_CTRL4_EXT_PIN_GMII_SEL_MASK; + /* configure QSGMII bypass according to mode */ + val &= ~MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL4_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL2_REG); + val &= ~MVPP2_PORT_CTRL2_DIS_PADING_OFFS; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL2_REG, val); + + val = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + /* configure GIG MAC to SGMII mode */ + val &= ~MVPP2_PORT_CTRL0_PORTTYPE_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, val); + + /* configure AN 0xB8EC */ + an = MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK | + MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_MASK; + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_AUTO_NEG_CFG_REG, an); +} +/* +* MvGopPhyAddrCfg +*/ +INT32 Mvpp2SmiPhyAddrCfg(PP2DXE_PORT *Pp2Port, INT32 port, INT32 addr) +{ + Mvpp2SmiWrite(Pp2Port->priv, MV_SMI_PHY_ADDRESS_REG(port), addr); + + return 0; +} +BOOLEAN MvGop110PortIsLinkUp(PP2DXE_PORT *Pp2Port) +{ + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + return MvGop110GmacLinkStatusGet(Pp2Port); + break; + case MV_MODE_XAUI: + case MV_MODE_RXAUI: + gBS->Stall(1000); +// return MvGop110XlgMacLinkStatusGet(Pp2Port); + return FALSE; + break; + default: + return FALSE; + } +} +/* Get MAC link status */ +BOOLEAN MvGop110GmacLinkStatusGet(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegAddr; + UINT32 val; + + RegAddr = MVPP2_PORT_STATUS0_REG; + + val = MvGop110GmacRead(Pp2Port, RegAddr); + return (val & 1) ? TRUE : FALSE; +} + +/* BM */ +INTN Mvpp2BmPoolCtrl(MVPP2_SHARED *pp2, INTN pool, enum Mvpp2Command cmd) +{ + UINT32 RegVal = 0; + RegVal = Mvpp2Read(pp2, MVPP2_BM_POOL_CTRL_REG(pool)); + + switch (cmd) { + case MVPP2_START: + RegVal |= MVPP2_BM_START_MASK; + break; + + case MVPP2_STOP: + RegVal |= MVPP2_BM_STOP_MASK; + break; + + default: + return -1; + } + Mvpp2Write(pp2, MVPP2_BM_POOL_CTRL_REG(pool), RegVal); + + return 0; +} + +VOID MvGop110PortDisable(PP2DXE_PORT *Pp2Port) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + MvGop110GmacPortDisable(Pp2Port); + break; +/* + case MV_MODE_XAUI: + case MV_MODE_RXAUI: + MvGop110XlgMacPortDisable(gop, PortNum); + break; + */ + + default: + return; + } +} + +VOID MvGop110PortEnable(PP2DXE_PORT *Pp2Port) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + MvGop110GmacPortEnable(Pp2Port); + break; +/* + case MV_MODE_XAUI: + case MV_MODE_RXAUI: + MvGop110XlgMacPortDisable(gop, PortNum); + break; + */ + + default: + return; + } +} + +/* Enable port and MIB counters */ +VOID MvGop110GmacPortEnable(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegVal; + + RegVal = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + RegVal |= MVPP2_PORT_CTRL0_PORTEN_MASK; + RegVal |= MVPP2_PORT_CTRL0_COUNT_EN_MASK; + + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, RegVal); +} + +/* Disable port */ +VOID MvGop110GmacPortDisable(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegVal; + + /* mask all ports interrupts */ + MvGop110GmacPortLinkEventMask(Pp2Port); + + RegVal = MvGop110GmacRead(Pp2Port, MVPP2_PORT_CTRL0_REG); + RegVal &= ~MVPP2_PORT_CTRL0_PORTEN_MASK; + + MvGop110GmacWrite(Pp2Port, MVPP2_PORT_CTRL0_REG, RegVal); +} + +VOID MvGop110GmacPortLinkEventMask(PP2DXE_PORT *Pp2Port) +{ + UINT32 RegVal; + + RegVal = MvGop110GmacRead(Pp2Port, + MV_GMAC_INTERRUPT_SUM_MASK_REG); + RegVal &= ~MV_GMAC_INTERRUPT_SUM_CAUSE_LINK_CHANGE_MASK; + MvGop110GmacWrite(Pp2Port, MV_GMAC_INTERRUPT_SUM_MASK_REG, + RegVal); +} + +INT32 MvGop110PortEventsMask(PP2DXE_PORT *Pp2Port) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + MvGop110GmacPortLinkEventMask(Pp2Port); + break; + default: + return -1; + } + return 0; +} + +INT32 MvGop110FlCfg(PP2DXE_PORT *Pp2Port) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + /* disable AN */ + MvGop110SpeedDuplexSet(Pp2Port, Pp2Port->speed, + MV_PORT_DUPLEX_FULL); + break; + + case MV_MODE_XAUI: + case MV_MODE_RXAUI: + return 0; + + default: + return -1; + } + return 0; +} +/* set port speed and duplex */ +INT32 MvGop110SpeedDuplexSet(PP2DXE_PORT *Pp2Port, + INT32 speed, enum MvPortDuplex duplex) +{ + + switch (Pp2Port->PhyInterface) { + case MV_MODE_RGMII: + case MV_MODE_SGMII: + case MV_MODE_QSGMII: + MvGop110GmacSpeedDuplexSet(Pp2Port, speed, duplex); + break; + + case MV_MODE_XAUI: + case MV_MODE_RXAUI: + break; + + default: + return -1; + } + return 0; +} + +/* Sets port speed to Auto Negotiation / 1000 / 100 / 10 Mbps. +* Sets port duplex to Auto Negotiation / Full / Half Duplex. +*/ +INT32 MvGop110GmacSpeedDuplexSet(PP2DXE_PORT *Pp2Port, + INT32 speed, enum MvPortDuplex duplex) +{ + UINT32 RegVal; + + RegVal = Mvpp2GmacRead(Pp2Port, + MVPP2_PORT_AUTO_NEG_CFG_REG); + + switch (speed) { + case MV_PORT_SPEED_2500: + case MV_PORT_SPEED_1000: + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK; + RegVal |= MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_MASK; + /* the 100/10 bit doesn't matter in this case */ + break; + case MV_PORT_SPEED_100: + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK; + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_MASK; + RegVal |= MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_MASK; + break; + case MV_PORT_SPEED_10: + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK; + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_MASK; + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_MASK; + break; + default: + return MVPP2_EINVAL; + } + + switch (duplex) { + case MV_PORT_DUPLEX_AN: + RegVal |= MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK; + /* the other bits don't matter in this case */ + break; + case MV_PORT_DUPLEX_HALF: + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK; + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_MASK; + break; + case MV_PORT_DUPLEX_FULL: + RegVal &= ~MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK; + RegVal |= MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_MASK; + break; + default: + return MVPP2_EINVAL; + } + + Mvpp2GmacWrite(Pp2Port, MVPP2_PORT_AUTO_NEG_CFG_REG, + RegVal); + return 0; +} + +VOID Mvpp2AxiConfig(MVPP2_SHARED *pp2) +{ + /* Config AXI Read&Write Normal and Soop mode */ + Mvpp2Write(pp2, MVPP22_AXI_BM_WR_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_BM_RD_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_AGGRQ_DESCR_RD_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_TXQ_DESCR_WR_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_TXQ_DESCR_RD_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_RXQ_DESCR_WR_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_RX_DATA_WR_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); + Mvpp2Write(pp2, MVPP22_AXI_TX_DATA_RD_ATTR_REG, + MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT); +} + +/* Cleanup Tx ports */ +VOID Mvpp2TxpClean(PP2DXE_PORT *pp, INT32 txp, + MVPP2_TX_QUEUE *txq) +{ + INT32 delay, pending; + UINT32 RegVal; + + Mvpp2Write(pp->priv, MVPP2_TXQ_NUM_REG, txq->id); + RegVal = Mvpp2Read(pp->priv, MVPP2_TXQ_PREF_BUF_REG); + RegVal |= MVPP2_TXQ_DRAIN_EN_MASK; + Mvpp2Write(pp->priv, MVPP2_TXQ_PREF_BUF_REG, RegVal); + + /* The napi queue has been stopped so wait for all packets + * to be transmitted. + */ + delay = 0; + do { + if (delay >= MVPP2_TX_PENDING_TIMEOUT_MSEC) { + Mvpp2Printf("port %d: cleaning queue %d timed out\n", + pp->id, txq->LogId); + break; + } + Mvpp2Mdelay(1); + delay++; + + pending = Mvpp2TxqPendDescNumGet(pp, txq); + } while (pending); + + RegVal &= ~MVPP2_TXQ_DRAIN_EN_MASK; + Mvpp2Write(pp->priv, MVPP2_TXQ_PREF_BUF_REG, RegVal); +} + +/* Cleanup all Tx queues */ +VOID Mvpp2CleanupTxqs(PP2DXE_PORT *pp) +{ + MVPP2_TX_QUEUE *txq; + INT32 txp, queue; + UINT32 RegVal; + + RegVal = Mvpp2Read(pp->priv, MVPP2_TX_PORT_FLUSH_REG); + + /* Reset Tx ports and delete Tx queues */ + for (txp = 0; txp < pp->TxpNum; txp++) { + RegVal |= MVPP2_TX_PORT_FLUSH_MASK(pp->id); + Mvpp2Write(pp->priv, MVPP2_TX_PORT_FLUSH_REG, RegVal); + + for (queue = 0; queue < TxqNumber; queue++) { + txq = &pp->txqs[txp * TxqNumber + queue]; + Mvpp2TxpClean(pp, txp, txq); + Mvpp2TxqHwDeinit(pp, txq); + } + + RegVal &= ~MVPP2_TX_PORT_FLUSH_MASK(pp->id); + Mvpp2Write(pp->priv, MVPP2_TX_PORT_FLUSH_REG, RegVal); + } +} + +/* Cleanup all Rx queues */ +VOID Mvpp2CleanupRxqs(PP2DXE_PORT *pp) +{ + INT32 queue; + + for (queue = 0; queue < RxqNumber; queue++) + Mvpp2RxqHwDeinit(pp, &pp->rxqs[queue]); +} diff --git a/Drivers/Net/Pp2Dxe/Mvpp2Lib.h b/Drivers/Net/Pp2Dxe/Mvpp2Lib.h new file mode 100644 index 0000000..911e993 --- /dev/null +++ b/Drivers/Net/Pp2Dxe/Mvpp2Lib.h @@ -0,0 +1,305 @@ +/******************************************************************************** +Copyright (C) 2016 Marvell International Ltd. + +Marvell BSD License Option + +If you received this File from Marvell, you may opt to use, redistribute and/or +modify this File under the following licensing terms. +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of Marvell nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*******************************************************************************/ + +#ifndef __MVPP2_LIB_H__ +#define __MVPP2_LIB_H__ + +#include "Mvpp2LibHw.h" +#include "Pp2Dxe.h" + +/* Number of RXQs used by single port */ +STATIC INT32 RxqNumber = 1; +/* Number of TXQs used by single port */ +STATIC INT32 TxqNumber = 1; + +VOID Mvpp2PrsMacPromiscSet(MVPP2_SHARED *priv, INT32 port, BOOLEAN add); +VOID Mvpp2PrsMacMultiSet(MVPP2_SHARED *priv, INT32 port, INT32 index, + BOOLEAN add); +INT32 Mvpp2PrsDefaultInit(MVPP2_SHARED *priv); +INT32 Mvpp2PrsMacDaAccept(MVPP2_SHARED *priv, INT32 port, + const UINT8 *da, BOOLEAN add); +VOID Mvpp2PrsMcastDelAll(MVPP2_SHARED *priv, INT32 port); +INT32 Mvpp2PrsTagModeSet(MVPP2_SHARED *priv, INT32 port, INT32 type); +INT32 Mvpp2PrsDefFlow(PP2DXE_PORT *port); +VOID Mvpp2ClsInit(MVPP2_SHARED *priv); +VOID Mvpp2ClsPortConfig(PP2DXE_PORT *port); +VOID Mvpp2ClsOversizeRxqSet(PP2DXE_PORT *port); +VOID Mvpp2BmPoolHwCreate(MVPP2_SHARED *priv, + MVPP2_BMS_POOL *BmPool, INT32 size); +VOID Mvpp2BmPoolBufsizeSet(MVPP2_SHARED *priv, + MVPP2_BMS_POOL *BmPool, + INT32 BufSize); +VOID Mvpp2BmStop(MVPP2_SHARED *priv, INT32 pool); +VOID Mvpp2BmIrqClear(MVPP2_SHARED *priv, INT32 pool); +VOID Mvpp2RxqLongPoolSet(PP2DXE_PORT *port, + INT32 lrxq, INT32 LongPool); +VOID Mvpp2RxqShortPoolSet(PP2DXE_PORT *port, + INT32 lrxq, INT32 ShortPool); +VOID Mvpp2BmPoolMcPut(PP2DXE_PORT *port, INT32 pool, + UINT32 BufPhysAddr, UINT32 BufVirtAddr, + INT32 McId); +VOID Mvpp2PoolRefill(PP2DXE_PORT *port, UINT32 bm, + UINT32 PhysAddr, UINT32 cookie); +VOID Mvpp2InterruptsMask(VOID *arg); +VOID Mvpp2InterruptsUnmask(VOID *arg); +VOID Mvpp2PortEnable(PP2DXE_PORT *port); +VOID Mvpp2PortDisable(PP2DXE_PORT *port); +VOID Mvpp2DefaultsSet(PP2DXE_PORT *port); +VOID Mvpp2IngressEnable(PP2DXE_PORT *port); +VOID Mvpp2IngressDisable(PP2DXE_PORT *port); +VOID Mvpp2EgressEnable(PP2DXE_PORT *port); +VOID Mvpp2EgressDisable(PP2DXE_PORT *port); +UINT32 Mvpp2BmCookieBuild(MVPP2_RX_DESC *RxDesc, INT32 cpu); +INT32 Mvpp2TxqDrainSet(PP2DXE_PORT *port, INT32 txq, BOOLEAN en); +INT32 Mvpp2TxqPendDescNumGet(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq); +UINT32 Mvpp2AggrTxqPendDescNumGet(MVPP2_SHARED *pp2, int cpu); +MVPP2_TX_DESC * +Mvpp2TxqNextDescGet(MVPP2_TX_QUEUE *txq); +VOID Mvpp2AggrTxqPendDescAdd(PP2DXE_PORT *port, INT32 pending); +INT32 Mvpp2AggrDescNumCheck(MVPP2_SHARED *priv, + MVPP2_TX_QUEUE *AggrTxq, + INT32 num, INT32 cpu); +INT32 Mvpp2TxqAllocReservedDesc(MVPP2_SHARED *priv, + MVPP2_TX_QUEUE *txq, INT32 num); +VOID Mvpp2TxqDescPut(MVPP2_TX_QUEUE *txq); +UINT32 Mvpp2TxqDescCsum(INT32 L3Offs, INT32 L3Proto, + INT32 IpHdrLen, INT32 L4Proto); +VOID Mvpp2TxqSentCounterClear(VOID *arg); +VOID Mvpp2GmacMaxRxSizeSet(PP2DXE_PORT *port); +VOID Mvpp2TxpMaxTxSizeSet(PP2DXE_PORT *port); +VOID Mvpp2RxPktsCoalSet(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, UINT32 pkts); +VOID Mvpp2RxTimeCoalSet(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, UINT32 usec); +VOID Mvpp2AggrTxqHwInit(MVPP2_TX_QUEUE *AggrTxq, + INT32 DescNum, INT32 cpu, + MVPP2_SHARED *priv); +VOID Mvpp2RxqHwInit(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq); +VOID Mvpp2RxqDropPkts(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq, + INT32 cpu); +VOID Mvpp2TxqHwInit(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq); +VOID Mvpp2TxqHwDeinit(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq); +VOID Mvpp2PortPowerUp(PP2DXE_PORT *port); +VOID Mvpp2RxFifoInit(MVPP2_SHARED *priv); +VOID Mvpp2RxqHwDeinit(PP2DXE_PORT *port, + MVPP2_RX_QUEUE *rxq); +UINT32 MvpPp2xGop110NetcCfgCreate(PP2DXE_PORT *Pp2Port); +INT32 MvGop110NetcInit(PP2DXE_PORT *mvport, + UINT32 NetCompConfig, enum MvNetcPhase phase); + +UINT32 MvpPp2xGop110NetcCfgCreate(PP2DXE_PORT *Pp2Port); +INT32 MvGop110PortInit(PP2DXE_PORT *Pp2Port); +INT32 MvGop110GmacReset(PP2DXE_PORT *Pp2Port, enum MvReset reset); +INT32 MvGop110GpcsModeCfg(PP2DXE_PORT *Pp2Port, BOOLEAN en); +INT32 MvGop110BypassClkCfg(PP2DXE_PORT *Pp2Port, BOOLEAN en); +INT32 MvGop110GpcsReset(PP2DXE_PORT *Pp2Port, enum MvReset act); +VOID MvGop110Xlg2GigMacCfg(PP2DXE_PORT *Pp2Port); +INT32 MvGop110GmacModeCfg(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacRgmiiCfg(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacSgmii25Cfg(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacSgmiiCfg(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacQsgmiiCfg(PP2DXE_PORT *Pp2Port); +INT32 Mvpp2SmiPhyAddrCfg(PP2DXE_PORT *Pp2Port, INT32 port, INT32 addr); +BOOLEAN MvGop110PortIsLinkUp(PP2DXE_PORT *Pp2Port); +BOOLEAN MvGop110GmacLinkStatusGet(PP2DXE_PORT *Pp2Port); +INTN Mvpp2BmPoolCtrl(MVPP2_SHARED *pp2, INTN pool, + enum Mvpp2Command cmd); +VOID MvGop110PortDisable(PP2DXE_PORT *Pp2Port); +VOID MvGop110PortEnable(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacPortEnable(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacPortDisable(PP2DXE_PORT *Pp2Port); +VOID MvGop110GmacPortLinkEventMask(PP2DXE_PORT *Pp2Port); +INT32 MvGop110PortEventsMask(PP2DXE_PORT *Pp2Port); +INT32 MvGop110FlCfg(PP2DXE_PORT *Pp2Port); +INT32 MvGop110SpeedDuplexSet(PP2DXE_PORT *Pp2Port, + INT32 speed, enum MvPortDuplex duplex); +INT32 MvGop110GmacSpeedDuplexSet(PP2DXE_PORT *Pp2Port, + INT32 speed, enum MvPortDuplex duplex); +VOID Mvpp2AxiConfig(MVPP2_SHARED *pp2); +VOID Mvpp2TxpClean(PP2DXE_PORT *pp, INT32 txp, + MVPP2_TX_QUEUE *txq); +VOID Mvpp2CleanupTxqs(PP2DXE_PORT *pp); +VOID Mvpp2CleanupRxqs(PP2DXE_PORT *pp); + +/* Get number of physical egress port */ +STATIC inline INT32 Mvpp2EgressPort(PP2DXE_PORT *port) +{ + return MVPP2_MAX_TCONT + port->id; +} + +/* Get number of physical TXQ */ +STATIC inline INT32 Mvpp2TxqPhys(INT32 port, INT32 txq) +{ + return (MVPP2_MAX_TCONT + port) * MVPP2_MAX_TXQ + txq; +} + +/* Set pool number in a BM cookie */ +STATIC inline UINT32 Mvpp2BmCookiePoolSet(UINT32 cookie, INT32 pool) +{ + UINT32 bm; + + bm = cookie & ~(0xFF << MVPP2_BM_COOKIE_POOL_OFFS); + bm |= ((pool & 0xFF) << MVPP2_BM_COOKIE_POOL_OFFS); + + return bm; +} + +/* Get pool number from a BM cookie */ +STATIC inline INT32 Mvpp2BmCookiePoolGet(UINT32 cookie) +{ + return (cookie >> MVPP2_BM_COOKIE_POOL_OFFS) & 0xFF; +} + +#ifdef MVPP2_V1 +/* Release buffer to BM */ +STATIC inline VOID Mvpp2BmPoolPut(MVPP2_SHARED *pp2, INT32 pool, + UINT32 BufPhysAddr, UINT32 BufVirtAddr) +{ + Mvpp2Write(port->priv, MVPP2_BM_VIRT_RLS_REG, BufVirtAddr); + Mvpp2Write(port->priv, MVPP2_BM_PHY_RLS_REG(pool), BufPhysAddr); +} +#else +STATIC inline VOID Mvpp2BmPoolPut(MVPP2_SHARED *pp2, INT32 pool, + UINT64 BufPhysAddr, UINT64 BufVirtAddr) +{ + UINT32 val = 0; + + val = (Upper32Bits(BufVirtAddr) & MVPP22_ADDR_HIGH_MASK) + << MVPP22_BM_VIRT_HIGH_RLS_OFFST; + val |= (Upper32Bits(BufPhysAddr) & MVPP22_ADDR_HIGH_MASK) + << MVPP22_BM_PHY_HIGH_RLS_OFFSET; + Mvpp2Write(pp2, MVPP22_BM_PHY_VIRT_HIGH_RLS_REG, val); + Mvpp2Write(pp2, MVPP2_BM_VIRT_RLS_REG, (UINT32)BufVirtAddr); + Mvpp2Write(pp2, MVPP2_BM_PHY_RLS_REG(pool), (UINT32)BufPhysAddr); +} +#endif + +STATIC inline VOID Mvpp2InterruptsEnable(PP2DXE_PORT *port, + INT32 CpuMask) +{ + Mvpp2Write(port->priv, MVPP2_ISR_ENABLE_REG(port->id), + MVPP2_ISR_ENABLE_INTERRUPT(CpuMask)); +} + +STATIC inline VOID Mvpp2InterruptsDisable(PP2DXE_PORT *port, + INT32 CpuMask) +{ + Mvpp2Write(port->priv, MVPP2_ISR_ENABLE_REG(port->id), + MVPP2_ISR_DISABLE_INTERRUPT(CpuMask)); +} + +/* Get number of Rx descriptors occupied by received packets */ +STATIC inline INT32 +Mvpp2RxqReceived(PP2DXE_PORT *port, INT32 RxqId) +{ + UINT32 val = Mvpp2Read(port->priv, MVPP2_RXQ_STATUS_REG(RxqId)); + + return val & MVPP2_RXQ_OCCUPIED_MASK; +} + +/* Update Rx queue status with the number of occupied and available + * Rx descriptor slots. + */ +STATIC inline VOID +Mvpp2RxqStatusUpdate(PP2DXE_PORT *port, INT32 RxqId, + INT32 UsedCount, INT32 FreeCount) +{ + /* Decrement the number of used descriptors and increment count + * increment the number of free descriptors. + */ + UINT32 val = UsedCount | (FreeCount << MVPP2_RXQ_NUM_NEW_OFFSET); + + Mvpp2Write(port->priv, MVPP2_RXQ_STATUS_UPDATE_REG(RxqId), val); +} + +/* Get pointer to next RX descriptor to be processed by SW */ +STATIC inline MVPP2_RX_DESC * +Mvpp2RxqNextDescGet(MVPP2_RX_QUEUE *rxq) +{ + INT32 RxDesc = rxq->NextDescToProc; + + rxq->NextDescToProc = MVPP2_QUEUE_NEXT_DESC(rxq, RxDesc); + Mvpp2Prefetch(rxq->descs + rxq->NextDescToProc); + return rxq->descs + RxDesc; +} + +/* Get number of sent descriptors and decrement counter. + * The number of sent descriptors is returned. + * Per-CPU access + */ +STATIC inline INT32 Mvpp2TxqSentDescProc(PP2DXE_PORT *port, + MVPP2_TX_QUEUE *txq) +{ + UINT32 val; + + /* Reading status reg resets transmitted descriptor counter */ +#ifdef MVPP2V1 + val = Mvpp2Read(port->priv, MVPP2_TXQ_SENT_REG(txq->id)); +#else + val = Mvpp2Read(port->priv, MVPP22_TXQ_SENT_REG(txq->id)); +#endif + + return (val & MVPP2_TRANSMITTED_COUNT_MASK) >> + MVPP2_TRANSMITTED_COUNT_OFFSET; +} + +STATIC inline MVPP2_RX_QUEUE *Mvpp2GetRxQueue(PP2DXE_PORT *port, + UINT32 cause) +{ + INT32 queue = Mvpp2Fls(cause) - 1; + + return &port->rxqs[queue]; +} + +STATIC inline MVPP2_TX_QUEUE *Mvpp2GetTxQueue(PP2DXE_PORT *port, + UINT32 cause) +{ + INT32 queue = Mvpp2Fls(cause) - 1; + + return &port->txqs[queue]; +} + +STATIC inline void Mvpp2x2TxdescPhysAddrSet(DmaAddrT PhysAddr, + MVPP2_TX_DESC *TxDesc) { + UINT64 *BufPhysAddrP = &TxDesc->BufPhysAddrHwCmd2; + + *BufPhysAddrP &= ~(MVPP22_ADDR_MASK); + *BufPhysAddrP |= PhysAddr & MVPP22_ADDR_MASK; +} +#endif /* __MVPP2_LIB_H__ */ diff --git a/Drivers/Net/Pp2Dxe/Mvpp2LibHw.h b/Drivers/Net/Pp2Dxe/Mvpp2LibHw.h new file mode 100644 index 0000000..f9b0178 --- /dev/null +++ b/Drivers/Net/Pp2Dxe/Mvpp2LibHw.h @@ -0,0 +1,2043 @@ +/******************************************************************************** +Copyright (C) 2016 Marvell International Ltd. + +Marvell BSD License Option + +If you received this File from Marvell, you may opt to use, redistribute and/or +modify this File under the following licensing terms. +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of Marvell nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*******************************************************************************/ + +#ifndef __MVPP2_LIB_HW__ +#define __MVPP2_LIB_HW__ + +#ifndef BIT +#define BIT(nr) (1 << (nr)) +#endif + +/* RX Fifo Registers */ +#define MVPP2_RX_DATA_FIFO_SIZE_REG(port) (0x00 + 4 * (port)) +#define MVPP2_RX_ATTR_FIFO_SIZE_REG(port) (0x20 + 4 * (port)) +#define MVPP2_RX_MIN_PKT_SIZE_REG 0x60 +#define MVPP2_RX_FIFO_INIT_REG 0x64 + +/* RX DMA Top Registers */ +#define MVPP2_RX_CTRL_REG(port) (0x140 + 4 * (port)) +#define MVPP2_RX_LOW_LATENCY_PKT_SIZE(s) (((s) & 0xfff) << 16) +#define MVPP2_RX_USE_PSEUDO_FOR_CSUM_MASK BIT(31) +#define MVPP2_POOL_BUF_SIZE_REG(pool) (0x180 + 4 * (pool)) +#define MVPP2_POOL_BUF_SIZE_OFFSET 5 +#define MVPP2_RXQ_CONFIG_REG(rxq) (0x800 + 4 * (rxq)) +#define MVPP2_SNOOP_PKT_SIZE_MASK 0x1ff +#define MVPP2_SNOOP_BUF_HDR_MASK BIT(9) +#define MVPP2_RXQ_POOL_SHORT_OFFS 20 +#define MVPP2_RXQ_POOL_SHORT_MASK 0x700000 +#define MVPP2_RXQ_POOL_LONG_OFFS 24 +#define MVPP2_RXQ_POOL_LONG_MASK 0x7000000 +#define MVPP2_RXQ_PACKET_OFFSET_OFFS 28 +#define MVPP2_RXQ_PACKET_OFFSET_MASK 0x70000000 +#define MVPP2_RXQ_DISABLE_MASK BIT(31) + +/* Parser Registers */ +#define MVPP2_PRS_INIT_LOOKUP_REG 0x1000 +#define MVPP2_PRS_PORT_LU_MAX 0xf +#define MVPP2_PRS_PORT_LU_MASK(port) (0xff << ((port) * 4)) +#define MVPP2_PRS_PORT_LU_VAL(port, val) ((val) << ((port) * 4)) +#define MVPP2_PRS_INIT_OFFS_REG(port) (0x1004 + ((port) & 4)) +#define MVPP2_PRS_INIT_OFF_MASK(port) (0x3f << (((port) % 4) * 8)) +#define MVPP2_PRS_INIT_OFF_VAL(port, val) ((val) << (((port) % 4) * 8)) +#define MVPP2_PRS_MAX_LOOP_REG(port) (0x100c + ((port) & 4)) +#define MVPP2_PRS_MAX_LOOP_MASK(port) (0xff << (((port) % 4) * 8)) +#define MVPP2_PRS_MAX_LOOP_VAL(port, val) ((val) << (((port) % 4) * 8)) +#define MVPP2_PRS_TCAM_IDX_REG 0x1100 +#define MVPP2_PRS_TCAM_DATA_REG(idx) (0x1104 + (idx) * 4) +#define MVPP2_PRS_TCAM_INV_MASK BIT(31) +#define MVPP2_PRS_SRAM_IDX_REG 0x1200 +#define MVPP2_PRS_SRAM_DATA_REG(idx) (0x1204 + (idx) * 4) +#define MVPP2_PRS_TCAM_CTRL_REG 0x1230 +#define MVPP2_PRS_TCAM_EN_MASK BIT(0) + +/* Classifier Registers */ +#define MVPP2_CLS_MODE_REG 0x1800 +#define MVPP2_CLS_MODE_ACTIVE_MASK BIT(0) +#define MVPP2_CLS_PORT_WAY_REG 0x1810 +#define MVPP2_CLS_PORT_WAY_MASK(port) (1 << (port)) +#define MVPP2_CLS_LKP_INDEX_REG 0x1814 +#define MVPP2_CLS_LKP_INDEX_WAY_OFFS 6 +#define MVPP2_CLS_LKP_TBL_REG 0x1818 +#define MVPP2_CLS_LKP_TBL_RXQ_MASK 0xff +#define MVPP2_CLS_LKP_TBL_LOOKUP_EN_MASK BIT(25) +#define MVPP2_CLS_FLOW_INDEX_REG 0x1820 +#define MVPP2_CLS_FLOW_TBL0_REG 0x1824 +#define MVPP2_CLS_FLOW_TBL1_REG 0x1828 +#define MVPP2_CLS_FLOW_TBL2_REG 0x182c +#define MVPP2_CLS_OVERSIZE_RXQ_LOW_REG(port) (0x1980 + ((port) * 4)) +#define MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS 3 +#define MVPP2_CLS_OVERSIZE_RXQ_LOW_MASK 0x7 +#define MVPP2_CLS_SWFWD_P2HQ_REG(port) (0x19b0 + ((port) * 4)) +#define MVPP2_CLS_SWFWD_PCTRL_REG 0x19d0 +#define MVPP2_CLS_SWFWD_PCTRL_MASK(port) (1 << (port)) + +/* Descriptor Manager Top Registers */ +#define MVPP2_RXQ_NUM_REG 0x2040 +#define MVPP2_RXQ_DESC_ADDR_REG 0x2044 +#define MVPP2_RXQ_DESC_SIZE_REG 0x2048 +#define MVPP2_RXQ_DESC_SIZE_MASK 0x3ff0 +#define MVPP2_RXQ_STATUS_UPDATE_REG(rxq) (0x3000 + 4 * (rxq)) +#define MVPP2_RXQ_NUM_PROCESSED_OFFSET 0 +#define MVPP2_RXQ_NUM_NEW_OFFSET 16 +#define MVPP2_RXQ_STATUS_REG(rxq) (0x3400 + 4 * (rxq)) +#define MVPP2_RXQ_OCCUPIED_MASK 0x3fff +#define MVPP2_RXQ_NON_OCCUPIED_OFFSET 16 +#define MVPP2_RXQ_NON_OCCUPIED_MASK 0x3fff0000 +#define MVPP2_RXQ_THRESH_REG 0x204c +#define MVPP2_OCCUPIED_THRESH_OFFSET 0 +#define MVPP2_OCCUPIED_THRESH_MASK 0x3fff +#define MVPP2_RXQ_INDEX_REG 0x2050 +#define MVPP2_TXQ_NUM_REG 0x2080 +#define MVPP2_TXQ_DESC_ADDR_REG 0x2084 +#define MVPP22_TXQ_DESC_ADDR_HIGH_REG 0x20a8 +#define MVPP22_TXQ_DESC_ADDR_HIGH_MASK 0xff +#define MVPP2_TXQ_DESC_SIZE_REG 0x2088 +#define MVPP2_TXQ_DESC_SIZE_MASK 0x3ff0 +#define MVPP2_AGGR_TXQ_UPDATE_REG 0x2090 +#define MVPP2_TXQ_THRESH_REG 0x2094 +#define MVPP2_TRANSMITTED_THRESH_OFFSET 16 +#define MVPP2_TRANSMITTED_THRESH_MASK 0x3fff0000 +#define MVPP2_TXQ_INDEX_REG 0x2098 +#define MVPP2_TXQ_PREF_BUF_REG 0x209c +#define MVPP2_PREF_BUF_PTR(desc) ((desc) & 0xfff) +#define MVPP2_PREF_BUF_SIZE_4 (BIT(12) | BIT(13)) +#define MVPP2_PREF_BUF_SIZE_16 (BIT(12) | BIT(14)) +#define MVPP2_PREF_BUF_THRESH(val) ((val) << 17) +#define MVPP2_TXQ_DRAIN_EN_MASK BIT(31) +#define MVPP2_TXQ_PENDING_REG 0x20a0 +#define MVPP2_TXQ_PENDING_MASK 0x3fff +#define MVPP2_TXQ_INT_STATUS_REG 0x20a4 +#define MVPP2_TXQ_SENT_REG(txq) (0x3c00 + 4 * (txq)) +#define MVPP22_TXQ_SENT_REG(txq) (0x3e00 + 4 * (txq-128)) +#define MVPP2_TRANSMITTED_COUNT_OFFSET 16 +#define MVPP2_TRANSMITTED_COUNT_MASK 0x3fff0000 +#define MVPP2_TXQ_RSVD_REQ_REG 0x20b0 +#define MVPP2_TXQ_RSVD_REQ_Q_OFFSET 16 +#define MVPP2_TXQ_RSVD_RSLT_REG 0x20b4 +#define MVPP2_TXQ_RSVD_RSLT_MASK 0x3fff +#define MVPP2_TXQ_RSVD_CLR_REG 0x20b8 +#define MVPP2_TXQ_RSVD_CLR_OFFSET 16 +#define MVPP2_AGGR_TXQ_DESC_ADDR_REG(cpu) (0x2100 + 4 * (cpu)) +#define MVPP2_AGGR_TXQ_DESC_SIZE_REG(cpu) (0x2140 + 4 * (cpu)) +#define MVPP2_AGGR_TXQ_DESC_SIZE_MASK 0x3ff0 +#define MVPP2_AGGR_TXQ_STATUS_REG(cpu) (0x2180 + 4 * (cpu)) +#define MVPP2_AGGR_TXQ_PENDING_MASK 0x3fff +#define MVPP2_AGGR_TXQ_INDEX_REG(cpu) (0x21c0 + 4 * (cpu)) + +/* MBUS bridge registers */ +#define MVPP2_WIN_BASE(w) (0x4000 + ((w) << 2)) +#define MVPP2_WIN_SIZE(w) (0x4020 + ((w) << 2)) +#define MVPP2_WIN_REMAP(w) (0x4040 + ((w) << 2)) +#define MVPP2_BASE_ADDR_ENABLE 0x4060 + +/* Interrupt Cause and Mask registers */ +#define MVPP2_ISR_RX_THRESHOLD_REG(rxq) (0x5200 + 4 * (rxq)) +#define MVPP2_ISR_RXQ_GROUP_REG(rxq) (0x5400 + 4 * (rxq)) +#define MVPP2_ISR_ENABLE_REG(port) (0x5420 + 4 * (port)) +#define MVPP2_ISR_ENABLE_INTERRUPT(mask) ((mask) & 0xffff) +#define MVPP2_ISR_DISABLE_INTERRUPT(mask) (((mask) << 16) & 0xffff0000) +#define MVPP2_ISR_RX_TX_CAUSE_REG(port) (0x5480 + 4 * (port)) +#define MVPP2_CAUSE_RXQ_OCCUP_DESC_ALL_MASK 0xffff +#define MVPP2_CAUSE_TXQ_OCCUP_DESC_ALL_MASK 0xff0000 +#define MVPP2_CAUSE_RX_FIFO_OVERRUN_MASK BIT(24) +#define MVPP2_CAUSE_FCS_ERR_MASK BIT(25) +#define MVPP2_CAUSE_TX_FIFO_UNDERRUN_MASK BIT(26) +#define MVPP2_CAUSE_TX_EXCEPTION_SUM_MASK BIT(29) +#define MVPP2_CAUSE_RX_EXCEPTION_SUM_MASK BIT(30) +#define MVPP2_CAUSE_MISC_SUM_MASK BIT(31) +#define MVPP2_ISR_RX_TX_MASK_REG(port) (0x54a0 + 4 * (port)) +#define MVPP2_ISR_PON_RX_TX_MASK_REG 0x54bc +#define MVPP2_PON_CAUSE_RXQ_OCCUP_DESC_ALL_MASK 0xffff +#define MVPP2_PON_CAUSE_TXP_OCCUP_DESC_ALL_MASK 0x3fc00000 +#define MVPP2_PON_CAUSE_MISC_SUM_MASK BIT(31) +#define MVPP2_ISR_MISC_CAUSE_REG 0x55b0 + +/* Buffer Manager registers */ +#define MVPP2_BM_POOL_BASE_REG(pool) (0x6000 + ((pool) * 4)) +#define MVPP2_BM_POOL_BASE_ADDR_MASK 0xfffff80 +#define MVPP2_BM_POOL_SIZE_REG(pool) (0x6040 + ((pool) * 4)) +#define MVPP2_BM_POOL_SIZE_MASK 0xfff0 +#define MVPP2_BM_POOL_READ_PTR_REG(pool) (0x6080 + ((pool) * 4)) +#define MVPP2_BM_POOL_GET_READ_PTR_MASK 0xfff0 +#define MVPP2_BM_POOL_PTRS_NUM_REG(pool) (0x60c0 + ((pool) * 4)) +#define MVPP2_BM_POOL_PTRS_NUM_MASK 0xfff0 +#define MVPP2_BM_BPPI_READ_PTR_REG(pool) (0x6100 + ((pool) * 4)) +#define MVPP2_BM_BPPI_PTRS_NUM_REG(pool) (0x6140 + ((pool) * 4)) +#define MVPP2_BM_BPPI_PTR_NUM_MASK 0x7ff +#define MVPP2_BM_BPPI_PREFETCH_FULL_MASK BIT(16) +#define MVPP2_BM_POOL_CTRL_REG(pool) (0x6200 + ((pool) * 4)) +#define MVPP2_BM_START_MASK BIT(0) +#define MVPP2_BM_STOP_MASK BIT(1) +#define MVPP2_BM_STATE_MASK BIT(4) +#define MVPP2_BM_LOW_THRESH_OFFS 8 +#define MVPP2_BM_LOW_THRESH_MASK 0x7f00 +#define MVPP2_BM_LOW_THRESH_VALUE(val) ((val) << \ + MVPP2_BM_LOW_THRESH_OFFS) +#define MVPP2_BM_HIGH_THRESH_OFFS 16 +#define MVPP2_BM_HIGH_THRESH_MASK 0x7f0000 +#define MVPP2_BM_HIGH_THRESH_VALUE(val) ((val) << \ + MVPP2_BM_HIGH_THRESH_OFFS) +#define MVPP2_BM_INTR_CAUSE_REG(pool) (0x6240 + ((pool) * 4)) +#define MVPP2_BM_RELEASED_DELAY_MASK BIT(0) +#define MVPP2_BM_ALLOC_FAILED_MASK BIT(1) +#define MVPP2_BM_BPPE_EMPTY_MASK BIT(2) +#define MVPP2_BM_BPPE_FULL_MASK BIT(3) +#define MVPP2_BM_AVAILABLE_BP_LOW_MASK BIT(4) +#define MVPP2_BM_INTR_MASK_REG(pool) (0x6280 + ((pool) * 4)) +#define MVPP2_BM_PHY_ALLOC_REG(pool) (0x6400 + ((pool) * 4)) +#define MVPP2_BM_PHY_ALLOC_GRNTD_MASK BIT(0) +#define MVPP2_BM_VIRT_ALLOC_REG 0x6440 +#define MVPP2_BM_PHY_RLS_REG(pool) (0x6480 + ((pool) * 4)) +#define MVPP2_BM_PHY_RLS_MC_BUFF_MASK BIT(0) +#define MVPP2_BM_PHY_RLS_PRIO_EN_MASK BIT(1) +#define MVPP2_BM_PHY_RLS_GRNTD_MASK BIT(2) +#define MVPP2_BM_VIRT_RLS_REG 0x64c0 +#define MVPP2_BM_MC_RLS_REG 0x64c4 +#define MVPP2_BM_MC_ID_MASK 0xfff +#define MVPP2_BM_FORCE_RELEASE_MASK BIT(12) + +#define MVPP22_BM_PHY_VIRT_HIGH_ALLOC_REG 0x6444 +#define MVPP22_BM_PHY_HIGH_ALLOC_OFFSET 0 +#define MVPP22_BM_VIRT_HIGH_ALLOC_OFFSET 8 +#define MVPP22_BM_VIRT_HIGH_ALLOC_MASK 0xff00 + +#define MVPP22_BM_PHY_VIRT_HIGH_RLS_REG 0x64c4 + +#define MVPP22_BM_PHY_HIGH_RLS_OFFSET 0 +#define MVPP22_BM_VIRT_HIGH_RLS_OFFST 8 + +#define MVPP22_BM_POOL_BASE_HIGH_REG 0x6310 +#define MVPP22_BM_POOL_BASE_HIGH_MASK 0xff +#define MVPP2_BM_PRIO_CTRL_REG 0x6800 + +/* TX Scheduler registers */ +#define MVPP2_TXP_SCHED_PORT_INDEX_REG 0x8000 +#define MVPP2_TXP_SCHED_Q_CMD_REG 0x8004 +#define MVPP2_TXP_SCHED_ENQ_MASK 0xff +#define MVPP2_TXP_SCHED_DISQ_OFFSET 8 +#define MVPP2_TXP_SCHED_CMD_1_REG 0x8010 +#define MVPP2_TXP_SCHED_PERIOD_REG 0x8018 +#define MVPP2_TXP_SCHED_MTU_REG 0x801c +#define MVPP2_TXP_MTU_MAX 0x7FFFF +#define MVPP2_TXP_SCHED_REFILL_REG 0x8020 +#define MVPP2_TXP_REFILL_TOKENS_ALL_MASK 0x7ffff +#define MVPP2_TXP_REFILL_PERIOD_ALL_MASK 0x3ff00000 +#define MVPP2_TXP_REFILL_PERIOD_MASK(v) ((v) << 20) +#define MVPP2_TXP_SCHED_TOKEN_SIZE_REG 0x8024 +#define MVPP2_TXP_TOKEN_SIZE_MAX 0xffffffff +#define MVPP2_TXQ_SCHED_REFILL_REG(q) (0x8040 + ((q) << 2)) +#define MVPP2_TXQ_REFILL_TOKENS_ALL_MASK 0x7ffff +#define MVPP2_TXQ_REFILL_PERIOD_ALL_MASK 0x3ff00000 +#define MVPP2_TXQ_REFILL_PERIOD_MASK(v) ((v) << 20) +#define MVPP2_TXQ_SCHED_TOKEN_SIZE_REG(q) (0x8060 + ((q) << 2)) +#define MVPP2_TXQ_TOKEN_SIZE_MAX 0x7fffffff +#define MVPP2_TXQ_SCHED_TOKEN_CNTR_REG(q) (0x8080 + ((q) << 2)) +#define MVPP2_TXQ_TOKEN_CNTR_MAX 0xffffffff + +/* TX general registers */ +#define MVPP2_TX_SNOOP_REG 0x8800 +#define MVPP2_TX_PORT_FLUSH_REG 0x8810 +#define MVPP2_TX_PORT_FLUSH_MASK(port) (1 << (port)) + +/* LMS registers */ +#define MVPP2_SRC_ADDR_MIDDLE 0x24 +#define MVPP2_SRC_ADDR_HIGH 0x28 +#define MVPP2_PHY_AN_CFG0_REG 0x34 +#define MVPP2_PHY_AN_STOP_SMI0_MASK BIT(7) +#define MVPP2_MIB_COUNTERS_BASE(port) (0x1000 + ((port) >> 1) * \ + 0x400 + (port) * 0x400) +#define MVPP2_MIB_LATE_COLLISION 0x7c +#define MVPP2_ISR_SUM_MASK_REG 0x220c +#define MVPP2_MNG_EXTENDED_GLOBAL_CTRL_REG 0x305c +#define MVPP2_EXT_GLOBAL_CTRL_DEFAULT 0x27 + +/* Per-port registers */ +#define MVPP2_GMAC_CTRL_0_REG 0x0 +#define MVPP2_GMAC_PORT_EN_MASK BIT(0) +#define MVPP2_GMAC_MAX_RX_SIZE_OFFS 2 +#define MVPP2_GMAC_MAX_RX_SIZE_MASK 0x7ffc +#define MVPP2_GMAC_MIB_CNTR_EN_MASK BIT(15) +#define MVPP2_GMAC_CTRL_1_REG 0x4 +#define MVPP2_GMAC_PERIODIC_XON_EN_MASK BIT(1) +#define MVPP2_GMAC_GMII_LB_EN_MASK BIT(5) +#define MVPP2_GMAC_PCS_LB_EN_BIT 6 +#define MVPP2_GMAC_PCS_LB_EN_MASK BIT(6) +#define MVPP2_GMAC_SA_LOW_OFFS 7 +#define MVPP2_GMAC_CTRL_2_REG 0x8 +#define MVPP2_GMAC_INBAND_AN_MASK BIT(0) +#define MVPP2_GMAC_PCS_ENABLE_MASK BIT(3) +#define MVPP2_GMAC_PORT_RGMII_MASK BIT(4) +#define MVPP2_GMAC_PORT_RESET_MASK BIT(6) +#define MVPP2_GMAC_AUTONEG_CONFIG 0xc +#define MVPP2_GMAC_FORCE_LINK_DOWN BIT(0) +#define MVPP2_GMAC_FORCE_LINK_PASS BIT(1) +#define MVPP2_GMAC_CONFIG_MII_SPEED BIT(5) +#define MVPP2_GMAC_CONFIG_GMII_SPEED BIT(6) +#define MVPP2_GMAC_AN_SPEED_EN BIT(7) +#define MVPP2_GMAC_FC_ADV_EN BIT(9) +#define MVPP2_GMAC_CONFIG_FULL_DUPLEX BIT(12) +#define MVPP2_GMAC_AN_DUPLEX_EN BIT(13) +#define MVPP2_GMAC_PORT_FIFO_CFG_1_REG 0x1c +#define MVPP2_GMAC_TX_FIFO_MIN_TH_OFFS 6 +#define MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK 0x1fc0 +#define MVPP2_GMAC_TX_FIFO_MIN_TH_MASK(v) (((v) << 6) & \ + MVPP2_GMAC_TX_FIFO_MIN_TH_ALL_MASK) +/* Port Interrupt Cause */ +#define MV_GMAC_INTERRUPT_CAUSE_REG (0x0020) +/* Port Interrupt Mask */ +#define MV_GMAC_INTERRUPT_MASK_REG (0x0024) +#define MV_GMAC_INTERRUPT_CAUSE_LINK_CHANGE_OFFS 1 +#define MV_GMAC_INTERRUPT_CAUSE_LINK_CHANGE_MASK \ + (0x1 << MV_GMAC_INTERRUPT_CAUSE_LINK_CHANGE_OFFS) + +/* Port Interrupt Summary Cause */ +#define MV_GMAC_INTERRUPT_SUM_CAUSE_REG (0x00A0) +/* Port Interrupt Summary Mask */ +#define MV_GMAC_INTERRUPT_SUM_MASK_REG (0x00A4) +#define MV_GMAC_INTERRUPT_SUM_CAUSE_LINK_CHANGE_OFFS 1 +#define MV_GMAC_INTERRUPT_SUM_CAUSE_LINK_CHANGE_MASK \ + (0x1 << MV_GMAC_INTERRUPT_SUM_CAUSE_LINK_CHANGE_OFFS) + +/* Port Mac Control0 */ +#define MVPP2_PORT_CTRL0_REG (0x0000) +#define MVPP2_PORT_CTRL0_PORTEN_OFFS 0 +#define MVPP2_PORT_CTRL0_PORTEN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL0_PORTEN_OFFS) + +#define MVPP2_PORT_CTRL0_PORTTYPE_OFFS 1 +#define MVPP2_PORT_CTRL0_PORTTYPE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL0_PORTTYPE_OFFS) + +#define MVPP2_PORT_CTRL0_FRAMESIZELIMIT_OFFS 2 +#define MVPP2_PORT_CTRL0_FRAMESIZELIMIT_MASK \ + (0x00001fff << MVPP2_PORT_CTRL0_FRAMESIZELIMIT_OFFS) + +#define MVPP2_PORT_CTRL0_COUNT_EN_OFFS 15 +#define MVPP2_PORT_CTRL0_COUNT_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL0_COUNT_EN_OFFS) + +/* Port Mac Control1 */ +#define MVPP2_PORT_CTRL1_REG (0x0004) +#define MVPP2_PORT_CTRL1_EN_RX_CRC_CHECK_OFFS 0 +#define MVPP2_PORT_CTRL1_EN_RX_CRC_CHECK_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_EN_RX_CRC_CHECK_OFFS) + +#define MVPP2_PORT_CTRL1_EN_PERIODIC_FC_XON_OFFS 1 +#define MVPP2_PORT_CTRL1_EN_PERIODIC_FC_XON_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_EN_PERIODIC_FC_XON_OFFS) + +#define MVPP2_PORT_CTRL1_MGMII_MODE_OFFS 2 +#define MVPP2_PORT_CTRL1_MGMII_MODE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_MGMII_MODE_OFFS) + +#define MVPP2_PORT_CTRL1_PFC_CASCADE_PORT_ENABLE_OFFS 3 +#define MVPP2_PORT_CTRL1_PFC_CASCADE_PORT_ENABLE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_PFC_CASCADE_PORT_ENABLE_OFFS) + +#define MVPP2_PORT_CTRL1_DIS_EXCESSIVE_COL_OFFS 4 +#define MVPP2_PORT_CTRL1_DIS_EXCESSIVE_COL_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_DIS_EXCESSIVE_COL_OFFS) + +#define MVPP2_PORT_CTRL1_GMII_LOOPBACK_OFFS 5 +#define MVPP2_PORT_CTRL1_GMII_LOOPBACK_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_GMII_LOOPBACK_OFFS) + +#define MVPP2_PORT_CTRL1_PCS_LOOPBACK_OFFS 6 +#define MVPP2_PORT_CTRL1_PCS_LOOPBACK_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_PCS_LOOPBACK_OFFS) + +#define MVPP2_PORT_CTRL1_FC_SA_ADDR_LO_OFFS 7 +#define MVPP2_PORT_CTRL1_FC_SA_ADDR_LO_MASK \ + (0x000000ff << MVPP2_PORT_CTRL1_FC_SA_ADDR_LO_OFFS) + +#define MVPP2_PORT_CTRL1_EN_SHORT_PREAMBLE_OFFS 15 +#define MVPP2_PORT_CTRL1_EN_SHORT_PREAMBLE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL1_EN_SHORT_PREAMBLE_OFFS) + +/* Port Mac Control2 */ +#define MVPP2_PORT_CTRL2_REG (0x0008) +#define MVPP2_PORT_CTRL2_SGMII_MODE_OFFS 0 +#define MVPP2_PORT_CTRL2_SGMII_MODE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_SGMII_MODE_OFFS) + +#define MVPP2_PORT_CTRL2_FC_MODE_OFFS 1 +#define MVPP2_PORT_CTRL2_FC_MODE_MASK \ + (0x00000003 << MVPP2_PORT_CTRL2_FC_MODE_OFFS) + +#define MVPP2_PORT_CTRL2_PCS_EN_OFFS 3 +#define MVPP2_PORT_CTRL2_PCS_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_PCS_EN_OFFS) + +#define MVPP2_PORT_CTRL2_RGMII_MODE_OFFS 4 +#define MVPP2_PORT_CTRL2_RGMII_MODE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_RGMII_MODE_OFFS) + +#define MVPP2_PORT_CTRL2_DIS_PADING_OFFS 5 +#define MVPP2_PORT_CTRL2_DIS_PADING_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_DIS_PADING_OFFS) + +#define MVPP2_PORT_CTRL2_PORTMACRESET_OFFS 6 +#define MVPP2_PORT_CTRL2_PORTMACRESET_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_PORTMACRESET_OFFS) + +#define MVPP2_PORT_CTRL2_TX_DRAIN_OFFS 7 +#define MVPP2_PORT_CTRL2_TX_DRAIN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_TX_DRAIN_OFFS) + +#define MVPP2_PORT_CTRL2_EN_MII_ODD_PRE_OFFS 8 +#define MVPP2_PORT_CTRL2_EN_MII_ODD_PRE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_EN_MII_ODD_PRE_OFFS) + +#define MVPP2_PORT_CTRL2_CLK_125_BYPS_EN_OFFS 9 +#define MVPP2_PORT_CTRL2_CLK_125_BYPS_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_CLK_125_BYPS_EN_OFFS) + +#define MVPP2_PORT_CTRL2_PRBS_CHECK_EN_OFFS 10 +#define MVPP2_PORT_CTRL2_PRBS_CHECK_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_PRBS_CHECK_EN_OFFS) + +#define MVPP2_PORT_CTRL2_PRBS_GEN_EN_OFFS 11 +#define MVPP2_PORT_CTRL2_PRBS_GEN_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_PRBS_GEN_EN_OFFS) + +#define MVPP2_PORT_CTRL2_SELECT_DATA_TO_TX_OFFS 12 +#define MVPP2_PORT_CTRL2_SELECT_DATA_TO_TX_MASK \ + (0x00000003 << MVPP2_PORT_CTRL2_SELECT_DATA_TO_TX_OFFS) + +#define MVPP2_PORT_CTRL2_EN_COL_ON_BP_OFFS 14 +#define MVPP2_PORT_CTRL2_EN_COL_ON_BP_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_EN_COL_ON_BP_OFFS) + +#define MVPP2_PORT_CTRL2_EARLY_REJECT_MODE_OFFS 15 +#define MVPP2_PORT_CTRL2_EARLY_REJECT_MODE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL2_EARLY_REJECT_MODE_OFFS) + +/* Port Auto-negotiation Configuration */ +#define MVPP2_PORT_AUTO_NEG_CFG_REG (0x000c) +#define MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_DOWN_OFFS 0 +#define MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_DOWN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_DOWN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_UP_OFFS 1 +#define MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_UP_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_FORCE_LINK_UP_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_OFFS 2 +#define MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_EN_PCS_AN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_OFFS 3 +#define MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_AN_BYPASS_EN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_INBAND_RESTARTAN_OFFS 4 +#define MVPP2_PORT_AUTO_NEG_CFG_INBAND_RESTARTAN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_INBAND_RESTARTAN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_OFFS 5 +#define MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_SET_MII_SPEED_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_OFFS 6 +#define MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_SET_GMII_SPEED_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_OFFS 7 +#define MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_EN_AN_SPEED_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_ADV_PAUSE_OFFS 9 +#define MVPP2_PORT_AUTO_NEG_CFG_ADV_PAUSE_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_ADV_PAUSE_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_ADV_ASM_PAUSE_OFFS 10 +#define MVPP2_PORT_AUTO_NEG_CFG_ADV_ASM_PAUSE_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_ADV_ASM_PAUSE_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_OFFS 11 +#define MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_EN_FC_AN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_OFFS 12 +#define MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_SET_FULL_DX_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_OFFS 13 +#define MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_EN_FDX_AN_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_PHY_MODE_OFFS 14 +#define MVPP2_PORT_AUTO_NEG_CFG_PHY_MODE_MASK \ + (0x00000001 << MVPP2_PORT_AUTO_NEG_CFG_PHY_MODE_OFFS) + +#define MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_OFFS 15 +#define MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_MASK \ + (0x00000001 << \ + MVPP2_PORT_AUTO_NEG_CFG_CHOOSE_SAMPLE_TX_CONFIG_OFFS) + +/* Port Status0 */ +#define MVPP2_PORT_STATUS0_REG (0x0010) +#define MVPP2_PORT_STATUS0_LINKUP_OFFS 0 +#define MVPP2_PORT_STATUS0_LINKUP_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_LINKUP_OFFS) + +#define MVPP2_PORT_STATUS0_GMIISPEED_OFFS 1 +#define MVPP2_PORT_STATUS0_GMIISPEED_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_GMIISPEED_OFFS) + +#define MVPP2_PORT_STATUS0_MIISPEED_OFFS 2 +#define MVPP2_PORT_STATUS0_MIISPEED_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_MIISPEED_OFFS) + +#define MVPP2_PORT_STATUS0_FULLDX_OFFS 3 +#define MVPP2_PORT_STATUS0_FULLDX_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_FULLDX_OFFS) + +#define MVPP2_PORT_STATUS0_RXFCEN_OFFS 4 +#define MVPP2_PORT_STATUS0_RXFCEN_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_RXFCEN_OFFS) + +#define MVPP2_PORT_STATUS0_TXFCEN_OFFS 5 +#define MVPP2_PORT_STATUS0_TXFCEN_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_TXFCEN_OFFS) + +#define MVPP2_PORT_STATUS0_PORTRXPAUSE_OFFS 6 +#define MVPP2_PORT_STATUS0_PORTRXPAUSE_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_PORTRXPAUSE_OFFS) + +#define MVPP2_PORT_STATUS0_PORTTXPAUSE_OFFS 7 +#define MVPP2_PORT_STATUS0_PORTTXPAUSE_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_PORTTXPAUSE_OFFS) + +#define MVPP2_PORT_STATUS0_PORTIS_DOINGPRESSURE_OFFS 8 +#define MVPP2_PORT_STATUS0_PORTIS_DOINGPRESSURE_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_PORTIS_DOINGPRESSURE_OFFS) + +#define MVPP2_PORT_STATUS0_PORTBUFFULL_OFFS 9 +#define MVPP2_PORT_STATUS0_PORTBUFFULL_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_PORTBUFFULL_OFFS) + +#define MVPP2_PORT_STATUS0_SYNCFAIL10MS_OFFS 10 +#define MVPP2_PORT_STATUS0_SYNCFAIL10MS_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_SYNCFAIL10MS_OFFS) + +#define MVPP2_PORT_STATUS0_ANDONE_OFFS 11 +#define MVPP2_PORT_STATUS0_ANDONE_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_ANDONE_OFFS) + +#define MVPP2_PORT_STATUS0_INBAND_AUTONEG_BYPASSACT_OFFS 12 +#define MVPP2_PORT_STATUS0_INBAND_AUTONEG_BYPASSACT_MASK \ + (0x00000001 << \ + MVPP2_PORT_STATUS0_INBAND_AUTONEG_BYPASSACT_OFFS) + +#define MVPP2_PORT_STATUS0_SERDESPLL_LOCKED_OFFS 13 +#define MVPP2_PORT_STATUS0_SERDESPLL_LOCKED_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_SERDESPLL_LOCKED_OFFS) + +#define MVPP2_PORT_STATUS0_SYNCOK_OFFS 14 +#define MVPP2_PORT_STATUS0_SYNCOK_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_SYNCOK_OFFS) + +#define MVPP2_PORT_STATUS0_SQUELCHNOT_DETECTED_OFFS 15 +#define MVPP2_PORT_STATUS0_SQUELCHNOT_DETECTED_MASK \ + (0x00000001 << MVPP2_PORT_STATUS0_SQUELCHNOT_DETECTED_OFFS) + +/* Port Serial Parameters Configuration */ +#define MVPP2_PORT_SERIAL_PARAM_CFG_REG (0x0014) +#define MVPP2_PORT_SERIAL_PARAM_CFG_UNIDIRECTIONAL_ENABLE_OFFS 0 +#define MVPP2_PORT_SERIAL_PARAM_CFG_UNIDIRECTIONAL_ENABLE_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_UNIDIRECTIONAL_ENABLE_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_RETRANSMIT_COLLISION_DOMAIN_OFFS 1 +#define MVPP2_PORT_SERIAL_PARAM_CFG_RETRANSMIT_COLLISION_DOMAIN_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_RETRANSMIT_COLLISION_DOMAIN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_PUMA2_BTS1444_EN_OFFS 2 +#define MVPP2_PORT_SERIAL_PARAM_CFG_PUMA2_BTS1444_EN_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_PUMA2_BTS1444_EN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_FORWARD_802_3X_FC_EN_OFFS 3 +#define MVPP2_PORT_SERIAL_PARAM_CFG_FORWARD_802_3X_FC_EN_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_FORWARD_802_3X_FC_EN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_BP_EN_OFFS 4 +#define MVPP2_PORT_SERIAL_PARAM_CFG_BP_EN_MASK \ + (0x00000001 << MVPP2_PORT_SERIAL_PARAM_CFG_BP_EN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_RX_NEGEDGE_SAMPLE_EN_OFFS 5 +#define MVPP2_PORT_SERIAL_PARAM_CFG_RX_NEGEDGE_SAMPLE_EN_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_RX_NEGEDGE_SAMPLE_EN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_COL_DOMAIN_LIMIT_OFFS 6 +#define MVPP2_PORT_SERIAL_PARAM_CFG_COL_DOMAIN_LIMIT_MASK \ + (0x0000003f << \ + MVPP2_PORT_SERIAL_PARAM_CFG_COL_DOMAIN_LIMIT_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_PERIODIC_TYPE_SELECT_OFFS 12 +#define MVPP2_PORT_SERIAL_PARAM_CFG_PERIODIC_TYPE_SELECT_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_PERIODIC_TYPE_SELECT_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_PER_PRIORITY_FC_EN_OFFS 13 +#define MVPP2_PORT_SERIAL_PARAM_CFG_PER_PRIORITY_FC_EN_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_PER_PRIORITY_FC_EN_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_TX_STANDARD_PRBS7_OFFS 14 +#define MVPP2_PORT_SERIAL_PARAM_CFG_TX_STANDARD_PRBS7_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_TX_STANDARD_PRBS7_OFFS) + +#define MVPP2_PORT_SERIAL_PARAM_CFG_REVERSE_PRBS_RX_OFFS 15 +#define MVPP2_PORT_SERIAL_PARAM_CFG_REVERSE_PRBS_RX_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERIAL_PARAM_CFG_REVERSE_PRBS_RX_OFFS) + +/* Port Fifo Configuration 0 */ +#define MVPP2_PORT_FIFO_CFG_0_REG (0x0018) +#define MVPP2_PORT_FIFO_CFG_0_TX_FIFO_HIGH_WM_OFFS 0 +#define MVPP2_PORT_FIFO_CFG_0_TX_FIFO_HIGH_WM_MASK \ + (0x000000ff << MVPP2_PORT_FIFO_CFG_0_TX_FIFO_HIGH_WM_OFFS) + +#define MVPP2_PORT_FIFO_CFG_0_TX_FIFO_LOW_WM_OFFS 8 +#define MVPP2_PORT_FIFO_CFG_0_TX_FIFO_LOW_WM_MASK \ + (0x000000ff << MVPP2_PORT_FIFO_CFG_0_TX_FIFO_LOW_WM_OFFS) + +/* Port Fifo Configuration 1 */ +#define MVPP2_PORT_FIFO_CFG_1_REG (0x001c) +#define MVPP2_PORT_FIFO_CFG_1_RX_FIFO_MAX_TH_OFFS 0 +#define MVPP2_PORT_FIFO_CFG_1_RX_FIFO_MAX_TH_MASK \ + (0x0000003f << MVPP2_PORT_FIFO_CFG_1_RX_FIFO_MAX_TH_OFFS) + +#define MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS 6 +#define MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_MASK \ + (0x000000ff << MVPP2_PORT_FIFO_CFG_1_TX_FIFO_MIN_TH_OFFS) + +#define MVPP2_PORT_FIFO_CFG_1_PORT_EN_FIX_EN_OFFS 15 +#define MVPP2_PORT_FIFO_CFG_1_PORT_EN_FIX_EN_MASK \ + (0x00000001 << MVPP2_PORT_FIFO_CFG_1_PORT_EN_FIX_EN_OFFS) + +/* Port Serdes Configuration0 */ +#define MVPP2_PORT_SERDES_CFG0_REG (0x0028) +#define MVPP2_PORT_SERDES_CFG0_SERDESRESET_OFFS 0 +#define MVPP2_PORT_SERDES_CFG0_SERDESRESET_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_SERDESRESET_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_PU_TX_OFFS 1 +#define MVPP2_PORT_SERDES_CFG0_PU_TX_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_PU_TX_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_PU_RX_OFFS 2 +#define MVPP2_PORT_SERDES_CFG0_PU_RX_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_PU_RX_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_PU_PLL_OFFS 3 +#define MVPP2_PORT_SERDES_CFG0_PU_PLL_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_PU_PLL_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_PU_IVREF_OFFS 4 +#define MVPP2_PORT_SERDES_CFG0_PU_IVREF_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_PU_IVREF_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_TESTEN_OFFS 5 +#define MVPP2_PORT_SERDES_CFG0_TESTEN_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_TESTEN_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_DPHER_EN_OFFS 6 +#define MVPP2_PORT_SERDES_CFG0_DPHER_EN_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_DPHER_EN_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_RUDI_INVALID_ENABLE_OFFS 7 +#define MVPP2_PORT_SERDES_CFG0_RUDI_INVALID_ENABLE_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERDES_CFG0_RUDI_INVALID_ENABLE_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_ACK_OVERRIDE_ENABLE_OFFS 8 +#define MVPP2_PORT_SERDES_CFG0_ACK_OVERRIDE_ENABLE_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERDES_CFG0_ACK_OVERRIDE_ENABLE_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_CONFIG_WORD_ENABLE_OFFS 9 +#define MVPP2_PORT_SERDES_CFG0_CONFIG_WORD_ENABLE_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_CONFIG_WORD_ENABLE_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_SYNC_FAIL_INT_ENABLE_OFFS 10 +#define MVPP2_PORT_SERDES_CFG0_SYNC_FAIL_INT_ENABLE_MASK \ + (0x00000001 << \ + MVPP2_PORT_SERDES_CFG0_SYNC_FAIL_INT_ENABLE_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_MASTER_MODE_ENABLE_OFFS 11 +#define MVPP2_PORT_SERDES_CFG0_MASTER_MODE_ENABLE_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_MASTER_MODE_ENABLE_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_TERM75_TX_OFFS 12 +#define MVPP2_PORT_SERDES_CFG0_TERM75_TX_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_TERM75_TX_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_OUTAMP_OFFS 13 +#define MVPP2_PORT_SERDES_CFG0_OUTAMP_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_OUTAMP_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_BTS712_FIX_EN_OFFS 14 +#define MVPP2_PORT_SERDES_CFG0_BTS712_FIX_EN_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_BTS712_FIX_EN_OFFS) + +#define MVPP2_PORT_SERDES_CFG0_BTS156_FIX_EN_OFFS 15 +#define MVPP2_PORT_SERDES_CFG0_BTS156_FIX_EN_MASK \ + (0x00000001 << MVPP2_PORT_SERDES_CFG0_BTS156_FIX_EN_OFFS) + +/* Port Serdes Configuration1 */ +#define MVPP2_PORT_SERDES_CFG1_REG (0x002c) +#define MVPP2_PORT_SERDES_CFG1_SMII_RX_10MB_CLK_EDGE_SEL_OFFS 0 +#define MVPP2_PORT_SERDES_CFG1_SMII_RX_10MB_CLK_EDGE_SEL_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_SMII_RX_10MB_CLK_EDGE_SEL_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_SMII_TX_10MB_CLK_EDGE_SEL_OFFS 1 +#define MVPP2_GMAC_PORT_SERDES_CFG1_SMII_TX_10MB_CLK_EDGE_SEL_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_SMII_TX_10MB_CLK_EDGE_SEL_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_MEN_OFFS 2 +#define MVPP2_GMAC_PORT_SERDES_CFG1_MEN_MASK \ + (0x00000003 << MVPP2_GMAC_PORT_SERDES_CFG1_MEN_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_VCMS_OFFS 4 +#define MVPP2_GMAC_PORT_SERDES_CFG1_VCMS_MASK \ + (0x00000001 << MVPP2_GMAC_PORT_SERDES_CFG1_VCMS_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_USE_SIGDET_OFFS 5 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_USE_SIGDET_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_USE_SIGDET_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_EN_CRS_MASK_TX_OFFS 6 +#define MVPP2_GMAC_PORT_SERDES_CFG1_EN_CRS_MASK_TX_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_EN_CRS_MASK_TX_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_ENABLE_OFFS 7 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_ENABLE_MASK \ + (0x00000001 << MVPP2_GMAC_PORT_SERDES_CFG1_100FX_ENABLE_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_PHY_ADDRESS_OFFS 8 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_PHY_ADDRESS_MASK \ + (0x0000001f << \ + MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_PHY_ADDRESS_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SIGDET_POLARITY_OFFS 13 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SIGDET_POLARITY_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SIGDET_POLARITY_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_INTERRUPT_POLARITY_OFFS 14 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_INTERRUPT_POLARITY_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_INTERRUPT_POLARITY_OFFS) + +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SERDES_POLARITY_OFFS 15 +#define MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SERDES_POLARITY_MASK \ + (0x00000001 << \ + MVPP2_GMAC_PORT_SERDES_CFG1_100FX_PCS_SERDES_POLARITY_OFFS) + +/* Port Serdes Configuration2 */ +#define MVPP2_PORT_SERDES_CFG2_REG (0x0030) +#define MVPP2_PORT_SERDES_CFG2_AN_ADV_CONFIGURATION_OFFS 0 +#define MVPP2_PORT_SERDES_CFG2_AN_ADV_CONFIGURATION_MASK \ + (0x0000ffff << \ + MVPP2_PORT_SERDES_CFG2_AN_ADV_CONFIGURATION_OFFS) + +/* Port Serdes Configuration3 */ +#define MVPP2_PORT_SERDES_CFG3_REG (0x0034) +#define MVPP2_PORT_SERDES_CFG3_ABILITY_MATCH_STATUS_OFFS 0 +#define MVPP2_PORT_SERDES_CFG3_ABILITY_MATCH_STATUS_MASK \ + (0x0000ffff << \ + MVPP2_PORT_SERDES_CFG3_ABILITY_MATCH_STATUS_OFFS) + +/* Port Prbs Status */ +#define MVPP2_PORT_PRBS_STATUS_REG (0x0038) +#define MVPP2_PORT_PRBS_STATUS_PRBSCHECK_LOCKED_OFFS 0 +#define MVPP2_PORT_PRBS_STATUS_PRBSCHECK_LOCKED_MASK \ + (0x00000001 << MVPP2_PORT_PRBS_STATUS_PRBSCHECK_LOCKED_OFFS) + +#define MVPP2_PORT_PRBS_STATUS_PRBSCHECKRDY_OFFS 1 +#define MVPP2_PORT_PRBS_STATUS_PRBSCHECKRDY_MASK \ + (0x00000001 << MVPP2_PORT_PRBS_STATUS_PRBSCHECKRDY_OFFS) + +/* Port Prbs Error Counter */ +#define MVPP2_PORT_PRBS_ERR_CNTR_REG (0x003c) +#define MVPP2_PORT_PRBS_ERR_CNTR_PRBSBITERRCNT_OFFS 0 +#define MVPP2_PORT_PRBS_ERR_CNTR_PRBSBITERRCNT_MASK \ + (0x0000ffff << MVPP2_PORT_PRBS_ERR_CNTR_PRBSBITERRCNT_OFFS) + +/* Port Status1 */ +#define MVPP2_PORT_STATUS1_REG (0x0040) +#define MVPP2_PORT_STATUS1_MEDIAACTIVE_OFFS 0 +#define MVPP2_PORT_STATUS1_MEDIAACTIVE_MASK \ + (0x00000001 << MVPP2_PORT_STATUS1_MEDIAACTIVE_OFFS) + +/* Port Mib Counters Control */ +#define MVPP2_PORT_MIB_CNTRS_CTRL_REG (0x0044) +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_COPY_TRIGGER_OFFS 0 +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_COPY_TRIGGER_MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_MIB_COPY_TRIGGER_OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_CLEAR_ON_READ__OFFS 1 +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_CLEAR_ON_READ__MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_MIB_CLEAR_ON_READ__OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_RX_HISTOGRAM_EN_OFFS 2 +#define MVPP2_PORT_MIB_CNTRS_CTRL_RX_HISTOGRAM_EN_MASK \ + (0x00000001 << MVPP2_PORT_MIB_CNTRS_CTRL_RX_HISTOGRAM_EN_OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_TX_HISTOGRAM_EN_OFFS 3 +#define MVPP2_PORT_MIB_CNTRS_CTRL_TX_HISTOGRAM_EN_MASK \ + (0x00000001 << MVPP2_PORT_MIB_CNTRS_CTRL_TX_HISTOGRAM_EN_OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__OFFS 4 +#define MVPP2_PORT_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_XCAT_BTS_340_EN__OFFS 5 +#define MVPP2_PORT_MIB_CNTRS_CTRL_XCAT_BTS_340_EN__MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_XCAT_BTS_340_EN__OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_OFFS 6 +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_OFFS) + +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_OFFS 7 +#define MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_MASK \ + (0x00000001 << \ + MVPP2_PORT_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_OFFS) + +/* Port Mac Control3 */ +#define MVPP2_PORT_CTRL3_REG (0x0048) +#define MVPP2_PORT_CTRL3_BUF_SIZE_OFFS 0 +#define MVPP2_PORT_CTRL3_BUF_SIZE_MASK \ + (0x0000003f << MVPP2_PORT_CTRL3_BUF_SIZE_OFFS) + +#define MVPP2_PORT_CTRL3_IPG_DATA_OFFS 6 +#define MVPP2_PORT_CTRL3_IPG_DATA_MASK \ + (0x000001ff << MVPP2_PORT_CTRL3_IPG_DATA_OFFS) + +#define MVPP2_PORT_CTRL3_LLFC_GLOBAL_FC_ENABLE_OFFS 15 +#define MVPP2_PORT_CTRL3_LLFC_GLOBAL_FC_ENABLE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL3_LLFC_GLOBAL_FC_ENABLE_OFFS) +#define MVPP2_CAUSE_TXQ_SENT_DESC_ALL_MASK 0xff + +/* Port Mac Control4 */ +#define MVPP2_PORT_CTRL4_REG (0x0090) +#define MVPP2_PORT_CTRL4_EXT_PIN_GMII_SEL_OFFS 0 +#define MVPP2_PORT_CTRL4_EXT_PIN_GMII_SEL_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_EXT_PIN_GMII_SEL_OFFS) + +#define MVPP2_PORT_CTRL4_PREAMBLE_FIX_OFFS 1 +#define MVPP2_PORT_CTRL4_PREAMBLE_FIX_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_PREAMBLE_FIX_OFFS) + +#define MVPP2_PORT_CTRL4_SQ_DETECT_FIX_EN_OFFS 2 +#define MVPP2_PORT_CTRL4_SQ_DETECT_FIX_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_SQ_DETECT_FIX_EN_OFFS) + +#define MVPP2_PORT_CTRL4_FC_EN_RX_OFFS 3 +#define MVPP2_PORT_CTRL4_FC_EN_RX_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_FC_EN_RX_OFFS) + +#define MVPP2_PORT_CTRL4_FC_EN_TX_OFFS 4 +#define MVPP2_PORT_CTRL4_FC_EN_TX_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_FC_EN_TX_OFFS) + +#define MVPP2_PORT_CTRL4_DP_CLK_SEL_OFFS 5 +#define MVPP2_PORT_CTRL4_DP_CLK_SEL_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_DP_CLK_SEL_OFFS) + +#define MVPP2_PORT_CTRL4_SYNC_BYPASS_OFFS 6 +#define MVPP2_PORT_CTRL4_SYNC_BYPASS_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_SYNC_BYPASS_OFFS) + +#define MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_OFFS 7 +#define MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_QSGMII_BYPASS_ACTIVE_OFFS) + +#define MVPP2_PORT_CTRL4_COUNT_EXTERNAL_FC_EN_OFFS 8 +#define MVPP2_PORT_CTRL4_COUNT_EXTERNAL_FC_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_COUNT_EXTERNAL_FC_EN_OFFS) + +#define MVPP2_PORT_CTRL4_MARVELL_HEADER_EN_OFFS 9 +#define MVPP2_PORT_CTRL4_MARVELL_HEADER_EN_MASK \ + (0x00000001 << MVPP2_PORT_CTRL4_MARVELL_HEADER_EN_OFFS) + +#define MVPP2_PORT_CTRL4_LEDS_NUMBER_OFFS 10 +#define MVPP2_PORT_CTRL4_LEDS_NUMBER_MASK \ + (0x0000003f << MVPP2_PORT_CTRL4_LEDS_NUMBER_OFFS) + +/* Descriptor ring Macros */ +#define MVPP2_QUEUE_NEXT_DESC(q, index) \ + (((index) < (q)->LastDesc) ? ((index) + 1) : 0) + +/* Various constants */ + +/* Coalescing */ +#define MVPP2_TXDONE_COAL_PKTS_THRESH 15 +#define MVPP2_TXDONE_HRTIMER_PERIOD_NS 1000000UL +#define MVPP2_RX_COAL_PKTS 32 +#define MVPP2_RX_COAL_USEC 100 + +/* The two bytes Marvell header. Either contains a special value used + * by Marvell switches when a specific hardware mode is enabled (not + * supported by this driver) or is filled automatically by zeroes on + * the RX side. Those two bytes being at the front of the Ethernet + * header, they allow to have the IP header aligned on a 4 bytes + * boundary automatically: the hardware skips those two bytes on its + * own. + */ +#define MVPP2_MH_SIZE 2 +#define MVPP2_ETH_TYPE_LEN 2 +#define MVPP2_PPPOE_HDR_SIZE 8 +#define MVPP2_VLAN_TAG_LEN 4 + +/* Lbtd 802.3 type */ +#define MVPP2_IP_LBDT_TYPE 0xfffa + +#define MVPP2_CPU_D_CACHE_LINE_SIZE 32 +#define MVPP2_TX_CSUM_MAX_SIZE 9800 + +/* Timeout constants */ +#define MVPP2_TX_DISABLE_TIMEOUT_MSEC 1000 +#define MVPP2_TX_PENDING_TIMEOUT_MSEC 1000 + +#define MVPP2_TX_MTU_MAX 0x7ffff + +/* Maximum number of T-CONTs of PON port */ +#define MVPP2_MAX_TCONT 16 + +/* Maximum number of supported ports */ +#define MVPP2_MAX_PORTS 4 + +/* Maximum number of TXQs used by single port */ +#define MVPP2_MAX_TXQ 8 + +/* Maximum number of RXQs used by single port */ +#define MVPP2_MAX_RXQ 8 + +/* Dfault number of RXQs in use */ +#define MVPP2_DEFAULT_RXQ 4 + +/* Total number of RXQs available to all ports */ +#define MVPP2_RXQ_TOTAL_NUM (MVPP2_MAX_PORTS * MVPP2_MAX_RXQ) + +/* Max number of Rx descriptors */ +#define MVPP2_MAX_RXD 32 + +/* Max number of Tx descriptors */ +#define MVPP2_MAX_TXD 32 + +/* Amount of Tx descriptors that can be reserved at once by CPU */ +#define MVPP2_CPU_DESC_CHUNK 64 + +/* Max number of Tx descriptors in each aggregated queue */ +#define MVPP2_AGGR_TXQ_SIZE 256 + +/* Descriptor aligned size */ +#define MVPP2_DESC_ALIGNED_SIZE 32 + +/* Descriptor alignment mask */ +#define MVPP2_TX_DESC_ALIGN (MVPP2_DESC_ALIGNED_SIZE - 1) + +/* RX FIFO constants */ +#define MVPP2_RX_FIFO_PORT_DATA_SIZE 0x2000 +#define MVPP2_RX_FIFO_PORT_ATTR_SIZE 0x80 +#define MVPP2_RX_FIFO_PORT_MIN_PKT 0x80 + +#define MVPP2_BIT_TO_BYTE(bit) ((bit) / 8) + +/* IPv6 max L3 address size */ +#define MVPP2_MAX_L3_ADDR_SIZE 16 + +/* Port flags */ +#define MVPP2_F_LOOPBACK BIT(0) + +/* Marvell tag types */ +enum Mvpp2TagType { + MVPP2_TAG_TYPE_NONE = 0, + MVPP2_TAG_TYPE_MH = 1, + MVPP2_TAG_TYPE_DSA = 2, + MVPP2_TAG_TYPE_EDSA = 3, + MVPP2_TAG_TYPE_VLAN = 4, + MVPP2_TAG_TYPE_LAST = 5 +}; + +/* Parser constants */ +#define MVPP2_PRS_TCAM_SRAM_SIZE 256 +#define MVPP2_PRS_TCAM_WORDS 6 +#define MVPP2_PRS_SRAM_WORDS 4 +#define MVPP2_PRS_FLOW_ID_SIZE 64 +#define MVPP2_PRS_FLOW_ID_MASK 0x3f +#define MVPP2_PRS_TCAM_ENTRY_INVALID 1 +#define MVPP2_PRS_TCAM_DSA_TAGGED_BIT BIT(5) +#define MVPP2_PRS_IPV4_HEAD 0x40 +#define MVPP2_PRS_IPV4_HEAD_MASK 0xf0 +#define MVPP2_PRS_IPV4_MC 0xe0 +#define MVPP2_PRS_IPV4_MC_MASK 0xf0 +#define MVPP2_PRS_IPV4_BC_MASK 0xff +#define MVPP2_PRS_IPV4_IHL 0x5 +#define MVPP2_PRS_IPV4_IHL_MASK 0xf +#define MVPP2_PRS_IPV6_MC 0xff +#define MVPP2_PRS_IPV6_MC_MASK 0xff +#define MVPP2_PRS_IPV6_HOP_MASK 0xff +#define MVPP2_PRS_TCAM_PROTO_MASK 0xff +#define MVPP2_PRS_TCAM_PROTO_MASK_L 0x3f +#define MVPP2_PRS_DBL_VLANS_MAX 100 + +/* Tcam structure: + * - lookup ID - 4 bits + * - port ID - 1 byte + * - additional information - 1 byte + * - header data - 8 bytes + * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(5)->(0). + */ +#define MVPP2_PRS_AI_BITS 8 +#define MVPP2_PRS_PORT_MASK 0xff +#define MVPP2_PRS_LU_MASK 0xf +#define MVPP2_PRS_TCAM_DATA_BYTE(offs) \ + (((offs) - ((offs) % 2)) * 2 + ((offs) % 2)) +#define MVPP2_PRS_TCAM_DATA_BYTE_EN(offs) \ + (((offs) * 2) - ((offs) % 2) + 2) +#define MVPP2_PRS_TCAM_AI_BYTE 16 +#define MVPP2_PRS_TCAM_PORT_BYTE 17 +#define MVPP2_PRS_TCAM_LU_BYTE 20 +#define MVPP2_PRS_TCAM_EN_OFFS(offs) ((offs) + 2) +#define MVPP2_PRS_TCAM_INV_WORD 5 +/* Tcam entries ID */ +#define MVPP2_PE_DROP_ALL 0 +#define MVPP2_PE_FIRST_FREE_TID 1 +#define MVPP2_PE_LAST_FREE_TID (MVPP2_PRS_TCAM_SRAM_SIZE - 31) +#define MVPP2_PE_IP6_EXT_PROTO_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 30) +#define MVPP2_PE_MAC_MC_IP6 (MVPP2_PRS_TCAM_SRAM_SIZE - 29) +#define MVPP2_PE_IP6_ADDR_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 28) +#define MVPP2_PE_IP4_ADDR_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 27) +#define MVPP2_PE_LAST_DEFAULT_FLOW (MVPP2_PRS_TCAM_SRAM_SIZE - 26) +#define MVPP2_PE_FIRST_DEFAULT_FLOW (MVPP2_PRS_TCAM_SRAM_SIZE - 19) +#define MVPP2_PE_EDSA_TAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 18) +#define MVPP2_PE_EDSA_UNTAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 17) +#define MVPP2_PE_DSA_TAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 16) +#define MVPP2_PE_DSA_UNTAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 15) +#define MVPP2_PE_ETYPE_EDSA_TAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 14) +#define MVPP2_PE_ETYPE_EDSA_UNTAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 13) +#define MVPP2_PE_ETYPE_DSA_TAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 12) +#define MVPP2_PE_ETYPE_DSA_UNTAGGED (MVPP2_PRS_TCAM_SRAM_SIZE - 11) +#define MVPP2_PE_MH_DEFAULT (MVPP2_PRS_TCAM_SRAM_SIZE - 10) +#define MVPP2_PE_DSA_DEFAULT (MVPP2_PRS_TCAM_SRAM_SIZE - 9) +#define MVPP2_PE_IP6_PROTO_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 8) +#define MVPP2_PE_IP4_PROTO_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 7) +#define MVPP2_PE_ETH_TYPE_UN (MVPP2_PRS_TCAM_SRAM_SIZE - 6) +#define MVPP2_PE_VLAN_DBL (MVPP2_PRS_TCAM_SRAM_SIZE - 5) +#define MVPP2_PE_VLAN_NONE (MVPP2_PRS_TCAM_SRAM_SIZE - 4) +#define MVPP2_PE_MAC_MC_ALL (MVPP2_PRS_TCAM_SRAM_SIZE - 3) +#define MVPP2_PE_MAC_PROMISCUOUS (MVPP2_PRS_TCAM_SRAM_SIZE - 2) +#define MVPP2_PE_MAC_NON_PROMISCUOUS (MVPP2_PRS_TCAM_SRAM_SIZE - 1) + +/* Sram structure + * The fields are represented by MVPP2_PRS_TCAM_DATA_REG(3)->(0). + */ +#define MVPP2_PRS_SRAM_RI_OFFS 0 +#define MVPP2_PRS_SRAM_RI_WORD 0 +#define MVPP2_PRS_SRAM_RI_CTRL_OFFS 32 +#define MVPP2_PRS_SRAM_RI_CTRL_WORD 1 +#define MVPP2_PRS_SRAM_RI_CTRL_BITS 32 +#define MVPP2_PRS_SRAM_SHIFT_OFFS 64 +#define MVPP2_PRS_SRAM_SHIFT_SIGN_BIT 72 +#define MVPP2_PRS_SRAM_UDF_OFFS 73 +#define MVPP2_PRS_SRAM_UDF_BITS 8 +#define MVPP2_PRS_SRAM_UDF_MASK 0xff +#define MVPP2_PRS_SRAM_UDF_SIGN_BIT 81 +#define MVPP2_PRS_SRAM_UDF_TYPE_OFFS 82 +#define MVPP2_PRS_SRAM_UDF_TYPE_MASK 0x7 +#define MVPP2_PRS_SRAM_UDF_TYPE_L3 1 +#define MVPP2_PRS_SRAM_UDF_TYPE_L4 4 +#define MVPP2_PRS_SRAM_OP_SEL_SHIFT_OFFS 85 +#define MVPP2_PRS_SRAM_OP_SEL_SHIFT_MASK 0x3 +#define MVPP2_PRS_SRAM_OP_SEL_SHIFT_ADD 1 +#define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP4_ADD 2 +#define MVPP2_PRS_SRAM_OP_SEL_SHIFT_IP6_ADD 3 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_OFFS 87 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_BITS 2 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_MASK 0x3 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_ADD 0 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_IP4_ADD 2 +#define MVPP2_PRS_SRAM_OP_SEL_UDF_IP6_ADD 3 +#define MVPP2_PRS_SRAM_OP_SEL_BASE_OFFS 89 +#define MVPP2_PRS_SRAM_AI_OFFS 90 +#define MVPP2_PRS_SRAM_AI_CTRL_OFFS 98 +#define MVPP2_PRS_SRAM_AI_CTRL_BITS 8 +#define MVPP2_PRS_SRAM_AI_MASK 0xff +#define MVPP2_PRS_SRAM_NEXT_LU_OFFS 106 +#define MVPP2_PRS_SRAM_NEXT_LU_MASK 0xf +#define MVPP2_PRS_SRAM_LU_DONE_BIT 110 +#define MVPP2_PRS_SRAM_LU_GEN_BIT 111 + +/* Sram result info bits assignment */ +#define MVPP2_PRS_RI_MAC_ME_MASK 0x1 +#define MVPP2_PRS_RI_DSA_MASK 0x2 +#define MVPP2_PRS_RI_VLAN_MASK 0xc +#define MVPP2_PRS_RI_VLAN_NONE ~(BIT(2) | BIT(3)) +#define MVPP2_PRS_RI_VLAN_SINGLE BIT(2) +#define MVPP2_PRS_RI_VLAN_DOUBLE BIT(3) +#define MVPP2_PRS_RI_VLAN_TRIPLE (BIT(2) | BIT(3)) +#define MVPP2_PRS_RI_CPU_CODE_MASK 0x70 +#define MVPP2_PRS_RI_CPU_CODE_RX_SPEC BIT(4) +#define MVPP2_PRS_RI_L2_CAST_MASK 0x600 +#define MVPP2_PRS_RI_L2_UCAST ~(BIT(9) | BIT(10)) +#define MVPP2_PRS_RI_L2_MCAST BIT(9) +#define MVPP2_PRS_RI_L2_BCAST BIT(10) +#define MVPP2_PRS_RI_PPPOE_MASK 0x800 +#define MVPP2_PRS_RI_L3_PROTO_MASK 0x7000 +#define MVPP2_PRS_RI_L3_UN ~(BIT(12) | BIT(13) | BIT(14)) +#define MVPP2_PRS_RI_L3_IP4 BIT(12) +#define MVPP2_PRS_RI_L3_IP4_OPT BIT(13) +#define MVPP2_PRS_RI_L3_IP4_OTHER (BIT(12) | BIT(13)) +#define MVPP2_PRS_RI_L3_IP6 BIT(14) +#define MVPP2_PRS_RI_L3_IP6_EXT (BIT(12) | BIT(14)) +#define MVPP2_PRS_RI_L3_ARP (BIT(13) | BIT(14)) +#define MVPP2_PRS_RI_L3_ADDR_MASK 0x18000 +#define MVPP2_PRS_RI_L3_UCAST ~(BIT(15) | BIT(16)) +#define MVPP2_PRS_RI_L3_MCAST BIT(15) +#define MVPP2_PRS_RI_L3_BCAST (BIT(15) | BIT(16)) +#define MVPP2_PRS_RI_IP_FRAG_MASK 0x20000 +#define MVPP2_PRS_RI_UDF3_MASK 0x300000 +#define MVPP2_PRS_RI_UDF3_RX_SPECIAL BIT(21) +#define MVPP2_PRS_RI_L4_PROTO_MASK 0x1c00000 +#define MVPP2_PRS_RI_L4_TCP BIT(22) +#define MVPP2_PRS_RI_L4_UDP BIT(23) +#define MVPP2_PRS_RI_L4_OTHER (BIT(22) | BIT(23)) +#define MVPP2_PRS_RI_UDF7_MASK 0x60000000 +#define MVPP2_PRS_RI_UDF7_IP6_LITE BIT(29) +#define MVPP2_PRS_RI_DROP_MASK 0x80000000 + +/* Sram additional info bits assignment */ +#define MVPP2_PRS_IPV4_DIP_AI_BIT BIT(0) +#define MVPP2_PRS_IPV6_NO_EXT_AI_BIT BIT(0) +#define MVPP2_PRS_IPV6_EXT_AI_BIT BIT(1) +#define MVPP2_PRS_IPV6_EXT_AH_AI_BIT BIT(2) +#define MVPP2_PRS_IPV6_EXT_AH_LEN_AI_BIT BIT(3) +#define MVPP2_PRS_IPV6_EXT_AH_L4_AI_BIT BIT(4) +#define MVPP2_PRS_SINGLE_VLAN_AI 0 +#define MVPP2_PRS_DBL_VLAN_AI_BIT BIT(7) + +/* DSA/EDSA type */ +#define MVPP2_PRS_TAGGED TRUE +#define MVPP2_PRS_UNTAGGED FALSE +#define MVPP2_PRS_EDSA TRUE +#define MVPP2_PRS_DSA FALSE + +/* MAC entries, shadow udf */ +enum Mvpp2PrsUdf { + MVPP2_PRS_UDF_MAC_DEF, + MVPP2_PRS_UDF_MAC_RANGE, + MVPP2_PRS_UDF_L2_DEF, + MVPP2_PRS_UDF_L2_DEF_COPY, + MVPP2_PRS_UDF_L2_USER, +}; + +/* Lookup ID */ +enum Mvpp2PrsLookup { + MVPP2_PRS_LU_MH, + MVPP2_PRS_LU_MAC, + MVPP2_PRS_LU_DSA, + MVPP2_PRS_LU_VLAN, + MVPP2_PRS_LU_L2, + MVPP2_PRS_LU_PPPOE, + MVPP2_PRS_LU_IP4, + MVPP2_PRS_LU_IP6, + MVPP2_PRS_LU_FLOWS, + MVPP2_PRS_LU_LAST, +}; + +/* L3 cast enum */ +enum Mvpp2PrsL3Cast { + MVPP2_PRS_L3_UNI_CAST, + MVPP2_PRS_L3_MULTI_CAST, + MVPP2_PRS_L3_BROAD_CAST +}; + +/* Classifier constants */ +#define MVPP2_CLS_FLOWS_TBL_SIZE 512 +#define MVPP2_CLS_FLOWS_TBL_DATA_WORDS 3 +#define MVPP2_CLS_LKP_TBL_SIZE 64 + +/* BM cookie (32 bits) definition */ +#define MVPP2_BM_COOKIE_POOL_OFFS 8 +#define MVPP2_BM_COOKIE_CPU_OFFS 24 + +/* The MVPP2_TX_DESC and MVPP2_RX_DESC structures describe the + * layout of the transmit and reception DMA descriptors, and their + * layout is therefore defined by the hardware design + */ + +#define MVPP2_TXD_L3_OFF_SHIFT 0 +#define MVPP2_TXD_IP_HLEN_SHIFT 8 +#define MVPP2_TXD_L4_CSUM_FRAG BIT(13) +#define MVPP2_TXD_L4_CSUM_NOT BIT(14) +#define MVPP2_TXD_IP_CSUM_DISABLE BIT(15) +#define MVPP2_TXD_PADDING_DISABLE BIT(23) +#define MVPP2_TXD_L4_UDP BIT(24) +#define MVPP2_TXD_L3_IP6 BIT(26) +#define MVPP2_TXD_L_DESC BIT(28) +#define MVPP2_TXD_F_DESC BIT(29) + +#define MVPP2_RXD_ERR_SUMMARY BIT(15) +#define MVPP2_RXD_ERR_CODE_MASK (BIT(13) | BIT(14)) +#define MVPP2_RXD_ERR_CRC 0x0 +#define MVPP2_RXD_ERR_OVERRUN BIT(13) +#define MVPP2_RXD_ERR_RESOURCE (BIT(13) | BIT(14)) +#define MVPP2_RXD_BM_POOL_ID_OFFS 16 +#define MVPP2_RXD_BM_POOL_ID_MASK (BIT(16) | BIT(17) | BIT(18)) +#define MVPP2_RXD_HWF_SYNC BIT(21) +#define MVPP2_RXD_L4_CSUM_OK BIT(22) +#define MVPP2_RXD_IP4_HEADER_ERR BIT(24) +#define MVPP2_RXD_L4_TCP BIT(25) +#define MVPP2_RXD_L4_UDP BIT(26) +#define MVPP2_RXD_L3_IP4 BIT(28) +#define MVPP2_RXD_L3_IP6 BIT(30) +#define MVPP2_RXD_BUF_HDR BIT(31) + +typedef struct { + UINT32 command; /* Options used by HW for packet transmitting.*/ + UINT8 PacketOffset; /* the offset from the buffer beginning */ + UINT8 PhysTxq; /* destination queue ID */ + UINT16 DataSize; /* data size of transmitted packet in bytes */ +#ifdef MVPP2_V1 + UINT32 BufPhysAddr; /* physical addr of transmitted buffer */ + UINT32 BufCookie; /* cookie for access to TX buffer in tx path */ + UINT32 reserved1[3]; /* HwCmd (for future use, BM, PON, PNC) */ + UINT32 reserved2; /* reserved (for future use) */ +#else + UINT64 RsrvdHwCmd1; /* HwCmd (BM, PON, PNC) */ + UINT64 BufPhysAddrHwCmd2; + UINT64 BufCookieBmQsetHwCmd3; +#endif +} MVPP2_TX_DESC; + +typedef struct { + UINT32 status; /* info about received packet */ + UINT16 reserved1; /* ParserInfo (for future use, PnC) */ + UINT16 DataSize; /* size of received packet in bytes */ +#ifdef MVPP2_V1 + UINT32 BufPhysAddr; /* physical address of the buffer */ + UINT32 BufCookie; /* cookie for access to RX buffer in rx path */ + UINT16 reserved2; /* GemPortId (for future use, PON) */ + UINT16 reserved3; /* CsumL4 (for future use, PnC) */ + UINT8 reserved4; /* BmQset (for future use, BM) */ + UINT8 reserved5; + UINT16 reserved6; /* ClassifyInfo (for future use, PnC) */ + UINT32 reserved7; /* FlowId (for future use, PnC) */ + UINT32 reserved8; +#else + UINT16 RsrvdGem; /* GemPortId (for future use, PON) */ + UINT16 RsrvdL4csum; /* CsumL4 (for future use, PnC) */ + UINT32 RsrvdTimestamp; + UINT64 BufPhysAddrKeyHash; + UINT64 BufCookieBmQsetClsInfo; +#endif +} MVPP2_RX_DESC; + +union Mvpp2PrsTcamEntry { + UINT32 word[MVPP2_PRS_TCAM_WORDS]; + UINT8 byte[MVPP2_PRS_TCAM_WORDS * 4]; +}; + +union Mvpp2PrsSramEntry { + UINT32 word[MVPP2_PRS_SRAM_WORDS]; + UINT8 byte[MVPP2_PRS_SRAM_WORDS * 4]; +}; + +typedef struct { + UINT32 index; + union Mvpp2PrsTcamEntry tcam; + union Mvpp2PrsSramEntry sram; +} MVPP2_PRS_ENTRY; + +typedef struct { + BOOLEAN valid; + BOOLEAN finish; + + /* Lookup ID */ + INT32 lu; + + /* User defined offset */ + INT32 udf; + + /* Result info */ + UINT32 ri; + UINT32 RiMask; +} MVPP2_PRS_SHADOW; + +typedef struct { + UINT32 index; + UINT32 data[MVPP2_CLS_FLOWS_TBL_DATA_WORDS]; +} MVPP2_CLS_FLOW_ENTRY; + +typedef struct { + UINT32 lkpid; + UINT32 way; + UINT32 data; +} MVPP2_CLS_LOOKUP_ENTRY; + +typedef struct { + UINT32 NextBuffPhysAddr; + UINT32 NextBuffVirtAddr; + UINT16 ByteCount; + UINT16 info; + UINT8 reserved1; /* BmQset (for future use, BM) */ +} MVPP2_BUFF_HDR; + +/* Buffer header info bits */ +#define MVPP2_B_HDR_INFO_MC_ID_MASK 0xfff +#define MVPP2_B_HDR_INFO_MC_ID(info) ((info) & MVPP2_B_HDR_INFO_MC_ID_MASK) +#define MVPP2_B_HDR_INFO_LAST_OFFS 12 +#define MVPP2_B_HDR_INFO_LAST_MASK BIT(12) +#define MVPP2_B_HDR_INFO_IS_LAST(info) \ + ((info & MVPP2_B_HDR_INFO_LAST_MASK) >> MVPP2_B_HDR_INFO_LAST_OFFS) + +/* SD1 Control1 */ +#define SD1_CONTROL_1_REG (0x148) + +#define SD1_CONTROL_XAUI_EN_OFFSET 28 +#define SD1_CONTROL_XAUI_EN_MASK (0x1 << SD1_CONTROL_XAUI_EN_OFFSET) + +#define SD1_CONTROL_RXAUI0_L23_EN_OFFSET 27 +#define SD1_CONTROL_RXAUI0_L23_EN_MASK (0x1 << \ + SD1_CONTROL_RXAUI0_L23_EN_OFFSET) + +#define SD1_CONTROL_RXAUI1_L45_EN_OFFSET 26 +#define SD1_CONTROL_RXAUI1_L45_EN_MASK (0x1 << \ + SD1_CONTROL_RXAUI1_L45_EN_OFFSET) + +/* System Soft Reset 1 */ +#define MV_GOP_SOFT_RESET_1_REG 0x108 + +#define NETC_GOP_SOFT_RESET_OFFSET 6 +#define NETC_GOP_SOFT_RESET_MASK (0x1 << NETC_GOP_SOFT_RESET_OFFSET) + +/* Ports Control 0 */ +#define MV_NETCOMP_PORTS_CONTROL_0 (0x110) + +#define NETC_CLK_DIV_PHASE_OFFSET 31 +#define NETC_CLK_DIV_PHASE_MASK (0x1 << NETC_CLK_DIV_PHASE_OFFSET) + +#define NETC_GIG_RX_DATA_SAMPLE_OFFSET 29 +#define NETC_GIG_RX_DATA_SAMPLE_MASK (0x1 << NETC_GIG_RX_DATA_SAMPLE_OFFSET) + +#define NETC_BUS_WIDTH_SELECT_OFFSET 1 +#define NETC_BUS_WIDTH_SELECT_MASK (0x1 << NETC_BUS_WIDTH_SELECT_OFFSET) + +#define NETC_GOP_ENABLE_OFFSET 0 +#define NETC_GOP_ENABLE_MASK (0x1 << NETC_GOP_ENABLE_OFFSET) + +/* Ports Control 1 */ +#define MV_NETCOMP_PORTS_CONTROL_1 (0x114) + +#define NETC_PORT_GIG_RF_RESET_OFFSET(port) (28 + port) +#define NETC_PORT_GIG_RF_RESET_MASK(port) \ + (0x1 << NETC_PORT_GIG_RF_RESET_OFFSET(port)) + +#define NETC_PORTS_ACTIVE_OFFSET(port) (0 + port) +#define NETC_PORTS_ACTIVE_MASK(port) (0x1 << NETC_PORTS_ACTIVE_OFFSET(port)) + +/* Ports Status */ +#define MV_NETCOMP_PORTS_STATUS (0x11C) +#define NETC_PORTS_STATUS_OFFSET(port) (0 + port) +#define NETC_PORTS_STATUS_MASK(port) (0x1 << NETC_PORTS_STATUS_OFFSET(port)) + +/* Networking Complex Control 0 */ +#define MV_NETCOMP_CONTROL_0 (0x120) + +#define NETC_GBE_PORT1_MII_MODE_OFFSET 2 +#define NETC_GBE_PORT1_MII_MODE_MASK \ + (0x1 << NETC_GBE_PORT1_MII_MODE_OFFSET) + +#define NETC_GBE_PORT1_SGMII_MODE_OFFSET 1 +#define NETC_GBE_PORT1_SGMII_MODE_MASK \ + (0x1 << NETC_GBE_PORT1_SGMII_MODE_OFFSET) + +#define NETC_GBE_PORT0_SGMII_MODE_OFFSET 0 +#define NETC_GBE_PORT0_SGMII_MODE_MASK \ + (0x1 << NETC_GBE_PORT0_SGMII_MODE_OFFSET) + +/* Port Mac Control0 */ +#define MV_XLG_PORT_MAC_CTRL0_REG (0x0000) +#define MV_XLG_MAC_CTRL0_PORTEN_OFFS 0 +#define MV_XLG_MAC_CTRL0_PORTEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_PORTEN_OFFS) + +#define MV_XLG_MAC_CTRL0_MACRESETN_OFFS 1 +#define MV_XLG_MAC_CTRL0_MACRESETN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_MACRESETN_OFFS) + +#define MV_XLG_MAC_CTRL0_FORCELINKDOWN_OFFS 2 +#define MV_XLG_MAC_CTRL0_FORCELINKDOWN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_FORCELINKDOWN_OFFS) + +#define MV_XLG_MAC_CTRL0_FORCELINKPASS_OFFS 3 +#define MV_XLG_MAC_CTRL0_FORCELINKPASS_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_FORCELINKPASS_OFFS) + +#define MV_XLG_MAC_CTRL0_TXIPGMODE_OFFS 5 +#define MV_XLG_MAC_CTRL0_TXIPGMODE_MASK \ + (0x00000003 << MV_XLG_MAC_CTRL0_TXIPGMODE_OFFS) + +#define MV_XLG_MAC_CTRL0_RXFCEN_OFFS 7 +#define MV_XLG_MAC_CTRL0_RXFCEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_RXFCEN_OFFS) + +#define MV_XLG_MAC_CTRL0_TXFCEN_OFFS 8 +#define MV_XLG_MAC_CTRL0_TXFCEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_TXFCEN_OFFS) + +#define MV_XLG_MAC_CTRL0_RXCRCCHECKEN_OFFS 9 +#define MV_XLG_MAC_CTRL0_RXCRCCHECKEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_RXCRCCHECKEN_OFFS) + +#define MV_XLG_MAC_CTRL0_PERIODICXONEN_OFFS 10 +#define MV_XLG_MAC_CTRL0_PERIODICXONEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_PERIODICXONEN_OFFS) + +#define MV_XLG_MAC_CTRL0_RXCRCSTRIPEN_OFFS 11 +#define MV_XLG_MAC_CTRL0_RXCRCSTRIPEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_RXCRCSTRIPEN_OFFS) + +#define MV_XLG_MAC_CTRL0_PADDINGDIS_OFFS 13 +#define MV_XLG_MAC_CTRL0_PADDINGDIS_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_PADDINGDIS_OFFS) + +#define MV_XLG_MAC_CTRL0_MIBCNTDIS_OFFS 14 +#define MV_XLG_MAC_CTRL0_MIBCNTDIS_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_MIBCNTDIS_OFFS) + +#define MV_XLG_MAC_CTRL0_PFC_CASCADE_PORT_ENABLE_OFFS 15 +#define MV_XLG_MAC_CTRL0_PFC_CASCADE_PORT_ENABLE_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL0_PFC_CASCADE_PORT_ENABLE_OFFS) + +/* Port Mac Control1 */ +#define MV_XLG_PORT_MAC_CTRL1_REG (0x0004) +#define MV_XLG_MAC_CTRL1_FRAMESIZELIMIT_OFFS 0 +#define MV_XLG_MAC_CTRL1_FRAMESIZELIMIT_MASK \ + (0x00001fff << MV_XLG_MAC_CTRL1_FRAMESIZELIMIT_OFFS) + +#define MV_XLG_MAC_CTRL1_MACLOOPBACKEN_OFFS 13 +#define MV_XLG_MAC_CTRL1_MACLOOPBACKEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL1_MACLOOPBACKEN_OFFS) + +#define MV_XLG_MAC_CTRL1_XGMIILOOPBACKEN_OFFS 14 +#define MV_XLG_MAC_CTRL1_XGMIILOOPBACKEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL1_XGMIILOOPBACKEN_OFFS) + +#define MV_XLG_MAC_CTRL1_LOOPBACKCLOCKSELECT_OFFS 15 +#define MV_XLG_MAC_CTRL1_LOOPBACKCLOCKSELECT_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL1_LOOPBACKCLOCKSELECT_OFFS) + +/* Port Mac Control2 */ +#define MV_XLG_PORT_MAC_CTRL2_REG (0x0008) +#define MV_XLG_MAC_CTRL2_SALOW_7_0_OFFS 0 +#define MV_XLG_MAC_CTRL2_SALOW_7_0_MASK \ + (0x000000ff << MV_XLG_MAC_CTRL2_SALOW_7_0_OFFS) + +#define MV_XLG_MAC_CTRL2_UNIDIRECTIONALEN_OFFS 8 +#define MV_XLG_MAC_CTRL2_UNIDIRECTIONALEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL2_UNIDIRECTIONALEN_OFFS) + +#define MV_XLG_MAC_CTRL2_FIXEDIPGBASE_OFFS 9 +#define MV_XLG_MAC_CTRL2_FIXEDIPGBASE_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL2_FIXEDIPGBASE_OFFS) + +#define MV_XLG_MAC_CTRL2_PERIODICXOFFEN_OFFS 10 +#define MV_XLG_MAC_CTRL2_PERIODICXOFFEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL2_PERIODICXOFFEN_OFFS) + +#define MV_XLG_MAC_CTRL2_SIMPLEXMODEEN_OFFS 13 +#define MV_XLG_MAC_CTRL2_SIMPLEXMODEEN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL2_SIMPLEXMODEEN_OFFS) + +#define MV_XLG_MAC_CTRL2_FC_MODE_OFFS 14 +#define MV_XLG_MAC_CTRL2_FC_MODE_MASK \ + (0x00000003 << MV_XLG_MAC_CTRL2_FC_MODE_OFFS) + +/* Port Status */ +#define MV_XLG_MAC_PORT_STATUS_REG (0x000c) +#define MV_XLG_MAC_PORT_STATUS_LINKSTATUS_OFFS 0 +#define MV_XLG_MAC_PORT_STATUS_LINKSTATUS_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_LINKSTATUS_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_REMOTEFAULT_OFFS 1 +#define MV_XLG_MAC_PORT_STATUS_REMOTEFAULT_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_REMOTEFAULT_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_LOCALFAULT_OFFS 2 +#define MV_XLG_MAC_PORT_STATUS_LOCALFAULT_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_LOCALFAULT_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_LINKSTATUSCLEAN_OFFS 3 +#define MV_XLG_MAC_PORT_STATUS_LINKSTATUSCLEAN_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_LINKSTATUSCLEAN_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_LOCALFAULTCLEAN_OFFS 4 +#define MV_XLG_MAC_PORT_STATUS_LOCALFAULTCLEAN_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_LOCALFAULTCLEAN_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_REMOTEFAULTCLEAN_OFFS 5 +#define MV_XLG_MAC_PORT_STATUS_REMOTEFAULTCLEAN_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_REMOTEFAULTCLEAN_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_PORTRXPAUSE_OFFS 6 +#define MV_XLG_MAC_PORT_STATUS_PORTRXPAUSE_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_PORTRXPAUSE_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_PORTTXPAUSE_OFFS 7 +#define MV_XLG_MAC_PORT_STATUS_PORTTXPAUSE_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_PORTTXPAUSE_OFFS) + +#define MV_XLG_MAC_PORT_STATUS_PFC_SYNC_FIFO_FULL_OFFS 8 +#define MV_XLG_MAC_PORT_STATUS_PFC_SYNC_FIFO_FULL_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_STATUS_PFC_SYNC_FIFO_FULL_OFFS) + +/* Port Fifos Thresholds Configuration */ +#define MV_XLG_PORT_FIFOS_THRS_CFG_REG (0x001) +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_RXFULLTHR_OFFS 0 +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_RXFULLTHR_MASK \ + (0x0000001f << MV_XLG_MAC_PORT_FIFOS_THRS_CFG_RXFULLTHR_OFFS) + +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXFIFOSIZE_OFFS 5 +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXFIFOSIZE_MASK \ + (0x0000003f << MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXFIFOSIZE_OFFS) + +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXRDTHR_OFFS 11 +#define MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXRDTHR_MASK \ + (0x0000001f << MV_XLG_MAC_PORT_FIFOS_THRS_CFG_TXRDTHR_OFFS) + +/* Port Mac Control3 */ +#define MV_XLG_PORT_MAC_CTRL3_REG (0x001c) +#define MV_XLG_MAC_CTRL3_BUFSIZE_OFFS 0 +#define MV_XLG_MAC_CTRL3_BUFSIZE_MASK \ + (0x0000003f << MV_XLG_MAC_CTRL3_BUFSIZE_OFFS) + +#define MV_XLG_MAC_CTRL3_XTRAIPG_OFFS 6 +#define MV_XLG_MAC_CTRL3_XTRAIPG_MASK \ + (0x0000007f << MV_XLG_MAC_CTRL3_XTRAIPG_OFFS) + +#define MV_XLG_MAC_CTRL3_MACMODESELECT_OFFS 13 +#define MV_XLG_MAC_CTRL3_MACMODESELECT_MASK \ + (0x00000007 << MV_XLG_MAC_CTRL3_MACMODESELECT_OFFS) + +/* Port Per Prio Flow Control Status */ +#define MV_XLG_PORT_PER_PRIO_FLOW_CTRL_STATUS_REG (0x0020) +#define MV_XLG_MAC_PORT_PER_PRIO_FLOW_CTRL_STATUS_PRIONSTATUS_OFFS 0 +#define MV_XLG_MAC_PORT_PER_PRIO_FLOW_CTRL_STATUS_PRIONSTATUS_MASK \ + (0x00000001 << \ + MV_XLG_MAC_PORT_PER_PRIO_FLOW_CTRL_STATUS_PRIONSTATUS_OFFS) + +/* Debug Bus Status */ +#define MV_XLG_DEBUG_BUS_STATUS_REG (0x0024) +#define MV_XLG_MAC_DEBUG_BUS_STATUS_DEBUG_BUS_OFFS 0 +#define MV_XLG_MAC_DEBUG_BUS_STATUS_DEBUG_BUS_MASK \ + (0x0000ffff << MV_XLG_MAC_DEBUG_BUS_STATUS_DEBUG_BUS_OFFS) + +/* Port Metal Fix */ +#define MV_XLG_PORT_METAL_FIX_REG (0x002c) +#define MV_XLG_MAC_PORT_METAL_FIX_EN_EOP_IN_FIFO__OFFS 0 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_EOP_IN_FIFO__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_EOP_IN_FIFO__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_LTF_FIX__OFFS 1 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_LTF_FIX__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_LTF_FIX__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_HOLD_FIX__OFFS 2 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_HOLD_FIX__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_HOLD_FIX__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_LED_FIX__OFFS 3 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_LED_FIX__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_LED_FIX__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_PAD_PROTECT__OFFS 4 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_PAD_PROTECT__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_PAD_PROTECT__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS44__OFFS 5 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS44__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS44__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS42__OFFS 6 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS42__MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_NX_BTS42__OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_FLUSH_FIX_OFFS 7 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_FLUSH_FIX_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_FLUSH_FIX_OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_EN_PORT_EN_FIX_OFFS 8 +#define MV_XLG_MAC_PORT_METAL_FIX_EN_PORT_EN_FIX_MASK \ + (0x00000001 << MV_XLG_MAC_PORT_METAL_FIX_EN_PORT_EN_FIX_OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF0_BITS_OFFS 9 +#define MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF0_BITS_MASK \ + (0x0000000f << MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF0_BITS_OFFS) + +#define MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF1_BITS_OFFS 13 +#define MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF1_BITS_MASK \ + (0x00000007 << MV_XLG_MAC_PORT_METAL_FIX_SPARE_DEF1_BITS_OFFS) + +/* Xg Mib Counters Control */ +#define MV_XLG_MIB_CNTRS_CTRL_REG (0x0030) +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGCAPTURETRIGGER_OFFS 0 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGCAPTURETRIGGER_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGCAPTURETRIGGER_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGDONTCLEARAFTERREAD_OFFS 1 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGDONTCLEARAFTERREAD_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGDONTCLEARAFTERREAD_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGRXHISTOGRAMEN_OFFS 2 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGRXHISTOGRAMEN_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGRXHISTOGRAMEN_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGTXHISTOGRAMEN_OFFS 3 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGTXHISTOGRAMEN_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_XGTXHISTOGRAMEN_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__OFFS 4 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MFA1_BTT940_FIX_ENABLE__OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_LEDS_NUMBER_OFFS 5 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_LEDS_NUMBER_MASK \ + (0x0000003f << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_LEDS_NUMBER_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_OFFS 11 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_COUNT_HIST_OFFS) + +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_OFFS 12 +#define MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_MASK \ + (0x00000001 << \ + MV_XLG_MAC_XG_MIB_CNTRS_CTRL_MIB_4_LIMIT_1518_1522_OFFS) + +/* Cn/ccfc Timer%i */ +#define MV_XLG_CNCCFC_TIMERI_REG(t) ((0x0038 + t*4)) +#define MV_XLG_MAC_CNCCFC_TIMERI_PORTSPEEDTIMER_OFFS 0 +#define MV_XLG_MAC_CNCCFC_TIMERI_PORTSPEEDTIMER_MASK \ + (0x0000ffff << MV_XLG_MAC_CNCCFC_TIMERI_PORTSPEEDTIMER_OFFS) + +/* Ppfc Control */ +#define MV_XLG_MAC_PPFC_CTRL_REG (0x0060) +#define MV_XLG_MAC_PPFC_CTRL_GLOBAL_PAUSE_ENI_OFFS 0 +#define MV_XLG_MAC_PPFC_CTRL_GLOBAL_PAUSE_ENI_MASK \ + (0x00000001 << MV_XLG_MAC_PPFC_CTRL_GLOBAL_PAUSE_ENI_OFFS) + +#define MV_XLG_MAC_PPFC_CTRL_DIP_BTS_677_EN_OFFS 9 +#define MV_XLG_MAC_PPFC_CTRL_DIP_BTS_677_EN_MASK \ + (0x00000001 << MV_XLG_MAC_PPFC_CTRL_DIP_BTS_677_EN_OFFS) + +/* Fc Dsa Tag 0 */ +#define MV_XLG_MAC_FC_DSA_TAG_0_REG (0x0068) +#define MV_XLG_MAC_FC_DSA_TAG_0_DSATAGREG0_OFFS 0 +#define MV_XLG_MAC_FC_DSA_TAG_0_DSATAGREG0_MASK \ + (0x0000ffff << MV_XLG_MAC_FC_DSA_TAG_0_DSATAGREG0_OFFS) + +/* Fc Dsa Tag 1 */ +#define MV_XLG_MAC_FC_DSA_TAG_1_REG (0x006c) +#define MV_XLG_MAC_FC_DSA_TAG_1_DSATAGREG1_OFFS 0 +#define MV_XLG_MAC_FC_DSA_TAG_1_DSATAGREG1_MASK \ + (0x0000ffff << MV_XLG_MAC_FC_DSA_TAG_1_DSATAGREG1_OFFS) + +/* Fc Dsa Tag 2 */ +#define MV_XLG_MAC_FC_DSA_TAG_2_REG (0x0070) +#define MV_XLG_MAC_FC_DSA_TAG_2_DSATAGREG2_OFFS 0 +#define MV_XLG_MAC_FC_DSA_TAG_2_DSATAGREG2_MASK \ + (0x0000ffff << MV_XLG_MAC_FC_DSA_TAG_2_DSATAGREG2_OFFS) + +/* Fc Dsa Tag 3 */ +#define MV_XLG_MAC_FC_DSA_TAG_3_REG (0x0074) +#define MV_XLG_MAC_FC_DSA_TAG_3_DSATAGREG3_OFFS 0 +#define MV_XLG_MAC_FC_DSA_TAG_3_DSATAGREG3_MASK \ + (0x0000ffff << MV_XLG_MAC_FC_DSA_TAG_3_DSATAGREG3_OFFS) + +/* Dic Budget Compensation */ +#define MV_XLG_MAC_DIC_BUDGET_COMPENSATION_REG (0x0080) +#define MV_XLG_MAC_DIC_BUDGET_COMPENSATION_DIC_COUNTER_TO_ADD_8BYTES_OFFS 0 +#define MV_XLG_MAC_DIC_BUDGET_COMPENSATION_DIC_COUNTER_TO_ADD_8BYTES_MASK \ + (0x0000ffff << \ + MV_XLG_MAC_DIC_BUDGET_COMPENSATION_DIC_COUNTER_TO_ADD_8BYTES_OFFS) + +/* Port Mac Control4 */ +#define MV_XLG_PORT_MAC_CTRL4_REG (0x0084) +#define MV_XLG_MAC_CTRL4_LLFC_GLOBAL_FC_ENABLE_OFFS 0 +#define MV_XLG_MAC_CTRL4_LLFC_GLOBAL_FC_ENABLE_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_LLFC_GLOBAL_FC_ENABLE_OFFS) + +#define MV_XLG_MAC_CTRL4_LED_STREAM_SELECT_OFFS 1 +#define MV_XLG_MAC_CTRL4_LED_STREAM_SELECT_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_LED_STREAM_SELECT_OFFS) + +#define MV_XLG_MAC_CTRL4_DEBUG_BUS_SELECT_OFFS 2 +#define MV_XLG_MAC_CTRL4_DEBUG_BUS_SELECT_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_DEBUG_BUS_SELECT_OFFS) + +#define MV_XLG_MAC_CTRL4_MASK_PCS_RESET_OFFS 3 +#define MV_XLG_MAC_CTRL4_MASK_PCS_RESET_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_MASK_PCS_RESET_OFFS) + +#define MV_XLG_MAC_CTRL4_ENABLE_SHORT_PREAMBLE_FOR_XLG_OFFS 4 +#define MV_XLG_MAC_CTRL4_ENABLE_SHORT_PREAMBLE_FOR_XLG_MASK \ + (0x00000001 << \ + MV_XLG_MAC_CTRL4_ENABLE_SHORT_PREAMBLE_FOR_XLG_OFFS) + +#define MV_XLG_MAC_CTRL4_FORWARD_802_3X_FC_EN_OFFS 5 +#define MV_XLG_MAC_CTRL4_FORWARD_802_3X_FC_EN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_FORWARD_802_3X_FC_EN_OFFS) + +#define MV_XLG_MAC_CTRL4_FORWARD_PFC_EN_OFFS 6 +#define MV_XLG_MAC_CTRL4_FORWARD_PFC_EN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_FORWARD_PFC_EN_OFFS) + +#define MV_XLG_MAC_CTRL4_FORWARD_UNKNOWN_FC_EN_OFFS 7 +#define MV_XLG_MAC_CTRL4_FORWARD_UNKNOWN_FC_EN_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_FORWARD_UNKNOWN_FC_EN_OFFS) + +#define MV_XLG_MAC_CTRL4_USE_XPCS_OFFS 8 +#define MV_XLG_MAC_CTRL4_USE_XPCS_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_USE_XPCS_OFFS) + +#define MV_XLG_MAC_CTRL4_DMA_INTERFACE_IS_64_BIT_OFFS 9 +#define MV_XLG_MAC_CTRL4_DMA_INTERFACE_IS_64_BIT_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_DMA_INTERFACE_IS_64_BIT_OFFS) + +#define MV_XLG_MAC_CTRL4_TX_DMA_INTERFACE_BITS_OFFS 10 +#define MV_XLG_MAC_CTRL4_TX_DMA_INTERFACE_BITS_MASK \ + (0x00000003 << MV_XLG_MAC_CTRL4_TX_DMA_INTERFACE_BITS_OFFS) + +#define MV_XLG_MAC_CTRL4_MAC_MODE_DMA_1G_OFFS 12 +#define MV_XLG_MAC_CTRL4_MAC_MODE_DMA_1G_MASK \ + (0x00000001 << MV_XLG_MAC_CTRL4_MAC_MODE_DMA_1G_OFFS) + +/* Port Mac Control5 */ +#define MV_XLG_PORT_MAC_CTRL5_REG (0x0088) +#define MV_XLG_MAC_CTRL5_TXIPGLENGTH_OFFS 0 +#define MV_XLG_MAC_CTRL5_TXIPGLENGTH_MASK \ + (0x0000000f << MV_XLG_MAC_CTRL5_TXIPGLENGTH_OFFS) + +#define MV_XLG_MAC_CTRL5_PREAMBLELENGTHTX_OFFS 4 +#define MV_XLG_MAC_CTRL5_PREAMBLELENGTHTX_MASK \ + (0x00000007 << MV_XLG_MAC_CTRL5_PREAMBLELENGTHTX_OFFS) + +#define MV_XLG_MAC_CTRL5_PREAMBLELENGTHRX_OFFS 7 +#define MV_XLG_MAC_CTRL5_PREAMBLELENGTHRX_MASK \ + (0x00000007 << MV_XLG_MAC_CTRL5_PREAMBLELENGTHRX_OFFS) + +#define MV_XLG_MAC_CTRL5_TXNUMCRCBYTES_OFFS 10 +#define MV_XLG_MAC_CTRL5_TXNUMCRCBYTES_MASK \ + (0x00000007 << MV_XLG_MAC_CTRL5_TXNUMCRCBYTES_OFFS) + +#define MV_XLG_MAC_CTRL5_RXNUMCRCBYTES_OFFS 13 +#define MV_XLG_MAC_CTRL5_RXNUMCRCBYTES_MASK \ + (0x00000007 << MV_XLG_MAC_CTRL5_RXNUMCRCBYTES_OFFS) + +/* External Control */ +#define MV_XLG_MAC_EXT_CTRL_REG (0x0090) +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL0_OFFS 0 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL0_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL0_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL1_OFFS 1 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL1_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL1_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL2_OFFS 2 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL2_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL2_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL3_OFFS 3 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL3_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL3_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL4_OFFS 4 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL4_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL4_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL5_OFFS 5 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL5_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL5_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL6_OFFS 6 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL6_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL6_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL7_OFFS 7 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL7_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL7_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL8_OFFS 8 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL8_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL8_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL9_OFFS 9 +#define MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL9_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXTERNAL_CTRL9_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_10_OFFS 10 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_10_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_10_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_11_OFFS 11 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_11_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_11_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_12_OFFS 12 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_12_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_12_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_13_OFFS 13 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_13_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_13_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_14_OFFS 14 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_14_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_14_OFFS) + +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_15_OFFS 15 +#define MV_XLG_MAC_EXT_CTRL_EXT_CTRL_15_MASK \ + (0x00000001 << MV_XLG_MAC_EXT_CTRL_EXT_CTRL_15_OFFS) + +/* Macro Control */ +#define MV_XLG_MAC_MACRO_CTRL_REG (0x0094) +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_0_OFFS 0 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_0_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_0_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_1_OFFS 1 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_1_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_1_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_2_OFFS 2 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_2_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_2_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_3_OFFS 3 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_3_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_3_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_4_OFFS 4 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_4_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_4_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_5_OFFS 5 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_5_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_5_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_6_OFFS 6 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_6_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_6_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_7_OFFS 7 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_7_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_7_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_8_OFFS 8 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_8_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_8_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_9_OFFS 9 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_9_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_9_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_10_OFFS 10 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_10_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_10_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_11_OFFS 11 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_11_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_11_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_12_OFFS 12 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_12_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_12_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_13_OFFS 13 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_13_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_13_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_14_OFFS 14 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_14_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_14_OFFS) + +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_15_OFFS 15 +#define MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_15_MASK \ + (0x00000001 << MV_XLG_MAC_MACRO_CTRL_MACRO_CTRL_15_OFFS) + +#define MV_XLG_MAC_DIC_PPM_IPG_REDUCE_REG (0x0094) + +/* Port Interrupt Cause */ +#define MV_XLG_INTERRUPT_CAUSE_REG (0x0014) +/* Port Interrupt Mask */ +#define MV_XLG_INTERRUPT_MASK_REG (0x0018) +#define MV_XLG_INTERRUPT_LINK_CHANGE_OFFS 1 +#define MV_XLG_INTERRUPT_LINK_CHANGE_MASK \ + (0x1 << MV_XLG_INTERRUPT_LINK_CHANGE_OFFS) + +/* Port Interrupt Summary Cause */ +#define MV_XLG_EXTERNAL_INTERRUPT_CAUSE_REG (0x0058) +/* Port Interrupt Summary Mask */ +#define MV_XLG_EXTERNAL_INTERRUPT_MASK_REG (0x005C) +#define MV_XLG_EXTERNAL_INTERRUPT_LINK_CHANGE_OFFS 1 +#define MV_XLG_EXTERNAL_INTERRUPT_LINK_CHANGE_MASK \ + (0x1 << MV_XLG_EXTERNAL_INTERRUPT_LINK_CHANGE_OFFS) + +/*All PPV22 Addresses are 40-bit */ +#define MVPP22_ADDR_HIGH_SIZE 8 +#define MVPP22_ADDR_HIGH_MASK ((1<<MVPP22_ADDR_HIGH_SIZE) - 1) +#define MVPP22_ADDR_MASK (0xFFFFFFFFFF) + +/* Desc addr shift */ +#define MVPP21_DESC_ADDR_SHIFT 0 /*Applies to RXQ, AGGR_TXQ*/ +#define MVPP22_DESC_ADDR_SHIFT (9-1) /*Applies to RXQ, AGGR_TXQ*/ + +/* AXI Bridge Registers */ +#define MVPP22_AXI_BM_WR_ATTR_REG 0x4100 +#define MVPP22_AXI_BM_RD_ATTR_REG 0x4104 +#define MVPP22_AXI_AGGRQ_DESCR_RD_ATTR_REG 0x4110 +#define MVPP22_AXI_TXQ_DESCR_WR_ATTR_REG 0x4114 +#define MVPP22_AXI_TXQ_DESCR_RD_ATTR_REG 0x4118 +#define MVPP22_AXI_RXQ_DESCR_WR_ATTR_REG 0x411c +#define MVPP22_AXI_RX_DATA_WR_ATTR_REG 0x4120 +#define MVPP22_AXI_TX_DATA_RD_ATTR_REG 0x4130 +#define MVPP22_AXI_RD_NORMAL_CODE_REG 0x4150 +#define MVPP22_AXI_RD_SNP_CODE_REG 0x4154 +#define MVPP22_AXI_WR_NORMAL_CODE_REG 0x4160 +#define MVPP22_AXI_WR_SNP_CODE_REG 0x4164 + +#define MVPP22_AXI_RD_CODE_MASK 0x33 +#define MVPP22_AXI_WR_CODE_MASK 0x33 + +#define MVPP22_AXI_ATTR_CACHE_OFFS 0 +#define MVPP22_AXI_ATTR_CACHE_SIZE 4 +#define MVPP22_AXI_ATTR_CACHE_MASK 0x0000000F + +#define MVPP22_AXI_ATTR_QOS_OFFS 4 +#define MVPP22_AXI_ATTR_QOS_SIZE 4 +#define MVPP22_AXI_ATTR_QOS_MASK 0x000000F0 + +#define MVPP22_AXI_ATTR_TC_OFFS 8 +#define MVPP22_AXI_ATTR_TC_SIZE 4 +#define MVPP22_AXI_ATTR_TC_MASK 0x00000F00 + +#define MVPP22_AXI_ATTR_DOMAIN_OFFS 12 +#define MVPP22_AXI_ATTR_DOMAIN_SIZE 2 +#define MVPP22_AXI_ATTR_DOMAIN_MASK 0x00003000 + +#define MVPP22_AXI_ATTR_SNOOP_CNTRL_BIT BIT(16) + +/* Net Complex */ +enum MvNetcTopology { + MV_NETC_GE_MAC0_RXAUI_L23 = BIT(0), + MV_NETC_GE_MAC0_RXAUI_L45 = BIT(1), + MV_NETC_GE_MAC0_XAUI = BIT(2), + MV_NETC_GE_MAC2_SGMII = BIT(3), + MV_NETC_GE_MAC3_SGMII = BIT(4), + MV_NETC_GE_MAC3_RGMII = BIT(5), +}; + +enum MvNetcPhase { + MV_NETC_FIRST_PHASE, + MV_NETC_SECOND_PHASE, +}; + +enum MvNetcSgmiiXmiMode { + MV_NETC_GBE_SGMII, + MV_NETC_GBE_XMII, +}; + +enum MvNetcMiiMode { + MV_NETC_GBE_RGMII, + MV_NETC_GBE_MII, +}; + +enum MvNetcLanes { + MV_NETC_LANE_23, + MV_NETC_LANE_45, +}; + +/* Port related */ +enum MvReset { + RESET, + UNRESET +}; + +enum Mvpp2Command { + MVPP2_START, /* Start */ + MVPP2_STOP, /* Stop */ + MVPP2_PAUSE, /* Pause */ + MVPP2_RESTART /* Restart */ +}; + +/* PHY_ADDRESS_REGISTER0 Register */ +#define MV_SMI_PHY_ADDRESS_REG(n) (0xC + 0x4*n) +#define MV_SMI_PHY_ADDRESS_PHYAD_OFFS 0 +#define MV_SMI_PHY_ADDRESS_PHYAD_MASK \ + (0x1F << MV_SMI_PHY_ADDRESS_PHYAD_OFFS) + +enum MvPortDuplex { + MV_PORT_DUPLEX_AN, + MV_PORT_DUPLEX_HALF, + MV_PORT_DUPLEX_FULL +}; + +#endif /* __MVPP2_LIB_HW__ */