/* SPDX-License-Identifier: GPL-2.0 */
// Copyright (c) 2025 Broadcom.

#ifndef __BNG_FW_H__
#define __BNG_FW_H__

#include "bng_tlv.h"

/* FW DB related */
#define BNG_FW_CMDQ_TRIG_VAL            1
#define BNG_FW_COMM_PCI_BAR_REGION      0
#define BNG_FW_COMM_CONS_PCI_BAR_REGION 2
#define BNG_FW_DBR_BASE_PAGE_SHIFT      12
#define BNG_FW_COMM_SIZE                0x104
#define BNG_FW_COMM_BASE_OFFSET         0x600
#define BNG_FW_COMM_TRIG_OFFSET         0x100
#define BNG_FW_PF_VF_COMM_PROD_OFFSET   0xc
#define BNG_FW_CREQ_DB_LEN              8

/* CREQ */
#define BNG_FW_CREQE_MAX_CNT            (64 * 1024)
#define BNG_FW_CREQE_UNITS              16
#define BNG_FW_CREQ_ENTRY_POLL_BUDGET   0x100
#define BNG_FW_CREQ_CMP_VALID(hdr, pass)                        \
        (!!((hdr)->v & CREQ_BASE_V) ==                          \
           !((pass) & BNG_RE_FLAG_EPOCH_CONS_MASK))
#define BNG_FW_CREQ_ENTRY_POLL_BUDGET   0x100

/* CMDQ */
struct bng_fw_cmdqe {
        u8      data[16];
};

#define BNG_FW_CMDQE_MAX_CNT            8192
#define BNG_FW_CMDQE_UNITS              sizeof(struct bng_fw_cmdqe)
#define BNG_FW_CMDQE_BYTES(depth)       ((depth) * BNG_FW_CMDQE_UNITS)

#define BNG_FW_MAX_COOKIE_VALUE         (BNG_FW_CMDQE_MAX_CNT - 1)
#define BNG_FW_CMD_IS_BLOCKING          0x8000

/* Crsq buf is 1024-Byte */
struct bng_re_crsbe {
        u8                      data[1024];
};


static inline u32 bng_fw_cmdqe_npages(u32 depth)
{
        u32 npages;

        npages = BNG_FW_CMDQE_BYTES(depth) / PAGE_SIZE;
        if (BNG_FW_CMDQE_BYTES(depth) % PAGE_SIZE)
                npages++;
        return npages;
}

static inline u32 bng_fw_cmdqe_page_size(u32 depth)
{
        return (bng_fw_cmdqe_npages(depth) * PAGE_SIZE);
}
struct bng_re_cmdq_mbox {
        struct bng_re_reg_desc          reg;
        void __iomem                    *prod;
        void __iomem                    *db;
};

/* HWQ */
struct bng_re_cmdq_ctx {
        struct bng_re_hwq               hwq;
        struct bng_re_cmdq_mbox         cmdq_mbox;
        unsigned long                   flags;
#define FIRMWARE_INITIALIZED_FLAG       (0)
#define FIRMWARE_STALL_DETECTED         (3)
#define FIRMWARE_FIRST_FLAG             (31)
        wait_queue_head_t               waitq;
        u32                             seq_num;
};

struct bng_re_creq_db {
        struct bng_re_reg_desc  reg;
        struct bng_re_db_info   dbinfo;
};

struct bng_re_creq_stat {
        u64     creq_qp_event_processed;
        u64     creq_func_event_processed;
};

struct bng_re_creq_ctx {
        struct bng_re_hwq               hwq;
        struct bng_re_creq_db           creq_db;
        struct bng_re_creq_stat         stats;
        struct tasklet_struct           creq_tasklet;
        u16                             ring_id;
        int                             msix_vec;
        bool                            irq_handler_avail;
        char                            *irq_name;
};

