Quelle  pds_core_if.h   Sprache: C

/* SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) OR BSD-2-Clause */
/* Copyright(c) 2023 Advanced Micro Devices, Inc. */

#ifndef _PDS_CORE_IF_H_
#define _PDS_CORE_IF_H_

#define PCI_VENDOR_ID_PENSANDO   0x1dd8
#define PCI_DEVICE_ID_PENSANDO_CORE_PF  0x100c
#define PCI_DEVICE_ID_VIRTIO_NET_TRANS  0x1000
#define PCI_DEVICE_ID_PENSANDO_IONIC_ETH_VF 0x1003
#define PCI_DEVICE_ID_PENSANDO_VDPA_VF  0x100b
#define PDS_CORE_BARS_MAX   4
#define PDS_CORE_PCI_BAR_DBELL   1

/* Bar0 */
#define PDS_CORE_DEV_INFO_SIGNATURE  0x44455649 /* 'DEVI' */
#define PDS_CORE_BAR0_SIZE   0x8000
#define PDS_CORE_BAR0_DEV_INFO_REGS_OFFSET 0x0000
#define PDS_CORE_BAR0_DEV_CMD_REGS_OFFSET 0x0800
#define PDS_CORE_BAR0_DEV_CMD_DATA_REGS_OFFSET 0x0c00
#define PDS_CORE_BAR0_INTR_STATUS_OFFSET 0x1000
#define PDS_CORE_BAR0_INTR_CTRL_OFFSET  0x2000
#define PDS_CORE_DEV_CMD_DONE   0x00000001

#define PDS_CORE_DEVCMD_TIMEOUT   5

#define PDS_CORE_CLIENT_ID   0
#define PDS_CORE_ASIC_TYPE_CAPRI  0

/*
 * enum pds_core_cmd_opcode - Device commands
 */
enum pds_core_cmd_opcode {
 /* Core init */
 PDS_CORE_CMD_NOP  = 0,
 PDS_CORE_CMD_IDENTIFY  = 1,
 PDS_CORE_CMD_RESET  = 2,
 PDS_CORE_CMD_INIT  = 3,

 PDS_CORE_CMD_FW_DOWNLOAD = 4,
 PDS_CORE_CMD_FW_CONTROL  = 5,

 /* SR/IOV commands */
 PDS_CORE_CMD_VF_GETATTR  = 60,
 PDS_CORE_CMD_VF_SETATTR  = 61,
 PDS_CORE_CMD_VF_CTRL  = 62,

 /* Add commands before this line */
 PDS_CORE_CMD_MAX,
 PDS_CORE_CMD_COUNT
};

/*
 * enum pds_core_status_code - Device command return codes
 */
enum pds_core_status_code {
 PDS_RC_SUCCESS = 0, /* Success */
 PDS_RC_EVERSION = 1, /* Incorrect version for request */
 PDS_RC_EOPCODE = 2, /* Invalid cmd opcode */
 PDS_RC_EIO = 3, /* I/O error */
 PDS_RC_EPERM = 4, /* Permission denied */
 PDS_RC_EQID = 5, /* Bad qid */
 PDS_RC_EQTYPE = 6, /* Bad qtype */
 PDS_RC_ENOENT = 7, /* No such element */
 PDS_RC_EINTR = 8, /* operation interrupted */
 PDS_RC_EAGAIN = 9, /* Try again */
 PDS_RC_ENOMEM = 10, /* Out of memory */
 PDS_RC_EFAULT = 11, /* Bad address */
 PDS_RC_EBUSY = 12, /* Device or resource busy */
 PDS_RC_EEXIST = 13, /* object already exists */
 PDS_RC_EINVAL = 14, /* Invalid argument */
 PDS_RC_ENOSPC = 15, /* No space left or alloc failure */
 PDS_RC_ERANGE = 16, /* Parameter out of range */
 PDS_RC_BAD_ADDR = 17, /* Descriptor contains a bad ptr */
 PDS_RC_DEV_CMD = 18, /* Device cmd attempted on AdminQ */
 PDS_RC_ENOSUPP = 19, /* Operation not supported */
 PDS_RC_ERROR = 29, /* Generic error */
 PDS_RC_ERDMA = 30, /* Generic RDMA error */
 PDS_RC_EVFID = 31, /* VF ID does not exist */
 PDS_RC_BAD_FW = 32, /* FW file is invalid or corrupted */
 PDS_RC_ECLIENT = 33,   /* No such client id */
 PDS_RC_BAD_PCI = 255,  /* Broken PCI when reading status */
};

