/*******************************************************************************
Copyright (C) Marvell International Ltd. and its affiliates

This software file (the "File") is owned and distributed by Marvell
International Ltd. and/or its affiliates ("Marvell") under the following
alternative licensing terms.  Once you have made an election to distribute the
File under one of the following license alternatives, please (i) delete this
introductory statement regarding license alternatives, (ii) delete the two
license alternatives that you have not elected to use and (iii) preserve the
Marvell copyright notice above.

********************************************************************************
Marvell Commercial License Option

If you received this File from Marvell and you have entered into a commercial
license agreement (a "Commercial License") with Marvell, the File is licensed
to you under the terms of the applicable Commercial License.

********************************************************************************
Marvell GPL License Option

If you received this File from Marvell, you may opt to use, redistribute and/or
modify this File in accordance with the terms and conditions of the General
Public License Version 2, June 1991 (the "GPL License"), a copy of which is
available along with the File in the license.txt file or by writing to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
on the worldwide web at http://www.gnu.org/licenses/gpl.txt.

THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
DISCLAIMED.  The GPL License provides additional details about this warranty
disclaimer.
********************************************************************************
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.

*******************************************************************************/

/*******************************************************************************
* mvNfp.h - Header File for Marvell NFP (Routing and NAT)
*
* DESCRIPTION:
*       This header file contains macros, typedefs and function declarations
* 	specific to the Marvell Network Fast Processing (Routing and NAT).
*
* DEPENDENCIES:
*       None.
*
*******************************************************************************/

#ifndef __mvNfp_h__
#define __mvNfp_h__

/* includes */
#include "mvTypes.h"
#include "mvCommon.h"
#include "mvStack.h"
#include "mv802_3.h"
#include "eth/mvEth.h"
#include "eth/gbe/mvEthGbe.h"
#include "mvSysHwConfig.h"

/* defines */
#define ETH_FP_IFINDEX_MAX     	128
#define ETH_FP_PPPOE_HDR        8	/* PPP header is 6, PPPoE header is 2 */
#define ETH_FP_MTU 		(1518 + ETH_MV_HEADER_SIZE)	/* maximum frame size incluing MH */
#define ETH_FP_PPPOE_MTU 		(ETH_FP_MTU - ETH_FP_PPPOE_HDR)	/* maximum frame size for PPPoE */

/* uncomment to open some debug prints on adding and updating NFP rules */
#define MV_FP_DEBUG
#undef MV_FP_DEBUG

#ifdef MV_FP_DEBUG
#   define MV_NFP_DBG(fmt, arg...) printk(KERN_INFO fmt, ##arg)
#else
#   define MV_NFP_DBG(fmt, arg...)
#endif

#ifdef MV_FP_STATISTICS
# define MV_NFP_STAT(CODE) CODE;
#else
# define MV_NFP_STAT(CODE)
#endif

/* enumerations */
typedef enum {
	MV_FP_ROUTE_CMD,	/* perform NFP routing */
	MV_FP_DROP_CMD,		/* drop packet */
	MV_FP_TO_STACK_CMD,	/* pass packet to linux stack */
	MV_FP_DIP_CMD,		/* replace DIP */
	MV_FP_SIP_CMD,		/* replace SIP */
	MV_FP_DPORT_CMD,	/* replace DPORT */
	MV_FP_SPORT_CMD,	/* replace SPORT */
	MV_FP_BRIDGE_CMD,	/* perform fast path bridging */
	MV_FP_PPP_CMD,		/* perform fast path pppoe */
} MV_FP_CMD_TYPE;

typedef enum {
	MV_NFP_DROP = -3,
	MV_NFP_STOLEN = -2,
	MV_NFP_NONE = -1,
	/* positive values are valid */
} MV_NFP_IF_INDEX;

#define MV_FP_NULL_BINDING  0
#define MV_FP_NULL_BINDING_SET	(1 << MV_FP_ROUTE_CMD)

#define MV_FP_DIP_CMD_MAP   (1 << MV_FP_DIP_CMD)
#define MV_FP_DPORT_CMD_MAP (1 << MV_FP_DPORT_CMD)
#define MV_FP_DNAT_CMD_MAP  (MV_FP_DIP_CMD_MAP | MV_FP_DPORT_CMD_MAP)

#define MV_FP_SIP_CMD_MAP   (1 << MV_FP_SIP_CMD)
#define MV_FP_SPORT_CMD_MAP (1 << MV_FP_SPORT_CMD)
#define MV_FP_SNAT_CMD_MAP  (MV_FP_SIP_CMD_MAP | MV_FP_SPORT_CMD_MAP)

