[ceph.git] / ceph / src / spdk / dpdk / drivers / net / qede / base / ecore_vfpf_if.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2016 - 2018 Cavium Inc.
 * All rights reserved.
 * www.cavium.com
 */

#ifndef __ECORE_VF_PF_IF_H__
#define __ECORE_VF_PF_IF_H__

/* @@@ TBD MichalK this should be HSI? */
#define T_ETH_INDIRECTION_TABLE_SIZE 128
#define T_ETH_RSS_KEY_SIZE 10 /* @@@ TBD this should be HSI? */

/***********************************************
 *
 * Common definitions for all HVs
 *
 **/
struct vf_pf_resc_request {
	u8 num_rxqs;
	u8 num_txqs;
	u8 num_sbs;
	u8 num_mac_filters;
	u8 num_vlan_filters;
	u8 num_mc_filters; /* No limit  so superfluous */
	u8 num_cids;
	u8 padding;
};

struct hw_sb_info {
	u16 hw_sb_id;    /* aka absolute igu id, used to ack the sb */
	u8 sb_qid;      /* used to update DHC for sb */
	u8 padding[5];
};

/***********************************************
 *
 * HW VF-PF channel definitions
 *
 * A.K.A VF-PF mailbox
 *
 **/
#define TLV_BUFFER_SIZE		1024

/* vf pf channel tlvs */
/* general tlv header (used for both vf->pf request and pf->vf response) */
struct channel_tlv {
	u16 type;
	u16 length;
};

/* header of first vf->pf tlv carries the offset used to calculate response
 * buffer address
 */
struct vfpf_first_tlv {
	struct channel_tlv tl;
	u32 padding;
	u64 reply_address;
};

/* header of pf->vf tlvs, carries the status of handling the request */
struct pfvf_tlv {
	struct channel_tlv tl;
	u8 status;
	u8 padding[3];
};

/* response tlv used for most tlvs */
struct pfvf_def_resp_tlv {
	struct pfvf_tlv hdr;
};

/* used to terminate and pad a tlv list */
struct channel_list_end_tlv {
	struct channel_tlv tl;
	u8 padding[4];
};

/* Acquire */
struct vfpf_acquire_tlv {
	struct vfpf_first_tlv first_tlv;

	struct vf_pf_vfdev_info {
#ifndef LINUX_REMOVE
	/* First bit was used on 8.7.x and 8.8.x versions, which had different
	 * FWs used but with the same faspath HSI. As this was prior to the
	 * fastpath versioning, wanted to have ability to override fw matching
	 * and allow them to interact.
	 */
#endif
/* VF pre-FP hsi version */
#define VFPF_ACQUIRE_CAP_PRE_FP_HSI	(1 << 0)
#define VFPF_ACQUIRE_CAP_100G		(1 << 1) /* VF can support 100g */

	/* A requirement for supporting multi-Tx queues on a single queue-zone,
	 * VF would pass qids as additional information whenever passing queue
	 * references.
	 * TODO - due to the CID limitations in Bar0, VFs currently don't pass
	 * this, and use the legacy CID scheme.
	 */
#define VFPF_ACQUIRE_CAP_QUEUE_QIDS	(1 << 2)

	/* The VF is using the physical bar. While this is mostly internal
	 * to the VF, might affect the number of CIDs supported assuming
	 * QUEUE_QIDS is set.
	 */
#define VFPF_ACQUIRE_CAP_PHYSICAL_BAR	(1 << 3)
		u64 capabilities;
		u8 fw_major;
		u8 fw_minor;
		u8 fw_revision;
		u8 fw_engineering;
		u32 driver_version;
		u16 opaque_fid; /* ME register value */
		u8 os_type; /* VFPF_ACQUIRE_OS_* value */
		u8 eth_fp_hsi_major;
		u8 eth_fp_hsi_minor;
		u8 padding[3];
	} vfdev_info;

	struct vf_pf_resc_request resc_request;

	u64 bulletin_addr;
	u32 bulletin_size;
	u32 padding;
};

/* receive side scaling tlv */
struct vfpf_vport_update_rss_tlv {
	struct channel_tlv	tl;

	u8 update_rss_flags;
	#define VFPF_UPDATE_RSS_CONFIG_FLAG	  (1 << 0)
	#define VFPF_UPDATE_RSS_CAPS_FLAG	  (1 << 1)
	#define VFPF_UPDATE_RSS_IND_TABLE_FLAG	  (1 << 2)
	#define VFPF_UPDATE_RSS_KEY_FLAG	  (1 << 3)

	u8 rss_enable;
	u8 rss_caps;
	u8 rss_table_size_log; /* The table size is 2 ^ rss_table_size_log */
	u16 rss_ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
	u32 rss_key[T_ETH_RSS_KEY_SIZE];
};

struct pfvf_storm_stats {
	u32 address;
	u32 len;
};

struct pfvf_stats_info {
	struct pfvf_storm_stats mstats;
	struct pfvf_storm_stats pstats;
	struct pfvf_storm_stats tstats;
	struct pfvf_storm_stats ustats;
};

/* acquire response tlv - carries the allocated resources */
struct pfvf_acquire_resp_tlv {
	struct pfvf_tlv hdr;

	struct pf_vf_pfdev_info {
		u32 chip_num;
		u32 mfw_ver;

		u16 fw_major;
		u16 fw_minor;
		u16 fw_rev;
		u16 fw_eng;

		u64 capabilities;
#define PFVF_ACQUIRE_CAP_DEFAULT_UNTAGGED	(1 << 0)
#define PFVF_ACQUIRE_CAP_100G			(1 << 1) /* If set, 100g PF */
/* There are old PF versions where the PF might mistakenly override the sanity
 * mechanism [version-based] and allow a VF that can't be supported to pass
 * the acquisition phase.
 * To overcome this, PFs now indicate that they're past that point and the new
 * VFs would fail probe on the older PFs that fail to do so.
 */
#ifndef LINUX_REMOVE
/* Said bug was in quest/serpens; Can't be certain no official release included
 * the bug since the fix arrived very late in the programs.
 */
#endif
#define PFVF_ACQUIRE_CAP_POST_FW_OVERRIDE	(1 << 2)

	/* PF expects queues to be received with additional qids */
#define PFVF_ACQUIRE_CAP_QUEUE_QIDS		(1 << 3)

		u16 db_size;
		u8  indices_per_sb;
		u8 os_type;

		/* These should match the PF's ecore_dev values */
		u16 chip_rev;
		u8 dev_type;

		/* Doorbell bar size configured in HW: log(size) or 0 */
		u8 bar_size;