struct bng_re_crsqe {
        struct creq_qp_event    *resp;
        u32                     req_size;
        /* Free slots at the time of submission */
        u32                     free_slots;
        u8                      opcode;
        bool                    is_waiter_alive;
        bool                    is_in_used;
};

struct bng_re_rcfw_sbuf {
        void *sb;
        dma_addr_t dma_addr;
        u32 size;
};

/* RoCE FW Communication Channels */
struct bng_re_rcfw {
        struct pci_dev          *pdev;
        struct bng_re_res       *res;
        struct bng_re_cmdq_ctx  cmdq;
        struct bng_re_creq_ctx  creq;
        struct bng_re_crsqe     *crsqe_tbl;
        /* To synchronize the qp-handle hash table */
        spinlock_t              tbl_lock;
        u32                     cmdq_depth;
        /* cached from chip cctx for quick reference in slow path */
        u16                     max_timeout;
        atomic_t                rcfw_intr_enabled;
};

struct bng_re_cmdqmsg {
        struct cmdq_base        *req;
        struct creq_base        *resp;
        void                    *sb;
        u32                     req_sz;
        u32                     res_sz;
        u8                      block;
};

static inline void bng_re_rcfw_cmd_prep(struct cmdq_base *req,
                                        u8 opcode, u8 cmd_size)
{
        req->opcode = opcode;
        req->cmd_size = cmd_size;
}

static inline void bng_re_fill_cmdqmsg(struct bng_re_cmdqmsg *msg,
                                       void *req, void *resp, void *sb,
                                       u32 req_sz, u32 res_sz, u8 block)
{
        msg->req = req;
        msg->resp = resp;
        msg->sb = sb;
        msg->req_sz = req_sz;
        msg->res_sz = res_sz;
        msg->block = block;
}

/* Get the number of command units required for the req. The
 * function returns correct value only if called before
 * setting using bng_re_set_cmd_slots
 */
static inline u32 bng_re_get_cmd_slots(struct cmdq_base *req)
{
        u32 cmd_units = 0;

        if (HAS_TLV_HEADER(req)) {
                struct roce_tlv *tlv_req = (struct roce_tlv *)req;

                cmd_units = tlv_req->total_size;
        } else {
                cmd_units = (req->cmd_size + BNG_FW_CMDQE_UNITS - 1) /
                            BNG_FW_CMDQE_UNITS;
        }

        return cmd_units;
}

static inline u32 bng_re_set_cmd_slots(struct cmdq_base *req)
{
        u32 cmd_byte = 0;

        if (HAS_TLV_HEADER(req)) {
                struct roce_tlv *tlv_req = (struct roce_tlv *)req;

                cmd_byte = tlv_req->total_size * BNG_FW_CMDQE_UNITS;
        } else {
                cmd_byte = req->cmd_size;
                req->cmd_size = (req->cmd_size + BNG_FW_CMDQE_UNITS - 1) /
                                 BNG_FW_CMDQE_UNITS;
        }

        return cmd_byte;
}

void bng_re_free_rcfw_channel(struct bng_re_rcfw *rcfw);
int bng_re_alloc_fw_channel(struct bng_re_res *res,
                            struct bng_re_rcfw *rcfw);
int bng_re_enable_fw_channel(struct bng_re_rcfw *rcfw,
                             int msix_vector,
                             int cp_bar_reg_off);
void bng_re_disable_rcfw_channel(struct bng_re_rcfw *rcfw);
int bng_re_rcfw_start_irq(struct bng_re_rcfw *rcfw, int msix_vector,
                          bool need_init);
void bng_re_rcfw_stop_irq(struct bng_re_rcfw *rcfw, bool kill);
int bng_re_rcfw_send_message(struct bng_re_rcfw *rcfw,
                             struct bng_re_cmdqmsg *msg);
int bng_re_init_rcfw(struct bng_re_rcfw *rcfw,
                     struct bng_re_stats *stats_ctx);
int bng_re_deinit_rcfw(struct bng_re_rcfw *rcfw);
#endif