/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (C) 2025 Intel Corporation */

#ifndef __LIBIE_ADMINQ_H
#define __LIBIE_ADMINQ_H

#include <linux/build_bug.h>
#include <linux/types.h>

#define LIBIE_CHECK_STRUCT_LEN(n, X)    \
        static_assert((n) == sizeof(struct X))
#define LIBIE_AQ_MAX_BUF_LEN 4096

/**
 * struct libie_aqc_generic - Generic structure used in adminq communication
 * @param0: generic parameter high 32bit
 * @param1: generic parameter lower 32bit
 * @addr_high: generic address high 32bit
 * @addr_low: generic address lower 32bit
 */
struct libie_aqc_generic {
        __le32 param0;
        __le32 param1;
        __le32 addr_high;
        __le32 addr_low;
};
LIBIE_CHECK_STRUCT_LEN(16, libie_aqc_generic);

/**
 * struct libie_aqc_get_ver -  Used in command get version (direct 0x0001)
 * @rom_ver: rom version
 * @fw_build: number coressponding to firmware build
 * @fw_branch: branch identifier of firmware version
 * @fw_major: major number of firmware version
 * @fw_minor: minor number of firmware version
 * @fw_patch: patch of firmware version
 * @api_branch: brancch identifier of API version
 * @api_major: major number of API version
 * @api_minor: minor number of API version
 * @api_patch: patch of API version
 */
struct libie_aqc_get_ver {
        __le32  rom_ver;
        __le32  fw_build;
        u8      fw_branch;
        u8      fw_major;
        u8      fw_minor;
        u8      fw_patch;
        u8      api_branch;
        u8      api_major;
        u8      api_minor;
        u8      api_patch;
};
LIBIE_CHECK_STRUCT_LEN(16, libie_aqc_get_ver);

/**
 * struct libie_aqc_driver_ver - Used in command send driver version
 *                               (indirect 0x0002)
 * @major_ver: driver major version
 * @minor_ver: driver minor version
 * @build_ver: driver build version
 * @subbuild_ver: driver subbuild version
 * @reserved: for feature use
 * @addr_high: high part of response address buff
 * @addr_low: low part of response address buff
 */
struct libie_aqc_driver_ver {
        u8      major_ver;
        u8      minor_ver;
        u8      build_ver;
        u8      subbuild_ver;
        u8      reserved[4];
        __le32  addr_high;
        __le32  addr_low;
};
LIBIE_CHECK_STRUCT_LEN(16, libie_aqc_driver_ver);

enum libie_aq_res_id {
        LIBIE_AQC_RES_ID_NVM                            = 1,
        LIBIE_AQC_RES_ID_SDP                            = 2,
        LIBIE_AQC_RES_ID_CHNG_LOCK                      = 3,
        LIBIE_AQC_RES_ID_GLBL_LOCK                      = 4,
};

enum libie_aq_res_access_type {
        LIBIE_AQC_RES_ACCESS_READ                       = 1,
        LIBIE_AQC_RES_ACCESS_WRITE                      = 2,
};

#define LIBIE_AQ_RES_NVM_READ_DFLT_TIMEOUT_MS           3000
#define LIBIE_AQ_RES_NVM_WRITE_DFLT_TIMEOUT_MS          180000
#define LIBIE_AQ_RES_CHNG_LOCK_DFLT_TIMEOUT_MS          1000
#define LIBIE_AQ_RES_GLBL_LOCK_DFLT_TIMEOUT_MS          3000

#define LIBIE_AQ_RES_GLBL_SUCCESS                       0
#define LIBIE_AQ_RES_GLBL_IN_PROG                       1
#define LIBIE_AQ_RES_GLBL_DONE                          2