		struct pfvf_stats_info stats_info;

		u8 port_mac[ETH_ALEN];

		/* It's possible PF had to configure an older fastpath HSI
		 * [in case VF is newer than PF]. This is communicated back
		 * to the VF. It can also be used in case of error due to
		 * non-matching versions to shed light in VF about failure.
		 */
		u8 major_fp_hsi;
		u8 minor_fp_hsi;
	} pfdev_info;

	struct pf_vf_resc {
		/* in case of status NO_RESOURCE in message hdr, pf will fill
		 * this struct with suggested amount of resources for next
		 * acquire request
		 */
		#define PFVF_MAX_QUEUES_PER_VF         16
		#define PFVF_MAX_SBS_PER_VF            16
		struct hw_sb_info hw_sbs[PFVF_MAX_SBS_PER_VF];
		u8      hw_qid[PFVF_MAX_QUEUES_PER_VF];
		u8      cid[PFVF_MAX_QUEUES_PER_VF];

		u8      num_rxqs;
		u8      num_txqs;
		u8      num_sbs;
		u8      num_mac_filters;
		u8      num_vlan_filters;
		u8      num_mc_filters;
		u8	num_cids;
		u8      padding;
	} resc;

	u32 bulletin_size;
	u32 padding;
};

struct pfvf_start_queue_resp_tlv {
	struct pfvf_tlv hdr;
	u32 offset; /* offset to consumer/producer of queue */
	u8 padding[4];
};

/* Extended queue information - additional index for reference inside qzone.
 * If commmunicated between VF/PF, each TLV relating to queues should be
 * extended by one such [or have a future base TLV that already contains info].
 */
struct vfpf_qid_tlv {
	struct channel_tlv	tl;
	u8			qid;
	u8			padding[3];
};

/* Setup Queue */
struct vfpf_start_rxq_tlv {
	struct vfpf_first_tlv	first_tlv;

	/* physical addresses */
	u64		rxq_addr;
	u64		deprecated_sge_addr;
	u64		cqe_pbl_addr;

	u16			cqe_pbl_size;
	u16			hw_sb;
	u16			rx_qid;
	u16			hc_rate; /* desired interrupts per sec. */

	u16			bd_max_bytes;
	u16			stat_id;
	u8			sb_index;
	u8			padding[3];

};

struct vfpf_start_txq_tlv {
	struct vfpf_first_tlv	first_tlv;

	/* physical addresses */
	u64		pbl_addr;
	u16			pbl_size;
	u16			stat_id;
	u16			tx_qid;
	u16			hw_sb;

	u32			flags; /* VFPF_QUEUE_FLG_X flags */
	u16			hc_rate; /* desired interrupts per sec. */
	u8			sb_index;
	u8			padding[3];
};

/* Stop RX Queue */
struct vfpf_stop_rxqs_tlv {
	struct vfpf_first_tlv	first_tlv;

	u16			rx_qid;

	/* While the API supports multiple Rx-queues on a single TLV
	 * message, in practice older VFs always used it as one [ecore].
	 * And there are PFs [starting with the CHANNEL_TLV_QID] which
	 * would start assuming this is always a '1'. So in practice this
	 * field should be considered deprecated and *Always* set to '1'.
	 */
	u8			num_rxqs;

	u8			cqe_completion;
	u8			padding[4];
};

/* Stop TX Queues */
struct vfpf_stop_txqs_tlv {
	struct vfpf_first_tlv	first_tlv;

	u16			tx_qid;

	/* While the API supports multiple Tx-queues on a single TLV
	 * message, in practice older VFs always used it as one [ecore].
	 * And there are PFs [starting with the CHANNEL_TLV_QID] which
	 * would start assuming this is always a '1'. So in practice this
	 * field should be considered deprecated and *Always* set to '1'.
	 */
	u8			num_txqs;
	u8			padding[5];
};

struct vfpf_update_rxq_tlv {
	struct vfpf_first_tlv	first_tlv;

	u64		deprecated_sge_addr[PFVF_MAX_QUEUES_PER_VF];

	u16			rx_qid;
	u8			num_rxqs;
	u8			flags;
	#define VFPF_RXQ_UPD_INIT_SGE_DEPRECATE_FLAG	(1 << 0)
	#define VFPF_RXQ_UPD_COMPLETE_CQE_FLAG		(1 << 1)
	#define VFPF_RXQ_UPD_COMPLETE_EVENT_FLAG	(1 << 2)

	u8			padding[4];
};

/* Set Queue Filters */
struct vfpf_q_mac_vlan_filter {
	u32 flags;
	#define VFPF_Q_FILTER_DEST_MAC_VALID    0x01
	#define VFPF_Q_FILTER_VLAN_TAG_VALID    0x02
	#define VFPF_Q_FILTER_SET_MAC		0x100   /* set/clear */

	u8  mac[ETH_ALEN];
	u16 vlan_tag;

	u8	padding[4];
};

/* Start a vport */
struct vfpf_vport_start_tlv {
	struct vfpf_first_tlv	first_tlv;

	u64		sb_addr[PFVF_MAX_SBS_PER_VF];

	u32			tpa_mode;
	u16			dep1;
	u16			mtu;

	u8			vport_id;
	u8			inner_vlan_removal;

	u8			only_untagged;
	u8			max_buffers_per_cqe;

	u8			padding[4];
};

/* Extended tlvs - need to add rss, mcast, accept mode tlvs */
struct vfpf_vport_update_activate_tlv {
	struct channel_tlv	tl;
	u8			update_rx;
	u8			update_tx;
	u8			active_rx;
	u8			active_tx;
};

struct vfpf_vport_update_tx_switch_tlv {
	struct channel_tlv	tl;
	u8			tx_switching;
	u8			padding[3];
};

struct vfpf_vport_update_vlan_strip_tlv {
	struct channel_tlv	tl;
	u8			remove_vlan;
	u8			padding[3];
};

struct vfpf_vport_update_mcast_bin_tlv {
	struct channel_tlv	tl;
	u8			padding[4];

	/* This was a mistake; There are only 256 approx bins,
	 * and in HSI they're divided into 32-bit values.
	 * As old VFs used to set-bit to the values on its side,
	 * the upper half of the array is never expected to contain any data.
	 */
	u64		bins[4];
	u64		obsolete_bins[4];
};

struct vfpf_vport_update_accept_param_tlv {
	struct channel_tlv tl;
	u8	update_rx_mode;
	u8	update_tx_mode;
	u8	rx_accept_filter;
	u8	tx_accept_filter;
};

