/*
 *  Copyright (c) 2011, 2014 Freescale Semiconductor, Inc.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.

 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.

 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *
 */


#ifndef _MODULE_IPSEC_C2000_H_
#define _MODULE_IPSEC_C2000_H_

#include "types.h"
#include "channels.h"
#include "modules.h"
#include "fpart.h"
#include "fe.h"
#include "common_hdrs.h"
#include "layer2.h"
#include "pfe/cbus/class_csr.h"


#define NUM_LMEM_SA		64
#define HW_SA_VALID		(1 << 0)
#define HW_SA_USED		(1 << 1)
#define HW_SA_UPDATING		(1 << 2)
#define SA_CACHE_COUNTER	128


#define ESPAH_USE_PRNG 1
#define ELP_HW_BYTECNT          1       // uses elliptic hardware bytecount
//#define ESPAH_USE_TRNG 1
// TRNG would require semaphore as spacc (linux) uses it as well
#if defined(ESPAH_USE_TRNG) && defined(ESPAH_USE_PRNG)
#       error "only one of ESPAH_USE_TRNG or ESPAH_USE_PRNG may be defined"
#endif
#if     !defined(ESPAH_USE_TRNG) && !defined(ESPAH_USE_PRNG)
#       error "one of ESPAH_USE_TRNG or ESPAH_USE_PRNG needs to be defined"
#endif

typedef struct _tSA_lft_cur {
#if     !defined(ELP_HW_BYTECNT)||(ELP_HW_BYTECNT == 0)
        U64     bytes;
#else
        /* Elliptic hardware does byte accounting. */
#endif
        U64     packets;
}SA_lft_cur, *PSA_lft_cur;


typedef struct _tSAID {	
	union
	{
	       /*Unused	U32		a4; */
		U32 			a6[4];
		U32			top[4]; // alias
	} daddr;		
	U32		saddr[4];	// added for NAT-T transport mode
	U32		spi;
	U8		proto;
	U8		unused[3];
} SAID, *PSAID;	


#define SA_STATE_INIT		0x1
#define SA_STATE_VALID		0x2
#define SA_STATE_DEAD		0x3
#define SA_STATE_EXPIRED	0x4
#define SA_STATE_DYING		0x5


/*
 * _TSAEntry.flags values
 */
#define SA_NOECN	1
#define SA_DECAP_DSCP	2
#define SA_NOPMTUDISC	4
#define SA_WILDRECV	8
/* Local mirror of the sa flags.  */
#define	SA_ENABLED 	0x10		
#define SA_ALLOW_SEQ_ROLL 0x20


/* Hardware structure for elliptic security association */
typedef struct _tElliptic_SA {
	U32		 	seq; 		//+4
	U32		 	ext_seq;	// +0
	U64			anti_replay_mask;	//+8
	U32			auth_key1;		//+0x14
	U32			auth_key0;		//+0x10
	U32			auth_key3;		//+0x1c
	U32			auth_key2;		//+0x18
	U32			cipher0;	//+0x24
	U32			auth_key4;		//+0x20
	U32			cipher2;	//+0x2c
	U32			cipher1;	//+0x28	
	U32			cipher4;	//+0x34
	U32			cipher3;	//+0x30
	U32			cipher6;	//+0x3C
	U32			cipher5;	//+0x38
	union{
		U32			CTR_Nonce;	//+0x44
		U32			iv0;
	};
	U32			cipher7;	//+0x40
	union {					//+0x4C
	    U32			ext_auth_key1;
	    U32			iv2;
	};
	union {					//+0x48
	    U32			ext_auth_key0;
	    U32			iv1;
	};
	U32			spi;		//+0x54
	union {					//+0x50
	    U32			ext_auth_key2;
	    U32			iv3;
	};
	U8			pad1a[16];
	U32			hard_ttl_hi;	//+0x6c
	U8			pad1b[4];	//+0x68
	U32			soft_ttl_hi;	//+0x74
	U32			hard_ttl_lo;	//+0x70
	U16			flags;		//+0x7c
	U8			res3;
	U8			algo;
	U32			soft_ttl_lo;	//+0x78
} Elliptic_SA, *PElliptic_SA;


