/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
/* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */

#ifndef _MLXSW_ITEM_H
#define _MLXSW_ITEM_H

#include <linux/types.h>
#include <linux/string.h>
#include <linux/bitops.h>

struct mlxsw_item {
        unsigned short  offset;         /* bytes in container */
        short           step;           /* step in bytes for indexed items */
        unsigned short  in_step_offset; /* offset within one step */
        unsigned char   shift;          /* shift in bits */
        unsigned char   element_size;   /* size of element in bit array */
        bool            no_real_shift;
        union {
                unsigned char   bits;
                unsigned short  bytes;
        } size;
        const char      *name;
};

static inline unsigned int
__mlxsw_item_offset(const struct mlxsw_item *item, unsigned short index,
                    size_t typesize)
{
        BUG_ON(index && !item->step);
        if (item->offset % typesize != 0 ||
            item->step % typesize != 0 ||
            item->in_step_offset % typesize != 0) {
                pr_err("mlxsw: item bug (name=%s,offset=%x,step=%x,in_step_offset=%x,typesize=%zx)\n",
                       item->name, item->offset, item->step,
                       item->in_step_offset, typesize);
                BUG();
        }

        return ((item->offset + item->step * index + item->in_step_offset) /
                typesize);
}

static inline u8 __mlxsw_item_get8(const char *buf,
                                   const struct mlxsw_item *item,
                                   unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u8));
        u8 *b = (u8 *) buf;
        u8 tmp;

        tmp = b[offset];
        tmp >>= item->shift;
        tmp &= GENMASK(item->size.bits - 1, 0);
        if (item->no_real_shift)
                tmp <<= item->shift;
        return tmp;
}

static inline void __mlxsw_item_set8(char *buf, const struct mlxsw_item *item,
                                     unsigned short index, u8 val)
{
        unsigned int offset = __mlxsw_item_offset(item, index,
                                                  sizeof(u8));
        u8 *b = (u8 *) buf;
        u8 mask = GENMASK(item->size.bits - 1, 0) << item->shift;
        u8 tmp;

        if (!item->no_real_shift)
                val <<= item->shift;
        val &= mask;
        tmp = b[offset];
        tmp &= ~mask;
        tmp |= val;
        b[offset] = tmp;
}

static inline u16 __mlxsw_item_get16(const char *buf,
                                     const struct mlxsw_item *item,
                                     unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u16));
        __be16 *b = (__be16 *) buf;
        u16 tmp;

        tmp = be16_to_cpu(b[offset]);
        tmp >>= item->shift;
        tmp &= GENMASK(item->size.bits - 1, 0);
        if (item->no_real_shift)
                tmp <<= item->shift;
        return tmp;
}

static inline void __mlxsw_item_set16(char *buf, const struct mlxsw_item *item,
                                      unsigned short index, u16 val)
{
        unsigned int offset = __mlxsw_item_offset(item, index,
                                                  sizeof(u16));
        __be16 *b = (__be16 *) buf;
        u16 mask = GENMASK(item->size.bits - 1, 0) << item->shift;
        u16 tmp;

        if (!item->no_real_shift)
                val <<= item->shift;
        val &= mask;
        tmp = be16_to_cpu(b[offset]);
        tmp &= ~mask;
        tmp |= val;
        b[offset] = cpu_to_be16(tmp);
}

static inline u32 __mlxsw_item_get32(const char *buf,
                                     const struct mlxsw_item *item,
                                     unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u32));
        __be32 *b = (__be32 *) buf;
        u32 tmp;

        tmp = be32_to_cpu(b[offset]);
        tmp >>= item->shift;
        tmp &= GENMASK(item->size.bits - 1, 0);
        if (item->no_real_shift)
                tmp <<= item->shift;
        return tmp;
}

static inline void __mlxsw_item_set32(char *buf, const struct mlxsw_item *item,
                                      unsigned short index, u32 val)
{
        unsigned int offset = __mlxsw_item_offset(item, index,
                                                  sizeof(u32));
        __be32 *b = (__be32 *) buf;
        u32 mask = GENMASK(item->size.bits - 1, 0) << item->shift;
        u32 tmp;

        if (!item->no_real_shift)
                val <<= item->shift;
        val &= mask;
        tmp = be32_to_cpu(b[offset]);
        tmp &= ~mask;
        tmp |= val;
        b[offset] = cpu_to_be32(tmp);
}