/**
 * struct pds_core_drv_identity - Driver identity information
 * @drv_type:         Driver type (enum pds_core_driver_type)
 * @os_dist:          OS distribution, numeric format
 * @os_dist_str:      OS distribution, string format
 * @kernel_ver:       Kernel version, numeric format
 * @kernel_ver_str:   Kernel version, string format
 * @driver_ver_str:   Driver version, string format
 */
struct pds_core_drv_identity {
 __le32 drv_type;
 __le32 os_dist;
 char   os_dist_str[128];
 __le32 kernel_ver;
 char   kernel_ver_str[32];
 char   driver_ver_str[32];
};

#define PDS_DEV_TYPE_MAX 16
/**
 * struct pds_core_dev_identity - Device identity information
 * @version:       Version of device identify
 * @type:       Identify type (0 for now)
 * @state:       Device state
 * @rsvd:       Word boundary padding
 * @nlifs:       Number of LIFs provisioned
 * @nintrs:       Number of interrupts provisioned
 * @ndbpgs_per_lif:   Number of doorbell pages per LIF
 * @intr_coal_mult:   Interrupt coalescing multiplication factor
 *       Scale user-supplied interrupt coalescing
 *       value in usecs to device units using:
 *       device units = usecs * mult / div
 * @intr_coal_div:    Interrupt coalescing division factor
 *       Scale user-supplied interrupt coalescing
 *       value in usecs to device units using:
 *       device units = usecs * mult / div
 * @vif_types:        How many of each VIF device type is supported
 */
struct pds_core_dev_identity {
 u8     version;
 u8     type;
 u8     state;
 u8     rsvd;
 __le32 nlifs;
 __le32 nintrs;
 __le32 ndbpgs_per_lif;
 __le32 intr_coal_mult;
 __le32 intr_coal_div;
 __le16 vif_types[PDS_DEV_TYPE_MAX];
};

#define PDS_CORE_IDENTITY_VERSION_1 1

/**
 * struct pds_core_dev_identify_cmd - Driver/device identify command
 * @opcode: Opcode PDS_CORE_CMD_IDENTIFY
 * @ver: Highest version of identify supported by driver
 *
 * Expects to find driver identification info (struct pds_core_drv_identity)
 * in cmd_regs->data.  Driver should keep the devcmd interface locked
 * while preparing the driver info.
 */
struct pds_core_dev_identify_cmd {
 u8 opcode;
 u8 ver;
};

/**
 * struct pds_core_dev_identify_comp - Device identify command completion
 * @status: Status of the command (enum pds_core_status_code)
 * @ver: Version of identify returned by device
 *
 * Device identification info (struct pds_core_dev_identity) can be found
 * in cmd_regs->data.  Driver should keep the devcmd interface locked
 * while reading the results.
 */
struct pds_core_dev_identify_comp {
 u8 status;
 u8 ver;
};

/**
 * struct pds_core_dev_reset_cmd - Device reset command
 * @opcode: Opcode PDS_CORE_CMD_RESET
 *
 * Resets and clears all LIFs, VDevs, and VIFs on the device.
 */
struct pds_core_dev_reset_cmd {
 u8 opcode;
};

/**
 * struct pds_core_dev_reset_comp - Reset command completion
 * @status: Status of the command (enum pds_core_status_code)
 */
struct pds_core_dev_reset_comp {
 u8 status;
};

/*
 * struct pds_core_dev_init_data - Pointers and info needed for the Core
 * initialization PDS_CORE_CMD_INIT command.  The in and out structs are
 * overlays on the pds_core_dev_cmd_regs.data space for passing data down
 * to the firmware on init, and then returning initialization results.
 */
struct pds_core_dev_init_data_in {
 __le64 adminq_q_base;
 __le64 adminq_cq_base;
 __le64 notifyq_cq_base;
 __le32 flags;
 __le16 intr_index;
 u8     adminq_ring_size;
 u8     notifyq_ring_size;
};

struct pds_core_dev_init_data_out {
 __le32 core_hw_index;
 __le32 adminq_hw_index;
 __le32 notifyq_hw_index;
 u8     adminq_hw_type;
 u8     notifyq_hw_type;
};

/**
 * struct pds_core_dev_init_cmd - Core device initialize
 * @opcode:          opcode PDS_CORE_CMD_INIT
 *
 * Initializes the core device and sets up the AdminQ and NotifyQ.
 * Expects to find initialization data (struct pds_core_dev_init_data_in)
 * in cmd_regs->data.  Driver should keep the devcmd interface locked
 * while preparing the driver info.
 */
