Quelle  pds_adminq.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright(c) 2023 Advanced Micro Devices, Inc */

#ifndef _PDS_CORE_ADMINQ_H_
#define _PDS_CORE_ADMINQ_H_

#define PDSC_ADMINQ_MAX_POLL_INTERVAL 256000 /* usecs */

enum pds_core_adminq_flags {
 PDS_AQ_FLAG_FASTPOLL = BIT(1), /* completion poll at 1ms */
};

/*
 * enum pds_core_adminq_opcode - AdminQ command opcodes
 * These commands are only processed on AdminQ, not available in devcmd
 */
enum pds_core_adminq_opcode {
 PDS_AQ_CMD_NOP   = 0,

 /* Client control */
 PDS_AQ_CMD_CLIENT_REG  = 6,
 PDS_AQ_CMD_CLIENT_UNREG  = 7,
 PDS_AQ_CMD_CLIENT_CMD  = 8,

 /* LIF commands */
 PDS_AQ_CMD_LIF_IDENTIFY  = 20,
 PDS_AQ_CMD_LIF_INIT  = 21,
 PDS_AQ_CMD_LIF_RESET  = 22,
 PDS_AQ_CMD_LIF_GETATTR  = 23,
 PDS_AQ_CMD_LIF_SETATTR  = 24,
 PDS_AQ_CMD_LIF_SETPHC  = 25,

 PDS_AQ_CMD_RX_MODE_SET  = 30,
 PDS_AQ_CMD_RX_FILTER_ADD = 31,
 PDS_AQ_CMD_RX_FILTER_DEL = 32,

 /* Queue commands */
 PDS_AQ_CMD_Q_IDENTIFY  = 39,
 PDS_AQ_CMD_Q_INIT  = 40,
 PDS_AQ_CMD_Q_CONTROL  = 41,

 /* SR/IOV commands */
 PDS_AQ_CMD_VF_GETATTR  = 60,
 PDS_AQ_CMD_VF_SETATTR  = 61,
};

/*
 * enum pds_core_notifyq_opcode - NotifyQ event codes
 */
enum pds_core_notifyq_opcode {
 PDS_EVENT_LINK_CHANGE  = 1,
 PDS_EVENT_RESET   = 2,
 PDS_EVENT_XCVR   = 5,
 PDS_EVENT_CLIENT  = 6,
};

#define PDS_COMP_COLOR_MASK  0x80

/**
 * struct pds_core_notifyq_event - Generic event reporting structure
 * @eid:   event number
 * @ecode: event code
 *
 * This is the generic event report struct from which the other
 * actual events will be formed.
 */
struct pds_core_notifyq_event {
 __le64 eid;
 __le16 ecode;
};

/**
 * struct pds_core_link_change_event - Link change event notification
 * @eid:  event number
 * @ecode:  event code = PDS_EVENT_LINK_CHANGE
 * @link_status: link up/down, with error bits
 * @link_speed:  speed of the network link
 *
 * Sent when the network link state changes between UP and DOWN
 */
struct pds_core_link_change_event {
 __le64 eid;
 __le16 ecode;
 __le16 link_status;
 __le32 link_speed; /* units of 1Mbps: e.g. 10000 = 10Gbps */
};

/**
 * struct pds_core_reset_event - Reset event notification
 * @eid:  event number
 * @ecode:  event code = PDS_EVENT_RESET
 * @reset_code:  reset type
 * @state:  0=pending, 1=complete, 2=error
 *
 * Sent when the NIC or some subsystem is going to be or
 * has been reset.
 */
struct pds_core_reset_event {
 __le64 eid;
 __le16 ecode;
 u8     reset_code;
 u8     state;
};

/**
 * struct pds_core_client_event - Client event notification
 * @eid:  event number
 * @ecode:  event code = PDS_EVENT_CLIENT
 * @client_id:          client to sent event to
 * @client_event:       wrapped event struct for the client
 *
 * Sent when an event needs to be passed on to a client
 */
struct pds_core_client_event {
 __le64 eid;
 __le16 ecode;
 __le16 client_id;
 u8     client_event[54];
};

/**
 * struct pds_core_notifyq_cmd - Placeholder for building qcq
 * @data:      anonymous field for building the qcq
 */
struct pds_core_notifyq_cmd {
 __le32 data; /* Not used but needed for qcq structure */
};

/*
 * union pds_core_notifyq_comp - Overlay of notifyq event structures
 */
union pds_core_notifyq_comp {
 struct {
  __le64 eid;
  __le16 ecode;
 };
 struct pds_core_notifyq_event     event;
 struct pds_core_link_change_event link_change;
 struct pds_core_reset_event       reset;
 u8     data[64];
};

#define PDS_DEVNAME_LEN  32
/**
 * struct pds_core_client_reg_cmd - Register a new client with DSC
 * @opcode:         opcode PDS_AQ_CMD_CLIENT_REG
 * @rsvd:           word boundary padding
 * @devname:        text name of client device
 * @vif_type:       what type of device (enum pds_core_vif_types)
 *
 * Tell the DSC of the new client, and receive a client_id from DSC.
 */
struct pds_core_client_reg_cmd {
 u8     opcode;
 u8     rsvd[3];
 char   devname[PDS_DEVNAME_LEN];
 u8     vif_type;
};

/**
 * struct pds_core_client_reg_comp - Client registration completion
 * @status:     Status of the command (enum pdc_core_status_code)
 * @rsvd:       Word boundary padding
 * @comp_index: Index in the descriptor ring for which this is the completion
 * @client_id:  New id assigned by DSC
 * @rsvd1:      Word boundary padding
 * @color:      Color bit
 */
struct pds_core_client_reg_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 __le16 client_id;
 u8     rsvd1[9];
 u8     color;
};

/**
 * struct pds_core_client_unreg_cmd - Unregister a client from DSC
 * @opcode:     opcode PDS_AQ_CMD_CLIENT_UNREG
 * @rsvd:       word boundary padding
 * @client_id:  id of client being removed
 *
 * Tell the DSC this client is going away and remove its context
 * This uses the generic completion.
 */
struct pds_core_client_unreg_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 client_id;
};

/**
 * struct pds_core_client_request_cmd - Pass along a wrapped client AdminQ cmd
 * @opcode:     opcode PDS_AQ_CMD_CLIENT_CMD
 * @rsvd:       word boundary padding
 * @client_id:  id of client being removed
 * @client_cmd: the wrapped client command
 *
 * Proxy post an adminq command for the client.
 * This uses the generic completion.
 */