#ifdef CFG_STATS
typedef struct _tSAStatEntry {
       U32 total_pkts_processed;
       U32 last_pkts_processed;
       U64 total_bytes_processed;
       U64 last_bytes_processed;
}SAStatEntry , *PSAStatEntry;
#endif


#if defined(COMCERTO_2000_CONTROL)
typedef struct _tSAEntry {
	struct slist_entry      list_spi;
	struct slist_entry      list_h;
	U16			hash_by_h;
        U16			hash_by_spi;
        struct _tSAID           id;             // SA 3-tuple
        struct _tElliptic_SA *elp_sa;           // pointer to elliptic SA descriptor
	U32			elp_sa_dma_addr;
        U8                      family;         // v4/v6
        U8                      header_len;     // ipv4/ipv6 tunnel header
        U8                      mode;           // Tunnel / transport mode
        U8                      flags;          // ECN, TOS ...
        struct _tSA_lft_cur lft_cur;
        struct _tSA_lft_conf lft_conf;
        U8                      direction;      // inbound / outbound
	U8			state:7;          // valid / expired / dead / dying
	U8			notify:1;
        U8                      blocksz;
        U8                      icvzs;
        U16                     handle;
        U16                     mtu;            // used for Transport mode
        union                           // keep union 32 bits aligned !!!
        {
                ipv4_hdr_t      ip4;
                ipv6_hdr_t      ip6;
        } tunnel;
        U16                             dev_mtu;
        /*NAT-T modifications*/
        struct
        {
                unsigned short sport;
                unsigned short dport;
                void*          socket;
        }natt;
	struct _t_hw_sa_entry 	*hw_sa;    /*pointer to the software socket entry */

	U32 route_id;
	PRouteEntry pRtEntry;

} SAEntry, *PSAEntry;

/* 
** This hw_sa structure is being shared by both class and utilpe.
CLASS uses the initial part of structure, UTIL starts from hw_sa_flags
to the end of the structure. 

CLASS uses CLASS_PE_OFFSET and UTIL uses UTIL_PE_OFFSET(which are defined below)
 as the starting offset while fetching the entry into the PFE  

IMPORTANT: Whenever structure members are added/deleted to this structure 
pls take care of above assumption.
*/

typedef struct _t_hw_sa_entry
{
	/* only class requires this */
        union
        {
                ipv4_hdr_t      ip4;
                ipv6_hdr_t      ip6;
        } tunnel;

        struct _tSAID           id;
	struct hw_route		route;

	/* util and class */
	u32	hw_sa_flags;
	u32	dma_addr;
	u32 	next_h;
	u32	next_spi;

	u16	handle;
	u16	dev_mtu;
	u16	mtu;
	u16	unused1;

        u8	family;       // v4/v6
        u8	header_len;   // ipv4/ipv6 tunnel header
        u8	mode;         // Tunnel / transport mode
        u8	flags;        // ECN, TOS ...
        u8	state;       // valid / expired / dead / dying
	u8	unused[3];

	/* only utilpe */

        struct _tSA_lft_cur     lft_cur;

        struct _tElliptic_SA    *elp_sa;  // pointer to elliptic SA descriptor
	u32	unused3;

        struct
        {
                unsigned short sport;
                unsigned short dport;
                void*          socket;
        }natt;

        struct _tSA_lft_conf    lft_conf;

#ifdef CFG_STATS
	struct _tSAStatEntry stats;
#endif
	/* HOST only */

	struct dlist_head       list_h;
        struct dlist_head       list_spi;
	struct _tSAEntry 	*sw_sa;    /*pointer to the software socket entry */
	struct _tElliptic_SA 	*elp_virt_sa; /* pointer to the elliptic sa entry */ 
	struct _t_hw_sa_entry    *lmem_next;
        unsigned long           removal_time;

}hw_sa_entry;

#elif defined(COMCERTO_2000_CLASS)