typedef enum {
	MV_FP_STATIC_RULE,	/* a static rule created by the user */
	MV_FP_DYNAMIC_RULE	/* a dynamic rule */
} MV_FP_RULE_TYPE;

/* structure definitions (used by the NFP Manager and the NFP Database)*/
typedef struct {
	MV_FP_CMD_TYPE actionType;
	MV_U32 old_count;
	int new_count;
	MV_FP_RULE_TYPE ruleType;
	int dnat_aware_refcnt;
	int snat_aware_refcnt;

} MV_FP_RULE_MGMT_INFO;

typedef struct {
	MV_U32 dstIp;
	MV_U32 srcIp;
	MV_U32 defGtwIp;
	MV_U8 dscp;
	MV_U8 txq;
	MV_U16 reserved1;
	MV_U8 reserved2;
	MV_U8 aware_flags;
	/* dstMac should be 2 byte aligned */
	MV_U8 dstMac[MV_MAC_ADDR_SIZE];
	MV_U8 srcMac[MV_MAC_ADDR_SIZE];
	MV_U8 inIfIndex;	/* Linux interface index */
	MV_U8 outIfIndex;	/* Linux interface index */
} MV_FP_RULE_ROUTING_INFO;

typedef struct _mv_fp_rule {
	struct _mv_fp_rule *next;

	MV_FP_RULE_MGMT_INFO mgmtInfo;
	MV_FP_RULE_ROUTING_INFO routingInfo;

} MV_FP_RULE;

struct ruleHashBucket {
	MV_FP_RULE *ruleChain;	/* This is an entry in the rule hash table. */

	/* Add additional fields (such as a lock) here if required */
};

#define MV_JHASH_MIX(a, b, c)        \
{                                   \
    a -= b; a -= c; a ^= (c>>13);   \
    b -= c; b -= a; b ^= (a<<8);    \
    c -= a; c -= b; c ^= (b>>13);   \
    a -= b; a -= c; a ^= (c>>12);   \
    b -= c; b -= a; b ^= (a<<16);   \
    c -= a; c -= b; c ^= (b>>5);    \
    a -= b; a -= c; a ^= (c>>3);    \
    b -= c; b -= a; b ^= (a<<10);   \
    c -= a; c -= b; c ^= (b>>15);   \
}

/* The golden ration: an arbitrary value */
#define MV_JHASH_GOLDEN_RATIO           0x9e3779b9

extern MV_U32 fp_ip_jhash_iv;

static INLINE MV_U32 mv_jhash_3words(MV_U32 a, MV_U32 b, MV_U32 c, MV_U32 initval)
{
	a += MV_JHASH_GOLDEN_RATIO;
	b += MV_JHASH_GOLDEN_RATIO;
	c += initval;
	MV_JHASH_MIX(a, b, c);

	return c;
}

#ifdef CONFIG_MV_ETH_NFP_NAT

typedef struct _mv_fp_nat_rule {
	struct _mv_fp_nat_rule *next;
	MV_U32 old_count;
	MV_U32 new_count;

	/* Original packet information */
	/* Fields will contain invalid values if they are irrelevant */
	MV_U32 srcIp;
	MV_U32 dstIp;
	MV_U16 srcPort;
	MV_U16 dstPort;
	MV_U8 proto;

	/* NAT information */
	MV_U8 flags;
	MV_U32 newIp;
	MV_U16 newPort;

} MV_FP_NAT_RULE;

struct natRuleHashBucket {
	MV_FP_NAT_RULE *natRuleChain;	/* This is an entry in the NAT rule hash table. */

	/* Add additional fields (such as a lock) here if required */
};

extern struct natRuleHashBucket *natRuleDb;
extern MV_U32 natRuleDbSize;
extern MV_U32 natRuleUpdateCount, natRuleSetCount, natRuleDeleteCount;
extern MV_U32 natHashMaxDepth;

#endif /* CONFIG_MV_ETH_NFP_NAT */

/*
 * PPPoE Support
 */
#ifdef CONFIG_MV_ETH_NFP_PPP

typedef struct {
	MV_U16 tag;
	MV_U8 da[MV_MAC_ADDR_SIZE];
	MV_U8 sa[MV_MAC_ADDR_SIZE];
	MV_U16 ethertype;
	MV_U8 version;
	MV_U8 code;
	MV_U16 session;
	MV_U16 len;
	MV_U16 proto;
} __attribute__ ((packed)) MV_PPPoE_HEADER;