struct pds_core_client_request_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 client_id;
 u8     client_cmd[60];
};

#define PDS_CORE_MAX_FRAGS  16

#define PDS_CORE_QCQ_F_INITED  BIT(0)
#define PDS_CORE_QCQ_F_SG  BIT(1)
#define PDS_CORE_QCQ_F_INTR  BIT(2)
#define PDS_CORE_QCQ_F_TX_STATS  BIT(3)
#define PDS_CORE_QCQ_F_RX_STATS  BIT(4)
#define PDS_CORE_QCQ_F_NOTIFYQ  BIT(5)
#define PDS_CORE_QCQ_F_CMB_RINGS BIT(6)
#define PDS_CORE_QCQ_F_CORE  BIT(7)

enum pds_core_lif_type {
 PDS_CORE_LIF_TYPE_DEFAULT = 0,
};

#define PDS_CORE_IFNAMSIZ  16

/**
 * enum pds_core_logical_qtype - Logical Queue Types
 * @PDS_CORE_QTYPE_ADMINQ:    Administrative Queue
 * @PDS_CORE_QTYPE_NOTIFYQ:   Notify Queue
 * @PDS_CORE_QTYPE_RXQ:       Receive Queue
 * @PDS_CORE_QTYPE_TXQ:       Transmit Queue
 * @PDS_CORE_QTYPE_EQ:        Event Queue
 * @PDS_CORE_QTYPE_MAX:       Max queue type supported
 */
enum pds_core_logical_qtype {
 PDS_CORE_QTYPE_ADMINQ  = 0,
 PDS_CORE_QTYPE_NOTIFYQ = 1,
 PDS_CORE_QTYPE_RXQ     = 2,
 PDS_CORE_QTYPE_TXQ     = 3,
 PDS_CORE_QTYPE_EQ      = 4,

 PDS_CORE_QTYPE_MAX     = 16   /* don't change - used in struct size */
};

/**
 * union pds_core_lif_config - LIF configuration
 * @state:     LIF state (enum pds_core_lif_state)
 * @rsvd:           Word boundary padding
 * @name:     LIF name
 * @rsvd2:          Word boundary padding
 * @features:     LIF features active (enum pds_core_hw_features)
 * @queue_count:    Queue counts per queue-type
 * @words:          Full union buffer size
 */
union pds_core_lif_config {
 struct {
  u8     state;
  u8     rsvd[3];
  char   name[PDS_CORE_IFNAMSIZ];
  u8     rsvd2[12];
  __le64 features;
  __le32 queue_count[PDS_CORE_QTYPE_MAX];
 } __packed;
 __le32 words[64];
};

/**
 * struct pds_core_lif_status - LIF status register
 * @eid:      most recent NotifyQ event id
 * @rsvd:            full struct size
 */
struct pds_core_lif_status {
 __le64 eid;
 u8     rsvd[56];
};

/**
 * struct pds_core_lif_info - LIF info structure
 * @config: LIF configuration structure
 * @status: LIF status structure
 */
struct pds_core_lif_info {
 union pds_core_lif_config config;
 struct pds_core_lif_status status;
};

/**
 * struct pds_core_lif_identity - LIF identity information (type-specific)
 * @features:  LIF features (see enum pds_core_hw_features)
 * @version:  Identify structure version
 * @hw_index:  LIF hardware index
 * @rsvd:  Word boundary padding
 * @max_nb_sessions: Maximum number of sessions supported
 * @rsvd2:  buffer padding
 * @config:  LIF config struct with features, q counts
 */
struct pds_core_lif_identity {
 __le64 features;
 u8     version;
 u8     hw_index;
 u8     rsvd[2];
 __le32 max_nb_sessions;
 u8     rsvd2[120];
 union pds_core_lif_config config;
};

/**
 * struct pds_core_lif_identify_cmd - Get LIF identity info command
 * @opcode: Opcode PDS_AQ_CMD_LIF_IDENTIFY
 * @type: LIF type (enum pds_core_lif_type)
 * @client_id: Client identifier
 * @ver: Version of identify returned by device
 * @rsvd:       Word boundary padding
 * @ident_pa: DMA address to receive identity info
 *
 * Firmware will copy LIF identity data (struct pds_core_lif_identity)
 * into the buffer address given.
 */
struct pds_core_lif_identify_cmd {
 u8     opcode;
 u8     type;
 __le16 client_id;
 u8     ver;
 u8     rsvd[3];
 __le64 ident_pa;
};

/**
 * struct pds_core_lif_identify_comp - LIF identify command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @ver: Version of identify returned by device
 * @bytes: Bytes copied into the buffer
 * @rsvd:       Word boundary padding
 * @color:      Color bit
 */
struct pds_core_lif_identify_comp {
 u8     status;
 u8     ver;
 __le16 bytes;
 u8     rsvd[11];
 u8     color;
};

/**
 * struct pds_core_lif_init_cmd - LIF init command
 * @opcode: Opcode PDS_AQ_CMD_LIF_INIT
 * @type: LIF type (enum pds_core_lif_type)
 * @client_id: Client identifier
 * @rsvd:       Word boundary padding
 * @info_pa: Destination address for LIF info (struct pds_core_lif_info)
 */
struct pds_core_lif_init_cmd {
 u8     opcode;
 u8     type;
 __le16 client_id;
 __le32 rsvd;
 __le64 info_pa;
};

/**
 * struct pds_core_lif_init_comp - LIF init command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd:       Word boundary padding
 * @hw_index: Hardware index of the initialized LIF
 * @rsvd1:      Word boundary padding
 * @color:      Color bit
 */
struct pds_core_lif_init_comp {
 u8 status;
 u8 rsvd;
 __le16 hw_index;
 u8     rsvd1[11];
 u8     color;
};

/**
 * struct pds_core_lif_reset_cmd - LIF reset command
 * Will reset only the specified LIF.
 * @opcode: Opcode PDS_AQ_CMD_LIF_RESET
 * @rsvd:       Word boundary padding
 * @client_id: Client identifier
 */
struct pds_core_lif_reset_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 client_id;
};