typedef struct _tSAEntry {
	/* only class requires this */
	union
	{
		ipv4_hdr_t      ip4;
		ipv6_hdr_t      ip6;
	} tunnel;

	struct _tSAID           id;
	RouteEntry		route;

	/* util and class */
	u32     hw_sa_flags;
	u32     dma_addr;
	u32     next_h;
	u32     next_spi;

	u16     handle;
	u16     dev_mtu;
	u16     mtu;
        u16     unused1;

        u8      family;       // v4/v6
        u8      header_len;   // ipv4/ipv6 tunnel header
        u8      mode;         // Tunnel / transport mode
        u8      flags;        // ECN, TOS ...
        u8      state;       // valid / expired / dead / dying
        u8      unused[3];
}SAEntry , *PSAEntry;


#else
/* utilpe structures */
typedef struct _tSAEntry {
	/* util and class */
        u32     hw_sa_flags;
        u32     dma_addr;
        u32     next_h;
        u32     next_spi;

        u16     handle;
        u16     dev_mtu;
        u16     mtu;
        u16     unused1;

        u8      family;       // v4/v6
        u8      header_len;   // ipv4/ipv6 tunnel header
        u8      mode;         // Tunnel / transport mode
        u8      flags;        // ECN, TOS ...
        u8      state;       // valid / expired / dead / dying
        u8      unused[3];

	struct _tSA_lft_cur     lft_cur;

        struct _tElliptic_SA    *elp_sa;  // pointer to elliptic SA descriptor
        u32     unused2;

        struct
        {
                unsigned short sport;
                unsigned short dport;
                void*          socket;
        }natt;

        struct _tSA_lft_conf    lft_conf;

#ifdef CFG_STATS
	struct _tSAStatEntry stats;
#endif

}SAEntry , *PSAEntry;

typedef struct _tSACacheEntry {
	SAEntry sa;
	u32 cache_cnt;
}SACacheEntry , *PSACacheEntry;

#endif


#if defined(COMCERTO_2000_UTIL)
#define UTIL_LMEM_SA_START_OFFSET 	96
#define UTIL_LMEM_UPDATE_STATE_LEN	16
#endif
/* These are the offsets used to fetch the SA structure.
The initial part of SA structure is used to fetch in CLASS where as
later part is used in UTIL. 

Whenever there is a change in the SA structure (addition or deletion of structure members)
the offset should be modified */

#if defined (COMCERTO_2000_UTIL) || defined (COMCERTO_2000_CLASS)
#define UTIL_PE_OFFSET		96
#define CLASS_PE_OFFSET		0
#endif

/*
 * Hardware dependencies for Elliptic engine
 *
*/
#define ELP_SA_ALIGN 128
#define ELP_SA_ALIGN_LOG 7
#if	(ELP_SA_ALIGN != (1<< ELP_SA_ALIGN_LOG))
#	error "fix  ELP_SA_ALIGN or ELP_SA_ALIGN_LOG"
#endif

/*
 * Codes
*/
#define ELP_HMAC_NULL	0
#define ELP_HMAC_MD5	1
#define ELP_HMAC_SHA1	2
#define ELP_HMAC_SHA2	3
#define ELP_GCM64	4
#define ELP_GCM96	5
#define ELP_GCM128	6

#define ELP_CIPHER_NULL 0
#define ELP_CIPHER_DES	 1
#define ELP_CIPHER_3DES 2
#define ELP_CIPHER_AES128 3
#define ELP_CIPHER_AES192 4
#define ELP_CIPHER_AES256 5
#define ELP_CIPHER_AES128_GCM 6
#define ELP_CIPHER_AES192_GCM 7
#define ELP_CIPHER_AES256_GCM 8
#define ELP_CIPHER_AES128_CTR 9
#define ELP_CIPHER_AES192_CTR 10
#define ELP_CIPHER_AES256_CTR 11


