xref: /linux/drivers/scsi/elx/libefc_sli/sli4.h (revision 0be3ff0c)

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2021 Broadcom. All Rights Reserved. The term
 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
 *
 */

/*
 * All common SLI-4 structures and function prototypes.
 */

#ifndef _SLI4_H
#define _SLI4_H

#include <linux/pci.h>
#include <linux/delay.h>
#include "scsi/fc/fc_els.h"
#include "scsi/fc/fc_fs.h"
#include "../include/efc_common.h"

/*************************************************************************
 * Common SLI-4 register offsets and field definitions
 */

/* SLI_INTF - SLI Interface Definition Register */
#define SLI4_INTF_REG			0x0058
enum sli4_intf {
	SLI4_INTF_REV_SHIFT		= 4,
	SLI4_INTF_REV_MASK		= 0xf0,

	SLI4_INTF_REV_S3		= 0x30,
	SLI4_INTF_REV_S4		= 0x40,

	SLI4_INTF_FAMILY_SHIFT		= 8,
	SLI4_INTF_FAMILY_MASK		= 0x0f00,

	SLI4_FAMILY_CHECK_ASIC_TYPE	= 0x0f00,

	SLI4_INTF_IF_TYPE_SHIFT		= 12,
	SLI4_INTF_IF_TYPE_MASK		= 0xf000,

	SLI4_INTF_IF_TYPE_2		= 0x2000,
	SLI4_INTF_IF_TYPE_6		= 0x6000,

	SLI4_INTF_VALID_SHIFT		= 29,
	SLI4_INTF_VALID_MASK		= 0xe0000000,

	SLI4_INTF_VALID_VALUE		= 0xc0000000,
};

/* ASIC_ID - SLI ASIC Type and Revision Register */
#define SLI4_ASIC_ID_REG	0x009c
enum sli4_asic {
	SLI4_ASIC_GEN_SHIFT	= 8,
	SLI4_ASIC_GEN_MASK	= 0xff00,
	SLI4_ASIC_GEN_5		= 0x0b00,
	SLI4_ASIC_GEN_6		= 0x0c00,
	SLI4_ASIC_GEN_7		= 0x0d00,
};

enum sli4_acic_revisions {
	SLI4_ASIC_REV_A0	= 0x00,
	SLI4_ASIC_REV_A1	= 0x01,
	SLI4_ASIC_REV_A2	= 0x02,
	SLI4_ASIC_REV_A3	= 0x03,
	SLI4_ASIC_REV_B0	= 0x10,
	SLI4_ASIC_REV_B1	= 0x11,
	SLI4_ASIC_REV_B2	= 0x12,
	SLI4_ASIC_REV_C0	= 0x20,
	SLI4_ASIC_REV_C1	= 0x21,
	SLI4_ASIC_REV_C2	= 0x22,
	SLI4_ASIC_REV_D0	= 0x30,
};

struct sli4_asic_entry_t {
	u32 rev_id;
	u32 family;
};

/* BMBX - Bootstrap Mailbox Register */
#define SLI4_BMBX_REG		0x0160
enum sli4_bmbx {
	SLI4_BMBX_MASK_HI	= 0x3,
	SLI4_BMBX_MASK_LO	= 0xf,
	SLI4_BMBX_RDY		= 1 << 0,
	SLI4_BMBX_HI		= 1 << 1,
	SLI4_BMBX_SIZE		= 256,
};

static inline u32
sli_bmbx_write_hi(u64 addr) {
	u32 val;

	val = upper_32_bits(addr) & ~SLI4_BMBX_MASK_HI;
	val |= SLI4_BMBX_HI;

	return val;
}

static inline u32
sli_bmbx_write_lo(u64 addr) {
	u32 val;

	val = (upper_32_bits(addr) & SLI4_BMBX_MASK_HI) << 30;
	val |= ((addr) & ~SLI4_BMBX_MASK_LO) >> 2;

	return val;
}

/* SLIPORT_CONTROL - SLI Port Control Register */
#define SLI4_PORT_CTRL_REG	0x0408
enum sli4_port_ctrl {
	SLI4_PORT_CTRL_IP	= 1u << 27,
	SLI4_PORT_CTRL_IDIS	= 1u << 22,
	SLI4_PORT_CTRL_FDD	= 1u << 31,
};

/* SLI4_SLIPORT_ERROR - SLI Port Error Register */
#define SLI4_PORT_ERROR1	0x040c
#define SLI4_PORT_ERROR2	0x0410

/* EQCQ_DOORBELL - EQ and CQ Doorbell Register */
#define SLI4_EQCQ_DB_REG	0x120
enum sli4_eqcq_e {
	SLI4_EQ_ID_LO_MASK	= 0x01ff,

	SLI4_CQ_ID_LO_MASK	= 0x03ff,

	SLI4_EQCQ_CI_EQ		= 0x0200,

	SLI4_EQCQ_QT_EQ		= 0x00000400,
	SLI4_EQCQ_QT_CQ		= 0x00000000,

	SLI4_EQCQ_ID_HI_SHIFT	= 11,
	SLI4_EQCQ_ID_HI_MASK	= 0xf800,

	SLI4_EQCQ_NUM_SHIFT	= 16,
	SLI4_EQCQ_NUM_MASK	= 0x1fff0000,

	SLI4_EQCQ_ARM		= 0x20000000,
	SLI4_EQCQ_UNARM		= 0x00000000,
};

static inline u32
sli_format_eq_db_data(u16 num_popped, u16 id, u32 arm) {
	u32 reg;

	reg = (id & SLI4_EQ_ID_LO_MASK) | SLI4_EQCQ_QT_EQ;
	reg |= (((id) >> 9) << SLI4_EQCQ_ID_HI_SHIFT) & SLI4_EQCQ_ID_HI_MASK;
	reg |= ((num_popped) << SLI4_EQCQ_NUM_SHIFT) & SLI4_EQCQ_NUM_MASK;
	reg |= arm | SLI4_EQCQ_CI_EQ;

	return reg;
}

static inline u32
sli_format_cq_db_data(u16 num_popped, u16 id, u32 arm) {
	u32 reg;

	reg = ((id) & SLI4_CQ_ID_LO_MASK) | SLI4_EQCQ_QT_CQ;
	reg |= (((id) >> 10) << SLI4_EQCQ_ID_HI_SHIFT) & SLI4_EQCQ_ID_HI_MASK;
	reg |= ((num_popped) << SLI4_EQCQ_NUM_SHIFT) & SLI4_EQCQ_NUM_MASK;
	reg |= arm;

	return reg;
}

/* EQ_DOORBELL - EQ Doorbell Register for IF_TYPE = 6*/
#define SLI4_IF6_EQ_DB_REG	0x120
enum sli4_eq_e {
	SLI4_IF6_EQ_ID_MASK	= 0x0fff,

	SLI4_IF6_EQ_NUM_SHIFT	= 16,
	SLI4_IF6_EQ_NUM_MASK	= 0x1fff0000,
};

static inline u32
sli_format_if6_eq_db_data(u16 num_popped, u16 id, u32 arm) {
	u32 reg;

	reg = id & SLI4_IF6_EQ_ID_MASK;
	reg |= (num_popped << SLI4_IF6_EQ_NUM_SHIFT) & SLI4_IF6_EQ_NUM_MASK;
	reg |= arm;

	return reg;
}

/* CQ_DOORBELL - CQ Doorbell Register for IF_TYPE = 6 */
#define SLI4_IF6_CQ_DB_REG	0xc0
enum sli4_cq_e {
	SLI4_IF6_CQ_ID_MASK	= 0xffff,

	SLI4_IF6_CQ_NUM_SHIFT	= 16,
	SLI4_IF6_CQ_NUM_MASK	= 0x1fff0000,
};

static inline u32
sli_format_if6_cq_db_data(u16 num_popped, u16 id, u32 arm) {
	u32 reg;

	reg = id & SLI4_IF6_CQ_ID_MASK;
	reg |= ((num_popped) << SLI4_IF6_CQ_NUM_SHIFT) & SLI4_IF6_CQ_NUM_MASK;
	reg |= arm;

	return reg;
}

/* MQ_DOORBELL - MQ Doorbell Register */
#define SLI4_MQ_DB_REG		0x0140
#define SLI4_IF6_MQ_DB_REG	0x0160
enum sli4_mq_e {
	SLI4_MQ_ID_MASK		= 0xffff,

	SLI4_MQ_NUM_SHIFT	= 16,
	SLI4_MQ_NUM_MASK	= 0x3fff0000,
};

static inline u32
sli_format_mq_db_data(u16 id) {
	u32 reg;

	reg = id & SLI4_MQ_ID_MASK;
	reg |= (1 << SLI4_MQ_NUM_SHIFT) & SLI4_MQ_NUM_MASK;

	return reg;
}

/* RQ_DOORBELL - RQ Doorbell Register */
#define SLI4_RQ_DB_REG		0x0a0
#define SLI4_IF6_RQ_DB_REG	0x0080
enum sli4_rq_e {
	SLI4_RQ_DB_ID_MASK	= 0xffff,

	SLI4_RQ_DB_NUM_SHIFT	= 16,
	SLI4_RQ_DB_NUM_MASK	= 0x3fff0000,
};

static inline u32
sli_format_rq_db_data(u16 id) {
	u32 reg;

	reg = id & SLI4_RQ_DB_ID_MASK;
	reg |= (1 << SLI4_RQ_DB_NUM_SHIFT) & SLI4_RQ_DB_NUM_MASK;

	return reg;
}

/* WQ_DOORBELL - WQ Doorbell Register */
#define SLI4_IO_WQ_DB_REG	0x040
#define SLI4_IF6_WQ_DB_REG	0x040
enum sli4_wq_e {
	SLI4_WQ_ID_MASK		= 0xffff,

	SLI4_WQ_IDX_SHIFT	= 16,
	SLI4_WQ_IDX_MASK	= 0xff0000,

	SLI4_WQ_NUM_SHIFT	= 24,
	SLI4_WQ_NUM_MASK	= 0x0ff00000,
};

static inline u32
sli_format_wq_db_data(u16 id) {
	u32 reg;

	reg = id & SLI4_WQ_ID_MASK;
	reg |= (1 << SLI4_WQ_NUM_SHIFT) & SLI4_WQ_NUM_MASK;

	return reg;
}

/* SLIPORT_STATUS - SLI Port Status Register */
#define SLI4_PORT_STATUS_REGOFF	0x0404
enum sli4_port_status {
	SLI4_PORT_STATUS_FDP	= 1u << 21,
	SLI4_PORT_STATUS_RDY	= 1u << 23,
	SLI4_PORT_STATUS_RN	= 1u << 24,
	SLI4_PORT_STATUS_DIP	= 1u << 25,
	SLI4_PORT_STATUS_OTI	= 1u << 29,
	SLI4_PORT_STATUS_ERR	= 1u << 31,
};

#define SLI4_PHYDEV_CTRL_REG	0x0414
#define SLI4_PHYDEV_CTRL_FRST	(1 << 1)
#define SLI4_PHYDEV_CTRL_DD	(1 << 2)

/* Register name enums */
enum sli4_regname_en {
	SLI4_REG_BMBX,
	SLI4_REG_EQ_DOORBELL,
	SLI4_REG_CQ_DOORBELL,
	SLI4_REG_RQ_DOORBELL,
	SLI4_REG_IO_WQ_DOORBELL,
	SLI4_REG_MQ_DOORBELL,
	SLI4_REG_PHYSDEV_CONTROL,
	SLI4_REG_PORT_CONTROL,
	SLI4_REG_PORT_ERROR1,
	SLI4_REG_PORT_ERROR2,
	SLI4_REG_PORT_SEMAPHORE,
	SLI4_REG_PORT_STATUS,
	SLI4_REG_UNKWOWN			/* must be last */
};

struct sli4_reg {
	u32	rset;
	u32	off;
};

struct sli4_dmaaddr {
	__le32 low;
	__le32 high;
};

/*
 * a 3-word Buffer Descriptor Entry with
 * address 1st 2 words, length last word
 */
struct sli4_bufptr {
	struct sli4_dmaaddr addr;
	__le32 length;
};

/* Buffer Descriptor Entry (BDE) */
enum sli4_bde_e {
	SLI4_BDE_LEN_MASK	= 0x00ffffff,
	SLI4_BDE_TYPE_MASK	= 0xff000000,
};

struct sli4_bde {
	__le32		bde_type_buflen;
	union {
		struct sli4_dmaaddr data;
		struct {
			__le32	offset;
			__le32	rsvd2;
		} imm;
		struct sli4_dmaaddr blp;
	} u;
};

/* Buffer Descriptors */
enum sli4_bde_type {
	SLI4_BDE_TYPE_SHIFT	= 24,
	SLI4_BDE_TYPE_64	= 0x00,	/* Generic 64-bit data */
	SLI4_BDE_TYPE_IMM	= 0x01,	/* Immediate data */
	SLI4_BDE_TYPE_BLP	= 0x40,	/* Buffer List Pointer */
};