/**
 * enum pds_core_lif_attr - List of LIF attributes
 * @PDS_CORE_LIF_ATTR_STATE:  LIF state attribute
 * @PDS_CORE_LIF_ATTR_NAME:  LIF name attribute
 * @PDS_CORE_LIF_ATTR_FEATURES:  LIF features attribute
 * @PDS_CORE_LIF_ATTR_STATS_CTRL: LIF statistics control attribute
 */
enum pds_core_lif_attr {
 PDS_CORE_LIF_ATTR_STATE  = 0,
 PDS_CORE_LIF_ATTR_NAME  = 1,
 PDS_CORE_LIF_ATTR_FEATURES = 4,
 PDS_CORE_LIF_ATTR_STATS_CTRL = 6,
};

/**
 * struct pds_core_lif_setattr_cmd - Set LIF attributes on the NIC
 * @opcode: Opcode PDS_AQ_CMD_LIF_SETATTR
 * @attr: Attribute type (enum pds_core_lif_attr)
 * @client_id: Client identifier
 * @state: LIF state (enum pds_core_lif_state)
 * @name: The name string, 0 terminated
 * @features: Features (enum pds_core_hw_features)
 * @stats_ctl: Stats control commands (enum pds_core_stats_ctl_cmd)
 * @rsvd:       Command Buffer padding
 */
struct pds_core_lif_setattr_cmd {
 u8     opcode;
 u8     attr;
 __le16 client_id;
 union {
  u8      state;
  char    name[PDS_CORE_IFNAMSIZ];
  __le64  features;
  u8      stats_ctl;
  u8      rsvd[60];
 } __packed;
};

/**
 * struct pds_core_lif_setattr_comp - LIF set attr command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd:       Word boundary padding
 * @comp_index: Index in the descriptor ring for which this is the completion
 * @features: Features (enum pds_core_hw_features)
 * @rsvd2:      Word boundary padding
 * @color: Color bit
 */
struct pds_core_lif_setattr_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 union {
  __le64  features;
  u8      rsvd2[11];
 } __packed;
 u8     color;
};

/**
 * struct pds_core_lif_getattr_cmd - Get LIF attributes from the NIC
 * @opcode: Opcode PDS_AQ_CMD_LIF_GETATTR
 * @attr: Attribute type (enum pds_core_lif_attr)
 * @client_id: Client identifier
 */
struct pds_core_lif_getattr_cmd {
 u8     opcode;
 u8     attr;
 __le16 client_id;
};

/**
 * struct pds_core_lif_getattr_comp - LIF get attr command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd:       Word boundary padding
 * @comp_index: Index in the descriptor ring for which this is the completion
 * @state: LIF state (enum pds_core_lif_state)
 * @features: Features (enum pds_core_hw_features)
 * @rsvd2:      Word boundary padding
 * @color: Color bit
 */
struct pds_core_lif_getattr_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 union {
  u8      state;
  __le64  features;
  u8      rsvd2[11];
 } __packed;
 u8     color;
};

/**
 * union pds_core_q_identity - Queue identity information
 * @version: Queue type version that can be used with FW
 * @supported: Bitfield of queue versions, first bit = ver 0
 * @rsvd:       Word boundary padding
 * @features: Queue features
 * @desc_sz: Descriptor size
 * @comp_sz: Completion descriptor size
 * @rsvd2:      Word boundary padding
 */
struct pds_core_q_identity {
 u8      version;
 u8      supported;
 u8      rsvd[6];
#define PDS_CORE_QIDENT_F_CQ 0x01 /* queue has completion ring */
 __le64  features;
 __le16  desc_sz;
 __le16  comp_sz;
 u8      rsvd2[6];
};

/**
 * struct pds_core_q_identify_cmd - queue identify command
 * @opcode: Opcode PDS_AQ_CMD_Q_IDENTIFY
 * @type: Logical queue type (enum pds_core_logical_qtype)
 * @client_id: Client identifier
 * @ver: Highest queue type version that the driver supports
 * @rsvd:       Word boundary padding
 * @ident_pa:   DMA address to receive the data (struct pds_core_q_identity)
 */
struct pds_core_q_identify_cmd {
 u8     opcode;
 u8     type;
 __le16 client_id;
 u8     ver;
 u8     rsvd[3];
 __le64 ident_pa;
};

/**
 * struct pds_core_q_identify_comp - queue identify command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd:       Word boundary padding
 * @comp_index: Index in the descriptor ring for which this is the completion
 * @ver: Queue type version that can be used with FW
 * @rsvd1:      Word boundary padding
 * @color:      Color bit
 */
struct pds_core_q_identify_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 u8     ver;
 u8     rsvd1[10];
 u8     color;
};

/**
 * struct pds_core_q_init_cmd - Queue init command
 * @opcode:   Opcode PDS_AQ_CMD_Q_INIT
 * @type:   Logical queue type
 * @client_id:   Client identifier
 * @ver:   Queue type version
 * @rsvd:         Word boundary padding
 * @index:   (LIF, qtype) relative admin queue index
 * @intr_index:   Interrupt control register index, or Event queue index
 * @pid:   Process ID
 * @flags:
 *    IRQ:   Interrupt requested on completion
 *    ENA:   Enable the queue.  If ENA=0 the queue is initialized
 *    but remains disabled, to be later enabled with the
 *    Queue Enable command. If ENA=1, then queue is
 *    initialized and then enabled.
 * @cos:   Class of service for this queue
 * @ring_size:   Queue ring size, encoded as a log2(size), in
 *    number of descriptors.  The actual ring size is
 *    (1 << ring_size).  For example, to select a ring size
 *    of 64 descriptors write ring_size = 6. The minimum
 *    ring_size value is 2 for a ring of 4 descriptors.
 *    The maximum ring_size value is 12 for a ring of 4k
 *    descriptors. Values of ring_size <2 and >12 are
 *    reserved.
 * @ring_base:   Queue ring base address
 * @cq_ring_base: Completion queue ring base address
 */
struct pds_core_q_init_cmd {
 u8     opcode;
 u8     type;
 __le16 client_id;
 u8     ver;
 u8     rsvd[3];
 __le32 index;
 __le16 pid;
 __le16 intr_index;
 __le16 flags;
#define PDS_CORE_QINIT_F_IRQ 0x01 /* Request interrupt on completion */
#define PDS_CORE_QINIT_F_ENA 0x02 /* Enable the queue */
 u8     cos;
#define PDS_CORE_QSIZE_MIN_LG2 2
#define PDS_CORE_QSIZE_MAX_LG2 12
 u8     ring_size;
 __le64 ring_base;
 __le64 cq_ring_base;
} __packed;