struct vfpf_vport_update_accept_any_vlan_tlv {
	struct channel_tlv tl;
	u8 update_accept_any_vlan_flg;
	u8 accept_any_vlan;

	u8 padding[2];
};

struct vfpf_vport_update_sge_tpa_tlv {
	struct channel_tlv	tl;

	u16			sge_tpa_flags;
	#define VFPF_TPA_IPV4_EN_FLAG	     (1 << 0)
	#define VFPF_TPA_IPV6_EN_FLAG        (1 << 1)
	#define VFPF_TPA_PKT_SPLIT_FLAG      (1 << 2)
	#define VFPF_TPA_HDR_DATA_SPLIT_FLAG (1 << 3)
	#define VFPF_TPA_GRO_CONSIST_FLAG    (1 << 4)
	#define VFPF_TPA_TUNN_IPV4_EN_FLAG   (1 << 5)
	#define VFPF_TPA_TUNN_IPV6_EN_FLAG   (1 << 6)

	u8			update_sge_tpa_flags;
	#define VFPF_UPDATE_SGE_DEPRECATED_FLAG	   (1 << 0)
	#define VFPF_UPDATE_TPA_EN_FLAG    (1 << 1)
	#define VFPF_UPDATE_TPA_PARAM_FLAG (1 << 2)

	u8			max_buffers_per_cqe;

	u16			deprecated_sge_buff_size;
	u16			tpa_max_size;
	u16			tpa_min_size_to_start;
	u16			tpa_min_size_to_cont;

	u8			tpa_max_aggs_num;
	u8			padding[7];

};

/* Primary tlv as a header for various extended tlvs for
 * various functionalities in vport update ramrod.
 */
struct vfpf_vport_update_tlv {
	struct vfpf_first_tlv first_tlv;
};

struct vfpf_ucast_filter_tlv {
	struct vfpf_first_tlv	first_tlv;

	u8			opcode;
	u8			type;

	u8			mac[ETH_ALEN];

	u16			vlan;
	u16			padding[3];
};

/* tunnel update param tlv */
struct vfpf_update_tunn_param_tlv {
	struct vfpf_first_tlv   first_tlv;

	u8			tun_mode_update_mask;
	u8			tunn_mode;
	u8			update_tun_cls;
	u8			vxlan_clss;
	u8			l2gre_clss;
	u8			ipgre_clss;
	u8			l2geneve_clss;
	u8			ipgeneve_clss;
	u8			update_geneve_port;
	u8			update_vxlan_port;
	u16			geneve_port;
	u16			vxlan_port;
	u8			padding[2];
};

struct pfvf_update_tunn_param_tlv {
	struct pfvf_tlv hdr;

	u16			tunn_feature_mask;
	u8			vxlan_mode;
	u8			l2geneve_mode;
	u8			ipgeneve_mode;
	u8			l2gre_mode;
	u8			ipgre_mode;
	u8			vxlan_clss;
	u8			l2gre_clss;
	u8			ipgre_clss;
	u8			l2geneve_clss;
	u8			ipgeneve_clss;
	u16			vxlan_udp_port;
	u16			geneve_udp_port;
};

struct tlv_buffer_size {
	u8 tlv_buffer[TLV_BUFFER_SIZE];
};

struct vfpf_update_coalesce {
	struct vfpf_first_tlv first_tlv;
	u16 rx_coal;
	u16 tx_coal;
	u16 qid;
	u8 padding[2];
};

struct vfpf_read_coal_req_tlv {
	struct vfpf_first_tlv first_tlv;
	u16 qid;
	u8 is_rx;
	u8 padding[5];
};

struct pfvf_read_coal_resp_tlv {
	struct pfvf_tlv hdr;
	u16 coal;
	u8 padding[6];
};

struct vfpf_bulletin_update_mac_tlv {
	struct vfpf_first_tlv first_tlv;
	u8 mac[ETH_ALEN];
	u8 padding[2];
};

struct vfpf_update_mtu_tlv {
	struct vfpf_first_tlv first_tlv;
	u16 mtu;
	u8 padding[6];
};

union vfpf_tlvs {
	struct vfpf_first_tlv			first_tlv;
	struct vfpf_acquire_tlv			acquire;
	struct vfpf_start_rxq_tlv		start_rxq;
	struct vfpf_start_txq_tlv		start_txq;
	struct vfpf_stop_rxqs_tlv		stop_rxqs;
	struct vfpf_stop_txqs_tlv		stop_txqs;
	struct vfpf_update_rxq_tlv		update_rxq;
	struct vfpf_vport_start_tlv		start_vport;
	struct vfpf_vport_update_tlv		vport_update;
	struct vfpf_ucast_filter_tlv		ucast_filter;
	struct vfpf_update_tunn_param_tlv	tunn_param_update;
	struct vfpf_update_coalesce		update_coalesce;
	struct vfpf_read_coal_req_tlv		read_coal_req;
	struct vfpf_bulletin_update_mac_tlv	bulletin_update_mac;
	struct vfpf_update_mtu_tlv		update_mtu;
	struct tlv_buffer_size			tlv_buf_size;
};

union pfvf_tlvs {
	struct pfvf_def_resp_tlv		default_resp;
	struct pfvf_acquire_resp_tlv		acquire_resp;
	struct tlv_buffer_size			tlv_buf_size;
	struct pfvf_start_queue_resp_tlv	queue_start;
	struct pfvf_update_tunn_param_tlv	tunn_param_resp;
	struct pfvf_read_coal_resp_tlv		read_coal_resp;
};

/* This is a structure which is allocated in the VF, which the PF may update
 * when it deems it necessary to do so. The bulletin board is sampled
 * periodically by the VF. A copy per VF is maintained in the PF (to prevent
 * loss of data upon multiple updates (or the need for read modify write)).
 */
enum ecore_bulletin_bit {
	/* Alert the VF that a forced MAC was set by the PF */
	MAC_ADDR_FORCED = 0,

	/* The VF should not access the vfpf channel */
	VFPF_CHANNEL_INVALID = 1,

	/* Alert the VF that a forced VLAN was set by the PF */
	VLAN_ADDR_FORCED = 2,

	/* Indicate that `default_only_untagged' contains actual data */
	VFPF_BULLETIN_UNTAGGED_DEFAULT = 3,
	VFPF_BULLETIN_UNTAGGED_DEFAULT_FORCED = 4,

	/* Alert the VF that suggested mac was sent by the PF.
	 * MAC_ADDR will be disabled in case MAC_ADDR_FORCED is set
	 */
	VFPF_BULLETIN_MAC_ADDR = 5
};