static inline u64 __mlxsw_item_get64(const char *buf,
                                     const struct mlxsw_item *item,
                                     unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u64));
        __be64 *b = (__be64 *) buf;
        u64 tmp;

        tmp = be64_to_cpu(b[offset]);
        tmp >>= item->shift;
        tmp &= GENMASK_ULL(item->size.bits - 1, 0);
        if (item->no_real_shift)
                tmp <<= item->shift;
        return tmp;
}

static inline void __mlxsw_item_set64(char *buf, const struct mlxsw_item *item,
                                      unsigned short index, u64 val)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(u64));
        __be64 *b = (__be64 *) buf;
        u64 mask = GENMASK_ULL(item->size.bits - 1, 0) << item->shift;
        u64 tmp;

        if (!item->no_real_shift)
                val <<= item->shift;
        val &= mask;
        tmp = be64_to_cpu(b[offset]);
        tmp &= ~mask;
        tmp |= val;
        b[offset] = cpu_to_be64(tmp);
}

static inline void __mlxsw_item_memcpy_from(const char *buf, char *dst,
                                            const struct mlxsw_item *item,
                                            unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(char));

        memcpy(dst, &buf[offset], item->size.bytes);
}

static inline void __mlxsw_item_memcpy_to(char *buf, const char *src,
                                          const struct mlxsw_item *item,
                                          unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(char));

        memcpy(&buf[offset], src, item->size.bytes);
}

static inline char *__mlxsw_item_data(char *buf, const struct mlxsw_item *item,
                                      unsigned short index)
{
        unsigned int offset = __mlxsw_item_offset(item, index, sizeof(char));

        return &buf[offset];
}

static inline u16
__mlxsw_item_bit_array_offset(const struct mlxsw_item *item,
                              u16 index, u8 *shift)
{
        u16 max_index, be_index;
        u16 offset;             /* byte offset inside the array */
        u8 in_byte_index;

        BUG_ON(index && !item->element_size);
        if (item->offset % sizeof(u32) != 0 ||
            BITS_PER_BYTE % item->element_size != 0) {
                pr_err("mlxsw: item bug (name=%s,offset=%x,element_size=%x)\n",
                       item->name, item->offset, item->element_size);
                BUG();
        }

        max_index = (item->size.bytes << 3) / item->element_size - 1;
        if (WARN_ONCE(index > max_index,
                      "name=%s,index=%u,max_index=%u\n", item->name, index,
                      max_index))
                index = 0;
        be_index = max_index - index;
        offset = be_index * item->element_size >> 3;
        in_byte_index  = index % (BITS_PER_BYTE / item->element_size);
        *shift = in_byte_index * item->element_size;

        return item->offset + offset;
}

static inline u8 __mlxsw_item_bit_array_get(const char *buf,
                                            const struct mlxsw_item *item,
                                            u16 index)
{
        u8 shift, tmp;
        u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift);

        tmp = buf[offset];
        tmp >>= shift;
        tmp &= GENMASK(item->element_size - 1, 0);
        return tmp;
}

static inline void __mlxsw_item_bit_array_set(char *buf,
                                              const struct mlxsw_item *item,
                                              u16 index, u8 val)
{
        u8 shift, tmp;
        u16 offset = __mlxsw_item_bit_array_offset(item, index, &shift);
        u8 mask = GENMASK(item->element_size - 1, 0) << shift;

        val <<= shift;
        val &= mask;
        tmp = buf[offset];
        tmp &= ~mask;
        tmp |= val;
        buf[offset] = tmp;
}

#define __ITEM_NAME(_type, _cname, _iname)                                      \
        mlxsw_##_type##_##_cname##_##_iname##_item

/* _type: cmd_mbox, reg, etc.
 * _cname: containter name (e.g. command name, register name)
 * _iname: item name within the container
 */

#define MLXSW_ITEM8(_type, _cname, _iname, _offset, _shift, _sizebits)          \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .shift = _shift,                                                        \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u8 __maybe_unused                                                 \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf)                      \
{                                                                               \
        return __mlxsw_item_get8(buf, &__ITEM_NAME(_type, _cname, _iname), 0);  \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u8 val)                    \
{                                                                               \
        __mlxsw_item_set8(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);    \
}