#define SLI4_BDE_TYPE_VAL(type) \
	(SLI4_BDE_TYPE_##type << SLI4_BDE_TYPE_SHIFT)

/* Scatter-Gather Entry (SGE) */
#define SLI4_SGE_MAX_RESERVED		3

enum sli4_sge_type {
	/* DW2 */
	SLI4_SGE_DATA_OFFSET_MASK	= 0x07ffffff,
	/*DW2W1*/
	SLI4_SGE_TYPE_SHIFT		= 27,
	SLI4_SGE_TYPE_MASK		= 0x78000000,
	/*SGE Types*/
	SLI4_SGE_TYPE_DATA		= 0x00,
	SLI4_SGE_TYPE_DIF		= 0x04,	/* Data Integrity Field */
	SLI4_SGE_TYPE_LSP		= 0x05,	/* List Segment Pointer */
	SLI4_SGE_TYPE_PEDIF		= 0x06,	/* Post Encryption Engine DIF */
	SLI4_SGE_TYPE_PESEED		= 0x07,	/* Post Encryption DIF Seed */
	SLI4_SGE_TYPE_DISEED		= 0x08,	/* DIF Seed */
	SLI4_SGE_TYPE_ENC		= 0x09,	/* Encryption */
	SLI4_SGE_TYPE_ATM		= 0x0a,	/* DIF Application Tag Mask */
	SLI4_SGE_TYPE_SKIP		= 0x0c,	/* SKIP */

	SLI4_SGE_LAST			= 1u << 31,
};

struct sli4_sge {
	__le32		buffer_address_high;
	__le32		buffer_address_low;
	__le32		dw2_flags;
	__le32		buffer_length;
};

/* T10 DIF Scatter-Gather Entry (SGE) */
struct sli4_dif_sge {
	__le32		buffer_address_high;
	__le32		buffer_address_low;
	__le32		dw2_flags;
	__le32		rsvd12;
};

/* Data Integrity Seed (DISEED) SGE */
enum sli4_diseed_sge_flags {
	/* DW2W1 */
	SLI4_DISEED_SGE_HS		= 1 << 2,
	SLI4_DISEED_SGE_WS		= 1 << 3,
	SLI4_DISEED_SGE_IC		= 1 << 4,
	SLI4_DISEED_SGE_ICS		= 1 << 5,
	SLI4_DISEED_SGE_ATRT		= 1 << 6,
	SLI4_DISEED_SGE_AT		= 1 << 7,
	SLI4_DISEED_SGE_FAT		= 1 << 8,
	SLI4_DISEED_SGE_NA		= 1 << 9,
	SLI4_DISEED_SGE_HI		= 1 << 10,

	/* DW3W1 */
	SLI4_DISEED_SGE_BS_MASK		= 0x0007,
	SLI4_DISEED_SGE_AI		= 1 << 3,
	SLI4_DISEED_SGE_ME		= 1 << 4,
	SLI4_DISEED_SGE_RE		= 1 << 5,
	SLI4_DISEED_SGE_CE		= 1 << 6,
	SLI4_DISEED_SGE_NR		= 1 << 7,

	SLI4_DISEED_SGE_OP_RX_SHIFT	= 8,
	SLI4_DISEED_SGE_OP_RX_MASK	= 0x0f00,
	SLI4_DISEED_SGE_OP_TX_SHIFT	= 12,
	SLI4_DISEED_SGE_OP_TX_MASK	= 0xf000,
};

/* Opcode values */
enum sli4_diseed_sge_opcodes {
	SLI4_DISEED_SGE_OP_IN_NODIF_OUT_CRC,
	SLI4_DISEED_SGE_OP_IN_CRC_OUT_NODIF,
	SLI4_DISEED_SGE_OP_IN_NODIF_OUT_CSUM,
	SLI4_DISEED_SGE_OP_IN_CSUM_OUT_NODIF,
	SLI4_DISEED_SGE_OP_IN_CRC_OUT_CRC,
	SLI4_DISEED_SGE_OP_IN_CSUM_OUT_CSUM,
	SLI4_DISEED_SGE_OP_IN_CRC_OUT_CSUM,
	SLI4_DISEED_SGE_OP_IN_CSUM_OUT_CRC,
	SLI4_DISEED_SGE_OP_IN_RAW_OUT_RAW,
};

#define SLI4_DISEED_SGE_OP_RX_VALUE(stype) \
	(SLI4_DISEED_SGE_OP_##stype << SLI4_DISEED_SGE_OP_RX_SHIFT)
#define SLI4_DISEED_SGE_OP_TX_VALUE(stype) \
	(SLI4_DISEED_SGE_OP_##stype << SLI4_DISEED_SGE_OP_TX_SHIFT)

struct sli4_diseed_sge {
	__le32		ref_tag_cmp;
	__le32		ref_tag_repl;
	__le16		app_tag_repl;
	__le16		dw2w1_flags;
	__le16		app_tag_cmp;
	__le16		dw3w1_flags;
};

/* List Segment Pointer Scatter-Gather Entry (SGE) */
#define SLI4_LSP_SGE_SEGLEN	0x00ffffff

struct sli4_lsp_sge {
	__le32		buffer_address_high;
	__le32		buffer_address_low;
	__le32		dw2_flags;
	__le32		dw3_seglen;
};

enum sli4_eqe_e {
	SLI4_EQE_VALID	= 1,
	SLI4_EQE_MJCODE	= 0xe,
	SLI4_EQE_MNCODE	= 0xfff0,
};

struct sli4_eqe {
	__le16		dw0w0_flags;
	__le16		resource_id;
};

#define SLI4_MAJOR_CODE_STANDARD	0
#define SLI4_MAJOR_CODE_SENTINEL	1

/* Sentinel EQE indicating the EQ is full */
#define SLI4_EQE_STATUS_EQ_FULL		2

enum sli4_mcqe_e {
	SLI4_MCQE_CONSUMED	= 1u << 27,
	SLI4_MCQE_COMPLETED	= 1u << 28,
	SLI4_MCQE_AE		= 1u << 30,
	SLI4_MCQE_VALID		= 1u << 31,
};

/* Entry was consumed but not completed */
#define SLI4_MCQE_STATUS_NOT_COMPLETED	-2

struct sli4_mcqe {
	__le16		completion_status;
	__le16		extended_status;
	__le32		mqe_tag_low;
	__le32		mqe_tag_high;
	__le32		dw3_flags;
};

enum sli4_acqe_e {
	SLI4_ACQE_AE	= 1 << 6, /* async event - this is an ACQE */
	SLI4_ACQE_VAL	= 1 << 7, /* valid - contents of CQE are valid */
};

struct sli4_acqe {
	__le32		event_data[3];
	u8		rsvd12;
	u8		event_code;
	u8		event_type;
	u8		ae_val;
};

enum sli4_acqe_event_code {
	SLI4_ACQE_EVENT_CODE_LINK_STATE		= 0x01,
	SLI4_ACQE_EVENT_CODE_FIP		= 0x02,
	SLI4_ACQE_EVENT_CODE_DCBX		= 0x03,
	SLI4_ACQE_EVENT_CODE_ISCSI		= 0x04,
	SLI4_ACQE_EVENT_CODE_GRP_5		= 0x05,
	SLI4_ACQE_EVENT_CODE_FC_LINK_EVENT	= 0x10,
	SLI4_ACQE_EVENT_CODE_SLI_PORT_EVENT	= 0x11,
	SLI4_ACQE_EVENT_CODE_VF_EVENT		= 0x12,
	SLI4_ACQE_EVENT_CODE_MR_EVENT		= 0x13,
};

enum sli4_qtype {
	SLI4_QTYPE_EQ,
	SLI4_QTYPE_CQ,
	SLI4_QTYPE_MQ,
	SLI4_QTYPE_WQ,
	SLI4_QTYPE_RQ,
	SLI4_QTYPE_MAX,			/* must be last */
};

#define SLI4_USER_MQ_COUNT	1
#define SLI4_MAX_CQ_SET_COUNT	16
#define SLI4_MAX_RQ_SET_COUNT	16

enum sli4_qentry {
	SLI4_QENTRY_ASYNC,
	SLI4_QENTRY_MQ,
	SLI4_QENTRY_RQ,
	SLI4_QENTRY_WQ,
	SLI4_QENTRY_WQ_RELEASE,
	SLI4_QENTRY_OPT_WRITE_CMD,
	SLI4_QENTRY_OPT_WRITE_DATA,
	SLI4_QENTRY_XABT,
	SLI4_QENTRY_MAX			/* must be last */
};

enum sli4_queue_flags {
	SLI4_QUEUE_FLAG_MQ	= 1 << 0,	/* CQ has MQ/Async completion */
	SLI4_QUEUE_FLAG_HDR	= 1 << 1,	/* RQ for packet headers */
	SLI4_QUEUE_FLAG_RQBATCH	= 1 << 2,	/* RQ index increment by 8 */
};

/* Generic Command Request header */
enum sli4_cmd_version {
	CMD_V0,
	CMD_V1,
	CMD_V2,
};

struct sli4_rqst_hdr {
	u8		opcode;
	u8		subsystem;
	__le16		rsvd2;
	__le32		timeout;
	__le32		request_length;
	__le32		dw3_version;
};

/* Generic Command Response header */
struct sli4_rsp_hdr {
	u8		opcode;
	u8		subsystem;
	__le16		rsvd2;
	u8		status;
	u8		additional_status;
	__le16		rsvd6;
	__le32		response_length;
	__le32		actual_response_length;
};

#define SLI4_QUEUE_RQ_BATCH	8

#define SZ_DMAADDR		sizeof(struct sli4_dmaaddr)
#define SLI4_RQST_CMDSZ(stype)	sizeof(struct sli4_rqst_##stype)

#define SLI4_RQST_PYLD_LEN(stype) \
		cpu_to_le32(sizeof(struct sli4_rqst_##stype) - \
			sizeof(struct sli4_rqst_hdr))

#define SLI4_RQST_PYLD_LEN_VAR(stype, varpyld) \
		cpu_to_le32((sizeof(struct sli4_rqst_##stype) + \
			varpyld) - sizeof(struct sli4_rqst_hdr))

#define SLI4_CFG_PYLD_LENGTH(stype) \
		max(sizeof(struct sli4_rqst_##stype), \
		sizeof(struct sli4_rsp_##stype))

enum sli4_create_cqv2_e {
	/* DW5_flags values*/
	SLI4_CREATE_CQV2_CLSWM_MASK	= 0x00003000,
	SLI4_CREATE_CQV2_NODELAY	= 0x00004000,
	SLI4_CREATE_CQV2_AUTOVALID	= 0x00008000,
	SLI4_CREATE_CQV2_CQECNT_MASK	= 0x18000000,
	SLI4_CREATE_CQV2_VALID		= 0x20000000,
	SLI4_CREATE_CQV2_EVT		= 0x80000000,
	/* DW6W1_flags values*/
	SLI4_CREATE_CQV2_ARM		= 0x8000,
};

struct sli4_rqst_cmn_create_cq_v2 {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	u8			page_size;
	u8			rsvd19;
	__le32			dw5_flags;
	__le16			eq_id;
	__le16			dw6w1_arm;
	__le16			cqe_count;
	__le16			rsvd30;
	__le32			rsvd32;
	struct sli4_dmaaddr	page_phys_addr[];
};

enum sli4_create_cqset_e {
	/* DW5_flags values*/
	SLI4_CREATE_CQSETV0_CLSWM_MASK	= 0x00003000,
	SLI4_CREATE_CQSETV0_NODELAY	= 0x00004000,
	SLI4_CREATE_CQSETV0_AUTOVALID	= 0x00008000,
	SLI4_CREATE_CQSETV0_CQECNT_MASK	= 0x18000000,
	SLI4_CREATE_CQSETV0_VALID	= 0x20000000,
	SLI4_CREATE_CQSETV0_EVT		= 0x80000000,
	/* DW5W1_flags values */
	SLI4_CREATE_CQSETV0_CQE_COUNT	= 0x7fff,
	SLI4_CREATE_CQSETV0_ARM		= 0x8000,
};

struct sli4_rqst_cmn_create_cq_set_v0 {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	u8			page_size;
	u8			rsvd19;
	__le32			dw5_flags;
	__le16			num_cq_req;
	__le16			dw6w1_flags;
	__le16			eq_id[16];
	struct sli4_dmaaddr	page_phys_addr[];
};

/* CQE count */
enum sli4_cq_cnt {
	SLI4_CQ_CNT_256,
	SLI4_CQ_CNT_512,
	SLI4_CQ_CNT_1024,
	SLI4_CQ_CNT_LARGE,
};

#define SLI4_CQ_CNT_SHIFT	27
#define SLI4_CQ_CNT_VAL(type)	(SLI4_CQ_CNT_##type << SLI4_CQ_CNT_SHIFT)

#define SLI4_CQE_BYTES		(4 * sizeof(u32))

#define SLI4_CREATE_CQV2_MAX_PAGES	8

/* Generic Common Create EQ/CQ/MQ/WQ/RQ Queue completion */
struct sli4_rsp_cmn_create_queue {
	struct sli4_rsp_hdr	hdr;
	__le16	q_id;
	u8	rsvd18;
	u8	ulp;
	__le32	db_offset;
	__le16	db_rs;
	__le16	db_fmt;
};

struct sli4_rsp_cmn_create_queue_set {
	struct sli4_rsp_hdr	hdr;
	__le16	q_id;
	__le16	num_q_allocated;
};

/* Common Destroy Queue */
struct sli4_rqst_cmn_destroy_q {
	struct sli4_rqst_hdr	hdr;
	__le16	q_id;
	__le16	rsvd;
};

struct sli4_rsp_cmn_destroy_q {
	struct sli4_rsp_hdr	hdr;
};

/* Modify the delay multiplier for EQs */
struct sli4_eqdelay_rec {
	__le32  eq_id;
	__le32  phase;
	__le32  delay_multiplier;
};

struct sli4_rqst_cmn_modify_eq_delay {
	struct sli4_rqst_hdr	hdr;
	__le32			num_eq;
	struct sli4_eqdelay_rec eq_delay_record[8];
};

struct sli4_rsp_cmn_modify_eq_delay {
	struct sli4_rsp_hdr	hdr;
};

enum sli4_create_cq_e {
	/* DW5 */
	SLI4_CREATE_EQ_AUTOVALID		= 1u << 28,
	SLI4_CREATE_EQ_VALID			= 1u << 29,
	SLI4_CREATE_EQ_EQESZ			= 1u << 31,
	/* DW6 */
	SLI4_CREATE_EQ_COUNT			= 7 << 26,
	SLI4_CREATE_EQ_ARM			= 1u << 31,
	/* DW7 */
	SLI4_CREATE_EQ_DELAYMULTI_SHIFT		= 13,
	SLI4_CREATE_EQ_DELAYMULTI_MASK		= 0x007fe000,
	SLI4_CREATE_EQ_DELAYMULTI		= 0x00040000,
};

struct sli4_rqst_cmn_create_eq {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	__le16			rsvd18;
	__le32			dw5_flags;
	__le32			dw6_flags;
	__le32			dw7_delaymulti;
	__le32			rsvd32;
	struct sli4_dmaaddr	page_address[8];
};

struct sli4_rsp_cmn_create_eq {
	struct sli4_rsp_cmn_create_queue q_rsp;
};

/* EQ count */
enum sli4_eq_cnt {
	SLI4_EQ_CNT_256,
	SLI4_EQ_CNT_512,
	SLI4_EQ_CNT_1024,
	SLI4_EQ_CNT_2048,
	SLI4_EQ_CNT_4096 = 3,
};

#define SLI4_EQ_CNT_SHIFT	26
#define SLI4_EQ_CNT_VAL(type)	(SLI4_EQ_CNT_##type << SLI4_EQ_CNT_SHIFT)

#define SLI4_EQE_SIZE_4		0
#define SLI4_EQE_SIZE_16	1

/* Create a Mailbox Queue; accommodate v0 and v1 forms. */
enum sli4_create_mq_flags {
	/* DW6W1 */
	SLI4_CREATE_MQEXT_RINGSIZE	= 0xf,
	SLI4_CREATE_MQEXT_CQID_SHIFT	= 6,
	SLI4_CREATE_MQEXT_CQIDV0_MASK	= 0xffc0,
	/* DW7 */
	SLI4_CREATE_MQEXT_VAL		= 1u << 31,
	/* DW8 */
	SLI4_CREATE_MQEXT_ACQV		= 1u << 0,
	SLI4_CREATE_MQEXT_ASYNC_CQIDV0	= 0x7fe,
};

struct sli4_rqst_cmn_create_mq_ext {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	__le16			cq_id_v1;
	__le32			async_event_bitmap;
	__le16			async_cq_id_v1;
	__le16			dw6w1_flags;
	__le32			dw7_val;
	__le32			dw8_flags;
	__le32			rsvd36;
	struct sli4_dmaaddr	page_phys_addr[];
};

struct sli4_rsp_cmn_create_mq_ext {
	struct sli4_rsp_cmn_create_queue q_rsp;
};

enum sli4_mqe_size {
	SLI4_MQE_SIZE_16 = 0x05,
	SLI4_MQE_SIZE_32,
	SLI4_MQE_SIZE_64,
	SLI4_MQE_SIZE_128,
};

enum sli4_async_evt {
	SLI4_ASYNC_EVT_LINK_STATE	= 1 << 1,
	SLI4_ASYNC_EVT_FIP		= 1 << 2,
	SLI4_ASYNC_EVT_GRP5		= 1 << 5,
	SLI4_ASYNC_EVT_FC		= 1 << 16,
	SLI4_ASYNC_EVT_SLI_PORT		= 1 << 17,
};

#define	SLI4_ASYNC_EVT_FC_ALL \
		(SLI4_ASYNC_EVT_LINK_STATE	| \
		 SLI4_ASYNC_EVT_FIP		| \
		 SLI4_ASYNC_EVT_GRP5		| \
		 SLI4_ASYNC_EVT_FC		| \
		 SLI4_ASYNC_EVT_SLI_PORT)

/* Create a Completion Queue. */
struct sli4_rqst_cmn_create_cq_v0 {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	__le16			rsvd18;
	__le32			dw5_flags;
	__le32			dw6_flags;
	__le32			rsvd28;
	__le32			rsvd32;
	struct sli4_dmaaddr	page_phys_addr[];
};

enum sli4_create_rq_e {
	SLI4_RQ_CREATE_DUA		= 0x1,
	SLI4_RQ_CREATE_BQU		= 0x2,

	SLI4_RQE_SIZE			= 8,
	SLI4_RQE_SIZE_8			= 0x2,
	SLI4_RQE_SIZE_16		= 0x3,
	SLI4_RQE_SIZE_32		= 0x4,
	SLI4_RQE_SIZE_64		= 0x5,
	SLI4_RQE_SIZE_128		= 0x6,

	SLI4_RQ_PAGE_SIZE_4096		= 0x1,
	SLI4_RQ_PAGE_SIZE_8192		= 0x2,
	SLI4_RQ_PAGE_SIZE_16384		= 0x4,
	SLI4_RQ_PAGE_SIZE_32768		= 0x8,
	SLI4_RQ_PAGE_SIZE_64536		= 0x10,

	SLI4_RQ_CREATE_V0_MAX_PAGES	= 8,
	SLI4_RQ_CREATE_V0_MIN_BUF_SIZE	= 128,
	SLI4_RQ_CREATE_V0_MAX_BUF_SIZE	= 2048,
};

struct sli4_rqst_rq_create {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	u8			dua_bqu_byte;
	u8			ulp;
	__le16			rsvd16;
	u8			rqe_count_byte;
	u8			rsvd19;
	__le32			rsvd20;
	__le16			buffer_size;
	__le16			cq_id;
	__le32			rsvd28;
	struct sli4_dmaaddr	page_phys_addr[SLI4_RQ_CREATE_V0_MAX_PAGES];
};

struct sli4_rsp_rq_create {
	struct sli4_rsp_cmn_create_queue rsp;
};

enum sli4_create_rqv1_e {
	SLI4_RQ_CREATE_V1_DNB		= 0x80,
	SLI4_RQ_CREATE_V1_MAX_PAGES	= 8,
	SLI4_RQ_CREATE_V1_MIN_BUF_SIZE	= 64,
	SLI4_RQ_CREATE_V1_MAX_BUF_SIZE	= 2048,
};

struct sli4_rqst_rq_create_v1 {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	u8			rsvd14;
	u8			dim_dfd_dnb;
	u8			page_size;
	u8			rqe_size_byte;
	__le16			rqe_count;
	__le32			rsvd20;
	__le16			rsvd24;
	__le16			cq_id;
	__le32			buffer_size;
	struct sli4_dmaaddr	page_phys_addr[SLI4_RQ_CREATE_V1_MAX_PAGES];
};

struct sli4_rsp_rq_create_v1 {
	struct sli4_rsp_cmn_create_queue rsp;
};

#define	SLI4_RQCREATEV2_DNB	0x80

struct sli4_rqst_rq_create_v2 {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	u8			rq_count;
	u8			dim_dfd_dnb;
	u8			page_size;
	u8			rqe_size_byte;
	__le16			rqe_count;
	__le16			hdr_buffer_size;
	__le16			payload_buffer_size;
	__le16			base_cq_id;
	__le16			rsvd26;
	__le32			rsvd42;
	struct sli4_dmaaddr	page_phys_addr[];
};

struct sli4_rsp_rq_create_v2 {
	struct sli4_rsp_cmn_create_queue rsp;
};

#define SLI4_CQE_CODE_OFFSET	14

enum sli4_cqe_code {
	SLI4_CQE_CODE_WORK_REQUEST_COMPLETION = 0x01,
	SLI4_CQE_CODE_RELEASE_WQE,
	SLI4_CQE_CODE_RSVD,
	SLI4_CQE_CODE_RQ_ASYNC,
	SLI4_CQE_CODE_XRI_ABORTED,
	SLI4_CQE_CODE_RQ_COALESCING,
	SLI4_CQE_CODE_RQ_CONSUMPTION,
	SLI4_CQE_CODE_MEASUREMENT_REPORTING,
	SLI4_CQE_CODE_RQ_ASYNC_V1,
	SLI4_CQE_CODE_RQ_COALESCING_V1,
	SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD,
	SLI4_CQE_CODE_OPTIMIZED_WRITE_DATA,
};

#define SLI4_WQ_CREATE_MAX_PAGES		8

struct sli4_rqst_wq_create {
	struct sli4_rqst_hdr	hdr;
	__le16			num_pages;
	__le16			cq_id;
	u8			page_size;
	u8			wqe_size_byte;
	__le16			wqe_count;
	__le32			rsvd;
	struct	sli4_dmaaddr	page_phys_addr[SLI4_WQ_CREATE_MAX_PAGES];
};

struct sli4_rsp_wq_create {
	struct sli4_rsp_cmn_create_queue rsp;
};

enum sli4_link_attention_flags {
	SLI4_LNK_ATTN_TYPE_LINK_UP		= 0x01,
	SLI4_LNK_ATTN_TYPE_LINK_DOWN		= 0x02,
	SLI4_LNK_ATTN_TYPE_NO_HARD_ALPA		= 0x03,

	SLI4_LNK_ATTN_P2P			= 0x01,
	SLI4_LNK_ATTN_FC_AL			= 0x02,
	SLI4_LNK_ATTN_INTERNAL_LOOPBACK		= 0x03,
	SLI4_LNK_ATTN_SERDES_LOOPBACK		= 0x04,
};

struct sli4_link_attention {
	u8		link_number;
	u8		attn_type;
	u8		topology;
	u8		port_speed;
	u8		port_fault;
	u8		shared_link_status;
	__le16		logical_link_speed;
	__le32		event_tag;
	u8		rsvd12;
	u8		event_code;
	u8		event_type;
	u8		flags;
};

enum sli4_link_event_type {
	SLI4_EVENT_LINK_ATTENTION		= 0x01,
	SLI4_EVENT_SHARED_LINK_ATTENTION	= 0x02,
};

enum sli4_wcqe_flags {
	SLI4_WCQE_XB = 0x10,
	SLI4_WCQE_QX = 0x80,
};

struct sli4_fc_wcqe {
	u8		hw_status;
	u8		status;
	__le16		request_tag;
	__le32		wqe_specific_1;
	__le32		wqe_specific_2;
	u8		rsvd12;
	u8		qx_byte;
	u8		code;
	u8		flags;
};

/* FC WQ consumed CQ queue entry */
struct sli4_fc_wqec {
	__le32		rsvd0;
	__le32		rsvd1;
	__le16		wqe_index;
	__le16		wq_id;
	__le16		rsvd12;
	u8		code;
	u8		vld_byte;
};

/* FC Completion Status Codes. */
enum sli4_wcqe_status {
	SLI4_FC_WCQE_STATUS_SUCCESS,
	SLI4_FC_WCQE_STATUS_FCP_RSP_FAILURE,
	SLI4_FC_WCQE_STATUS_REMOTE_STOP,
	SLI4_FC_WCQE_STATUS_LOCAL_REJECT,
	SLI4_FC_WCQE_STATUS_NPORT_RJT,
	SLI4_FC_WCQE_STATUS_FABRIC_RJT,
	SLI4_FC_WCQE_STATUS_NPORT_BSY,
	SLI4_FC_WCQE_STATUS_FABRIC_BSY,
	SLI4_FC_WCQE_STATUS_RSVD,
	SLI4_FC_WCQE_STATUS_LS_RJT,
	SLI4_FC_WCQE_STATUS_RX_BUF_OVERRUN,
	SLI4_FC_WCQE_STATUS_CMD_REJECT,
	SLI4_FC_WCQE_STATUS_FCP_TGT_LENCHECK,
	SLI4_FC_WCQE_STATUS_RSVD1,
	SLI4_FC_WCQE_STATUS_ELS_CMPLT_NO_AUTOREG,
	SLI4_FC_WCQE_STATUS_RSVD2,
	SLI4_FC_WCQE_STATUS_RQ_SUCCESS,
	SLI4_FC_WCQE_STATUS_RQ_BUF_LEN_EXCEEDED,
	SLI4_FC_WCQE_STATUS_RQ_INSUFF_BUF_NEEDED,
	SLI4_FC_WCQE_STATUS_RQ_INSUFF_FRM_DISC,
	SLI4_FC_WCQE_STATUS_RQ_DMA_FAILURE,
	SLI4_FC_WCQE_STATUS_FCP_RSP_TRUNCATE,
	SLI4_FC_WCQE_STATUS_DI_ERROR,
	SLI4_FC_WCQE_STATUS_BA_RJT,
	SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_NEEDED,
	SLI4_FC_WCQE_STATUS_RQ_INSUFF_XRI_DISC,
	SLI4_FC_WCQE_STATUS_RX_ERROR_DETECT,
	SLI4_FC_WCQE_STATUS_RX_ABORT_REQUEST,

	/* driver generated status codes */
	SLI4_FC_WCQE_STATUS_DISPATCH_ERROR	= 0xfd,
	SLI4_FC_WCQE_STATUS_SHUTDOWN		= 0xfe,
	SLI4_FC_WCQE_STATUS_TARGET_WQE_TIMEOUT	= 0xff,
};

/* DI_ERROR Extended Status */
enum sli4_fc_di_error_status {
	SLI4_FC_DI_ERROR_GE			= 1 << 0,
	SLI4_FC_DI_ERROR_AE			= 1 << 1,
	SLI4_FC_DI_ERROR_RE			= 1 << 2,
	SLI4_FC_DI_ERROR_TDPV			= 1 << 3,
	SLI4_FC_DI_ERROR_UDB			= 1 << 4,
	SLI4_FC_DI_ERROR_EDIR			= 1 << 5,
};

/* WQE DIF field contents */
enum sli4_dif_fields {
	SLI4_DIF_DISABLED,
	SLI4_DIF_PASS_THROUGH,
	SLI4_DIF_STRIP,
	SLI4_DIF_INSERT,
};

/* Work Queue Entry (WQE) types */
enum sli4_wqe_types {
	SLI4_WQE_ABORT				= 0x0f,
	SLI4_WQE_ELS_REQUEST64			= 0x8a,
	SLI4_WQE_FCP_IBIDIR64			= 0xac,
	SLI4_WQE_FCP_IREAD64			= 0x9a,
	SLI4_WQE_FCP_IWRITE64			= 0x98,
	SLI4_WQE_FCP_ICMND64			= 0x9c,
	SLI4_WQE_FCP_TRECEIVE64			= 0xa1,
	SLI4_WQE_FCP_CONT_TRECEIVE64		= 0xe5,
	SLI4_WQE_FCP_TRSP64			= 0xa3,
	SLI4_WQE_FCP_TSEND64			= 0x9f,
	SLI4_WQE_GEN_REQUEST64			= 0xc2,
	SLI4_WQE_SEND_FRAME			= 0xe1,
	SLI4_WQE_XMIT_BCAST64			= 0x84,
	SLI4_WQE_XMIT_BLS_RSP			= 0x97,
	SLI4_WQE_ELS_RSP64			= 0x95,
	SLI4_WQE_XMIT_SEQUENCE64		= 0x82,
	SLI4_WQE_REQUEUE_XRI			= 0x93,
};

/* WQE command types */
enum sli4_wqe_cmds {
	SLI4_CMD_FCP_IREAD64_WQE		= 0x00,
	SLI4_CMD_FCP_ICMND64_WQE		= 0x00,
	SLI4_CMD_FCP_IWRITE64_WQE		= 0x01,
	SLI4_CMD_FCP_TRECEIVE64_WQE		= 0x02,
	SLI4_CMD_FCP_TRSP64_WQE			= 0x03,
	SLI4_CMD_FCP_TSEND64_WQE		= 0x07,
	SLI4_CMD_GEN_REQUEST64_WQE		= 0x08,
	SLI4_CMD_XMIT_BCAST64_WQE		= 0x08,
	SLI4_CMD_XMIT_BLS_RSP64_WQE		= 0x08,
	SLI4_CMD_ABORT_WQE			= 0x08,
	SLI4_CMD_XMIT_SEQUENCE64_WQE		= 0x08,
	SLI4_CMD_REQUEUE_XRI_WQE		= 0x0a,
	SLI4_CMD_SEND_FRAME_WQE			= 0x0a,
};

#define SLI4_WQE_SIZE		0x05
#define SLI4_WQE_EXT_SIZE	0x06

#define SLI4_WQE_BYTES		(16 * sizeof(u32))
#define SLI4_WQE_EXT_BYTES	(32 * sizeof(u32))

/* Mask for ccp (CS_CTL) */
#define SLI4_MASK_CCP		0xfe

/* Generic WQE */
enum sli4_gen_wqe_flags {
	SLI4_GEN_WQE_EBDECNT	= 0xf,
	SLI4_GEN_WQE_LEN_LOC	= 0x3 << 7,
	SLI4_GEN_WQE_QOSD	= 1 << 9,
	SLI4_GEN_WQE_XBL	= 1 << 11,
	SLI4_GEN_WQE_HLM	= 1 << 12,
	SLI4_GEN_WQE_IOD	= 1 << 13,
	SLI4_GEN_WQE_DBDE	= 1 << 14,
	SLI4_GEN_WQE_WQES	= 1 << 15,

	SLI4_GEN_WQE_PRI	= 0x7,
	SLI4_GEN_WQE_PV		= 1 << 3,
	SLI4_GEN_WQE_EAT	= 1 << 4,
	SLI4_GEN_WQE_XC		= 1 << 5,
	SLI4_GEN_WQE_CCPE	= 1 << 7,

	SLI4_GEN_WQE_CMDTYPE	= 0xf,
	SLI4_GEN_WQE_WQEC	= 1 << 7,
};

struct sli4_generic_wqe {
	__le32		cmd_spec0_5[6];
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		rsvd34;
	__le16		dw10w0_flags;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmdtype_wqec_byte;
	u8		rsvd41;
	__le16		cq_id;
};

/* WQE used to abort exchanges. */
enum sli4_abort_wqe_flags {
	SLI4_ABRT_WQE_IR	= 0x02,

	SLI4_ABRT_WQE_EBDECNT	= 0xf,
	SLI4_ABRT_WQE_LEN_LOC	= 0x3 << 7,
	SLI4_ABRT_WQE_QOSD	= 1 << 9,
	SLI4_ABRT_WQE_XBL	= 1 << 11,
	SLI4_ABRT_WQE_IOD	= 1 << 13,
	SLI4_ABRT_WQE_DBDE	= 1 << 14,
	SLI4_ABRT_WQE_WQES	= 1 << 15,

	SLI4_ABRT_WQE_PRI	= 0x7,
	SLI4_ABRT_WQE_PV	= 1 << 3,
	SLI4_ABRT_WQE_EAT	= 1 << 4,
	SLI4_ABRT_WQE_XC	= 1 << 5,
	SLI4_ABRT_WQE_CCPE	= 1 << 7,

	SLI4_ABRT_WQE_CMDTYPE	= 0xf,
	SLI4_ABRT_WQE_WQEC	= 1 << 7,
};

struct sli4_abort_wqe {
	__le32		rsvd0;
	__le32		rsvd4;
	__le32		ext_t_tag;
	u8		ia_ir_byte;
	u8		criteria;
	__le16		rsvd10;
	__le32		ext_t_mask;
	__le32		t_mask;
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		t_tag;
	__le16		request_tag;
	__le16		rsvd34;
	__le16		dw10w0_flags;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmdtype_wqec_byte;
	u8		rsvd41;
	__le16		cq_id;
};

enum sli4_abort_criteria {
	SLI4_ABORT_CRITERIA_XRI_TAG = 0x01,
	SLI4_ABORT_CRITERIA_ABORT_TAG,
	SLI4_ABORT_CRITERIA_REQUEST_TAG,
	SLI4_ABORT_CRITERIA_EXT_ABORT_TAG,
};

enum sli4_abort_type {
	SLI4_ABORT_XRI,
	SLI4_ABORT_ABORT_ID,
	SLI4_ABORT_REQUEST_ID,
	SLI4_ABORT_MAX,		/* must be last */
};

/* WQE used to create an ELS request. */
enum sli4_els_req_wqe_flags {
	SLI4_REQ_WQE_QOSD		= 0x2,
	SLI4_REQ_WQE_DBDE		= 0x40,
	SLI4_REQ_WQE_XBL		= 0x8,
	SLI4_REQ_WQE_XC			= 0x20,
	SLI4_REQ_WQE_IOD		= 0x20,
	SLI4_REQ_WQE_HLM		= 0x10,
	SLI4_REQ_WQE_CCPE		= 0x80,
	SLI4_REQ_WQE_EAT		= 0x10,
	SLI4_REQ_WQE_WQES		= 0x80,
	SLI4_REQ_WQE_PU_SHFT		= 4,
	SLI4_REQ_WQE_CT_SHFT		= 2,
	SLI4_REQ_WQE_CT			= 0xc,
	SLI4_REQ_WQE_ELSID_SHFT		= 4,
	SLI4_REQ_WQE_SP_SHFT		= 24,
	SLI4_REQ_WQE_LEN_LOC_BIT1	= 0x80,
	SLI4_REQ_WQE_LEN_LOC_BIT2	= 0x1,
};

struct sli4_els_request64_wqe {
	struct sli4_bde	els_request_payload;
	__le32		els_request_payload_length;
	__le32		sid_sp_dword;
	__le32		remote_id_dword;
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		temporary_rpi;
	u8		len_loc1_byte;
	u8		qosd_xbl_hlm_iod_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmdtype_elsid_byte;
	u8		rsvd41;
	__le16		cq_id;
	struct sli4_bde	els_response_payload_bde;
	__le32		max_response_payload_length;
};

/* WQE used to create an FCP initiator no data command. */
enum sli4_icmd_wqe_flags {
	SLI4_ICMD_WQE_DBDE		= 0x40,
	SLI4_ICMD_WQE_XBL		= 0x8,
	SLI4_ICMD_WQE_XC		= 0x20,
	SLI4_ICMD_WQE_IOD		= 0x20,
	SLI4_ICMD_WQE_HLM		= 0x10,
	SLI4_ICMD_WQE_CCPE		= 0x80,
	SLI4_ICMD_WQE_EAT		= 0x10,
	SLI4_ICMD_WQE_APPID		= 0x10,
	SLI4_ICMD_WQE_WQES		= 0x80,
	SLI4_ICMD_WQE_PU_SHFT		= 4,
	SLI4_ICMD_WQE_CT_SHFT		= 2,
	SLI4_ICMD_WQE_BS_SHFT		= 4,
	SLI4_ICMD_WQE_LEN_LOC_BIT1	= 0x80,
	SLI4_ICMD_WQE_LEN_LOC_BIT2	= 0x1,
};

struct sli4_fcp_icmnd64_wqe {
	struct sli4_bde	bde;
	__le16		payload_offset_length;
	__le16		fcp_cmd_buffer_length;
	__le32		rsvd12;
	__le32		remote_n_port_id_dword;
	__le16		xri_tag;
	__le16		context_tag;
	u8		dif_ct_bs_byte;
	u8		command;
	u8		class_pu_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		rsvd34;
	u8		len_loc1_byte;
	u8		qosd_xbl_hlm_iod_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		rsvd44;
	__le32		rsvd48;
	__le32		rsvd52;
	__le32		rsvd56;
};

/* WQE used to create an FCP initiator read. */
enum sli4_ir_wqe_flags {
	SLI4_IR_WQE_DBDE		= 0x40,
	SLI4_IR_WQE_XBL			= 0x8,
	SLI4_IR_WQE_XC			= 0x20,
	SLI4_IR_WQE_IOD			= 0x20,
	SLI4_IR_WQE_HLM			= 0x10,
	SLI4_IR_WQE_CCPE		= 0x80,
	SLI4_IR_WQE_EAT			= 0x10,
	SLI4_IR_WQE_APPID		= 0x10,
	SLI4_IR_WQE_WQES		= 0x80,
	SLI4_IR_WQE_PU_SHFT		= 4,
	SLI4_IR_WQE_CT_SHFT		= 2,
	SLI4_IR_WQE_BS_SHFT		= 4,
	SLI4_IR_WQE_LEN_LOC_BIT1	= 0x80,
	SLI4_IR_WQE_LEN_LOC_BIT2	= 0x1,
};

struct sli4_fcp_iread64_wqe {
	struct sli4_bde	bde;
	__le16		payload_offset_length;
	__le16		fcp_cmd_buffer_length;

	__le32		total_transfer_length;

	__le32		remote_n_port_id_dword;

	__le16		xri_tag;
	__le16		context_tag;

	u8		dif_ct_bs_byte;
	u8		command;
	u8		class_pu_byte;
	u8		timer;

	__le32		abort_tag;

	__le16		request_tag;
	__le16		rsvd34;

	u8		len_loc1_byte;
	u8		qosd_xbl_hlm_iod_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;

	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;

	__le32		rsvd44;
	struct sli4_bde	first_data_bde;
};

/* WQE used to create an FCP initiator write. */
enum sli4_iwr_wqe_flags {
	SLI4_IWR_WQE_DBDE		= 0x40,
	SLI4_IWR_WQE_XBL		= 0x8,
	SLI4_IWR_WQE_XC			= 0x20,
	SLI4_IWR_WQE_IOD		= 0x20,
	SLI4_IWR_WQE_HLM		= 0x10,
	SLI4_IWR_WQE_DNRX		= 0x10,
	SLI4_IWR_WQE_CCPE		= 0x80,
	SLI4_IWR_WQE_EAT		= 0x10,
	SLI4_IWR_WQE_APPID		= 0x10,
	SLI4_IWR_WQE_WQES		= 0x80,
	SLI4_IWR_WQE_PU_SHFT		= 4,
	SLI4_IWR_WQE_CT_SHFT		= 2,
	SLI4_IWR_WQE_BS_SHFT		= 4,
	SLI4_IWR_WQE_LEN_LOC_BIT1	= 0x80,
	SLI4_IWR_WQE_LEN_LOC_BIT2	= 0x1,
};

struct sli4_fcp_iwrite64_wqe {
	struct sli4_bde	bde;
	__le16		payload_offset_length;
	__le16		fcp_cmd_buffer_length;
	__le16		total_transfer_length;
	__le16		initial_transfer_length;
	__le16		xri_tag;
	__le16		context_tag;
	u8		dif_ct_bs_byte;
	u8		command;
	u8		class_pu_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		rsvd34;
	u8		len_loc1_byte;
	u8		qosd_xbl_hlm_iod_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		remote_n_port_id_dword;
	struct sli4_bde	first_data_bde;
};

struct sli4_fcp_128byte_wqe {
	u32 dw[32];
};

/* WQE used to create an FCP target receive */
enum sli4_trcv_wqe_flags {
	SLI4_TRCV_WQE_DBDE		= 0x40,
	SLI4_TRCV_WQE_XBL		= 0x8,
	SLI4_TRCV_WQE_AR		= 0x8,
	SLI4_TRCV_WQE_XC		= 0x20,
	SLI4_TRCV_WQE_IOD		= 0x20,
	SLI4_TRCV_WQE_HLM		= 0x10,
	SLI4_TRCV_WQE_DNRX		= 0x10,
	SLI4_TRCV_WQE_CCPE		= 0x80,
	SLI4_TRCV_WQE_EAT		= 0x10,
	SLI4_TRCV_WQE_APPID		= 0x10,
	SLI4_TRCV_WQE_WQES		= 0x80,
	SLI4_TRCV_WQE_PU_SHFT		= 4,
	SLI4_TRCV_WQE_CT_SHFT		= 2,
	SLI4_TRCV_WQE_BS_SHFT		= 4,
	SLI4_TRCV_WQE_LEN_LOC_BIT2	= 0x1,
};

struct sli4_fcp_treceive64_wqe {
	struct sli4_bde	bde;
	__le32		payload_offset_length;
	__le32		relative_offset;
	union {
		__le16	sec_xri_tag;
		__le16	rsvd;
		__le32	dword;
	} dword5;
	__le16		xri_tag;
	__le16		context_tag;
	u8		dif_ct_bs_byte;
	u8		command;
	u8		class_ar_pu_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		remote_xid;
	u8		lloc1_appid;
	u8		qosd_xbl_hlm_iod_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		fcp_data_receive_length;
	struct sli4_bde	first_data_bde;
};

/* WQE used to create an FCP target response */
enum sli4_trsp_wqe_flags {
	SLI4_TRSP_WQE_AG	= 0x8,
	SLI4_TRSP_WQE_DBDE	= 0x40,
	SLI4_TRSP_WQE_XBL	= 0x8,
	SLI4_TRSP_WQE_XC	= 0x20,
	SLI4_TRSP_WQE_HLM	= 0x10,
	SLI4_TRSP_WQE_DNRX	= 0x10,
	SLI4_TRSP_WQE_CCPE	= 0x80,
	SLI4_TRSP_WQE_EAT	= 0x10,
	SLI4_TRSP_WQE_APPID	= 0x10,
	SLI4_TRSP_WQE_WQES	= 0x80,
};

struct sli4_fcp_trsp64_wqe {
	struct sli4_bde	bde;
	__le32		fcp_response_length;
	__le32		rsvd12;
	__le32		dword5;
	__le16		xri_tag;
	__le16		rpi;
	u8		ct_dnrx_byte;
	u8		command;
	u8		class_ag_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		remote_xid;
	u8		lloc1_appid;
	u8		qosd_xbl_hlm_dbde_wqes;
	u8		eat_xc_ccpe;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		rsvd44;
	__le32		rsvd48;
	__le32		rsvd52;
	__le32		rsvd56;
};

/* WQE used to create an FCP target send (DATA IN). */
enum sli4_tsend_wqe_flags {
	SLI4_TSEND_WQE_XBL	= 0x8,
	SLI4_TSEND_WQE_DBDE	= 0x40,
	SLI4_TSEND_WQE_IOD	= 0x20,
	SLI4_TSEND_WQE_QOSD	= 0x2,
	SLI4_TSEND_WQE_HLM	= 0x10,
	SLI4_TSEND_WQE_PU_SHFT	= 4,
	SLI4_TSEND_WQE_AR	= 0x8,
	SLI4_TSEND_CT_SHFT	= 2,
	SLI4_TSEND_BS_SHFT	= 4,
	SLI4_TSEND_LEN_LOC_BIT2 = 0x1,
	SLI4_TSEND_CCPE		= 0x80,
	SLI4_TSEND_APPID_VALID	= 0x20,
	SLI4_TSEND_WQES		= 0x80,
	SLI4_TSEND_XC		= 0x20,
	SLI4_TSEND_EAT		= 0x10,
};

struct sli4_fcp_tsend64_wqe {
	struct sli4_bde	bde;
	__le32		payload_offset_length;
	__le32		relative_offset;
	__le32		dword5;
	__le16		xri_tag;
	__le16		rpi;
	u8		ct_byte;
	u8		command;
	u8		class_pu_ar_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		remote_xid;
	u8		dw10byte0;
	u8		ll_qd_xbl_hlm_iod_dbde;
	u8		dw10byte2;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd45;
	__le16		cq_id;
	__le32		fcp_data_transmit_length;
	struct sli4_bde	first_data_bde;
};

/* WQE used to create a general request. */
enum sli4_gen_req_wqe_flags {
	SLI4_GEN_REQ64_WQE_XBL	= 0x8,
	SLI4_GEN_REQ64_WQE_DBDE	= 0x40,
	SLI4_GEN_REQ64_WQE_IOD	= 0x20,
	SLI4_GEN_REQ64_WQE_QOSD	= 0x2,
	SLI4_GEN_REQ64_WQE_HLM	= 0x10,
	SLI4_GEN_REQ64_CT_SHFT	= 2,
};

struct sli4_gen_request64_wqe {
	struct sli4_bde	bde;
	__le32		request_payload_length;
	__le32		relative_offset;
	u8		rsvd17;
	u8		df_ctl;
	u8		type;
	u8		r_ctl;
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		rsvd34;
	u8		dw10flags0;
	u8		dw10flags1;
	u8		dw10flags2;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		remote_n_port_id_dword;
	__le32		rsvd48;
	__le32		rsvd52;
	__le32		max_response_payload_length;
};

/* WQE used to create a send frame request */
enum sli4_sf_wqe_flags {
	SLI4_SF_WQE_DBDE	= 0x40,
	SLI4_SF_PU		= 0x30,
	SLI4_SF_CT		= 0xc,
	SLI4_SF_QOSD		= 0x2,
	SLI4_SF_LEN_LOC_BIT1	= 0x80,
	SLI4_SF_LEN_LOC_BIT2	= 0x1,
	SLI4_SF_XC		= 0x20,
	SLI4_SF_XBL		= 0x8,
};

struct sli4_send_frame_wqe {
	struct sli4_bde	bde;
	__le32		frame_length;
	__le32		fc_header_0_1[2];
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		dw7flags0;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	u8		eof;
	u8		sof;
	u8		dw10flags0;
	u8		dw10flags1;
	u8		dw10flags2;
	u8		ccp;
	u8		cmd_type_byte;
	u8		rsvd41;
	__le16		cq_id;
	__le32		fc_header_2_5[4];
};

/* WQE used to create a transmit sequence */
enum sli4_seq_wqe_flags {
	SLI4_SEQ_WQE_DBDE		= 0x4000,
	SLI4_SEQ_WQE_XBL		= 0x800,
	SLI4_SEQ_WQE_SI			= 0x4,
	SLI4_SEQ_WQE_FT			= 0x8,
	SLI4_SEQ_WQE_XO			= 0x40,
	SLI4_SEQ_WQE_LS			= 0x80,
	SLI4_SEQ_WQE_DIF		= 0x3,
	SLI4_SEQ_WQE_BS			= 0x70,
	SLI4_SEQ_WQE_PU			= 0x30,
	SLI4_SEQ_WQE_HLM		= 0x1000,
	SLI4_SEQ_WQE_IOD_SHIFT		= 13,
	SLI4_SEQ_WQE_CT_SHIFT		= 2,
	SLI4_SEQ_WQE_LEN_LOC_SHIFT	= 7,
};

struct sli4_xmit_sequence64_wqe {
	struct sli4_bde	bde;
	__le32		remote_n_port_id_dword;
	__le32		relative_offset;
	u8		dw5flags0;
	u8		df_ctl;
	u8		type;
	u8		r_ctl;
	__le16		xri_tag;
	__le16		context_tag;
	u8		dw7flags0;
	u8		command;
	u8		dw7flags1;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		remote_xid;
	__le16		dw10w0;
	u8		dw10flags0;
	u8		ccp;
	u8		cmd_type_wqec_byte;
	u8		rsvd45;
	__le16		cq_id;
	__le32		sequence_payload_len;
	__le32		rsvd48;
	__le32		rsvd52;
	__le32		rsvd56;
};

/*
 * WQE used unblock the specified XRI and to release
 * it to the SLI Port's free pool.
 */
enum sli4_requeue_wqe_flags {
	SLI4_REQU_XRI_WQE_XC	= 0x20,
	SLI4_REQU_XRI_WQE_QOSD	= 0x2,
};

struct sli4_requeue_xri_wqe {
	__le32		rsvd0;
	__le32		rsvd4;
	__le32		rsvd8;
	__le32		rsvd12;
	__le32		rsvd16;
	__le32		rsvd20;
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		rsvd32;
	__le16		request_tag;
	__le16		rsvd34;
	__le16		flags0;
	__le16		flags1;
	__le16		flags2;
	u8		ccp;
	u8		cmd_type_wqec_byte;
	u8		rsvd42;
	__le16		cq_id;
	__le32		rsvd44;
	__le32		rsvd48;
	__le32		rsvd52;
	__le32		rsvd56;
};

/* WQE used to create a BLS response */
enum sli4_bls_rsp_wqe_flags {
	SLI4_BLS_RSP_RID		= 0xffffff,
	SLI4_BLS_RSP_WQE_AR		= 0x40000000,
	SLI4_BLS_RSP_WQE_CT_SHFT	= 2,
	SLI4_BLS_RSP_WQE_QOSD		= 0x2,
	SLI4_BLS_RSP_WQE_HLM		= 0x10,
};

struct sli4_xmit_bls_rsp_wqe {
	__le32		payload_word0;
	__le16		rx_id;
	__le16		ox_id;
	__le16		high_seq_cnt;
	__le16		low_seq_cnt;
	__le32		rsvd12;
	__le32		local_n_port_id_dword;
	__le32		remote_id_dword;
	__le16		xri_tag;
	__le16		context_tag;
	u8		dw8flags0;
	u8		command;
	u8		dw8flags1;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		rsvd38;
	u8		dw11flags0;
	u8		dw11flags1;
	u8		dw11flags2;
	u8		ccp;
	u8		dw12flags0;
	u8		rsvd45;
	__le16		cq_id;
	__le16		temporary_rpi;
	u8		rsvd50;
	u8		rsvd51;
	__le32		rsvd52;
	__le32		rsvd56;
	__le32		rsvd60;
};

enum sli_bls_type {
	SLI4_SLI_BLS_ACC,
	SLI4_SLI_BLS_RJT,
	SLI4_SLI_BLS_MAX
};

struct sli_bls_payload {
	enum sli_bls_type	type;
	__le16			ox_id;
	__le16			rx_id;
	union {
		struct {
			u8	seq_id_validity;
			u8	seq_id_last;
			u8	rsvd2;
			u8	rsvd3;
			u16	ox_id;
			u16	rx_id;
			__le16	low_seq_cnt;
			__le16	high_seq_cnt;
		} acc;
		struct {
			u8	vendor_unique;
			u8	reason_explanation;
			u8	reason_code;
			u8	rsvd3;
		} rjt;
	} u;
};

/* WQE used to create an ELS response */

enum sli4_els_rsp_flags {
	SLI4_ELS_SID		= 0xffffff,
	SLI4_ELS_RID		= 0xffffff,
	SLI4_ELS_DBDE		= 0x40,
	SLI4_ELS_XBL		= 0x8,
	SLI4_ELS_IOD		= 0x20,
	SLI4_ELS_QOSD		= 0x2,
	SLI4_ELS_XC		= 0x20,
	SLI4_ELS_CT_OFFSET	= 0X2,
	SLI4_ELS_SP		= 0X1000000,
	SLI4_ELS_HLM		= 0X10,
};

struct sli4_xmit_els_rsp64_wqe {
	struct sli4_bde	els_response_payload;
	__le32		els_response_payload_length;
	__le32		sid_dw;
	__le32		rid_dw;
	__le16		xri_tag;
	__le16		context_tag;
	u8		ct_byte;
	u8		command;
	u8		class_byte;
	u8		timer;
	__le32		abort_tag;
	__le16		request_tag;
	__le16		ox_id;
	u8		flags1;
	u8		flags2;
	u8		flags3;
	u8		flags4;
	u8		cmd_type_wqec;
	u8		rsvd34;
	__le16		cq_id;
	__le16		temporary_rpi;
	__le16		rsvd38;
	u32		rsvd40;
	u32		rsvd44;
	u32		rsvd48;
};

/* Local Reject Reason Codes */
enum sli4_fc_local_rej_codes {
	SLI4_FC_LOCAL_REJECT_UNKNOWN,
	SLI4_FC_LOCAL_REJECT_MISSING_CONTINUE,
	SLI4_FC_LOCAL_REJECT_SEQUENCE_TIMEOUT,
	SLI4_FC_LOCAL_REJECT_INTERNAL_ERROR,
	SLI4_FC_LOCAL_REJECT_INVALID_RPI,
	SLI4_FC_LOCAL_REJECT_NO_XRI,
	SLI4_FC_LOCAL_REJECT_ILLEGAL_COMMAND,
	SLI4_FC_LOCAL_REJECT_XCHG_DROPPED,
	SLI4_FC_LOCAL_REJECT_ILLEGAL_FIELD,
	SLI4_FC_LOCAL_REJECT_RPI_SUSPENDED,
	SLI4_FC_LOCAL_REJECT_RSVD,
	SLI4_FC_LOCAL_REJECT_RSVD1,
	SLI4_FC_LOCAL_REJECT_NO_ABORT_MATCH,
	SLI4_FC_LOCAL_REJECT_TX_DMA_FAILED,
	SLI4_FC_LOCAL_REJECT_RX_DMA_FAILED,
	SLI4_FC_LOCAL_REJECT_ILLEGAL_FRAME,
	SLI4_FC_LOCAL_REJECT_RSVD2,
	SLI4_FC_LOCAL_REJECT_NO_RESOURCES, //0x11
	SLI4_FC_LOCAL_REJECT_FCP_CONF_FAILURE,
	SLI4_FC_LOCAL_REJECT_ILLEGAL_LENGTH,
	SLI4_FC_LOCAL_REJECT_UNSUPPORTED_FEATURE,
	SLI4_FC_LOCAL_REJECT_ABORT_IN_PROGRESS,
	SLI4_FC_LOCAL_REJECT_ABORT_REQUESTED,
	SLI4_FC_LOCAL_REJECT_RCV_BUFFER_TIMEOUT,
	SLI4_FC_LOCAL_REJECT_LOOP_OPEN_FAILURE,
	SLI4_FC_LOCAL_REJECT_RSVD3,
	SLI4_FC_LOCAL_REJECT_LINK_DOWN,
	SLI4_FC_LOCAL_REJECT_CORRUPTED_DATA,
	SLI4_FC_LOCAL_REJECT_CORRUPTED_RPI,
	SLI4_FC_LOCAL_REJECT_OUTOFORDER_DATA,
	SLI4_FC_LOCAL_REJECT_OUTOFORDER_ACK,
	SLI4_FC_LOCAL_REJECT_DUP_FRAME,
	SLI4_FC_LOCAL_REJECT_LINK_CONTROL_FRAME, //0x20
	SLI4_FC_LOCAL_REJECT_BAD_HOST_ADDRESS,
	SLI4_FC_LOCAL_REJECT_RSVD4,
	SLI4_FC_LOCAL_REJECT_MISSING_HDR_BUFFER,
	SLI4_FC_LOCAL_REJECT_MSEQ_CHAIN_CORRUPTED,
	SLI4_FC_LOCAL_REJECT_ABORTMULT_REQUESTED,
	SLI4_FC_LOCAL_REJECT_BUFFER_SHORTAGE	= 0x28,
	SLI4_FC_LOCAL_REJECT_RCV_XRIBUF_WAITING,
	SLI4_FC_LOCAL_REJECT_INVALID_VPI	= 0x2e,
	SLI4_FC_LOCAL_REJECT_NO_FPORT_DETECTED,
	SLI4_FC_LOCAL_REJECT_MISSING_XRIBUF,
	SLI4_FC_LOCAL_REJECT_RSVD5,
	SLI4_FC_LOCAL_REJECT_INVALID_XRI,
	SLI4_FC_LOCAL_REJECT_INVALID_RELOFFSET	= 0x40,
	SLI4_FC_LOCAL_REJECT_MISSING_RELOFFSET,
	SLI4_FC_LOCAL_REJECT_INSUFF_BUFFERSPACE,
	SLI4_FC_LOCAL_REJECT_MISSING_SI,
	SLI4_FC_LOCAL_REJECT_MISSING_ES,
	SLI4_FC_LOCAL_REJECT_INCOMPLETE_XFER,
	SLI4_FC_LOCAL_REJECT_SLER_FAILURE,
	SLI4_FC_LOCAL_REJECT_SLER_CMD_RCV_FAILURE,
	SLI4_FC_LOCAL_REJECT_SLER_REC_RJT_ERR,
	SLI4_FC_LOCAL_REJECT_SLER_REC_SRR_RETRY_ERR,
	SLI4_FC_LOCAL_REJECT_SLER_SRR_RJT_ERR,
	SLI4_FC_LOCAL_REJECT_RSVD6,
	SLI4_FC_LOCAL_REJECT_SLER_RRQ_RJT_ERR,
	SLI4_FC_LOCAL_REJECT_SLER_RRQ_RETRY_ERR,
	SLI4_FC_LOCAL_REJECT_SLER_ABTS_ERR,
};

enum sli4_async_rcqe_flags {
	SLI4_RACQE_RQ_EL_INDX	= 0xfff,
	SLI4_RACQE_FCFI		= 0x3f,
	SLI4_RACQE_HDPL		= 0x3f,
	SLI4_RACQE_RQ_ID	= 0xffc0,
};

struct sli4_fc_async_rcqe {
	u8		rsvd0;
	u8		status;
	__le16		rq_elmt_indx_word;
	__le32		rsvd4;
	__le16		fcfi_rq_id_word;
	__le16		data_placement_length;
	u8		sof_byte;
	u8		eof_byte;
	u8		code;
	u8		hdpl_byte;
};

struct sli4_fc_async_rcqe_v1 {
	u8		rsvd0;
	u8		status;
	__le16		rq_elmt_indx_word;
	u8		fcfi_byte;
	u8		rsvd5;
	__le16		rsvd6;
	__le16		rq_id;
	__le16		data_placement_length;
	u8		sof_byte;
	u8		eof_byte;
	u8		code;
	u8		hdpl_byte;
};

enum sli4_fc_async_rq_status {
	SLI4_FC_ASYNC_RQ_SUCCESS = 0x10,
	SLI4_FC_ASYNC_RQ_BUF_LEN_EXCEEDED,
	SLI4_FC_ASYNC_RQ_INSUFF_BUF_NEEDED,
	SLI4_FC_ASYNC_RQ_INSUFF_BUF_FRM_DISC,
	SLI4_FC_ASYNC_RQ_DMA_FAILURE,
};

#define SLI4_RCQE_RQ_EL_INDX	0xfff

struct sli4_fc_coalescing_rcqe {
	u8		rsvd0;
	u8		status;
	__le16		rq_elmt_indx_word;
	__le32		rsvd4;
	__le16		rq_id;
	__le16		seq_placement_length;
	__le16		rsvd14;
	u8		code;
	u8		vld_byte;
};

#define SLI4_FC_COALESCE_RQ_SUCCESS		0x10
#define SLI4_FC_COALESCE_RQ_INSUFF_XRI_NEEDED	0x18

enum sli4_optimized_write_cmd_cqe_flags {
	SLI4_OCQE_RQ_EL_INDX	= 0x7f,		/* DW0 bits 16:30 */
	SLI4_OCQE_FCFI		= 0x3f,		/* DW1 bits 0:6 */
	SLI4_OCQE_OOX		= 1 << 6,	/* DW1 bit 15 */
	SLI4_OCQE_AGXR		= 1 << 7,	/* DW1 bit 16 */
	SLI4_OCQE_HDPL		= 0x3f,		/* DW3 bits 24:29*/
};

struct sli4_fc_optimized_write_cmd_cqe {
	u8		rsvd0;
	u8		status;
	__le16		w1;
	u8		flags0;
	u8		flags1;
	__le16		xri;
	__le16		rq_id;
	__le16		data_placement_length;
	__le16		rpi;
	u8		code;
	u8		hdpl_vld;
};

#define	SLI4_OCQE_XB		0x10

struct sli4_fc_optimized_write_data_cqe {
	u8		hw_status;
	u8		status;
	__le16		xri;
	__le32		total_data_placed;
	__le32		extended_status;
	__le16		rsvd12;
	u8		code;
	u8		flags;
};

struct sli4_fc_xri_aborted_cqe {
	u8		rsvd0;
	u8		status;
	__le16		rsvd2;
	__le32		extended_status;
	__le16		xri;
	__le16		remote_xid;
	__le16		rsvd12;
	u8		code;
	u8		flags;
};

enum sli4_generic_ctx {
	SLI4_GENERIC_CONTEXT_RPI,
	SLI4_GENERIC_CONTEXT_VPI,
	SLI4_GENERIC_CONTEXT_VFI,
	SLI4_GENERIC_CONTEXT_FCFI,
};

#define SLI4_GENERIC_CLASS_CLASS_2		0x1
#define SLI4_GENERIC_CLASS_CLASS_3		0x2

#define SLI4_ELS_REQUEST64_DIR_WRITE		0x0
#define SLI4_ELS_REQUEST64_DIR_READ		0x1

enum sli4_els_request {
	SLI4_ELS_REQUEST64_OTHER,
	SLI4_ELS_REQUEST64_LOGO,
	SLI4_ELS_REQUEST64_FDISC,
	SLI4_ELS_REQUEST64_FLOGIN,
	SLI4_ELS_REQUEST64_PLOGI,
};

enum sli4_els_cmd_type {
	SLI4_ELS_REQUEST64_CMD_GEN		= 0x08,
	SLI4_ELS_REQUEST64_CMD_NON_FABRIC	= 0x0c,
	SLI4_ELS_REQUEST64_CMD_FABRIC		= 0x0d,
};

#define SLI_PAGE_SIZE				SZ_4K

#define SLI4_BMBX_TIMEOUT_MSEC			30000
#define SLI4_FW_READY_TIMEOUT_MSEC		30000

#define SLI4_BMBX_DELAY_US			1000	/* 1 ms */
#define SLI4_INIT_PORT_DELAY_US			10000	/* 10 ms */

static inline u32
sli_page_count(size_t bytes, u32 page_size)
{
	if (!page_size)
		return 0;

	return (bytes + (page_size - 1)) >> __ffs(page_size);
}

/*************************************************************************
 * SLI-4 mailbox command formats and definitions
 */

struct sli4_mbox_command_header {
	u8	resvd0;
	u8	command;
	__le16	status;	/* Port writes to indicate success/fail */
};

enum sli4_mbx_cmd_value {
	SLI4_MBX_CMD_CONFIG_LINK	= 0x07,
	SLI4_MBX_CMD_DUMP		= 0x17,
	SLI4_MBX_CMD_DOWN_LINK		= 0x06,
	SLI4_MBX_CMD_INIT_LINK		= 0x05,
	SLI4_MBX_CMD_INIT_VFI		= 0xa3,
	SLI4_MBX_CMD_INIT_VPI		= 0xa4,
	SLI4_MBX_CMD_POST_XRI		= 0xa7,
	SLI4_MBX_CMD_RELEASE_XRI	= 0xac,
	SLI4_MBX_CMD_READ_CONFIG	= 0x0b,
	SLI4_MBX_CMD_READ_STATUS	= 0x0e,
	SLI4_MBX_CMD_READ_NVPARMS	= 0x02,
	SLI4_MBX_CMD_READ_REV		= 0x11,
	SLI4_MBX_CMD_READ_LNK_STAT	= 0x12,
	SLI4_MBX_CMD_READ_SPARM64	= 0x8d,
	SLI4_MBX_CMD_READ_TOPOLOGY	= 0x95,
	SLI4_MBX_CMD_REG_FCFI		= 0xa0,
	SLI4_MBX_CMD_REG_FCFI_MRQ	= 0xaf,
	SLI4_MBX_CMD_REG_RPI		= 0x93,
	SLI4_MBX_CMD_REG_RX_RQ		= 0xa6,
	SLI4_MBX_CMD_REG_VFI		= 0x9f,
	SLI4_MBX_CMD_REG_VPI		= 0x96,
	SLI4_MBX_CMD_RQST_FEATURES	= 0x9d,
	SLI4_MBX_CMD_SLI_CONFIG		= 0x9b,
	SLI4_MBX_CMD_UNREG_FCFI		= 0xa2,
	SLI4_MBX_CMD_UNREG_RPI		= 0x14,
	SLI4_MBX_CMD_UNREG_VFI		= 0xa1,
	SLI4_MBX_CMD_UNREG_VPI		= 0x97,
	SLI4_MBX_CMD_WRITE_NVPARMS	= 0x03,
	SLI4_MBX_CMD_CFG_AUTO_XFER_RDY	= 0xad,
};

enum sli4_mbx_status {
	SLI4_MBX_STATUS_SUCCESS		= 0x0000,
	SLI4_MBX_STATUS_FAILURE		= 0x0001,
	SLI4_MBX_STATUS_RPI_NOT_REG	= 0x1400,
};

/* CONFIG_LINK - configure link-oriented parameters,
 * such as default N_Port_ID address and various timers
 */
enum sli4_cmd_config_link_flags {
	SLI4_CFG_LINK_BBSCN = 0xf00,
	SLI4_CFG_LINK_CSCN  = 0x1000,
};

struct sli4_cmd_config_link {
	struct sli4_mbox_command_header	hdr;
	u8		maxbbc;
	u8		rsvd5;
	u8		rsvd6;
	u8		rsvd7;
	u8		alpa;
	__le16		n_port_id;
	u8		rsvd11;
	__le32		rsvd12;
	__le32		e_d_tov;
	__le32		lp_tov;
	__le32		r_a_tov;
	__le32		r_t_tov;
	__le32		al_tov;
	__le32		rsvd36;
	__le32		bbscn_dword;
};

#define SLI4_DUMP4_TYPE		0xf

#define SLI4_WKI_TAG_SAT_TEM	0x1040

struct sli4_cmd_dump4 {
	struct sli4_mbox_command_header	hdr;
	__le32		type_dword;
	__le16		wki_selection;
	__le16		rsvd10;
	__le32		rsvd12;
	__le32		returned_byte_cnt;
	__le32		resp_data[59];
};

/* INIT_LINK - initialize the link for a FC port */
enum sli4_init_link_flags {
	SLI4_INIT_LINK_F_LOOPBACK	= 1 << 0,

	SLI4_INIT_LINK_F_P2P_ONLY	= 1 << 1,
	SLI4_INIT_LINK_F_FCAL_ONLY	= 2 << 1,
	SLI4_INIT_LINK_F_FCAL_FAIL_OVER	= 0 << 1,
	SLI4_INIT_LINK_F_P2P_FAIL_OVER	= 1 << 1,

	SLI4_INIT_LINK_F_UNFAIR		= 1 << 6,
	SLI4_INIT_LINK_F_NO_LIRP	= 1 << 7,
	SLI4_INIT_LINK_F_LOOP_VALID_CHK	= 1 << 8,
	SLI4_INIT_LINK_F_NO_LISA	= 1 << 9,
	SLI4_INIT_LINK_F_FAIL_OVER	= 1 << 10,
	SLI4_INIT_LINK_F_FIXED_SPEED	= 1 << 11,
	SLI4_INIT_LINK_F_PICK_HI_ALPA	= 1 << 15,

};

enum sli4_fc_link_speed {
	SLI4_LINK_SPEED_1G = 1,
	SLI4_LINK_SPEED_2G,
	SLI4_LINK_SPEED_AUTO_1_2,
	SLI4_LINK_SPEED_4G,
	SLI4_LINK_SPEED_AUTO_4_1,
	SLI4_LINK_SPEED_AUTO_4_2,
	SLI4_LINK_SPEED_AUTO_4_2_1,
	SLI4_LINK_SPEED_8G,
	SLI4_LINK_SPEED_AUTO_8_1,
	SLI4_LINK_SPEED_AUTO_8_2,
	SLI4_LINK_SPEED_AUTO_8_2_1,
	SLI4_LINK_SPEED_AUTO_8_4,
	SLI4_LINK_SPEED_AUTO_8_4_1,
	SLI4_LINK_SPEED_AUTO_8_4_2,
	SLI4_LINK_SPEED_10G,
	SLI4_LINK_SPEED_16G,
	SLI4_LINK_SPEED_AUTO_16_8_4,
	SLI4_LINK_SPEED_AUTO_16_8,
	SLI4_LINK_SPEED_32G,
	SLI4_LINK_SPEED_AUTO_32_16_8,
	SLI4_LINK_SPEED_AUTO_32_16,
	SLI4_LINK_SPEED_64G,
	SLI4_LINK_SPEED_AUTO_64_32_16,
	SLI4_LINK_SPEED_AUTO_64_32,
	SLI4_LINK_SPEED_128G,
	SLI4_LINK_SPEED_AUTO_128_64_32,
	SLI4_LINK_SPEED_AUTO_128_64,
};

struct sli4_cmd_init_link {
	struct sli4_mbox_command_header       hdr;
	__le32	sel_reset_al_pa_dword;
	__le32	flags0;
	__le32	link_speed_sel_code;
};

/* INIT_VFI - initialize the VFI resource */
enum sli4_init_vfi_flags {
	SLI4_INIT_VFI_FLAG_VP	= 0x1000,
	SLI4_INIT_VFI_FLAG_VF	= 0x2000,
	SLI4_INIT_VFI_FLAG_VT	= 0x4000,
	SLI4_INIT_VFI_FLAG_VR	= 0x8000,

	SLI4_INIT_VFI_VFID	= 0x1fff,
	SLI4_INIT_VFI_PRI	= 0xe000,

	SLI4_INIT_VFI_HOP_COUNT = 0xff000000,
};

struct sli4_cmd_init_vfi {
	struct sli4_mbox_command_header	hdr;
	__le16		vfi;
	__le16		flags0_word;
	__le16		fcfi;
	__le16		vpi;
	__le32		vf_id_pri_dword;
	__le32		hop_cnt_dword;
};

/* INIT_VPI - initialize the VPI resource */
struct sli4_cmd_init_vpi {
	struct sli4_mbox_command_header	hdr;
	__le16		vpi;
	__le16		vfi;
};

/* POST_XRI - post XRI resources to the SLI Port */
enum sli4_post_xri_flags {
	SLI4_POST_XRI_COUNT	= 0xfff,
	SLI4_POST_XRI_FLAG_ENX	= 0x1000,
	SLI4_POST_XRI_FLAG_DL	= 0x2000,
	SLI4_POST_XRI_FLAG_DI	= 0x4000,
	SLI4_POST_XRI_FLAG_VAL	= 0x8000,
};

struct sli4_cmd_post_xri {
	struct sli4_mbox_command_header	hdr;
	__le16		xri_base;
	__le16		xri_count_flags;
};

/* RELEASE_XRI - Release XRI resources from the SLI Port */
enum sli4_release_xri_flags {
	SLI4_RELEASE_XRI_REL_XRI_CNT	= 0x1f,
	SLI4_RELEASE_XRI_COUNT		= 0x1f,
};

struct sli4_cmd_release_xri {
	struct sli4_mbox_command_header	hdr;
	__le16		rel_xri_count_word;
	__le16		xri_count_word;

	struct {
		__le16	xri_tag0;
		__le16	xri_tag1;
	} xri_tbl[62];
};

/* READ_CONFIG - read SLI port configuration parameters */
struct sli4_cmd_read_config {
	struct sli4_mbox_command_header	hdr;
};

enum sli4_read_cfg_resp_flags {
	SLI4_READ_CFG_RESP_RESOURCE_EXT = 0x80000000,	/* DW1 */
	SLI4_READ_CFG_RESP_TOPOLOGY	= 0xff000000,	/* DW2 */
};

enum sli4_read_cfg_topo {
	SLI4_READ_CFG_TOPO_FC		= 0x1,	/* FC topology unknown */
	SLI4_READ_CFG_TOPO_NON_FC_AL	= 0x2,	/* FC point-to-point or fabric */
	SLI4_READ_CFG_TOPO_FC_AL	= 0x3,	/* FC-AL topology */
};

/* Link Module Type */
enum sli4_read_cfg_lmt {
	SLI4_LINK_MODULE_TYPE_1GB	= 0x0004,
	SLI4_LINK_MODULE_TYPE_2GB	= 0x0008,
	SLI4_LINK_MODULE_TYPE_4GB	= 0x0040,
	SLI4_LINK_MODULE_TYPE_8GB	= 0x0080,
	SLI4_LINK_MODULE_TYPE_16GB	= 0x0200,
	SLI4_LINK_MODULE_TYPE_32GB	= 0x0400,
	SLI4_LINK_MODULE_TYPE_64GB	= 0x0800,
	SLI4_LINK_MODULE_TYPE_128GB	= 0x1000,
};

struct sli4_rsp_read_config {
	struct sli4_mbox_command_header	hdr;
	__le32		ext_dword;
	__le32		topology_dword;
	__le32		resvd8;
	__le16		e_d_tov;
	__le16		resvd14;
	__le32		resvd16;
	__le16		r_a_tov;
	__le16		resvd22;
	__le32		resvd24;
	__le32		resvd28;
	__le16		lmt;
	__le16		resvd34;
	__le32		resvd36;
	__le32		resvd40;
	__le16		xri_base;
	__le16		xri_count;
	__le16		rpi_base;
	__le16		rpi_count;
	__le16		vpi_base;
	__le16		vpi_count;
	__le16		vfi_base;
	__le16		vfi_count;
	__le16		resvd60;
	__le16		fcfi_count;
	__le16		rq_count;
	__le16		eq_count;
	__le16		wq_count;
	__le16		cq_count;
	__le32		pad[45];
};

/* READ_NVPARMS - read SLI port configuration parameters */
enum sli4_read_nvparms_flags {
	SLI4_READ_NVPARAMS_HARD_ALPA	  = 0xff,
	SLI4_READ_NVPARAMS_PREFERRED_D_ID = 0xffffff00,
};

struct sli4_cmd_read_nvparms {
	struct sli4_mbox_command_header	hdr;
	__le32		resvd0;
	__le32		resvd4;
	__le32		resvd8;
	__le32		resvd12;
	u8		wwpn[8];
	u8		wwnn[8];
	__le32		hard_alpa_d_id;
};

/* WRITE_NVPARMS - write SLI port configuration parameters */
struct sli4_cmd_write_nvparms {
	struct sli4_mbox_command_header	hdr;
	__le32		resvd0;
	__le32		resvd4;
	__le32		resvd8;
	__le32		resvd12;
	u8		wwpn[8];
	u8		wwnn[8];
	__le32		hard_alpa_d_id;
};

/* READ_REV - read the Port revision levels */
enum {
	SLI4_READ_REV_FLAG_SLI_LEVEL	= 0xf,
	SLI4_READ_REV_FLAG_FCOEM	= 0x10,
	SLI4_READ_REV_FLAG_CEEV		= 0x60,
	SLI4_READ_REV_FLAG_VPD		= 0x2000,

	SLI4_READ_REV_AVAILABLE_LENGTH	= 0xffffff,
};

struct sli4_cmd_read_rev {
	struct sli4_mbox_command_header	hdr;
	__le16			resvd0;
	__le16			flags0_word;
	__le32			first_hw_rev;
	__le32			second_hw_rev;
	__le32			resvd12;
	__le32			third_hw_rev;
	u8			fc_ph_low;
	u8			fc_ph_high;
	u8			feature_level_low;
	u8			feature_level_high;
	__le32			resvd24;
	__le32			first_fw_id;
	u8			first_fw_name[16];
	__le32			second_fw_id;
	u8			second_fw_name[16];
	__le32			rsvd18[30];
	__le32			available_length_dword;
	struct sli4_dmaaddr	hostbuf;
	__le32			returned_vpd_length;
	__le32			actual_vpd_length;
};

/* READ_SPARM64 - read the Port service parameters */
#define SLI4_READ_SPARM64_WWPN_OFFSET	(4 * sizeof(u32))
#define SLI4_READ_SPARM64_WWNN_OFFSET	(6 * sizeof(u32))

struct sli4_cmd_read_sparm64 {
	struct sli4_mbox_command_header hdr;
	__le32			resvd0;
	__le32			resvd4;
	struct sli4_bde		bde_64;
	__le16			vpi;
	__le16			resvd22;
	__le16			port_name_start;
	__le16			port_name_len;
	__le16			node_name_start;
	__le16			node_name_len;
};

/* READ_TOPOLOGY - read the link event information */
enum sli4_read_topo_e {
	SLI4_READTOPO_ATTEN_TYPE	= 0xff,
	SLI4_READTOPO_FLAG_IL		= 0x100,
	SLI4_READTOPO_FLAG_PB_RECVD	= 0x200,

	SLI4_READTOPO_LINKSTATE_RECV	= 0x3,
	SLI4_READTOPO_LINKSTATE_TRANS	= 0xc,
	SLI4_READTOPO_LINKSTATE_MACHINE	= 0xf0,
	SLI4_READTOPO_LINKSTATE_SPEED	= 0xff00,
	SLI4_READTOPO_LINKSTATE_TF	= 0x40000000,
	SLI4_READTOPO_LINKSTATE_LU	= 0x80000000,

	SLI4_READTOPO_SCN_BBSCN		= 0xf,
	SLI4_READTOPO_SCN_CBBSCN	= 0xf0,

	SLI4_READTOPO_R_T_TOV		= 0x1ff,
	SLI4_READTOPO_AL_TOV		= 0xf000,

	SLI4_READTOPO_PB_FLAG		= 0x80,

	SLI4_READTOPO_INIT_N_PORTID	= 0xffffff,
};

#define SLI4_MIN_LOOP_MAP_BYTES	128

struct sli4_cmd_read_topology {
	struct sli4_mbox_command_header	hdr;
	__le32			event_tag;
	__le32			dw2_attentype;
	u8			topology;
	u8			lip_type;
	u8			lip_al_ps;
	u8			al_pa_granted;
	struct sli4_bde		bde_loop_map;
	__le32			linkdown_state;
	__le32			currlink_state;
	u8			max_bbc;
	u8			init_bbc;
	u8			scn_flags;
	u8			rsvd39;
	__le16			dw10w0_al_rt_tov;
	__le16			lp_tov;
	u8			acquired_al_pa;
	u8			pb_flags;
	__le16			specified_al_pa;
	__le32			dw12_init_n_port_id;
};

enum sli4_read_topo_link {
	SLI4_READ_TOPOLOGY_LINK_UP	= 0x1,
	SLI4_READ_TOPOLOGY_LINK_DOWN,
	SLI4_READ_TOPOLOGY_LINK_NO_ALPA,
};

enum sli4_read_topo {
	SLI4_READ_TOPO_UNKNOWN		= 0x0,
	SLI4_READ_TOPO_NON_FC_AL,
	SLI4_READ_TOPO_FC_AL,
};

enum sli4_read_topo_speed {
	SLI4_READ_TOPOLOGY_SPEED_NONE	= 0x00,
	SLI4_READ_TOPOLOGY_SPEED_1G	= 0x04,
	SLI4_READ_TOPOLOGY_SPEED_2G	= 0x08,
	SLI4_READ_TOPOLOGY_SPEED_4G	= 0x10,
	SLI4_READ_TOPOLOGY_SPEED_8G	= 0x20,
	SLI4_READ_TOPOLOGY_SPEED_10G	= 0x40,
	SLI4_READ_TOPOLOGY_SPEED_16G	= 0x80,
	SLI4_READ_TOPOLOGY_SPEED_32G	= 0x90,
	SLI4_READ_TOPOLOGY_SPEED_64G	= 0xa0,
	SLI4_READ_TOPOLOGY_SPEED_128G	= 0xb0,
};

/* REG_FCFI - activate a FC Forwarder */
struct sli4_cmd_reg_fcfi_rq_cfg {
	u8	r_ctl_mask;
	u8	r_ctl_match;
	u8	type_mask;
	u8	type_match;
};

enum sli4_regfcfi_tag {
	SLI4_REGFCFI_VLAN_TAG		= 0xfff,
	SLI4_REGFCFI_VLANTAG_VALID	= 0x1000,
};

#define SLI4_CMD_REG_FCFI_NUM_RQ_CFG	4
struct sli4_cmd_reg_fcfi {
	struct sli4_mbox_command_header	hdr;
	__le16		fcf_index;
	__le16		fcfi;
	__le16		rqid1;
	__le16		rqid0;
	__le16		rqid3;
	__le16		rqid2;
	struct sli4_cmd_reg_fcfi_rq_cfg
			rq_cfg[SLI4_CMD_REG_FCFI_NUM_RQ_CFG];
	__le32		dw8_vlan;
};

#define SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG	4
#define SLI4_CMD_REG_FCFI_MRQ_MAX_NUM_RQ	32
#define SLI4_CMD_REG_FCFI_SET_FCFI_MODE		0
#define SLI4_CMD_REG_FCFI_SET_MRQ_MODE		1

enum sli4_reg_fcfi_mrq {
	SLI4_REGFCFI_MRQ_VLAN_TAG	= 0xfff,
	SLI4_REGFCFI_MRQ_VLANTAG_VALID	= 0x1000,
	SLI4_REGFCFI_MRQ_MODE		= 0x2000,

	SLI4_REGFCFI_MRQ_MASK_NUM_PAIRS	= 0xff,
	SLI4_REGFCFI_MRQ_FILTER_BITMASK = 0xf00,
	SLI4_REGFCFI_MRQ_RQ_SEL_POLICY	= 0xf000,
};

struct sli4_cmd_reg_fcfi_mrq {
	struct sli4_mbox_command_header	hdr;
	__le16		fcf_index;
	__le16		fcfi;
	__le16		rqid1;
	__le16		rqid0;
	__le16		rqid3;
	__le16		rqid2;
	struct sli4_cmd_reg_fcfi_rq_cfg
			rq_cfg[SLI4_CMD_REG_FCFI_MRQ_NUM_RQ_CFG];
	__le32		dw8_vlan;
	__le32		dw9_mrqflags;
};

struct sli4_cmd_rq_cfg {
	__le16	rq_id;
	u8	r_ctl_mask;
	u8	r_ctl_match;
	u8	type_mask;
	u8	type_match;
};

/* REG_RPI - register a Remote Port Indicator */
enum sli4_reg_rpi {
	SLI4_REGRPI_REMOTE_N_PORTID	= 0xffffff,	/* DW2 */
	SLI4_REGRPI_UPD			= 0x1000000,
	SLI4_REGRPI_ETOW		= 0x8000000,
	SLI4_REGRPI_TERP		= 0x20000000,
	SLI4_REGRPI_CI			= 0x80000000,
};

struct sli4_cmd_reg_rpi {
	struct sli4_mbox_command_header	hdr;
	__le16			rpi;
	__le16			rsvd2;
	__le32			dw2_rportid_flags;
	struct sli4_bde		bde_64;
	__le16			vpi;
	__le16			rsvd26;
};

#define SLI4_REG_RPI_BUF_LEN		0x70

/* REG_VFI - register a Virtual Fabric Indicator */
enum sli_reg_vfi {
	SLI4_REGVFI_VP			= 0x1000,	/* DW1 */
	SLI4_REGVFI_UPD			= 0x2000,

	SLI4_REGVFI_LOCAL_N_PORTID	= 0xffffff,	/* DW10 */
};

struct sli4_cmd_reg_vfi {
	struct sli4_mbox_command_header	hdr;
	__le16			vfi;
	__le16			dw0w1_flags;
	__le16			fcfi;
	__le16			vpi;
	u8			wwpn[8];
	struct sli4_bde		sparm;
	__le32			e_d_tov;
	__le32			r_a_tov;
	__le32			dw10_lportid_flags;
};

/* REG_VPI - register a Virtual Port Indicator */
enum sli4_reg_vpi {
	SLI4_REGVPI_LOCAL_N_PORTID	= 0xffffff,
	SLI4_REGVPI_UPD			= 0x1000000,
};

struct sli4_cmd_reg_vpi {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le32		dw2_lportid_flags;
	u8		wwpn[8];
	__le32		rsvd12;
	__le16		vpi;
	__le16		vfi;
};

/* REQUEST_FEATURES - request / query SLI features */
enum sli4_req_features_flags {
	SLI4_REQFEAT_QRY	= 0x1,		/* Dw1 */

	SLI4_REQFEAT_IAAB	= 1 << 0,	/* DW2 & DW3 */
	SLI4_REQFEAT_NPIV	= 1 << 1,
	SLI4_REQFEAT_DIF	= 1 << 2,
	SLI4_REQFEAT_VF		= 1 << 3,
	SLI4_REQFEAT_FCPI	= 1 << 4,
	SLI4_REQFEAT_FCPT	= 1 << 5,
	SLI4_REQFEAT_FCPC	= 1 << 6,
	SLI4_REQFEAT_RSVD	= 1 << 7,
	SLI4_REQFEAT_RQD	= 1 << 8,
	SLI4_REQFEAT_IAAR	= 1 << 9,
	SLI4_REQFEAT_HLM	= 1 << 10,
	SLI4_REQFEAT_PERFH	= 1 << 11,
	SLI4_REQFEAT_RXSEQ	= 1 << 12,
	SLI4_REQFEAT_RXRI	= 1 << 13,
	SLI4_REQFEAT_DCL2	= 1 << 14,
	SLI4_REQFEAT_RSCO	= 1 << 15,
	SLI4_REQFEAT_MRQP	= 1 << 16,
};

struct sli4_cmd_request_features {
	struct sli4_mbox_command_header	hdr;
	__le32		dw1_qry;
	__le32		cmd;
	__le32		resp;
};

/*
 * SLI_CONFIG - submit a configuration command to Port
 *
 * Command is either embedded as part of the payload (embed) or located
 * in a separate memory buffer (mem)
 */
enum sli4_sli_config {
	SLI4_SLICONF_EMB		= 0x1,		/* DW1 */
	SLI4_SLICONF_PMDCMD_SHIFT	= 3,
	SLI4_SLICONF_PMDCMD_MASK	= 0xf8,
	SLI4_SLICONF_PMDCMD_VAL_1	= 8,
	SLI4_SLICONF_PMDCNT		= 0xf8,

	SLI4_SLICONF_PMD_LEN		= 0x00ffffff,
};

struct sli4_cmd_sli_config {
	struct sli4_mbox_command_header	hdr;
	__le32		dw1_flags;
	__le32		payload_len;
	__le32		rsvd12[3];
	union {
		u8 embed[58 * sizeof(u32)];
		struct sli4_bufptr mem;
	} payload;
};

/* READ_STATUS - read tx/rx status of a particular port */
#define SLI4_READSTATUS_CLEAR_COUNTERS	0x1

struct sli4_cmd_read_status {
	struct sli4_mbox_command_header	hdr;
	__le32		dw1_flags;
	__le32		rsvd4;
	__le32		trans_kbyte_cnt;
	__le32		recv_kbyte_cnt;
	__le32		trans_frame_cnt;
	__le32		recv_frame_cnt;
	__le32		trans_seq_cnt;
	__le32		recv_seq_cnt;
	__le32		tot_exchanges_orig;
	__le32		tot_exchanges_resp;
	__le32		recv_p_bsy_cnt;
	__le32		recv_f_bsy_cnt;
	__le32		no_rq_buf_dropped_frames_cnt;
	__le32		empty_rq_timeout_cnt;
	__le32		no_xri_dropped_frames_cnt;
	__le32		empty_xri_pool_cnt;
};

/* READ_LNK_STAT - read link status of a particular port */
enum sli4_read_link_stats_flags {
	SLI4_READ_LNKSTAT_REC	= 1u << 0,
	SLI4_READ_LNKSTAT_GEC	= 1u << 1,
	SLI4_READ_LNKSTAT_W02OF	= 1u << 2,
	SLI4_READ_LNKSTAT_W03OF	= 1u << 3,
	SLI4_READ_LNKSTAT_W04OF	= 1u << 4,
	SLI4_READ_LNKSTAT_W05OF	= 1u << 5,
	SLI4_READ_LNKSTAT_W06OF	= 1u << 6,
	SLI4_READ_LNKSTAT_W07OF	= 1u << 7,
	SLI4_READ_LNKSTAT_W08OF	= 1u << 8,
	SLI4_READ_LNKSTAT_W09OF	= 1u << 9,
	SLI4_READ_LNKSTAT_W10OF = 1u << 10,
	SLI4_READ_LNKSTAT_W11OF = 1u << 11,
	SLI4_READ_LNKSTAT_W12OF	= 1u << 12,
	SLI4_READ_LNKSTAT_W13OF	= 1u << 13,
	SLI4_READ_LNKSTAT_W14OF	= 1u << 14,
	SLI4_READ_LNKSTAT_W15OF	= 1u << 15,
	SLI4_READ_LNKSTAT_W16OF	= 1u << 16,
	SLI4_READ_LNKSTAT_W17OF	= 1u << 17,
	SLI4_READ_LNKSTAT_W18OF	= 1u << 18,
	SLI4_READ_LNKSTAT_W19OF	= 1u << 19,
	SLI4_READ_LNKSTAT_W20OF	= 1u << 20,
	SLI4_READ_LNKSTAT_W21OF	= 1u << 21,
	SLI4_READ_LNKSTAT_CLRC	= 1u << 30,
	SLI4_READ_LNKSTAT_CLOF	= 1u << 31,
};

struct sli4_cmd_read_link_stats {
	struct sli4_mbox_command_header	hdr;
	__le32	dw1_flags;
	__le32	linkfail_errcnt;
	__le32	losssync_errcnt;
	__le32	losssignal_errcnt;
	__le32	primseq_errcnt;
	__le32	inval_txword_errcnt;
	__le32	crc_errcnt;
	__le32	primseq_eventtimeout_cnt;
	__le32	elastic_bufoverrun_errcnt;
	__le32	arbit_fc_al_timeout_cnt;
	__le32	adv_rx_buftor_to_buf_credit;
	__le32	curr_rx_buf_to_buf_credit;
	__le32	adv_tx_buf_to_buf_credit;
	__le32	curr_tx_buf_to_buf_credit;
	__le32	rx_eofa_cnt;
	__le32	rx_eofdti_cnt;
	__le32	rx_eofni_cnt;
	__le32	rx_soff_cnt;
	__le32	rx_dropped_no_aer_cnt;
	__le32	rx_dropped_no_avail_rpi_rescnt;
	__le32	rx_dropped_no_avail_xri_rescnt;
};

/* Format a WQE with WQ_ID Association performance hint */
static inline void
sli_set_wq_id_association(void *entry, u16 q_id)
{
	u32 *wqe = entry;

	/*
	 * Set Word 10, bit 0 to zero
	 * Set Word 10, bits 15:1 to the WQ ID
	 */
	wqe[10] &= ~0xffff;
	wqe[10] |= q_id << 1;
}

/* UNREG_FCFI - unregister a FCFI */
struct sli4_cmd_unreg_fcfi {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le16		fcfi;
	__le16		rsvd6;
};

/* UNREG_RPI - unregister one or more RPI */
enum sli4_unreg_rpi {
	SLI4_UNREG_RPI_DP	= 0x2000,
	SLI4_UNREG_RPI_II_SHIFT	= 14,
	SLI4_UNREG_RPI_II_MASK	= 0xc000,
	SLI4_UNREG_RPI_II_RPI	= 0x0000,
	SLI4_UNREG_RPI_II_VPI	= 0x4000,
	SLI4_UNREG_RPI_II_VFI	= 0x8000,
	SLI4_UNREG_RPI_II_FCFI	= 0xc000,

	SLI4_UNREG_RPI_DEST_N_PORTID_MASK = 0x00ffffff,
};

struct sli4_cmd_unreg_rpi {
	struct sli4_mbox_command_header	hdr;
	__le16		index;
	__le16		dw1w1_flags;
	__le32		dw2_dest_n_portid;
};

/* UNREG_VFI - unregister one or more VFI */
enum sli4_unreg_vfi {
	SLI4_UNREG_VFI_II_SHIFT	= 14,
	SLI4_UNREG_VFI_II_MASK	= 0xc000,
	SLI4_UNREG_VFI_II_VFI	= 0x0000,
	SLI4_UNREG_VFI_II_FCFI	= 0xc000,
};

struct sli4_cmd_unreg_vfi {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le16		index;
	__le16		dw2_flags;
};

enum sli4_unreg_type {
	SLI4_UNREG_TYPE_PORT,
	SLI4_UNREG_TYPE_DOMAIN,
	SLI4_UNREG_TYPE_FCF,
	SLI4_UNREG_TYPE_ALL
};

/* UNREG_VPI - unregister one or more VPI */
enum sli4_unreg_vpi {
	SLI4_UNREG_VPI_II_SHIFT	= 14,
	SLI4_UNREG_VPI_II_MASK	= 0xc000,
	SLI4_UNREG_VPI_II_VPI	= 0x0000,
	SLI4_UNREG_VPI_II_VFI	= 0x8000,
	SLI4_UNREG_VPI_II_FCFI	= 0xc000,
};

struct sli4_cmd_unreg_vpi {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le16		index;
	__le16		dw2w0_flags;
};

/* AUTO_XFER_RDY - Configure the auto-generate XFER-RDY feature */
struct sli4_cmd_config_auto_xfer_rdy {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le32		max_burst_len;
};

#define SLI4_CONFIG_AUTO_XFERRDY_BLKSIZE	0xffff

struct sli4_cmd_config_auto_xfer_rdy_hp {
	struct sli4_mbox_command_header	hdr;
	__le32		rsvd0;
	__le32		max_burst_len;
	__le32		dw3_esoc_flags;
	__le16		block_size;
	__le16		rsvd14;
};

/*************************************************************************
 * SLI-4 common configuration command formats and definitions
 */

/*
 * Subsystem values.
 */
enum sli4_subsystem {
	SLI4_SUBSYSTEM_COMMON	= 0x01,
	SLI4_SUBSYSTEM_LOWLEVEL	= 0x0b,
	SLI4_SUBSYSTEM_FC	= 0x0c,
	SLI4_SUBSYSTEM_DMTF	= 0x11,
};

#define	SLI4_OPC_LOWLEVEL_SET_WATCHDOG		0X36

/*
 * Common opcode (OPC) values.
 */
enum sli4_cmn_opcode {
	SLI4_CMN_FUNCTION_RESET		= 0x3d,
	SLI4_CMN_CREATE_CQ		= 0x0c,
	SLI4_CMN_CREATE_CQ_SET		= 0x1d,
	SLI4_CMN_DESTROY_CQ		= 0x36,
	SLI4_CMN_MODIFY_EQ_DELAY	= 0x29,
	SLI4_CMN_CREATE_EQ		= 0x0d,
	SLI4_CMN_DESTROY_EQ		= 0x37,
	SLI4_CMN_CREATE_MQ_EXT		= 0x5a,
	SLI4_CMN_DESTROY_MQ		= 0x35,
	SLI4_CMN_GET_CNTL_ATTRIBUTES	= 0x20,
	SLI4_CMN_NOP			= 0x21,
	SLI4_CMN_GET_RSC_EXTENT_INFO	= 0x9a,
	SLI4_CMN_GET_SLI4_PARAMS	= 0xb5,
	SLI4_CMN_QUERY_FW_CONFIG	= 0x3a,
	SLI4_CMN_GET_PORT_NAME		= 0x4d,

	SLI4_CMN_WRITE_FLASHROM		= 0x07,
	/* TRANSCEIVER Data */
	SLI4_CMN_READ_TRANS_DATA	= 0x49,
	SLI4_CMN_GET_CNTL_ADDL_ATTRS	= 0x79,
	SLI4_CMN_GET_FUNCTION_CFG	= 0xa0,
	SLI4_CMN_GET_PROFILE_CFG	= 0xa4,
	SLI4_CMN_SET_PROFILE_CFG	= 0xa5,
	SLI4_CMN_GET_PROFILE_LIST	= 0xa6,
	SLI4_CMN_GET_ACTIVE_PROFILE	= 0xa7,
	SLI4_CMN_SET_ACTIVE_PROFILE	= 0xa8,
	SLI4_CMN_READ_OBJECT		= 0xab,
	SLI4_CMN_WRITE_OBJECT		= 0xac,
	SLI4_CMN_DELETE_OBJECT		= 0xae,
	SLI4_CMN_READ_OBJECT_LIST	= 0xad,
	SLI4_CMN_SET_DUMP_LOCATION	= 0xb8,
	SLI4_CMN_SET_FEATURES		= 0xbf,
	SLI4_CMN_GET_RECFG_LINK_INFO	= 0xc9,
	SLI4_CMN_SET_RECNG_LINK_ID	= 0xca,
};

/* DMTF opcode (OPC) values */
#define DMTF_EXEC_CLP_CMD 0x01

/*
 * COMMON_FUNCTION_RESET
 *
 * Resets the Port, returning it to a power-on state. This configuration
 * command does not have a payload and should set/expect the lengths to
 * be zero.
 */
struct sli4_rqst_cmn_function_reset {
	struct sli4_rqst_hdr	hdr;
};

struct sli4_rsp_cmn_function_reset {
	struct sli4_rsp_hdr	hdr;
};

/*
 * COMMON_GET_CNTL_ATTRIBUTES
 *
 * Query for information about the SLI Port
 */
enum sli4_cntrl_attr_flags {
	SLI4_CNTL_ATTR_PORTNUM	= 0x3f,
	SLI4_CNTL_ATTR_PORTTYPE	= 0xc0,
};

struct sli4_rsp_cmn_get_cntl_attributes {
	struct sli4_rsp_hdr	hdr;
	u8		version_str[32];
	u8		manufacturer_name[32];
	__le32		supported_modes;
	u8		eprom_version_lo;
	u8		eprom_version_hi;
	__le16		rsvd17;
	__le32		mbx_ds_version;
	__le32		ep_fw_ds_version;
	u8		ncsi_version_str[12];
	__le32		def_extended_timeout;
	u8		model_number[32];
	u8		description[64];
	u8		serial_number[32];
	u8		ip_version_str[32];
	u8		fw_version_str[32];
	u8		bios_version_str[32];
	u8		redboot_version_str[32];
	u8		driver_version_str[32];
	u8		fw_on_flash_version_str[32];
	__le32		functionalities_supported;
	__le16		max_cdb_length;
	u8		asic_revision;
	u8		generational_guid0;
	__le32		generational_guid1_12[3];
	__le16		generational_guid13_14;
	u8		generational_guid15;
	u8		hba_port_count;
	__le16		default_link_down_timeout;
	u8		iscsi_version_min_max;
	u8		multifunctional_device;
	u8		cache_valid;
	u8		hba_status;
	u8		max_domains_supported;
	u8		port_num_type_flags;
	__le32		firmware_post_status;
	__le32		hba_mtu;
	u8		iscsi_features;
	u8		rsvd121[3];
	__le16		pci_vendor_id;
	__le16		pci_device_id;
	__le16		pci_sub_vendor_id;
	__le16		pci_sub_system_id;
	u8		pci_bus_number;
	u8		pci_device_number;
	u8		pci_function_number;
	u8		interface_type;
	__le64		unique_identifier;
	u8		number_of_netfilters;
	u8		rsvd122[3];
};

/*
 * COMMON_GET_CNTL_ATTRIBUTES
 *
 * This command queries the controller information from the Flash ROM.
 */
struct sli4_rqst_cmn_get_cntl_addl_attributes {
	struct sli4_rqst_hdr	hdr;
};

struct sli4_rsp_cmn_get_cntl_addl_attributes {
	struct sli4_rsp_hdr	hdr;
	__le16		ipl_file_number;
	u8		ipl_file_version;
	u8		rsvd4;
	u8		on_die_temperature;
	u8		rsvd5[3];
	__le32		driver_advanced_features_supported;
	__le32		rsvd7[4];
	char		universal_bios_version[32];
	char		x86_bios_version[32];
	char		efi_bios_version[32];
	char		fcode_version[32];
	char		uefi_bios_version[32];
	char		uefi_nic_version[32];
	char		uefi_fcode_version[32];
	char		uefi_iscsi_version[32];
	char		iscsi_x86_bios_version[32];
	char		pxe_x86_bios_version[32];
	u8		default_wwpn[8];
	u8		ext_phy_version[32];
	u8		fc_universal_bios_version[32];
	u8		fc_x86_bios_version[32];
	u8		fc_efi_bios_version[32];
	u8		fc_fcode_version[32];
	u8		ext_phy_crc_label[8];
	u8		ipl_file_name[16];
	u8		rsvd139[72];
};

/*
 * COMMON_NOP
 *
 * This command does not do anything; it only returns
 * the payload in the completion.
 */
struct sli4_rqst_cmn_nop {
	struct sli4_rqst_hdr	hdr;
	__le32			context[2];
};

struct sli4_rsp_cmn_nop {
	struct sli4_rsp_hdr	hdr;
	__le32			context[2];
};

struct sli4_rqst_cmn_get_resource_extent_info {
	struct sli4_rqst_hdr	hdr;
	__le16	resource_type;
	__le16	rsvd16;
};

enum sli4_rsc_type {
	SLI4_RSC_TYPE_VFI	= 0x20,
	SLI4_RSC_TYPE_VPI	= 0x21,
	SLI4_RSC_TYPE_RPI	= 0x22,
	SLI4_RSC_TYPE_XRI	= 0x23,
};

struct sli4_rsp_cmn_get_resource_extent_info {
	struct sli4_rsp_hdr	hdr;
	__le16		resource_extent_count;
	__le16		resource_extent_size;
};

#define SLI4_128BYTE_WQE_SUPPORT	0x02

#define GET_Q_CNT_METHOD(m) \
	(((m) & SLI4_PARAM_Q_CNT_MTHD_MASK) >> SLI4_PARAM_Q_CNT_MTHD_SHFT)
#define GET_Q_CREATE_VERSION(v) \
	(((v) & SLI4_PARAM_QV_MASK) >> SLI4_PARAM_QV_SHIFT)

enum sli4_rsp_get_params_e {
	/*GENERIC*/
	SLI4_PARAM_Q_CNT_MTHD_SHFT	= 24,
	SLI4_PARAM_Q_CNT_MTHD_MASK	= 0xf << 24,
	SLI4_PARAM_QV_SHIFT		= 14,
	SLI4_PARAM_QV_MASK		= 3 << 14,

	/* DW4 */
	SLI4_PARAM_PROTO_TYPE_MASK	= 0xff,
	/* DW5 */
	SLI4_PARAM_FT			= 1 << 0,
	SLI4_PARAM_SLI_REV_MASK		= 0xf << 4,
	SLI4_PARAM_SLI_FAM_MASK		= 0xf << 8,
	SLI4_PARAM_IF_TYPE_MASK		= 0xf << 12,
	SLI4_PARAM_SLI_HINT1_MASK	= 0xff << 16,
	SLI4_PARAM_SLI_HINT2_MASK	= 0x1f << 24,
	/* DW6 */
	SLI4_PARAM_EQ_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_EQE_SZS_MASK		= 0xf << 8,
	SLI4_PARAM_EQ_PAGE_SZS_MASK	= 0xff << 16,
	/* DW8 */
	SLI4_PARAM_CQ_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_CQE_SZS_MASK		= 0xf << 8,
	SLI4_PARAM_CQ_PAGE_SZS_MASK	= 0xff << 16,
	/* DW10 */
	SLI4_PARAM_MQ_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_MQ_PAGE_SZS_MASK	= 0xff << 16,
	/* DW12 */
	SLI4_PARAM_WQ_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_WQE_SZS_MASK		= 0xf << 8,
	SLI4_PARAM_WQ_PAGE_SZS_MASK	= 0xff << 16,
	/* DW14 */
	SLI4_PARAM_RQ_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_RQE_SZS_MASK		= 0xf << 8,
	SLI4_PARAM_RQ_PAGE_SZS_MASK	= 0xff << 16,
	/* DW15W1*/
	SLI4_PARAM_RQ_DB_WINDOW_MASK	= 0xf000,
	/* DW16 */
	SLI4_PARAM_FC			= 1 << 0,
	SLI4_PARAM_EXT			= 1 << 1,
	SLI4_PARAM_HDRR			= 1 << 2,
	SLI4_PARAM_SGLR			= 1 << 3,
	SLI4_PARAM_FBRR			= 1 << 4,
	SLI4_PARAM_AREG			= 1 << 5,
	SLI4_PARAM_TGT			= 1 << 6,
	SLI4_PARAM_TERP			= 1 << 7,
	SLI4_PARAM_ASSI			= 1 << 8,
	SLI4_PARAM_WCHN			= 1 << 9,
	SLI4_PARAM_TCCA			= 1 << 10,
	SLI4_PARAM_TRTY			= 1 << 11,
	SLI4_PARAM_TRIR			= 1 << 12,
	SLI4_PARAM_PHOFF		= 1 << 13,
	SLI4_PARAM_PHON			= 1 << 14,
	SLI4_PARAM_PHWQ			= 1 << 15,
	SLI4_PARAM_BOUND_4GA		= 1 << 16,
	SLI4_PARAM_RXC			= 1 << 17,
	SLI4_PARAM_HLM			= 1 << 18,
	SLI4_PARAM_IPR			= 1 << 19,
	SLI4_PARAM_RXRI			= 1 << 20,
	SLI4_PARAM_SGLC			= 1 << 21,
	SLI4_PARAM_TIMM			= 1 << 22,
	SLI4_PARAM_TSMM			= 1 << 23,
	SLI4_PARAM_OAS			= 1 << 25,
	SLI4_PARAM_LC			= 1 << 26,
	SLI4_PARAM_AGXF			= 1 << 27,
	SLI4_PARAM_LOOPBACK_MASK	= 0xf << 28,
	/* DW18 */
	SLI4_PARAM_SGL_PAGE_CNT_MASK	= 0xf << 0,
	SLI4_PARAM_SGL_PAGE_SZS_MASK	= 0xff << 8,
	SLI4_PARAM_SGL_PP_ALIGN_MASK	= 0xff << 16,
};

struct sli4_rqst_cmn_get_sli4_params {
	struct sli4_rqst_hdr	hdr;
};

struct sli4_rsp_cmn_get_sli4_params {
	struct sli4_rsp_hdr	hdr;
	__le32		dw4_protocol_type;
	__le32		dw5_sli;
	__le32		dw6_eq_page_cnt;
	__le16		eqe_count_mask;
	__le16		rsvd26;
	__le32		dw8_cq_page_cnt;
	__le16		cqe_count_mask;
	__le16		rsvd34;
	__le32		dw10_mq_page_cnt;
	__le16		mqe_count_mask;
	__le16		rsvd42;
	__le32		dw12_wq_page_cnt;
	__le16		wqe_count_mask;
	__le16		rsvd50;
	__le32		dw14_rq_page_cnt;
	__le16		rqe_count_mask;
	__le16		dw15w1_rq_db_window;
	__le32		dw16_loopback_scope;
	__le32		sge_supported_length;
	__le32		dw18_sgl_page_cnt;
	__le16		min_rq_buffer_size;
	__le16		rsvd75;
	__le32		max_rq_buffer_size;
	__le16		physical_xri_max;
	__le16		physical_rpi_max;
	__le16		physical_vpi_max;
	__le16		physical_vfi_max;
	__le32		rsvd88;
	__le16		frag_num_field_offset;
	__le16		frag_num_field_size;
	__le16		sgl_index_field_offset;
	__le16		sgl_index_field_size;
	__le32		chain_sge_initial_value_lo;
	__le32		chain_sge_initial_value_hi;
};

/*Port Types*/
enum sli4_port_types {
	SLI4_PORT_TYPE_ETH	= 0,
	SLI4_PORT_TYPE_FC	= 1,
};

struct sli4_rqst_cmn_get_port_name {
	struct sli4_rqst_hdr	hdr;
	u8	port_type;
	u8	rsvd4[3];
};

struct sli4_rsp_cmn_get_port_name {
	struct sli4_rsp_hdr	hdr;
	char	port_name[4];
};

struct sli4_rqst_cmn_write_flashrom {
	struct sli4_rqst_hdr	hdr;
	__le32		flash_rom_access_opcode;
	__le32		flash_rom_access_operation_type;
	__le32		data_buffer_size;
	__le32		offset;
	u8		data_buffer[4];
};

/*
 * COMMON_READ_TRANSCEIVER_DATA
 *
 * This command reads SFF transceiver data(Format is defined
 * by the SFF-8472 specification).
 */
struct sli4_rqst_cmn_read_transceiver_data {
	struct sli4_rqst_hdr	hdr;
	__le32			page_number;
	__le32			port;
};

struct sli4_rsp_cmn_read_transceiver_data {
	struct sli4_rsp_hdr	hdr;
	__le32			page_number;
	__le32			port;
	u8			page_data[128];
	u8			page_data_2[128];
};

#define SLI4_REQ_DESIRE_READLEN		0xffffff

struct sli4_rqst_cmn_read_object {
	struct sli4_rqst_hdr	hdr;
	__le32			desired_read_length_dword;
	__le32			read_offset;
	u8			object_name[104];
	__le32			host_buffer_descriptor_count;
	struct sli4_bde		host_buffer_descriptor[];
};

#define RSP_COM_READ_OBJ_EOF		0x80000000

struct sli4_rsp_cmn_read_object {
	struct sli4_rsp_hdr	hdr;
	__le32			actual_read_length;
	__le32			eof_dword;
};

enum sli4_rqst_write_object_flags {
	SLI4_RQ_DES_WRITE_LEN		= 0xffffff,
	SLI4_RQ_DES_WRITE_LEN_NOC	= 0x40000000,
	SLI4_RQ_DES_WRITE_LEN_EOF	= 0x80000000,
};

struct sli4_rqst_cmn_write_object {
	struct sli4_rqst_hdr	hdr;
	__le32			desired_write_len_dword;
	__le32			write_offset;
	u8			object_name[104];
	__le32			host_buffer_descriptor_count;
	struct sli4_bde		host_buffer_descriptor[];
};

#define	RSP_CHANGE_STATUS		0xff

struct sli4_rsp_cmn_write_object {
	struct sli4_rsp_hdr	hdr;
	__le32			actual_write_length;
	__le32			change_status_dword;
};

struct sli4_rqst_cmn_delete_object {
	struct sli4_rqst_hdr	hdr;
	__le32			rsvd4;
	__le32			rsvd5;
	u8			object_name[104];
};

#define SLI4_RQ_OBJ_LIST_READ_LEN	0xffffff

struct sli4_rqst_cmn_read_object_list {
	struct sli4_rqst_hdr	hdr;
	__le32			desired_read_length_dword;
	__le32			read_offset;
	u8			object_name[104];
	__le32			host_buffer_descriptor_count;
	struct sli4_bde		host_buffer_descriptor[];
};

enum sli4_rqst_set_dump_flags {
	SLI4_CMN_SET_DUMP_BUFFER_LEN	= 0xffffff,
	SLI4_CMN_SET_DUMP_FDB		= 0x20000000,
	SLI4_CMN_SET_DUMP_BLP		= 0x40000000,
	SLI4_CMN_SET_DUMP_QRY		= 0x80000000,
};

struct sli4_rqst_cmn_set_dump_location {
	struct sli4_rqst_hdr	hdr;
	__le32			buffer_length_dword;
	__le32			buf_addr_low;
	__le32			buf_addr_high;
};

struct sli4_rsp_cmn_set_dump_location {
	struct sli4_rsp_hdr	hdr;
	__le32			buffer_length_dword;
};

enum sli4_dump_level {
	SLI4_DUMP_LEVEL_NONE,
	SLI4_CHIP_LEVEL_DUMP,
	SLI4_FUNC_DESC_DUMP,
};

enum sli4_dump_state {
	SLI4_DUMP_STATE_NONE,
	SLI4_CHIP_DUMP_STATE_VALID,
	SLI4_FUNC_DUMP_STATE_VALID,
};

enum sli4_dump_status {
	SLI4_DUMP_READY_STATUS_NOT_READY,
	SLI4_DUMP_READY_STATUS_DD_PRESENT,
	SLI4_DUMP_READY_STATUS_FDB_PRESENT,
	SLI4_DUMP_READY_STATUS_SKIP_DUMP,
	SLI4_DUMP_READY_STATUS_FAILED = -1,
};

enum sli4_set_features {
	SLI4_SET_FEATURES_DIF_SEED			= 0x01,
	SLI4_SET_FEATURES_XRI_TIMER			= 0x03,
	SLI4_SET_FEATURES_MAX_PCIE_SPEED		= 0x04,
	SLI4_SET_FEATURES_FCTL_CHECK			= 0x05,
	SLI4_SET_FEATURES_FEC				= 0x06,
	SLI4_SET_FEATURES_PCIE_RECV_DETECT		= 0x07,
	SLI4_SET_FEATURES_DIF_MEMORY_MODE		= 0x08,
	SLI4_SET_FEATURES_DISABLE_SLI_PORT_PAUSE_STATE	= 0x09,
	SLI4_SET_FEATURES_ENABLE_PCIE_OPTIONS		= 0x0a,
	SLI4_SET_FEAT_CFG_AUTO_XFER_RDY_T10PI		= 0x0c,
	SLI4_SET_FEATURES_ENABLE_MULTI_RECEIVE_QUEUE	= 0x0d,
	SLI4_SET_FEATURES_SET_FTD_XFER_HINT		= 0x0f,
	SLI4_SET_FEATURES_SLI_PORT_HEALTH_CHECK		= 0x11,
};

struct sli4_rqst_cmn_set_features {
	struct sli4_rqst_hdr	hdr;
	__le32			feature;
	__le32			param_len;
	__le32			params[8];
};

struct sli4_rqst_cmn_set_features_dif_seed {
	__le16		seed;
	__le16		rsvd16;
};

enum sli4_rqst_set_mrq_features {
	SLI4_RQ_MULTIRQ_ISR		 = 0x1,
	SLI4_RQ_MULTIRQ_AUTOGEN_XFER_RDY = 0x2,

	SLI4_RQ_MULTIRQ_NUM_RQS		 = 0xff,
	SLI4_RQ_MULTIRQ_RQ_SELECT	 = 0xf00,
};

struct sli4_rqst_cmn_set_features_multirq {
	__le32		auto_gen_xfer_dword;
	__le32		num_rqs_dword;
};

enum sli4_rqst_health_check_flags {
	SLI4_RQ_HEALTH_CHECK_ENABLE	= 0x1,
	SLI4_RQ_HEALTH_CHECK_QUERY	= 0x2,
};

struct sli4_rqst_cmn_set_features_health_check {
	__le32		health_check_dword;
};

struct sli4_rqst_cmn_set_features_set_fdt_xfer_hint {
	__le32		fdt_xfer_hint;
};

struct sli4_rqst_dmtf_exec_clp_cmd {
	struct sli4_rqst_hdr	hdr;
	__le32			cmd_buf_length;
	__le32			resp_buf_length;
	__le32			cmd_buf_addr_low;
	__le32			cmd_buf_addr_high;
	__le32			resp_buf_addr_low;
	__le32			resp_buf_addr_high;
};

struct sli4_rsp_dmtf_exec_clp_cmd {
	struct sli4_rsp_hdr	hdr;
	__le32			rsvd4;
	__le32			resp_length;
	__le32			rsvd6;
	__le32			rsvd7;
	__le32			rsvd8;
	__le32			rsvd9;
	__le32			clp_status;
	__le32			clp_detailed_status;
};

#define SLI4_PROTOCOL_FC		0x10
#define SLI4_PROTOCOL_DEFAULT		0xff

struct sli4_rspource_descriptor_v1 {
	u8		descriptor_type;
	u8		descriptor_length;
	__le16		rsvd16;
	__le32		type_specific[];
};

enum sli4_pcie_desc_flags {
	SLI4_PCIE_DESC_IMM		= 0x4000,
	SLI4_PCIE_DESC_NOSV		= 0x8000,

	SLI4_PCIE_DESC_PF_NO		= 0x3ff0000,

	SLI4_PCIE_DESC_MISSN_ROLE	= 0xff,
	SLI4_PCIE_DESC_PCHG		= 0x8000000,
	SLI4_PCIE_DESC_SCHG		= 0x10000000,
	SLI4_PCIE_DESC_XCHG		= 0x20000000,
	SLI4_PCIE_DESC_XROM		= 0xc0000000
};

struct sli4_pcie_resource_descriptor_v1 {
	u8		descriptor_type;
	u8		descriptor_length;
	__le16		imm_nosv_dword;
	__le32		pf_number_dword;
	__le32		rsvd3;
	u8		sriov_state;
	u8		pf_state;
	u8		pf_type;
	u8		rsvd4;
	__le16		number_of_vfs;
	__le16		rsvd5;
	__le32		mission_roles_dword;
	__le32		rsvd7[16];
};

struct sli4_rqst_cmn_get_function_config {
	struct sli4_rqst_hdr  hdr;
};

struct sli4_rsp_cmn_get_function_config {
	struct sli4_rsp_hdr	hdr;
	__le32			desc_count;
	__le32			desc[54];
};

/* Link Config Descriptor for link config functions */
struct sli4_link_config_descriptor {
	u8		link_config_id;
	u8		rsvd1[3];
	__le32		config_description[8];
};

#define MAX_LINK_DES	10

struct sli4_rqst_cmn_get_reconfig_link_info {
	struct sli4_rqst_hdr  hdr;
};

struct sli4_rsp_cmn_get_reconfig_link_info {
	struct sli4_rsp_hdr	hdr;
	u8			active_link_config_id;
	u8			rsvd17;
	u8			next_link_config_id;
	u8			rsvd19;
	__le32			link_configuration_descriptor_count;
	struct sli4_link_config_descriptor
				desc[MAX_LINK_DES];
};

enum sli4_set_reconfig_link_flags {
	SLI4_SET_RECONFIG_LINKID_NEXT	= 0xff,
	SLI4_SET_RECONFIG_LINKID_FD	= 1u << 31,
};

struct sli4_rqst_cmn_set_reconfig_link_id {
	struct sli4_rqst_hdr  hdr;
	__le32			dw4_flags;
};

struct sli4_rsp_cmn_set_reconfig_link_id {
	struct sli4_rsp_hdr	hdr;
};

struct sli4_rqst_lowlevel_set_watchdog {
	struct sli4_rqst_hdr	hdr;
	__le16			watchdog_timeout;
	__le16			rsvd18;
};

struct sli4_rsp_lowlevel_set_watchdog {
	struct sli4_rsp_hdr	hdr;
	__le32			rsvd;
};

/* FC opcode (OPC) values */
enum sli4_fc_opcodes {
	SLI4_OPC_WQ_CREATE		= 0x1,
	SLI4_OPC_WQ_DESTROY		= 0x2,
	SLI4_OPC_POST_SGL_PAGES		= 0x3,
	SLI4_OPC_RQ_CREATE		= 0x5,
	SLI4_OPC_RQ_DESTROY		= 0x6,
	SLI4_OPC_READ_FCF_TABLE		= 0x8,
	SLI4_OPC_POST_HDR_TEMPLATES	= 0xb,
	SLI4_OPC_REDISCOVER_FCF		= 0x10,
};

/* Use the default CQ associated with the WQ */
#define SLI4_CQ_DEFAULT 0xffff

/*
 * POST_SGL_PAGES
 *
 * Register the scatter gather list (SGL) memory and
 * associate it with an XRI.
 */
struct sli4_rqst_post_sgl_pages {
	struct sli4_rqst_hdr	hdr;
	__le16			xri_start;
	__le16			xri_count;
	struct {
		__le32		page0_low;
		__le32		page0_high;
		__le32		page1_low;
		__le32		page1_high;
	} page_set[10];
};

struct sli4_rsp_post_sgl_pages {
	struct sli4_rsp_hdr	hdr;
};

struct sli4_rqst_post_hdr_templates {
	struct sli4_rqst_hdr	hdr;
	__le16			rpi_offset;
	__le16			page_count;
	struct sli4_dmaaddr	page_descriptor[];
};

#define SLI4_HDR_TEMPLATE_SIZE		64

enum sli4_io_flags {
/* The XRI associated with this IO is already active */
	SLI4_IO_CONTINUATION		= 1 << 0,
/* Automatically generate a good RSP frame */
	SLI4_IO_AUTO_GOOD_RESPONSE	= 1 << 1,
	SLI4_IO_NO_ABORT		= 1 << 2,
/* Set the DNRX bit because no auto xref rdy buffer is posted */
	SLI4_IO_DNRX			= 1 << 3,
};

enum sli4_callback {
	SLI4_CB_LINK,
	SLI4_CB_MAX,
};

enum sli4_link_status {
	SLI4_LINK_STATUS_UP,
	SLI4_LINK_STATUS_DOWN,
	SLI4_LINK_STATUS_NO_ALPA,
	SLI4_LINK_STATUS_MAX,
};

enum sli4_link_topology {
	SLI4_LINK_TOPO_NON_FC_AL = 1,
	SLI4_LINK_TOPO_FC_AL,
	SLI4_LINK_TOPO_LOOPBACK_INTERNAL,
	SLI4_LINK_TOPO_LOOPBACK_EXTERNAL,
	SLI4_LINK_TOPO_NONE,
	SLI4_LINK_TOPO_MAX,
};

enum sli4_link_medium {
	SLI4_LINK_MEDIUM_ETHERNET,
	SLI4_LINK_MEDIUM_FC,
	SLI4_LINK_MEDIUM_MAX,
};
/******Driver specific structures******/

struct sli4_queue {
	/* Common to all queue types */
	struct efc_dma	dma;
	spinlock_t	lock;		/* Lock to protect the doorbell register
					 * writes and queue reads
					 */
	u32		index;		/* current host entry index */
	u16		size;		/* entry size */
	u16		length;		/* number of entries */
	u16		n_posted;	/* number entries posted for CQ, EQ */
	u16		id;		/* Port assigned xQ_ID */
	u8		type;		/* queue type ie EQ, CQ, ... */
	void __iomem    *db_regaddr;	/* register address for the doorbell */
	u16		phase;		/* For if_type = 6, this value toggle
					 * for each iteration of the queue,
					 * a queue entry is valid when a cqe
					 * valid bit matches this value
					 */
	u32		proc_limit;	/* limit CQE processed per iteration */
	u32		posted_limit;	/* CQE/EQE process before ring db */
	u32		max_num_processed;
	u64		max_process_time;
	union {
		u32	r_idx;		/* "read" index (MQ only) */
		u32	flag;
	} u;
};

/* Parameters used to populate WQE*/
struct sli_bls_params {
	u32		s_id;
	u32		d_id;
	u16		ox_id;
	u16		rx_id;
	u32		rpi;
	u32		vpi;
	bool		rpi_registered;
	u8		payload[12];
	u16		xri;
	u16		tag;
};

struct sli_els_params {
	u32		s_id;
	u32		d_id;
	u16		ox_id;
	u32		rpi;
	u32		vpi;
	bool		rpi_registered;
	u32		xmit_len;
	u32		rsp_len;
	u8		timeout;
	u8		cmd;
	u16		xri;
	u16		tag;
};

struct sli_ct_params {
	u8		r_ctl;
	u8		type;
	u8		df_ctl;
	u8		timeout;
	u16		ox_id;
	u32		d_id;
	u32		rpi;
	u32		vpi;
	bool		rpi_registered;
	u32		xmit_len;
	u32		rsp_len;
	u16		xri;
	u16		tag;
};

struct sli_fcp_tgt_params {
	u32		s_id;
	u32		d_id;
	u32		rpi;
	u32		vpi;
	u32		offset;
	u16		ox_id;
	u16		flags;
	u8		cs_ctl;
	u8		timeout;
	u32		app_id;
	u32		xmit_len;
	u16		xri;
	u16		tag;
};

struct sli4_link_event {
	enum sli4_link_status	status;
	enum sli4_link_topology	topology;
	enum sli4_link_medium	medium;
	u32			speed;
	u8			*loop_map;
	u32			fc_id;
};

enum sli4_resource {
	SLI4_RSRC_VFI,
	SLI4_RSRC_VPI,
	SLI4_RSRC_RPI,
	SLI4_RSRC_XRI,
	SLI4_RSRC_FCFI,
	SLI4_RSRC_MAX,
};

struct sli4_extent {
	u32		number;
	u32		size;
	u32		n_alloc;
	u32		*base;
	unsigned long	*use_map;
	u32		map_size;
};

struct sli4_queue_info {
	u16	max_qcount[SLI4_QTYPE_MAX];
	u32	max_qentries[SLI4_QTYPE_MAX];
	u16	count_mask[SLI4_QTYPE_MAX];
	u16	count_method[SLI4_QTYPE_MAX];
	u32	qpage_count[SLI4_QTYPE_MAX];
};

struct sli4_params {
	u8	has_extents;
	u8	auto_reg;
	u8	auto_xfer_rdy;
	u8	hdr_template_req;
	u8	perf_hint;
	u8	perf_wq_id_association;
	u8	cq_create_version;
	u8	mq_create_version;
	u8	high_login_mode;
	u8	sgl_pre_registered;
	u8	sgl_pre_reg_required;
	u8	t10_dif_inline_capable;
	u8	t10_dif_separate_capable;
};

struct sli4 {
	void			*os;
	struct pci_dev		*pci;
	void __iomem		*reg[PCI_STD_NUM_BARS];

	u32			sli_rev;
	u32			sli_family;
	u32			if_type;

	u16			asic_type;
	u16			asic_rev;

	u16			e_d_tov;
	u16			r_a_tov;
	struct sli4_queue_info	qinfo;
	u16			link_module_type;
	u8			rq_batch;
	u8			port_number;
	char			port_name[2];
	u16			rq_min_buf_size;
	u32			rq_max_buf_size;
	u8			topology;
	u8			wwpn[8];
	u8			wwnn[8];
	u32			fw_rev[2];
	u8			fw_name[2][16];
	char			ipl_name[16];
	u32			hw_rev[3];
	char			modeldesc[64];
	char			bios_version_string[32];
	u32			wqe_size;
	u32			vpd_length;
	/*
	 * Tracks the port resources using extents metaphor. For
	 * devices that don't implement extents (i.e.
	 * has_extents == FALSE), the code models each resource as
	 * a single large extent.
	 */
	struct sli4_extent	ext[SLI4_RSRC_MAX];
	u32			features;
	struct sli4_params	params;
	u32			sge_supported_length;
	u32			sgl_page_sizes;
	u32			max_sgl_pages;

	/*
	 * Callback functions
	 */
	int			(*link)(void *ctx, void *event);
	void			*link_arg;

	struct efc_dma		bmbx;

	/* Save pointer to physical memory descriptor for non-embedded
	 * SLI_CONFIG commands for BMBX dumping purposes
	 */
	struct efc_dma		*bmbx_non_emb_pmd;

	struct efc_dma		vpd_data;
};

static inline void
sli_cmd_fill_hdr(struct sli4_rqst_hdr *hdr, u8 opc, u8 sub, u32 ver, __le32 len)
{
	hdr->opcode = opc;
	hdr->subsystem = sub;
	hdr->dw3_version = cpu_to_le32(ver);
	hdr->request_length = len;
}

/**
 * Get / set parameter functions
 */

static inline u32
sli_get_max_sge(struct sli4 *sli4)
{
	return sli4->sge_supported_length;
}

static inline u32
sli_get_max_sgl(struct sli4 *sli4)
{
	if (sli4->sgl_page_sizes != 1) {
		efc_log_err(sli4, "unsupported SGL page sizes %#x\n",
			    sli4->sgl_page_sizes);
		return 0;
	}

	return (sli4->max_sgl_pages * SLI_PAGE_SIZE) / sizeof(struct sli4_sge);
}

static inline enum sli4_link_medium
sli_get_medium(struct sli4 *sli4)
{
	switch (sli4->topology) {
	case SLI4_READ_CFG_TOPO_FC:
	case SLI4_READ_CFG_TOPO_FC_AL:
	case SLI4_READ_CFG_TOPO_NON_FC_AL:
		return SLI4_LINK_MEDIUM_FC;
	default:
		return SLI4_LINK_MEDIUM_MAX;
	}
}

static inline u32
sli_get_lmt(struct sli4 *sli4)
{
	return sli4->link_module_type;
}

static inline int
sli_set_topology(struct sli4 *sli4, u32 value)
{
	int	rc = 0;

	switch (value) {
	case SLI4_READ_CFG_TOPO_FC:
	case SLI4_READ_CFG_TOPO_FC_AL:
	case SLI4_READ_CFG_TOPO_NON_FC_AL:
		sli4->topology = value;
		break;
	default:
		efc_log_err(sli4, "unsupported topology %#x\n", value);
		rc = -1;
	}

	return rc;
}

static inline u32
sli_convert_mask_to_count(u32 method, u32 mask)
{
	u32 count = 0;

	if (method) {
		count = 1 << (31 - __builtin_clz(mask));
		count *= 16;
	} else {
		count = mask;
	}

	return count;
}

static inline u32
sli_reg_read_status(struct sli4 *sli)
{
	return readl(sli->reg[0] + SLI4_PORT_STATUS_REGOFF);
}

static inline int
sli_fw_error_status(struct sli4 *sli4)
{
	return (sli_reg_read_status(sli4) & SLI4_PORT_STATUS_ERR) ? 1 : 0;
}

static inline u32
sli_reg_read_err1(struct sli4 *sli)
{
	return readl(sli->reg[0] + SLI4_PORT_ERROR1);
}

static inline u32
sli_reg_read_err2(struct sli4 *sli)
{
	return readl(sli->reg[0] + SLI4_PORT_ERROR2);
}

static inline int
sli_fc_rqe_length(struct sli4 *sli4, void *cqe, u32 *len_hdr,
		  u32 *len_data)
{
	struct sli4_fc_async_rcqe	*rcqe = cqe;

	*len_hdr = *len_data = 0;

	if (rcqe->status == SLI4_FC_ASYNC_RQ_SUCCESS) {
		*len_hdr  = rcqe->hdpl_byte & SLI4_RACQE_HDPL;
		*len_data = le16_to_cpu(rcqe->data_placement_length);
		return 0;
	} else {
		return -1;
	}
}

static inline u8
sli_fc_rqe_fcfi(struct sli4 *sli4, void *cqe)
{
	u8 code = ((u8 *)cqe)[SLI4_CQE_CODE_OFFSET];
	u8 fcfi = U8_MAX;

	switch (code) {
	case SLI4_CQE_CODE_RQ_ASYNC: {
		struct sli4_fc_async_rcqe *rcqe = cqe;

		fcfi = le16_to_cpu(rcqe->fcfi_rq_id_word) & SLI4_RACQE_FCFI;
		break;
	}
	case SLI4_CQE_CODE_RQ_ASYNC_V1: {
		struct sli4_fc_async_rcqe_v1 *rcqev1 = cqe;

		fcfi = rcqev1->fcfi_byte & SLI4_RACQE_FCFI;
		break;
	}
	case SLI4_CQE_CODE_OPTIMIZED_WRITE_CMD: {
		struct sli4_fc_optimized_write_cmd_cqe *opt_wr = cqe;

		fcfi = opt_wr->flags0 & SLI4_OCQE_FCFI;
		break;
	}
	}

	return fcfi;
}

/****************************************************************************
 * Function prototypes
 */
int
sli_cmd_config_link(struct sli4 *sli4, void *buf);
int
sli_cmd_down_link(struct sli4 *sli4, void *buf);
int
sli_cmd_dump_type4(struct sli4 *sli4, void *buf, u16 wki);
int
sli_cmd_common_read_transceiver_data(struct sli4 *sli4, void *buf,
				     u32 page_num, struct efc_dma *dma);
int
sli_cmd_read_link_stats(struct sli4 *sli4, void *buf, u8 req_stats,
			u8 clear_overflow_flags, u8 clear_all_counters);
int
sli_cmd_read_status(struct sli4 *sli4, void *buf, u8 clear);
int
sli_cmd_init_link(struct sli4 *sli4, void *buf, u32 speed,
		  u8 reset_alpa);
int
sli_cmd_init_vfi(struct sli4 *sli4, void *buf, u16 vfi, u16 fcfi,
		 u16 vpi);
int
sli_cmd_init_vpi(struct sli4 *sli4, void *buf, u16 vpi, u16 vfi);
int
sli_cmd_post_xri(struct sli4 *sli4, void *buf, u16 base, u16 cnt);
int
sli_cmd_release_xri(struct sli4 *sli4, void *buf, u8 num_xri);
int
sli_cmd_read_sparm64(struct sli4 *sli4, void *buf,
		     struct efc_dma *dma, u16 vpi);
int
sli_cmd_read_topology(struct sli4 *sli4, void *buf, struct efc_dma *dma);
int
sli_cmd_read_nvparms(struct sli4 *sli4, void *buf);
int
sli_cmd_write_nvparms(struct sli4 *sli4, void *buf, u8 *wwpn,
		      u8 *wwnn, u8 hard_alpa, u32 preferred_d_id);
int
sli_cmd_reg_fcfi(struct sli4 *sli4, void *buf, u16 index,
		 struct sli4_cmd_rq_cfg *rq_cfg);
int
sli_cmd_reg_fcfi_mrq(struct sli4 *sli4, void *buf, u8 mode, u16 index,
		     u8 rq_selection_policy, u8 mrq_bit_mask, u16 num_mrqs,
		     struct sli4_cmd_rq_cfg *rq_cfg);
int
sli_cmd_reg_rpi(struct sli4 *sli4, void *buf, u32 rpi, u32 vpi, u32 fc_id,
		struct efc_dma *dma, u8 update, u8 enable_t10_pi);
int
sli_cmd_unreg_fcfi(struct sli4 *sli4, void *buf, u16 indicator);
int
sli_cmd_unreg_rpi(struct sli4 *sli4, void *buf, u16 indicator,
		  enum sli4_resource which, u32 fc_id);
int
sli_cmd_reg_vpi(struct sli4 *sli4, void *buf, u32 fc_id,
		__be64 sli_wwpn, u16 vpi, u16 vfi, bool update);
int
sli_cmd_reg_vfi(struct sli4 *sli4, void *buf, size_t size,
		u16 vfi, u16 fcfi, struct efc_dma dma,
		u16 vpi, __be64 sli_wwpn, u32 fc_id);
int
sli_cmd_unreg_vpi(struct sli4 *sli4, void *buf, u16 id, u32 type);
int
sli_cmd_unreg_vfi(struct sli4 *sli4, void *buf, u16 idx, u32 type);
int
sli_cmd_common_nop(struct sli4 *sli4, void *buf, uint64_t context);
int
sli_cmd_common_get_resource_extent_info(struct sli4 *sli4, void *buf,
					u16 rtype);
int
sli_cmd_common_get_sli4_parameters(struct sli4 *sli4, void *buf);
int
sli_cmd_common_write_object(struct sli4 *sli4, void *buf, u16 noc,
		u16 eof, u32 len, u32 offset, char *name, struct efc_dma *dma);
int
sli_cmd_common_delete_object(struct sli4 *sli4, void *buf, char *object_name);
int
sli_cmd_common_read_object(struct sli4 *sli4, void *buf,
		u32 length, u32 offset, char *name, struct efc_dma *dma);
int
sli_cmd_dmtf_exec_clp_cmd(struct sli4 *sli4, void *buf,
		struct efc_dma *cmd, struct efc_dma *resp);
int
sli_cmd_common_set_dump_location(struct sli4 *sli4, void *buf,
		bool query, bool is_buffer_list, struct efc_dma *dma, u8 fdb);
int
sli_cmd_common_set_features(struct sli4 *sli4, void *buf,
			    u32 feature, u32 param_len, void *parameter);

int sli_cqe_mq(struct sli4 *sli4, void *buf);
int sli_cqe_async(struct sli4 *sli4, void *buf);

int
sli_setup(struct sli4 *sli4, void *os, struct pci_dev *pdev, void __iomem *r[]);
void sli_calc_max_qentries(struct sli4 *sli4);
int sli_init(struct sli4 *sli4);
int sli_reset(struct sli4 *sli4);
int sli_fw_reset(struct sli4 *sli4);
void sli_teardown(struct sli4 *sli4);
int
sli_callback(struct sli4 *sli4, enum sli4_callback cb, void *func, void *arg);
int
sli_bmbx_command(struct sli4 *sli4);
int
__sli_queue_init(struct sli4 *sli4, struct sli4_queue *q, u32 qtype,
		 size_t size, u32 n_entries, u32 align);
int
__sli_create_queue(struct sli4 *sli4, struct sli4_queue *q);
int
sli_eq_modify_delay(struct sli4 *sli4, struct sli4_queue *eq, u32 num_eq,
		    u32 shift, u32 delay_mult);
int
sli_queue_alloc(struct sli4 *sli4, u32 qtype, struct sli4_queue *q,
		u32 n_entries, struct sli4_queue *assoc);
int
sli_cq_alloc_set(struct sli4 *sli4, struct sli4_queue *qs[], u32 num_cqs,
		 u32 n_entries, struct sli4_queue *eqs[]);
int
sli_get_queue_entry_size(struct sli4 *sli4, u32 qtype);
int
sli_queue_free(struct sli4 *sli4, struct sli4_queue *q, u32 destroy_queues,
	       u32 free_memory);
int
sli_queue_eq_arm(struct sli4 *sli4, struct sli4_queue *q, bool arm);
int
sli_queue_arm(struct sli4 *sli4, struct sli4_queue *q, bool arm);

int
sli_wq_write(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_mq_write(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_rq_write(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_eq_read(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_cq_read(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_mq_read(struct sli4 *sli4, struct sli4_queue *q, u8 *entry);
int
sli_resource_alloc(struct sli4 *sli4, enum sli4_resource rtype, u32 *rid,
		   u32 *index);
int
sli_resource_free(struct sli4 *sli4, enum sli4_resource rtype, u32 rid);
int
sli_resource_reset(struct sli4 *sli4, enum sli4_resource rtype);
int
sli_eq_parse(struct sli4 *sli4, u8 *buf, u16 *cq_id);
int
sli_cq_parse(struct sli4 *sli4, struct sli4_queue *cq, u8 *cqe,
	     enum sli4_qentry *etype, u16 *q_id);

int sli_raise_ue(struct sli4 *sli4, u8 dump);
int sli_dump_is_ready(struct sli4 *sli4);
bool sli_reset_required(struct sli4 *sli4);
bool sli_fw_ready(struct sli4 *sli4);

int
sli_fc_process_link_attention(struct sli4 *sli4, void *acqe);
int
sli_fc_cqe_parse(struct sli4 *sli4, struct sli4_queue *cq,
		 u8 *cqe, enum sli4_qentry *etype,
		 u16 *rid);
u32 sli_fc_response_length(struct sli4 *sli4, u8 *cqe);
u32 sli_fc_io_length(struct sli4 *sli4, u8 *cqe);
int sli_fc_els_did(struct sli4 *sli4, u8 *cqe, u32 *d_id);
u32 sli_fc_ext_status(struct sli4 *sli4, u8 *cqe);
int
sli_fc_rqe_rqid_and_index(struct sli4 *sli4, u8 *cqe, u16 *rq_id, u32 *index);
int
sli_cmd_wq_create(struct sli4 *sli4, void *buf,
		  struct efc_dma *qmem, u16 cq_id);
int sli_cmd_post_sgl_pages(struct sli4 *sli4, void *buf, u16 xri,
		u32 xri_count, struct efc_dma *page0[], struct efc_dma *page1[],
		struct efc_dma *dma);
int
sli_cmd_post_hdr_templates(struct sli4 *sli4, void *buf,
		struct efc_dma *dma, u16 rpi, struct efc_dma *payload_dma);
int
sli_fc_rq_alloc(struct sli4 *sli4, struct sli4_queue *q, u32 n_entries,
		u32 buffer_size, struct sli4_queue *cq, bool is_hdr);
int
sli_fc_rq_set_alloc(struct sli4 *sli4, u32 num_rq_pairs, struct sli4_queue *q[],
		u32 base_cq_id, u32 num, u32 hdr_buf_size, u32 data_buf_size);
u32 sli_fc_get_rpi_requirements(struct sli4 *sli4, u32 n_rpi);
int
sli_abort_wqe(struct sli4 *sli4, void *buf, enum sli4_abort_type type,
	      bool send_abts, u32 ids, u32 mask, u16 tag, u16 cq_id);

int
sli_send_frame_wqe(struct sli4 *sli4, void *buf, u8 sof, u8 eof,
		   u32 *hdr, struct efc_dma *payload, u32 req_len, u8 timeout,
		   u16 xri, u16 req_tag);

int
sli_xmit_els_rsp64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *rsp,
		       struct sli_els_params *params);

int
sli_els_request64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		      struct sli_els_params *params);

int
sli_fcp_icmnd64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl, u16 xri,
		    u16 tag, u16 cq_id, u32 rpi, u32 rnode_fcid, u8 timeout);

int
sli_fcp_iread64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		    u32 first_data_sge, u32 xfer_len, u16 xri,
		    u16 tag, u16 cq_id, u32 rpi, u32 rnode_fcid, u8 dif, u8 bs,
		    u8 timeout);

int
sli_fcp_iwrite64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		     u32 first_data_sge, u32 xfer_len,
		     u32 first_burst, u16 xri, u16 tag, u16 cq_id, u32 rpi,
		     u32 rnode_fcid, u8 dif, u8 bs, u8 timeout);

int
sli_fcp_treceive64_wqe(struct sli4 *sli, void *buf, struct efc_dma *sgl,
		       u32 first_data_sge, u16 cq_id, u8 dif, u8 bs,
		       struct sli_fcp_tgt_params *params);
int
sli_fcp_cont_treceive64_wqe(struct sli4 *sli, void *buf, struct efc_dma *sgl,
			    u32 first_data_sge, u16 sec_xri, u16 cq_id, u8 dif,
			    u8 bs, struct sli_fcp_tgt_params *params);

int
sli_fcp_trsp64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		   u16 cq_id, u8 port_owned, struct sli_fcp_tgt_params *params);

int
sli_fcp_tsend64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		    u32 first_data_sge, u16 cq_id, u8 dif, u8 bs,
		    struct sli_fcp_tgt_params *params);
int
sli_gen_request64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *sgl,
		      struct sli_ct_params *params);

int
sli_xmit_bls_rsp64_wqe(struct sli4 *sli4, void *buf,
		struct sli_bls_payload *payload, struct sli_bls_params *params);

int
sli_xmit_sequence64_wqe(struct sli4 *sli4, void *buf, struct efc_dma *payload,
			struct sli_ct_params *params);

int
sli_requeue_xri_wqe(struct sli4 *sli4, void *buf, u16 xri, u16 tag, u16 cq_id);
void
sli4_cmd_lowlevel_set_watchdog(struct sli4 *sli4, void *buf, size_t size,
			       u16 timeout);

const char *sli_fc_get_status_string(u32 status);

#endif /* !_SLI4_H */