struct pds_core_dev_init_cmd {
 u8     opcode;
};

/**
 * struct pds_core_dev_init_comp - Core init completion
 * @status:     Status of the command (enum pds_core_status_code)
 *
 * Initialization result data (struct pds_core_dev_init_data_in)
 * is found in cmd_regs->data.
 */
struct pds_core_dev_init_comp {
 u8     status;
};

/**
 * struct pds_core_fw_download_cmd - Firmware download command
 * @opcode:     opcode
 * @rsvd: Word boundary padding
 * @addr:       DMA address of the firmware buffer
 * @offset:     offset of the firmware buffer within the full image
 * @length:     number of valid bytes in the firmware buffer
 */
struct pds_core_fw_download_cmd {
 u8     opcode;
 u8     rsvd[3];
 __le32 offset;
 __le64 addr;
 __le32 length;
};

/**
 * struct pds_core_fw_download_comp - Firmware download completion
 * @status:     Status of the command (enum pds_core_status_code)
 */
struct pds_core_fw_download_comp {
 u8     status;
};

/**
 * enum pds_core_fw_control_oper - FW control operations
 * @PDS_CORE_FW_INSTALL_ASYNC:     Install firmware asynchronously
 * @PDS_CORE_FW_INSTALL_STATUS:    Firmware installation status
 * @PDS_CORE_FW_ACTIVATE_ASYNC:    Activate firmware asynchronously
 * @PDS_CORE_FW_ACTIVATE_STATUS:   Firmware activate status
 * @PDS_CORE_FW_UPDATE_CLEANUP:    Cleanup any firmware update leftovers
 * @PDS_CORE_FW_GET_BOOT:          Return current active firmware slot
 * @PDS_CORE_FW_SET_BOOT:          Set active firmware slot for next boot
 * @PDS_CORE_FW_GET_LIST:          Return list of installed firmware images
 */
enum pds_core_fw_control_oper {
 PDS_CORE_FW_INSTALL_ASYNC          = 0,
 PDS_CORE_FW_INSTALL_STATUS         = 1,
 PDS_CORE_FW_ACTIVATE_ASYNC         = 2,
 PDS_CORE_FW_ACTIVATE_STATUS        = 3,
 PDS_CORE_FW_UPDATE_CLEANUP         = 4,
 PDS_CORE_FW_GET_BOOT               = 5,
 PDS_CORE_FW_SET_BOOT               = 6,
 PDS_CORE_FW_GET_LIST               = 7,
};

enum pds_core_fw_slot {
 PDS_CORE_FW_SLOT_INVALID    = 0,
 PDS_CORE_FW_SLOT_A     = 1,
 PDS_CORE_FW_SLOT_B          = 2,
 PDS_CORE_FW_SLOT_GOLD       = 3,
};

/**
 * struct pds_core_fw_control_cmd - Firmware control command
 * @opcode:    opcode
 * @rsvd:      Word boundary padding
 * @oper:      firmware control operation (enum pds_core_fw_control_oper)
 * @slot:      slot to operate on (enum pds_core_fw_slot)
 */
struct pds_core_fw_control_cmd {
 u8  opcode;
 u8  rsvd[3];
 u8  oper;
 u8  slot;
};

/**
 * struct pds_core_fw_control_comp - Firmware control copletion
 * @status: Status of the command (enum pds_core_status_code)
 * @rsvd: Word alignment space
 * @slot: Slot number (enum pds_core_fw_slot)
 * @rsvd1: Struct padding
 * @color: Color bit
 */
struct pds_core_fw_control_comp {
 u8     status;
 u8     rsvd[3];
 u8     slot;
 u8     rsvd1[10];
 u8     color;
};

struct pds_core_fw_name_info {
#define PDS_CORE_FWSLOT_BUFLEN  8
#define PDS_CORE_FWVERS_BUFLEN  32
 char   slotname[PDS_CORE_FWSLOT_BUFLEN];
 char   fw_version[PDS_CORE_FWVERS_BUFLEN];
};

struct pds_core_fw_list_info {
#define PDS_CORE_FWVERS_LIST_LEN 16
 u8 num_fw_slots;
 struct pds_core_fw_name_info fw_names[PDS_CORE_FWVERS_LIST_LEN];
} __packed;