/**
 * struct pds_core_q_init_comp - Queue init command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd:       Word boundary padding
 * @comp_index: Index in the descriptor ring for which this is the completion
 * @hw_index: Hardware Queue ID
 * @hw_type: Hardware Queue type
 * @rsvd2:      Word boundary padding
 * @color: Color
 */
struct pds_core_q_init_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 __le32 hw_index;
 u8     hw_type;
 u8     rsvd2[6];
 u8     color;
};

/*
 * enum pds_vdpa_cmd_opcode - vDPA Device commands
 */
enum pds_vdpa_cmd_opcode {
 PDS_VDPA_CMD_INIT  = 48,
 PDS_VDPA_CMD_IDENT  = 49,
 PDS_VDPA_CMD_RESET  = 51,
 PDS_VDPA_CMD_VQ_RESET  = 52,
 PDS_VDPA_CMD_VQ_INIT  = 53,
 PDS_VDPA_CMD_STATUS_UPDATE = 54,
 PDS_VDPA_CMD_SET_FEATURES = 55,
 PDS_VDPA_CMD_SET_ATTR  = 56,
};

/**
 * struct pds_vdpa_cmd - generic command
 * @opcode: Opcode
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 */
struct pds_vdpa_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
};

/**
 * struct pds_vdpa_init_cmd - INIT command
 * @opcode: Opcode PDS_VDPA_CMD_INIT
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 */
struct pds_vdpa_init_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
};

/**
 * struct pds_vdpa_ident - vDPA identification data
 * @hw_features: vDPA features supported by device
 * @max_vqs:  max queues available (2 queues for a single queuepair)
 * @max_qlen:  log(2) of maximum number of descriptors
 * @min_qlen:  log(2) of minimum number of descriptors
 *
 * This struct is used in a DMA block that is set up for the PDS_VDPA_CMD_IDENT
 * transaction.  Set up the DMA block and send the address in the IDENT cmd
 * data, the DSC will write the ident information, then we can remove the DMA
 * block after reading the answer.  If the completion status is 0, then there
 * is valid information, else there was an error and the data should be invalid.
 */
struct pds_vdpa_ident {
 __le64 hw_features;
 __le16 max_vqs;
 __le16 max_qlen;
 __le16 min_qlen;
};

/**
 * struct pds_vdpa_ident_cmd - IDENT command
 * @opcode: Opcode PDS_VDPA_CMD_IDENT
 * @rsvd:       Word boundary padding
 * @vf_id: VF id
 * @len: length of ident info DMA space
 * @ident_pa: address for DMA of ident info (struct pds_vdpa_ident)
 *   only used for this transaction, then forgotten by DSC
 */
struct pds_vdpa_ident_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 __le32 len;
 __le64 ident_pa;
};

/**
 * struct pds_vdpa_status_cmd - STATUS_UPDATE command
 * @opcode: Opcode PDS_VDPA_CMD_STATUS_UPDATE
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 * @status: new status bits
 */
struct pds_vdpa_status_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
 u8     status;
};

/**
 * enum pds_vdpa_attr - List of VDPA device attributes
 * @PDS_VDPA_ATTR_MAC:          MAC address
 * @PDS_VDPA_ATTR_MAX_VQ_PAIRS: Max virtqueue pairs
 */
enum pds_vdpa_attr {
 PDS_VDPA_ATTR_MAC          = 1,
 PDS_VDPA_ATTR_MAX_VQ_PAIRS = 2,
};

/**
 * struct pds_vdpa_setattr_cmd - SET_ATTR command
 * @opcode:  Opcode PDS_VDPA_CMD_SET_ATTR
 * @vdpa_index:  Index for vdpa subdevice
 * @vf_id:  VF id
 * @attr:  attribute to be changed (enum pds_vdpa_attr)
 * @pad:  Word boundary padding
 * @mac:  new mac address to be assigned as vdpa device address
 * @max_vq_pairs: new limit of virtqueue pairs
 */
struct pds_vdpa_setattr_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
 u8     attr;
 u8     pad[3];
 union {
  u8 mac[6];
  __le16 max_vq_pairs;
 } __packed;
};

/**
 * struct pds_vdpa_vq_init_cmd - queue init command
 * @opcode: Opcode PDS_VDPA_CMD_VQ_INIT
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 * @qid: Queue id (bit0 clear = rx, bit0 set = tx, qid=N is ctrlq)
 * @len: log(2) of max descriptor count
 * @desc_addr: DMA address of descriptor area
 * @avail_addr: DMA address of available descriptors (aka driver area)
 * @used_addr: DMA address of used descriptors (aka device area)
 * @intr_index: interrupt index
 * @avail_index: initial device position in available ring
 * @used_index: initial device position in used ring
 */
struct pds_vdpa_vq_init_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
 __le16 qid;
 __le16 len;
 __le64 desc_addr;
 __le64 avail_addr;
 __le64 used_addr;
 __le16 intr_index;
 __le16 avail_index;
 __le16 used_index;
};

/**
 * struct pds_vdpa_vq_init_comp - queue init completion
 * @status: Status of the command (enum pds_core_status_code)
 * @hw_qtype: HW queue type, used in doorbell selection
 * @hw_qindex: HW queue index, used in doorbell selection
 * @rsvd: Word boundary padding
 * @color: Color bit
 */
struct pds_vdpa_vq_init_comp {
 u8     status;
 u8     hw_qtype;
 __le16 hw_qindex;
 u8     rsvd[11];
 u8     color;
};

/**
 * struct pds_vdpa_vq_reset_cmd - queue reset command
 * @opcode: Opcode PDS_VDPA_CMD_VQ_RESET
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 * @qid: Queue id
 */
struct pds_vdpa_vq_reset_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
 __le16 qid;
};

/**
 * struct pds_vdpa_vq_reset_comp - queue reset completion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd0: Word boundary padding
 * @avail_index: current device position in available ring
 * @used_index: current device position in used ring
 * @rsvd: Word boundary padding
 * @color: Color bit
 */