#define MLXSW_ITEM8_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits,  \
                            _step, _instepoffset, _norealshift)                 \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .step = _step,                                                          \
        .in_step_offset = _instepoffset,                                        \
        .shift = _shift,                                                        \
        .no_real_shift = _norealshift,                                          \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u8 __maybe_unused                                                 \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf, unsigned short index)\
{                                                                               \
        return __mlxsw_item_get8(buf, &__ITEM_NAME(_type, _cname, _iname),      \
                                 index);                                        \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
                                          u8 val)                               \
{                                                                               \
        __mlxsw_item_set8(buf, &__ITEM_NAME(_type, _cname, _iname),             \
                          index, val);                                          \
}

#define MLXSW_ITEM16(_type, _cname, _iname, _offset, _shift, _sizebits)         \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .shift = _shift,                                                        \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u16 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf)                      \
{                                                                               \
        return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 val)                   \
{                                                                               \
        __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
}

#define MLXSW_ITEM16_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \
                             _step, _instepoffset, _norealshift)                \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .step = _step,                                                          \
        .in_step_offset = _instepoffset,                                        \
        .shift = _shift,                                                        \
        .no_real_shift = _norealshift,                                          \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u16 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf, unsigned short index)\
{                                                                               \
        return __mlxsw_item_get16(buf, &__ITEM_NAME(_type, _cname, _iname),     \
                                  index);                                       \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
                                          u16 val)                              \
{                                                                               \
        __mlxsw_item_set16(buf, &__ITEM_NAME(_type, _cname, _iname),            \
                           index, val);                                         \
}

#define MLXSW_ITEM32(_type, _cname, _iname, _offset, _shift, _sizebits)         \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .shift = _shift,                                                        \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u32 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf)                      \
{                                                                               \
        return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u32 val)                   \
{                                                                               \
        __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
}

#define LOCAL_PORT_LSB_SIZE 8
#define LOCAL_PORT_MSB_SIZE 2

#define MLXSW_ITEM32_LP(_type, _cname, _offset1, _shift1, _offset2, _shift2)    \
static struct mlxsw_item __ITEM_NAME(_type, _cname, local_port) = {             \
        .offset = _offset1,                                                     \
        .shift = _shift1,                                                       \
        .size = {.bits = LOCAL_PORT_LSB_SIZE,},                                 \
        .name = #_type "_" #_cname "_local_port",                               \
};                                                                              \
static struct mlxsw_item __ITEM_NAME(_type, _cname, lp_msb) = {                 \
        .offset = _offset2,                                                     \
        .shift = _shift2,                                                       \
        .size = {.bits = LOCAL_PORT_MSB_SIZE,},                                 \
        .name = #_type "_" #_cname "_lp_msb",                                   \
};                                                                              \
static inline u32 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_local_port_get(const char *buf)                      \
{                                                                               \
        u32 local_port, lp_msb;                                                 \
                                                                                \
        local_port = __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname,        \
                                        local_port), 0);                        \
        lp_msb = __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, lp_msb),   \
                                   0);                                          \
        return (lp_msb << LOCAL_PORT_LSB_SIZE) + local_port;                    \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_local_port_set(char *buf, u32 val)                   \
{                                                                               \
        __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, local_port), 0,     \
                           val & ((1 << LOCAL_PORT_LSB_SIZE) - 1));             \
        __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, lp_msb), 0,         \
                           val >> LOCAL_PORT_LSB_SIZE);                         \
}

#define MLXSW_ITEM32_INDEXED(_type, _cname, _iname, _offset, _shift, _sizebits, \
                             _step, _instepoffset, _norealshift)                \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .step = _step,                                                          \
        .in_step_offset = _instepoffset,                                        \
        .shift = _shift,                                                        \
        .no_real_shift = _norealshift,                                          \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u32 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf, unsigned short index)\
{                                                                               \
        return __mlxsw_item_get32(buf, &__ITEM_NAME(_type, _cname, _iname),     \
                                  index);                                       \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
                                          u32 val)                              \
{                                                                               \
        __mlxsw_item_set32(buf, &__ITEM_NAME(_type, _cname, _iname),            \
                           index, val);                                         \
}