enum pds_core_vf_attr {
 PDS_CORE_VF_ATTR_SPOOFCHK = 1,
 PDS_CORE_VF_ATTR_TRUST  = 2,
 PDS_CORE_VF_ATTR_MAC  = 3,
 PDS_CORE_VF_ATTR_LINKSTATE = 4,
 PDS_CORE_VF_ATTR_VLAN  = 5,
 PDS_CORE_VF_ATTR_RATE  = 6,
 PDS_CORE_VF_ATTR_STATSADDR = 7,
};

/**
 * enum pds_core_vf_link_status - Virtual Function link status
 * @PDS_CORE_VF_LINK_STATUS_AUTO:   Use link state of the uplink
 * @PDS_CORE_VF_LINK_STATUS_UP:     Link always up
 * @PDS_CORE_VF_LINK_STATUS_DOWN:   Link always down
 */
enum pds_core_vf_link_status {
 PDS_CORE_VF_LINK_STATUS_AUTO = 0,
 PDS_CORE_VF_LINK_STATUS_UP   = 1,
 PDS_CORE_VF_LINK_STATUS_DOWN = 2,
};

/**
 * struct pds_core_vf_setattr_cmd - Set VF attributes on the NIC
 * @opcode:     Opcode
 * @attr:       Attribute type (enum pds_core_vf_attr)
 * @vf_index:   VF index
 * @macaddr: mac address
 * @vlanid: vlan ID
 * @maxrate: max Tx rate in Mbps
 * @spoofchk: enable address spoof checking
 * @trust: enable VF trust
 * @linkstate: set link up or down
 * @stats: stats addr struct
 * @stats.pa: set DMA address for VF stats
 * @stats.len: length of VF stats space
 * @pad: force union to specific size
 */
struct pds_core_vf_setattr_cmd {
 u8     opcode;
 u8     attr;
 __le16 vf_index;
 union {
  u8     macaddr[6];
  __le16 vlanid;
  __le32 maxrate;
  u8     spoofchk;
  u8     trust;
  u8     linkstate;
  struct {
   __le64 pa;
   __le32 len;
  } stats;
  u8     pad[60];
 } __packed;
};

struct pds_core_vf_setattr_comp {
 u8     status;
 u8     attr;
 __le16 vf_index;
 __le16 comp_index;
 u8     rsvd[9];
 u8     color;
};

/**
 * struct pds_core_vf_getattr_cmd - Get VF attributes from the NIC
 * @opcode:     Opcode
 * @attr:       Attribute type (enum pds_core_vf_attr)
 * @vf_index:   VF index
 */
struct pds_core_vf_getattr_cmd {
 u8     opcode;
 u8     attr;
 __le16 vf_index;
};

struct pds_core_vf_getattr_comp {
 u8     status;
 u8     attr;
 __le16 vf_index;
 union {
  u8     macaddr[6];
  __le16 vlanid;
  __le32 maxrate;
  u8     spoofchk;
  u8     trust;
  u8     linkstate;
  __le64 stats_pa;
  u8     pad[11];
 } __packed;
 u8     color;
};

enum pds_core_vf_ctrl_opcode {
 PDS_CORE_VF_CTRL_START_ALL = 0,
 PDS_CORE_VF_CTRL_START  = 1,
};

/**
 * struct pds_core_vf_ctrl_cmd - VF control command
 * @opcode:         Opcode for the command
 * @ctrl_opcode:    VF control operation type
 * @vf_index:       VF Index. It is unused if op START_ALL is used.
 */

struct pds_core_vf_ctrl_cmd {
 u8 opcode;
 u8 ctrl_opcode;
 __le16 vf_index;
};

/**
 * struct pds_core_vf_ctrl_comp - VF_CTRL command completion.
 * @status:     Status of the command (enum pds_core_status_code)
 */
struct pds_core_vf_ctrl_comp {
 u8 status;
};

/*
 * union pds_core_dev_cmd - Overlay of core device command structures
 */
union pds_core_dev_cmd {
 u8     opcode;
 u32    words[16];

 struct pds_core_dev_identify_cmd identify;
 struct pds_core_dev_init_cmd     init;
 struct pds_core_dev_reset_cmd    reset;
 struct pds_core_fw_download_cmd  fw_download;
 struct pds_core_fw_control_cmd   fw_control;

 struct pds_core_vf_setattr_cmd   vf_setattr;
 struct pds_core_vf_getattr_cmd   vf_getattr;
 struct pds_core_vf_ctrl_cmd      vf_ctrl;
};