struct pds_vdpa_vq_reset_comp {
 u8     status;
 u8     rsvd0;
 __le16 avail_index;
 __le16 used_index;
 u8     rsvd[9];
 u8     color;
};

/**
 * struct pds_vdpa_set_features_cmd - set hw features
 * @opcode: Opcode PDS_VDPA_CMD_SET_FEATURES
 * @vdpa_index: Index for vdpa subdevice
 * @vf_id: VF id
 * @rsvd:       Word boundary padding
 * @features: Feature bit mask
 */
struct pds_vdpa_set_features_cmd {
 u8     opcode;
 u8     vdpa_index;
 __le16 vf_id;
 __le32 rsvd;
 __le64 features;
};

#define PDS_LM_DEVICE_STATE_LENGTH  65536
#define PDS_LM_CHECK_DEVICE_STATE_LENGTH(X) \
   PDS_CORE_SIZE_CHECK(union, PDS_LM_DEVICE_STATE_LENGTH, X)

/*
 * enum pds_lm_cmd_opcode - Live Migration Device commands
 */
enum pds_lm_cmd_opcode {
 PDS_LM_CMD_HOST_VF_STATUS  = 1,

 /* Device state commands */
 PDS_LM_CMD_STATE_SIZE    = 16,
 PDS_LM_CMD_SUSPEND         = 18,
 PDS_LM_CMD_SUSPEND_STATUS  = 19,
 PDS_LM_CMD_RESUME          = 20,
 PDS_LM_CMD_SAVE            = 21,
 PDS_LM_CMD_RESTORE         = 22,

 /* Dirty page tracking commands */
 PDS_LM_CMD_DIRTY_STATUS    = 32,
 PDS_LM_CMD_DIRTY_ENABLE    = 33,
 PDS_LM_CMD_DIRTY_DISABLE   = 34,
 PDS_LM_CMD_DIRTY_READ_SEQ  = 35,
 PDS_LM_CMD_DIRTY_WRITE_ACK = 36,
};

/**
 * struct pds_lm_cmd - generic command
 * @opcode: Opcode
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @rsvd2: Structure padding to 60 Bytes
 */
struct pds_lm_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     rsvd2[56];
};

/**
 * struct pds_lm_state_size_cmd - STATE_SIZE command
 * @opcode: Opcode
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 */
struct pds_lm_state_size_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
};

/**
 * struct pds_lm_state_size_comp - STATE_SIZE command completion
 * @status:  Status of the command (enum pds_core_status_code)
 * @rsvd:  Word boundary padding
 * @comp_index:  Index in the desc ring for which this is the completion
 * @size:  Size of the device state
 * @rsvd2:  Word boundary padding
 * @color:  Color bit
 */
struct pds_lm_state_size_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 union {
  __le64 size;
  u8     rsvd2[11];
 } __packed;
 u8     color;
};

enum pds_lm_suspend_resume_type {
 PDS_LM_SUSPEND_RESUME_TYPE_FULL = 0,
 PDS_LM_SUSPEND_RESUME_TYPE_P2P = 1,
};

/**
 * struct pds_lm_suspend_cmd - SUSPEND command
 * @opcode: Opcode PDS_LM_CMD_SUSPEND
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @type: Type of suspend (enum pds_lm_suspend_resume_type)
 */
struct pds_lm_suspend_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     type;
};

/**
 * struct pds_lm_suspend_status_cmd - SUSPEND status command
 * @opcode: Opcode PDS_AQ_CMD_LM_SUSPEND_STATUS
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @type: Type of suspend (enum pds_lm_suspend_resume_type)
 */
struct pds_lm_suspend_status_cmd {
 u8 opcode;
 u8 rsvd;
 __le16 vf_id;
 u8 type;
};

/**
 * struct pds_lm_resume_cmd - RESUME command
 * @opcode: Opcode PDS_LM_CMD_RESUME
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @type: Type of resume (enum pds_lm_suspend_resume_type)
 */
struct pds_lm_resume_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     type;
};

/**
 * struct pds_lm_sg_elem - Transmit scatter-gather (SG) descriptor element
 * @addr: DMA address of SG element data buffer
 * @len: Length of SG element data buffer, in bytes
 * @rsvd: Word boundary padding
 */
struct pds_lm_sg_elem {
 __le64 addr;
 __le32 len;
 __le16 rsvd[2];
};

/**
 * struct pds_lm_save_cmd - SAVE command
 * @opcode: Opcode PDS_LM_CMD_SAVE
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @rsvd2: Word boundary padding
 * @sgl_addr: IOVA address of the SGL to dma the device state
 * @num_sge: Total number of SG elements
 */
struct pds_lm_save_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     rsvd2[4];
 __le64 sgl_addr;
 __le32 num_sge;
} __packed;

/**
 * struct pds_lm_restore_cmd - RESTORE command
 * @opcode: Opcode PDS_LM_CMD_RESTORE
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @rsvd2: Word boundary padding
 * @sgl_addr: IOVA address of the SGL to dma the device state
 * @num_sge: Total number of SG elements
 */
struct pds_lm_restore_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     rsvd2[4];
 __le64 sgl_addr;
 __le32 num_sge;
} __packed;

/**
 * union pds_lm_dev_state - device state information
 * @words: Device state words
 */
union pds_lm_dev_state {
 __le32 words[PDS_LM_DEVICE_STATE_LENGTH / sizeof(__le32)];
};

enum pds_lm_host_vf_status {
 PDS_LM_STA_NONE = 0,
 PDS_LM_STA_IN_PROGRESS,
 PDS_LM_STA_MAX,
};

/**
 * struct pds_lm_dirty_region_info - Memory region info for STATUS and ENABLE
 * @dma_base:  Base address of the DMA-contiguous memory region
 * @page_count:  Number of pages in the memory region
 * @page_size_log2: Log2 page size in the memory region
 * @rsvd:  Word boundary padding
 */
struct pds_lm_dirty_region_info {
 __le64 dma_base;
 __le32 page_count;
 u8     page_size_log2;
 u8     rsvd[3];
};