struct ecore_bulletin_content {
	/* crc of structure to ensure is not in mid-update */
	u32 crc;

	u32 version;

	/* bitmap indicating which fields hold valid values */
	u64 valid_bitmap;

	/* used for MAC_ADDR or MAC_ADDR_FORCED */
	u8 mac[ETH_ALEN];

	/* If valid, 1 => only untagged Rx if no vlan is configured */
	u8 default_only_untagged;
	u8 padding;

	/* The following is a 'copy' of ecore_mcp_link_state,
	 * ecore_mcp_link_params and ecore_mcp_link_capabilities. Since it's
	 * possible the structs will increase further along the road we cannot
	 * have it here; Instead we need to have all of its fields.
	 */
	u8 req_autoneg;
	u8 req_autoneg_pause;
	u8 req_forced_rx;
	u8 req_forced_tx;
	u8 padding2[4];

	u32 req_adv_speed;
	u32 req_forced_speed;
	u32 req_loopback;
	u32 padding3;

	u8 link_up;
	u8 full_duplex;
	u8 autoneg;
	u8 autoneg_complete;
	u8 parallel_detection;
	u8 pfc_enabled;
	u8 partner_tx_flow_ctrl_en;
	u8 partner_rx_flow_ctrl_en;

	u8 partner_adv_pause;
	u8 sfp_tx_fault;
	u16 vxlan_udp_port;
	u16 geneve_udp_port;
	u8 padding4[2];

	u32 speed;
	u32 partner_adv_speed;

	u32 capability_speed;

	/* Forced vlan */
	u16 pvid;
	u16 padding5;
};

struct ecore_bulletin {
	dma_addr_t phys;
	struct ecore_bulletin_content *p_virt;
	u32 size;
};

enum {
/*!!!!! Make sure to update STRINGS structure accordingly !!!!!*/

	CHANNEL_TLV_NONE, /* ends tlv sequence */
	CHANNEL_TLV_ACQUIRE,
	CHANNEL_TLV_VPORT_START,
	CHANNEL_TLV_VPORT_UPDATE,
	CHANNEL_TLV_VPORT_TEARDOWN,
	CHANNEL_TLV_START_RXQ,
	CHANNEL_TLV_START_TXQ,
	CHANNEL_TLV_STOP_RXQS,
	CHANNEL_TLV_STOP_TXQS,
	CHANNEL_TLV_UPDATE_RXQ,
	CHANNEL_TLV_INT_CLEANUP,
	CHANNEL_TLV_CLOSE,
	CHANNEL_TLV_RELEASE,
	CHANNEL_TLV_LIST_END,
	CHANNEL_TLV_UCAST_FILTER,
	CHANNEL_TLV_VPORT_UPDATE_ACTIVATE,
	CHANNEL_TLV_VPORT_UPDATE_TX_SWITCH,
	CHANNEL_TLV_VPORT_UPDATE_VLAN_STRIP,
	CHANNEL_TLV_VPORT_UPDATE_MCAST,
	CHANNEL_TLV_VPORT_UPDATE_ACCEPT_PARAM,
	CHANNEL_TLV_VPORT_UPDATE_RSS,
	CHANNEL_TLV_VPORT_UPDATE_ACCEPT_ANY_VLAN,
	CHANNEL_TLV_VPORT_UPDATE_SGE_TPA,
	CHANNEL_TLV_UPDATE_TUNN_PARAM,
	CHANNEL_TLV_COALESCE_UPDATE,
	CHANNEL_TLV_QID,
	CHANNEL_TLV_COALESCE_READ,
	CHANNEL_TLV_BULLETIN_UPDATE_MAC,
	CHANNEL_TLV_UPDATE_MTU,
	CHANNEL_TLV_MAX,

	/* Required for iterating over vport-update tlvs.
	 * Will break in case non-sequential vport-update tlvs.
	 */
	CHANNEL_TLV_VPORT_UPDATE_MAX = CHANNEL_TLV_VPORT_UPDATE_SGE_TPA + 1,

/*!!!!! Make sure to update STRINGS structure accordingly !!!!!*/
};
extern const char *qede_ecore_channel_tlvs_string[];