typedef struct {
	union {
		MV_PPPoE_HEADER ppp;
		MV_U32 u32[6];
	} u;
	MV_U32 if_ppp;		/* e.g. ppp0 */
	MV_U32 if_eth;		/* e.g. eth0 */
	MV_U32 channel;
} MV_FP_RULE_PPP_INFO;

typedef struct _mv_fp_ppp_rule {
	struct _mv_fp_ppp_rule *next;

	MV_FP_RULE_MGMT_INFO mgmtInfo;
	MV_FP_RULE_PPP_INFO pppInfo;

} MV_FP_PPP_RULE;

extern MV_FP_PPP_RULE pppOpen[];

#endif /* CONFIG_MV_ETH_NFP_PPP */

/*
 * 802.1D Support
 */
#ifdef CONFIG_MV_ETH_NFP_FDB

#define MV_FP_FDB_IS_LOCAL 1

typedef struct {
	MV_U16 flags;
	MV_U8 mac[6];
	MV_U32 ifIndex;
	MV_U32 bridge;
} MV_FP_RULE_FDB_INFO;

typedef struct _mv_fp_fdb_rule {
	struct _mv_fp_fdb_rule *next;

	MV_FP_RULE_MGMT_INFO mgmtInfo;
	MV_FP_RULE_FDB_INFO fdbInfo;

} MV_FP_FDB_RULE;

struct fdbRuleHashBucket {
	MV_FP_FDB_RULE *ruleChain;
};

extern struct fdbRuleHashBucket *fdbRuleDb;
extern MV_U32 fdbRuleDbSize;
extern MV_U32 fdbMember[];
extern MV_U32 fdbRuleUpdateCount, fdbRuleSetCount, fdbRuleDeleteCount;
extern MV_U32 fdbHashMaxDepth;

#endif /* CONFIG_MV_ETH_NFP_FDB */

typedef struct {
	MV_U32 parsing;
	MV_U32 process;
	MV_U32 route_miss;
	MV_U32 route_hit;
	MV_U32 ip_ttl_expired;
	MV_U32 slowpath;
	MV_U32 multicast;
	MV_U32 ethertype_unknown;
	MV_U32 ip_frag;
	MV_U32 vlan_tagged;

#ifdef CONFIG_MV_ETH_NFP_NAT
	MV_U32 nat_bad_proto;
	MV_U32 dnat_aware;
	MV_U32 snat_aware;
	MV_U32 dnat_found;
	MV_U32 snat_found;
	MV_U32 dnat_not_found;
	MV_U32 snat_not_found;
#endif				/* CONFIG_MV_ETH_NFP_NAT */

#ifdef CONFIG_MV_ETH_NFP_FDB
	MV_U32 fdb_rx_local;
	MV_U32 fdb_rx_unknown;
	MV_U32 fdb_tx_found;
	MV_U32 fdb_bridged;
#endif				/* CONFIG_MV_ETH_NFP_FDB */

#ifdef CONFIG_MV_ETH_NFP_PPP
	MV_U32 ppp_rx;
	MV_U32 ppp_rx_slow;
	MV_U32 ppp_rx_frag;
	MV_U32 ppp_tx;
	MV_U32 ppp_tx_slow;
	MV_U32 ppp_tx_esp;
	MV_U32 ppp_err;
#endif				/* CONFIG_MV_ETH_NFP_PPP */

#ifdef CONFIG_MV_ETH_NFP_SEC
	MV_U32 sec_in;
	MV_U32 sec_in_drop;
	MV_U32 sec_out;
	MV_U32 sec_out_drop;
	MV_U32 sec_out_slow;
#endif				/* CONFIG_MV_ETH_NFP_SEC */

} MV_FP_STATS;