/**
 * struct pds_lm_dirty_status_cmd - DIRTY_STATUS command
 * @opcode:  Opcode PDS_LM_CMD_DIRTY_STATUS
 * @rsvd:  Word boundary padding
 * @vf_id:  VF id
 * @max_regions: Capacity of the region info buffer
 * @rsvd2:  Word boundary padding
 * @regions_dma: DMA address of the region info buffer
 *
 * The minimum of max_regions (from the command) and num_regions (from the
 * completion) of struct pds_lm_dirty_region_info will be written to
 * regions_dma.
 *
 * The max_regions may be zero, in which case regions_dma is ignored.  In that
 * case, the completion will only report the maximum number of regions
 * supported by the device, and the number of regions currently enabled.
 */
struct pds_lm_dirty_status_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     max_regions;
 u8     rsvd2[3];
 __le64 regions_dma;
} __packed;

/**
 * enum pds_lm_dirty_bmp_type - Type of dirty page bitmap
 * @PDS_LM_DIRTY_BMP_TYPE_NONE: No bitmap / disabled
 * @PDS_LM_DIRTY_BMP_TYPE_SEQ_ACK: Seq/Ack bitmap representation
 */
enum pds_lm_dirty_bmp_type {
 PDS_LM_DIRTY_BMP_TYPE_NONE     = 0,
 PDS_LM_DIRTY_BMP_TYPE_SEQ_ACK  = 1,
};

/**
 * struct pds_lm_dirty_status_comp - STATUS command completion
 * @status:  Status of the command (enum pds_core_status_code)
 * @rsvd:  Word boundary padding
 * @comp_index:  Index in the desc ring for which this is the completion
 * @max_regions: Maximum number of regions supported by the device
 * @num_regions: Number of regions currently enabled
 * @bmp_type:  Type of dirty bitmap representation
 * @rsvd2:  Word boundary padding
 * @bmp_type_mask: Mask of supported bitmap types, bit index per type
 * @rsvd3:  Word boundary padding
 * @color:  Color bit
 *
 * This completion descriptor is used for STATUS, ENABLE, and DISABLE.
 */
struct pds_lm_dirty_status_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 u8     max_regions;
 u8     num_regions;
 u8     bmp_type;
 u8     rsvd2;
 __le32 bmp_type_mask;
 u8     rsvd3[3];
 u8     color;
};

/**
 * struct pds_lm_dirty_enable_cmd - DIRTY_ENABLE command
 * @opcode:  Opcode PDS_LM_CMD_DIRTY_ENABLE
 * @rsvd:  Word boundary padding
 * @vf_id:  VF id
 * @bmp_type:  Type of dirty bitmap representation
 * @num_regions: Number of entries in the region info buffer
 * @rsvd2:  Word boundary padding
 * @regions_dma: DMA address of the region info buffer
 *
 * The num_regions must be nonzero, and less than or equal to the maximum
 * number of regions supported by the device.
 *
 * The memory regions should not overlap.
 *
 * The information should be initialized by the driver.  The device may modify
 * the information on successful completion, such as by size-aligning the
 * number of pages in a region.
 *
 * The modified number of pages will be greater than or equal to the page count
 * given in the enable command, and at least as coarsly aligned as the given
 * value.  For example, the count might be aligned to a multiple of 64, but
 * if the value is already a multiple of 128 or higher, it will not change.
 * If the driver requires its own minimum alignment of the number of pages, the
 * driver should account for that already in the region info of this command.
 *
 * This command uses struct pds_lm_dirty_status_comp for its completion.
 */
struct pds_lm_dirty_enable_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     bmp_type;
 u8     num_regions;
 u8     rsvd2[2];
 __le64 regions_dma;
} __packed;

/**
 * struct pds_lm_dirty_disable_cmd - DIRTY_DISABLE command
 * @opcode: Opcode PDS_LM_CMD_DIRTY_DISABLE
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 *
 * Dirty page tracking will be disabled.  This may be called in any state, as
 * long as dirty page tracking is supported by the device, to ensure that dirty
 * page tracking is disabled.
 *
 * This command uses struct pds_lm_dirty_status_comp for its completion.  On
 * success, num_regions will be zero.
 */
struct pds_lm_dirty_disable_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
};

/**
 * struct pds_lm_dirty_seq_ack_cmd - DIRTY_READ_SEQ or _WRITE_ACK command
 * @opcode: Opcode PDS_LM_CMD_DIRTY_[READ_SEQ|WRITE_ACK]
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @off_bytes: Byte offset in the bitmap
 * @len_bytes: Number of bytes to transfer
 * @num_sge: Number of DMA scatter gather elements
 * @rsvd2: Word boundary padding
 * @sgl_addr: DMA address of scatter gather list
 *
 * Read bytes from the SEQ bitmap, or write bytes into the ACK bitmap.
 *
 * This command treats the entire bitmap as a byte buffer.  It does not
 * distinguish between guest memory regions.  The driver should refer to the
 * number of pages in each region, according to PDS_LM_CMD_DIRTY_STATUS, to
 * determine the region boundaries in the bitmap.  Each region will be
 * represented by exactly the number of bits as the page count for that region,
 * immediately following the last bit of the previous region.
 */
struct pds_lm_dirty_seq_ack_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 __le32 off_bytes;
 __le32 len_bytes;
 __le16 num_sge;
 u8     rsvd2[2];
 __le64 sgl_addr;
} __packed;

/**
 * struct pds_lm_host_vf_status_cmd - HOST_VF_STATUS command
 * @opcode: Opcode PDS_LM_CMD_HOST_VF_STATUS
 * @rsvd: Word boundary padding
 * @vf_id: VF id
 * @status: Current LM status of host VF driver (enum pds_lm_host_status)
 */
struct pds_lm_host_vf_status_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 vf_id;
 u8     status;
};

enum pds_fwctl_cmd_opcode {
 PDS_FWCTL_CMD_IDENT = 70,
 PDS_FWCTL_CMD_RPC   = 71,
 PDS_FWCTL_CMD_QUERY = 72,
};

/**
 * struct pds_fwctl_cmd - Firmware control command structure
 * @opcode: Opcode
 * @rsvd:   Reserved
 * @ep:     Endpoint identifier
 * @op:     Operation identifier
 */
struct pds_fwctl_cmd {
 u8     opcode;
 u8     rsvd[3];
 __le32 ep;
 __le32 op;
} __packed;

/**
 * struct pds_fwctl_comp - Firmware control completion structure
 * @status:     Status of the firmware control operation
 * @rsvd:       Reserved
 * @comp_index: Completion index in little-endian format
 * @rsvd2:      Reserved
 * @color:      Color bit indicating the state of the completion
 */
