/* SPDX-License-Identifier: GPL-2.0 */
#ifndef S390_ISM_H
#define S390_ISM_H

#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/dibs.h>
#include <asm/pci_insn.h>

#define UTIL_STR_LEN    16
#define ISM_ERROR       0xFFFF

#define ISM_NR_DMBS     1920

/*
 * Do not use the first word of the DMB bits to ensure 8 byte aligned access.
 */
#define ISM_DMB_WORD_OFFSET     1
#define ISM_DMB_BIT_OFFSET      (ISM_DMB_WORD_OFFSET * 32)

#define ISM_REG_SBA     0x1
#define ISM_REG_IEQ     0x2
#define ISM_READ_GID    0x3
#define ISM_ADD_VLAN_ID 0x4
#define ISM_DEL_VLAN_ID 0x5
#define ISM_SET_VLAN    0x6
#define ISM_RESET_VLAN  0x7
#define ISM_QUERY_INFO  0x8
#define ISM_QUERY_RGID  0x9
#define ISM_REG_DMB     0xA
#define ISM_UNREG_DMB   0xB
#define ISM_SIGNAL_IEQ  0xE
#define ISM_UNREG_SBA   0x11
#define ISM_UNREG_IEQ   0x12

enum ism_event_type {
        ISM_EVENT_BUF = 0x00,
        ISM_EVENT_DEV = 0x01,
        ISM_EVENT_SWR = 0x02
};

enum ism_event_code {
        ISM_BUF_DMB_UNREGISTERED = 0x04,
        ISM_BUF_USING_ISM_DEV_DISABLED = 0x08,
        ISM_BUF_OWNING_ISM_DEV_IN_ERR_STATE = 0x02,
        ISM_BUF_USING_ISM_DEV_IN_ERR_STATE = 0x03,
        ISM_BUF_VLAN_MISMATCH_WITH_OWNER = 0x05,
        ISM_BUF_VLAN_MISMATCH_WITH_USER = 0x06,
        ISM_DEV_GID_DISABLED = 0x07,
        ISM_DEV_GID_ERR_STATE = 0x01
};

struct ism_req_hdr {
        u32 cmd;
        u16 : 16;
        u16 len;
};

struct ism_resp_hdr {
        u32 cmd;
        u16 ret;
        u16 len;
};

union ism_reg_sba {
        struct {
                struct ism_req_hdr hdr;
                u64 sba;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(16);

union ism_reg_ieq {
        struct {
                struct ism_req_hdr hdr;
                u64 ieq;
                u64 len;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(16);

/* ISM-vPCI devices provide 64 Bit GIDs
 * Map them to ISM UUID GIDs like this:
 *  _________________________________________
 * | 64 Bit ISM-vPCI GID | 00000000_00000000 |
 *  -----------------------------------------
 * This will be interpreted as a UIID variant, that is reserved
 * for NCS backward compatibility. So it will not collide with
 * proper UUIDs.
 */
union ism_read_gid {
        struct {
                struct ism_req_hdr hdr;
        } request;
        struct {
                struct ism_resp_hdr hdr;
                u64 gid;
        } response;
} __aligned(16);

union ism_qi {
        struct {
                struct ism_req_hdr hdr;
        } request;
        struct {
                struct ism_resp_hdr hdr;
                u32 version;
                u32 max_len;
                u64 ism_state;
                u64 my_gid;
                u64 sba;
                u64 ieq;
                u32 ieq_len;
                u32 : 32;
                u32 dmbs_owned;
                u32 dmbs_used;
                u32 vlan_required;
                u32 vlan_nr_ids;
                u16 vlan_id[64];
        } response;
} __aligned(64);

union ism_query_rgid {
        struct {
                struct ism_req_hdr hdr;
                u64 rgid;
                u32 vlan_valid;
                u32 vlan_id;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(16);

union ism_reg_dmb {
        struct {
                struct ism_req_hdr hdr;
                u64 dmb;
                u32 dmb_len;
                u32 sba_idx;
                u32 vlan_valid;
                u32 vlan_id;
                u64 rgid;
        } request;
        struct {
                struct ism_resp_hdr hdr;
                u64 dmb_tok;
        } response;
} __aligned(32);

union ism_sig_ieq {
        struct {
                struct ism_req_hdr hdr;
                u64 rgid;
                u32 trigger_irq;
                u32 event_code;
                u64 info;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(32);

union ism_unreg_dmb {
        struct {
                struct ism_req_hdr hdr;
                u64 dmb_tok;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(16);

union ism_cmd_simple {
        struct {
                struct ism_req_hdr hdr;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(8);

union ism_set_vlan_id {
        struct {
                struct ism_req_hdr hdr;
                u64 vlan_id;
        } request;
        struct {
                struct ism_resp_hdr hdr;
        } response;
} __aligned(16);

struct ism_eq_header {
        u64 idx;
        u64 ieq_len;
        u64 entry_len;
        u64 : 64;
};

struct ism_event {
        u32 type;
        u32 code;
        u64 tok;
        u64 time;
        u64 info;
};

struct ism_eq {
        struct ism_eq_header header;
        struct ism_event entry[15];
};

struct ism_sba {
        u32 s : 1;      /* summary bit */
        u32 e : 1;      /* event bit */
        u32 : 30;
        u32 dmb_bits[ISM_NR_DMBS / 32];
        u32 reserved[3];
        u16 dmbe_mask[ISM_NR_DMBS];
};

struct ism_dev {
        spinlock_t cmd_lock; /* serializes cmds */
        struct dibs_dev *dibs;
        struct pci_dev *pdev;
        struct ism_sba *sba;
        dma_addr_t sba_dma_addr;
        DECLARE_BITMAP(sba_bitmap, ISM_NR_DMBS);

        struct ism_eq *ieq;
        dma_addr_t ieq_dma_addr;
        int ieq_idx;
};

#define ISM_CREATE_REQ(dmb, idx, sf, offset)            \
        ((dmb) | (idx) << 24 | (sf) << 23 | (offset))

static inline void __ism_read_cmd(struct ism_dev *ism, void *data,
                                  unsigned long offset, unsigned long len)
{
        struct zpci_dev *zdev = to_zpci(ism->pdev);
        u64 req = ZPCI_CREATE_REQ(zdev->fh, 2, 8);

        while (len > 0) {
                __zpci_load(data, req, offset);
                offset += 8;
                data += 8;
                len -= 8;
        }
}

static inline void __ism_write_cmd(struct ism_dev *ism, void *data,
                                   unsigned long offset, unsigned long len)
{
        struct zpci_dev *zdev = to_zpci(ism->pdev);
        u64 req = ZPCI_CREATE_REQ(zdev->fh, 2, len);

        if (len)
                __zpci_store_block(data, req, offset);
}

static inline int __ism_move(struct ism_dev *ism, u64 dmb_req, void *data,
                             unsigned int size)
{
        struct zpci_dev *zdev = to_zpci(ism->pdev);
        u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, size);

        return __zpci_store_block(data, req, dmb_req);
}

#endif /* S390_ISM_H */