/**
 * struct libie_aqc_req_res - Request resource ownership
 * @res_id: resource ID (look at enum definition above)
 * @access_type: read or write (enum definition above)
 * @timeout: Upon successful completion, FW writes this value and driver is
 * expected to release resource before timeout. This value is provided in
 * milliseconds.
 * @res_number: for SDP, this is the pin ID of the SDP
 * @status: status only used for LIBIE_AQC_RES_ID_GLBL_LOCK, for others reserved
 * @reserved: reserved for future use
 *
 * Used in commands:
 * request resource ownership (direct 0x0008)
 * request resource ownership (direct 0x0009)
 */
struct libie_aqc_req_res {
        __le16  res_id;
        __le16  access_type;

        __le32  timeout;
        __le32  res_number;
        __le16  status;
        u8      reserved[2];
};
LIBIE_CHECK_STRUCT_LEN(16, libie_aqc_req_res);

/**
 * struct libie_aqc_list_caps - Getting capabilities
 * @cmd_flags: command flags
 * @pf_index: index of PF to get caps from
 * @reserved: reserved for future use
 * @count: number of capabilities records
 * @addr_high: high part of response address buff
 * @addr_low: low part of response address buff
 *
 * Used in commands:
 * get function capabilities (indirect 0x000A)
 * get device capabilities (indirect 0x000B)
 */
struct libie_aqc_list_caps {
        u8      cmd_flags;
        u8      pf_index;
        u8      reserved[2];
        __le32  count;
        __le32  addr_high;
        __le32  addr_low;
};
LIBIE_CHECK_STRUCT_LEN(16, libie_aqc_list_caps);

/* Device/Function buffer entry, repeated per reported capability */
#define LIBIE_AQC_CAPS_SWITCH_MODE                      0x0001
#define LIBIE_AQC_CAPS_MNG_MODE                         0x0002
#define LIBIE_AQC_CAPS_NPAR_ACTIVE                      0x0003
#define LIBIE_AQC_CAPS_OS2BMC_CAP                       0x0004
#define LIBIE_AQC_CAPS_VALID_FUNCTIONS                  0x0005
#define LIBIE_AQC_MAX_VALID_FUNCTIONS                   0x8
#define LIBIE_AQC_CAPS_SRIOV                            0x0012
#define LIBIE_AQC_CAPS_VF                               0x0013
#define LIBIE_AQC_CAPS_VMDQ                             0x0014
#define LIBIE_AQC_CAPS_8021QBG                          0x0015
#define LIBIE_AQC_CAPS_8021QBR                          0x0016
#define LIBIE_AQC_CAPS_VSI                              0x0017
#define LIBIE_AQC_CAPS_DCB                              0x0018
#define LIBIE_AQC_CAPS_FCOE                             0x0021
#define LIBIE_AQC_CAPS_ISCSI                            0x0022
#define LIBIE_AQC_CAPS_RSS                              0x0040
#define LIBIE_AQC_CAPS_RXQS                             0x0041
#define LIBIE_AQC_CAPS_TXQS                             0x0042
#define LIBIE_AQC_CAPS_MSIX                             0x0043
#define LIBIE_AQC_CAPS_VF_MSIX                          0x0044
#define LIBIE_AQC_CAPS_FD                               0x0045
#define LIBIE_AQC_CAPS_1588                             0x0046
#define LIBIE_AQC_CAPS_MAX_MTU                          0x0047
#define LIBIE_AQC_CAPS_NVM_VER                          0x0048
#define LIBIE_AQC_CAPS_PENDING_NVM_VER                  0x0049
#define LIBIE_AQC_CAPS_OROM_VER                         0x004A
#define LIBIE_AQC_CAPS_PENDING_OROM_VER                 0x004B
#define LIBIE_AQC_CAPS_NET_VER                          0x004C
#define LIBIE_AQC_CAPS_PENDING_NET_VER                  0x004D
#define LIBIE_AQC_CAPS_RDMA                             0x0051
#define LIBIE_AQC_CAPS_LED                              0x0061
#define LIBIE_AQC_CAPS_SDP                              0x0062
#define LIBIE_AQC_CAPS_MDIO                             0x0063
#define LIBIE_AQC_CAPS_WSR_PROT                         0x0064
#define LIBIE_AQC_CAPS_SENSOR_READING                   0x0067
#define LIBIE_AQC_INLINE_IPSEC                          0x0070
#define LIBIE_AQC_CAPS_NUM_ENABLED_PORTS                0x0072
#define LIBIE_AQC_CAPS_PCIE_RESET_AVOIDANCE             0x0076
#define LIBIE_AQC_CAPS_POST_UPDATE_RESET_RESTRICT       0x0077
#define LIBIE_AQC_CAPS_NVM_MGMT                         0x0080
#define LIBIE_AQC_CAPS_EXT_TOPO_DEV_IMG0                0x0081
#define LIBIE_AQC_CAPS_EXT_TOPO_DEV_IMG1                0x0082
#define LIBIE_AQC_CAPS_EXT_TOPO_DEV_IMG2                0x0083
#define LIBIE_AQC_CAPS_EXT_TOPO_DEV_IMG3                0x0084
#define LIBIE_AQC_CAPS_TX_SCHED_TOPO_COMP_MODE          0x0085
#define LIBIE_AQC_CAPS_NAC_TOPOLOGY                     0x0087
#define LIBIE_AQC_CAPS_FW_LAG_SUPPORT                   0x0092
#define LIBIE_AQC_BIT_ROCEV2_LAG                        BIT(0)
#define LIBIE_AQC_BIT_SRIOV_LAG                         BIT(1)
#define LIBIE_AQC_BIT_SRIOV_AA_LAG                      BIT(2)
#define LIBIE_AQC_CAPS_FLEX10                           0x00F1
#define LIBIE_AQC_CAPS_CEM                              0x00F2

