| /* 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, | |
| PDS_CORE_CMD_GET_COMPONENT_INFO = 6, | |
| PDS_CORE_CMD_SEND_PKG_DATA = 7, | |
| PDS_CORE_CMD_SEND_COMPONENT_TBL = 8, | |
| PDS_CORE_CMD_SEND_COMPONENT = 9, | |
| PDS_CORE_CMD_FINALIZE_UPDATE = 10, | |
| PDS_CORE_CMD_MATCH_RECORD_DESC = 11, | |
| PDS_CORE_CMD_HOST_MEM = 12, | |
| /* 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]; | |
| }; | |
| /** | |
| * enum pds_core_dev_capability - Device capabilities | |
| * @PDS_CORE_DEV_CAP_PLDM_FW_UPDATE: Device only supports FW update via PLDM | |
| * @PDS_CORE_DEV_CAP_HOST_MEM: Device supports host memory for fw use | |
| */ | |
| enum pds_core_dev_capability { | |
| PDS_CORE_DEV_CAP_PLDM_FW_UPDATE = BIT(0), | |
| PDS_CORE_DEV_CAP_HOST_MEM = BIT(1), | |
| }; | |
| #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 | |
| * @max_fw_slots: Number of firmware components reported by device | |
| * only supported on version >= PDS_CORE_IDENTITY_VERSION_2 | |
| * @rsvd2: Word boundary padding | |
| * @capabilities: Device capabilities | |
| * only supported on version >= PDS_CORE_IDENTITY_VERSION_2 | |
| */ | |
| 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]; | |
| __le16 max_fw_slots; | |
| u8 rsvd2[6]; | |
| __le64 capabilities; | |
| }; | |
| #define PDS_CORE_IDENTITY_VERSION_1 1 | |
| #define PDS_CORE_IDENTITY_VERSION_2 2 | |
| /** | |
| * 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 - Firmware slot identifiers | |
| * @PDS_CORE_FW_SLOT_INVALID: Let firmware select slot based on package metadata | |
| * @PDS_CORE_FW_SLOT_A: Primary firmware slot A | |
| * @PDS_CORE_FW_SLOT_B: Primary firmware slot B | |
| * @PDS_CORE_FW_SLOT_GOLD: Gold/recovery firmware slot | |
| * @PDS_CORE_FW_SLOT_MAX: Sentinel value indicating no slot resolved | |
| */ | |
| 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, | |
| PDS_CORE_FW_SLOT_MAX = 0xff, | |
| }; | |
| /** | |
| * 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; | |
| }; | |
| /** | |
| * struct pds_core_send_pkg_data_cmd - Send package data command | |
| * @opcode: Opcode PDS_CORE_CMD_SEND_PKG_DATA | |
| * @ver: Driver's max support version of this command | |
| * @total_len: Total length of the package data | |
| * @offset: Offset in the package data, non-zero if multiple commands are | |
| * needed for sending the package data | |
| * @data_len: Length of data stored at data_pa | |
| * @data_pa: Data physical address for DMA to device | |
| * | |
| * The package data may be too large to store in a single buffer, so multiple | |
| * PDS_CORE_CMD_SEND_PKG_DATA devcmds may be needed. | |
| */ | |
| struct pds_core_send_pkg_data_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| __le16 total_len; | |
| __le16 offset; | |
| __le16 data_len; | |
| __le64 data_pa; | |
| }; | |
| /** | |
| * struct pds_core_send_pkg_data_comp - Send package data completion | |
| * @status: Status of the command (enum pds_core_status_code) | |
| * @ver: Device's max supported version of this command | |
| * @rsvd: Word boundary padding | |
| */ | |
| struct pds_core_send_pkg_data_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * struct pds_core_component_tbl - Component table details | |
| * @comparison_stamp: Comparison stamp used for component version checks | |
| * @classification: Vendor specific classification info | |
| * @identifier: Component's ID | |
| * @transfer_flag: Part of the component table this request represents | |
| * @version_str_type: The types of strings used | |
| * @version_str_len: Length of @version_str | |
| * @version_str: Component version information | |
| */ | |
| struct pds_core_component_tbl { | |
| __le32 comparison_stamp; | |
| __le16 classification; | |
| __le16 identifier; | |
| u8 transfer_flag; | |
| u8 version_str_type; | |
| u8 version_str_len; | |
| u8 version_str[]; | |
| }; | |
| /** | |
| * struct pds_core_send_component_tbl_cmd - Send component table command | |
| * @opcode: Opcode PDS_CORE_CMD_SEND_COMPONENT_TBL | |
| * @ver: Driver's max support version of this command | |
| * @slot_id: enum pds_core_fw_slot | |
| * @rsvd: Word boundary padding | |
| * | |
| * Expects to find component table info (struct pds_core_component_tbl) | |
| * in cmd_regs->data. Driver should keep the devcmd interface locked | |
| * while preparing the component table info. | |
| */ | |
| struct pds_core_send_component_tbl_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| u8 slot_id; | |
| u8 rsvd; | |
| }; | |
| enum pds_core_component_resp_code { | |
| PDS_CORE_COMPONENT_VALID = 0x0, | |
| PDS_CORE_COMPONENT_STAMP_IDENTICAL = 0x1, | |
| PDS_CORE_COMPONENT_STAMP_LOWER = 0x2, | |
| PDS_CORE_COMPONENT_STAMP_OR_VERSION_INVALID = 0x3, | |
| PDS_CORE_COMPONENT_CONFLICT = 0x4, | |
| PDS_CORE_COMPONENT_PREREQS_NOT_MET = 0x5, | |
| PDS_CORE_COMPONENT_NOT_SUPPORTED = 0x6, | |
| PDS_CORE_COMPONENT_FW_TYPE_INVALID = 0xd0, | |
| }; | |
| /** | |
| * struct pds_core_send_component_tbl_comp - Send component table completion | |
| * @status: Status of the command (enum pds_core_status_code) | |
| * @ver: Device's max supported version of this command | |
| * @completion_code: Component completion code | |
| * @response: Component response | |
| * @response_code: Component response code | |
| * @slot_id: Actual slot_id of the component (enum pds_core_fw_slot) | |
| * @rsvd: Word boundary padding | |
| */ | |
| struct pds_core_send_component_tbl_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 completion_code; | |
| u8 response; | |
| u8 response_code; | |
| u8 slot_id; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * enum pds_core_send_component_op - PDS_CORE_CMD_SEND_COMPONENT operation | |
| * @PDS_CORE_SEND_COMPONENT_START: Initial operation to start transfer | |
| * @PDS_CORE_SEND_COMPONENT_STATUS: Subsequent calls to check on status | |
| */ | |
| enum pds_core_send_component_op { | |
| PDS_CORE_SEND_COMPONENT_START = 0, | |
| PDS_CORE_SEND_COMPONENT_STATUS = 1, | |
| }; | |
| #define PDS_CORE_FW_COMPONENT_ID_INVALID 0xFFFF | |
| /** | |
| * struct pds_core_flash_component - Component details | |
| * @comparison_stamp: Comparison stamp used for component version checks | |
| * @image_size: Component image size | |
| * @classification: Vendor specific classification info | |
| * @identifier: Component's ID | |
| * @options: Component options | |
| * @rsvd: Word boundary padding | |
| * @version_str_type: The types of strings used | |
| * @version_str_len: Length of @version_str | |
| * @version_str: Component version information | |
| */ | |
| struct pds_core_flash_component { | |
| __le32 comparison_stamp; | |
| __le32 image_size; | |
| __le16 classification; | |
| __le16 identifier; | |
| __le16 options; | |
| u8 rsvd[3]; | |
| u8 version_str_type; | |
| u8 version_str_len; | |
| u8 version_str[]; | |
| }; | |
| /** | |
| * struct pds_core_send_component_cmd - Send component command | |
| * @opcode: Opcode PDS_CORE_CMD_SEND_COMPONENT | |
| * @ver: Driver's max supported version of this command | |
| * @slot_id: enum pds_core_fw_slot | |
| * @operation: enum pds_core_send_component_op | |
| * @offset: Offset into the component, non-zero if multiple commands | |
| * are needed for a single component | |
| * @data_len: Length of this part of the component stored at @data_pa | |
| * @rsvd: Word boundary padding | |
| * @data_pa: DMA address of the component | |
| * | |
| * A component may be too large to store in a single buffer, so multiple | |
| * PDS_CORE_CMD_SEND_COMPONENT devcmds may be needed. | |
| * | |
| * Expects to find flash component info (struct pds_core_flash_component) | |
| * in cmd_regs->data. Driver should keep the devcmd interface locked | |
| * while preparing and sending the flash component info. | |
| */ | |
| struct pds_core_send_component_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| u8 slot_id; | |
| u8 operation; | |
| __le32 offset; | |
| __le32 data_len; | |
| u8 rsvd[4]; | |
| __le64 data_pa; | |
| }; | |
| /** | |
| * struct pds_core_send_component_comp - Send component completion | |
| * @status: Status of the command (enum pds_core_status_code) | |
| * @ver: Device's max supported version of this command | |
| * @completion_code: Completion code | |
| * @compat_response: Compatibility response (0 = Component can be updated) | |
| * @compat_response_code: Compatibility response code | |
| * @rsvd: Word boundary padding | |
| */ | |
| struct pds_core_send_component_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 completion_code; | |
| u8 compat_response; | |
| u8 compat_response_code; | |
| u8 rsvd[3]; | |
| }; | |
| /** | |
| * enum pds_core_fw_component_type - Firmware component type | |
| * @PDS_CORE_FW_TYPE_UNKNOWN: Unknown component type | |
| * @PDS_CORE_FW_TYPE_MAIN: Main firmware | |
| * @PDS_CORE_FW_TYPE_BOOT: Boot loader | |
| * @PDS_CORE_FW_TYPE_CPLD: CPLD firmware | |
| * @PDS_CORE_FW_TYPE_SECURE: Secure firmware | |
| * @PDS_CORE_FW_TYPE_FPGA: FPGA configuration | |
| * @PDS_CORE_FW_TYPE_SUC_MAIN: System Unit Controller firmware | |
| * @PDS_CORE_FW_TYPE_SUC_BOOT: System Unit Controller bootloader | |
| * @PDS_CORE_FW_TYPE_UBOOT: U-Boot bootloader | |
| * | |
| * Gold/recovery variants are identified by slot_id == PDS_CORE_FW_SLOT_GOLD | |
| * and reported with a ".gold" suffix (e.g., fw.gold). | |
| */ | |
| enum pds_core_fw_component_type { | |
| PDS_CORE_FW_TYPE_UNKNOWN = 0, | |
| PDS_CORE_FW_TYPE_MAIN = 1, | |
| PDS_CORE_FW_TYPE_BOOT = 2, | |
| PDS_CORE_FW_TYPE_CPLD = 3, | |
| PDS_CORE_FW_TYPE_SECURE = 4, | |
| PDS_CORE_FW_TYPE_FPGA = 5, | |
| PDS_CORE_FW_TYPE_SUC_MAIN = 6, | |
| PDS_CORE_FW_TYPE_SUC_BOOT = 7, | |
| PDS_CORE_FW_TYPE_UBOOT = 8, | |
| }; | |
| /** | |
| * enum pds_core_component_info_flags - Component info flags | |
| * @PDS_CORE_FW_COMPONENT_INFO_F_RUNNING: Component is currently running | |
| * @PDS_CORE_FW_COMPONENT_INFO_F_STARTUP: Component version on next FW boot | |
| * @PDS_CORE_FW_COMPONENT_INFO_F_FIXED: Component is fixed and cannot be updated | |
| * @PDS_CORE_FW_COMPONENT_INFO_F_UPDATE_BY_NAME: Component can be updated | |
| * by name | |
| */ | |
| enum pds_core_component_info_flags { | |
| PDS_CORE_FW_COMPONENT_INFO_F_RUNNING = BIT(0), | |
| PDS_CORE_FW_COMPONENT_INFO_F_STARTUP = BIT(1), | |
| PDS_CORE_FW_COMPONENT_INFO_F_FIXED = BIT(2), | |
| PDS_CORE_FW_COMPONENT_INFO_F_UPDATE_BY_NAME = BIT(3), | |
| }; | |
| /** | |
| * struct pds_core_fw_component_info - GET_COMPONENT_INFO entry | |
| * @name: Component's name | |
| * @component_type: enum pds_core_fw_component_type | |
| * @rsvd: Word boundary padding | |
| * @flags: enum pds_core_component_info_flags | |
| * @identifier: Component's identifier | |
| * @slot_id: Component's slot identifier | |
| * @version: Component's version | |
| */ | |
| struct pds_core_fw_component_info { | |
| #define PDS_CORE_FW_COMPONENT_NAME_BUFLEN 24 | |
| char name[PDS_CORE_FW_COMPONENT_NAME_BUFLEN]; | |
| u8 component_type; | |
| u8 rsvd[3]; | |
| __le16 flags; | |
| u8 identifier; | |
| u8 slot_id; | |
| #define PDS_CORE_FW_COMPONENT_VER_BUFLEN 32 | |
| char version[PDS_CORE_FW_COMPONENT_VER_BUFLEN]; | |
| }; | |
| #define PDS_CORE_FW_COMPONENT_LIST_LEN ((PDS_PAGE_SIZE - 8) / \ | |
| sizeof(struct pds_core_fw_component_info)) | |
| /** | |
| * struct pds_core_component_list_info - GET_COMPONENT_INFO completion data | |
| * @num_components: Number of valid components | |
| * @rsvd: Word boundary padding | |
| * @info: List of valid components | |
| */ | |
| struct pds_core_component_list_info { | |
| u8 num_components; | |
| u8 rsvd[7]; | |
| struct pds_core_fw_component_info info[PDS_CORE_FW_COMPONENT_LIST_LEN]; | |
| }; | |
| /** | |
| * struct pds_core_get_component_info_cmd - GET_COMPONENT_INFO command | |
| * @opcode: PDS_CORE_CMD_GET_COMPONENT_INFO | |
| * @ver: Driver's max supported version of this command | |
| * @data_len: Length of data at data_pa | |
| * @rsvd: Word boundary padding | |
| * @data_pa: DMA address of data | |
| * | |
| * FW populates struct pds_core_component_list_info pointed to by @data_pa | |
| */ | |
| struct pds_core_get_component_info_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| __le16 data_len; | |
| u8 rsvd[4]; | |
| __le64 data_pa; | |
| }; | |
| /** | |
| * struct pds_core_get_component_info_comp - GET_COMPONENT_INFO completion | |
| * @status: enum pds_core_status_code | |
| * @ver: Device's max supported version of this command | |
| * @rsvd: Word boundary padding | |
| */ | |
| struct pds_core_get_component_info_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * struct pds_core_finalize_update_cmd - FINALIZE_UPDATE command | |
| * @opcode: PDS_CORE_CMD_FINALIZE_UPDATE | |
| * @ver: Driver's max support version of this command | |
| * @rsvd: Word boundary padding | |
| * | |
| * Driver sends at the end of updating all components to finalize the update | |
| */ | |
| struct pds_core_finalize_update_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * struct pds_core_finalize_update_comp - FINALIZE_UPDATE completion | |
| * @status: enum pds_core_status_code | |
| * @ver: Device's max supported version of this command | |
| * @rsvd: Word boundary padding | |
| */ | |
| struct pds_core_finalize_update_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * struct pds_core_match_record_desc_cmd - MATCH_RECORD_DESC command | |
| * @opcode: PDS_CORE_CMD_MATCH_RECORD_DESC | |
| * @ver: Driver's max supported version of this command | |
| * @type: PLDM Descriptor Identifier Type | |
| * @size: Length of the Descriptor Identifier Value | |
| * @rsvd: Word boundary padding | |
| * | |
| * Expects to find the Descriptor Identifier Data in cmd_regs->data. Driver | |
| * should keep the devcmd interface locked while preparing and sending this | |
| * command. | |
| */ | |
| struct pds_core_match_record_desc_cmd { | |
| u8 opcode; | |
| u8 ver; | |
| __le16 type; | |
| __le16 size; | |
| u8 rsvd[2]; | |
| }; | |
| /** | |
| * struct pds_core_match_record_desc_comp - MATCH_RECORD_DESC completion | |
| * @status: enum pds_core_status_code | |
| * @ver: Device's max supported version of this command | |
| * @match: Whether or not the Record Descriptor matches the device | |
| * @rsvd: Word boundary padding | |
| * | |
| * When status is PDS_RC_SUCCESS, then @match is valid, otherwise it's | |
| * undefined. | |
| */ | |
| struct pds_core_match_record_desc_comp { | |
| u8 status; | |
| u8 ver; | |
| u8 match; | |
| u8 rsvd; | |
| }; | |
| /** | |
| * enum pds_core_host_mem_oper - HOST_MEM sub-operations | |
| * @PDS_CORE_HOST_MEM_GET_COUNT: Query number of memory requests | |
| * @PDS_CORE_HOST_MEM_QUERY: Query details of a memory request | |
| * @PDS_CORE_HOST_MEM_ADD: Provide allocated memory to firmware | |
| * @PDS_CORE_HOST_MEM_DEL: Notify firmware of memory deallocation | |
| */ | |
| enum pds_core_host_mem_oper { | |
| PDS_CORE_HOST_MEM_GET_COUNT = 0, | |
| PDS_CORE_HOST_MEM_QUERY = 1, | |
| PDS_CORE_HOST_MEM_ADD = 2, | |
| PDS_CORE_HOST_MEM_DEL = 3, | |
| }; | |
| /** | |
| * struct pds_core_host_mem_cmd - HOST_MEM command | |
| * @opcode: Opcode PDS_CORE_CMD_HOST_MEM | |
| * @oper: Operation (enum pds_core_host_mem_oper) | |
| * @index: Memory request index (GET_COUNT: max_count, QUERY: index) | |
| * @tag: Tag for this memory request (ADD/DEL) | |
| * @reason: Reason for deletion (DEL only) | |
| * @rsvd: Reserved | |
| * @max_contig: Maximum contiguous memory size (GET_COUNT only) | |
| * @size: Size of memory in bytes (ADD only) | |
| * @buf_pa: DMA address of memory (ADD only) | |
| * | |
| * Unified command for all host memory operations. Fields are reused | |
| * across operations to minimize opcode space usage. | |
| */ | |
| struct pds_core_host_mem_cmd { | |
| u8 opcode; | |
| u8 oper; | |
| __le16 index; | |
| __le16 tag; | |
| u8 reason; | |
| u8 rsvd; | |
| __le32 max_contig; | |
| __le32 size; | |
| __le64 buf_pa; | |
| }; | |
| /** | |
| * struct pds_core_host_mem_comp - HOST_MEM completion | |
| * @status: Status of the command (enum pds_core_status_code) | |
| * @oper: Operation that was performed | |
| * @count: Number of memory requests (GET_COUNT) | |
| * @size: Size of memory request in bytes (QUERY) | |
| * @tag: Tag for this memory request (QUERY/DEL) | |
| * @rsvd: Reserved | |
| */ | |
| struct pds_core_host_mem_comp { | |
| u8 status; | |
| u8 oper; | |
| __le16 count; | |
| __le32 size; | |
| __le16 tag; | |
| u8 rsvd[6]; | |
| }; | |
| /* | |
| * 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; | |
| struct pds_core_get_component_info_cmd get_component_info; | |
| struct pds_core_send_pkg_data_cmd send_pkg_data; | |
| struct pds_core_send_component_tbl_cmd send_component_tbl; | |
| struct pds_core_send_component_cmd send_component; | |
| struct pds_core_finalize_update_cmd finalize_update; | |
| struct pds_core_match_record_desc_cmd match_record_desc; | |
| struct pds_core_host_mem_cmd host_mem; | |
| }; | |
| /* | |
| * 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_get_component_info_comp get_component_info; | |
| struct pds_core_send_pkg_data_comp send_pkg_data; | |
| struct pds_core_send_component_tbl_comp send_component_tbl; | |
| struct pds_core_send_component_comp send_component; | |
| struct pds_core_finalize_update_comp finalize_update; | |
| struct pds_core_match_record_desc_comp match_record_desc; | |
| struct pds_core_host_mem_comp host_mem; | |
| }; | |
| /** | |
| * 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_ */ |