/* SPDX-License-Identifier: BSD-3-Clause */

#ifndef _VMBUS_BUF_H_
#define _VMBUS_BUF_H_

#include <stdbool.h>
#include <stdint.h>

#define __packed   __attribute__((__packed__))
#define unlikely(x)     __builtin_expect(!!(x), 0)

#define ICMSGHDRFLAG_TRANSACTION        1
#define ICMSGHDRFLAG_REQUEST            2
#define ICMSGHDRFLAG_RESPONSE           4

#define IC_VERSION_NEGOTIATION_MAX_VER_COUNT 100
#define ICMSG_HDR (sizeof(struct vmbuspipe_hdr) + sizeof(struct icmsg_hdr))
#define ICMSG_NEGOTIATE_PKT_SIZE(icframe_vercnt, icmsg_vercnt) \
        (ICMSG_HDR + sizeof(struct icmsg_negotiate) + \
         (((icframe_vercnt) + (icmsg_vercnt)) * sizeof(struct ic_version)))

/*
 * Channel packets
 */

/* Channel packet flags */
#define VMBUS_CHANPKT_TYPE_INBAND       0x0006
#define VMBUS_CHANPKT_TYPE_RXBUF        0x0007
#define VMBUS_CHANPKT_TYPE_GPA          0x0009
#define VMBUS_CHANPKT_TYPE_COMP         0x000b

#define VMBUS_CHANPKT_FLAG_NONE         0
#define VMBUS_CHANPKT_FLAG_RC           0x0001  /* report completion */

#define VMBUS_CHANPKT_SIZE_SHIFT        3
#define VMBUS_CHANPKT_SIZE_ALIGN        BIT(VMBUS_CHANPKT_SIZE_SHIFT)
#define VMBUS_CHANPKT_HLEN_MIN          \
        (sizeof(struct vmbus_chanpkt_hdr) >> VMBUS_CHANPKT_SIZE_SHIFT)

/*
 * Buffer ring
 */
struct vmbus_bufring {
        volatile uint32_t windex;
        volatile uint32_t rindex;

        /*
         * Interrupt mask {0,1}
         *
         * For TX bufring, host set this to 1, when it is processing
         * the TX bufring, so that we can safely skip the TX event
         * notification to host.
         *
         * For RX bufring, once this is set to 1 by us, host will not
         * further dispatch interrupts to us, even if there are data
         * pending on the RX bufring.  This effectively disables the
         * interrupt of the channel to which this RX bufring is attached.
         */
        volatile uint32_t imask;

        /*
         * Win8 uses some of the reserved bits to implement
         * interrupt driven flow management. On the send side
         * we can request that the receiver interrupt the sender
         * when the ring transitions from being full to being able
         * to handle a message of size "pending_send_sz".
         *
         * Add necessary state for this enhancement.
         */
        volatile uint32_t pending_send;
        uint32_t reserved1[12];

        union {
                struct {
                        uint32_t feat_pending_send_sz:1;
                };
                uint32_t value;
        } feature_bits;

        /* Pad it to rte_mem_page_size() so that data starts on page boundary */
        uint8_t reserved2[4028];

        /*
         * Ring data starts here + RingDataStartOffset
         * !!! DO NOT place any fields below this !!!
         */
        uint8_t data[];
} __packed;

struct vmbus_br {
        struct vmbus_bufring *vbr;
        uint32_t        dsize;
        uint32_t        windex; /* next available location */
};

struct vmbus_chanpkt_hdr {
        uint16_t        type;   /* VMBUS_CHANPKT_TYPE_ */
        uint16_t        hlen;   /* header len, in 8 bytes */
        uint16_t        tlen;   /* total len, in 8 bytes */
        uint16_t        flags;  /* VMBUS_CHANPKT_FLAG_ */
        uint64_t        xactid;
} __packed;

struct vmbus_chanpkt {
        struct vmbus_chanpkt_hdr hdr;
} __packed;

struct vmbuspipe_hdr {
        unsigned int flags;
        unsigned int msgsize;
} __packed;

struct ic_version {
        unsigned short major;
        unsigned short minor;
} __packed;

struct icmsg_negotiate {
        unsigned short icframe_vercnt;
        unsigned short icmsg_vercnt;
        unsigned int reserved;
        struct ic_version icversion_data[]; /* any size array */
} __packed;

struct icmsg_hdr {
        struct ic_version icverframe;
        unsigned short icmsgtype;
        struct ic_version icvermsg;
        unsigned short icmsgsize;
        unsigned int status;
        unsigned char ictransaction_id;
        unsigned char icflags;
        unsigned char reserved[2];
} __packed;

int rte_vmbus_chan_recv_raw(struct vmbus_br *rxbr, void *data, uint32_t *len);
int rte_vmbus_chan_send(struct vmbus_br *txbr, uint16_t type, void *data,
                        uint32_t dlen, uint32_t flags);
void vmbus_br_setup(struct vmbus_br *br, void *buf, unsigned int blen);
void *vmbus_uio_map(int *fd, int size);

/* Amount of space available for write */
static inline uint32_t vmbus_br_availwrite(const struct vmbus_br *br, uint32_t windex)
{
        uint32_t rindex = br->vbr->rindex;

        if (windex >= rindex)
                return br->dsize - (windex - rindex);
        else
                return rindex - windex;
}

static inline uint32_t vmbus_br_availread(const struct vmbus_br *br)
{
        return br->dsize - vmbus_br_availwrite(br, br->vbr->windex);
}

#endif  /* !_VMBUS_BUF_H_ */