/**
 * struct libie_aqc_list_caps_elem - Getting list of caps elements
 * @cap: one from the defines list above
 * @major_ver: major version
 * @minor_ver: minor version
 * @number: number of resources described by this capability
 * @logical_id: logical ID, only meaningful for some types of resources
 * @phys_id: physical ID, only meaningful for some types of resources
 * @rsvd1: reserved for future use
 * @rsvd2: reserved for future use
 */
struct libie_aqc_list_caps_elem {
        __le16  cap;

        u8      major_ver;
        u8      minor_ver;
        __le32  number;
        __le32  logical_id;
        __le32  phys_id;
        __le64  rsvd1;
        __le64  rsvd2;
};
LIBIE_CHECK_STRUCT_LEN(32, libie_aqc_list_caps_elem);

/* Admin Queue command opcodes */
enum libie_adminq_opc {
        /* FW Logging Commands */
        libie_aqc_opc_fw_logs_config                    = 0xFF30,
        libie_aqc_opc_fw_logs_register                  = 0xFF31,
        libie_aqc_opc_fw_logs_query                     = 0xFF32,
        libie_aqc_opc_fw_logs_event                     = 0xFF33,
};

enum libie_aqc_fw_logging_mod {
        LIBIE_AQC_FW_LOG_ID_GENERAL = 0,
        LIBIE_AQC_FW_LOG_ID_CTRL,
        LIBIE_AQC_FW_LOG_ID_LINK,
        LIBIE_AQC_FW_LOG_ID_LINK_TOPO,
        LIBIE_AQC_FW_LOG_ID_DNL,
        LIBIE_AQC_FW_LOG_ID_I2C,
        LIBIE_AQC_FW_LOG_ID_SDP,
        LIBIE_AQC_FW_LOG_ID_MDIO,
        LIBIE_AQC_FW_LOG_ID_ADMINQ,
        LIBIE_AQC_FW_LOG_ID_HDMA,
        LIBIE_AQC_FW_LOG_ID_LLDP,
        LIBIE_AQC_FW_LOG_ID_DCBX,
        LIBIE_AQC_FW_LOG_ID_DCB,
        LIBIE_AQC_FW_LOG_ID_XLR,
        LIBIE_AQC_FW_LOG_ID_NVM,
        LIBIE_AQC_FW_LOG_ID_AUTH,
        LIBIE_AQC_FW_LOG_ID_VPD,
        LIBIE_AQC_FW_LOG_ID_IOSF,
        LIBIE_AQC_FW_LOG_ID_PARSER,
        LIBIE_AQC_FW_LOG_ID_SW,
        LIBIE_AQC_FW_LOG_ID_SCHEDULER,
        LIBIE_AQC_FW_LOG_ID_TXQ,
        LIBIE_AQC_FW_LOG_ID_RSVD,
        LIBIE_AQC_FW_LOG_ID_POST,
        LIBIE_AQC_FW_LOG_ID_WATCHDOG,
        LIBIE_AQC_FW_LOG_ID_TASK_DISPATCH,
        LIBIE_AQC_FW_LOG_ID_MNG,
        LIBIE_AQC_FW_LOG_ID_SYNCE,
        LIBIE_AQC_FW_LOG_ID_HEALTH,
        LIBIE_AQC_FW_LOG_ID_TSDRV,
        LIBIE_AQC_FW_LOG_ID_PFREG,
        LIBIE_AQC_FW_LOG_ID_MDLVER,
        LIBIE_AQC_FW_LOG_ID_MAX
};