#endif /* __ECORE_VF_PF_IF_H__ */
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
11fdf7f2 TL	2	* Copyright (c) 2016 - 2018 Cavium Inc.
7c673cae	3	* All rights reserved.
11fdf7f2	4	* www.cavium.com
7c673cae FG	5	*/
	6
	7	#ifndef __ECORE_VF_PF_IF_H__
	8	#define __ECORE_VF_PF_IF_H__
	9
	10	/* @@@ TBD MichalK this should be HSI? */
	11	#define T_ETH_INDIRECTION_TABLE_SIZE 128
	12	#define T_ETH_RSS_KEY_SIZE 10 /* @@@ TBD this should be HSI? */
	13
	14	/***********************************************
	15	*
	16	* Common definitions for all HVs
	17	*
	18	**/
	19	struct vf_pf_resc_request {
11fdf7f2 TL	20	u8 num_rxqs;
	21	u8 num_txqs;
	22	u8 num_sbs;
	23	u8 num_mac_filters;
	24	u8 num_vlan_filters;
	25	u8 num_mc_filters; /* No limit so superfluous */
	26	u8 num_cids;
	27	u8 padding;
7c673cae FG	28	};
	29
	30	struct hw_sb_info {
	31	u16 hw_sb_id; /* aka absolute igu id, used to ack the sb */
	32	u8 sb_qid; /* used to update DHC for sb */
	33	u8 padding[5];
	34	};
	35
	36	/***********************************************
	37	*
	38	* HW VF-PF channel definitions
	39	*
	40	* A.K.A VF-PF mailbox
	41	*
	42	**/
	43	#define TLV_BUFFER_SIZE 1024
	44
	45	/* vf pf channel tlvs */
	46	/* general tlv header (used for both vf->pf request and pf->vf response) */
	47	struct channel_tlv {
	48	u16 type;
	49	u16 length;
	50	};
	51
	52	/* header of first vf->pf tlv carries the offset used to calculate response
	53	* buffer address
	54	*/
	55	struct vfpf_first_tlv {
	56	struct channel_tlv tl;
	57	u32 padding;
	58	u64 reply_address;
	59	};
	60
	61	/* header of pf->vf tlvs, carries the status of handling the request */
	62	struct pfvf_tlv {
	63	struct channel_tlv tl;
	64	u8 status;
	65	u8 padding[3];
	66	};
	67
	68	/* response tlv used for most tlvs */
	69	struct pfvf_def_resp_tlv {
	70	struct pfvf_tlv hdr;
	71	};
	72
	73	/* used to terminate and pad a tlv list */
	74	struct channel_list_end_tlv {
	75	struct channel_tlv tl;
	76	u8 padding[4];
	77	};
	78
	79	/* Acquire */
	80	struct vfpf_acquire_tlv {
	81	struct vfpf_first_tlv first_tlv;
	82
	83	struct vf_pf_vfdev_info {
	84	#ifndef LINUX_REMOVE
	85	/* First bit was used on 8.7.x and 8.8.x versions, which had different
	86	* FWs used but with the same faspath HSI. As this was prior to the
	87	* fastpath versioning, wanted to have ability to override fw matching
	88	* and allow them to interact.
	89	*/
	90	#endif
	91	/* VF pre-FP hsi version */
92	#define VFPF_ACQUIRE_CAP_PRE_FP_HSI (1 << 0)
93	#define VFPF_ACQUIRE_CAP_100G (1 << 1) /* VF can support 100g */
11fdf7f2 TL	94
	95	/* A requirement for supporting multi-Tx queues on a single queue-zone,
	96	* VF would pass qids as additional information whenever passing queue
	97	* references.
	98	* TODO - due to the CID limitations in Bar0, VFs currently don't pass
	99	* this, and use the legacy CID scheme.
	100	*/
	101	#define VFPF_ACQUIRE_CAP_QUEUE_QIDS (1 << 2)
	102
	103	/* The VF is using the physical bar. While this is mostly internal
	104	* to the VF, might affect the number of CIDs supported assuming
	105	* QUEUE_QIDS is set.
	106	*/
	107	#define VFPF_ACQUIRE_CAP_PHYSICAL_BAR (1 << 3)
7c673cae FG	108	u64 capabilities;
	109	u8 fw_major;
	110	u8 fw_minor;
	111	u8 fw_revision;
	112	u8 fw_engineering;
	113	u32 driver_version;
	114	u16 opaque_fid; /* ME register value */
	115	u8 os_type; /* VFPF_ACQUIRE_OS_* value */
	116	u8 eth_fp_hsi_major;
	117	u8 eth_fp_hsi_minor;
	118	u8 padding[3];
	119	} vfdev_info;
	120
	121	struct vf_pf_resc_request resc_request;
	122
	123	u64 bulletin_addr;
	124	u32 bulletin_size;
	125	u32 padding;
	126	};
	127
	128	/* receive side scaling tlv */
	129	struct vfpf_vport_update_rss_tlv {
	130	struct channel_tlv tl;
	131
	132	u8 update_rss_flags;
	133	#define VFPF_UPDATE_RSS_CONFIG_FLAG (1 << 0)
	134	#define VFPF_UPDATE_RSS_CAPS_FLAG (1 << 1)
	135	#define VFPF_UPDATE_RSS_IND_TABLE_FLAG (1 << 2)
	136	#define VFPF_UPDATE_RSS_KEY_FLAG (1 << 3)
	137
	138	u8 rss_enable;
	139	u8 rss_caps;
	140	u8 rss_table_size_log; /* The table size is 2 ^ rss_table_size_log */
	141	u16 rss_ind_table[T_ETH_INDIRECTION_TABLE_SIZE];
	142	u32 rss_key[T_ETH_RSS_KEY_SIZE];
	143	};
	144
	145	struct pfvf_storm_stats {
	146	u32 address;
	147	u32 len;
	148	};
	149
	150	struct pfvf_stats_info {
	151	struct pfvf_storm_stats mstats;
	152	struct pfvf_storm_stats pstats;
	153	struct pfvf_storm_stats tstats;
	154	struct pfvf_storm_stats ustats;
	155	};
	156
	157	/* acquire response tlv - carries the allocated resources */
	158	struct pfvf_acquire_resp_tlv {
	159	struct pfvf_tlv hdr;
	160
	161	struct pf_vf_pfdev_info {
	162	u32 chip_num;
	163	u32 mfw_ver;
	164
	165	u16 fw_major;
	166	u16 fw_minor;
	167	u16 fw_rev;
	168	u16 fw_eng;
	169
	170	u64 capabilities;
	171	#define PFVF_ACQUIRE_CAP_DEFAULT_UNTAGGED (1 << 0)
172	#define PFVF_ACQUIRE_CAP_100G (1 << 1) /* If set, 100g PF */
173	/* There are old PF versions where the PF might mistakenly override the sanity
174	* mechanism [version-based] and allow a VF that can't be supported to pass
175	* the acquisition phase.
176	* To overcome this, PFs now indicate that they're past that point and the new
177	* VFs would fail probe on the older PFs that fail to do so.
178	*/
179	#ifndef LINUX_REMOVE
180	/* Said bug was in quest/serpens; Can't be certain no official release included
181	* the bug since the fix arrived very late in the programs.
182	*/
183	#endif
184	#define PFVF_ACQUIRE_CAP_POST_FW_OVERRIDE (1 << 2)
185
11fdf7f2 TL	186	/* PF expects queues to be received with additional qids */
	187	#define PFVF_ACQUIRE_CAP_QUEUE_QIDS (1 << 3)
	188
7c673cae FG	189	u16 db_size;
	190	u8 indices_per_sb;
	191	u8 os_type;
	192
	193	/* These should match the PF's ecore_dev values */
	194	u16 chip_rev;
	195	u8 dev_type;
	196
11fdf7f2 TL	197	/* Doorbell bar size configured in HW: log(size) or 0 */
11fdf7f2 TL	198	u8 bar_size;
7c673cae FG	199
	200	struct pfvf_stats_info stats_info;
	201
	202	u8 port_mac[ETH_ALEN];
	203
	204	/* It's possible PF had to configure an older fastpath HSI
	205	* [in case VF is newer than PF]. This is communicated back
	206	* to the VF. It can also be used in case of error due to
	207	* non-matching versions to shed light in VF about failure.
	208	*/
	209	u8 major_fp_hsi;
	210	u8 minor_fp_hsi;
	211	} pfdev_info;
	212
	213	struct pf_vf_resc {
	214	/* in case of status NO_RESOURCE in message hdr, pf will fill
	215	* this struct with suggested amount of resources for next
	216	* acquire request
	217	*/
	218	#define PFVF_MAX_QUEUES_PER_VF 16
	219	#define PFVF_MAX_SBS_PER_VF 16
	220	struct hw_sb_info hw_sbs[PFVF_MAX_SBS_PER_VF];
	221	u8 hw_qid[PFVF_MAX_QUEUES_PER_VF];
	222	u8 cid[PFVF_MAX_QUEUES_PER_VF];
	223
	224	u8 num_rxqs;
	225	u8 num_txqs;
	226	u8 num_sbs;
	227	u8 num_mac_filters;
	228	u8 num_vlan_filters;
	229	u8 num_mc_filters;
11fdf7f2 TL	230	u8 num_cids;
11fdf7f2 TL	231	u8 padding;
7c673cae FG	232	} resc;
	233
	234	u32 bulletin_size;
	235	u32 padding;
	236	};
	237
	238	struct pfvf_start_queue_resp_tlv {
	239	struct pfvf_tlv hdr;
	240	u32 offset; /* offset to consumer/producer of queue */
	241	u8 padding[4];
	242	};
	243
