arch/arm/plat-feroceon/mv_hal/qd-dsdt/Include/msApiDefs.h

#include <Copyright.h>

/********************************************************************************
* msApiDefs.h
*
* DESCRIPTION:
*       API definitions for QuarterDeck Device
*
* DEPENDENCIES:
*
* FILE REVISION NUMBER:
*
*******************************************************************************/

#ifndef __msApiDefs_h
#define __msApiDefs_h

#ifdef __cplusplus
extern "C" {
#endif
#include <msApiTypes.h>
/* Debug function   */
#ifdef DEBUG_QD
#define DBG_INFO(x) gtDbgPrint x
#else
#define DBG_INFO(x);
#endif /* DEBUG_QD */

typedef GT_U32 GT_SEM;

#define ETHERNET_HEADER_SIZE	GT_ETHERNET_HEADER_SIZE
#define IS_MULTICAST_MAC		GT_IS_MULTICAST_MAC
#define IS_BROADCAST_MAC		GT_IS_BROADCAST_MAC

#define GT_INVALID_PHY			0xFF
#define GT_INVALID_PORT			0xFF
#define GT_INVALID_PORT_VEC		0xFFFFFFFF

#define GT_UNUSED_PARAM(_a)		(_a)=(_a)

/*
 *   Logical Port value based on a Port
 *   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *  |0|  reserved                                   |    port       |
 *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *
 *
 *   The following macros should be used to extract specific info
 *   from a Logical Port index
 */
typedef GT_U32 GT_LPORT;
typedef GT_U32 GT_ETYPE;


/* Define the different device type that may exist in system        */
typedef enum
{
	GT_88E6021  = 0x021,
	GT_88E6051  = 0x051,
	GT_88E6052  = 0x052,
	GT_88E6060  = 0x060,
	GT_88E6063	= 0x153,
	GT_FH_VPN	= 0xF53,
	GT_FF_EG	= 0xF91,
	GT_FF_HG	= 0xF93,
	
	GT_88E6083	= 0x083,

	GT_88E6181	= 0x1A0,

	GT_88E6153	= 0x1A1,
	GT_88E6183	= 0x1A3,

	GT_88E6093	= 0x093,
	GT_88E6092	= 0x097,
	GT_88E6045	= 0x094,
	GT_88E6095	= 0x095,

	GT_88E6152	= 0x1A4,
	GT_88E6155	= 0x1A5,
	GT_88E6182	= 0x1A6,
	GT_88E6185	= 0x1A7,

	GT_88E6121	= 0x104,
	GT_88E6122	= 0x105,
	GT_88E6131	= 0x106,
	GT_88E6108	= 0x107,

	GT_88E6031	= 0x031,
	GT_88E6035	= 0x035,
	GT_88E6055	= 0x055,
	GT_88E6061	= 0x061,
	GT_88E6065	= 0x065,

	GT_88E6046	= 0x048,
	GT_88E6047	= 0x049,
	GT_88E6085	= 0x04A,
	GT_88E6096	= 0x098,
	GT_88E6097	= 0x099,

	GT_88E6123	= 0x121,
	GT_88E6140	= 0x141,
	GT_88E6161	= 0x161,
	GT_88E6165	= 0x165,

	GT_88E6351	= 0x375,
	GT_88E6175	= 0x175,
	GT_88E6125	= 0x124,	/* was 88E6124 */
	GT_88E6171	= 0x171,
	GT_88E6321	= 0x324,	/* was 88E6325 */
	GT_88E6350	= 0x371,	/* was 88E6371 */
	GT_KW2_INT	= 0x044		/* Internal Swiych in KW2 */

}GT_DEVICE;


/* Definition for the revision number of the device        */
typedef enum
{
	GT_REV_0 = 0,
	GT_REV_1,
	GT_REV_2,
	GT_REV_3
}GT_DEVICE_REV;


/* ToDo: No Used */
typedef enum
{
	INTR_MODE_DISABLE =0,
	INTR_MODE_ENABLE
}INTERRUPT_MODE;

/* Definition for the Port Speed */
typedef enum
{
	PORT_SPEED_10_MBPS = 0,
	PORT_SPEED_100_MBPS = 1,
	PORT_SPEED_200_MBPS = 2,	/* valid only if device support */
	PORT_SPEED_1000_MBPS = 2 ,	/* valid only if device support */
	PORT_SPEED_UNKNOWN = 3
} GT_PORT_SPEED_MODE;

/* Definition for the forced Port Speed */
typedef enum
{
	PORT_FORCE_SPEED_10_MBPS = 0,
	PORT_FORCE_SPEED_100_MBPS = 1,
	PORT_FORCE_SPEED_200_MBPS = 2,	/* valid only if device support */
	PORT_FORCE_SPEED_1000_MBPS = 2,	/* valid only if device support */
	PORT_DO_NOT_FORCE_SPEED =3
} GT_PORT_FORCED_SPEED_MODE;

/* Definition for the forced Port Duplex mode */
typedef enum
{
	PORT_DO_NOT_FORCE_DUPLEX,
	PORT_FORCE_FULL_DUPLEX,
	PORT_FORCE_HALF_DUPLEX
} GT_PORT_FORCED_DUPLEX_MODE;

/* Definition for the forced Port Link */
typedef enum
{
	PORT_DO_NOT_FORCE_LINK,
	PORT_FORCE_LINK_UP,
	PORT_FORCE_LINK_DOWN
} GT_PORT_FORCED_LINK_MODE;

/* Definition for the forced flow control mode */
typedef enum
{
	PORT_DO_NOT_FORCE_FC,
	PORT_FORCE_FC_ENABLED,
	PORT_FORCE_FC_DISABLED
} GT_PORT_FORCED_FC_MODE;

/* Definition for the PPU state */
typedef enum
{
	PPU_STATE_DISABLED_AT_RESET,
	PPU_STATE_ACTIVE,
	PPU_STATE_DISABLED_AFTER_RESET,
	PPU_STATE_POLLING
} GT_PPU_STATE;


/*
 * Typedef: enum GT_PORT_CONFIG_MODE
 *
 * Description: Defines port's interface type configuration mode determined at 
 *				reset. This definition may not represent the device under use.
 *				Please refer to the device datasheet for detailed information.
 *
 */
typedef enum
{
	PORTCFG_GMII_125MHZ = 0,		/* Px_GTXCLK = 125MHz, 1000BASE */
	PORTCFG_FD_MII_0MHZ = 1,		/* Px_GTXCLK = 0 MHz, Power Save */
	PORTCFG_FDHD_MII_25MHZ = 2,		/* Px_GTXCLK = 25MHz, 100BASE */ 
	PORTCFG_FDHD_MII_2_5MHZ = 3,	/* Px_GTXCLK = 2.5MHz, 10BASE */
	PORTCFG_FD_SERDES = 4,			/* Default value */
	PORTCFG_FD_1000BASE_X = 5,		
	PORTCFG_MGMII = 6,				/* duplex, speed determined by the PPU */
	PORTCFG_DISABLED = 7			
} GT_PORT_CONFIG_MODE;


typedef enum
{
	GT_SA_FILTERING_DISABLE = 0,
	GT_SA_DROP_ON_LOCK,
	GT_SA_DROP_ON_UNLOCK,
	GT_SA_DROP_TO_CPU
} GT_SA_FILTERING;


/* Definition for the Ingree/Egress Frame Mode */
typedef enum
{
	GT_FRAME_MODE_NORMAL = 0,	/* Normal Network */
	GT_FRAME_MODE_DSA,			/* Distributed Switch Architecture */
	GT_FRAME_MODE_PROVIDER,		/* Provider */
	GT_FRAME_MODE_ETHER_TYPE_DSA	/* Ether Type DSA */
} GT_FRAME_MODE;

/*
 * Typedef: enum GT_JUMBO_MODE
 *
 * Description: Defines Jumbo Frame Size allowed to be tx and rx
 *
 * Fields:
 *      GT_JUMBO_MODE_1522 - Rx and Tx frames with max byte of 1522.
 *      GT_JUMBO_MODE_2048 - Rx and Tx frames with max byte of 2048.
 *      GT_JUMBO_MODE_10240 - Rx and Tx frames with max byte of 10240.
 *				 
 */
typedef enum
{
	GT_JUMBO_MODE_1522 = 0,
	GT_JUMBO_MODE_2048,
	GT_JUMBO_MODE_10240
} GT_JUMBO_MODE;


/*
 * Typedef: enum GT_PRI_OVERRIDE
 *
 * Description: Defines the priority override
 *
 * Fields:
 *      PRI_OVERRIDE_NONE - Normal frame priority processing occurs.
 *		PRI_OVERRIDE_FRAME_QUEUE -
 *			Both frame and queue overrides take place on the frame.
 *      PRI_OVERRIDE_FRAME - 
 *			Overwite the frame's FPri (frame priority).
 *			If the frame egresses tagged, the priority in the frame will be
 *			the overwritten priority value.
 *		PRI_OVERRIDE_QUEUE -
 *			Overwite the frame's QPri (queue priority).
 *			QPri is used internally to map the frame to one of the egress
 *			queues inside the switch.
 *
 */
typedef enum
{
	PRI_OVERRIDE_NONE = 0,
	PRI_OVERRIDE_FRAME_QUEUE,
	PRI_OVERRIDE_FRAME,
	PRI_OVERRIDE_QUEUE
} GT_PRI_OVERRIDE;


/*
 * Typedef: enum GT_FRAME_POLICY
 *
 * Description: Defines the policy of the frame
 *
 * Fields:
 *      FRAME_POLICY_NONE - Normal frame switching
 *      FRAME_POLICY_MIRROR - Mirror(copy) frame to the MirrorDest port
 *      FRAME_POLICY_TRAP - Trap(re-direct) frame to the CPUDest port
 *      FRAME_POLICY_DISCARD - Discard(filter) the frame
 *
 */
typedef enum
{
	FRAME_POLICY_NONE = 0,
	FRAME_POLICY_MIRROR,
	FRAME_POLICY_TRAP,
	FRAME_POLICY_DISCARD
} GT_FRAME_POLICY;


/*
 * Typedef: enum GT_POLICY_TYPE
 *
 * Description: Defines the policy type
 *
 * Fields:
 *      POLICY_TYPE_DA 	- Policy based on Destination Address
 *      POLICY_TYPE_SA 	- Policy based on Source Address
 *      POLICY_TYPE_VTU 	- Policy based on VID
 *		POLICY_TYPE_ETYPE	- based on Ether Type of a frame
 *		POLICY_TYPE_PPPoE	- Policy for the frame with Ether Type of 0x8863
 *		POLICY_TYPE_VBAS	- Policy for the frame with Ether Type of 0x8200
 *		POLICY_TYPE_OPT82	- Policy for the frame with DHCP Option 82
 *		POLICY_TYPE_UDP	- Policy for the frame with Broadcast IPv4 UDP or
 *						Multicast IPv6 UDP
 */
typedef enum
{
	POLICY_TYPE_DA,
	POLICY_TYPE_SA,
	POLICY_TYPE_VTU,
	POLICY_TYPE_ETYPE,
	POLICY_TYPE_PPPoE,
	POLICY_TYPE_VBAS,
	POLICY_TYPE_OPT82,
	POLICY_TYPE_UDP
} GT_POLICY_TYPE;


/*
 * Typedef: enum GT_PRI_OVERRIDE_FTYPE
 *
 * Description: Definition of the frame type for priority override
 *
 * Fields:
 *		FTYPE_DSA_TO_CPU_BPDU -
 *			Used on multicast DSA To_CPU frames with a Code of 0x0 (BPDU/MGMT).
 *			Not used on non-DSA Control frames.
 *		FTYPE_DSA_TO_CPU_F2R -
 *			Used on DSA To_CPU frames with a Code of 0x1 (Frame to Register
 *			Reply). Not used on non-DSA Control frames.
 *		FTYPE_DSA_TO_CPU_IGMP -
 *			Used on DSA To_CPU frames with a Code of 0x2 (IGMP/MLD Trap)
 *			and on non-DSA Control frames that are IGMP or MLD trapped
 *		FTYPE_DSA_TO_CPU_TRAP -
 *			Used on DSA To_CPU frames with a Code of 0x3 (Policy Trap) and
 *			on non-DSA Control frames that are Policy Trapped
 *		FTYPE_DSA_TO_CPU_ARP -
 *			Used on DSA To_CPU frames with a Code of 0x4 (ARP Mirror) and
 *			on non-DSA Control frames that are ARP Mirrored (see gprtSetARPtoCPU API).
 *		FTYPE_DSA_TO_CPU_MIRROR -
 *			Used on DSA To_CPU frames with a Code of 0x5 (Policy Mirror) and
 *			on non-DSA Control frames that are Policy Mirrored (see gprtSetPolicy API).
 *		FTYPE_DSA_TO_CPU_RESERVED -
 *			Used on DSA To_CPU frames with a Code of 0x6 (Reserved). Not
 *			used on non-DSA Control frames.
 *		FTYPE_DSA_TO_CPU_UCAST_MGMT -
 *			Used on unicast DSA To_CPU frames with a Code of 0x0 (unicast
 *			MGMT). Not used on non-DSA Control frames.
 *		FTYPE_DSA_FROM_CPU -
 *			Used on DSA From_CPU frames. Not used on non-DSA Control frame
 *		FTYPE_DSA_CROSS_CHIP_FC -
 *			Used on DSA Cross Chip Flow Control frames (To_Sniffer Flow
 *			Control). Not used on non-DSA Control frames.
 *		FTYPE_DSA_CROSS_CHIP_EGRESS_MON -
 *			Used on DSA Cross Chip Egress Monitor frames (To_Sniffer Tx).
 *			Not used on non-DSA Control frames.
 *		FTYPE_DSA_CROSS_CHIP_INGRESS_MON -
 *			Used on DSA Cross Chip Ingress Monitor frames (To_Sniffer Rx).
 *			Not used on non-DSA Control frames.
 *		FTYPE_PORT_ETYPE_MATCH -
 *			Used on normal network ports (see gprtSetFrameMode API)
 *			on frames whose Ethertype matches the port's PortEType register.
 *			Not used on non-DSA Control frames.
 *		FTYPE_BCAST_NON_DSA_CONTROL -
 *			Used on Non-DSA Control frames that contain a Broadcast
 *			destination address. Not used on DSA Control frames.
 *		FTYPE_PPPoE_NON_DSA_CONTROL -
 *			Used on Non-DSA Control frames that contain an Ether Type 0x8863
 *			(i.e., PPPoE frames). Not used on DSA Control frames.
 *		FTYPE_IP_NON_DSA_CONTROL -
 *			Used on Non-DSA Control frames that contain an IPv4 or IPv6 Ether
 *			Type. Not used on DSA Control frames.
 */
typedef enum
{
	FTYPE_DSA_TO_CPU_BPDU = 0,
	FTYPE_DSA_TO_CPU_F2R,
	FTYPE_DSA_TO_CPU_IGMP,
	FTYPE_DSA_TO_CPU_TRAP,
	FTYPE_DSA_TO_CPU_ARP,
	FTYPE_DSA_TO_CPU_MIRROR,
	FTYPE_DSA_TO_CPU_RESERVED,
	FTYPE_DSA_TO_CPU_UCAST_MGMT,
	FTYPE_DSA_FROM_CPU,
	FTYPE_DSA_CROSS_CHIP_FC,
	FTYPE_DSA_CROSS_CHIP_EGRESS_MON,
	FTYPE_DSA_CROSS_CHIP_INGRESS_MON,
	FTYPE_PORT_ETYPE_MATCH,
	FTYPE_BCAST_NON_DSA_CONTROL,
	FTYPE_PPPoE_NON_DSA_CONTROL,
	FTYPE_IP_NON_DSA_CONTROL
} GT_PRI_OVERRIDE_FTYPE;


/*
 * Typedef: struct GT_QPRI_TBL_ENTRY
 *
 * Description: This structure is used for the entry of Queue Priority Override
 *				Table.
 *
 * Fields:
 *		qPriEn    - GT_TRUE to enable Queue Priority, GT_FALSE otherwise
 *		qPriority - priority to be overridden ( 0 ~ 3 ) only if qPriEn is GT_TRUE
 *					When qPriEn is GT_FALSE, qPriority should be ignored.
 *
 * Notes: If device does not support qPriAvbEn, qPriAvbEn and qAvbPriority fields
 *		will be ignored.
 */
typedef struct
{
	GT_BOOL		qPriEn;
	GT_U32		qPriority;
}GT_QPRI_TBL_ENTRY;


/*
 * Typedef: struct GT_FPRI_TBL_ENTRY
 *
 * Description: This structure is used for the entry of Frame Priority Override
 *				Table.
 *
 * Fields:
 *		fPriEn    - GT_TRUE to enable Frame Priority, GT_FALSE otherwise
 *		fPriority - priority to be overridden ( 0 ~ 7 ) only if fPriEn is GT_TRUE
 *					When fPriEn is GT_FALSE, fPriority should be ignored.
 */
typedef struct
{
	GT_BOOL		fPriEn;
	GT_U32		fPriority;
}GT_FPRI_TBL_ENTRY;


/* Maximam number of ports a switch may have. */
#define MAX_SWITCH_PORTS    11
#define VERSION_MAX_LEN 	30
#define MAX_QOS_WEIGHTS		128

/*
 * Typedef: struct GT_QoS_WEIGHT
 *
 * Description: This structure is used for Programmable Round Robin Weights.
 *
 * Fields:
 *      len    - length of the valid queue data
 *		queue  - upto 128 queue data
 */
typedef struct
{
	GT_U32		len;
	GT_U8		queue[MAX_QOS_WEIGHTS];
}GT_QoS_WEIGHT;



/*
 * Typedef: struct GT_VERSION
 *
 * Description: This struct holds the package version.
 *
 * Fields:
 *      version - string array holding the version.
 *
 */
typedef struct
{
	GT_U8   version[VERSION_MAX_LEN];
}GT_VERSION;


/*
 * typedef: struct GT_RMU
 *
 * Description: This struct holds the Remote Management Unit mode.
 *
 * Fields:
 *		rmuEn	- enable or disable RMU
 *		port	- logical port where RMU is enabled
 */
typedef struct
{
	GT_BOOL		rmuEn;
	GT_LPORT	port;
} GT_RMU;



/*
 * Typedef:
 *
 * Description: Defines the different sizes of the Mac address table.
 *
 * Fields:
 *      ATU_SIZE_256    -   256 entries Mac address table.
 *      ATU_SIZE_512    -   512 entries Mac address table.
 *      ATU_SIZE_1024   -   1024 entries Mac address table.
 *      ATU_SIZE_2048   -   2048 entries Mac address table.
 *      ATU_SIZE_4096   -   4096 entries Mac address table.
 *      ATU_SIZE_8192   -   8192 entries Mac address table.
 *
 */
typedef enum
{
	ATU_SIZE_256,
	ATU_SIZE_512,
	ATU_SIZE_1024,
	ATU_SIZE_2048,
	ATU_SIZE_4096,
	ATU_SIZE_8192
}ATU_SIZE;


/*
 * typedef: enum GT_PORT_STP_STATE
 *
 * Description: Enumeration of the port spanning tree state.
 *
 * Enumerations:
 *   GT_PORT_DISABLE    - port is disabled.
 *   GT_PORT_BLOCKING   - port is in blocking/listening state.
 *   GT_PORT_LEARNING   - port is in learning state.
 *   GT_PORT_FORWARDING - port is in forwarding state.
 */
typedef enum
{
	GT_PORT_DISABLE = 0,
	GT_PORT_BLOCKING,
	GT_PORT_LEARNING,
	GT_PORT_FORWARDING
} GT_PORT_STP_STATE;


/*
 * typedef: enum GT_EGRESS_MODE
 *
 * Description: Enumeration of the port egress mode.
 *
 * Enumerations:
 *   GT_UNMODIFY_EGRESS - frames are transmited unmodified.
 *   GT_TAGGED_EGRESS   - all frames are transmited tagged.
 *   GT_UNTAGGED_EGRESS - all frames are transmited untagged.
 *   GT_ADD_TAG         - always add a tag. (or double tag)
 */
typedef enum
{
	GT_UNMODIFY_EGRESS = 0,
	GT_UNTAGGED_EGRESS,
	GT_TAGGED_EGRESS,
	GT_ADD_TAG
} GT_EGRESS_MODE;

/*  typedef: enum GT_DOT1Q_MODE */

typedef enum
{
	GT_DISABLE = 0,
	GT_FALLBACK,
	GT_CHECK,
	GT_SECURE
} GT_DOT1Q_MODE;


/* typedef: enum GT_SW_MODE */

typedef enum
{
	GT_CPU_ATTATCHED = 0, /* ports come up disabled */
	GT_BACKOFF,           /* EEPROM attac mode with old half duplex backoff mode */
	GT_STAND_ALONE,       /* ports come up enabled, ignore EEPROM */
	GT_EEPROM_ATTATCHED   /* EEPROM defined prot states */
} GT_SW_MODE;


/*
 * Typedef: enum GT_ATU_OPERARION
 *
 * Description: Defines the different ATU and VTU operations
 *
 * Fields:
 *      FLUSH_ALL           - Flush all entries.
 *      FLUSH_UNLOCKED      - Flush all unlocked entries in ATU.
 *      LOAD_PURGE_ENTRY    - Load / Purge entry.
 *      GET_NEXT_ENTRY      - Get next ATU or VTU  entry.
 *      FLUSH_ALL_IN_DB     - Flush all entries in a particular DBNum.
 *      FLUSH_UNLOCKED_IN_DB - Flush all unlocked entries in a particular DBNum.
 *      SERVICE_VIOLATONS   - sevice violations of VTU
 *
 */
typedef enum
{
	FLUSH_ALL = 1,		/* for both atu and vtu */
	FLUSH_UNLOCKED,		/* for atu only */
	LOAD_PURGE_ENTRY,	/* for both atu and vtu */
	GET_NEXT_ENTRY,		/* for both atu and vtu */
	FLUSH_ALL_IN_DB,	/* for atu only */
	FLUSH_UNLOCKED_IN_DB,	/* for atu only */
	SERVICE_VIOLATIONS 	/* for vtu only */
} GT_ATU_OPERATION, GT_VTU_OPERATION;


/*
 * typedef: enum GT_FLUSH_CMD
 *
 * Description: Enumeration of the address translation unit flush operation.
 *
 * Enumerations:
 *   GT_FLUSH_ALL       - flush all entries.
 *   GT_FLUSH_ALL_UNBLK - flush all unblocked (or unlocked).
 *   GT_FLUSH_ALL_UNLOCKED - flush all unblocked (or unlocked).
 */
typedef enum
{
    GT_FLUSH_ALL       = 1,
    GT_FLUSH_ALL_UNBLK = 2,
    GT_FLUSH_ALL_UNLOCKED = 2
}GT_FLUSH_CMD;

/*
 * typedef: enum GT_MOVE_CMD
 *
 * Description: Enumeration of the address translation unit move or remove operation.
 *	 When destination port is set to 0xF, Remove operation occurs.
 *
 * Enumerations:
 *   GT_MOVE_ALL       - move all entries.
 *   GT_MOVE_ALL_UNBLK - move all unblocked (or unlocked).
 *   GT_MOVE_ALL_UNLOCKED - move all unblocked (or unlocked).
 */
typedef enum
{
	GT_MOVE_ALL       = 1,
	GT_MOVE_ALL_UNBLK = 2,
	GT_MOVE_ALL_UNLOCKED = 2
}GT_MOVE_CMD;


/*
 * typedef: enum GT_ATU_UC_STATE
 *
 * Description:
 *      Enumeration of the address translation unit entry state of unicast
 *      entris.
 *
 * Enumerations:
 *		GT_UC_INVALID   - invalid entry.
 *		GT_UC_DYNAMIC   - unicast dynamic entry.
 *		GT_UC_NO_PRI_TO_CPU_STATIC_NRL 
 *				- static unicast entry that will be forwarded to CPU without 
 *					forcing priority and without rate limiting.
 *		GT_UC_TO_CPU_STATIC_NRL 
 *				- static unicast entry that will be forwarded to CPU without
 *					rate limiting.
 *		GT_UC_NO_PRI_STATIC_NRL 
 *				- static unicast entry without forcing priority and without.
 *					rate limiting.
 *		GT_UC_NO_PRI_STATIC_AVB_ENTRY 
 *				- static unicast AVB entry without forcing priority if MacAvb is enabled.
 *		GT_UC_STATIC_NRL    - static unicast entry without rate limiting.
 *		GT_UC_STATIC_AVB_ENTRY - static unicast AVB entry if MacAvb is enabled .
 *		GT_UC_NO_PRI_TO_CPU_STATIC
 *				- static unicast entry that will be forwarded to CPU without 
 *					forcing priority.
 *		GT_UC_TO_CPU_STATIC - static unicast entry that will be forwarded to CPU.
 *		GT_UC_NO_PRI_STATIC - static unicast entry without forcing priority.
 *		GT_UC_STATIC    - static unicast entry.
 *
 * Note: Please refer to the device datasheet for detailed unicast entry states
 *		that are supported by the device.
 */
typedef enum
{
	GT_UC_INVALID      = 0,
	GT_UC_DYNAMIC      = 0x1,

	GT_UC_NO_PRI_TO_CPU_STATIC_NRL	= 0x8,
	GT_UC_TO_CPU_STATIC_NRL			= 0x9,
	GT_UC_NO_PRI_STATIC_NRL			= 0xA,
	GT_UC_NO_PRI_STATIC_AVB_ENTRY	= 0xA,
	GT_UC_STATIC_NRL 				= 0xB,
	GT_UC_STATIC_AVB_ENTRY			= 0xB,

	GT_UC_NO_PRI_TO_CPU_STATIC	= 0xC,
	GT_UC_TO_CPU_STATIC 		= 0xD,
	GT_UC_NO_PRI_STATIC 		= 0xE,
	GT_UC_STATIC  				= 0xF
} GT_ATU_UC_STATE;


/*
 * typedef: enum GT_ATU_MC_STATE
 *
 * Description:
 *      Enumeration of the address translation unit entry state of multicast
 *      entris.
 *
 * Enumerations:
 *      GT_MC_INVALID         - invalid entry.
 *      GT_MC_MGM_STATIC      - static multicast management entries.
 *      GT_MC_STATIC          - static multicast regular entris.
 *      GT_MC_STATIC_AVB_ENTRY- static AVB entry if MacAvb is enalbed.
 *      GT_MC_PRIO_MGM_STATIC - static multicast management entries with
 *                              priority.
 *      GT_MC_PRIO_STATIC     - static multicast regular entris with priority.
 *      GT_MC_PRIO_STATIC_AVB_ENTRY      - static multicast AVB Entry with priority if MacAvb is enabled
 *      GT_MC_PRIO_STATIC_UNLIMITED_RATE - static multicast regular entris with priority
 *											and without rate limiting.
 *      GT_MC_MGM_STATIC_UNLIMITED_RATE	 - static multicast management entries without
 *											rate limiting.
 *      GT_MC_STATIC_UNLIMITED_RATE      - static multicast regular entris without
 *											rate limiting.
 *      GT_MC_PRIO_MGM_STATIC_UNLIMITED_RATE - static multicast management entries with
 *                              priority and without rate limiting.
 *
 * Note: Please refer to the device datasheet for detailed multicast entry states
 *		that are supported by the device.
 */
typedef enum
{
	GT_MC_INVALID         = 0,
	GT_MC_MGM_STATIC_UNLIMITED_RATE = 0x4,
	GT_MC_STATIC_UNLIMITED_RATE	= 0x5,
	GT_MC_STATIC_AVB_ENTRY	= 0x5,
	GT_MC_MGM_STATIC      = 0x6,
	GT_MC_STATIC          = 0x7,
	GT_MC_PRIO_MGM_STATIC_UNLIMITED_RATE = 0xC,
	GT_MC_PRIO_STATIC_UNLIMITED_RATE	= 0xD,
	GT_MC_PRIO_STATIC_AVB_ENTRY	= 0xD,
	GT_MC_PRIO_MGM_STATIC = 0xE,
	GT_MC_PRIO_STATIC     = 0xF
} GT_ATU_MC_STATE;


/*
 *  typedef: struct GT_ATU_EXT_PRI
 *
 *  Description: 
 *		Extanded priority information for the address tarnslaton unit entry.
 *
 *		macFPri data is used to override the frame priority on any frame associated
 *		with this MAC, if the useMacFPri is GT_TRUE and the port's SA and/or 
 *		DA FPriOverride are enabled. SA Frame Priority Overrides can only occur on 
 *		MAC addresses that are Static or where the Port is Locked, and where the port 
 *		is mapped source port for the MAC address.
 *
 *		macQPri data is used to override the queue priority on any frame associated
 *		with this MAC, if the EntryState indicates Queue Priority Override and the 
 *		port's SA and/or DA QPriOverride are enabled. 
 *
 *  Fields:
 *      useMacFPri - Use MAC frame priority override. When this is GT_TRUE,
 *					 MacFPri data can be used to override the frame priority on
 *					 any frame associated with this MAC.
 *      macFPri    - MAC frame priority data (0 ~ 7).
 *      macQPri    - MAC queue priority data (0 ~ 3).
 *
 *  Comment:
 *      Please refer to the device datasheet to find out if this feature is supported.
 *		When this structure is implemented, the followings are the devices supporting 
 *		this feature:
 *			88E6065, 88E6035, and 88E6055 support all extanded priority data.
 *			88E6061 and 88E6031 support only macQPri data
 */
typedef struct
{
	GT_BOOL			useMacFPri;
	GT_U8 			macFPri;
	GT_U8 			macQPri;
} GT_ATU_EXT_PRI;


/*
 *  typedef: struct GT_ATU_ENTRY
 *
 *  Description: address tarnslaton unit Entry
 *
 *  Fields:
 *      macAddr    - mac address
 *      trunkMember- GT_TRUE if entry belongs to a Trunk. This field will be
 *					 ignored if device does not support Trunk.
 *      portVec    - port Vector. 
 *					 If trunkMember field is GT_TRUE, this value represents trunk ID.
 *      prio       - entry priority.
 *      entryState - the entry state.
 *		DBNum	   - ATU MAC Address Database number. If multiple address 
 *					 databases are not being used, DBNum should be zero.
 *					 If multiple address databases are being used, this value
 *					 should be set to the desired address database number.
 *		exPrio     - extanded priority information. If device support extanded 
 *					 priority, prio field should be ignored.
 *
 *  Comment:
 *      The entryState union Type is determine according to the Mac Type.
 */
typedef struct
{
	GT_ETHERADDR 	macAddr;
	GT_BOOL			trunkMember;
	GT_U32			portVec;
	GT_U8			prio;
	GT_U8			reserved;
	GT_U16			DBNum;
	union
	{
		GT_ATU_UC_STATE ucEntryState;
		GT_ATU_MC_STATE mcEntryState;
	} entryState;
	GT_ATU_EXT_PRI	exPrio;
} GT_ATU_ENTRY;


/*
 *  typedef: struct GT_VTU_DATA
 *
 *  Description: VLAN  tarnslaton unit Data Register
 *
 *  Fields:
 *      memberTagP - Membership and Egress Tagging
 *                   memberTagP[0] is for Port 0, MemberTagP[1] is for port 1, and so on 
 *
 *  Comment:
 * 	MAX_SWITCH_PORTS is 10 for Octane.
 * 	In the case of FullSail, there are 3 ports. So, the rest 7 is ignored in memeberTagP
 */
typedef struct
{
	GT_U8     memberTagP[MAX_SWITCH_PORTS];
	GT_U8     portStateP[MAX_SWITCH_PORTS];
} GT_VTU_DATA;

/*
 *  definition for MEMBER_TAG
 */
#define MEMBER_EGRESS_UNMODIFIED	0
#define NOT_A_MEMBER				1
#define MEMBER_EGRESS_UNTAGGED		2
#define MEMBER_EGRESS_TAGGED		3

/*
 *  typedef: struct GT_VTU_EXT_INFO
 *
 *  Description: 
 *		Extanded VTU Entry information for Priority Override and Non Rate Limit.
 *		Frame Priority is used to as the tag's PRI bits if the frame egresses
 *		the switch tagged. The egresss queue the frame is switch into is not
 *		modified by the Frame Priority Override.
 *		Queue Priority is used to determine the egress queue the frame is
 *		switched into. If the frame egresses tagged, the priority in the frame 
 *		will not be modified by a Queue Priority Override.
 *		NonRateLimit for VID is used to indicate any frames associated with this 
 *		VID are to bypass ingress and egress rate limiting, if the ingress 
 *		port's VID NRateLimit is also enabled.
 *
 *  Fields:
 *      useVIDFPri - Use VID frame priority override. When this is GT_TRUE and 
 *					 VIDFPriOverride of the ingress port of the frame is enabled,
 *					 vidFPri data is used to override the frame priority on
 *					 any frame associated with this VID.
 *      vidFPri    - VID frame priority data (0 ~ 7).
 *      useVIDQPri - Use VID queue priority override. When this is GT_TRUE and
 *					 VIDQPriOverride of the ingress port of the frame is enabled,
 *					 vidQPri data can be used to override the queue priority on
 *					 any frame associated with this VID.
 *      vidQPri    - VID queue priority data (0 ~ 3).
 *      vidNRateLimit - bypass rate ingress and egress limiting
 *
 *  Comment:
 *      Please refer to the device datasheet to find out if this feature is supported.
 *		When this structure is implemented, the followings are the devices supporting 
 *		this feature:
 *			88E6065, 88E6035, and 88E6055 support all data.
 *			88E6061 and 88E6031 support only vidNRateLimit.
 */
typedef struct
{
	GT_BOOL			useVIDFPri;
	GT_U8 			vidFPri;
	GT_BOOL			useVIDQPri;
	GT_U8 			vidQPri;
	GT_BOOL			vidNRateLimit;
} GT_VTU_EXT_INFO;

 
/*
 *  typedef: struct GT_VTU_ENTRY
 *
 *  Description: VLAN tarnslaton unit Entry
 *		Each field in the structure is device specific, i.e., some fields may not
 *		be supported by the used switch device. In such case, those fields are
 *		ignored by the DSDT driver. Please refer to the datasheet for the list of
 *		supported fields.
 *
 *  Fields:
 *      DBNum      - database number or FID (forwarding information database)
 *      vid        - VLAN ID 
 *      vtuData    - VTU data
 *		vidPriOverride - override the priority on any frame associated with this VID
 *		vidPriority - VID Priority bits (0 ~ 7)
 *		sid	       - 802.1s Port State Database ID
 *		vidPolicy  - indicate that the frame with this VID uses VID Policy
 *		             (see gprtSetPolicy API).
 *		vidExInfo  - extanded information for VTU entry. If the device supports extanded 
 *					 information, vidPriorityOverride and vidPriority values are 
 *					 ignored.
 */
typedef struct
{
	GT_U16        DBNum;
	GT_U16        vid;
	GT_VTU_DATA   vtuData;
	GT_BOOL		  vidPriOverride;
	GT_U8		  vidPriority;
	GT_U8		  sid;
	GT_BOOL		  vidPolicy;
	GT_VTU_EXT_INFO	vidExInfo;
} GT_VTU_ENTRY;


/*
 * Typedef: enum GT_STU_OPERARION
 *
 * Description: Defines the STU operations
 *
 * Fields:
 *      LOAD_PURGE_STU_ENTRY    - Load / Purge entry.
 *      GET_NEXT_STU_ENTRY      - Get next STU  entry.
 *
 */
typedef enum
{
	LOAD_PURGE_STU_ENTRY = 5,
	GET_NEXT_STU_ENTRY =6 
} GT_STU_OPERATION;


/*
 *  typedef: struct GT_STU_ENTRY
 *
 *  Description: 802.1s Port State Information Database (STU) Entry
 *
 *  Fields:
 *      sid       - STU ID 
 *		portState - Per VLAN Port States for each port.
 */
typedef struct
{
	GT_U16				sid;
	GT_PORT_STP_STATE	portState[MAX_SWITCH_PORTS];
} GT_STU_ENTRY;


/*
 *  typedef: struct GT_VTU_INT_STATUS
 *
 *  Description: VLAN tarnslaton unit interrupt status
 *
 *  Fields:
 *      intCause  - VTU Interrupt Cause
 *					GT_VTU_FULL_VIOLATION,GT_MEMEBER_VIOLATION,or
 *					GT_MISS_VIOLATION
 *      SPID      - source port number
 * 					if intCause is GT_VTU_FULL_VIOLATION, it means nothing
 *      vid       - VLAN ID 
 * 					if intCause is GT_VTU_FULL_VIOLATION, it means nothing
 */
typedef struct
{
	GT_U16   vtuIntCause;
	GT_U8    spid;
	GT_U16   vid;
} GT_VTU_INT_STATUS;

/*
 *  typedef: struct GT_ATU_INT_STATUS
 *
 *  Description: VLAN tarnslaton unit interrupt status
 *
 *  Fields:
 *      intCause  - ATU Interrupt Cause
 *					GT_FULL_VIOLATION,GT_MEMEBER_VIOLATION,
 *					GT_MISS_VIOLATION, GT_AGE_VIOLATION, or 
 *					GT_AGE_OUT_VIOLATION
 *      SPID      - source port number
 * 					if intCause is GT_FULL_VIOLATION, it means nothing
 *      DBNum     - DB Num (or FID)
 * 					if intCause is GT_FULL_VIOLATION, it means nothing
 *		macAddr	  - MAC Address
 */
typedef struct
{
	GT_U16   atuIntCause;
	GT_U8    spid;
	GT_U8    dbNum;
	GT_ETHERADDR  macAddr;
} GT_ATU_INT_STATUS;

/*
* Definition for VTU interrupt
*/
#define GT_MEMBER_VIOLATION		0x4
#define GT_MISS_VIOLATION		0x2
#define GT_VTU_FULL_VIOLATION	0x1
/*
* Definitions for ATU interrupt in Gigabit switch are the same as 
* the ones for VTU interrupt. Here we just redefine the FULL_VIOLATION for
* both VTU and ATU.
*/
#define GT_FULL_VIOLATION		0x1

#define GT_AGE_VIOLATION		0x8
#define GT_AGE_OUT_VIOLATION	0x10


/*
 * Typedef: enum GT_PVT_OPERATION
 *
 * Description: Defines the PVT (Cross Chip Port VLAN Table) Operation type
 *
 * Fields:
 *      PVT_INITIALIZE - Initialize all resources to the inital state
 *      PVT_WRITE      - Write to the selected PVT entry
 *      PVT_READ       - Read from the selected PVT entry
 */
typedef enum
{
	PVT_INITIALIZE 	= 0x1,
	PVT_WRITE		= 0x3,
	PVT_READ		= 0x4
} GT_PVT_OPERATION;


/*
 *  typedef: struct GT_PVT_OP_DATA
 *
 *  Description: data required by PVT (Cross Chip Port VLAN Table) Operation
 *
 *  Fields:
 *      pvtAddr - pointer to the desired entry of PVT
 *      pvtData - Cross Chip Port VLAN data for the entry pointed by pvtAddr
 */
typedef struct
{
	GT_U32	pvtAddr;
	GT_U32	pvtData;
} GT_PVT_OP_DATA;


/*
 *  typedef: enum GT_PIRL_FC_DEASSERT
 *
 *  Description: Enumeration of the port flow control de-assertion mode on PIRL.
 *
 *  Enumerations:
 *      GT_PIRL_FC_DEASSERT_EMPTY -
 *				De-assert when the ingress rate resource has become empty
 *		GT_PIRL_FC_DEASSERT_CBS_LIMIT -
 *				De-assert when the ingress rate resource has enough room as
 *				specified by the CBSLimit.
 */
typedef enum
{
	GT_PIRL_FC_DEASSERT_EMPTY = 0,
	GT_PIRL_FC_DEASSERT_CBS_LIMIT
} GT_PIRL_FC_DEASSERT;


/*
 *  typedef: enum GT_PIRL_ELIMIT_MODE
 *
 *  Description: Enumeration of the port egress rate limit counting mode.
 *
 *  Enumerations:
 *      GT_PIRL_ELIMIT_FRAME -
 *				Count the number of frames
 *      GT_PIRL_ELIMIT_LAYER1 -
 *				Count all Layer 1 bytes: 
 *				Preamble (8bytes) + Frame's DA to CRC + IFG (12bytes)
 *      GT_PIRL_ELIMIT_LAYER2 -
 *				Count all Layer 2 bytes: Frame's DA to CRC
 *      GT_PIRL_ELIMIT_LAYER3 -
 *				Count all Layer 3 bytes: 
 *				Frame's DA to CRC - 18 - 4 (if frame is tagged)
 */
typedef enum
{
	GT_PIRL_ELIMIT_FRAME = 0,
	GT_PIRL_ELIMIT_LAYER1,
	GT_PIRL_ELIMIT_LAYER2,
	GT_PIRL_ELIMIT_LAYER3
} GT_PIRL_ELIMIT_MODE;


/* typedef: enum GT_RATE_LIMIT_MODE
 * The ingress limit mode in the rate control register (0xA)
 */

typedef enum
{
	GT_LIMT_ALL = 0, 		/* limit and count all frames */
	GT_LIMIT_FLOOD,      	/* limit and count Broadcast, Multicast and flooded unicast frames */
	GT_LIMIT_BRDCST_MLTCST,	/* limit and count Broadcast and Multicast frames */
	GT_LIMIT_BRDCST   		/* limit and count Broadcast frames */
} GT_RATE_LIMIT_MODE;

/* typedef: enum GT_PRI0_RATE
 * The ingress data rate limit for priority 0 frames 
 */

typedef enum
{
	GT_NO_LIMIT = 0, 	/* Not limited   */
	GT_128K,      		/* 128K bits/sec */
	GT_256K,      		/* 256K bits/sec */
	GT_512K,      		/* 512 bits/sec */
	GT_1M,      		/* 1M  bits/sec */
	GT_2M,      		/* 2M  bits/sec */
	GT_4M,      		/* 4M  bits/sec */
	GT_8M,      		/* 8M  bits/sec */
	GT_16M,      		/* 16M  bits/sec, Note: supported only by Gigabit Ethernet Switch */
	GT_32M,      		/* 32M  bits/sec, Note: supported only by Gigabit Ethernet Switch */
	GT_64M,      		/* 64M  bits/sec, Note: supported only by Gigabit Ethernet Switch */
	GT_128M,      		/* 128M  bits/sec, Note: supported only by Gigabit Ethernet Switch */
	GT_256M      		/* 256M  bits/sec, Note: supported only by Gigabit Ethernet Switch */
} GT_PRI0_RATE,GT_EGRESS_RATE;


/*
 * Typedef: union GT_ERATE_TYPE
 *
 * Description: Egress Rate
 *
 * Fields:
 *      definedRate - GT_EGRESS_RATE enum type should be used on the following devices:
 *						88E6218, 88E6318, 88E6063, 88E6083, 88E6181, 88E6183, 88E6093
 *						88E6095, 88E6185, 88E6108, 88E6065, 88E6061, and their variations.
 *      kbRate      - rate in kbps that should be used on the following devices:
 *						88E6097, 88E6096 with count mode of non frame, such as
 *									ALL_LAYER1, ALL_LAYER2, and ALL_LAYER3
 *						64kbps ~ 1Mbps    : increments of 64kbps,
 *						1Mbps ~ 100Mbps   : increments of 1Mbps, and
 *						100Mbps ~ 1000Mbps: increments of 10Mbps
 *						Therefore, the valid values are:
 *							64, 128, 192, 256, 320, 384,..., 960,
 *							1000, 2000, 3000, 4000, ..., 100000,
 *							110000, 120000, 130000, ..., 1000000.
 *      fRate 		- frame per second that should be used on the following devices:
 *						88E6097, 88E6096 with count mode of frame (GT_PIRL_COUNT_FRAME)
 */
typedef union
{
	GT_EGRESS_RATE	definedRate;
	GT_U32			kbRate;
	GT_U32			fRate;
} GT_ERATE_TYPE;

/*
 * Formula for Rate Limit of Gigabit Switch family and Enhanced FastEthernet Switch
 */
#define GT_GET_RATE_LIMIT(_kbps)	\
		((_kbps)?(8000000 / (28 * (_kbps))):0)
#define GT_GET_RATE_LIMIT2(_kbps)	\
		((_kbps)?(8000000 / (32 * (_kbps)) + (8000000 % (32 * (_kbps))?1:0)):0)
#define GT_GET_RATE_LIMIT3(_kbps)	\
		((_kbps)?(8000000 / (40 * (_kbps)) + (8000000 % (40 * (_kbps))?1:0)):0)

#define MAX_RATE_LIMIT		256000	/* unit of Kbps */
#define MIN_RATE_LIMIT		65		/* unit of Kbps */


#define GT_GET_RATE_LIMIT_PER_FRAME(_frames, _dec)	\
		((_frames)?(1000000000 / (32 * (_frames)) + (1000000000 % (32 * (_frames))?1:0)):0)

#define GT_GET_RATE_LIMIT_PER_BYTE(_kbps, _dec)	\
		((_kbps)?((8000000*(_dec)) / (32 * (_kbps)) + ((8000000*(_dec)) % (32 * (_kbps))?1:0)):0)

/* 
 * typedef: enum GT_BURST_SIZE
 * The ingress data rate limit burst size windows selection
 */

typedef enum
{
	GT_BURST_SIZE_12K = 0, 	/* 12K byte burst size */
	GT_BURST_SIZE_24K,		/* 24K byte burst size */
	GT_BURST_SIZE_48K,		/* 48K byte burst size */
	GT_BURST_SIZE_96K 	 	/* 96K byte burst size */
} GT_BURST_SIZE;

/* 
 * typedef: enum GT_BURST_RATE
 * The ingress data rate limit based on burst size
 */

typedef enum
{
	GT_BURST_NO_LIMIT = 0, 	/* Not limited   */
	GT_BURST_64K,  		/* 64K bits/sec */
	GT_BURST_128K,  	/* 128K bits/sec */
	GT_BURST_256K,  	/* 256K bits/sec */
	GT_BURST_384K,  	/* 384K bits/sec */
	GT_BURST_512K,  	/* 512 bits/sec */
	GT_BURST_640K,  	/* 640K bits/sec */
	GT_BURST_768K,  	/* 768K bits/sec */
	GT_BURST_896K,  	/* 896K bits/sec */
	GT_BURST_1M,    	/* 1M  bits/sec */
	GT_BURST_1500K,  	/* 1.5M bits/sec */
	GT_BURST_2M,    	/* 2M  bits/sec */
	GT_BURST_4M,    	/* 4M  bits/sec */
	GT_BURST_8M,   		/* 8M  bits/sec */
	GT_BURST_16M,  		/* 16M  bits/sec */
	GT_BURST_32M,  		/* 32M  bits/sec */
	GT_BURST_64M,  		/* 64M  bits/sec */
	GT_BURST_128M, 		/* 128M  bits/sec */
	GT_BURST_256M  		/* 256M  bits/sec */
} GT_BURST_RATE;

/*
 * Formula for burst based Rate Limit
 */
#define GT_GET_BURST_RATE_LIMIT(_bsize,_kbps)	\
		((_kbps)?(((_bsize)+1)*8000000 / (32 * (_kbps)) + 		\
				(((_bsize)+1)*8000000 % (32 * (_kbps))?1:0))	\
				:0)

/*
 * Typedef: enum GT_PIRL_OPERATION
 *
 * Description: Defines the PIRL (Port Ingress Rate Limit) Operation type
 *
 * Fields:
 *      PIRL_INIT_ALL_RESOURCE - Initialize all resources to the inital state
 *      PIRL_INIT_RESOURCE     - Initialize selected resources to the inital state
 *      PIRL_WRITE_RESOURCE    - Write to the selected resource/register
 *      PIRL_READ_RESOURCE     - Read from the selected resource/register
 */
typedef enum
{
	PIRL_INIT_ALL_RESOURCE 	= 0x1,
	PIRL_INIT_RESOURCE		= 0x2,
	PIRL_WRITE_RESOURCE		= 0x3,
	PIRL_READ_RESOURCE		= 0x4
} GT_PIRL_OPERATION, GT_PIRL2_OPERATION;


/*
 *  typedef: struct GT_PIRL_OP_DATA
 *
 *  Description: data required by PIRL Operation
 *
 *  Fields:
 *      irlUnit   - Ingress Rate Limit Unit that defines one of IRL resources.
 *      irlReg    - Ingress Rate Limit Register.
 *      irlData   - Ingress Rate Limit Data.
 */
typedef struct
{
	GT_U32	irlUnit;
	GT_U32	irlReg;
	GT_U32	irlData;
} GT_PIRL_OP_DATA;

/*
 *  typedef: struct GT_PIRL2_OP_DATA
 *
 *  Description: data required by PIRL Operation
 *
 *  Fields:
 *      irlPort   - Ingress Rate Limiting port (physical port number).
 *      irlRes    - Ingress Rate Limit Resource.
 *      irlReg    - Ingress Rate Limit Register.
 *      irlData   - Ingress Rate Limit Data.
 */
typedef struct
{
	GT_U32	irlPort;
	GT_U32	irlRes;
	GT_U32	irlReg;
	GT_U32	irlData;
} GT_PIRL2_OP_DATA;

/*
 * Typedef: enum GT_PIRL_ACTION
 *
 * Description: Defines the Action that should be taken when
 *		there there are not enough tokens to accept the entire incoming frame
 *
 * Fields:
 *		PIRL_ACTION_ACCEPT - accept the frame
 *		PIRL_ACTION_USE_LIMIT_ACTION - use ESB Limit Action
 */
typedef enum
{
	PIRL_ACTION_USE_LIMIT_ACTION = 0x0,
	PIRL_ACTION_ACCEPT 	= 0x1
} GT_PIRL_ACTION;

/*
 * Typedef: enum GT_ESB_LIMIT_ACTION
 *
 * Description: Defines the ESB Limit Action that should be taken when
 *		the incoming port information rate exceeds the EBS_Limit.
 *
 * Fields:
 *		ESB_LIMIT_ACTION_DROP - drop packets
 *		ESB_LIMIT_ACTION_FC   - send flow control packet
 */
typedef enum
{
	ESB_LIMIT_ACTION_DROP 	= 0x0,
	ESB_LIMIT_ACTION_FC		= 0x1
} GT_ESB_LIMIT_ACTION;


/*
 * Typedef: enum GT_BUCKET_RATE_TYPE
 *
 * Description: Defines the Bucket Rate Type
 *
 * Fields:
 *		BUCKET_TYPE_TRAFFIC_BASED	- bucket is traffic type based
 *		BUCKET_TYPE_RATE_BASED		- bucket is rate based
 */
typedef enum
{
	BUCKET_TYPE_TRAFFIC_BASED	= 0x0,
	BUCKET_TYPE_RATE_BASED		= 0x1
} GT_BUCKET_RATE_TYPE;

/*
 * Definition for GT_BUCKET_TYPE_TRAFFIC_BASED
 *
 * Description: Defines the Traffic Type that is used when Bucket Rate Type
 *		is traffic type based (BUCKET_TYPE_TRAFFIC_BASED).
 *		Please refer to the device datasheet in order to check which traffic
 *		types are supported.
 *
 * Definition:
 *		BUCKET_TRAFFIC_UNKNOWN_UNICAST	- unknown unicast frame
 *		BUCKET_TRAFFIC_UNKNOWN_MULTICAST- unknown multicast frame
 *		BUCKET_TRAFFIC_BROADCAST		- broadcast frame
 *		BUCKET_TRAFFIC_MULTICAST		- multicast frame
 *		BUCKET_TRAFFIC_UNICAST			- unicast frame
 *		BUCKET_TRAFFIC_MGMT_FRAME		- management frame
 *		BUCKET_TRAFFIC_ARP				- arp frame
 *		BUCKET_TRAFFIC_TCP_DATA			- TCP Data
 *		BUCKET_TRAFFIC_TCP_CTRL			- TCP Ctrl (if any of the TCP Flags[5:0] are set)
 *		BUCKET_TRAFFIC_UDP				- UDP
 *		BUCKET_TRAFFIC_NON_TCPUDP		- covers IGMP,ICMP,GRE,IGRP,L2TP
 *		BUCKET_TRAFFIC_IMS				- Ingress Monitor Source
 *		BUCKET_TRAFFIC_POLICY_MIRROR	- Policy Mirror
 *		BUCKET_TRAFFIC_PLICY_TRAP		- Policy Trap
 */
#define BUCKET_TRAFFIC_UNKNOWN_UNICAST  	0x01
#define BUCKET_TRAFFIC_UNKNOWN_MULTICAST	0x02
#define BUCKET_TRAFFIC_BROADCAST			0x04
#define BUCKET_TRAFFIC_MULTICAST			0x08
#define BUCKET_TRAFFIC_UNICAST				0x10
#define BUCKET_TRAFFIC_MGMT_FRAME			0x20
#define BUCKET_TRAFFIC_ARP					0x40
#define BUCKET_TRAFFIC_TCP_DATA				0x100
#define BUCKET_TRAFFIC_TCP_CTRL				0x200
#define BUCKET_TRAFFIC_UDP					0x400
#define BUCKET_TRAFFIC_NON_TCPUDP			0x800
#define BUCKET_TRAFFIC_IMS					0x1000
#define BUCKET_TRAFFIC_POLICY_MIRROR		0x2000
#define BUCKET_TRAFFIC_PLICY_TRAP			0x4000

/*
 *  typedef: enum GT_PIRL_COUNT_MODE
 *
 *  Description: Enumeration of the port egress rate limit counting mode.
 *
 *  Enumerations:
 *      GT_PIRL_COUNT_ALL_LAYER1 -
 *				Count all Layer 1 bytes: 
 *				Preamble (8bytes) + Frame's DA to CRC + IFG (12bytes)
 *      GT_PIRL_COUNT_ALL_LAYER2 -
 *				Count all Layer 2 bytes: Frame's DA to CRC
 *      GT_PIRL_COUNT_ALL_LAYER3 -
 *				Count all Layer 3 bytes: 
 *				Frame's DA to CRC - 18 - 4 (if frame is tagged)
 */
typedef enum
{
	GT_PIRL_COUNT_ALL_LAYER1 = 0,
	GT_PIRL_COUNT_ALL_LAYER2,
	GT_PIRL_COUNT_ALL_LAYER3
} GT_PIRL_COUNT_MODE;

/*
 *  typedef: enum GT_PIRL2_COUNT_MODE
 *
 *  Description: Enumeration of the port egress rate limit counting mode.
 *
 *  Enumerations:
 *      GT_PIRL2_COUNT_FRAME -
 *				Count the number of frames
 *      GT_PIRL2_COUNT_ALL_LAYER1 -
 *				Count all Layer 1 bytes: 
 *				Preamble (8bytes) + Frame's DA to CRC + IFG (12bytes)
 *      GT_PIRL2_COUNT_ALL_LAYER2 -
 *				Count all Layer 2 bytes: Frame's DA to CRC
 *      GT_PIRL2_COUNT_ALL_LAYER3 -
 *				Count all Layer 3 bytes: 
 *				Frame's DA to CRC - 18 - 4 (if frame is tagged)
 */
typedef enum
{
	GT_PIRL2_COUNT_FRAME = 0,
	GT_PIRL2_COUNT_ALL_LAYER1,
	GT_PIRL2_COUNT_ALL_LAYER2,
	GT_PIRL2_COUNT_ALL_LAYER3
} GT_PIRL2_COUNT_MODE;



/*
 *  typedef: struct GT_PIRL_RESOURCE
 *
 *  Description: data structure that represents a PIRL Resource
 *
 *  Fields:
 *      accountQConf    - account discarded frames due to queue congestion
 *      accountFiltered - account filtered frames
 *		ebsLimitAction  - action should be taken when the incoming rate exceeds
 *						  the ebsLimit.
 *								ESB_LIMIT_ACTION_DROP - drop packets
 *								ESB_LIMIT_ACTION_FC   - send flow control packet
 *		ebsLimit        - Excess Burst Size limit ( 0 ~ 0xFFFFFF)
 *		cbsLimit		- Committed BUrst Size limit (expected to be 2kBytes)
 *		bktRateFactor   - bucket rate factor = bucketDecrement/updateInterval,
 *						  where updateInterval indicates the rate at which the 
 *						  bucket needs to be updated with tokens, or 1/CIR, 
 *						  where CIR is the committed information rate in kbps.
 *						  bucketDecrement indicates the amount of tokens that 
 *						  need to be removed per each bucket decrement.
 *		bktIncrement    - the amount of tokens that need to be added for each 
 *						  byte of packet information.
 *		bktRateType		- bucket is either rate based or traffic type based.
 *								BUCKET_TYPE_RATE_BASED, or
 *								BUCKET_TYPE_TRAFFIC_BASED
 *		bktTypeMask		- used if bktRateType is BUCKET_TYPE_TRAFFIC_BASED. 
 *						  any combination of the following definitions:
 *								BUCKET_TRAFFIC_UNKNOWN_UNICAST,
 *								BUCKET_TRAFFIC_UNKNOWN_MULTICAST,
 *								BUCKET_TRAFFIC_BROADCAST,
 *								BUCKET_TRAFFIC_MULTICAST,
 *								BUCKET_TRAFFIC_UNICAST,
 *								BUCKET_TRAFFIC_MGMT_FRAME, and
 *								BUCKET_TRAFFIC_ARP
 *		byteTobeCounted	- bytes to be counted for accounting
 *								GT_PIRL_COUNT_ALL_LAYER1,
 *								GT_PIRL_COUNT_ALL_LAYER2, or
 *								GT_PIRL_COUNT_ALL_LAYER3
 *
 */
typedef struct
{
	GT_BOOL		accountQConf;
	GT_BOOL		accountFiltered;
	GT_ESB_LIMIT_ACTION ebsLimitAction;
	GT_U32		ebsLimit;
	GT_U32		cbsLimit;
	GT_U32		bktRateFactor;
	GT_U32		bktIncrement;
	GT_BUCKET_RATE_TYPE	bktRateType;
	GT_U32		bktTypeMask;
	GT_PIRL_COUNT_MODE	byteTobeCounted;
} GT_PIRL_RESOURCE;

/*
 *  typedef: struct GT_PIRL_CUSTOM_RATE_LIMIT
 *
 *  Description: The parameters that decides Ingress Rate Limit vary depending on
 *				the application. Since DSDT driver cannot cover all the cases,
 *				this structure is provided for the custom parameter setting.
 *				However, in most cases, user may ingore this structure by setting
 *				isValid to GT_FALSE. If Ingress Rate Limit is too much off from
 *				the expected rate, please contact FAE and gets the correct ebsLimit,
 *				cbsLimit,bktIncrement, and bktRateFactor value and use this structure 
 *				to do custom parameter setting.
 *
 *		isValid         - If GT_TRUE, the paramers in this structure are used 
 *						  to program PIRL Resource's Rate Limit. And ingressRate
 *						  in GT_PIRL_BUCKET_DATA structure are ignored.
 *						  If GT_FALSE, ingressRate in GT_PIRL_BUCKET_DATA structure 
 *						  is used for Resource's Rate Limit.
 *		ebsLimit        - Excess Burst Size limit ( 0 ~ 0xFFFFFF)
 *		cbsLimit		- Committed Burst Size limit (expected to be 2kBytes)
 *		bktIncrement    - the amount of tokens that need to be added for each 
 *						  byte of packet information.
 *		bktRateFactor   - bucket rate factor = bucketDecrement/updateInterval,
 *						  where updateInterval indicates the rate at which the 
 *						  bucket needs to be updated with tokens, or 1/CIR, 
 *						  where CIR is the committed information rate in kbps.
 *						  bucketDecrement indicates the amount of tokens that 
 *						  need to be removed per each bucket decrement.
*/
typedef struct
{
	GT_BOOL		isValid;
	GT_U32		ebsLimit;
	GT_U32		cbsLimit;
	GT_U32		bktIncrement;
	GT_U32		bktRateFactor;
} GT_PIRL_CUSTOM_RATE_LIMIT;

/*
 *  typedef: struct GT_PIRL_BUCKET_DATA
 *
 *  Description: data structure for PIRL Bucket programing that is resource based
 *
 *  Fields:
 *		ingressRate   	- commited ingress rate in kbps.
 *						  64kbps ~ 1Mbps    : increments of 64kbps,
 *						  1Mbps ~ 100Mbps   : increments of 1Mbps, and
 *						  100Mbps ~ 200Mbps : increments of 10Mbps
 *						  Therefore, the valid values are:
 *								64, 128, 192, 256, 320, 384,..., 960,
 *								1000, 2000, 3000, 4000, ..., 100000,
 *								110000, 120000, 130000, ..., 200000.
 *		customSetup   	- custom ingress rate parameter setup. please refer to
 *						  GT_PIRL_CUSTOM_RATE_LIMIT structure.
 *      accountQConf    - account discarded frames due to queue congestion
 *      accountFiltered - account filtered frames
 *		esbLimitAction 	- action should be taken when the incoming rate exceeds
 *						  the limit.
 *								ESB_LIMIT_ACTION_DROP - drop packets
 *								ESB_LIMIT_ACTION_FC   - send flow control packet
 *		fcDeassertMode	- port flow control de-assertion mode when limitAction is
 *						  set to ESB_LIMIT_ACTION_FC.
 *						  fcDeassertMode[0] for port 0, fcDeassertMode[1] for 
 *						  port 1, etc. If port x does not share the bucket,
 *						  fcDeassertMode[x] data will be ignored.
 *								GT_PIRL_FC_DEASSERT_EMPTY -
 *									De-assert when the ingress rate resource has 
 *									become empty.
 *								GT_PIRL_FC_DEASSERT_CBS_LIMIT -
 *									De-assert when the ingress rate resource has 
 *									enough room as specified by the CBSLimit.
 *		bktRateType		- bucket is either rate based or traffic type based.
 *								BUCKET_TYPE_RATE_BASED, or
 *								BUCKET_TYPE_TRAFFIC_BASED
 *		bktTypeMask		- used if bktRateType is BUCKET_TYPE_TRAFFIC_BASED. 
 *						  any combination of the following definitions:
 *								BUCKET_TRAFFIC_UNKNOWN_UNICAST,
 *								BUCKET_TRAFFIC_UNKNOWN_MULTICAST,
 *								BUCKET_TRAFFIC_BROADCAST,
 *								BUCKET_TRAFFIC_MULTICAST,
 *								BUCKET_TRAFFIC_UNICAST,
 *								BUCKET_TRAFFIC_MGMT_FRAME, and
 *								BUCKET_TRAFFIC_ARP
 *		byteTobeCounted	- bytes to be counted for accounting
 *								GT_PIRL_COUNT_ALL_LAYER1,
 *								GT_PIRL_COUNT_ALL_LAYER2, or
 *								GT_PIRL_COUNT_ALL_LAYER3
 *
 */
typedef struct
{
	GT_U32		ingressRate;
	GT_PIRL_CUSTOM_RATE_LIMIT customSetup;
	GT_BOOL		accountQConf;
	GT_BOOL		accountFiltered;
	GT_ESB_LIMIT_ACTION ebsLimitAction;
	GT_PIRL_FC_DEASSERT fcDeassertMode[MAX_SWITCH_PORTS];
	GT_BUCKET_RATE_TYPE	bktRateType;
	GT_U32		bktTypeMask;
	GT_PIRL_COUNT_MODE	byteTobeCounted;
} GT_PIRL_DATA;


/*
 *  typedef: struct GT_PIRL2_RESOURCE
 *
 *  Description: data structure that represents a PIRL Resource
 *
 *  Fields:
 *      accountQConf    - account discarded frames due to queue congestion
 *      accountFiltered - account filtered frames
 *      mgmtNrlEn 		- exclude management frame from ingress rate limiting calculation
 *      saNrlEn 		- exclude from ingress rate limiting calculation if the SA of the
 *						  frame is in ATU with EntryState that indicates Non Rate Limited.
 *      daNrlEn 		- exclude from ingress rate limiting calculation if the DA of the
 *						  frame is in ATU with EntryState that indicates Non Rate Limited.
 *		samplingMode	- sample one out of so many frames/bytes for a stream of frames
 *		actionMode		- action should be taken when there are not enough tokens
 *						  to accept the entire incoming frame
 *								PIRL_ACTION_ACCEPT - accept the frame
 *								PIRL_ACTION_USE_LIMIT_ACTION - use limitAction
 *		ebsLimitAction  - action should be taken when the incoming rate exceeds
 *						  the ebsLimit.
 *								ESB_LIMIT_ACTION_DROP - drop packets
 *								ESB_LIMIT_ACTION_FC   - send flow control packet
 *		ebsLimit        - Excess Burst Size limit ( 0 ~ 0xFFFFFF)
 *		cbsLimit		- Committed BUrst Size limit (expected to be 2kBytes)
 *		bktRateFactor   - bucket rate factor = bucketDecrement/updateInterval,
 *						  where updateInterval indicates the rate at which the 
 *						  bucket needs to be updated with tokens, or 1/CIR, 
 *						  where CIR is the committed information rate in kbps.
 *						  bucketDecrement indicates the amount of tokens that 
 *						  need to be removed per each bucket decrement.
 *		bktIncrement    - the amount of tokens that need to be added for each 
 *						  byte of packet information.
 *		fcDeassertMode	- flow control de-assertion mode when limitAction is
 *						  set to ESB_LIMIT_ACTION_FC.
 *								GT_PIRL_FC_DEASSERT_EMPTY -
 *									De-assert when the ingress rate resource has 
 *									become empty.
 *								GT_PIRL_FC_DEASSERT_CBS_LIMIT -
 *									De-assert when the ingress rate resource has 
 *									enough room as specified by the CBSLimit.
 *		bktRateType		- bucket is either rate based or traffic type based.
 *								BUCKET_TYPE_RATE_BASED, or
 *								BUCKET_TYPE_TRAFFIC_BASED
 *      priORpt         - determine the incoming frames that get rate limited using
 *						  this ingress rate resource.
 *						  		GT_TRUE - typeMask OR priMask
 *						  		GT_FALSE - typeMask AND priMask
 *		priMask         - priority bit mask that each bit indicates one of the four
 *						  queue priorities. Setting each one of these bits indicates
 *						  that this particular rate resource is slated to account for
 *						  incoming frames with the enabled bits' priority.
 *		bktTypeMask		- used if bktRateType is BUCKET_TYPE_TRAFFIC_BASED. 
 *						  any combination of the following definitions:
 *								BUCKET_TRAFFIC_UNKNOWN_UNICAST,
 *								BUCKET_TRAFFIC_UNKNOWN_MULTICAST,
 *								BUCKET_TRAFFIC_BROADCAST,
 *								BUCKET_TRAFFIC_MULTICAST,
 *								BUCKET_TRAFFIC_UNICAST,
 *								BUCKET_TRAFFIC_MGMT_FRAME,
 *								BUCKET_TRAFFIC_ARP,
 *								BUCKET_TRAFFIC_TCP_DATA,
 *								BUCKET_TRAFFIC_TCP_CTRL,
 *								BUCKET_TRAFFIC_UDP,
 *								BUCKET_TRAFFIC_NON_TCPUDP,
 *								BUCKET_TRAFFIC_IMS,
 *								BUCKET_TRAFFIC_POLICY_MIRROR, and
 *								BUCKET_TRAFFIC_PLICY_TRAP
 *		byteTobeCounted	- bytes to be counted for accounting
 *								GT_PIRL2_COUNT_FRAME,
 *								GT_PIRL2_COUNT_ALL_LAYER1,
 *								GT_PIRL2_COUNT_ALL_LAYER2, or
 *								GT_PIRL2_COUNT_ALL_LAYER3
 *
 */
typedef struct
{
	GT_BOOL		accountQConf;
	GT_BOOL		accountFiltered;
	GT_BOOL		mgmtNrlEn;
	GT_BOOL		saNrlEn;
	GT_BOOL		daNrlEn;
	GT_BOOL		samplingMode;
	GT_PIRL_ACTION	actionMode;
	GT_ESB_LIMIT_ACTION ebsLimitAction;
	GT_U32		ebsLimit;
	GT_U32		cbsLimit;
	GT_U32		bktRateFactor;
	GT_U32		bktIncrement;
	GT_PIRL_FC_DEASSERT fcDeassertMode;
	GT_BUCKET_RATE_TYPE	bktRateType;
	GT_BOOL		priORpt;
	GT_U32		priMask;
	GT_U32		bktTypeMask;
	GT_PIRL2_COUNT_MODE	byteTobeCounted;
} GT_PIRL2_RESOURCE;


/*
 *  typedef: struct GT_PIRL2_BUCKET_DATA
 *
 *  Description: data structure for PIRL2 Bucket programing that is port based.
 *
 *  Fields:
 *		ingressRate   	- commited ingress rate in kbps.
 *						  64kbps ~ 1Mbps    : increments of 64kbps,
 *						  1Mbps ~ 100Mbps   : increments of 1Mbps, and
 *						  100Mbps ~ 200Mbps : increments of 10Mbps
 *						  Therefore, the valid values are:
 *								64, 128, 192, 256, 320, 384,..., 960,
 *								1000, 2000, 3000, 4000, ..., 100000,
 *								110000, 120000, 130000, ..., 200000.
 *		customSetup   	- custom ingress rate parameter setup. please refer to
 *						  GT_PIRL_CUSTOM_RATE_LIMIT structure.
 *      accountQConf    - account discarded frames due to queue congestion
 *      accountFiltered - account filtered frames
 *      mgmtNrlEn 		- exclude management frame from ingress rate limiting calculation
 *      saNrlEn 		- exclude from ingress rate limiting calculation if the SA of the
 *						  frame is in ATU with EntryState that indicates Non Rate Limited.
 *      daNrlEn 		- exclude from ingress rate limiting calculation if the DA of the
 *						  frame is in ATU with EntryState that indicates Non Rate Limited.
 *		samplingMode	- sample one out of so many frames/bytes for a stream of frames
 *		actionMode		- action should be taken when there are not enough tokens
 *						  to accept the entire incoming frame
 *								PIRL_ACTION_ACCEPT - accept the frame
 *								PIRL_ACTION_USE_LIMIT_ACTION - use limitAction
 *		ebsLimitAction 	- action should be taken when the incoming rate exceeds
 *						  the limit.
 *								ESB_LIMIT_ACTION_DROP - drop packets
 *								ESB_LIMIT_ACTION_FC   - send flow control packet
 *		fcDeassertMode	- flow control de-assertion mode when limitAction is
 *						  set to ESB_LIMIT_ACTION_FC.
 *								GT_PIRL_FC_DEASSERT_EMPTY -
 *									De-assert when the ingress rate resource has 
 *									become empty.
 *								GT_PIRL_FC_DEASSERT_CBS_LIMIT -
 *									De-assert when the ingress rate resource has 
 *									enough room as specified by the CBSLimit.
 *		bktRateType		- bucket is either rate based or traffic type based.
 *								BUCKET_TYPE_RATE_BASED, or
 *								BUCKET_TYPE_TRAFFIC_BASED
 *      priORpt         - determine the incoming frames that get rate limited using
 *						  this ingress rate resource.
 *						  		GT_TRUE - typeMask OR priMask
 *						  		GT_FALSE - typeMask AND priMask
 *		priMask         - priority bit mask that each bit indicates one of the four
 *						  queue priorities. Setting each one of these bits indicates
 *						  that this particular rate resource is slated to account for
 *						  incoming frames with the enabled bits' priority.
 *		bktTypeMask		- used if bktRateType is BUCKET_TYPE_TRAFFIC_BASED. 
 *						  any combination of the following definitions:
 *								BUCKET_TRAFFIC_UNKNOWN_UNICAST,
 *								BUCKET_TRAFFIC_UNKNOWN_MULTICAST,
 *								BUCKET_TRAFFIC_BROADCAST,
 *								BUCKET_TRAFFIC_MULTICAST,
 *								BUCKET_TRAFFIC_UNICAST,
 *								BUCKET_TRAFFIC_MGMT_FRAME,
 *								BUCKET_TRAFFIC_ARP,
 *								BUCKET_TRAFFIC_TCP_DATA,
 *								BUCKET_TRAFFIC_TCP_CTRL,
 *								BUCKET_TRAFFIC_UDP,
 *								BUCKET_TRAFFIC_NON_TCPUDP,
 *								BUCKET_TRAFFIC_IMS,
 *								BUCKET_TRAFFIC_POLICY_MIRROR, and
 *								BUCKET_TRAFFIC_PLICY_TRAP
 *		byteTobeCounted	- bytes to be counted for accounting
 *								GT_PIRL2_COUNT_FRAME,
 *								GT_PIRL2_COUNT_ALL_LAYER1,
 *								GT_PIRL2_COUNT_ALL_LAYER2, or
 *								GT_PIRL2_COUNT_ALL_LAYER3
 *
 */
typedef struct
{
	GT_U32		ingressRate;
	GT_PIRL_CUSTOM_RATE_LIMIT customSetup;
	GT_BOOL		accountQConf;
	GT_BOOL		accountFiltered;
	GT_BOOL		mgmtNrlEn;
	GT_BOOL		saNrlEn;
	GT_BOOL		daNrlEn;
	GT_BOOL		samplingMode;
	GT_PIRL_ACTION	actionMode;
	GT_ESB_LIMIT_ACTION ebsLimitAction;
	GT_PIRL_FC_DEASSERT fcDeassertMode;
	GT_BUCKET_RATE_TYPE	bktRateType;
	GT_BOOL		priORpt;
	GT_U32		priMask;
	GT_U32		bktTypeMask;
	GT_PIRL2_COUNT_MODE	byteTobeCounted;
} GT_PIRL2_DATA;



/*
 *  typedef: struct GT_PIRL_CUSTOM_TSM_CFG
 *
 *  Description: The parameters that decides Ingress Rate Limit for AVB frames vary 
 * 				depending on the application. Since DSDT driver cannot cover all the cases,
 *				this structure is provided for the custom parameter setting.
 *				However, in most cases, user may ingore this structure by setting
 *				isValid to GT_FALSE. If Ingress Rate Limit is too much off from
 *				the expected rate, please contact FAE and gets the correct ebsLimit,
 *				cbsLimit, CTS interval, and action mode value and use this structure 
 *				to do custom parameter setting.
 *
 *		isValid         - If GT_TRUE, the paramers in this structure are used 
 *						  to program PIRL Resource's Rate Limit. And ingressRate
 *						  in GT_PIRL_TSM_DATA structure are ignored.
 *						  If GT_FALSE, ingressRate in GT_PIRL_TSM_DATA structure 
 *						  is used for Resource's Rate Limit.
 *		ebsLimit        - Excess Burst Size limit (0 ~ 0xFFFF)
 *		cbsLimit		- Committed Burst Size limit (0 ~ 0xFFFF)
 *		ctsIntv         - Class Time Slot Interval
 *						  0 - interval is 62.5us
 *						  1 - interval is 125us
 *						  2 - interval is 250us
 *						  3 - interval is 1000us
 *		actionMode		- action should be taken when there are not enough tokens
 *						  to accept the entire incoming frame
 *								PIRL_ACTION_ACCEPT - accept the frame
 *								PIRL_ACTION_USE_LIMIT_ACTION - use limitAction
*/
typedef struct
{
	GT_BOOL		isValid;
	GT_U32		ebsLimit;
	GT_U32		cbsLimit;
	GT_U32		ctsIntv;
	GT_PIRL_ACTION		actionMode;
} GT_PIRL_CUSTOM_TSM_CFG;


/*
 *  typedef: struct GT_PIRL2_TSM_DATA
 *
 *  Description: data structure for PIRL2 TSM Ingress Rate Limit.
 *
 *  Fields:
 *		ebsLimit        - Excess Burst Size limit (0 ~ 0xFFFF)
 *		cbsLimit		- Committed Burst Size limit (0 ~ 0xFFFF)
 *		ctsIntv         - Class Time Slot Interval
 *						  0 - interval is 62.5us
 *						  1 - interval is 125us
 *						  2 - interval is 250us
 *						  3 - interval is 1000us
 *		actionMode		- action should be taken when there are not enough tokens
 *						  to accept the entire incoming frame
 *								PIRL_ACTION_ACCEPT - accept the frame
 *								PIRL_ACTION_USE_LIMIT_ACTION - use limitAction
 * 		mgmtNrlEn 		- exclude management frame from ingress rate limiting calculation
 *		priMask         - priority bit mask that each bit indicates one of the four
 *						  queue priorities. Setting each one of these bits indicates
 *						  that this particular rate resource is slated to account for
 *						  incoming frames with the enabled bits' priority.
 *
 */
typedef struct
{
	GT_BOOL		tsmMode;
	GT_U32		ebsLimit;
	GT_U32		cbsLimit;
	GT_U32		ctsIntv;
	GT_PIRL_ACTION		actionMode;
	GT_BOOL		mgmtNrlEn;
	GT_U32		priMask;
} GT_PIRL2_TSM_RESOURCE;



/*
 *  typedef: struct GT_PIRL2_TSM_DATA
 *
 *  Description: data structure for PIRL2 TSM Ingress Rate Limit.
 *
 *  Fields:
 *		tsmMode			- enable/disable TSM mode. 
 *						  The following fields are ignored if diable
 *		ingressRate   	- commited ingress rate in kbps.(min 64 for 64kbps)
 *		customSetup   	- custom ingress rate parameter setup. please refer to
 *						  GT_PIRL_CUSTOM_TSM_CFG structure.
 *		mgmtNrlEn		- exclude management frame from ingress rate limiting calculation
 *		priMask         - priority bit mask that each bit indicates one of the four
 *						  queue priorities. Setting each one of these bits indicates
 *						  that this particular rate resource is slated to account for
 *						  incoming frames with the enabled bits' priority.
 *
 */
typedef struct
{
	GT_BOOL		tsmMode;
	GT_U32		ingressRate;
	GT_PIRL_CUSTOM_TSM_CFG customSetup;
	GT_BOOL		mgmtNrlEn;
	GT_U32		priMask;
} GT_PIRL2_TSM_DATA;



#define MAX_PTP_CONSECUTIVE_READ	4

/*
 * Typedef: enum GT_PTP_OPERATION
 *
 * Description: Defines the PTP (Precise Time Protocol) Operation type
 *
 * Fields:
 *      PTP_WRITE_DATA 			- Write data to the PTP register
 *      PTP_READ_DATA			- Read data from PTP register
 *      PTP_READ_MULTIPLE_DATA	- Read multiple data from PTP register
 *      PTP_READ_TIMESTAMP_DATA	- Read timestamp data from PTP register
 *					valid bit will be reset after read
 */
typedef enum
{
	PTP_WRITE_DATA 			= 0x3,
	PTP_READ_DATA  			= 0x4,
	PTP_READ_MULTIPLE_DATA	= 0x6,
	PTP_READ_TIMESTAMP_DATA	= 0x8,
} GT_PTP_OPERATION;


/*
 * Typedef: enum GT_PTP_SPEC
 *
 * Description: Defines the PTP (Precise Time Protocol) SPEC type
 *
 * Fields:
 *      PTP_IEEE_1588 		- IEEE 1588
 *      PTP_IEEE_802_1AS	- IEEE 802.1as
 */
typedef enum
{
	PTP_IEEE_1588		= 0x0,
	PTP_IEEE_802_1AS	= 0x1
} GT_PTP_SPEC;


/*
 *  typedef: struct GT_PTP_OP_DATA
 *
 *  Description: data required by PTP Operation
 *
 *  Fields:
 *      ptpPort		- physical port of the device
 *      ptpAddr 	- register address
 *      ptpData 	- data for ptp register.
 *      ptpMultiData- used for multiple read operation.
 *      nData 		- number of data to be read on multiple read operation.
 */
typedef struct
{
	GT_U32	ptpPort;
	GT_U32	ptpBlock;
	GT_U32	ptpAddr;
	GT_U32	ptpData;
	GT_U32	ptpMultiData[MAX_PTP_CONSECUTIVE_READ];
	GT_U32	nData;
} GT_PTP_OP_DATA;


/*
 *  typedef: struct GT_PTP_CONFIG
 *
 *  Description: PTP configuration parameters
 *
 *  Fields:
 *      ptpEType	- PTP Ether Type
 *      msgIdTSEn 	- Message IDs that needs time stamp
 *      tsArrPtr 	- Time stamp arrival time counter pointer (either Arr0Time or Arr1Time)
 *      ptpArrIntEn	- PTP port arrival interrupt enable
 *      ptpDepIntEn	- PTP port departure interrupt enable
 *      transSpec	- This is to differentiate between various timing protocols.
 *      msgIdStartBit 	- Message ID starting bit in the PTP common header
 *      disTSOverwrite 	- disable time stamp counter overwriting until the corresponding
 *						  timer valid bit is cleared.
 */
typedef struct
{
	GT_U32	ptpEType;
	GT_U32	msgIdTSEn;
	GT_U32	tsArrPtr;
	GT_U32	ptpArrIntEn;
	GT_U32	ptpDepIntEn;
	GT_PTP_SPEC	transSpec;
	GT_U32	msgIdStartBit;
	GT_BOOL	disTSOverwrite;
} GT_PTP_CONFIG;


/*
 *  typedef: struct GT_PTP_GLOBAL_CONFIG
 *
 *  Description: PTP global configuration parameters
 *
 *  Fields:
 *      ptpEType	- PTP Ether Type
 *      msgIdTSEn 	- Message IDs that needs time stamp
 *      tsArrPtr 	- Time stamp arrival time counter pointer (either Arr0Time or Arr1Time)
 */
typedef struct
{
	GT_U32	ptpEType;
	GT_U32	msgIdTSEn;
	GT_U32	tsArrPtr;
} GT_PTP_GLOBAL_CONFIG;


/*
 *  typedef: struct GT_PTP_PORT_CONFIG
 *
 *  Description: PTP configuration parameters for each port
 *
 *  Fields:
 *      transSpec	- This is to differentiate between various timing protocols.
 *      disTSpec 	- Disable Transport specific check
 *      etJump 		- offset to Ether type start address in bytes
 *      ipJump 		- offset to IP header start address counting from Ether type offset
 *      ptpArrIntEn	- PTP port arrival interrupt enable
 *      ptpDepIntEn	- PTP port departure interrupt enable
 *      disTSOverwrite 	- disable time stamp counter overwriting until the corresponding
 *						  timer valid bit is cleared.
 */
typedef struct
{
	GT_PTP_SPEC	transSpec;
	GT_BOOL	disTSpec;
	GT_U32	etJump;
	GT_U32	ipJump;
	GT_BOOL	ptpArrIntEn;
	GT_BOOL	ptpDepIntEn;
	GT_BOOL	disTSOverwrite;
} GT_PTP_PORT_CONFIG;


/*
 * Typedef: enum GT_PTP_TIME
 *
 * Description: Defines the PTP Time to be read
 *
 * Fields:
 *      PTP_WRITE_DATA 			- Write data to the PTP register
 *      PTP_READ_DATA			- Read data from PTP register
 *      PTP_READ_MULTIPLE_DATA	- Read multiple data from PTP register
 */
typedef enum
{
	PTP_ARR0_TIME = 0x0,
	PTP_ARR1_TIME = 0x1,
	PTP_DEP_TIME = 0x2
} GT_PTP_TIME;


/*
 * Typedef: enum GT_PTP_INT_STATUS
 *
 * Description: Defines the PTP Port interrupt status for time stamp
 *
 * Fields:
 *      PTP_INT_NORMAL		- No error condition occurred
 *      PTP_INT_OVERWRITE 	- PTP logic has to process more than one PTP frame
 *						  		that needs time stamping before the current read.
 *								Only the latest one is saved.
 *      PTP_INT_DROP	  	- PTP logic has to process more than one PTP frame
 *						  		that needs time stamping before the current read.
 *								Only the oldest one is saved.
 *
 */
typedef enum
{
	PTP_INT_NORMAL 		= 0x0,
	PTP_INT_OVERWRITE 	= 0x1,
	PTP_INT_DROP 		= 0x2
} GT_PTP_INT_STATUS;


/*
 *  typedef: struct GT_PTP_TS_STATUS
 *
 *  Description: PTP port status of time stamp
 *
 *  Fields:
 *      isValid		- time stamp is valid
 *      status		- time stamp error status
 *      timeStamped	- time stamp value of a PTP frame that needs to be time stamped
 *      ptpSeqId	- sequence ID of the frame whose time stamp information has been captured
 */
typedef struct
{
	GT_BOOL	isValid;
	GT_U32	timeStamped;
	GT_U32	ptpSeqId;
	GT_PTP_INT_STATUS	status;
} GT_PTP_TS_STATUS;


/*
 *  typedef: struct GT_PTP_PORT_DISCARD_STATS
 *
 *  Description: PTP port discard statistics. The counter (4 bit wide) wraps around after 15. 
 *
 *  Fields:
 *      tsDepDisCtr	- PTP departure frame discard counter for PTP frames that need time stamping.
 *      ntsDepDisCtr	- PTP departure frame discard counter for PTP frames that do not need time stamping.
 *      tsArrDisCtr	- PTP arrival frame discard counter for PTP frames that need time stamping.
 *      ntsArrDisCtr	- PTP arrival frame discard counter for PTP frames that do not need time stamping.
 */
typedef struct
{
	GT_U32	tsDepDisCtr;
	GT_U32	ntsDepDisCtr;
	GT_U32	tsArrDisCtr;
	GT_U32	ntsArrDisCtr;
} GT_PTP_PORT_DISCARD_STATS;


#ifdef CONFIG_AVB_FPGA

typedef enum
{
	PTP_CLOCK_SRC_AD_DEVICE = 0,	/* PTP Clock source is from A/D device */
	PTP_CLOCK_SRC_FPGA				/* PTP Clock source is from Cesium FPGA */
} GT_PTP_CLOCK_SRC;

typedef enum
{
	PTP_P9_MODE_GMII = 0, 	/* Port 9 uses GMII connect to 88E1111 */
	PTP_P9_MODE_MII,		/* Port 9 uses MII connect to 88E1111 */
	PTP_P9_MODE_MII_CONNECTOR,		/* Port 9 connect to MII connector */
	PTP_P9_MODE_JUMPER		/* Use Jumper setup */
} GT_PTP_P9_MODE;

typedef enum
{
	GT_PTP_SIGN_NEGATIVE = 0,	/* apply Minus sign to the Duty Cycle */
	GT_PTP_SIGN_PLUS			/* apply Plus sign to the Duty Cycle */
} GT_PTP_SIGN;

typedef struct
{
	GT_PTP_SIGN	adjSign;	/* determine the plus/minus sign of the duty cycle adj */
	GT_U32	cycleStep;		/* number of steps which will be applied in adjusting the duty cycle high time 
								of the 8KHz clock cycle. 
								valid values are 0 ~ 7 */
	GT_U32	cycleInterval;	/* define the interval of clock cycles for which a duty cycle adj will occur */
	GT_U32	cycleAdjust;	/* define the number of 8KHz clock cycles for which duty cycle adj will occur
								within each PTP clock clycle interval.
								Note that (cycleAdjust <= cycleInterval) for proper operation */
} GT_PTP_CLOCK_ADJUSTMENT;

#endif

/*
 *  typedef: struct GT_TAI_EVENT_CONFIG
 *
 *  Description: TAI event capture configuration parameters
 *
 *  Fields:
 *      eventOverwrite	- event capture overwrite
 *      eventCtrStart	 	- event counter start
 *      intEn 			- event capture interrupt enable
 */
typedef struct
{
	GT_BOOL	eventOverwrite;
	GT_BOOL	eventCtrStart;
	GT_BOOL	intEn;
} GT_TAI_EVENT_CONFIG;


/*
 *  typedef: struct GT_TAI_EVENT_STATUS
 *
 *  Description: TAI event capture status
 *
 *  Fields:
 *      isValid		- eventTime is valid
 *      eventTime 	- PTP global time when event is registered.
 *      eventCtr	- event capture counter. increamented only if eventCtrStart is set.
 *      eventErr	- isValid is already set when a new event is observed.
 */
typedef struct
{
	GT_BOOL	isValid;
	GT_U32	eventTime;
	GT_U32	eventCtr;
	GT_BOOL	eventErr;
} GT_TAI_EVENT_STATUS;


typedef enum
{
	GT_TAI_TRIG_PERIODIC_PURSE = 0,	/* generate periodic purse */
	GT_TAI_TRIG_ON_GIVEN_TIME		/* generate purse when 
									PTP global time matches with given time */
} GT_TAI_TRIG_MODE;


/*
 *  typedef: struct GT_TAI_TRIGGER_CONFIG
 *
 *  Description: TAI trigger generator configuration parameters
 *
 *  Fields:
 *      intEn 		- trigger generator interrupt enable
 *      mode		- trigger mode, either GT_TAI_TRIG_PERIODIC_PURSE or 
 *					  GT_TAI_TRIG_ON_GIVEN_TIME
 *      trigGenAmt 	- if mode is GT_TAI_TRIG_PERIODIC_PURSE,
 *					  this value is used as a clock period in TSClkPer increments
 *					  If mode is GT_TAI_TRIG_ON_GIVEN_TIME,
 *					  this value is used to compare with PTP global time.
 *      pulseWidth		- pulse width in units of TSClkPer.
 *					  this value should be 1 ~ 0xF. If it's 0, no changes made.
 *					  this value is valid only in GT_TAI_TRIG_ON_GIVEN_TIME mode.
 *      trigClkComp	- trigger mode clock compensation amount in pico sec.
 *					  this value is valid only in GT_TAI_TRIG_PERIODIC_PURSE mode.
 */
typedef struct
{
	GT_BOOL	intEn;
	GT_TAI_TRIG_MODE 	mode;
	GT_U32	trigGenAmt;
	GT_U32	pulseWidth;
	GT_U32	trigClkComp;
} GT_TAI_TRIGGER_CONFIG;


typedef enum
{
	GT_AVB_HI_FPRI,		/* AVB Hi Frame Priority */
	GT_AVB_HI_QPRI,		/* AVB Hi Queue Priority */
	GT_AVB_LO_FPRI,		/* AVB Lo Frame Priority */
	GT_AVB_LO_QPRI,		/* AVB Lo Queue Priority */
	GT_LEGACY_HI_FPRI,	/* Legacy Hi Frame Priority */
	GT_LEGACY_HI_QPRI,	/* Legacy Hi Queue Priority */
	GT_LEGACY_LO_FPRI,	/* Legacy Lo Frame Priority */
	GT_LEGACY_LO_QPRI	/* Legacy Lo Queue Priority */
} GT_AVB_PRI_TYPE;


typedef enum
{
	GT_AVB_LEGACY_MODE,			/* all frames entering the port are considered 
									legacy */
	GT_AVB_STANDARD_AVB_MODE,	/* any tagged frame that ends up with an AVB frame 
									priority is considered AVB */
	GT_AVB_ENHANCED_AVB_MODE,	/* any frame that ends up with an AVB frame priority 
									whose DA is contained in the ATU with an AVB Entry 
									state is considered AVB */
	GT_AVB_SECURE_AVB_MODE		/* any frame that ends up with an AVB frame priority 
									whose DA is contained in the ATU with an AVB 
									entry state and whose DPV has this source port's 
									bit set to a one is considered AVB. */
} GT_AVB_MODE;


/*
 * Typedef: enum GT_AVB_FRAME_POLICY
 *
 * Description: Defines the policy of the frame
 *
 * Fields:
 *      AVB_FRAME_POLICY_NONE - Normal frame switching
 *      AVB_FRAME_POLICY_MIRROR - Mirror(copy) frame to the MirrorDest port
 *      AVB_FRAME_POLICY_TRAP - Trap(re-direct) frame to the CPUDest port
 *
 */
typedef enum
{
	AVB_FRAME_POLICY_NONE = 0,
	AVB_FRAME_POLICY_MIRROR,
	AVB_FRAME_POLICY_TRAP
} GT_AVB_FRAME_POLICY;


/*
 * Typedef: enum GT_AVB_FRAME_TYPE
 *
 * Description: 
 *		Defines the AVB frame type.
 *		AVB Hi Frame is one that DA of the frame is contained in the ATU with an 
 *		Entry State that indicates AVB with priority override where the overridden 
 *		priority equals the Hi AVB frame priority(refer to gavbGetPriority API) and 
 *		when the port's DA AvbOverride is enabled.
 *		AVB Lo Frame is one that DA of the frame is contained in the ATU with an 
 *		Entry State that indicates AVB with priority override where the overridden 
 *		priority equals the Lo AVB frame priority(refer to gavbGetPriority API) and 
 *		when the port's DA AvbOverride is enabled.
 *
 * Fields:
 *      AVB_HI_FRAME	- AVB Hi Frame
 *      AVB_LO_FRAME	- AVB Lo Frame
 */
typedef enum
{
	AVB_HI_FRAME,
	AVB_LO_FRAME
} GT_AVB_FRAME_TYPE;


/*
 * typedef: enum GT_EVENT_TYPE
 *
 * Description: Enumeration of the available hardware driven events.
 *
 * Enumerations:
 *   GT_AVB_INT    - AVB Interrupt Enable
 *   GT_DEVICE_INT - Device Interrupt (GT_DEVICE_INT_TYPE) Enable
 *   GT_STATS_DONE - Statistics Operation Done interrrupt Enable 
 *   GT_VTU_PROB - VLAN Problem/Violation Interrupt Enable
 *   GT_VTU_DONE - VALN Table Operation Done Interrupt Enable
 *   GT_ATU_PROB - ATU Problem/Violation Interrupt Enable, for Gigabit Switch
 *   GT_ATU_FULL - ATU full interrupt enable, for Fast Ethernet Switch
 *   GT_ATU_DONE - ATU Done interrupt enable.
 *   GT_PHY_INT  - PHY interrupt enable, for Fast Ethernet Switch
 *   GT_EE_INT   - EEPROM Done interrupt enable.
 */
#define GT_AVB_INT           	0x100
#define GT_DEVICE_INT           0x80
#define GT_STATS_DONE           0x40
#define GT_VTU_PROB             0x20
#define GT_VTU_DONE             0x10
#define GT_ATU_PROB 		0x8
#define GT_ATU_FULL 		0x8
#define GT_ATU_DONE		0x4
#define GT_PHY_INTERRUPT	0x2		/* Device may not support PHY Int. Please refer to datasheet. */
#define GT_EE_INTERRUPT		0x1

#define GT_INT_MASK			\
		(GT_AVB_INT | GT_DEVICE_INT | GT_STATS_DONE | GT_VTU_PROB | GT_VTU_DONE | GT_ATU_FULL | 	\
		GT_ATU_DONE | GT_PHY_INTERRUPT | GT_EE_INTERRUPT)
#define GT_NO_INTERNAL_PHY_INT_MASK		\
		(GT_AVB_INT | GT_DEVICE_INT | GT_STATS_DONE | GT_VTU_PROB | GT_VTU_DONE | GT_ATU_PROB | 	\
		GT_ATU_DONE | GT_EE_INTERRUPT)


/*
 *  typedef: struct GT_DEV_EVENT
 *
 *  Description: Device interrupt status
 *
 *  Fields:
 *      event     - Device Interrupts to be enabled
 *					GT_DEV_INT_WATCHDOG, GT_DEV_INT_JAMLIMIT,
 *					GT_DEV_INT_DUPLEX_MISMATCH, and/or GT_DEV_INT_SERDES_LINK
 *      portList  - SERDES port list where GT_DEV_INT_SERDES_LINK interrupt needs
 *					to be asserted. It's in vector format, Bit 10 is for port 10, 
 *					Bit 9 is for port 9, etc.
 *					valid only if GT_DEV_INT_SERDES_LINK bit is set.
 *      phyList   - Phy list where GT_DEV_INT_PHY interrupt needs to be asserted.
 *					It's in vector format, Bit 0 is for port 0, 
 *					Bit 1 is for port 1, etc.
 *					valid only if GT_DEV_INT_PHY bit is set.
 */
typedef struct
{
	GT_U32		event;
	GT_U32		portList;
	GT_U32		phyList;
} GT_DEV_EVENT;


/*
 *  typedef: struct GT_DEV_INT_STATUS
 *
 *  Description: Device interrupt status
 *
 *  Fields:
 *      intCause  - Device Interrupt Cause
 *					GT_DEV_INT_WATCHDOG, GT_DEV_INT_JAMLIMIT,
 *					GT_DEV_INT_DUPLEX_MISMATCH, and/or GT_DEV_INT_SERDES_LINK
 *		port	  - logical port where GT_DEV_INT_DUPLEX_MISMATCH occurred.
 *					valid only if GT_DEV_INT_DUPLEX_MISMATCH is set.
 *      linkInt   - SERDES port list where GT_DEV_INT_SERDES_LINK interrupt is
 *					asserted. It's in vector format, Bit 10 is for port 10, 
 *					Bit 9 is for port 9, etc.
 *					valid only if GT_DEV_INT_SERDES_LINK bit is set.
 *					These bits are only valid of the port that is in 1000Base-X mode.
 */
typedef struct
{
	GT_U32		devIntCause;
	GT_LPORT	port;
	GT_U32		linkInt;
	GT_U32		phyInt;
} GT_DEV_INT_STATUS;


/*
* GT_DEVICE_INT
*
* Description: Enumeration of Device interrupt
*	GT_DEV_INT_WATCHDOG		- WatchDog event interrupt (WatchDog event can be
*							  configured with gwdSetEvent API)
*	GT_DEV_INT_JAMLIMIT		- any of the ports detect an Ingress Jam Limit violation
*							  (gprtSetPauseLimitIn API)
*	GT_DEV_INT_DUPLEX_MISMATCH	- any of the ports detect a duplex mismatch 
*							  (i.e., the local port is in half duplex mode while 
*							  the link partner is in full duplex mode)
*	GT_DEV_INT_SERDES_LINK	- SERDES link chage interrupt.
*							  An interrupt occurs when a SERDES port changes link 
*							  status (link up or link down)
*/

#define GT_DEV_INT_WATCHDOG			0x8
#define GT_DEV_INT_JAMLIMIT			0x4
#define GT_DEV_INT_DUPLEX_MISMATCH	0x2
#define GT_DEV_INT_SERDES_LINK		0x1
#define GT_DEV_INT_PHY				0x10

/*
* GT_WATCHDOG_EVENT
*
* Description: Enumeration of WatchDog event
*		GT_WD_QC  - Queue Controller Watch Dog enable.
*					When enabled, the QC's watch dog circuit checks for link
*					list errors and any errors found in the QC.
*		GT_WD_EGRESS - Egress Watch Dog enable.
*					When enabled, each port's egress circuit checks for problems
*					between the port and the Queue Controller.
*		GT_WD_FORCE - Force a Watch Dog event.
*/

#define GT_WD_QC		0x1
#define GT_WD_EGRESS	0x2
#define GT_WD_FORCE		0x4


/*
* typedef: struct GT_WD_EVENT_HISTORY
*
* Description: WatchDog Event History (cleared only by a hardware reset)
*		wdEvent   - When it's set to GT_TRUE, some enabled Watch Dog event occurred.
*					The following events are possible:
*						QC WatchDog Event (GT_WD_QC)
*						Egress WatchDog Event (GT_WD_EGRESS)
*						Forced WatchDog Event (GT_WD_FORCE)
*		egressEvent-If any port's egress logic detects an egress watch dog issue,
*					this field is set to GT_TRUE, regardless of the enabling GT_WD_EGRESS
*					event.
*/
typedef struct
{
	GT_BOOL	wdEvent;
	GT_BOOL egressEvent;
} GT_WD_EVENT_HISTORY;


/*
* typedef: enum GT_PHY_INT
*
* Description: Enumeration of PHY interrupt
*/

#define GT_SPEED_CHANGED 		0x4000
#define GT_DUPLEX_CHANGED		0x2000
#define GT_PAGE_RECEIVED		0x1000
#define GT_AUTO_NEG_COMPLETED	0x800
#define GT_LINK_STATUS_CHANGED	0x400
#define GT_SYMBOL_ERROR			0x200
#define GT_FALSE_CARRIER		0x100
#define GT_FIFO_FLOW			0x80
#define GT_CROSSOVER_CHANGED	0x40
#define GT_POLARITY_CHANGED		0x2
#define GT_JABBER				0x1

#define GT_AUTO_NEG_ERROR		0x8000
#define GT_DOWNSHIFT_DETECT		0x20
#define GT_ENERGY_DETECT		0x10

/*
* typedef: enum GT_PHY_AUTO_MODE
*
* Description: Enumeration of Autonegotiation mode.
*	Auto for both speed and duplex.
*	Auto for speed only and Full duplex.
*	Auto for speed only and Half duplex. (1000Mbps is not supported)
*	Auto for duplex only and speed 1000Mbps.
*	Auto for duplex only and speed 100Mbps.
*	Auto for duplex only and speed 10Mbps.
*	1000Mbps Full duplex.
*	100Mbps Full duplex.
*	100Mbps Half duplex.
*	10Mbps Full duplex.
*	10Mbps Half duplex.
*/

typedef enum
{
	SPEED_AUTO_DUPLEX_AUTO,
	SPEED_1000_DUPLEX_AUTO,
	SPEED_100_DUPLEX_AUTO,
	SPEED_10_DUPLEX_AUTO,
	SPEED_AUTO_DUPLEX_FULL,
	SPEED_AUTO_DUPLEX_HALF,
	SPEED_1000_DUPLEX_FULL,
	SPEED_1000_DUPLEX_HALF,
	SPEED_100_DUPLEX_FULL,
	SPEED_100_DUPLEX_HALF,
	SPEED_10_DUPLEX_FULL,
	SPEED_10_DUPLEX_HALF
}GT_PHY_AUTO_MODE;


/*
* typedef: enum GT_PHY_PAUSE_MODE
*
* Description: Enumeration of Pause Mode in the Phy.
*
* Enumerations:
*	GT_PHY_NO_PAUSE		- disable pause
*	GT_PHY_PAUSE		- support pause
*	GT_PHY_ASYMMETRIC_PAUSE	- support asymmetric pause
*	GT_PHY_BOTH_PAUSE	- support both pause and asymmetric pause
*/
typedef enum
{
	GT_PHY_NO_PAUSE = 0,
	GT_PHY_PAUSE,
	GT_PHY_ASYMMETRIC_PAUSE,
	GT_PHY_BOTH_PAUSE
} GT_PHY_PAUSE_MODE;


/*
* typedef: enum GT_PHY_SPEED
*
* Description: Enumeration of Phy Speed
*
* Enumerations:
*	PHY_SPEED_10_MBPS   - 10Mbps
*	PHY_SPEED_100_MBPS	- 100Mbps
*	PHY_SPEED_1000_MBPS - 1000Mbps
*/
typedef enum
{
	PHY_SPEED_10_MBPS,
	PHY_SPEED_100_MBPS,
	PHY_SPEED_1000_MBPS
} GT_PHY_SPEED;

/*
* typedef: enum GT_PHY_LOOPBACK_MODE
*
* Description: Enumeration of Phy loopback mode
*
* Enumerations:
	PHY_INTERNAL_LOOPBACK: internal loopback mode
	PHY_EXTERNAL_LOOPBACK:external loopback mode
*/
typedef enum
{
	PHY_INTERNAL_LOOPBACK,
	PHY_EXTERNAL_LOOPBACK
} GT_PHY_LOOPBACK_MODE;

/*
* typedef: enum GT_MIRROR_MODE
*
* Description: Enumeration of Phy Speed
*
* Enumerations:
*	SW_MIRROR_INGRESS   - mirror ingress packets to destination port
*	SW_MIRROR_EGRESS	- mirror egress packets to destination port
*/
typedef enum
{
	SW_MIRROR_INGRESS,
	SW_MIRROR_EGRESS
} GT_MIRROR_MODE;


/*
* typedef: enum GT_SERDES_MODE
*
* Description: Enumeration of Serdes mode
*
* Enumerations:
*	PHY_SERDES_100FX	 - 100 FX
*	PHY_SERDES_1000X	 - 1000 X
*	PHY_SERDES_SGMII_PHY - SGMII PHY
*	PHY_SERDES_SGMII_MAC - SGMII MAC
*/
typedef enum
{
	PHY_SERDES_100FX = 0,
	PHY_SERDES_1000X,	
	PHY_SERDES_SGMII_PHY,
	PHY_SERDES_SGMII_MAC
} GT_SERDES_MODE;


/*
* typedef: enum GT_EDETECT_MODE
*
* Description: Enumeration of Energy Detect mode
*
* Enumerations:
*	GT_EDETECT_OFF		- Energy Detect disabled
*	GT_EDETECT_SENSE_PULSE	- Energy Detect enabled with sense and pulse
*	GT_EDETECT_SENSE	- Energy Detect enabled only with sense
*/
typedef enum
{
	GT_EDETECT_OFF = 0,
	GT_EDETECT_SENSE_PULSE,
	GT_EDETECT_SENSE
} GT_EDETECT_MODE;

/*
 * typedef: enum GT_INGRESS_MODE
 *
 * Description: Enumeration of the port ingress mode.
 *
 * Enumerations:
 *   GT_UNMODIFY_INGRESS - frames are receive unmodified.
 *   GT_TRAILER_INGRESS  - all frames are received with trailer.
 *   GT_UNTAGGED_INGRESS  - remove tag on receive (for double tagging).
 *   GT_CPUPORT_INGRESS - no trailer. used to identify the CPU port for IGMP/MLD Snooping
 */
typedef enum
{
	GT_UNMODIFY_INGRESS = 0,  /* 0x00 */
	GT_TRAILER_INGRESS,       /* 0x01 */
	GT_UNTAGGED_INGRESS,      /* 0x10 */
	GT_CPUPORT_INGRESS        /* 0x11 */
} GT_INGRESS_MODE;


/*
 * typedef: enum GT_EGRESS_FLOOD
 *
 * Description: Enumeration of the port ingress mode.
 *
 * Enumerations:
 *   GT_BLOCK_EGRESS_UNKNOWN - do not egress frame with unknown DA
 *   GT_BLOCK_EGRESS_UNKNOWN_MULTICAST - do not egress frame with unknown multicast DA
 *   GT_BLOCK_EGRESS_UNKNOWN_UNIICAST - do not egress frame with unknown unicast DA
 *   GT_BLOCK_EGRESS_NONE - egress all frames with unknown DA
 */
typedef enum
{
	GT_BLOCK_EGRESS_UNKNOWN = 0,
	GT_BLOCK_EGRESS_UNKNOWN_MULTICAST,
	GT_BLOCK_EGRESS_UNKNOWN_UNICAST,
	GT_BLOCK_EGRESS_NONE
} GT_EGRESS_FLOOD;


/*
 *  typedef: enum GT_MC_RATE
 *
 *  Description: Enumeration of the port ingress mode.
 *
 *  Enumerations:
 *      GT_MC_3_PERCENT_RL   - multicast rate is limited to 3 percent.
 *      GT_MC_6_PERCENT_RL   - multicast rate is limited to 6 percent.
 *      GT_MC_12_PERCENT_RL  - multicast rate is limited to 12 percent.
 *      GT_MC_100_PERCENT_RL - unlimited multicast rate.
 */
typedef enum
{
	GT_MC_3_PERCENT_RL = 0,
	GT_MC_6_PERCENT_RL,
	GT_MC_12_PERCENT_RL,
	GT_MC_100_PERCENT_RL,
} GT_MC_RATE;


/*
 *  typedef: enum GT_INGRESS_RATE_MODE
 *
 *  Description: Enumeration of the port ingress rate limit mode.
 *
 *  Enumerations:
 *      GT_RATE_PRI_BASE   - Priority based rate limiting
 *		GT_RATE_BURST_BASE - Burst Size based rate limiting
 */
typedef enum
{
	GT_RATE_PRI_BASE = 0,
	GT_RATE_BURST_BASE
} GT_INGRESS_RATE_MODE;


/*
 *  typedef: enum GT_PORT_SCHED_MODE
 *
 *  Description: Enumeration of port scheduling mode
 *
 *  Fields:
 *	 	GT_PORT_SCHED_WEIGHTED_RRB - use 8,4,2,1 weighted fair scheduling
 *	 	GT_PORT_SCHED_STRICT_PRI - use a strict priority scheme
 *	 	GT_PORT_SCHED_STRICT_PRI3 - use a strict for priority 3 and weighted 
 *									round robin for the priority 2,1,and 0
 *	 	GT_PORT_SCHED_STRICT_PRI2_3 - use a strict for priority 2,3 and weighted 
 *									round robin for the priority 1,and 0
 *
 *  Comment:
 */
typedef enum
{
	GT_PORT_SCHED_WEIGHTED_RRB = 0,
	GT_PORT_SCHED_STRICT_PRI,
	GT_PORT_SCHED_STRICT_PRI3,
	GT_PORT_SCHED_STRICT_PRI2_3
} GT_PORT_SCHED_MODE;


/*
 *  typedef: struct GT_PORT_STAT
 *
 *  Description: port statistic struct.
 *
 *  Fields:
 *      rxCtr   - port receive counter.
 *      txCtr   - port transmit counter.
 *      dropped - dropped frame counter.
 *
 *  Comment:
 *		dropped frame counter is supported by only limited devices.
 *		At this moment, 88E6061/88E6065 are the devices supporting
 *		dropped frame counter.
 */
typedef struct
{
	GT_U16  rxCtr;
	GT_U16  txCtr;
	GT_U16  dropped;
} GT_PORT_STAT;

/*
 *  typedef: struct GT_PORT_STAT2
 *
 *  Description: port statistic struct.
 *
 *  Fields:
 *      inDiscardLo - InDiscards Low Frame Counter
 *      inDiscardHi - InDiscards High Frame Counter
 *      inFiltered  - InFiltered Frame Counter
 *      outFiltered - OutFiltered Frame Counter
 *
 *  Comment:
 */
typedef struct
{
	GT_U16  inDiscardLo;
	GT_U16  inDiscardHi;
	GT_U16  inFiltered;
	GT_U16  outFiltered;
} GT_PORT_STAT2;


/*
 **  typedef: struct GT_PORT_Q_COUNTERS
 **
 **  Description: port queue statistic struct.
 **
 **  Fields:
 **      OutQ_Size - port egress queue size coi
 **      Rsv_Size  - ingress reserved e counter
 **
 **/
typedef struct
{
	GT_U16  OutQ_Size;
	GT_U16  Rsv_Size;
} GT_PORT_Q_STAT;

/*
 * typedef: enum GT_CTR_MODE
 *
 * Description: Enumeration of the port counters mode.
 *
 * Enumerations:
 *   GT_CTR_ALL    - In this mode the counters counts Rx receive and transmit
 *                   frames.
 *   GT_CTR_ERRORS - In this mode the counters counts Rx Errors and collisions.
 */
typedef enum
{
	GT_CTR_ALL = 0,
	GT_CTR_ERRORS,
} GT_CTR_MODE;

typedef struct _GT_QD_DEV GT_QD_DEV;

/*
 * semaphore related definitions.
 * User Applications may register Semaphore functions using following definitions
 */
typedef enum
{
	GT_SEM_EMPTY,
	GT_SEM_FULL
} GT_SEM_BEGIN_STATE;

typedef GT_SEM (*FGT_SEM_CREATE)(
						GT_SEM_BEGIN_STATE state);
typedef GT_STATUS (*FGT_SEM_DELETE)(
						GT_SEM semId);
typedef GT_STATUS (*FGT_SEM_TAKE)(
						GT_SEM semId, GT_U32 timOut);
typedef GT_STATUS (*FGT_SEM_GIVE)(
						GT_SEM semId);

typedef struct
{
	FGT_SEM_CREATE	semCreate; 	/* create semapore */
	FGT_SEM_DELETE	semDelete; 	/* delete the semapore */
	FGT_SEM_TAKE	semTake;	/* try to get a semapore */
	FGT_SEM_GIVE	semGive;	/* return semaphore */
}GT_SEM_ROUTINES;

/*
 * definitions for registering MII access functions.
 *
*/
typedef GT_BOOL (*FGT_READ_MII)(
						GT_QD_DEV*   dev,
						unsigned int phyAddr, 
						unsigned int miiReg, 
						unsigned int* value);
typedef GT_BOOL (*FGT_WRITE_MII)(
						GT_QD_DEV*   dev,
						unsigned int phyAddr, 
						unsigned int miiReg, 
						unsigned int value);
typedef GT_BOOL (*FGT_INT_HANDLER)(
						GT_QD_DEV*   dev,
						GT_U16*);

typedef struct _BSP_FUNCTIONS
{
	FGT_READ_MII 	readMii;	/* read MII Registers */
	FGT_WRITE_MII 	writeMii;	/* write MII Registers */
	FGT_SEM_CREATE	semCreate; 	/* create semapore */
	FGT_SEM_DELETE	semDelete; 	/* delete the semapore */
	FGT_SEM_TAKE	semTake;	/* try to get a semapore */
	FGT_SEM_GIVE	semGive;	/* return semaphore */
}BSP_FUNCTIONS;


/*
 *	Type definition for MIB counter operation
*/
typedef enum 
{
	STATS_FLUSH_ALL,		/* Flush all counters for all ports */
	STATS_FLUSH_PORT,		/* Flush all counters for a port */
	STATS_READ_COUNTER,		/* Read a specific counter from a port */
	STATS_READ_REALTIME_COUNTER,	/* Read a realtime counter from a port */
	STATS_READ_ALL			/* Read all counters from a port */

} GT_STATS_OPERATION;

typedef struct _GT_STATS_COUNTER_SET
{
	GT_U32	InUnicasts;
	GT_U32	InBroadcasts;
	GT_U32	InPause;
	GT_U32	InMulticasts;
	GT_U32	InFCSErr;
	GT_U32	AlignErr;
	GT_U32	InGoodOctets;
	GT_U32	InBadOctets;
	GT_U32	Undersize;
	GT_U32	Fragments;
	GT_U32	In64Octets;		/* 64 Octets */
	GT_U32	In127Octets;	/* 65 to 127 Octets */
	GT_U32	In255Octets;	/* 128 to 255 Octets */
	GT_U32	In511Octets;	/* 256 to 511 Octets */
	GT_U32	In1023Octets;	/* 512 to 1023 Octets */
	GT_U32	InMaxOctets;	/* 1024 to Max Octets */
	GT_U32	Jabber;
	GT_U32	Oversize;
	GT_U32	InDiscards;
	GT_U32	Filtered;
	GT_U32	OutUnicasts;
	GT_U32	OutBroadcasts;
	GT_U32	OutPause;
	GT_U32	OutMulticasts;
	GT_U32	OutFCSErr;
	GT_U32	OutGoodOctets;
	GT_U32	Out64Octets;	/* 64 Octets */
	GT_U32	Out127Octets;	/* 65 to 127 Octets */
	GT_U32	Out255Octets;	/* 128 to 255 Octets */
	GT_U32	Out511Octets;	/* 256 to 511 Octets */
	GT_U32	Out1023Octets;	/* 512 to 1023 Octets */
	GT_U32	OutMaxOctets;	/* 1024 to Max Octets */
	GT_U32	Collisions;
	GT_U32	Late;
	GT_U32	Excessive;
	GT_U32	Multiple;
	GT_U32	Single;
	GT_U32	Deferred;
	GT_U32	OutDiscards;

} GT_STATS_COUNTER_SET;


typedef enum
{
	STATS_InUnicasts = 0,
	STATS_InBroadcasts,
	STATS_InPause,
	STATS_InMulticasts,
	STATS_InFCSErr,
	STATS_AlignErr,
	STATS_InGoodOctets,
	STATS_InBadOctets,
	STATS_Undersize,
	STATS_Fragments,
	STATS_In64Octets,
	STATS_In127Octets,
	STATS_In255Octets,
	STATS_In511Octets,
	STATS_In1023Octets,
	STATS_InMaxOctets,
	STATS_Jabber,
	STATS_Oversize,
	STATS_InDiscards,
	STATS_Filtered,
	STATS_OutUnicasts,
	STATS_OutBroadcasts,
	STATS_OutPause,
	STATS_OutMulticasts,
	STATS_OutFCSErr,
	STATS_OutGoodOctets,
	STATS_Out64Octets,
	STATS_Out127Octets,
	STATS_Out255Octets,
	STATS_Out511Octets,
	STATS_Out1023Octets,
	STATS_OutMaxOctets,
	STATS_Collisions,
	STATS_Late,
	STATS_Excessive,
	STATS_Multiple,
	STATS_Single,
	STATS_Deferred,
	STATS_OutDiscards

} GT_STATS_COUNTERS;
/*
 * typedef: enum GT_HISTOGRAM_MODE
 *
 * Description: Enumeration of the histogram counters mode.
 *
 * Enumerations:
 *   GT_COUNT_RX_ONLY - In this mode, Rx Histogram Counters are counted.
 *   GT_COUNT_TX_ONLY - In this mode, Tx Histogram Counters are counted.
 *   GT_COUNT_RX_TX   - In this mode, Rx and Tx Histogram Counters are counted.
 */
typedef enum
{
	GT_COUNT_RX_ONLY = 0,
	GT_COUNT_TX_ONLY,
	GT_COUNT_RX_TX
} GT_HISTOGRAM_MODE;

/*
	Counter set 2 is used by 88E6183
*/
typedef struct _GT_STATS_COUNTER_SET2
{
	GT_U32	InGoodOctetsHi;
	GT_U32	InGoodOctetsLo;
	GT_U32	InBadOctets;
	GT_U32	OutDiscards;
	GT_U32	InGoodFrames;
	GT_U32	InBadFrames;
	GT_U32	InBroadcasts;
	GT_U32	InMulticasts;
	/* 
		Histogram Counters : Rx Only, Tx Only, or both Rx and Tx 
		(refer to Histogram Mode) 
	*/
	GT_U32	Octets64;		/* 64 Octets */
	GT_U32	Octets127;		/* 65 to 127 Octets */
	GT_U32	Octets255;		/* 128 to 255 Octets */
	GT_U32	Octets511;		/* 256 to 511 Octets */
	GT_U32	Octets1023;		/* 512 to 1023 Octets */
	GT_U32	OctetsMax;		/* 1024 to Max Octets */
	GT_U32	OutOctetsHi;
	GT_U32	OutOctetsLo;
	GT_U32	OutFrames;
	GT_U32	Excessive;
	GT_U32	OutMulticasts;
	GT_U32	OutBroadcasts;
	GT_U32	InBadMACCtrl;

	GT_U32	OutPause;
	GT_U32	InPause;
	GT_U32	InDiscards;
	GT_U32	Undersize;
	GT_U32	Fragments;
	GT_U32	Oversize;
	GT_U32	Jabber;
	GT_U32	MACRcvErr;
	GT_U32	InFCSErr;
	GT_U32	Collisions;
	GT_U32	Late;

} GT_STATS_COUNTER_SET2;


typedef enum
{
	STATS2_InGoodOctetsHi = 0,
	STATS2_InGoodOctetsLo,
	STATS2_InBadOctets,
	
	STATS2_OutDiscards,
	STATS2_InGoodFrames,
	STATS2_InBadFrames,
	STATS2_InBroadcasts,
	STATS2_InMulticasts,
	STATS2_64Octets,
	STATS2_127Octets,
	STATS2_255Octets,
	STATS2_511Octets,
	STATS2_1023Octets,
	STATS2_MaxOctets,
	STATS2_OutOctetsHi,
	STATS2_OutOctetsLo,
	STATS2_OutFrames,
	STATS2_Excessive,
	STATS2_OutMulticasts,
	STATS2_OutBroadcasts,
	STATS2_InBadMACCtrl,
	STATS2_OutPause,
	STATS2_InPause,
	STATS2_InDiscards,
	STATS2_Undersize,
	STATS2_Fragments,
	STATS2_Oversize,
	STATS2_Jabber,
	STATS2_MACRcvErr,
	STATS2_InFCSErr,
	STATS2_Collisions,
	STATS2_Late

} GT_STATS_COUNTERS2;

/*
	Counter set 3 is used by 88E6093 and 88E6065
*/
typedef struct _GT_STATS_COUNTER_SET3
{
	GT_U32	InGoodOctetsLo;	/* offset 0 */
	GT_U32	InGoodOctetsHi;	/* offset 1, not supported by 88E6065 */
	GT_U32	InBadOctets;		/* offset 2 */
	GT_U32	OutFCSErr;			/* offset 3 */
	GT_U32	InUnicasts;			/* offset 4 */
	GT_U32	Deferred;			/* offset 5 */
	GT_U32	InBroadcasts;		/* offset 6 */
	GT_U32	InMulticasts;		/* offset 7 */
	/* 
		Histogram Counters : Rx Only, Tx Only, or both Rx and Tx 
		(refer to Histogram Mode) 
	*/
	GT_U32	Octets64;		/* 64 Octets, offset 8 */
	GT_U32	Octets127;		/* 65 to 127 Octets, offset 9 */
	GT_U32	Octets255;		/* 128 to 255 Octets, offset 10 */
	GT_U32	Octets511;		/* 256 to 511 Octets, offset 11 */
	GT_U32	Octets1023;		/* 512 to 1023 Octets, offset 12 */
	GT_U32	OctetsMax;		/* 1024 to Max Octets, offset 13 */
	GT_U32	OutOctetsLo;	/* offset 14 */
	GT_U32	OutOctetsHi;	/* offset 15, not supported by 88E6065 */
	GT_U32	OutUnicasts;	/* offset 16 */
	GT_U32	Excessive;		/* offset 17 */
	GT_U32	OutMulticasts;	/* offset 18 */
	GT_U32	OutBroadcasts;	/* offset 19 */
	GT_U32	Single;			/* offset 20 */

	GT_U32	OutPause;		/* offset 21 */
	GT_U32	InPause;			/* offset 22 */
	GT_U32	Multiple;		/* offset 23 */
	GT_U32	Undersize;		/* offset 24 */
	GT_U32	Fragments;		/* offset 25 */
	GT_U32	Oversize;		/* offset 26 */
	GT_U32	Jabber;			/* offset 27 */
	GT_U32	InMACRcvErr;	/* offset 28 */
	GT_U32	InFCSErr;		/* offset 29 */
	GT_U32	Collisions;		/* offset 30 */
	GT_U32	Late;				/* offset 31 */

} GT_STATS_COUNTER_SET3;

/*
	PM Counter  is used by 88E6093 and 88E6065
*/
typedef struct _GT_STATS_PM_COUNTER
{
      GT_STATS_COUNTER_SET3  Counterset3;
      GT_PORT_STAT2  	 Counterstat2;

} GT_STATS_PM_COUNTER;



typedef enum
{
	STATS3_InGoodOctetsLo = 0,
	STATS3_InGoodOctetsHi,
	STATS3_InBadOctets,
	
	STATS3_OutFCSErr,
	STATS3_InUnicasts,
	STATS3_Deferred,			/* offset 5 */
	STATS3_InBroadcasts,
	STATS3_InMulticasts,
	STATS3_64Octets,
	STATS3_127Octets,
	STATS3_255Octets,			/* offset 10 */
	STATS3_511Octets,
	STATS3_1023Octets,
	STATS3_MaxOctets,
	STATS3_OutOctetsLo,
	STATS3_OutOctetsHi,
	STATS3_OutUnicasts,		/* offset 16 */
	STATS3_Excessive,
	STATS3_OutMulticasts,
	STATS3_OutBroadcasts,
	STATS3_Single,
	STATS3_OutPause,
	STATS3_InPause,
	STATS3_Multiple,
	STATS3_Undersize,			/* offset 24 */
	STATS3_Fragments,
	STATS3_Oversize,
	STATS3_Jabber,
	STATS3_InMACRcvErr,
	STATS3_InFCSErr,
	STATS3_Collisions,
	STATS3_Late					/* offset 31 */

} GT_STATS_COUNTERS3;



/*
 * typedef: struct GT_1000T_MASTER_SLAVE
 *
 * Description: 1000Base-T Master/Slave Configuration
 *
 * Fields:
 *      autoConfig   - GT_TRUE for auto-config, GT_FALSE for manual setup.
 *      masterPrefer - GT_TRUE if Master configuration is preferred.
 *
 */
typedef struct _GT_1000T_MASTER_SLAVE
{
	GT_BOOL	autoConfig;
	GT_BOOL masterPrefer;
} GT_1000T_MASTER_SLAVE;


#define GT_MDI_PAIR_NUM     	4	/* (1,2),(3,6),(4,5),(7,8) */
#define GT_CHANNEL_PAIR_NUM     2	/* (channel A,B),(channel C,D) */


/*
 * typedef: enum GT_PHY_LINK_STATUS
 *
 * Description: Enumeration of Link Status
 *
 * Enumerations:
 *		GT_PHY_LINK_OFF		- No Link
 *		GT_PHY_LINK_COPPER	- Link on Copper
 *		GT_PHY_LINK_FIBER	- Link on Fiber
 */
typedef enum
{
	GT_PHY_LINK_OFF = 0,
	GT_PHY_LINK_COPPER = 1,
	GT_PHY_LINK_FIBER = 2
} GT_PHY_LINK_STATUS;


/* Definition for packet generator */

/* Payload */
typedef enum
{
	GT_PG_PAYLOAD_RANDOM = 0,	/* Pseudo-random */
	GT_PG_PAYLOAD_5AA5		/* 5A,A5,5A,A5,... */
} GT_PG_PAYLOAD;

/* Length */
typedef enum
{
	GT_PG_LENGTH_64 = 0,		/* 64 bytes */
	GT_PG_LENGTH_1514
} GT_PG_LENGTH;

/* Error */
typedef enum
{
	GT_PG_TX_NORMAL = 0,		/* No Error */
	GT_PG_TX_ERROR			/* Tx packets with CRC error and Symbol error */
} GT_PG_TX;

/* Structure for packet generator */
typedef struct
{
	GT_PG_PAYLOAD  payload;
	GT_PG_LENGTH   length;
	GT_PG_TX       tx;
} GT_PG;


/*
 * typedef: enum GT_TEST_STATUS
 *
 * Description: Enumeration of VCT test status
 *
 * Enumerations:
 *      GT_TEST_FAIL    - virtual cable test failed.
 *      GT_NORMAL_CABLE - normal cable.
 *      GT_IMPEDANCE_MISMATCH - impedance mismatch.
 *      GT_OPEN_CABLE   - open in cable.
 *      GT_SHORT_CABLE  - short in cable.
 *
 */
typedef enum
{
	GT_TEST_FAIL,
	GT_NORMAL_CABLE,
	GT_IMPEDANCE_MISMATCH,
	GT_OPEN_CABLE,
	GT_SHORT_CABLE,
} GT_TEST_STATUS;


/*
 * typedef: enum GT_NORMAL_CABLE_LEN
 *
 * Description: Enumeration for normal cable length
 *
 * Enumerations:
 *      GT_LESS_THAN_50M - cable length less than 50 meter.
 *      GT_50M_80M       - cable length between 50 - 80 meter.
 *      GT_80M_110M      - cable length between 80 - 110 meter.
 *      GT_110M_140M     - cable length between 110 - 140 meter.
 *      GT_MORE_THAN_140 - cable length more than 140 meter.
 *      GT_UNKNOWN_LEN   - unknown length.
 *
 */
typedef enum
{
	GT_LESS_THAN_50M,
	GT_50M_80M,
	GT_80M_110M,
	GT_110M_140M,
	GT_MORE_THAN_140,
	GT_UNKNOWN_LEN,

} GT_NORMAL_CABLE_LEN;


/*
 * typedef: enum GT_CABLE_LEN
 *
 * Description: Enumeration cable length
 *
 * Enumerations:
 *      normCableLen - cable lenght for normal cable.
 *      errCableLen  - for cable failure the estimate fault distance in meters.
 *
 */
typedef union
{
	GT_NORMAL_CABLE_LEN normCableLen;
	GT_U8               errCableLen;

} GT_CABLE_LEN;

/*
 * typedef: struct GT_CABLE_STATUS
 *
 * Description: virtual cable diagnostic status per MDI pair.
 *
 * Fields:
 *      cableStatus - VCT cable status.
 *      cableLen    - VCT cable length.
 *	phyType	    - type of phy (100M phy or Gigabit phy)
 */
typedef struct
{
	GT_TEST_STATUS  cableStatus[GT_MDI_PAIR_NUM];
	GT_CABLE_LEN    cableLen[GT_MDI_PAIR_NUM];
	GT_U16	    phyType;

} GT_CABLE_STATUS;


/*
 * typedef: enum GT_CABLE_TYPE
 *
 * Description: Enumeration of Cable Type
 *
 * Enumerations:
 *		GT_STRAIGHT_CABLE	_ straight cable
 *      GT_CROSSOVER_CABLE 	- crossover cable
 */
typedef enum
{
	GT_STRAIGHT_CABLE,
	GT_CROSSOVER_CABLE

} GT_CABLE_TYPE;


/*
 * typedef: enum GT_RX_CHANNEL
 *
 * Description: Enumeration of Receiver Channel Assignment
 *
 * Enumerations:
 *		GT_CHANNEL_A   - Channel A
 *		GT_CHANNEL_B   - Channel B
 *		GT_CHANNEL_C   - Channel C
 *		GT_CHANNEL_D   - Channel D
 */
typedef enum
{
    GT_CHANNEL_A,
    GT_CHANNEL_B,
    GT_CHANNEL_C,
    GT_CHANNEL_D
} GT_RX_CHANNEL;


/*
 * typedef: enum GT_POLARITY_STATUS
 *
 * Description: Enumeration of polarity status
 *
 * Enumerations:
 *		GT_POSITIVE	- positive polarity
 *      GT_NEGATIVE	- negative polarity
 */
typedef enum
{
	GT_POSITIVE,
	GT_NEGATIVE

} GT_POLARITY_STATUS;


/*
 * typedef: struct GT_1000BT_EXTENDED_STATUS
 *
 * Description: Currently the 1000Base-T PCS can determine the cable polarity
 * 		on pairs A,B,C,D; crossover on pairs A,B and C,D; and skew among 
 *		the pares. These status enhance the capability of the virtual cable tester
 *
 * Fields:
 *      isValid		- GT_TRUE if this structure have valid information, 
 * 					  GT_FALSE otherwise.
 *					  It is valid only if 1000BASE-T Link is up.
 *      pairSwap    - GT_CROSSOVER_CABLE, if the cable is crossover,
 *					  GT_STRAIGHT_CABLE, otherwise
 *		pairPolarity- GT_POSITIVE, if polarity is positive,
 *					  GT_NEGATIVE, otherwise
 *		pairSkew	- pair skew in units of ns
 */
typedef struct
{
	GT_BOOL				isValid;
	GT_CABLE_TYPE		pairSwap[GT_CHANNEL_PAIR_NUM];
	GT_POLARITY_STATUS	pairPolarity[GT_MDI_PAIR_NUM];
	GT_U32			    pairSkew[GT_MDI_PAIR_NUM];

} GT_1000BT_EXTENDED_STATUS;


/*
 * typedef: struct GT_ADV_EXTENDED_STATUS
 *
 * Description: Currently the 1000Base-T PCS can determine the cable polarity
 * 		on pairs A,B,C,D; crossover on pairs A,B and C,D; and skew among 
 *		the pares. These status enhance the capability of the virtual cable tester
 *
 * Fields:
 *      isValid		- GT_TRUE if this structure have valid information, 
 * 					  GT_FALSE otherwise.
 *					  It is valid only if 1000BASE-T Link is up.
 *      pairSwap    - Receive channel assignement
 *		pairPolarity- GT_POSITIVE, if polarity is positive,
 *					  GT_NEGATIVE, otherwise
 *		pairSkew	- pair skew in units of ns
 *		cableLen	- cable length based on DSP
 */
typedef struct
{
    GT_BOOL            isValid;
    GT_RX_CHANNEL      pairSwap[GT_MDI_PAIR_NUM];
    GT_POLARITY_STATUS pairPolarity[GT_MDI_PAIR_NUM];
    GT_U32             pairSkew[GT_MDI_PAIR_NUM];
	GT_U32				cableLen[GT_MDI_PAIR_NUM];
} GT_ADV_EXTENDED_STATUS;


/*
 * if isGigPhy in GT_CABLE_STATUS is not GT_TRUE, cableStatus and cableLen 
 * will have only 2 pairs available.
 * One is RX Pair and the other is TX Pair.
 */
#define MDI_RX_PAIR		0	/* cableStatus[0] or cableLen[0] */
#define MDI_TX_PAIR		1	/* cableStatus[1] or cableLen[1] */

/* definition for Phy Type */
#define PHY_100M		0 /* 10/100M phy, E3082 or E3083 */
#define PHY_1000M		1 /* Gigabit phy, the rest phys */
#define PHY_10000M		2 /* 10 Gigabit phy, unused */
#define PHY_1000M_B		3 /* Gigabit phy which needs work-around */
#define PHY_1000M_MP	4 /* Gigabit phy with multiple page mode */


/* Definition for Advance Virtual Cable Test */

/*
 * typedef: enum GT_ADV_VCT_TRANS_CHAN_SEL
 *
 * Description: Enumeration of Advanced VCT Transmitter channel select
 *
 * Enumerations:
 *		GT_ADV_VCT_NO_CROSSPAIR - Transmitter channel select is 000
 *		GT_ADV_VCT_CROSSPAIR    - Transmitter channelselect is 100/101/110/111
 */
typedef enum
{
	/* Advanced VCT Mode */
    GT_ADV_VCT_TCS_NO_CROSSPAIR		= 0,
    GT_ADV_VCT_TCS_CROSSPAIR_0		    = 0x4,
    GT_ADV_VCT_TCS_CROSSPAIR_1		    = 0x5,
    GT_ADV_VCT_TCS_CROSSPAIR_2		    = 0x6,
    GT_ADV_VCT_TCS_CROSSPAIR_3		    = 0x7
} GT_ADV_VCT_TRANS_CHAN_SEL;


typedef enum
{
	/* Advanced VCT Mode */
    GT_ADV_VCT_SAVG_2		= 0,
    GT_ADV_VCT_SAVG_4		= 1,
    GT_ADV_VCT_SAVG_8		= 2,
    GT_ADV_VCT_SAVG_16		= 3,
    GT_ADV_VCT_SAVG_32		= 4,
    GT_ADV_VCT_SAVG_64		= 5,
    GT_ADV_VCT_SAVG_128	= 6,
    GT_ADV_VCT_SAVG_256	= 7
} GT_ADV_VCT_SAMPLE_AVG;

typedef enum
{
	/* Advanced VCT Mode */
    GT_ADV_VCT_MAX_PEAK		=0x00,
    GT_ADV_VCT_FIRST_PEAK		=0x01,
} GT_ADV_VCT_MOD;


typedef unsigned int GT_ADV_VCT_PEAKDET_HYST;

/*
 * typedef: enum GT_ADV_VCT_MODE
 *
 * Description: Enumeration of Advanced VCT Mode and Transmitter channel select
 *
 * Enumerations:
 *      GT_ADV_VCT_FIRST_PEAK   - first peak above a certain threshold is reported.
 *      GT_ADV_VCT_MAX_PEAK     - maximum peak above a certain threshold is reported.
 *		GT_ADV_VCT_OFFSE	     - offset
 *		GT_ADV_VCT_SAMPLE_POINT - sample point
 *
 *		GT_ADV_VCT_NO_CROSSPAIR - Transmitter channel select is 000
 *		GT_ADV_VCT_CROSSPAIR    - Transmitter channelselect is 100/101/110/111
 *   Example: mode = GT_ADV_VCT_FIRST_PEAK | GT_ADV_VCT_CROSSPAIR.
 */
typedef struct
{
    GT_ADV_VCT_MOD					mode;
    GT_ADV_VCT_TRANS_CHAN_SEL      transChanSel;
    GT_ADV_VCT_SAMPLE_AVG			sampleAvg;
	GT_ADV_VCT_PEAKDET_HYST		peakDetHyst;
} GT_ADV_VCT_MODE;


/*
 * typedef: enum GT_ADV_VCT_STATUS
 *
 * Description: Enumeration of Advanced VCT status
 *
 * Enumerations:
 *      GT_ADV_VCT_FAIL     - advanced virtual cable test failed.
 *                             cable lengh cannot be determined.
 *      GT_ADV_VCT_NORMAL   - normal cable.
 *                             cable lengh may not be determined.
 *      GT_ADV_VCT_IMP_GREATER_THAN_115 - impedance mismatch > 115 ohms
 *                             cable lengh is valid.
 *      GT_ADV_VCT_IMP_LESS_THAN_85 - impedance mismatch < 85 ohms
 *                             cable lengh is valid.
 *      GT_ADV_VCT_OPEN 	 - cable open
 *                             cable lengh is valid.
 *      GT_ADV_VCT_SHORT 	 - cable shorted
 *                             cable lengh is valid.
 *      GT_ADV_VCT_CROSS_PAIR_SHORT - cross pair short.
 *                             cable lengh for each channel is valid.
 */
typedef enum
{
    GT_ADV_VCT_FAIL,
    GT_ADV_VCT_NORMAL,
    GT_ADV_VCT_IMP_GREATER_THAN_115,
    GT_ADV_VCT_IMP_LESS_THAN_85,
    GT_ADV_VCT_OPEN,
    GT_ADV_VCT_SHORT,
    GT_ADV_VCT_CROSS_PAIR_SHORT
} GT_ADV_VCT_STATUS;


/*
 * typedef: struct GT_CROSS_PAIR_LIST
 *
 * Description: strucuture for cross pair short channels.
 *
 * Fields:
 *      channel - cross pair short channel list
 *                channel[i] is GT_TRUE if the channel[i] is cross pair short
 *                with the current channel under test.
 *      dist2fault - estimated distance to the shorted location.
 *                   valid only if related channel (above) is GT_TRUE.
 */
typedef struct _GT_CROSS_SHORT_LIST
{
    GT_BOOL    channel[GT_MDI_PAIR_NUM];
    GT_16     dist2fault[GT_MDI_PAIR_NUM];
} GT_CROSS_SHORT_LIST;


/*
 * typedef: struct GT_ADV_CABLE_STATUS
 *
 * Description: strucuture for advanced cable status.
 *
 * Fields:
 *      cableStatus - VCT cable status for each channel.
 *      crossShort  - cross pair short list for each channel. 
 *                    Valid only if relative cableStatus is GT_ADV_VCT_CROSS_PAIR_SHORT.
 *      dist2fault  - estimated distance to fault for each channel.
 *                    Valid if relative cableStatus is one of the followings:
 *                      GT_ADV_VCT_NORMAL
 *                      GT_ADV_VCT_IMP_GREATER_THAN_115
 *                      GT_ADV_VCT_IMP_LESS_THAN_85,
 *                      GT_ADV_VCT_OPEN, or
 *						GT_ADV_VCT_SHORT
  */
typedef struct
{
    GT_ADV_VCT_STATUS   cableStatus[GT_MDI_PAIR_NUM];
    union {
        GT_CROSS_SHORT_LIST crossShort;
        GT_16     dist2fault;
    }u[GT_MDI_PAIR_NUM];
} GT_ADV_CABLE_STATUS;


/*
 * Definition:
 *		GT_LED_LINK_ACT_SPEED 	- off = no link, on = link, blink = activity, blink speed = link speed
 *		GT_LED_LINK_ACT	 		- off = no link, on = link, blink = activity
 *		GT_LED_LINK		 		- off = no link, on = link
 *		GT_LED_10_LINK_ACT		- off = no link, on = 10, blink = activity
 *		GT_LED_10_LINK			- off = no link, on = 10
 *		GT_LED_100_LINK_ACT		- off = no link, on = 100 link, blink = activity
 *		GT_LED_100_LINK			- off = no link, on = 100 link
 *		GT_LED_1000_LINK_ACT	- off = no link, on = 1000 link, blink = activity
 *		GT_LED_1000_LINK		- off = no link, on = 1000 link
 *		GT_LED_10_100_LINK_ACT	- off = no link, on = 10 or 100 link, blink = activity
 *		GT_LED_10_100_LINK		- off = no link, on = 10 or 100 link
 *		GT_LED_10_1000_LINK_ACT	- off = no link, on = 10 or 1000 link, blink = activity
 *		GT_LED_10_1000_LINK		- off = no link, on = 10 or 1000 link
 *		GT_LED_100_1000_LINK_ACT- off = no link, on = 100 or 1000 link, blink = activity
 *		GT_LED_100_1000_LINK	- off = no link, on = 100 or 1000 link
 *		GT_LED_SPECIAL			- special leds
 *		GT_LED_DUPLEX_COL		- off = half duplx, on = full duplex, blink = collision
 *		GT_LED_ACTIVITY			- off = no link, blink on = activity
 *		GT_LED_PTP_ACT			- blink on = PTP activity
 *		GT_LED_FORCE_BLINK		- force blink
 *		GT_LED_FORCE_OFF		- force off
 *		GT_LED_FORCE_ON			- force on
*/
#define GT_LED_LINK_ACT_SPEED		1
#define GT_LED_LINK_ACT			2
#define GT_LED_LINK				3
#define GT_LED_10_LINK_ACT			4
#define GT_LED_10_LINK				5
#define GT_LED_100_LINK_ACT		6
#define GT_LED_100_LINK			7
#define GT_LED_1000_LINK_ACT		8
#define GT_LED_1000_LINK			9
#define GT_LED_10_100_LINK_ACT		10
#define GT_LED_10_100_LINK			11
#define GT_LED_10_1000_LINK_ACT	12
#define GT_LED_10_1000_LINK		13
#define GT_LED_100_1000_LINK_ACT	14
#define GT_LED_100_1000_LINK		15
#define GT_LED_SPECIAL				16
#define GT_LED_DUPLEX_COL			17
#define GT_LED_ACTIVITY			18
#define GT_LED_PTP_ACT				19
#define GT_LED_FORCE_BLINK			20
#define GT_LED_FORCE_OFF			21
#define GT_LED_FORCE_ON			22
#define GT_LED_RESERVE				23


/*
 * typedef: enum GT_LED_CFG
 *
 * Description: Enumeration for LED configuration type
 *
 * Enumerations:
 *		GT_LED_CFG_LED0		- read/write led0 value (GT_LED_xxx definition)
 *		GT_LED_CFG_LED1		- read/write led1 value
 *		GT_LED_CFG_LED2		- read/write led2 value
 *		GT_LED_CFG_LED3		- read/write led3 value
 *		GT_LED_CFG_PULSE_STRETCH	- read/write pulse stretch (0 ~ 4)
 *		GT_LED_CFG_BLINK_RATE		- read/write blink rate	(0 ~ 5)
 *		GT_LED_CFG_SPECIAL_CONTROL	- read/write special control (port vector)
 */
typedef enum
{
	GT_LED_CFG_LED0,
	GT_LED_CFG_LED1,
	GT_LED_CFG_LED2,
	GT_LED_CFG_LED3,
	GT_LED_CFG_PULSE_STRETCH,
	GT_LED_CFG_BLINK_RATE,
	GT_LED_CFG_SPECIAL_CONTROL
} GT_LED_CFG;


/*
 * typedef: enum GT_AVB_RECOVERED_CLOCK
 *
 * Description: Enumeration for recovered clock type
 *
 * Enumerations:
 *		GT_PRIMARY_RECOVERED_CLOCK 		- primary recovered clock
 *		GT_SECONDARY_RECOVERED_CLOCK 	- secondary recovered clock
 */
typedef enum
{
	GT_PRIMARY_RECOVERED_CLOCK,
	GT_SECONDARY_RECOVERED_CLOCK
} GT_AVB_RECOVERED_CLOCK;


/* Define QAV interrupt bits */

#define GT_QAV_INT_STATUS_ENQ_LMT_BIT			0x8000	/* EnQ Limit Interrupt Enable */
#define GT_QAV_INT_STATUS_ISO_DEL_BIT			0x0400	/* Iso Delay Interrupt Enable */
#define GT_QAV_INT_STATUS_ISO_DIS_BIT			0x0200  /* Iso Discard Interrupt Enable */
#define GT_QAV_INT_STATUS_ISO_LIMIT_EX_BIT		0x0100  /* Iso Packet Memory Exceeded Interrupt Enable */

#define GT_QAV_INT_ENABLE_ENQ_LMT_BIT			0x80  /* EnQ Limit Interrupt Enable */
#define GT_QAV_INT_ENABLE_ISO_DEL_BIT			0x04  /* Iso Delay Interrupt Enable */
#define GT_QAV_INT_ENABLE_ISO_DIS_BIT			0x02  /* Iso Discard Interrupt Enable */
#define GT_QAV_INT_ENABLE_ISO_LIMIT_EX_BIT		0x01  /* Iso Packet Memory Exceeded Interrupt Enable */


/*
 * Typedef: enum GT_EEPROM_OPERATION
 *
 * Description: Defines the EEPROM Operation type
 *
 * Fields:
 *      PTP_WRITE_DATA 			- Write data to the EEPROM register
 *      PTP_READ_DATA			- Read data from EEPROM register
 *      PTP_RESTART				- Restart EEPROM oprition
 */
typedef enum
{
	GT_EEPROM_NO_OP		 			= 0x0,
	GT_EEPROM_WRITE_DATA 			= 0x3,
	GT_EEPROM_READ_DATA  			= 0x4,
	GT_EEPROM_RESTART				= 0x6,
	GT_EEPROM_HALT					= 0x7,
} GT_EEPROM_OPERATION;


/*
 *  typedef: struct GT_EEPROM_OP_DATA
 *
 *  Description: data required by EEPROM Operation
 *
 *  Fields:
 *      eepromPort		- physical port of the device
 *      eepromAddr 	- register address
 *      eepromData 	- data for ptp register.
 */
typedef struct
{
	GT_U32	eepromPort;
	GT_U32	eepromBlock;
	GT_U32	eepromAddr;
	GT_U32	eepromData;
} GT_EEPROM_OP_DATA;

#define GT_EEPROM_OP_ST_RUNNING_MASK		0x800
#define GT_EEPROM_OP_ST_WRITE_EN_MASK		0x400

#define GT_SCRAT_MISC_REG_SCRAT_0	0x00 /* Scratch Byte 0 */
#define GT_SCRAT_MISC_REG_SCRAT_1	0x01 /* Scratch Byte 1 */
#define GT_SCRAT_MISC_REG_GPIO_CFG	0x60 /* GPIO Configuration */
										 /* 0x61 = Reserved for future use */
#define GT_SCRAT_MISC_REG_GPIO_DIR	0x62 /* GPIO Direction */
#define GT_SCRAT_MISC_REG_GPIO_DAT	0x63 /* GPIO Data */
#define GT_SCRAT_MISC_REG_CFG_DAT0	0x70 /* CONFIG Data 0 */
#define GT_SCRAT_MISC_REG_CFG_DAT1	0x71 /* CONFIG Data 1 */
#define GT_SCRAT_MISC_REG_CFG_DAT2	0x72 /* CONFIG Data 2 */
#define GT_SCRAT_MISC_REG_CFG_DAT3	0x73 /* CONFIG Data 3 */
#define GT_SCRAT_MISC_REG_SYNCE		0x7C /* SyncE & TAICLK125’s Drive */
#define GT_SCRAT_MISC_REG_P5_CLK	0x7D /* P5’s & CLK125’s Clock Drive */
#define GT_SCRAT_MISC_REG_P6_CLK	0x7E /* P6’s Clock Drive */
#define GT_SCRAT_MISC_REG_EEPROM	0x7F /* EEPROM Pad drive */
#define GT_SCRAT_MISC_REG_MAX		0x80 /* Maximun register pointer */

#define GT_GPIO_BIT_0	0x1
#define GT_GPIO_BIT_1	0x2
#define GT_GPIO_BIT_2	0x4
#define GT_GPIO_BIT_3	0x8
#define GT_GPIO_BIT_4	0x10
#define GT_GPIO_BIT_5	0x20
#define GT_GPIO_BIT_6	0x40

typedef struct
{
	GT_U8         user : 3;
	GT_U8         addr : 5;
}GT_CONFIG_DATA_0;

typedef struct
{
	GT_U8         led  : 2;
	GT_U8         fourcol : 1;
	GT_U8         normCx : 1;
	GT_U8         jumbo : 1;
	GT_U8         ee_we : 1;
	GT_U8         fd_flow : 1;
	GT_U8         hd_flow : 1;
}GT_CONFIG_DATA_1;

typedef struct
{
	GT_U8         p5_mod : 3;
	GT_U8         bit4	 : 1;
	GT_U8         p6_mod : 3;
}GT_CONFIG_DATA_2;

typedef struct
{
	GT_U8         rmu_mod : 2;
}GT_CONFIG_DATA_3;

typedef struct
{
	union {
		GT_U8				Byte;
		GT_CONFIG_DATA_0	Data;
	} cfgData0;
	union {
		GT_U8				Byte;
		GT_CONFIG_DATA_0	Data;
	} cfgData1;
	union {
		GT_U8				Byte;
		GT_CONFIG_DATA_0	Data;
	} cfgData2;
	union {
		GT_U8				Byte;
		GT_CONFIG_DATA_0	Data;
	} cfgData3;
}GT_CONFIG_DATA;


/* definition for Trunking */
#define IS_TRUNK_ID_VALID(_dev, _id)	(((_id) < 16) ? 1 : 0)


/* definition for device scan mode */
#define SMI_AUTO_SCAN_MODE		0	/* Scan 0 or 0x10 base address to find the QD */
#define SMI_MANUAL_MODE			1	/* Use QD located at manually defined base addr */
#define SMI_MULTI_ADDR_MODE		2	/* Use QD at base addr and use indirect access */
typedef struct
{
	GT_U32	scanMode;	/* check definition for device scan mode */
	GT_U32	baseAddr;	/* meaningful if scanMode is not SMI_AUTO_SCAN_MODE */
} GT_SCAN_MODE;


#define GT_SKIP_INIT_SETUP	0x736b6970

/*
 * Typedef: struct GT_SYS_CONFIG
 *
 * Description: System configuration Parameters struct.
 *
 * Fields:
 *	devNum		- Switch Device Number 
 *  cpuPortNum  - The physical port used to connect the device to CPU.
 *                This is the port to which packets destined to CPU are
 *                forwarded.
 *  initPorts   - Whether to initialize the ports state.
 *                GT_FALSE    - leave in default state.
 *                GT_TRUE     - Initialize to Forwarding state.
 *  skipInitSetup - skip init setup, if value is GT_SKIP_INIT_SETUP
 *                  perform init setup, otherwise
 *	                Initializing port state is not affected by this variable.
 *	BSPFunctions	- Group of BSP specific functions.
 *				SMI Read/Write and Semaphore Related functions.
 */
typedef struct
{
	GT_U8         devNum;
	GT_U8         cpuPortNum;
	GT_BOOL       initPorts;
	BSP_FUNCTIONS BSPFunctions;
	GT_SCAN_MODE  mode;
	GT_U32        skipInitSetup;
}GT_SYS_CONFIG;



/*
 * Typedef: struct GT_QD_DEV
 *
 * Description: Includes Tapi layer switch configuration data.
 *
 * Fields:
 *   deviceId       - The device type identifier.
 *   revision       - The device revision number.
 *   baseRegAddr    - Switch Base Register address.
 *   numOfPorts     - Number of active ports.
 *   maxPorts       - max ports. This field is only for driver's use.
 *   cpuPortNum     - Logical port number whose physical port is connected to the CPU.
 *   maxPhyNum      - max configurable Phy address.
 *   stpMode        - current switch STP mode (0 none, 1 en, 2 dis)
 *   accessMode	    - shows how to find and access the device.
 *   phyAddr        - SMI address used to access Switch registers(only for SMI_MULTI_ADDR_MODE).
 *   validPortVec   - valid port list in vector format
 *   validPhyVec	- valid phy list in vector format
 *   validSerdesVec	- valid serdes list in vector format
 *   devGroup	    - the device group
 *   devName	    - name of the device
 *   devStorage	    - driver internal use (hold various temp information)
 *   multiAddrSem   - Semaphore for Accessing SMI Device
 *   atuRegsSem     - Semaphore for ATU access
 *   vtuRegsSem     - Semaphore for VTU access
 *   statsRegsSem   - Semaphore for RMON counter access
 *   pirlRegsSem    - Semaphore for PIRL Resource access
 *   ptpRegsSem     - Semaphore for PTP Resource access
 *   tblRegsSem     - Semaphore for various Table Resource access,
 *                    such as Trunk Tables and Device Table
 *   eepromRegsSem  - Semaphore for eeprom control access
 *   phyRegsSem     - Semaphore for PHY Device access
 *   fgtReadMii     - platform specific SMI register Read function
 *   fgtWriteMii    - platform specific SMI register Write function
 *   semCreate      - function to create semapore
 *   semDelete      - function to delete the semapore
 *   semTake        - function to get a semapore
 *   semGive        - function to return semaphore
 *   appData        - application data that user may use
 */
struct _GT_QD_DEV
{
	GT_DEVICE   deviceId;
	GT_LPORT    cpuPortNum;
	GT_U8       revision;
	GT_U8		devNum;
	GT_U8		devEnabled;
	GT_U8       baseRegAddr;
	GT_U8       numOfPorts;
	GT_U8		maxPorts;
	GT_U8       maxPhyNum;
	GT_U8		stpMode;
	GT_U8		accessMode;
	GT_U8		phyAddr;
	GT_U16		reserved;
	GT_U16		validPortVec;
	GT_U16		validPhyVec;
	GT_U16		validSerdesVec;
	GT_U16		devGroup;
	GT_U32		devName;
	GT_U32		devStorage;
	GT_SEM		multiAddrSem;
	GT_SEM		atuRegsSem;
	GT_SEM		vtuRegsSem;
	GT_SEM		statsRegsSem;
	GT_SEM		pirlRegsSem;
	GT_SEM		ptpRegsSem;
	GT_SEM		tblRegsSem;
	GT_SEM		eepromRegsSem;
	GT_SEM		phyRegsSem;

	FGT_READ_MII 	fgtReadMii;
	FGT_WRITE_MII 	fgtWriteMii;

	FGT_SEM_CREATE	semCreate; 	/* create semaphore */
	FGT_SEM_DELETE	semDelete; 	/* delete the semaphore */
	FGT_SEM_TAKE	semTake;	/* try to get a semaphore */
	FGT_SEM_GIVE	semGive;	/* return semaphore */
	void*		appData;

};

/*
 * typedef: struct PIRL_PARA_TBL_T
 *
 * Description: PIRL parameter table structure
 *
 * Fields:
 *      BI     - bucket increment 
 *      BRF    - bucket rate factor
 *      CBS    - Committed Burst Size
 *      EBS    - Excess Burst Size
 */
typedef struct {
	GT_U32 BI;
	GT_U32 BRF;
	GT_U32 CBS;
	GT_U32 EBS;
} PIRL_PARA_TBL_T;

/*special rate which can not be calculated by formula*/
typedef enum {
	PIRL_RATE_NO_LIMIT = 0,
	PIRL_RATE_64K,
	PIRL_RATE_128K,
	PIRL_RATE_192K,
	PIRL_RATE_256K,
	PIRL_RATE_320K,
	PIRL_RATE_384K,
	PIRL_RATE_448K,
	PIRL_RATE_512K,
	PIRL_RATE_576K,
	PIRL_RATE_640K,
	PIRL_RATE_704K,
	PIRL_RATE_768K,
	PIRL_RATE_832K,
	PIRL_RATE_896K,
	PIRL_RATE_960K,
	PIRL_RATE_1M,
	PIRL_RATE_2M,
	PIRL_RATE_3M,
	PIRL_RATE_4M,
	PIRL_RATE_5M,
	PIRL_RATE_6M,
	PIRL_RATE_7M,
	PIRL_RATE_8M,
	PIRL_RATE_9M,
	PIRL_RATE_10M,
	PIRL_RATE_11M,
	PIRL_RATE_12M,
	PIRL_RATE_13M,
	PIRL_RATE_14M,
	PIRL_RATE_15M,
	PIRL_RATE_16M,
	PIRL_RATE_17M,
	PIRL_RATE_18M,
	PIRL_RATE_19M,
	PIRL_RATE_20M
} PIRL_SPECIAL_RATE_ENUM_T;

#ifdef __cplusplus
}
#endif

#endif /* __msApi_h */