// Elliptic ESP AH Offload Engine registers
#define ESPAH_BASE	0x00000
#define ESPAH_IRQ_EN                             (0x00)
#define		ESPAH_IRQ_OUTBND_CMD_EN		0x1
#define		ESPAH_IRQ_OUTBND_STAT_EN		0x2
#define		ESPAH_IRQ_INBND_CMD_EN		0x4
#define		ESPAH_IRQ_INBND_STAT_EN		0x8
#define		ESPAH_IRQ_ALL_EN		(ESPAH_IRQ_OUTBND_CMD_EN|ESPAH_IRQ_OUTBND_STAT_EN|ESPAH_IRQ_INBND_CMD_EN|ESPAH_IRQ_INBND_STAT_EN)
#define		ESPAH_IRQ_GLBL_EN		(1UL<<31)
#define ESPAH_IRQ_STAT                           (0x04)
#define		ESPAH_STAT_OUTBND_CMD		0x1
#define		ESPAH_STAT_OUTBND_STAT		0x2
#define		ESPAH_STAT_INBND_CMD		0x4
#define		ESPAH_STAT_INBND_STAT		0x8

#define ESPAH_DMA_BURST_SZ                       (0x08)
#define ESPAH_IV_RND                             (0x10)
#define ESPAH_OUT_SRC_PTR                        (0x20)
#define ESPAH_OUT_DST_PTR                        (0x24)
#define ESPAH_OUT_OFFSET                         (0x28)
#define ESPAH_OUT_ID                             (0x2C)
#define ESPAH_OUT_SAI                            (0x30)
#define ESPAH_OUT_POP                            (0x38)
#define ESPAH_OUT_STAT                           (0x3C)
#define ESPAH_IN_SRC_PTR                         (0x40)
#define ESPAH_IN_DST_PTR                         (0x44)
#define ESPAH_IN_OFFSET                          (0x48)
#define ESPAH_IN_ID                              (0x4C)
#define ESPAH_IN_SAI                             (0x50)
#define ESPAH_IN_POP                             (0x58)
#define ESPAH_IN_STAT                            (0x5C)

typedef struct _t_clp30_espah_regs {
  V32 espah_irq_en;	// 0x00
  V32 espah_irq_stat;	// 0x04
  V32 espah_dma_burst_sz;      //  0x0008  maximum in words (8-256)
  U32 _rsv0;
  V32 espah_iv_rnd;            //  0x0010  value to be added to the core's IV
  U32 _rsv1;
  V32 espah_endian_ctrl;       //  0x0018
  U32 _rsv2;
  V32 espah_out_src_ptr;       //  0x0020
  V32 espah_out_dst_ptr;       //  0x0024
  V32 espah_out_offset;        //  0x0028  DDT offset to start of packet
  V32 espah_out_id;            //  0x002c  software tag
  V32 espah_out_sai;           //  0x0030
  U32 _rsvd3;
  V32 espah_out_pop;           //  0x0038
  V32 espah_out_stat;          //  0x003C
  V32 espah_in_src_ptr;        //  0x0040
  V32 espah_in_dst_ptr;        //  0x0044
  V32 espah_in_offset;         //  0x0048  DDT offset to start of packet
  V32 espah_in_id;             //  0x004C  software tag
  V32 espah_in_sai;            //  0x0050
  U32 _rsvd4;
  V32 espah_in_pop;            //  0x0058
  V32 espah_in_stat;           //  0x005C
  U32 _rsvd5[8];
  V32 espah_sa_cache_flush;    //  0x0080
  V32 espah_sa_cache_ready;    //  0x0084
} clp30_espah_regs;

#define BITMASK(pos,width)	(((1UL<<(width))-1) << (pos))
// IN_STAT and OUT_STAT
#define ESPAH_STAT_LEN            0
#define ESPAH_STAT_LEN_BITS      16
#define ESPAH_STAT_LEN_MASK      BITMASK(ESPAH_STAT_LEN, ESPAH_STAT_LEN_BITS)

#define ESPAH_STAT_ID            16
#define ESPAH_STAT_ID_BITS        8
#define ESPAH_STAT_ID_MASK       BITMASK(ESPAH_STAT_ID, ESPAH_STAT_ID_BITS)

#define ESPAH_STAT_RET           24
#define ESPAH_STAT_RET_BITS       4
#define ESPAH_STAT_RET_MASK      BITMASK(ESPAH_STAT_RET, ESPAH_STAT_RET_BITS)