struct pds_fwctl_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 u8     rsvd2[11];
 u8     color;
} __packed;

/**
 * struct pds_fwctl_ident_cmd - Firmware control identification command structure
 * @opcode:   Operation code for the command
 * @rsvd:     Reserved
 * @version:  Interface version
 * @rsvd2:    Reserved
 * @len:      Length of the identification data
 * @ident_pa: Physical address of the identification data
 */
struct pds_fwctl_ident_cmd {
 u8     opcode;
 u8     rsvd;
 u8     version;
 u8     rsvd2;
 __le32 len;
 __le64 ident_pa;
} __packed;

/* future feature bits here
 * enum pds_fwctl_features {
 * };
 * (compilers don't like empty enums)
 */

/**
 * struct pds_fwctl_ident - Firmware control identification structure
 * @features:    Supported features (enum pds_fwctl_features)
 * @version:     Interface version
 * @rsvd:        Reserved
 * @max_req_sz:  Maximum request size
 * @max_resp_sz: Maximum response size
 * @max_req_sg_elems:  Maximum number of request SGs
 * @max_resp_sg_elems: Maximum number of response SGs
 */
struct pds_fwctl_ident {
 __le64 features;
 u8     version;
 u8     rsvd[3];
 __le32 max_req_sz;
 __le32 max_resp_sz;
 u8     max_req_sg_elems;
 u8     max_resp_sg_elems;
} __packed;

enum pds_fwctl_query_entity {
 PDS_FWCTL_RPC_ROOT = 0,
 PDS_FWCTL_RPC_ENDPOINT = 1,
 PDS_FWCTL_RPC_OPERATION = 2,
};

#define PDS_FWCTL_RPC_OPCODE_CMD_SHIFT 0
#define PDS_FWCTL_RPC_OPCODE_CMD_MASK GENMASK(15, PDS_FWCTL_RPC_OPCODE_CMD_SHIFT)
#define PDS_FWCTL_RPC_OPCODE_VER_SHIFT 16
#define PDS_FWCTL_RPC_OPCODE_VER_MASK GENMASK(23, PDS_FWCTL_RPC_OPCODE_VER_SHIFT)

#define PDS_FWCTL_RPC_OPCODE_GET_CMD(op)  FIELD_GET(PDS_FWCTL_RPC_OPCODE_CMD_MASK, op)
#define PDS_FWCTL_RPC_OPCODE_GET_VER(op)  FIELD_GET(PDS_FWCTL_RPC_OPCODE_VER_MASK, op)

#define PDS_FWCTL_RPC_OPCODE_CMP(op1, op2) \
 (PDS_FWCTL_RPC_OPCODE_GET_CMD(op1) == PDS_FWCTL_RPC_OPCODE_GET_CMD(op2) && \
  PDS_FWCTL_RPC_OPCODE_GET_VER(op1) <= PDS_FWCTL_RPC_OPCODE_GET_VER(op2))

/*
 * FW command attributes that map to the FWCTL scope values
 */
#define PDSFC_FW_CMD_ATTR_READ               0x00
#define PDSFC_FW_CMD_ATTR_DEBUG_READ         0x02
#define PDSFC_FW_CMD_ATTR_WRITE              0x04
#define PDSFC_FW_CMD_ATTR_DEBUG_WRITE        0x08
#define PDSFC_FW_CMD_ATTR_SYNC               0x10

/**
 * struct pds_fwctl_query_cmd - Firmware control query command structure
 * @opcode: Operation code for the command
 * @entity:  Entity type to query (enum pds_fwctl_query_entity)
 * @version: Version of the query data structure supported by the driver
 * @rsvd:    Reserved
 * @query_data_buf_len: Length of the query data buffer
 * @query_data_buf_pa:  Physical address of the query data buffer
 * @ep:      Endpoint identifier to query  (when entity is PDS_FWCTL_RPC_ENDPOINT)
 * @op:      Operation identifier to query (when entity is PDS_FWCTL_RPC_OPERATION)
 *
 * This structure is used to send a query command to the firmware control
 * interface. The structure is packed to ensure there is no padding between
 * the fields.
 */
struct pds_fwctl_query_cmd {
 u8     opcode;
 u8     entity;
 u8     version;
 u8     rsvd;
 __le32 query_data_buf_len;
 __le64 query_data_buf_pa;
 union {
  __le32 ep;
  __le32 op;
 };
} __packed;

/**
 * struct pds_fwctl_query_comp - Firmware control query completion structure
 * @status:     Status of the query command
 * @rsvd:       Reserved
 * @comp_index: Completion index in little-endian format
 * @version:    Version of the query data structure returned by firmware. This
 *   should be less than or equal to the version supported by the driver
 * @rsvd2:      Reserved
 * @color:      Color bit indicating the state of the completion
 */
struct pds_fwctl_query_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 u8     version;
 u8     rsvd2[2];
 u8     color;
} __packed;

/**
 * struct pds_fwctl_query_data_endpoint - query data for entity PDS_FWCTL_RPC_ROOT
 * @id: The identifier for the data endpoint
 */
struct pds_fwctl_query_data_endpoint {
 __le32 id;
} __packed;

/**
 * struct pds_fwctl_query_data_operation - query data for entity PDS_FWCTL_RPC_ENDPOINT
 * @id:    Operation identifier
 * @scope: Scope of the operation (enum fwctl_rpc_scope)
 * @rsvd:  Reserved
 */
struct pds_fwctl_query_data_operation {
 __le32 id;
 u8     scope;
 u8     rsvd[3];
} __packed;

/**
 * struct pds_fwctl_query_data - query data structure
 * @version:     Version of the query data structure
 * @rsvd:        Reserved
 * @num_entries: Number of entries in the union
 * @entries:     Array of query data entries, depending on the entity type
 */
struct pds_fwctl_query_data {
 u8      version;
 u8      rsvd[3];
 __le32  num_entries;
 u8      entries[] __counted_by_le(num_entries);
} __packed;