static INLINE MV_IP_HEADER *mvFpParsing(MV_PKT_INFO *pPktInfo, MV_FP_STATS *pFpStats)
{
	MV_U8 *pData;
	MV_IP_HEADER *pIpHdr;
	MV_U32 tx_status;

	pData = (MV_U8 *) pPktInfo->pFrags[0].bufVirtPtr + ETH_MV_HEADER_SIZE;

	MV_NFP_STAT(pFpStats->parsing++);

	/* Check LLC/SNAP and IP header */
	if (((pPktInfo->status & ETH_RX_NOT_LLC_SNAP_FORMAT_MASK) == 0) ||
	    ((pPktInfo->status & ETH_RX_IP_HEADER_OK_MASK) == 0)) {
		/* Non IP packet: go to Linux IP stack */
		MV_NFP_STAT(pFpStats->ethertype_unknown++);
		return NULL;
	}

	if (pPktInfo->fragIP) {
		MV_NFP_STAT(pFpStats->ip_frag++);
		return NULL;
	}

	tx_status = (ETH_TX_GENERATE_IP_CHKSUM_MASK | ETH_TX_IP_NO_FRAG | (5 << ETH_TX_IP_HEADER_LEN_OFFSET));

	/* Calculate start of IP header */
	if ((pPktInfo->status & ETH_RX_VLAN_TAGGED_FRAME_MASK)) {
		MV_NFP_STAT(pFpStats->vlan_tagged++);
		pIpHdr = (MV_IP_HEADER *) (pData + sizeof(MV_802_3_HEADER) + MV_VLAN_HLEN);
		tx_status |= ETH_TX_VLAN_TAGGED_FRAME_MASK;
	} else {
		pIpHdr = (MV_IP_HEADER *) (pData + sizeof(MV_802_3_HEADER));
	}

	if ((pPktInfo->status & ETH_RX_L4_TYPE_MASK) == ETH_RX_L4_TCP_TYPE)
		tx_status |= (ETH_TX_L4_TCP_TYPE | ETH_TX_GENERATE_L4_CHKSUM_MASK);
	else if ((pPktInfo->status & ETH_RX_L4_TYPE_MASK) == ETH_RX_L4_UDP_TYPE)
		tx_status |= (ETH_TX_L4_UDP_TYPE | ETH_TX_GENERATE_L4_CHKSUM_MASK);

	pPktInfo->status = tx_status;

	return pIpHdr;
}

/* Initialize NFP Rule Database (Routing + ARP information table) */
MV_STATUS mvFpRuleDbInit(MV_U32 dbSize);
/* Clear NFP Rule Database (Routing + ARP information table) */
MV_STATUS mvFpRuleDbClear(void);
/* Free Rule Database memory */
void mvFpRuleDbDestroy(void);
/* Print NFP Rule Database (Routing + ARP information table) */
MV_STATUS mvFpRuleDbPrint(void);
/* Copy all the information from src_rule to new_rule */
/* Warning - doesn't perform any checks on memory, just copies */
/* count is set to zero in new_rule */
/* Note: the next pointer is not updated . */
void mvFpRuleCopy(MV_FP_RULE *newRule, const MV_FP_RULE *srcRule);
/* Get the maximum count value for a rule with srcIp == given ip */
MV_U32 mvFpMaxArpCountGet(MV_U32 ip);
/* Get the count value for a rule that matches the given SIP, DIP */
MV_U32 mvFpRouteCountGet(MV_U32 srcIp, MV_U32 dstIp);
/* Set a Routing Rule: create a new rule or update an existing rule  */
/* in the Routing + ARP information table */
MV_STATUS mvFpRuleSet(MV_FP_RULE *rule);
/* Delete a specified rule from the Routing + ARP information table */
MV_STATUS mvFpRuleDelete(MV_FP_RULE *rule);
/* Set a Routing ToS Rule */
MV_STATUS mvFpToSSet(MV_FP_RULE *rule);
/* Print a Rule */
void mvFpRulePrint(const MV_FP_RULE *rule);
/* Enable NFP */
void mvFpEnable(void);
/* Give all packets to Linux IP stack */
void mvFpDisable(void);
MV_STATUS mvFpInit(void);
int mvFpProcess(MV_U32 ifIndex, MV_PKT_INFO *pPkt, MV_IP_HEADER *pIpHdr, MV_FP_STATS *pFpStats);
void mvFpStatsPrint(MV_FP_STATS *pFpStats);

/* NAT SUPPORT Functions */

#ifdef CONFIG_MV_ETH_NFP_NAT
/* Find and return the first matching rule */
static INLINE MV_FP_NAT_RULE *mvFpNatRuleFind(MV_U32 dstIp, MV_U32 srcIp, MV_U8 proto, MV_U16 dport, MV_U16 sport)
{
	MV_U32 hash, hash_tr;
	MV_FP_NAT_RULE *pNatRule;
	int count = 0;

	hash = mv_jhash_3words(dstIp, srcIp, (MV_U32) ((dport << 16) | sport),
			       (MV_U32) ((fp_ip_jhash_iv << 8) | proto));
	hash_tr = hash & (natRuleDbSize - 1);
/*
    mvOsPrintf("mvFpNatRuleFind: DIP=0x%08x, SIP=0x%08x, proto=%d, DPort=%d, SPort=%d, hash=0x%08x (0x%x)\n",
		dstIp, srcIp, proto, dport, sport, hash, hash_tr);
*/
	pNatRule = natRuleDb[hash_tr].natRuleChain;

	while (pNatRule) {
		/* look for a matching rule */
		if ((pNatRule->dstIp == dstIp) &&
		    (pNatRule->srcIp == srcIp) &&
		    (pNatRule->proto == proto) && (pNatRule->dstPort == dport) && (pNatRule->srcPort == sport)) {
			pNatRule->new_count++;
			return pNatRule;
		}
		pNatRule = pNatRule->next;
		count++;
	}
	return NULL;
}