11fdf7f2 TL	244	/* Extended queue information - additional index for reference inside qzone.
	245	* If commmunicated between VF/PF, each TLV relating to queues should be
	246	* extended by one such [or have a future base TLV that already contains info].
	247	*/
	248	struct vfpf_qid_tlv {
	249	struct channel_tlv tl;
	250	u8 qid;
	251	u8 padding[3];
	252	};
	253
7c673cae FG	254	/* Setup Queue */
	255	struct vfpf_start_rxq_tlv {
	256	struct vfpf_first_tlv first_tlv;
	257
	258	/* physical addresses */
	259	u64 rxq_addr;
	260	u64 deprecated_sge_addr;
	261	u64 cqe_pbl_addr;
	262
	263	u16 cqe_pbl_size;
	264	u16 hw_sb;
	265	u16 rx_qid;
	266	u16 hc_rate; /* desired interrupts per sec. */
	267
	268	u16 bd_max_bytes;
	269	u16 stat_id;
	270	u8 sb_index;
	271	u8 padding[3];
	272
	273	};
	274
	275	struct vfpf_start_txq_tlv {
	276	struct vfpf_first_tlv first_tlv;
	277
	278	/* physical addresses */
	279	u64 pbl_addr;
	280	u16 pbl_size;
	281	u16 stat_id;
	282	u16 tx_qid;
	283	u16 hw_sb;
	284
	285	u32 flags; /* VFPF_QUEUE_FLG_X flags */
	286	u16 hc_rate; /* desired interrupts per sec. */
	287	u8 sb_index;
	288	u8 padding[3];
	289	};
	290
	291	/* Stop RX Queue */
	292	struct vfpf_stop_rxqs_tlv {
	293	struct vfpf_first_tlv first_tlv;
	294
	295	u16 rx_qid;
11fdf7f2 TL	296
	297	/* While the API supports multiple Rx-queues on a single TLV
	298	* message, in practice older VFs always used it as one [ecore].
	299	* And there are PFs [starting with the CHANNEL_TLV_QID] which
	300	* would start assuming this is always a '1'. So in practice this
	301	* field should be considered deprecated and Always set to '1'.
	302	*/
7c673cae	303	u8 num_rxqs;
11fdf7f2	304
7c673cae FG	305	u8 cqe_completion;
	306	u8 padding[4];
	307	};
	308
	309	/* Stop TX Queues */
	310	struct vfpf_stop_txqs_tlv {
	311	struct vfpf_first_tlv first_tlv;
	312
	313	u16 tx_qid;
11fdf7f2 TL	314
	315	/* While the API supports multiple Tx-queues on a single TLV
	316	* message, in practice older VFs always used it as one [ecore].
	317	* And there are PFs [starting with the CHANNEL_TLV_QID] which
	318	* would start assuming this is always a '1'. So in practice this
	319	* field should be considered deprecated and Always set to '1'.
	320	*/
7c673cae FG	321	u8 num_txqs;
	322	u8 padding[5];
	323	};
	324
	325	struct vfpf_update_rxq_tlv {
	326	struct vfpf_first_tlv first_tlv;
	327
	328	u64 deprecated_sge_addr[PFVF_MAX_QUEUES_PER_VF];
	329
	330	u16 rx_qid;
	331	u8 num_rxqs;
	332	u8 flags;
	333	#define VFPF_RXQ_UPD_INIT_SGE_DEPRECATE_FLAG (1 << 0)
	334	#define VFPF_RXQ_UPD_COMPLETE_CQE_FLAG (1 << 1)
	335	#define VFPF_RXQ_UPD_COMPLETE_EVENT_FLAG (1 << 2)
	336
	337	u8 padding[4];
	338	};
	339
	340	/* Set Queue Filters */
	341	struct vfpf_q_mac_vlan_filter {
	342	u32 flags;
	343	#define VFPF_Q_FILTER_DEST_MAC_VALID 0x01
	344	#define VFPF_Q_FILTER_VLAN_TAG_VALID 0x02
	345	#define VFPF_Q_FILTER_SET_MAC 0x100 /* set/clear */
	346
	347	u8 mac[ETH_ALEN];
	348	u16 vlan_tag;
	349
	350	u8 padding[4];
	351	};
	352
	353	/* Start a vport */
	354	struct vfpf_vport_start_tlv {
	355	struct vfpf_first_tlv first_tlv;
	356
	357	u64 sb_addr[PFVF_MAX_SBS_PER_VF];
	358
	359	u32 tpa_mode;
	360	u16 dep1;
	361	u16 mtu;
	362
	363	u8 vport_id;
	364	u8 inner_vlan_removal;
	365
	366	u8 only_untagged;
	367	u8 max_buffers_per_cqe;
	368
	369	u8 padding[4];
	370	};
	371
	372	/* Extended tlvs - need to add rss, mcast, accept mode tlvs */
	373	struct vfpf_vport_update_activate_tlv {
	374	struct channel_tlv tl;
	375	u8 update_rx;
	376	u8 update_tx;
	377	u8 active_rx;
	378	u8 active_tx;
	379	};
	380
	381	struct vfpf_vport_update_tx_switch_tlv {
	382	struct channel_tlv tl;
	383	u8 tx_switching;
	384	u8 padding[3];
385	};
386
387	struct vfpf_vport_update_vlan_strip_tlv {
388	struct channel_tlv tl;
389	u8 remove_vlan;
390	u8 padding[3];
391	};
392
393	struct vfpf_vport_update_mcast_bin_tlv {
394	struct channel_tlv tl;
395	u8 padding[4];
396
11fdf7f2 TL	397	/* This was a mistake; There are only 256 approx bins,
	398	* and in HSI they're divided into 32-bit values.
	399	* As old VFs used to set-bit to the values on its side,
	400	* the upper half of the array is never expected to contain any data.
	401	*/
	402	u64 bins[4];
	403	u64 obsolete_bins[4];
7c673cae FG	404	};
	405
	406	struct vfpf_vport_update_accept_param_tlv {
	407	struct channel_tlv tl;
	408	u8 update_rx_mode;
	409	u8 update_tx_mode;
	410	u8 rx_accept_filter;
	411	u8 tx_accept_filter;
	412	};
	413
	414	struct vfpf_vport_update_accept_any_vlan_tlv {
	415	struct channel_tlv tl;
	416	u8 update_accept_any_vlan_flg;
	417	u8 accept_any_vlan;
	418
	419	u8 padding[2];
	420	};
	421
	422	struct vfpf_vport_update_sge_tpa_tlv {
	423	struct channel_tlv tl;
	424
	425	u16 sge_tpa_flags;
	426	#define VFPF_TPA_IPV4_EN_FLAG (1 << 0)
	427	#define VFPF_TPA_IPV6_EN_FLAG (1 << 1)
	428	#define VFPF_TPA_PKT_SPLIT_FLAG (1 << 2)
	429	#define VFPF_TPA_HDR_DATA_SPLIT_FLAG (1 << 3)
	430	#define VFPF_TPA_GRO_CONSIST_FLAG (1 << 4)
11fdf7f2 TL	431	#define VFPF_TPA_TUNN_IPV4_EN_FLAG (1 << 5)
11fdf7f2 TL	432	#define VFPF_TPA_TUNN_IPV6_EN_FLAG (1 << 6)
7c673cae FG	433
	434	u8 update_sge_tpa_flags;
	435	#define VFPF_UPDATE_SGE_DEPRECATED_FLAG (1 << 0)
	436	#define VFPF_UPDATE_TPA_EN_FLAG (1 << 1)
	437	#define VFPF_UPDATE_TPA_PARAM_FLAG (1 << 2)
	438
	439	u8 max_buffers_per_cqe;
	440
	441	u16 deprecated_sge_buff_size;
	442	u16 tpa_max_size;
	443	u16 tpa_min_size_to_start;
	444	u16 tpa_min_size_to_cont;
	445
	446	u8 tpa_max_aggs_num;
	447	u8 padding[7];
	448
	449	};
	450
	451	/* Primary tlv as a header for various extended tlvs for
	452	* various functionalities in vport update ramrod.
	453	*/
	454	struct vfpf_vport_update_tlv {
	455	struct vfpf_first_tlv first_tlv;
	456	};
	457
	458	struct vfpf_ucast_filter_tlv {
	459	struct vfpf_first_tlv first_tlv;
	460
	461	u8 opcode;
	462	u8 type;
	463
	464	u8 mac[ETH_ALEN];
	465
	466	u16 vlan;
	467	u16 padding[3];
	468	};
	469