/* Set FW Logging configuration (indirect 0xFF30)
 * Register for FW Logging (indirect 0xFF31)
 * Query FW Logging (indirect 0xFF32)
 * FW Log Event (indirect 0xFF33)
 */
#define LIBIE_AQC_FW_LOG_CONF_UART_EN           BIT(0)
#define LIBIE_AQC_FW_LOG_CONF_AQ_EN             BIT(1)
#define LIBIE_AQC_FW_LOG_QUERY_REGISTERED       BIT(2)
#define LIBIE_AQC_FW_LOG_CONF_SET_VALID         BIT(3)
#define LIBIE_AQC_FW_LOG_AQ_REGISTER            BIT(0)
#define LIBIE_AQC_FW_LOG_AQ_QUERY               BIT(2)

#define LIBIE_AQC_FW_LOG_MIN_RESOLUTION         1
#define LIBIE_AQC_FW_LOG_MAX_RESOLUTION         128

struct libie_aqc_fw_log {
        u8 cmd_flags;

        u8 rsp_flag;
        __le16 fw_rt_msb;
        union {
                struct {
                        __le32 fw_rt_lsb;
                } sync;
                struct {
                        __le16 log_resolution;
                        __le16 mdl_cnt;
                } cfg;
        } ops;
        __le32 addr_high;
        __le32 addr_low;
};

/* Response Buffer for:
 *    Set Firmware Logging Configuration (0xFF30)
 *    Query FW Logging (0xFF32)
 */
struct libie_aqc_fw_log_cfg_resp {
        __le16 module_identifier;
        u8 log_level;
        u8 rsvd0;
};

/**
 * struct libie_aq_desc - Admin Queue (AQ) descriptor
 * @flags: LIBIE_AQ_FLAG_* flags
 * @opcode: AQ command opcode
 * @datalen: length in bytes of indirect/external data buffer
 * @retval: return value from firmware
 * @cookie_high: opaque data high-half
 * @cookie_low: opaque data low-half
 * @params: command-specific parameters
 *
 * Descriptor format for commands the driver posts on the Admin Transmit Queue
 * (ATQ). The firmware writes back onto the command descriptor and returns
 * the result of the command. Asynchronous events that are not an immediate
 * result of the command are written to the Admin Receive Queue (ARQ) using
 * the same descriptor format. Descriptors are in little-endian notation with
 * 32-bit words.
 */