#define MLXSW_ITEM64(_type, _cname, _iname, _offset, _shift, _sizebits)         \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .shift = _shift,                                                        \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u64 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf)                      \
{                                                                               \
        return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname), 0); \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u64 val)                   \
{                                                                               \
        __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname), 0, val);   \
}

#define MLXSW_ITEM64_INDEXED(_type, _cname, _iname, _offset, _shift,            \
                             _sizebits, _step, _instepoffset, _norealshift)     \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .step = _step,                                                          \
        .in_step_offset = _instepoffset,                                        \
        .shift = _shift,                                                        \
        .no_real_shift = _norealshift,                                          \
        .size = {.bits = _sizebits,},                                           \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u64 __maybe_unused                                                \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf, unsigned short index)\
{                                                                               \
        return __mlxsw_item_get64(buf, &__ITEM_NAME(_type, _cname, _iname),     \
                                  index);                                       \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, unsigned short index,      \
                                          u64 val)                              \
{                                                                               \
        __mlxsw_item_set64(buf, &__ITEM_NAME(_type, _cname, _iname),            \
                           index, val);                                         \
}

#define MLXSW_ITEM_BUF(_type, _cname, _iname, _offset, _sizebytes)              \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .size = {.bytes = _sizebytes,},                                         \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(const char *buf, char *dst)   \
{                                                                               \
        __mlxsw_item_memcpy_from(buf, dst,                                      \
                                 &__ITEM_NAME(_type, _cname, _iname), 0);       \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_memcpy_to(char *buf, const char *src)     \
{                                                                               \
        __mlxsw_item_memcpy_to(buf, src,                                        \
                               &__ITEM_NAME(_type, _cname, _iname), 0);         \
}                                                                               \
static inline char * __maybe_unused                                             \
mlxsw_##_type##_##_cname##_##_iname##_data(char *buf)                           \
{                                                                               \
        return __mlxsw_item_data(buf, &__ITEM_NAME(_type, _cname, _iname), 0);  \
}

#define MLXSW_ITEM_BUF_INDEXED(_type, _cname, _iname, _offset, _sizebytes,      \
                               _step, _instepoffset)                            \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .step = _step,                                                          \
        .in_step_offset = _instepoffset,                                        \
        .size = {.bytes = _sizebytes,},                                         \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_memcpy_from(const char *buf,              \
                                                  unsigned short index,         \
                                                  char *dst)                    \
{                                                                               \
        __mlxsw_item_memcpy_from(buf, dst,                                      \
                                 &__ITEM_NAME(_type, _cname, _iname), index);   \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_memcpy_to(char *buf,                      \
                                                unsigned short index,           \
                                                const char *src)                \
{                                                                               \
        __mlxsw_item_memcpy_to(buf, src,                                        \
                               &__ITEM_NAME(_type, _cname, _iname), index);     \
}                                                                               \
static inline char * __maybe_unused                                             \
mlxsw_##_type##_##_cname##_##_iname##_data(char *buf, unsigned short index)     \
{                                                                               \
        return __mlxsw_item_data(buf,                                           \
                                 &__ITEM_NAME(_type, _cname, _iname), index);   \
}

#define MLXSW_ITEM_BIT_ARRAY(_type, _cname, _iname, _offset, _sizebytes,        \
                             _element_size)                                     \
static struct mlxsw_item __ITEM_NAME(_type, _cname, _iname) = {                 \
        .offset = _offset,                                                      \
        .element_size = _element_size,                                          \
        .size = {.bytes = _sizebytes,},                                         \
        .name = #_type "_" #_cname "_" #_iname,                                 \
};                                                                              \
static inline u8 __maybe_unused                                                 \
mlxsw_##_type##_##_cname##_##_iname##_get(const char *buf, u16 index)           \
{                                                                               \
        return __mlxsw_item_bit_array_get(buf,                                  \
                                          &__ITEM_NAME(_type, _cname, _iname),  \
                                          index);                               \
}                                                                               \
static inline void __maybe_unused                                               \
mlxsw_##_type##_##_cname##_##_iname##_set(char *buf, u16 index, u8 val)         \
{                                                                               \
        return __mlxsw_item_bit_array_set(buf,                                  \
                                          &__ITEM_NAME(_type, _cname, _iname),  \
                                          index, val);                          \
}                                                                               \

#endif