11fdf7f2 TL	470	/* tunnel update param tlv */
	471	struct vfpf_update_tunn_param_tlv {
	472	struct vfpf_first_tlv first_tlv;
	473
	474	u8 tun_mode_update_mask;
	475	u8 tunn_mode;
	476	u8 update_tun_cls;
	477	u8 vxlan_clss;
	478	u8 l2gre_clss;
	479	u8 ipgre_clss;
	480	u8 l2geneve_clss;
	481	u8 ipgeneve_clss;
	482	u8 update_geneve_port;
	483	u8 update_vxlan_port;
	484	u16 geneve_port;
	485	u16 vxlan_port;
	486	u8 padding[2];
	487	};
	488
	489	struct pfvf_update_tunn_param_tlv {
	490	struct pfvf_tlv hdr;
	491
	492	u16 tunn_feature_mask;
	493	u8 vxlan_mode;
	494	u8 l2geneve_mode;
	495	u8 ipgeneve_mode;
	496	u8 l2gre_mode;
	497	u8 ipgre_mode;
	498	u8 vxlan_clss;
	499	u8 l2gre_clss;
	500	u8 ipgre_clss;
	501	u8 l2geneve_clss;
	502	u8 ipgeneve_clss;
	503	u16 vxlan_udp_port;
	504	u16 geneve_udp_port;
	505	};
	506
7c673cae FG	507	struct tlv_buffer_size {
	508	u8 tlv_buffer[TLV_BUFFER_SIZE];
	509	};
	510
11fdf7f2 TL	511	struct vfpf_update_coalesce {
	512	struct vfpf_first_tlv first_tlv;
	513	u16 rx_coal;
	514	u16 tx_coal;
	515	u16 qid;
	516	u8 padding[2];
	517	};
	518
	519	struct vfpf_read_coal_req_tlv {
	520	struct vfpf_first_tlv first_tlv;
	521	u16 qid;
	522	u8 is_rx;
	523	u8 padding[5];
	524	};
	525
	526	struct pfvf_read_coal_resp_tlv {
	527	struct pfvf_tlv hdr;
	528	u16 coal;
	529	u8 padding[6];
	530	};
	531
	532	struct vfpf_bulletin_update_mac_tlv {
	533	struct vfpf_first_tlv first_tlv;
	534	u8 mac[ETH_ALEN];
	535	u8 padding[2];
	536	};
	537
	538	struct vfpf_update_mtu_tlv {
	539	struct vfpf_first_tlv first_tlv;
	540	u16 mtu;
	541	u8 padding[6];
	542	};
	543