#define ESPAH_STAT_FIFO_FULL      30
#define ESPAH_STAT_FIFO_FULL_MASK      (1UL<<30)
#define ESPAH_STAT_FIFO_EMPTY     31
#define ESPAH_STAT_FIFO_EMPTY_MASK     (1UL<<31)
/* IN_OFFSET and OUT_OFFSET */
#define ESPAH_OFFSET_SRC          0
#define ESPAH_OFFSET_DST          16


typedef struct _tESPAH_XFORM {
  V32 src_ptr;
  V32 dst_ptr;
  V32 offset;
  V32 id;
  V32 sai;
  V32 pop;
  V32 stat;
} ESPAH_XFORM, *PESPAH_XFORM;

/* Elliptic SA Cache mgmt */
#if defined(COMCERTO_2000_CONTROL)
#	define	SA_CACHE_FLUSH		 *((volatile u32*)((u32)pfe->ipsec_baseaddr+ ESPAH_BASE + 0x80))
#	define	SA_CACHE_FLUSH_RDY	 *((volatile u32*)((u32)pfe->ipsec_baseaddr+ ESPAH_BASE + 0x84))
#else
#	define	SA_CACHE_FLUSH		*((volatile U32 *)  0x9a000080)
#	define	SA_CACHE_FLUSH_RDY	*((volatile U32 *)  0x9a000084)
#endif
/* Elliptic TRNG
Note that it is part of SPAcc and likely be protected by spin-lock to share with linux */
#	define	TRNG_CNTL	*((volatile U32 *)  0x0E010000)
#	define	TRNG_IRQ_EN	*((volatile U32 *)  0x0E010004)
#	define	TRNG_IRQ_STAT	*((volatile U32 *)  0x0E010008)
#	define	TRNG_DATA0	*((volatile U32 *)  0x0E010010)
#	define	TRNG_DATA1	*((volatile U32 *)  0x0E010014)
#	define	TRNG_DATA2	*((volatile U32 *)  0x0E010018)
#	define	TRNG_DATA3	*((volatile U32 *)  0x0E01001C)


/* SA flags (oxffest 0x7e) bits  */
#define ESPAH_ENABLED			0x0001
#define ESPAH_SEQ_ROLL_ALLOWED		0x0002
#define ESPAH_TTL_ENABLE		0x0004	
#define ESPAH_TTL_TYPE			0x0008 /* 0:byte 1:time */
#define ESPAH_AH_MODE			0x0010 /* 0:ESP 1:AH */
#define ESPAH_ANTI_REPLAY_ENABLE 	0x0080
#define ESPAH_COFF_EN			0x0400 /* 1:Crypto offload enable */
#define ESPAH_COFF_MODE			0x0800 /* Crypto offload mode: 0: ECB cypher or raw hash, 1 CBC cypher or HMAC hash */
#define ESPAH_IPV6_ENABLE 		0x1000 /* 1:IPv6 SA */ 
#define ESPAH_DST_OP_MODE 		0x2000 /* IPv6 dest opt treatment EDN-0277 page 16 */ 
#define ESPAH_EXTENDED_SEQNUM   	0x4000


/* STAT codes that go into the STAT_RET_CODE  of a register */
#define ESPAH_STAT_OK          	0
#define ESPAH_STAT_BUSY       	1
#define ESPAH_STAT_SOFT_TTL    	2
#define ESPAH_STAT_HARD_TTL    	3
#define ESPAH_STAT_SA_INACTIVE 	4
#define ESPAH_STAT_REPLAY      	5
#define ESPAH_STAT_ICV_FAIL    	6
#define ESPAH_STAT_SEQ_ROLL    	7
#define ESPAH_STAT_MEM_ERROR   	8
#define ESPAH_STAT_VERS_ERROR  	9
#define ESPAH_STAT_PROT_ERROR  	10
#define ESPAH_STAT_PYLD_ERROR  	11
#define ESPAH_STAT_PAD_ERROR   	12
#define ESPAH_DUMMY_PKT   	13


