/* Public domain. */

#ifndef _LINUXKPI_LINUX_IOSYS_MAP_H
#define _LINUXKPI_LINUX_IOSYS_MAP_H

#include <linux/io.h>
#include <linux/string.h>

struct iosys_map {
        union {
                void *vaddr_iomem;
                void *vaddr;
        };
        bool is_iomem;
#ifdef __OpenBSD__
        bus_space_handle_t bsh;
        bus_size_t size;
#endif
};

#define IOSYS_MAP_INIT_OFFSET(_ism_src_p, _off) ({                      \
        struct iosys_map ism_dst = *(_ism_src_p);                       \
        iosys_map_incr(&ism_dst, _off);                                 \
        ism_dst;                                                        \
})

static inline void
iosys_map_incr(struct iosys_map *ism, size_t n)
{
        if (ism->is_iomem)
                ism->vaddr_iomem += n;
        else
                ism->vaddr += n;
}

static inline void
iosys_map_memcpy_to(struct iosys_map *ism, size_t off, const void *src,
    size_t len)
{
        if (ism->is_iomem)
                memcpy_toio(ism->vaddr_iomem + off, src, len);
        else
                memcpy(ism->vaddr + off, src, len);
}

static inline bool
iosys_map_is_null(const struct iosys_map *ism)
{
        if (ism->is_iomem)
                return (ism->vaddr_iomem == NULL);
        else
                return (ism->vaddr == NULL);
}

static inline bool
iosys_map_is_set(const struct iosys_map *ism)
{
        if (ism->is_iomem)
                return (ism->vaddr_iomem != NULL);
        else
                return (ism->vaddr != NULL);
}

static inline bool
iosys_map_is_equal(const struct iosys_map *ism_a,
    const struct iosys_map *ism_b)
{
        if (ism_a->is_iomem != ism_b->is_iomem)
                return (false);

        if (ism_a->is_iomem)
                return (ism_a->vaddr_iomem == ism_b->vaddr_iomem);
        else
                return (ism_a->vaddr == ism_b->vaddr);
}

static inline void
iosys_map_clear(struct iosys_map *ism)
{
        if (ism->is_iomem) {
                ism->vaddr_iomem = NULL;
                ism->is_iomem = false;
        } else {
                ism->vaddr = NULL;
        }
}

static inline void
iosys_map_set_vaddr_iomem(struct iosys_map *ism, void *addr)
{
        ism->vaddr_iomem = addr;
        ism->is_iomem = true;
}

static inline void
iosys_map_set_vaddr(struct iosys_map *ism, void *addr)
{
        ism->vaddr = addr;
        ism->is_iomem = false;
}

static inline void
iosys_map_memset(struct iosys_map *ism, size_t off, int value, size_t len)
{
        if (ism->is_iomem)
                memset_io(ism->vaddr_iomem + off, value, len);
        else
                memset(ism->vaddr + off, value, len);
}

#ifdef __LP64__
#define _iosys_map_readq(_addr)                 readq(_addr)
#define _iosys_map_writeq(_val, _addr)          writeq(_val, _addr)
#else
#define _iosys_map_readq(_addr) ({                                      \
        uint64_t val;                                                   \
        memcpy_fromio(&val, _addr, sizeof(uint64_t));                   \
        val;                                                            \
})
#define _iosys_map_writeq(_val, _addr)                                  \
        memcpy_toio(_addr, &(_val), sizeof(uint64_t))
#endif

#define iosys_map_rd(_ism, _off, _type) ({                              \
        _type val;                                                      \
        if ((_ism)->is_iomem) {                                         \
                void *addr = (_ism)->vaddr_iomem + (_off);              \
                val = _Generic(val,                                     \
                    uint8_t : readb(addr),                              \
                    uint16_t: readw(addr),                              \
                    uint32_t: readl(addr),                              \
                    uint64_t: _iosys_map_readq(addr));                  \
        } else                                                          \
                val = READ_ONCE(*(_type *)((_ism)->vaddr + (_off)));    \
        val;                                                            \
})
#define iosys_map_wr(_ism, _off, _type, _val) ({                        \
        _type val = (_val);                                             \
        if ((_ism)->is_iomem) {                                         \
                void *addr = (_ism)->vaddr_iomem + (_off);              \
                _Generic(val,                                           \
                    uint8_t : writeb(val, addr),                        \
                    uint16_t: writew(val, addr),                        \
                    uint32_t: writel(val, addr),                        \
                    uint64_t: _iosys_map_writeq(val, addr));            \
        } else                                                          \
                WRITE_ONCE(*(_type *)((_ism)->vaddr + (_off)), val);    \
})

#define iosys_map_rd_field(_ism, _off, _type, _field) ({                \
        _type *s;                                                       \
        iosys_map_rd(_ism, (_off) + offsetof(_type, _field),            \
            __typeof(s->_field));                                       \
})
#define iosys_map_wr_field(_ism, _off, _type, _field, _val) ({          \
        _type *s;                                                       \
        iosys_map_wr(_ism, (_off) + offsetof(_type, _field),            \
            __typeof(s->_field), _val);                                 \
})

#endif