7c673cae FG	544	union vfpf_tlvs {
	545	struct vfpf_first_tlv first_tlv;
	546	struct vfpf_acquire_tlv acquire;
	547	struct vfpf_start_rxq_tlv start_rxq;
	548	struct vfpf_start_txq_tlv start_txq;
	549	struct vfpf_stop_rxqs_tlv stop_rxqs;
	550	struct vfpf_stop_txqs_tlv stop_txqs;
	551	struct vfpf_update_rxq_tlv update_rxq;
	552	struct vfpf_vport_start_tlv start_vport;
	553	struct vfpf_vport_update_tlv vport_update;
	554	struct vfpf_ucast_filter_tlv ucast_filter;
11fdf7f2 TL	555	struct vfpf_update_tunn_param_tlv tunn_param_update;
	556	struct vfpf_update_coalesce update_coalesce;
	557	struct vfpf_read_coal_req_tlv read_coal_req;
	558	struct vfpf_bulletin_update_mac_tlv bulletin_update_mac;
	559	struct vfpf_update_mtu_tlv update_mtu;
7c673cae FG	560	struct tlv_buffer_size tlv_buf_size;
	561	};
	562
	563	union pfvf_tlvs {
	564	struct pfvf_def_resp_tlv default_resp;
	565	struct pfvf_acquire_resp_tlv acquire_resp;
	566	struct tlv_buffer_size tlv_buf_size;
	567	struct pfvf_start_queue_resp_tlv queue_start;
11fdf7f2 TL	568	struct pfvf_update_tunn_param_tlv tunn_param_resp;
11fdf7f2 TL	569	struct pfvf_read_coal_resp_tlv read_coal_resp;
7c673cae FG	570	};
	571
	572	/* This is a structure which is allocated in the VF, which the PF may update
	573	* when it deems it necessary to do so. The bulletin board is sampled
	574	* periodically by the VF. A copy per VF is maintained in the PF (to prevent
	575	* loss of data upon multiple updates (or the need for read modify write)).
	576	*/
	577	enum ecore_bulletin_bit {
	578	/* Alert the VF that a forced MAC was set by the PF */
	579	MAC_ADDR_FORCED = 0,
	580
	581	/* The VF should not access the vfpf channel */
	582	VFPF_CHANNEL_INVALID = 1,
	583
	584	/* Alert the VF that a forced VLAN was set by the PF */
	585	VLAN_ADDR_FORCED = 2,
	586
	587	/* Indicate that `default_only_untagged' contains actual data */
	588	VFPF_BULLETIN_UNTAGGED_DEFAULT = 3,
	589	VFPF_BULLETIN_UNTAGGED_DEFAULT_FORCED = 4,
	590
	591	/* Alert the VF that suggested mac was sent by the PF.
	592	* MAC_ADDR will be disabled in case MAC_ADDR_FORCED is set
	593	*/
	594	VFPF_BULLETIN_MAC_ADDR = 5
	595	};
	596
	597	struct ecore_bulletin_content {
	598	/* crc of structure to ensure is not in mid-update */
	599	u32 crc;
	600
	601	u32 version;
	602
	603	/* bitmap indicating which fields hold valid values */
	604	u64 valid_bitmap;
	605
	606	/* used for MAC_ADDR or MAC_ADDR_FORCED */
	607	u8 mac[ETH_ALEN];
	608
	609	/* If valid, 1 => only untagged Rx if no vlan is configured */
	610	u8 default_only_untagged;
	611	u8 padding;
	612
	613	/* The following is a 'copy' of ecore_mcp_link_state,
	614	* ecore_mcp_link_params and ecore_mcp_link_capabilities. Since it's
	615	* possible the structs will increase further along the road we cannot
	616	* have it here; Instead we need to have all of its fields.
	617	*/
	618	u8 req_autoneg;
	619	u8 req_autoneg_pause;
	620	u8 req_forced_rx;
	621	u8 req_forced_tx;
	622	u8 padding2[4];
	623
	624	u32 req_adv_speed;
	625	u32 req_forced_speed;
	626	u32 req_loopback;
	627	u32 padding3;
	628
	629	u8 link_up;
	630	u8 full_duplex;
	631	u8 autoneg;
	632	u8 autoneg_complete;
	633	u8 parallel_detection;
634	u8 pfc_enabled;
635	u8 partner_tx_flow_ctrl_en;
636	u8 partner_rx_flow_ctrl_en;
11fdf7f2	637
7c673cae FG	638	u8 partner_adv_pause;
7c673cae FG	639	u8 sfp_tx_fault;
11fdf7f2 TL	640	u16 vxlan_udp_port;
	641	u16 geneve_udp_port;
	642	u8 padding4[2];
7c673cae FG	643
	644	u32 speed;
	645	u32 partner_adv_speed;
	646
	647	u32 capability_speed;
	648
	649	/* Forced vlan */
	650	u16 pvid;
	651	u16 padding5;
	652	};
	653
	654	struct ecore_bulletin {
	655	dma_addr_t phys;
	656	struct ecore_bulletin_content *p_virt;
	657	u32 size;
	658	};
	659
	660	enum {
	661	/!!!!! Make sure to update STRINGS structure accordingly !!!!!/
	662
	663	CHANNEL_TLV_NONE, /* ends tlv sequence */
	664	CHANNEL_TLV_ACQUIRE,
	665	CHANNEL_TLV_VPORT_START,
	666	CHANNEL_TLV_VPORT_UPDATE,
	667	CHANNEL_TLV_VPORT_TEARDOWN,
	668	CHANNEL_TLV_START_RXQ,
	669	CHANNEL_TLV_START_TXQ,
	670	CHANNEL_TLV_STOP_RXQS,
	671	CHANNEL_TLV_STOP_TXQS,
	672	CHANNEL_TLV_UPDATE_RXQ,
	673	CHANNEL_TLV_INT_CLEANUP,
	674	CHANNEL_TLV_CLOSE,
	675	CHANNEL_TLV_RELEASE,
	676	CHANNEL_TLV_LIST_END,
	677	CHANNEL_TLV_UCAST_FILTER,
	678	CHANNEL_TLV_VPORT_UPDATE_ACTIVATE,
	679	CHANNEL_TLV_VPORT_UPDATE_TX_SWITCH,
	680	CHANNEL_TLV_VPORT_UPDATE_VLAN_STRIP,
	681	CHANNEL_TLV_VPORT_UPDATE_MCAST,
	682	CHANNEL_TLV_VPORT_UPDATE_ACCEPT_PARAM,
	683	CHANNEL_TLV_VPORT_UPDATE_RSS,
	684	CHANNEL_TLV_VPORT_UPDATE_ACCEPT_ANY_VLAN,
	685	CHANNEL_TLV_VPORT_UPDATE_SGE_TPA,
11fdf7f2 TL	686	CHANNEL_TLV_UPDATE_TUNN_PARAM,
	687	CHANNEL_TLV_COALESCE_UPDATE,
	688	CHANNEL_TLV_QID,
	689	CHANNEL_TLV_COALESCE_READ,
	690	CHANNEL_TLV_BULLETIN_UPDATE_MAC,
	691	CHANNEL_TLV_UPDATE_MTU,
7c673cae FG	692	CHANNEL_TLV_MAX,
	693
	694	/* Required for iterating over vport-update tlvs.
	695	* Will break in case non-sequential vport-update tlvs.
	696	*/
	697	CHANNEL_TLV_VPORT_UPDATE_MAX = CHANNEL_TLV_VPORT_UPDATE_SGE_TPA + 1,
	698
	699	/!!!!! Make sure to update STRINGS structure accordingly !!!!!/
	700	};
9f95a23c	701	extern const char *qede_ecore_channel_tlvs_string[];
7c673cae FG	702
7c673cae FG	703	#endif /* __ECORE_VF_PF_IF_H__ */