/**
 * struct pds_fwctl_rpc_cmd - Firmware control RPC command
 * @opcode:        opcode PDS_FWCTL_CMD_RPC
 * @rsvd:          Reserved
 * @flags:         Indicates indirect request and/or response handling
 * @ep:            Endpoint identifier
 * @op:            Operation identifier
 * @inline_req0:   Buffer for inline request
 * @inline_req1:   Buffer for inline request
 * @req_pa:        Physical address of request data
 * @req_sz:        Size of the request
 * @req_sg_elems:  Number of request SGs
 * @req_rsvd:      Reserved
 * @inline_req2:   Buffer for inline request
 * @resp_pa:       Physical address of response data
 * @resp_sz:       Size of the response
 * @resp_sg_elems: Number of response SGs
 * @resp_rsvd:     Reserved
 */
struct pds_fwctl_rpc_cmd {
 u8     opcode;
 u8     rsvd;
 __le16 flags;
#define PDS_FWCTL_RPC_IND_REQ  0x1
#define PDS_FWCTL_RPC_IND_RESP  0x2
 __le32 ep;
 __le32 op;
 u8 inline_req0[16];
 union {
  u8 inline_req1[16];
  struct {
   __le64 req_pa;
   __le32 req_sz;
   u8     req_sg_elems;
   u8     req_rsvd[3];
  };
 };
 union {
  u8 inline_req2[16];
  struct {
   __le64 resp_pa;
   __le32 resp_sz;
   u8     resp_sg_elems;
   u8     resp_rsvd[3];
  };
 };
} __packed;

/**
 * struct pds_sg_elem - Transmit scatter-gather (SG) descriptor element
 * @addr: DMA address of SG element data buffer
 * @len: Length of SG element data buffer, in bytes
 * @rsvd: Reserved
 */
struct pds_sg_elem {
 __le64 addr;
 __le32 len;
 u8     rsvd[4];
} __packed;

/**
 * struct pds_fwctl_rpc_comp - Completion of a firmware control RPC
 * @status:     Status of the command
 * @rsvd:       Reserved
 * @comp_index: Completion index of the command
 * @err:        Error code, if any, from the RPC
 * @resp_sz:    Size of the response
 * @rsvd2:      Reserved
 * @color:      Color bit indicating the state of the completion
 */
struct pds_fwctl_rpc_comp {
 u8     status;
 u8     rsvd;
 __le16 comp_index;
 __le32 err;
 __le32 resp_sz;
 u8     rsvd2[3];
 u8     color;
} __packed;

union pds_core_adminq_cmd {
 u8     opcode;
 u8     bytes[64];

 struct pds_core_client_reg_cmd     client_reg;
 struct pds_core_client_unreg_cmd   client_unreg;
 struct pds_core_client_request_cmd client_request;

 struct pds_core_lif_identify_cmd  lif_ident;
 struct pds_core_lif_init_cmd      lif_init;
 struct pds_core_lif_reset_cmd     lif_reset;
 struct pds_core_lif_setattr_cmd   lif_setattr;
 struct pds_core_lif_getattr_cmd   lif_getattr;

 struct pds_core_q_identify_cmd    q_ident;
 struct pds_core_q_init_cmd        q_init;

 struct pds_vdpa_cmd    vdpa;
 struct pds_vdpa_init_cmd   vdpa_init;
 struct pds_vdpa_ident_cmd   vdpa_ident;
 struct pds_vdpa_status_cmd   vdpa_status;
 struct pds_vdpa_setattr_cmd   vdpa_setattr;
 struct pds_vdpa_set_features_cmd  vdpa_set_features;
 struct pds_vdpa_vq_init_cmd   vdpa_vq_init;
 struct pds_vdpa_vq_reset_cmd   vdpa_vq_reset;

 struct pds_lm_suspend_cmd   lm_suspend;
 struct pds_lm_suspend_status_cmd  lm_suspend_status;
 struct pds_lm_resume_cmd   lm_resume;
 struct pds_lm_state_size_cmd   lm_state_size;
 struct pds_lm_save_cmd    lm_save;
 struct pds_lm_restore_cmd   lm_restore;
 struct pds_lm_host_vf_status_cmd  lm_host_vf_status;
 struct pds_lm_dirty_status_cmd   lm_dirty_status;
 struct pds_lm_dirty_enable_cmd   lm_dirty_enable;
 struct pds_lm_dirty_disable_cmd   lm_dirty_disable;
 struct pds_lm_dirty_seq_ack_cmd   lm_dirty_seq_ack;

 struct pds_fwctl_cmd    fwctl;
 struct pds_fwctl_ident_cmd   fwctl_ident;
 struct pds_fwctl_rpc_cmd   fwctl_rpc;
 struct pds_fwctl_query_cmd   fwctl_query;
};

union pds_core_adminq_comp {
 struct {
  u8     status;
  u8     rsvd;
  __le16 comp_index;
  u8     rsvd2[11];
  u8     color;
 };
 u32    words[4];

 struct pds_core_client_reg_comp   client_reg;

 struct pds_core_lif_identify_comp lif_ident;
 struct pds_core_lif_init_comp     lif_init;
 struct pds_core_lif_setattr_comp  lif_setattr;
 struct pds_core_lif_getattr_comp  lif_getattr;

 struct pds_core_q_identify_comp   q_ident;
 struct pds_core_q_init_comp       q_init;

 struct pds_vdpa_vq_init_comp   vdpa_vq_init;
 struct pds_vdpa_vq_reset_comp   vdpa_vq_reset;

 struct pds_lm_state_size_comp   lm_state_size;
 struct pds_lm_dirty_status_comp   lm_dirty_status;

 struct pds_fwctl_comp    fwctl;
 struct pds_fwctl_rpc_comp   fwctl_rpc;
 struct pds_fwctl_query_comp   fwctl_query;
};

#ifndef __CHECKER__
static_assert(sizeof(union pds_core_adminq_cmd) == 64);
static_assert(sizeof(union pds_core_adminq_comp) == 16);
static_assert(sizeof(union pds_core_notifyq_comp) == 64);
#endif /* __CHECKER__ */

/* The color bit is a 'done' bit for the completion descriptors
 * where the meaning alternates between '1' and '0' for alternating
 * passes through the completion descriptor ring.
 */
static inline bool pdsc_color_match(u8 color, bool done_color)
{
 return (!!(color & PDS_COMP_COLOR_MASK)) == done_color;
}

struct pdsc;
int pdsc_adminq_post(struct pdsc *pdsc,
       union pds_core_adminq_cmd *cmd,
       union pds_core_adminq_comp *comp,
       bool fast_poll);

#endif /* _PDS_CORE_ADMINQ_H_ */