/*
** Implementation limits
*/

// HW fifo size
#define ESPAH_MAX_FIFO 			32
// DDT allocation size
#define ELP_WQ_RING_SIZE		ESPAH_MAX_FIFO
// Need that much extra space in the egress ddt
#define 	ELP_MAX_ESPAH_OVERHEAD	128	// At least ESP + IV + max pad + 2 + 12

/* ELP_MAX_DDT_PER_PKT is a max number of DDTs, which may be required
** Worst case consumption is worse on FPP then on linux because data buffers may spawn 64K boundary.
** worst packet-to-ddt-mapping is ipv6 packet which crosses 64k boundary:
**  - sop-to-64K boundary
**  - 64k boundary -to -eop
**  - null terminator
*/
#define ELP_MAX_DDT_PER_PKT 3

#define ELP_DDT_ENTRY_SIZE sizeof(struct elp_ddtdesc)
#define ELP_DDT_NUMBER 	(ELP_WQ_RING_SIZE * ELP_MAX_DDT_PER_PKT)
#define ELP_SA_ARAM_OFFSET (4*ELP_DDT_NUMBER*ELP_DDT_ENTRY_SIZE) // 4 fifos (src,dst) x (in,out)
/*
 * Soft formats and layouts
 */

/*
** elp_wqentry describes the packet queued to elliptic engine.
** it is functional equivalent of src_ddtring plus dst_ddtring plus pe_entry on the linux side
** All the sizes below are an important consideration because rings map onto dedicated aram
*/
struct elp_wqentry {
	struct elp_ddtdesc src_ddt[ELP_MAX_DDT_PER_PKT];	// 24 bytes
	struct elp_ddtdesc dst_ddt[ELP_MAX_DDT_PER_PKT];	// 24 bytes
};

// Structure above is 48 bytes to avoid division we use macros to convert between addresses and priv.ipsec.wq_idx
// macros will work as long as structure size is multiple of 32.
#define wqe_addr2pi(base,this_addr) ((((U32) this_addr) - ((U32) base))/16)
#define wqe_pi2addr(base,index) (void*) ((((U32) index) * 16) + ((U32) base))
//
//#if ((sizeof(struct elp_wqentry)) / 32) !=3 )
//#	error " redefine wqe_addr2pi and wqe_pi2addr macros above"
//#endif

/*
** ELP Engine descriptor
*/
struct elp_packet_engine{
        U32     wq_avail;
        struct elp_wqentry                      *pe_wq_ring;            /* work ring */
        struct elp_wqentry                      *pe_wq_ringlast;        /* last entry in work ring */
        struct elp_wqentry                      *pe_wq_free;            /* next wq entry  to use */
 };


typedef struct tIPSec_hw_context {
	// Elliptic driver structure
	clp30_espah_regs *ELP_REGS;
  	U32 ARAM_base;
  	int 	elp_irqm;
	int	irq_en_flags;

  	struct elp_packet_engine in_pe;
  	struct elp_packet_engine out_pe;
  	U32 ARAM_sa_base;
  	U32 ARAM_sa_base_end;
//#if	defined(IPSEC_DEBUG) && (IPSEC_DEBUG)
#if 0
  U32 flush_create_count;
  U32 flush_enable_count;
  U32 flush_disable_count;
  U32 inbound_counters[16];
  U32 outbound_counters[16];
#endif
} IPSec_hw_context;

#ifdef CFG_IPSEC_DEBUG
typedef struct tIPsec_dbg_cntrs {
	u32 dbg_outbnd_rcvd;
	u32 dbg_outbnd_xmit;
	u32 dbg_outbnd_expt;
	u32 dbg_outbnd_drops;
	u32 dbg_inbnd_rcvd;
	u32 dbg_inbnd_xmit;
	u32 dbg_inbnd_expt;
	u32 dbg_inbnd_drops;
	u32 dbg_wa_drops;
}IPSec_dbg_cntrs;
#endif