struct libie_aq_desc {
        __le16  flags;
        __le16  opcode;
        __le16  datalen;
        __le16  retval;
        __le32  cookie_high;
        __le32  cookie_low;
        union {
                u8      raw[16];
                struct  libie_aqc_generic generic;
                struct  libie_aqc_get_ver get_ver;
                struct  libie_aqc_driver_ver driver_ver;
                struct  libie_aqc_req_res res_owner;
                struct  libie_aqc_list_caps get_cap;
                struct  libie_aqc_fw_log fw_log;
        } params;
};
LIBIE_CHECK_STRUCT_LEN(32, libie_aq_desc);

/* FW defined boundary for a large buffer, 4k >= Large buffer > 512 bytes */
#define LIBIE_AQ_LG_BUF                         512

/* Flags sub-structure
 * |0  |1  |2  |3  |4  |5  |6  |7  |8  |9  |10 |11 |12 |13 |14 |15 |
 * |DD |CMP|ERR|VFE| * *  RESERVED * * |LB |RD |VFC|BUF|SI |EI |FE |
 */
#define LIBIE_AQ_FLAG_DD                        BIT(0)  /* 0x1    */
#define LIBIE_AQ_FLAG_CMP                       BIT(1)  /* 0x2    */
#define LIBIE_AQ_FLAG_ERR                       BIT(2)  /* 0x4    */
#define LIBIE_AQ_FLAG_VFE                       BIT(3)  /* 0x8    */
#define LIBIE_AQ_FLAG_LB                        BIT(9)  /* 0x200  */
#define LIBIE_AQ_FLAG_RD                        BIT(10) /* 0x400  */
#define LIBIE_AQ_FLAG_VFC                       BIT(11) /* 0x800  */
#define LIBIE_AQ_FLAG_BUF                       BIT(12) /* 0x1000 */
#define LIBIE_AQ_FLAG_SI                        BIT(13) /* 0x2000 */
#define LIBIE_AQ_FLAG_EI                        BIT(14) /* 0x4000 */
#define LIBIE_AQ_FLAG_FE                        BIT(15) /* 0x8000 */

/* error codes */
enum libie_aq_err {
        LIBIE_AQ_RC_OK          = 0,  /* Success */
        LIBIE_AQ_RC_EPERM       = 1,  /* Operation not permitted */
        LIBIE_AQ_RC_ENOENT      = 2,  /* No such element */
        LIBIE_AQ_RC_ESRCH       = 3,  /* Bad opcode */
        LIBIE_AQ_RC_EIO         = 5,  /* I/O error */
        LIBIE_AQ_RC_EAGAIN      = 8,  /* Try again */
        LIBIE_AQ_RC_ENOMEM      = 9,  /* Out of memory */
        LIBIE_AQ_RC_EACCES      = 10, /* Permission denied */
        LIBIE_AQ_RC_EBUSY       = 12, /* Device or resource busy */
        LIBIE_AQ_RC_EEXIST      = 13, /* Object already exists */
        LIBIE_AQ_RC_EINVAL      = 14, /* Invalid argument */
        LIBIE_AQ_RC_ENOSPC      = 16, /* No space left or allocation failure */
        LIBIE_AQ_RC_ENOSYS      = 17, /* Function not implemented */
        LIBIE_AQ_RC_EMODE       = 21, /* Op not allowed in current dev mode */
        LIBIE_AQ_RC_ENOSEC      = 24, /* Missing security manifest */
        LIBIE_AQ_RC_EBADSIG     = 25, /* Bad RSA signature */
        LIBIE_AQ_RC_ESVN        = 26, /* SVN number prohibits this package */
        LIBIE_AQ_RC_EBADMAN     = 27, /* Manifest hash mismatch */
        LIBIE_AQ_RC_EBADBUF     = 28, /* Buffer hash mismatches manifest */
};

static inline void *libie_aq_raw(struct libie_aq_desc *desc)
{
        return &desc->params.raw;
}

const char *libie_aq_str(enum libie_aq_err err);

#endif /* __LIBIE_ADMINQ_H */