/* Initialize NFP NAT Rule Database (SNAT + DNAT table) */
MV_STATUS mvFpNatDbInit(MV_U32 dbSize);

/* Clear NFP NAT Rule Database (SNAT + DNAT table) */
MV_STATUS mvFpNatDbClear(void);

/* Free NAT Database memory */
void mvFpNatDbDestroy(void);

/* Set a NAT rule: create a new rule or update an existing rule in the SNAT + DNAT table */
MV_STATUS mvFpNatRuleSet(MV_FP_NAT_RULE *natRule);

MV_STATUS mvFpRuleAwareSet(MV_FP_RULE *pSetRule);

/* Delete a specified NAT rule from the SNAT + DNAT table */
MV_STATUS mvFpNatRuleDelete(MV_FP_NAT_RULE *natRule);

/* Get the count value for a NAT rule */
MV_U32 mvFpNatCountGet(MV_U32 srcIp, MV_U32 dstIp, MV_U16 srcPort, MV_U16 dstPort, MV_U8 proto);

/* Print NFP NAT Rule Database (SNAT + DNAT table) */
MV_STATUS mvFpNatDbPrint(void);

/* Print a NAT Rule */
void mvFpNatRulePrint(const MV_FP_NAT_RULE *rule);

/* Extract dstPort and srcPort values from the packet */
MV_U8 mvFpNatPortsGet(MV_IP_HEADER *pIpHdr, MV_U16 *pDstPort, MV_U16 *pSrcPort);

int mvFpNatPktUpdate(MV_IP_HEADER *pIpHdr, MV_FP_NAT_RULE *pDnatRule, MV_FP_NAT_RULE *pSnatRule);

#endif /* CONFIG_MV_ETH_NFP_NAT */

#ifdef CONFIG_MV_ETH_NFP_FDB

/* Init NFP Bridge Rule Database */
MV_STATUS mvFpFdbInit(MV_U32 dbSize);

/* Clear NFP Bridge Rule Database */
MV_STATUS mvFpFdbClear(void);

/* Destroy NFP Bridge Rule Database */
void mvFpFdbDestroy(void);

/* Add NFP Bridge Rule */
MV_STATUS mvFpFdbRuleSet(MV_FP_FDB_RULE *rule);

/* Delete NFP Bridge Rule Database */
MV_STATUS mvFpFdbRuleDel(MV_FP_FDB_RULE *rule);

/* Aging NFP Bridge Rule Database */
MV_U32 mvFpFdbRuleAge(MV_FP_FDB_RULE *rule);

/* Print NFP Bridge Rule Database */
MV_STATUS mvFpFdbPrint(void);

#endif /* CONFIG_MV_ETH_NFP_FDB */

#ifdef CONFIG_MV_ETH_NFP_PPP

/* Init NFP PPPoE Rule Database */
MV_STATUS mvFpPppInit(void);

/* Clear NFP PPPoE Rule Database */
MV_STATUS mvFpPppClear(void);

/* Destroy NFP PPPoE Rule Database */
void mvFpPppDestroy(void);

/* Add NFP PPPoE Rule */
MV_STATUS mvFpPppRuleSet(MV_FP_PPP_RULE *rule);

/* Delete NFP PPPoE Rule Database */
MV_STATUS mvFpPppRuleDel(MV_FP_PPP_RULE *rule);

/* Aging NFP PPPoE Rule Database */
MV_U32 mvFpPppRuleAge(MV_FP_PPP_RULE *rule);

/* Print NFP PPPoE Rule Database */
MV_STATUS mvFpPppPrint(void);

/* Add PPPoE header */
int mvFpPPPoE(MV_U32 ifIndex, MV_PKT_INFO *pPkt, MV_FP_STATS *pFpStats);

/* Get physical interface the PPP runs over */
MV_U32 mvFpPppPhyIf(MV_U32 ifIndex);

#endif /* CONFIG_MV_ETH_NFP_PPP */

#ifdef CONFIG_MV_ETH_NFP_SEC
MV_VOID mvNfpSecDbPrint(MV_VOID);
#endif /* CONFIG_MV_ETH_NFP_SEC */

#endif /* __mvNfp_h__ */