static __inline U32 elp_read( IPSec_hw_context *pctx, U32 elp_reg_offset) {
    	return  *((volatile U32 *) ((U32)pctx->ELP_REGS + elp_reg_offset));
}
static __inline U32 elp_write( IPSec_hw_context *pctx, U32 elp_reg_offset, U32 val) {
    	*((volatile U32 *) ((U32)pctx->ELP_REGS + elp_reg_offset)) = val;
    	return  val;
}

#if defined(COMCERTO_2000_CLASS)
/* SA notifications */
void M_IPS_IN_process_packet(PMetadata mtd);
void M_IPS_OUT_process_packet(PMetadata mtd);
void M_IPsec_inbound_process_from_util(PMetadata mtd, lmem_trailer_t *trailer);
int prepare_ipsec_oubound_packet(PMetadata mtd);
#endif

//#if	defined(IPSEC_DEBUG) && (IPSEC_DEBUG)
//static unsigned int M_ipsec_ttl_check_data(PSAEntry sa, U16 retcode);
//#else
//static void M_ipsec_ttl_check_data(PSAEntry sa, U16 retcode);
//#endif


static __inline void elp_cache_wait(void) {
	while (SA_CACHE_FLUSH_RDY == 0)
		;
}


static __inline void hw_sa_cache_flush(PElliptic_SA elp_sa_ptr, int sa_cache_flush)
{
#if 0
	printk(KERN_INFO "%s: cache_flush_ready ..:addr:%x - val:%x\n",__func__, ((u32)pfe->ipsec_baseaddr+ ESPAH_BASE + 0x84), SA_CACHE_FLUSH_RDY);
#endif
	if (sa_cache_flush) {
                elp_cache_wait();
                SA_CACHE_FLUSH = (U32)elp_sa_ptr; /* Any value causes flush-all. We write SA address for debug purposes */
                elp_cache_wait();
        }
}


#if defined (COMCERTO_2000_UTIL)
/* Extern declarations required */
extern struct elp_wqentry  dmem_ddt ;
extern u8 upe_dmem_pkt[];
extern void util_ipsec_init();
extern TIMER_ENTRY sa_timer;
#ifdef CFG_STATS
extern U32 gFpStatFeatureBitMask;
#endif
#endif

#if defined (COMCERTO_2000_CLASS) || defined (COMCERTO_2000_UTIL)
#ifdef CFG_IPSEC_DEBUG
extern IPSec_dbg_cntrs g_ipsec_dbg_cntrs;
#define IPSEC_DEBUG_COUNTER_INCREMENT(counter) do { (g_ipsec_dbg_cntrs.dbg_##counter) += 1; } while(0)
#endif

/* While adding GRE-IPV6 over IPV6 tunnel header, overall bytes to add before sending to utilpe 
 * is coming up to 130 bytes(98(total GRE +IPSEC headers) + 24 (util_rx_hdr) + 8 (class_tx_hdr)).
 * But the allowed DMEM to grow is 128 - 16 = 112 bytes). So inorder to make it work,
 * copy the packet's initial 16 bytes to the end of packet's DDR location
 * (DDR address + 2K -128 ) and copy these 16 bytes again into the data before
 * encryption (use the util_rx_hdr space in DMEM).*/

#define PKT_CPY_DATA_LEN_FROM_START	16
#define PKT_CPY_OFFSET_FROM_END		128
#endif

extern IPSec_hw_context g_ipsec_hw_ctx;
#if defined (COMCERTO_2000_CONTROL)
int hw_sa_set_digest_key(PSAEntry sa, U16 key_bits, U8* key);
int hw_sa_set_cipher_ALG_AESCTR(PSAEntry sa, U16 key_bits, U8* key , U8* algo);
int hw_sa_set_cipher_key(PSAEntry sa, U8* key);
int hw_sa_set_lifetime(CommandIPSecSetLifetime *cmd, PSAEntry sa);
PElliptic_SA allocElpSA(dma_addr_t*);
void freeElpSA(PElliptic_SA psa, dma_addr_t);
int freeAramElpSA(PElliptic_SA psa);
void disableElpSA(PElliptic_SA psa);
#endif

#endif	/* _MODULE_IPSEC_H_ */