/*
 * union pds_core_dev_comp - Overlay of core device completion structures
 */
union pds_core_dev_comp {
 u8                                status;
 u8                                bytes[16];

 struct pds_core_dev_identify_comp identify;
 struct pds_core_dev_reset_comp    reset;
 struct pds_core_dev_init_comp     init;
 struct pds_core_fw_download_comp  fw_download;
 struct pds_core_fw_control_comp   fw_control;

 struct pds_core_vf_setattr_comp   vf_setattr;
 struct pds_core_vf_getattr_comp   vf_getattr;
 struct pds_core_vf_ctrl_comp      vf_ctrl;
};

/**
 * struct pds_core_dev_hwstamp_regs - Hardware current timestamp registers
 * @tick_low:        Low 32 bits of hardware timestamp
 * @tick_high:       High 32 bits of hardware timestamp
 */
struct pds_core_dev_hwstamp_regs {
 u32    tick_low;
 u32    tick_high;
};

/**
 * struct pds_core_dev_info_regs - Device info register format (read-only)
 * @signature:       Signature value of 0x44455649 ('DEVI')
 * @version:         Current version of info
 * @asic_type:       Asic type
 * @asic_rev:        Asic revision
 * @fw_status:       Firmware status
 * bit 0   - 1 = fw running
 * bit 4-7 - 4 bit generation number, changes on fw restart
 * @fw_heartbeat:    Firmware heartbeat counter
 * @serial_num:      Serial number
 * @fw_version:      Firmware version
 * @oprom_regs:      oprom_regs to store oprom debug enable/disable and bmp
 * @rsvd_pad1024:    Struct padding
 * @hwstamp:         Hardware current timestamp registers
 * @rsvd_pad2048:    Struct padding
 */
struct pds_core_dev_info_regs {
#define PDS_CORE_DEVINFO_FWVERS_BUFLEN 32
#define PDS_CORE_DEVINFO_SERIAL_BUFLEN 32
 u32    signature;
 u8     version;
 u8     asic_type;
 u8     asic_rev;
#define PDS_CORE_FW_STS_F_STOPPED 0x00
#define PDS_CORE_FW_STS_F_RUNNING 0x01
#define PDS_CORE_FW_STS_F_GENERATION 0xF0
 u8     fw_status;
 __le32 fw_heartbeat;
 char   fw_version[PDS_CORE_DEVINFO_FWVERS_BUFLEN];
 char   serial_num[PDS_CORE_DEVINFO_SERIAL_BUFLEN];
 u8     oprom_regs[32];     /* reserved */
 u8     rsvd_pad1024[916];
 struct pds_core_dev_hwstamp_regs hwstamp;   /* on 1k boundary */
 u8     rsvd_pad2048[1016];
} __packed;

/**
 * struct pds_core_dev_cmd_regs - Device command register format (read-write)
 * @doorbell: Device Cmd Doorbell, write-only
 *              Write a 1 to signal device to process cmd
 * @done: Command completed indicator, poll for completion
 *              bit 0 == 1 when command is complete
 * @cmd: Opcode-specific command bytes
 * @comp: Opcode-specific response bytes
 * @rsvd: Struct padding
 * @data: Opcode-specific side-data
 */
struct pds_core_dev_cmd_regs {
 u32                     doorbell;
 u32                     done;
 union pds_core_dev_cmd  cmd;
 union pds_core_dev_comp comp;
 u8                      rsvd[48];
 u32                     data[478];
} __packed;

/**
 * struct pds_core_dev_regs - Device register format for bar 0 page 0
 * @info:            Device info registers
 * @devcmd:          Device command registers
 */
struct pds_core_dev_regs {
 struct pds_core_dev_info_regs info;
 struct pds_core_dev_cmd_regs  devcmd;
} __packed;

#ifndef __CHECKER__
static_assert(sizeof(struct pds_core_drv_identity) <= 1912);
static_assert(sizeof(struct pds_core_dev_identity) <= 1912);
static_assert(sizeof(union pds_core_dev_cmd) == 64);
static_assert(sizeof(union pds_core_dev_comp) == 16);
static_assert(sizeof(struct pds_core_dev_info_regs) == 2048);
static_assert(sizeof(struct pds_core_dev_cmd_regs) == 2048);
static_assert(sizeof(struct pds_core_dev_regs) == 4096);
#endif /* __CHECKER__ */

#endif /* _PDS_CORE_IF_H_ */