// SPDX-License-Identifier: GPL-2.0+
/* Microchip VCAP API
 *
 * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
 */

#include <linux/types.h>

#include "vcap_api_private.h"

static int keyfield_size_table[] = {
        [VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_key),
        [VCAP_FIELD_U32]  = sizeof(struct vcap_u32_key),
        [VCAP_FIELD_U48]  = sizeof(struct vcap_u48_key),
        [VCAP_FIELD_U56]  = sizeof(struct vcap_u56_key),
        [VCAP_FIELD_U64]  = sizeof(struct vcap_u64_key),
        [VCAP_FIELD_U72]  = sizeof(struct vcap_u72_key),
        [VCAP_FIELD_U112] = sizeof(struct vcap_u112_key),
        [VCAP_FIELD_U128] = sizeof(struct vcap_u128_key),
};

static int actionfield_size_table[] = {
        [VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_action),
        [VCAP_FIELD_U32]  = sizeof(struct vcap_u32_action),
        [VCAP_FIELD_U48]  = sizeof(struct vcap_u48_action),
        [VCAP_FIELD_U56]  = sizeof(struct vcap_u56_action),
        [VCAP_FIELD_U64]  = sizeof(struct vcap_u64_action),
        [VCAP_FIELD_U72]  = sizeof(struct vcap_u72_action),
        [VCAP_FIELD_U112] = sizeof(struct vcap_u112_action),
        [VCAP_FIELD_U128] = sizeof(struct vcap_u128_action),
};

/* Moving a rule in the VCAP address space */
struct vcap_rule_move {
        int addr; /* address to move */
        int offset; /* change in address */
        int count; /* blocksize of addresses to move */
};

/* Stores the filter cookie and chain id that enabled the port */
struct vcap_enabled_port {
        struct list_head list; /* for insertion in enabled ports list */
        struct net_device *ndev;  /* the enabled port */
        unsigned long cookie; /* filter that enabled the port */
        int src_cid; /* source chain id */
        int dst_cid; /* destination chain id */
};

void vcap_iter_set(struct vcap_stream_iter *itr, int sw_width,
                   const struct vcap_typegroup *tg, u32 offset)
{
        memset(itr, 0, sizeof(*itr));
        itr->offset = offset;
        itr->sw_width = sw_width;
        itr->regs_per_sw = DIV_ROUND_UP(sw_width, 32);
        itr->tg = tg;
}

static void vcap_iter_skip_tg(struct vcap_stream_iter *itr)
{
        /* Compensate the field offset for preceding typegroups.
         * A typegroup table ends with an all-zero terminator.
         */
        while (itr->tg->width && itr->offset >= itr->tg->offset) {
                itr->offset += itr->tg->width;
                itr->tg++; /* next typegroup */
        }
}

void vcap_iter_update(struct vcap_stream_iter *itr)
{
        int sw_idx, sw_bitpos;

        /* Calculate the subword index and bitposition for current bit */
        sw_idx = itr->offset / itr->sw_width;
        sw_bitpos = itr->offset % itr->sw_width;
        /* Calculate the register index and bitposition for current bit */
        itr->reg_idx = (sw_idx * itr->regs_per_sw) + (sw_bitpos / 32);
        itr->reg_bitpos = sw_bitpos % 32;
}

void vcap_iter_init(struct vcap_stream_iter *itr, int sw_width,
                    const struct vcap_typegroup *tg, u32 offset)
{
        vcap_iter_set(itr, sw_width, tg, offset);
        vcap_iter_skip_tg(itr);
        vcap_iter_update(itr);
}

void vcap_iter_next(struct vcap_stream_iter *itr)
{
        itr->offset++;
        vcap_iter_skip_tg(itr);
        vcap_iter_update(itr);
}

static void vcap_set_bit(u32 *stream, struct vcap_stream_iter *itr, bool value)
{
        u32 mask = BIT(itr->reg_bitpos);
        u32 *p = &stream[itr->reg_idx];

        if (value)
                *p |= mask;
        else
                *p &= ~mask;
}

static void vcap_encode_bit(u32 *stream, struct vcap_stream_iter *itr, bool val)
{
        /* When intersected by a type group field, stream the type group bits
         * before continuing with the value bit
         */
        while (itr->tg->width &&
               itr->offset >= itr->tg->offset &&
               itr->offset < itr->tg->offset + itr->tg->width) {
                int tg_bitpos = itr->tg->offset - itr->offset;

                vcap_set_bit(stream, itr, (itr->tg->value >> tg_bitpos) & 0x1);
                itr->offset++;
                vcap_iter_update(itr);
        }
        vcap_set_bit(stream, itr, val);
}

static void vcap_encode_field(u32 *stream, struct vcap_stream_iter *itr,
                              int width, const u8 *value)
{
        int idx;

        /* Loop over the field value bits and add the value bits one by one to
         * the output stream.
         */
        for (idx = 0; idx < width; idx++) {
                u8 bidx = idx & GENMASK(2, 0);

                /* Encode one field value bit */
                vcap_encode_bit(stream, itr, (value[idx / 8] >> bidx) & 0x1);
                vcap_iter_next(itr);
        }
}

static void vcap_encode_typegroups(u32 *stream, int sw_width,
                                   const struct vcap_typegroup *tg,
                                   bool mask)
{
        struct vcap_stream_iter iter;
        int idx;

        /* Mask bits must be set to zeros (inverted later when writing to the
         * mask cache register), so that the mask typegroup bits consist of
         * match-1 or match-0, or both
         */
        vcap_iter_set(&iter, sw_width, tg, 0);
        while (iter.tg->width) {
                /* Set position to current typegroup bit */
                iter.offset = iter.tg->offset;
                vcap_iter_update(&iter);
                for (idx = 0; idx < iter.tg->width; idx++) {
                        /* Iterate over current typegroup bits. Mask typegroup
                         * bits are always set
                         */
                        if (mask)
                                vcap_set_bit(stream, &iter, 0x1);
                        else
                                vcap_set_bit(stream, &iter,
                                             (iter.tg->value >> idx) & 0x1);
                        iter.offset++;
                        vcap_iter_update(&iter);
                }
                iter.tg++; /* next typegroup */
        }
}

static bool vcap_bitarray_zero(int width, u8 *value)
{
        int bytes = DIV_ROUND_UP(width, BITS_PER_BYTE);
        u8 total = 0, bmask = 0xff;
        int rwidth = width;
        int idx;

        for (idx = 0; idx < bytes; ++idx, rwidth -= BITS_PER_BYTE) {
                if (rwidth && rwidth < BITS_PER_BYTE)
                        bmask = (1 << rwidth) - 1;
                total += value[idx] & bmask;
        }
        return total == 0;
}

static bool vcap_get_bit(u32 *stream, struct vcap_stream_iter *itr)
{
        u32 mask = BIT(itr->reg_bitpos);
        u32 *p = &stream[itr->reg_idx];

        return !!(*p & mask);
}

static void vcap_decode_field(u32 *stream, struct vcap_stream_iter *itr,
                              int width, u8 *value)
{
        int idx;

        /* Loop over the field value bits and get the field bits and
         * set them in the output value byte array
         */
        for (idx = 0; idx < width; idx++) {
                u8 bidx = idx & 0x7;

                /* Decode one field value bit */
                if (vcap_get_bit(stream, itr))
                        *value |= 1 << bidx;
                vcap_iter_next(itr);
                if (bidx == 7)
                        value++;
        }
}

/* Verify that the type id in the stream matches the type id of the keyset */
static bool vcap_verify_keystream_keyset(struct vcap_control *vctrl,
                                         enum vcap_type vt,
                                         u32 *keystream,
                                         u32 *mskstream,
                                         enum vcap_keyfield_set keyset)
{
        const struct vcap_info *vcap = &vctrl->vcaps[vt];
        const struct vcap_field *typefld;
        const struct vcap_typegroup *tgt;
        const struct vcap_field *fields;
        struct vcap_stream_iter iter;
        const struct vcap_set *info;
        u32 value = 0;
        u32 mask = 0;

        if (vcap_keyfield_count(vctrl, vt, keyset) == 0)
                return false;

        info = vcap_keyfieldset(vctrl, vt, keyset);
        /* Check that the keyset is valid */
        if (!info)
                return false;

        /* a type_id of value -1 means that there is no type field */
        if (info->type_id == (u8)-1)
                return true;

        /* Get a valid typegroup for the specific keyset */
        tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
        if (!tgt)
                return false;

        fields = vcap_keyfields(vctrl, vt, keyset);
        if (!fields)
                return false;

        typefld = &fields[VCAP_KF_TYPE];
        vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);
        vcap_decode_field(mskstream, &iter, typefld->width, (u8 *)&mask);
        /* no type info if there are no mask bits */
        if (vcap_bitarray_zero(typefld->width, (u8 *)&mask))
                return false;

        /* Get the value of the type field in the stream and compare to the
         * one define in the vcap keyset
         */
        vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);
        vcap_decode_field(keystream, &iter, typefld->width, (u8 *)&value);

        return (value & mask) == (info->type_id & mask);
}

/* Verify that the typegroup bits have the correct values */
static int vcap_verify_typegroups(u32 *stream, int sw_width,
                                  const struct vcap_typegroup *tgt, bool mask,
                                  int sw_max)
{
        struct vcap_stream_iter iter;
        int sw_cnt, idx;

        vcap_iter_set(&iter, sw_width, tgt, 0);
        sw_cnt = 0;
        while (iter.tg->width) {
                u32 value = 0;
                u32 tg_value = iter.tg->value;

                if (mask)
                        tg_value = (1 << iter.tg->width) - 1;
                /* Set position to current typegroup bit */
                iter.offset = iter.tg->offset;
                vcap_iter_update(&iter);
                for (idx = 0; idx < iter.tg->width; idx++) {
                        /* Decode one typegroup bit */
                        if (vcap_get_bit(stream, &iter))
                                value |= 1 << idx;
                        iter.offset++;
                        vcap_iter_update(&iter);
                }
                if (value != tg_value)
                        return -EINVAL;
                iter.tg++; /* next typegroup */
                sw_cnt++;
                /* Stop checking more typegroups */
                if (sw_max && sw_cnt >= sw_max)
                        break;
        }
        return 0;
}

/* Find the subword width of the key typegroup that matches the stream data */
static int vcap_find_keystream_typegroup_sw(struct vcap_control *vctrl,
                                            enum vcap_type vt, u32 *stream,
                                            bool mask, int sw_max)
{
        const struct vcap_typegroup **tgt;
        int sw_idx, res;

        tgt = vctrl->vcaps[vt].keyfield_set_typegroups;
        /* Try the longest subword match first */
        for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) {
                if (!tgt[sw_idx])
                        continue;

                res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].sw_width,
                                             tgt[sw_idx], mask, sw_max);
                if (res == 0)
                        return sw_idx;
        }
        return -EINVAL;
}

/* Verify that the typegroup information, subword count, keyset and type id
 * are in sync and correct, return the list of matching keysets
 */
int
vcap_find_keystream_keysets(struct vcap_control *vctrl,
                            enum vcap_type vt,
                            u32 *keystream,
                            u32 *mskstream,
                            bool mask, int sw_max,
                            struct vcap_keyset_list *kslist)
{
        const struct vcap_set *keyfield_set;
        int sw_count, idx;

        sw_count = vcap_find_keystream_typegroup_sw(vctrl, vt, keystream, mask,
                                                    sw_max);
        if (sw_count < 0)
                return sw_count;

        keyfield_set = vctrl->vcaps[vt].keyfield_set;
        for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
                if (keyfield_set[idx].sw_per_item != sw_count)
                        continue;

                if (vcap_verify_keystream_keyset(vctrl, vt, keystream,
                                                 mskstream, idx))
                        vcap_keyset_list_add(kslist, idx);
        }
        if (kslist->cnt > 0)
                return 0;
        return -EINVAL;
}
EXPORT_SYMBOL_GPL(vcap_find_keystream_keysets);

/* Read key data from a VCAP address and discover if there are any rule keysets
 * here
 */
int vcap_addr_keysets(struct vcap_control *vctrl,
                      struct net_device *ndev,
                      struct vcap_admin *admin,
                      int addr,
                      struct vcap_keyset_list *kslist)
{
        enum vcap_type vt = admin->vtype;
        int keyset_sw_regs, idx;
        u32 key = 0, mask = 0;

        /* Read the cache at the specified address */
        keyset_sw_regs = DIV_ROUND_UP(vctrl->vcaps[vt].sw_width, 32);
        vctrl->ops->update(ndev, admin, VCAP_CMD_READ, VCAP_SEL_ALL, addr);
        vctrl->ops->cache_read(ndev, admin, VCAP_SEL_ENTRY, 0,
                               keyset_sw_regs);
        /* Skip uninitialized key/mask entries */
        for (idx = 0; idx < keyset_sw_regs; ++idx) {
                key |= ~admin->cache.keystream[idx];
                mask |= admin->cache.maskstream[idx];
        }
        if (key == 0 && mask == 0)
                return -EINVAL;
        /* Decode and locate the keysets */
        return vcap_find_keystream_keysets(vctrl, vt, admin->cache.keystream,
                                           admin->cache.maskstream, false, 0,
                                           kslist);
}
EXPORT_SYMBOL_GPL(vcap_addr_keysets);

/* Return the list of keyfields for the keyset */
const struct vcap_field *vcap_keyfields(struct vcap_control *vctrl,
                                        enum vcap_type vt,
                                        enum vcap_keyfield_set keyset)
{
        /* Check that the keyset exists in the vcap keyset list */
        if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
                return NULL;
        return vctrl->vcaps[vt].keyfield_set_map[keyset];
}

/* Return the keyset information for the keyset */
const struct vcap_set *vcap_keyfieldset(struct vcap_control *vctrl,
                                        enum vcap_type vt,
                                        enum vcap_keyfield_set keyset)
{
        const struct vcap_set *kset;

        /* Check that the keyset exists in the vcap keyset list */
        if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
                return NULL;
        kset = &vctrl->vcaps[vt].keyfield_set[keyset];
        if (kset->sw_per_item == 0 || kset->sw_per_item > vctrl->vcaps[vt].sw_count)
                return NULL;
        return kset;
}
EXPORT_SYMBOL_GPL(vcap_keyfieldset);

/* Return the typegroup table for the matching keyset (using subword size) */
const struct vcap_typegroup *
vcap_keyfield_typegroup(struct vcap_control *vctrl,
                        enum vcap_type vt, enum vcap_keyfield_set keyset)
{
        const struct vcap_set *kset = vcap_keyfieldset(vctrl, vt, keyset);

        /* Check that the keyset is valid */
        if (!kset)
                return NULL;
        return vctrl->vcaps[vt].keyfield_set_typegroups[kset->sw_per_item];
}

/* Return the number of keyfields in the keyset */
int vcap_keyfield_count(struct vcap_control *vctrl,
                        enum vcap_type vt, enum vcap_keyfield_set keyset)
{
        /* Check that the keyset exists in the vcap keyset list */
        if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
                return 0;
        return vctrl->vcaps[vt].keyfield_set_map_size[keyset];
}

static void vcap_encode_keyfield(struct vcap_rule_internal *ri,
                                 const struct vcap_client_keyfield *kf,
                                 const struct vcap_field *rf,
                                 const struct vcap_typegroup *tgt)
{
        int sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width;
        struct vcap_cache_data *cache = &ri->admin->cache;
        struct vcap_stream_iter iter;
        const u8 *value, *mask;

        /* Encode the fields for the key and the mask in their respective
         * streams, respecting the subword width.
         */
        switch (kf->ctrl.type) {
        case VCAP_FIELD_BIT:
                value = &kf->data.u1.value;
                mask = &kf->data.u1.mask;
                break;
        case VCAP_FIELD_U32:
                value = (const u8 *)&kf->data.u32.value;
                mask = (const u8 *)&kf->data.u32.mask;
                break;
        case VCAP_FIELD_U48:
                value = kf->data.u48.value;
                mask = kf->data.u48.mask;
                break;
        case VCAP_FIELD_U56:
                value = kf->data.u56.value;
                mask = kf->data.u56.mask;
                break;
        case VCAP_FIELD_U64:
                value = kf->data.u64.value;
                mask = kf->data.u64.mask;
                break;
        case VCAP_FIELD_U72:
                value = kf->data.u72.value;
                mask = kf->data.u72.mask;
                break;
        case VCAP_FIELD_U112:
                value = kf->data.u112.value;
                mask = kf->data.u112.mask;
                break;
        case VCAP_FIELD_U128:
                value = kf->data.u128.value;
                mask = kf->data.u128.mask;
                break;
        }
        vcap_iter_init(&iter, sw_width, tgt, rf->offset);
        vcap_encode_field(cache->keystream, &iter, rf->width, value);
        vcap_iter_init(&iter, sw_width, tgt, rf->offset);
        vcap_encode_field(cache->maskstream, &iter, rf->width, mask);
}

static void vcap_encode_keyfield_typegroups(struct vcap_control *vctrl,
                                            struct vcap_rule_internal *ri,
                                            const struct vcap_typegroup *tgt)
{
        int sw_width = vctrl->vcaps[ri->admin->vtype].sw_width;
        struct vcap_cache_data *cache = &ri->admin->cache;

        /* Encode the typegroup bits for the key and the mask in their streams,
         * respecting the subword width.
         */
        vcap_encode_typegroups(cache->keystream, sw_width, tgt, false);
        vcap_encode_typegroups(cache->maskstream, sw_width, tgt, true);
}

/* Copy data from src to dst but reverse the data in chunks of 32bits.
 * For example if src is 00:11:22:33:44:55 where 55 is LSB the dst will
 * have the value 22:33:44:55:00:11.
 */
static void vcap_copy_to_w32be(u8 *dst, const u8 *src, int size)
{
        for (int idx = 0; idx < size; ++idx) {
                int first_byte_index = 0;
                int nidx;

                first_byte_index = size - (((idx >> 2) + 1) << 2);
                if (first_byte_index < 0)
                        first_byte_index = 0;
                nidx = idx + first_byte_index - (idx & ~0x3);
                dst[nidx] = src[idx];
        }
}

static void
vcap_copy_from_client_keyfield(struct vcap_rule *rule,
                               struct vcap_client_keyfield *dst,
                               const struct vcap_client_keyfield *src)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_client_keyfield_data *sdata;
        struct vcap_client_keyfield_data *ddata;
        int size;

        dst->ctrl.type = src->ctrl.type;
        dst->ctrl.key = src->ctrl.key;
        INIT_LIST_HEAD(&dst->ctrl.list);
        sdata = &src->data;
        ddata = &dst->data;

        if (!ri->admin->w32be) {
                memcpy(ddata, sdata, sizeof(dst->data));
                return;
        }

        size = keyfield_size_table[dst->ctrl.type] / 2;

        switch (dst->ctrl.type) {
        case VCAP_FIELD_BIT:
        case VCAP_FIELD_U32:
                memcpy(ddata, sdata, sizeof(dst->data));
                break;
        case VCAP_FIELD_U48:
                vcap_copy_to_w32be(ddata->u48.value, src->data.u48.value, size);
                vcap_copy_to_w32be(ddata->u48.mask,  src->data.u48.mask, size);
                break;
        case VCAP_FIELD_U56:
                vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size);
                vcap_copy_to_w32be(ddata->u56.mask,  sdata->u56.mask, size);
                break;
        case VCAP_FIELD_U64:
                vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size);
                vcap_copy_to_w32be(ddata->u64.mask,  sdata->u64.mask, size);
                break;
        case VCAP_FIELD_U72:
                vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size);
                vcap_copy_to_w32be(ddata->u72.mask,  sdata->u72.mask, size);
                break;
        case VCAP_FIELD_U112:
                vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size);
                vcap_copy_to_w32be(ddata->u112.mask,  sdata->u112.mask, size);
                break;
        case VCAP_FIELD_U128:
                vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size);
                vcap_copy_to_w32be(ddata->u128.mask,  sdata->u128.mask, size);
                break;
        }
}

static void
vcap_copy_from_client_actionfield(struct vcap_rule *rule,
                                  struct vcap_client_actionfield *dst,
                                  const struct vcap_client_actionfield *src)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_client_actionfield_data *sdata;
        struct vcap_client_actionfield_data *ddata;
        int size;

        dst->ctrl.type = src->ctrl.type;
        dst->ctrl.action = src->ctrl.action;
        INIT_LIST_HEAD(&dst->ctrl.list);
        sdata = &src->data;
        ddata = &dst->data;

        if (!ri->admin->w32be) {
                memcpy(ddata, sdata, sizeof(dst->data));
                return;
        }

        size = actionfield_size_table[dst->ctrl.type];

        switch (dst->ctrl.type) {
        case VCAP_FIELD_BIT:
        case VCAP_FIELD_U32:
                memcpy(ddata, sdata, sizeof(dst->data));
                break;
        case VCAP_FIELD_U48:
                vcap_copy_to_w32be(ddata->u48.value, sdata->u48.value, size);
                break;
        case VCAP_FIELD_U56:
                vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size);
                break;
        case VCAP_FIELD_U64:
                vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size);
                break;
        case VCAP_FIELD_U72:
                vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size);
                break;
        case VCAP_FIELD_U112:
                vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size);
                break;
        case VCAP_FIELD_U128:
                vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size);
                break;
        }
}

static int vcap_encode_rule_keyset(struct vcap_rule_internal *ri)
{
        const struct vcap_client_keyfield *ckf;
        const struct vcap_typegroup *tg_table;
        struct vcap_client_keyfield tempkf;
        const struct vcap_field *kf_table;
        int keyset_size;

        /* Get a valid set of fields for the specific keyset */
        kf_table = vcap_keyfields(ri->vctrl, ri->admin->vtype, ri->data.keyset);
        if (!kf_table) {
                pr_err("%s:%d: no fields available for this keyset: %d\n",
                       __func__, __LINE__, ri->data.keyset);
                return -EINVAL;
        }
        /* Get a valid typegroup for the specific keyset */
        tg_table = vcap_keyfield_typegroup(ri->vctrl, ri->admin->vtype,
                                           ri->data.keyset);
        if (!tg_table) {
                pr_err("%s:%d: no typegroups available for this keyset: %d\n",
                       __func__, __LINE__, ri->data.keyset);
                return -EINVAL;
        }
        /* Get a valid size for the specific keyset */
        keyset_size = vcap_keyfield_count(ri->vctrl, ri->admin->vtype,
                                          ri->data.keyset);
        if (keyset_size == 0) {
                pr_err("%s:%d: zero field count for this keyset: %d\n",
                       __func__, __LINE__, ri->data.keyset);
                return -EINVAL;
        }
        /* Iterate over the keyfields (key, mask) in the rule
         * and encode these bits
         */
        if (list_empty(&ri->data.keyfields)) {
                pr_err("%s:%d: no keyfields in the rule\n", __func__, __LINE__);
                return -EINVAL;
        }
        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
                /* Check that the client entry exists in the keyset */
                if (ckf->ctrl.key >= keyset_size) {
                        pr_err("%s:%d: key %d is not in vcap\n",
                               __func__, __LINE__, ckf->ctrl.key);
                        return -EINVAL;
                }
                vcap_copy_from_client_keyfield(&ri->data, &tempkf, ckf);
                vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key],
                                     tg_table);
        }
        /* Add typegroup bits to the key/mask bitstreams */
        vcap_encode_keyfield_typegroups(ri->vctrl, ri, tg_table);
        return 0;
}

/* Return the list of actionfields for the actionset */
const struct vcap_field *
vcap_actionfields(struct vcap_control *vctrl,
                  enum vcap_type vt, enum vcap_actionfield_set actionset)
{
        /* Check that the actionset exists in the vcap actionset list */
        if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
                return NULL;
        return vctrl->vcaps[vt].actionfield_set_map[actionset];
}

const struct vcap_set *
vcap_actionfieldset(struct vcap_control *vctrl,
                    enum vcap_type vt, enum vcap_actionfield_set actionset)
{
        const struct vcap_set *aset;

        /* Check that the actionset exists in the vcap actionset list */
        if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
                return NULL;
        aset = &vctrl->vcaps[vt].actionfield_set[actionset];
        if (aset->sw_per_item == 0 || aset->sw_per_item > vctrl->vcaps[vt].sw_count)
                return NULL;
        return aset;
}

/* Return the typegroup table for the matching actionset (using subword size) */
const struct vcap_typegroup *
vcap_actionfield_typegroup(struct vcap_control *vctrl,
                           enum vcap_type vt, enum vcap_actionfield_set actionset)
{
        const struct vcap_set *aset = vcap_actionfieldset(vctrl, vt, actionset);

        /* Check that the actionset is valid */
        if (!aset)
                return NULL;
        return vctrl->vcaps[vt].actionfield_set_typegroups[aset->sw_per_item];
}

/* Return the number of actionfields in the actionset */
int vcap_actionfield_count(struct vcap_control *vctrl,
                           enum vcap_type vt,
                           enum vcap_actionfield_set actionset)
{
        /* Check that the actionset exists in the vcap actionset list */
        if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
                return 0;
        return vctrl->vcaps[vt].actionfield_set_map_size[actionset];
}

static void vcap_encode_actionfield(struct vcap_rule_internal *ri,
                                    const struct vcap_client_actionfield *af,
                                    const struct vcap_field *rf,
                                    const struct vcap_typegroup *tgt)
{
        int act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;

        struct vcap_cache_data *cache = &ri->admin->cache;
        struct vcap_stream_iter iter;
        const u8 *value;

        /* Encode the action field in the stream, respecting the subword width */
        switch (af->ctrl.type) {
        case VCAP_FIELD_BIT:
                value = &af->data.u1.value;
                break;
        case VCAP_FIELD_U32:
                value = (const u8 *)&af->data.u32.value;
                break;
        case VCAP_FIELD_U48:
                value = af->data.u48.value;
                break;
        case VCAP_FIELD_U56:
                value = af->data.u56.value;
                break;
        case VCAP_FIELD_U64:
                value = af->data.u64.value;
                break;
        case VCAP_FIELD_U72:
                value = af->data.u72.value;
                break;
        case VCAP_FIELD_U112:
                value = af->data.u112.value;
                break;
        case VCAP_FIELD_U128:
                value = af->data.u128.value;
                break;
        }
        vcap_iter_init(&iter, act_width, tgt, rf->offset);
        vcap_encode_field(cache->actionstream, &iter, rf->width, value);
}

static void vcap_encode_actionfield_typegroups(struct vcap_rule_internal *ri,
                                               const struct vcap_typegroup *tgt)
{
        int sw_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;
        struct vcap_cache_data *cache = &ri->admin->cache;

        /* Encode the typegroup bits for the actionstream respecting the subword
         * width.
         */
        vcap_encode_typegroups(cache->actionstream, sw_width, tgt, false);
}

static int vcap_encode_rule_actionset(struct vcap_rule_internal *ri)
{
        const struct vcap_client_actionfield *caf;
        const struct vcap_typegroup *tg_table;
        struct vcap_client_actionfield tempaf;
        const struct vcap_field *af_table;
        int actionset_size;

        /* Get a valid set of actionset fields for the specific actionset */
        af_table = vcap_actionfields(ri->vctrl, ri->admin->vtype,
                                     ri->data.actionset);
        if (!af_table) {
                pr_err("%s:%d: no fields available for this actionset: %d\n",
                       __func__, __LINE__, ri->data.actionset);
                return -EINVAL;
        }
        /* Get a valid typegroup for the specific actionset */
        tg_table = vcap_actionfield_typegroup(ri->vctrl, ri->admin->vtype,
                                              ri->data.actionset);
        if (!tg_table) {
                pr_err("%s:%d: no typegroups available for this actionset: %d\n",
                       __func__, __LINE__, ri->data.actionset);
                return -EINVAL;
        }
        /* Get a valid actionset size for the specific actionset */
        actionset_size = vcap_actionfield_count(ri->vctrl, ri->admin->vtype,
                                                ri->data.actionset);
        if (actionset_size == 0) {
                pr_err("%s:%d: zero field count for this actionset: %d\n",
                       __func__, __LINE__, ri->data.actionset);
                return -EINVAL;
        }
        /* Iterate over the actionfields in the rule
         * and encode these bits
         */
        if (list_empty(&ri->data.actionfields))
                pr_warn("%s:%d: no actionfields in the rule\n",
                        __func__, __LINE__);
        list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
                /* Check that the client action exists in the actionset */
                if (caf->ctrl.action >= actionset_size) {
                        pr_err("%s:%d: action %d is not in vcap\n",
                               __func__, __LINE__, caf->ctrl.action);
                        return -EINVAL;
                }
                vcap_copy_from_client_actionfield(&ri->data, &tempaf, caf);
                vcap_encode_actionfield(ri, &tempaf,
                                        &af_table[caf->ctrl.action], tg_table);
        }
        /* Add typegroup bits to the entry bitstreams */
        vcap_encode_actionfield_typegroups(ri, tg_table);
        return 0;
}

static int vcap_encode_rule(struct vcap_rule_internal *ri)
{
        int err;

        err = vcap_encode_rule_keyset(ri);
        if (err)
                return err;
        err = vcap_encode_rule_actionset(ri);
        if (err)
                return err;
        return 0;
}

int vcap_api_check(struct vcap_control *ctrl)
{
        if (!ctrl) {
                pr_err("%s:%d: vcap control is missing\n", __func__, __LINE__);
                return -EINVAL;
        }
        if (!ctrl->ops || !ctrl->ops->validate_keyset ||
            !ctrl->ops->add_default_fields || !ctrl->ops->cache_erase ||
            !ctrl->ops->cache_write || !ctrl->ops->cache_read ||
            !ctrl->ops->init || !ctrl->ops->update || !ctrl->ops->move ||
            !ctrl->ops->port_info) {
                pr_err("%s:%d: client operations are missing\n",
                       __func__, __LINE__);
                return -ENOENT;
        }
        return 0;
}

void vcap_erase_cache(struct vcap_rule_internal *ri)
{
        ri->vctrl->ops->cache_erase(ri->admin);
}

/* Update the keyset for the rule */
int vcap_set_rule_set_keyset(struct vcap_rule *rule,
                             enum vcap_keyfield_set keyset)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_set *kset;
        int sw_width;

        kset = vcap_keyfieldset(ri->vctrl, ri->admin->vtype, keyset);
        /* Check that the keyset is valid */
        if (!kset)
                return -EINVAL;
        ri->keyset_sw = kset->sw_per_item;
        sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width;
        ri->keyset_sw_regs = DIV_ROUND_UP(sw_width, 32);
        ri->data.keyset = keyset;
        return 0;
}
EXPORT_SYMBOL_GPL(vcap_set_rule_set_keyset);

/* Update the actionset for the rule */
int vcap_set_rule_set_actionset(struct vcap_rule *rule,
                                enum vcap_actionfield_set actionset)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_set *aset;
        int act_width;

        aset = vcap_actionfieldset(ri->vctrl, ri->admin->vtype, actionset);
        /* Check that the actionset is valid */
        if (!aset)
                return -EINVAL;
        ri->actionset_sw = aset->sw_per_item;
        act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;
        ri->actionset_sw_regs = DIV_ROUND_UP(act_width, 32);
        ri->data.actionset = actionset;
        return 0;
}
EXPORT_SYMBOL_GPL(vcap_set_rule_set_actionset);

/* Check if a rule with this id exists */
static bool vcap_rule_exists(struct vcap_control *vctrl, u32 id)
{
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;

        /* Look for the rule id in all vcaps */
        list_for_each_entry(admin, &vctrl->list, list)
                list_for_each_entry(ri, &admin->rules, list)
                        if (ri->data.id == id)
                                return true;
        return false;
}

/* Find a rule with a provided rule id return a locked vcap */
static struct vcap_rule_internal *
vcap_get_locked_rule(struct vcap_control *vctrl, u32 id)
{
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;

        /* Look for the rule id in all vcaps */
        list_for_each_entry(admin, &vctrl->list, list) {
                mutex_lock(&admin->lock);
                list_for_each_entry(ri, &admin->rules, list)
                        if (ri->data.id == id)
                                return ri;
                mutex_unlock(&admin->lock);
        }
        return NULL;
}

/* Find a rule id with a provided cookie */
int vcap_lookup_rule_by_cookie(struct vcap_control *vctrl, u64 cookie)
{
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;
        int id = 0;

        /* Look for the rule id in all vcaps */
        list_for_each_entry(admin, &vctrl->list, list) {
                mutex_lock(&admin->lock);
                list_for_each_entry(ri, &admin->rules, list) {
                        if (ri->data.cookie == cookie) {
                                id = ri->data.id;
                                break;
                        }
                }
                mutex_unlock(&admin->lock);
                if (id)
                        return id;
        }
        return -ENOENT;
}
EXPORT_SYMBOL_GPL(vcap_lookup_rule_by_cookie);

/* Get number of rules in a vcap instance lookup chain id range */
int vcap_admin_rule_count(struct vcap_admin *admin, int cid)
{
        int max_cid = roundup(cid + 1, VCAP_CID_LOOKUP_SIZE);
        int min_cid = rounddown(cid, VCAP_CID_LOOKUP_SIZE);
        struct vcap_rule_internal *elem;
        int count = 0;

        list_for_each_entry(elem, &admin->rules, list) {
                mutex_lock(&admin->lock);
                if (elem->data.vcap_chain_id >= min_cid &&
                    elem->data.vcap_chain_id < max_cid)
                        ++count;
                mutex_unlock(&admin->lock);
        }
        return count;
}
EXPORT_SYMBOL_GPL(vcap_admin_rule_count);

/* Make a copy of the rule, shallow or full */
static struct vcap_rule_internal *vcap_dup_rule(struct vcap_rule_internal *ri,
                                                bool full)
{
        struct vcap_client_actionfield *caf, *newcaf;
        struct vcap_client_keyfield *ckf, *newckf;
        struct vcap_rule_internal *duprule;

        /* Allocate the client part */
        duprule = kzalloc_obj(*duprule);
        if (!duprule)
                return ERR_PTR(-ENOMEM);
        *duprule = *ri;
        /* Not inserted in the VCAP */
        INIT_LIST_HEAD(&duprule->list);
        /* No elements in these lists */
        INIT_LIST_HEAD(&duprule->data.keyfields);
        INIT_LIST_HEAD(&duprule->data.actionfields);

        /* A full rule copy includes keys and actions */
        if (!full)
                return duprule;

        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
                newckf = kmemdup(ckf, sizeof(*newckf), GFP_KERNEL);
                if (!newckf)
                        goto err;
                list_add_tail(&newckf->ctrl.list, &duprule->data.keyfields);
        }

        list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
                newcaf = kmemdup(caf, sizeof(*newcaf), GFP_KERNEL);
                if (!newcaf)
                        goto err;
                list_add_tail(&newcaf->ctrl.list, &duprule->data.actionfields);
        }

        return duprule;

err:
        list_for_each_entry_safe(ckf, newckf, &duprule->data.keyfields, ctrl.list) {
                list_del(&ckf->ctrl.list);
                kfree(ckf);
        }

        list_for_each_entry_safe(caf, newcaf, &duprule->data.actionfields, ctrl.list) {
                list_del(&caf->ctrl.list);
                kfree(caf);
        }

        kfree(duprule);
        return ERR_PTR(-ENOMEM);
}

static void vcap_apply_width(u8 *dst, int width, int bytes)
{
        u8 bmask;
        int idx;

        for (idx = 0; idx < bytes; idx++) {
                if (width > 0)
                        if (width < 8)
                                bmask = (1 << width) - 1;
                        else
                                bmask = ~0;
                else
                        bmask = 0;
                dst[idx] &= bmask;
                width -= 8;
        }
}

static void vcap_copy_from_w32be(u8 *dst, u8 *src, int size, int width)
{
        int idx, ridx, wstart, nidx;
        int tail_bytes = (((size + 4) >> 2) << 2) - size;

        for (idx = 0, ridx = size - 1; idx < size; ++idx, --ridx) {
                wstart = (idx >> 2) << 2;
                nidx = wstart + 3 - (idx & 0x3);
                if (nidx >= size)
                        nidx -= tail_bytes;
                dst[nidx] = src[ridx];
        }

        vcap_apply_width(dst, width, size);
}

static void vcap_copy_action_bit_field(struct vcap_u1_action *field, u8 *value)
{
        field->value = (*value) & 0x1;
}

static void vcap_copy_limited_actionfield(u8 *dstvalue, u8 *srcvalue,
                                          int width, int bytes)
{
        memcpy(dstvalue, srcvalue, bytes);
        vcap_apply_width(dstvalue, width, bytes);
}

static void vcap_copy_to_client_actionfield(struct vcap_rule_internal *ri,
                                            struct vcap_client_actionfield *field,
                                            u8 *value, u16 width)
{
        int field_size = actionfield_size_table[field->ctrl.type];

        if (ri->admin->w32be) {
                switch (field->ctrl.type) {
                case VCAP_FIELD_BIT:
                        vcap_copy_action_bit_field(&field->data.u1, value);
                        break;
                case VCAP_FIELD_U32:
                        vcap_copy_limited_actionfield((u8 *)&field->data.u32.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U48:
                        vcap_copy_from_w32be(field->data.u48.value, value,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U56:
                        vcap_copy_from_w32be(field->data.u56.value, value,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U64:
                        vcap_copy_from_w32be(field->data.u64.value, value,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U72:
                        vcap_copy_from_w32be(field->data.u72.value, value,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U112:
                        vcap_copy_from_w32be(field->data.u112.value, value,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U128:
                        vcap_copy_from_w32be(field->data.u128.value, value,
                                             field_size, width);
                        break;
                }
        } else {
                switch (field->ctrl.type) {
                case VCAP_FIELD_BIT:
                        vcap_copy_action_bit_field(&field->data.u1, value);
                        break;
                case VCAP_FIELD_U32:
                        vcap_copy_limited_actionfield((u8 *)&field->data.u32.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U48:
                        vcap_copy_limited_actionfield(field->data.u48.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U56:
                        vcap_copy_limited_actionfield(field->data.u56.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U64:
                        vcap_copy_limited_actionfield(field->data.u64.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U72:
                        vcap_copy_limited_actionfield(field->data.u72.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U112:
                        vcap_copy_limited_actionfield(field->data.u112.value,
                                                      value,
                                                      width, field_size);
                        break;
                case VCAP_FIELD_U128:
                        vcap_copy_limited_actionfield(field->data.u128.value,
                                                      value,
                                                      width, field_size);
                        break;
                }
        }
}

static void vcap_copy_key_bit_field(struct vcap_u1_key *field,
                                    u8 *value, u8 *mask)
{
        field->value = (*value) & 0x1;
        field->mask = (*mask) & 0x1;
}

static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask,
                                       u8 *srcvalue, u8 *srcmask,
                                       int width, int bytes)
{
        memcpy(dstvalue, srcvalue, bytes);
        vcap_apply_width(dstvalue, width, bytes);
        memcpy(dstmask, srcmask, bytes);
        vcap_apply_width(dstmask, width, bytes);
}

static void vcap_copy_to_client_keyfield(struct vcap_rule_internal *ri,
                                         struct vcap_client_keyfield *field,
                                         u8 *value, u8 *mask, u16 width)
{
        int field_size = keyfield_size_table[field->ctrl.type] / 2;

        if (ri->admin->w32be) {
                switch (field->ctrl.type) {
                case VCAP_FIELD_BIT:
                        vcap_copy_key_bit_field(&field->data.u1, value, mask);
                        break;
                case VCAP_FIELD_U32:
                        vcap_copy_limited_keyfield((u8 *)&field->data.u32.value,
                                                   (u8 *)&field->data.u32.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U48:
                        vcap_copy_from_w32be(field->data.u48.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u48.mask,  mask,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U56:
                        vcap_copy_from_w32be(field->data.u56.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u56.mask,  mask,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U64:
                        vcap_copy_from_w32be(field->data.u64.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u64.mask,  mask,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U72:
                        vcap_copy_from_w32be(field->data.u72.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u72.mask,  mask,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U112:
                        vcap_copy_from_w32be(field->data.u112.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u112.mask,  mask,
                                             field_size, width);
                        break;
                case VCAP_FIELD_U128:
                        vcap_copy_from_w32be(field->data.u128.value, value,
                                             field_size, width);
                        vcap_copy_from_w32be(field->data.u128.mask,  mask,
                                             field_size, width);
                        break;
                }
        } else {
                switch (field->ctrl.type) {
                case VCAP_FIELD_BIT:
                        vcap_copy_key_bit_field(&field->data.u1, value, mask);
                        break;
                case VCAP_FIELD_U32:
                        vcap_copy_limited_keyfield((u8 *)&field->data.u32.value,
                                                   (u8 *)&field->data.u32.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U48:
                        vcap_copy_limited_keyfield(field->data.u48.value,
                                                   field->data.u48.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U56:
                        vcap_copy_limited_keyfield(field->data.u56.value,
                                                   field->data.u56.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U64:
                        vcap_copy_limited_keyfield(field->data.u64.value,
                                                   field->data.u64.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U72:
                        vcap_copy_limited_keyfield(field->data.u72.value,
                                                   field->data.u72.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U112:
                        vcap_copy_limited_keyfield(field->data.u112.value,
                                                   field->data.u112.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                case VCAP_FIELD_U128:
                        vcap_copy_limited_keyfield(field->data.u128.value,
                                                   field->data.u128.mask,
                                                   value, mask,
                                                   width, field_size);
                        break;
                }
        }
}

static void vcap_rule_alloc_keyfield(struct vcap_rule_internal *ri,
                                     const struct vcap_field *keyfield,
                                     enum vcap_key_field key,
                                     u8 *value, u8 *mask)
{
        struct vcap_client_keyfield *field;

        field = kzalloc_obj(*field);
        if (!field)
                return;
        INIT_LIST_HEAD(&field->ctrl.list);
        field->ctrl.key = key;
        field->ctrl.type = keyfield->type;
        vcap_copy_to_client_keyfield(ri, field, value, mask, keyfield->width);
        list_add_tail(&field->ctrl.list, &ri->data.keyfields);
}

/* Read key data from a VCAP address and discover if there is a rule keyset
 * here
 */
static bool
vcap_verify_actionstream_actionset(struct vcap_control *vctrl,
                                   enum vcap_type vt,
                                   u32 *actionstream,
                                   enum vcap_actionfield_set actionset)
{
        const struct vcap_typegroup *tgt;
        const struct vcap_field *fields;
        const struct vcap_set *info;

        if (vcap_actionfield_count(vctrl, vt, actionset) == 0)
                return false;

        info = vcap_actionfieldset(vctrl, vt, actionset);
        /* Check that the actionset is valid */
        if (!info)
                return false;

        /* a type_id of value -1 means that there is no type field */
        if (info->type_id == (u8)-1)
                return true;

        /* Get a valid typegroup for the specific actionset */
        tgt = vcap_actionfield_typegroup(vctrl, vt, actionset);
        if (!tgt)
                return false;

        fields = vcap_actionfields(vctrl, vt, actionset);
        if (!fields)
                return false;

        /* Later this will be expanded with a check of the type id */
        return true;
}

/* Find the subword width of the action typegroup that matches the stream data
 */
static int vcap_find_actionstream_typegroup_sw(struct vcap_control *vctrl,
                                               enum vcap_type vt, u32 *stream,
                                               int sw_max)
{
        const struct vcap_typegroup **tgt;
        int sw_idx, res;

        tgt = vctrl->vcaps[vt].actionfield_set_typegroups;
        /* Try the longest subword match first */
        for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) {
                if (!tgt[sw_idx])
                        continue;
                res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].act_width,
                                             tgt[sw_idx], false, sw_max);
                if (res == 0)
                        return sw_idx;
        }
        return -EINVAL;
}

/* Verify that the typegroup information, subword count, actionset and type id
 * are in sync and correct, return the actionset
 */
static enum vcap_actionfield_set
vcap_find_actionstream_actionset(struct vcap_control *vctrl,
                                 enum vcap_type vt,
                                 u32 *stream,
                                 int sw_max)
{
        const struct vcap_set *actionfield_set;
        int sw_count, idx;
        bool res;

        sw_count = vcap_find_actionstream_typegroup_sw(vctrl, vt, stream,
                                                       sw_max);
        if (sw_count < 0)
                return sw_count;

        actionfield_set = vctrl->vcaps[vt].actionfield_set;
        for (idx = 0; idx < vctrl->vcaps[vt].actionfield_set_size; ++idx) {
                if (actionfield_set[idx].sw_per_item != sw_count)
                        continue;

                res = vcap_verify_actionstream_actionset(vctrl, vt,
                                                         stream, idx);
                if (res)
                        return idx;
        }
        return -EINVAL;
}

/* Store action value in an element in a list for the client */
static void vcap_rule_alloc_actionfield(struct vcap_rule_internal *ri,
                                        const struct vcap_field *actionfield,
                                        enum vcap_action_field action,
                                        u8 *value)
{
        struct vcap_client_actionfield *field;

        field = kzalloc_obj(*field);
        if (!field)
                return;
        INIT_LIST_HEAD(&field->ctrl.list);
        field->ctrl.action = action;
        field->ctrl.type = actionfield->type;
        vcap_copy_to_client_actionfield(ri, field, value, actionfield->width);
        list_add_tail(&field->ctrl.list, &ri->data.actionfields);
}

static int vcap_decode_actionset(struct vcap_rule_internal *ri)
{
        struct vcap_control *vctrl = ri->vctrl;
        struct vcap_admin *admin = ri->admin;
        const struct vcap_field *actionfield;
        enum vcap_actionfield_set actionset;
        enum vcap_type vt = admin->vtype;
        const struct vcap_typegroup *tgt;
        struct vcap_stream_iter iter;
        int idx, res, actfield_count;
        u32 *actstream;
        u8 value[16];

        actstream = admin->cache.actionstream;
        res = vcap_find_actionstream_actionset(vctrl, vt, actstream, 0);
        if (res < 0) {
                pr_err("%s:%d: could not find valid actionset: %d\n",
                       __func__, __LINE__, res);
                return -EINVAL;
        }
        actionset = res;
        actfield_count = vcap_actionfield_count(vctrl, vt, actionset);
        actionfield = vcap_actionfields(vctrl, vt, actionset);
        tgt = vcap_actionfield_typegroup(vctrl, vt, actionset);
        /* Start decoding the stream */
        for (idx = 0; idx < actfield_count; ++idx) {
                if (actionfield[idx].width <= 0)
                        continue;
                /* Get the action */
                memset(value, 0, DIV_ROUND_UP(actionfield[idx].width, 8));
                vcap_iter_init(&iter, vctrl->vcaps[vt].act_width, tgt,
                               actionfield[idx].offset);
                vcap_decode_field(actstream, &iter, actionfield[idx].width,
                                  value);
                /* Skip if no bits are set */
                if (vcap_bitarray_zero(actionfield[idx].width, value))
                        continue;
                vcap_rule_alloc_actionfield(ri, &actionfield[idx], idx, value);
                /* Later the action id will also be checked */
        }
        return vcap_set_rule_set_actionset((struct vcap_rule *)ri, actionset);
}

static int vcap_decode_keyset(struct vcap_rule_internal *ri)
{
        struct vcap_control *vctrl = ri->vctrl;
        struct vcap_stream_iter kiter, miter;
        struct vcap_admin *admin = ri->admin;
        enum vcap_keyfield_set keysets[10];
        const struct vcap_field *keyfield;
        enum vcap_type vt = admin->vtype;
        const struct vcap_typegroup *tgt;
        struct vcap_keyset_list matches;
        enum vcap_keyfield_set keyset;
        int idx, res, keyfield_count;
        u32 *maskstream;
        u32 *keystream;
        u8 value[16];
        u8 mask[16];

        keystream = admin->cache.keystream;
        maskstream = admin->cache.maskstream;
        matches.keysets = keysets;
        matches.cnt = 0;
        matches.max = ARRAY_SIZE(keysets);
        res = vcap_find_keystream_keysets(vctrl, vt, keystream, maskstream,
                                          false, 0, &matches);
        if (res < 0) {
                pr_err("%s:%d: could not find valid keysets: %d\n",
                       __func__, __LINE__, res);
                return -EINVAL;
        }
        keyset = matches.keysets[0];
        keyfield_count = vcap_keyfield_count(vctrl, vt, keyset);
        keyfield = vcap_keyfields(vctrl, vt, keyset);
        tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
        /* Start decoding the streams */
        for (idx = 0; idx < keyfield_count; ++idx) {
                if (keyfield[idx].width <= 0)
                        continue;
                /* First get the mask */
                memset(mask, 0, DIV_ROUND_UP(keyfield[idx].width, 8));
                vcap_iter_init(&miter, vctrl->vcaps[vt].sw_width, tgt,
                               keyfield[idx].offset);
                vcap_decode_field(maskstream, &miter, keyfield[idx].width,
                                  mask);
                /* Skip if no mask bits are set */
                if (vcap_bitarray_zero(keyfield[idx].width, mask))
                        continue;
                /* Get the key */
                memset(value, 0, DIV_ROUND_UP(keyfield[idx].width, 8));
                vcap_iter_init(&kiter, vctrl->vcaps[vt].sw_width, tgt,
                               keyfield[idx].offset);
                vcap_decode_field(keystream, &kiter, keyfield[idx].width,
                                  value);
                vcap_rule_alloc_keyfield(ri, &keyfield[idx], idx, value, mask);
        }
        return vcap_set_rule_set_keyset((struct vcap_rule *)ri, keyset);
}

/* Read VCAP content into the VCAP cache */
static int vcap_read_rule(struct vcap_rule_internal *ri)
{
        struct vcap_admin *admin = ri->admin;
        int sw_idx, ent_idx = 0, act_idx = 0;
        u32 addr = ri->addr;

        if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) {
                pr_err("%s:%d: rule is empty\n", __func__, __LINE__);
                return -EINVAL;
        }
        vcap_erase_cache(ri);
        /* Use the values in the streams to read the VCAP cache */
        for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) {
                ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ,
                                       VCAP_SEL_ALL, addr);
                ri->vctrl->ops->cache_read(ri->ndev, admin,
                                           VCAP_SEL_ENTRY, ent_idx,
                                           ri->keyset_sw_regs);
                ri->vctrl->ops->cache_read(ri->ndev, admin,
                                           VCAP_SEL_ACTION, act_idx,
                                           ri->actionset_sw_regs);
                if (sw_idx == 0)
                        ri->vctrl->ops->cache_read(ri->ndev, admin,
                                                   VCAP_SEL_COUNTER,
                                                   ri->counter_id, 0);
                ent_idx += ri->keyset_sw_regs;
                act_idx += ri->actionset_sw_regs;
        }
        return 0;
}

/* Write VCAP cache content to the VCAP HW instance */
static int vcap_write_rule(struct vcap_rule_internal *ri)
{
        struct vcap_admin *admin = ri->admin;
        int sw_idx, ent_idx = 0, act_idx = 0;
        u32 addr = ri->addr;

        if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) {
                pr_err("%s:%d: rule is empty\n", __func__, __LINE__);
                return -EINVAL;
        }
        /* Use the values in the streams to write the VCAP cache */
        for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) {
                ri->vctrl->ops->cache_write(ri->ndev, admin,
                                            VCAP_SEL_ENTRY, ent_idx,
                                            ri->keyset_sw_regs);
                ri->vctrl->ops->cache_write(ri->ndev, admin,
                                            VCAP_SEL_ACTION, act_idx,
                                            ri->actionset_sw_regs);
                ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE,
                                       VCAP_SEL_ALL, addr);
                ent_idx += ri->keyset_sw_regs;
                act_idx += ri->actionset_sw_regs;
        }
        return 0;
}

static int vcap_write_counter(struct vcap_rule_internal *ri,
                              struct vcap_counter *ctr)
{
        struct vcap_admin *admin = ri->admin;

        admin->cache.counter = ctr->value;
        admin->cache.sticky = ctr->sticky;
        ri->vctrl->ops->cache_write(ri->ndev, admin, VCAP_SEL_COUNTER,
                                    ri->counter_id, 0);
        ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE,
                               VCAP_SEL_COUNTER, ri->addr);
        return 0;
}

/* Convert a chain id to a VCAP lookup index */
int vcap_chain_id_to_lookup(struct vcap_admin *admin, int cur_cid)
{
        int lookup_first = admin->vinst * admin->lookups_per_instance;
        int lookup_last = lookup_first + admin->lookups_per_instance;
        int cid_next = admin->first_cid + VCAP_CID_LOOKUP_SIZE;
        int cid = admin->first_cid;
        int lookup;

        for (lookup = lookup_first; lookup < lookup_last; ++lookup,
             cid += VCAP_CID_LOOKUP_SIZE, cid_next += VCAP_CID_LOOKUP_SIZE)
                if (cur_cid >= cid && cur_cid < cid_next)
                        return lookup;
        return 0;
}
EXPORT_SYMBOL_GPL(vcap_chain_id_to_lookup);

/* Lookup a vcap instance using chain id */
struct vcap_admin *vcap_find_admin(struct vcap_control *vctrl, int cid)
{
        struct vcap_admin *admin;

        if (vcap_api_check(vctrl))
                return NULL;

        list_for_each_entry(admin, &vctrl->list, list) {
                if (cid >= admin->first_cid && cid <= admin->last_cid)
                        return admin;
        }
        return NULL;
}
EXPORT_SYMBOL_GPL(vcap_find_admin);

/* Is this the last admin instance ordered by chain id and direction */
static bool vcap_admin_is_last(struct vcap_control *vctrl,
                               struct vcap_admin *admin,
                               bool ingress)
{
        struct vcap_admin *iter, *last = NULL;
        int max_cid = 0;

        list_for_each_entry(iter, &vctrl->list, list) {
                if (iter->first_cid > max_cid &&
                    iter->ingress == ingress) {
                        last = iter;
                        max_cid = iter->first_cid;
                }
        }
        if (!last)
                return false;

        return admin == last;
}

/* Calculate the value used for chaining VCAP rules */
int vcap_chain_offset(struct vcap_control *vctrl, int from_cid, int to_cid)
{
        int diff = to_cid - from_cid;

        if (diff < 0) /* Wrong direction */
                return diff;
        to_cid %= VCAP_CID_LOOKUP_SIZE;
        if (to_cid == 0)  /* Destination aligned to a lookup == no chaining */
                return 0;
        diff %= VCAP_CID_LOOKUP_SIZE;  /* Limit to a value within a lookup */
        return diff;
}
EXPORT_SYMBOL_GPL(vcap_chain_offset);

/* Is the next chain id in one of the following lookups
 * For now this does not support filters linked to other filters using
 * keys and actions. That will be added later.
 */
bool vcap_is_next_lookup(struct vcap_control *vctrl, int src_cid, int dst_cid)
{
        struct vcap_admin *admin;
        int next_cid;

        if (vcap_api_check(vctrl))
                return false;

        /* The offset must be at least one lookup so round up one chain */
        next_cid = roundup(src_cid + 1, VCAP_CID_LOOKUP_SIZE);

        if (dst_cid < next_cid)
                return false;

        admin = vcap_find_admin(vctrl, dst_cid);
        if (!admin)
                return false;

        return true;
}
EXPORT_SYMBOL_GPL(vcap_is_next_lookup);

/* Check if there is room for a new rule */
static int vcap_rule_space(struct vcap_admin *admin, int size)
{
        if (admin->last_used_addr - size < admin->first_valid_addr) {
                pr_err("%s:%d: No room for rule size: %u, %u\n",
                       __func__, __LINE__, size, admin->first_valid_addr);
                return -ENOSPC;
        }
        return 0;
}

/* Add the keyset typefield to the list of rule keyfields */
static int vcap_add_type_keyfield(struct vcap_rule *rule)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        enum vcap_keyfield_set keyset = rule->keyset;
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_field *fields;
        const struct vcap_set *kset;
        int ret = -EINVAL;

        kset = vcap_keyfieldset(ri->vctrl, vt, keyset);
        if (!kset)
                return ret;
        if (kset->type_id == (u8)-1)  /* No type field is needed */
                return 0;

        fields = vcap_keyfields(ri->vctrl, vt, keyset);
        if (!fields)
                return -EINVAL;
        if (fields[VCAP_KF_TYPE].width > 1) {
                ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE,
                                            kset->type_id, 0xff);
        } else {
                if (kset->type_id)
                        ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE,
                                                    VCAP_BIT_1);
                else
                        ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE,
                                                    VCAP_BIT_0);
        }
        return 0;
}

/* Add the actionset typefield to the list of rule actionfields */
static int vcap_add_type_actionfield(struct vcap_rule *rule)
{
        enum vcap_actionfield_set actionset = rule->actionset;
        struct vcap_rule_internal *ri = to_intrule(rule);
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_field *fields;
        const struct vcap_set *aset;
        int ret = -EINVAL;

        aset = vcap_actionfieldset(ri->vctrl, vt, actionset);
        if (!aset)
                return ret;
        if (aset->type_id == (u8)-1)  /* No type field is needed */
                return 0;

        fields = vcap_actionfields(ri->vctrl, vt, actionset);
        if (!fields)
                return -EINVAL;
        if (fields[VCAP_AF_TYPE].width > 1) {
                ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE,
                                               aset->type_id);
        } else {
                if (aset->type_id)
                        ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
                                                       VCAP_BIT_1);
                else
                        ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
                                                       VCAP_BIT_0);
        }
        return ret;
}

/* Add a keyset to a keyset list */
bool vcap_keyset_list_add(struct vcap_keyset_list *keysetlist,
                          enum vcap_keyfield_set keyset)
{
        int idx;

        if (keysetlist->cnt < keysetlist->max) {
                /* Avoid duplicates */
                for (idx = 0; idx < keysetlist->cnt; ++idx)
                        if (keysetlist->keysets[idx] == keyset)
                                return keysetlist->cnt < keysetlist->max;
                keysetlist->keysets[keysetlist->cnt++] = keyset;
        }
        return keysetlist->cnt < keysetlist->max;
}
EXPORT_SYMBOL_GPL(vcap_keyset_list_add);

/* Add a actionset to a actionset list */
static bool vcap_actionset_list_add(struct vcap_actionset_list *actionsetlist,
                                    enum vcap_actionfield_set actionset)
{
        int idx;

        if (actionsetlist->cnt < actionsetlist->max) {
                /* Avoid duplicates */
                for (idx = 0; idx < actionsetlist->cnt; ++idx)
                        if (actionsetlist->actionsets[idx] == actionset)
                                return actionsetlist->cnt < actionsetlist->max;
                actionsetlist->actionsets[actionsetlist->cnt++] = actionset;
        }
        return actionsetlist->cnt < actionsetlist->max;
}

/* map keyset id to a string with the keyset name */
const char *vcap_keyset_name(struct vcap_control *vctrl,
                             enum vcap_keyfield_set keyset)
{
        return vctrl->stats->keyfield_set_names[keyset];
}
EXPORT_SYMBOL_GPL(vcap_keyset_name);

/* map key field id to a string with the key name */
const char *vcap_keyfield_name(struct vcap_control *vctrl,
                               enum vcap_key_field key)
{
        return vctrl->stats->keyfield_names[key];
}
EXPORT_SYMBOL_GPL(vcap_keyfield_name);

/* map actionset id to a string with the actionset name */
const char *vcap_actionset_name(struct vcap_control *vctrl,
                                enum vcap_actionfield_set actionset)
{
        return vctrl->stats->actionfield_set_names[actionset];
}

/* map action field id to a string with the action name */
const char *vcap_actionfield_name(struct vcap_control *vctrl,
                                  enum vcap_action_field action)
{
        return vctrl->stats->actionfield_names[action];
}

/* Return the keyfield that matches a key in a keyset */
static const struct vcap_field *
vcap_find_keyset_keyfield(struct vcap_control *vctrl,
                          enum vcap_type vtype,
                          enum vcap_keyfield_set keyset,
                          enum vcap_key_field key)
{
        const struct vcap_field *fields;
        int idx, count;

        fields = vcap_keyfields(vctrl, vtype, keyset);
        if (!fields)
                return NULL;

        /* Iterate the keyfields of the keyset */
        count = vcap_keyfield_count(vctrl, vtype, keyset);
        for (idx = 0; idx < count; ++idx) {
                if (fields[idx].width == 0)
                        continue;

                if (key == idx)
                        return &fields[idx];
        }

        return NULL;
}

/* Match a list of keys against the keysets available in a vcap type */
static bool _vcap_rule_find_keysets(struct vcap_rule_internal *ri,
                                    struct vcap_keyset_list *matches)
{
        const struct vcap_client_keyfield *ckf;
        int keyset, found, keycount, map_size;
        const struct vcap_field **map;
        enum vcap_type vtype;

        vtype = ri->admin->vtype;
        map = ri->vctrl->vcaps[vtype].keyfield_set_map;
        map_size = ri->vctrl->vcaps[vtype].keyfield_set_size;

        /* Get a count of the keyfields we want to match */
        keycount = 0;
        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
                ++keycount;

        matches->cnt = 0;
        /* Iterate the keysets of the VCAP */
        for (keyset = 0; keyset < map_size; ++keyset) {
                if (!map[keyset])
                        continue;

                /* Iterate the keys in the rule */
                found = 0;
                list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
                        if (vcap_find_keyset_keyfield(ri->vctrl, vtype,
                                                      keyset, ckf->ctrl.key))
                                ++found;

                /* Save the keyset if all keyfields were found */
                if (found == keycount)
                        if (!vcap_keyset_list_add(matches, keyset))
                                /* bail out when the quota is filled */
                                break;
        }

        return matches->cnt > 0;
}

/* Match a list of keys against the keysets available in a vcap type */
bool vcap_rule_find_keysets(struct vcap_rule *rule,
                            struct vcap_keyset_list *matches)
{
        struct vcap_rule_internal *ri = to_intrule(rule);

        return _vcap_rule_find_keysets(ri, matches);
}
EXPORT_SYMBOL_GPL(vcap_rule_find_keysets);

/* Return the actionfield that matches a action in a actionset */
static const struct vcap_field *
vcap_find_actionset_actionfield(struct vcap_control *vctrl,
                                enum vcap_type vtype,
                                enum vcap_actionfield_set actionset,
                                enum vcap_action_field action)
{
        const struct vcap_field *fields;
        int idx, count;

        fields = vcap_actionfields(vctrl, vtype, actionset);
        if (!fields)
                return NULL;

        /* Iterate the actionfields of the actionset */
        count = vcap_actionfield_count(vctrl, vtype, actionset);
        for (idx = 0; idx < count; ++idx) {
                if (fields[idx].width == 0)
                        continue;

                if (action == idx)
                        return &fields[idx];
        }

        return NULL;
}

/* Match a list of actions against the actionsets available in a vcap type */
static bool vcap_rule_find_actionsets(struct vcap_rule_internal *ri,
                                      struct vcap_actionset_list *matches)
{
        int actionset, found, actioncount, map_size;
        const struct vcap_client_actionfield *ckf;
        const struct vcap_field **map;
        enum vcap_type vtype;

        vtype = ri->admin->vtype;
        map = ri->vctrl->vcaps[vtype].actionfield_set_map;
        map_size = ri->vctrl->vcaps[vtype].actionfield_set_size;

        /* Get a count of the actionfields we want to match */
        actioncount = 0;
        list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list)
                ++actioncount;

        matches->cnt = 0;
        /* Iterate the actionsets of the VCAP */
        for (actionset = 0; actionset < map_size; ++actionset) {
                if (!map[actionset])
                        continue;

                /* Iterate the actions in the rule */
                found = 0;
                list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list)
                        if (vcap_find_actionset_actionfield(ri->vctrl, vtype,
                                                            actionset,
                                                            ckf->ctrl.action))
                                ++found;

                /* Save the actionset if all actionfields were found */
                if (found == actioncount)
                        if (!vcap_actionset_list_add(matches, actionset))
                                /* bail out when the quota is filled */
                                break;
        }

        return matches->cnt > 0;
}

/* Validate a rule with respect to available port keys */
int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_keyset_list matches = {};
        enum vcap_keyfield_set keysets[10];
        int ret;

        ret = vcap_api_check(ri->vctrl);
        if (ret)
                return ret;
        if (!ri->admin) {
                ri->data.exterr = VCAP_ERR_NO_ADMIN;
                return -EINVAL;
        }
        if (!ri->ndev) {
                ri->data.exterr = VCAP_ERR_NO_NETDEV;
                return -EINVAL;
        }

        matches.keysets = keysets;
        matches.max = ARRAY_SIZE(keysets);
        if (ri->data.keyset == VCAP_KFS_NO_VALUE) {
                /* Iterate over rule keyfields and select keysets that fits */
                if (!_vcap_rule_find_keysets(ri, &matches)) {
                        ri->data.exterr = VCAP_ERR_NO_KEYSET_MATCH;
                        return -EINVAL;
                }
        } else {
                /* prepare for keyset validation */
                keysets[0] = ri->data.keyset;
                matches.cnt = 1;
        }

        /* Pick a keyset that is supported in the port lookups */
        ret = ri->vctrl->ops->validate_keyset(ri->ndev, ri->admin, rule,
                                              &matches, l3_proto);
        if (ret < 0) {
                pr_err("%s:%d: keyset validation failed: %d\n",
                       __func__, __LINE__, ret);
                ri->data.exterr = VCAP_ERR_NO_PORT_KEYSET_MATCH;
                return ret;
        }
        /* use the keyset that is supported in the port lookups */
        ret = vcap_set_rule_set_keyset(rule, ret);
        if (ret < 0) {
                pr_err("%s:%d: keyset was not updated: %d\n",
                       __func__, __LINE__, ret);
                return ret;
        }
        if (ri->data.actionset == VCAP_AFS_NO_VALUE) {
                struct vcap_actionset_list matches = {};
                enum vcap_actionfield_set actionsets[10];

                matches.actionsets = actionsets;
                matches.max = ARRAY_SIZE(actionsets);

                /* Find an actionset that fits the rule actions */
                if (!vcap_rule_find_actionsets(ri, &matches)) {
                        ri->data.exterr = VCAP_ERR_NO_ACTIONSET_MATCH;
                        return -EINVAL;
                }
                ret = vcap_set_rule_set_actionset(rule, actionsets[0]);
                if (ret < 0) {
                        pr_err("%s:%d: actionset was not updated: %d\n",
                               __func__, __LINE__, ret);
                        return ret;
                }
        }
        vcap_add_type_keyfield(rule);
        vcap_add_type_actionfield(rule);
        /* Add default fields to this rule */
        ri->vctrl->ops->add_default_fields(ri->ndev, ri->admin, rule);

        /* Rule size is the maximum of the entry and action subword count */
        ri->size = max(ri->keyset_sw, ri->actionset_sw);

        /* Finally check if there is room for the rule in the VCAP */
        return vcap_rule_space(ri->admin, ri->size);
}
EXPORT_SYMBOL_GPL(vcap_val_rule);

/* Entries are sorted with increasing values of sort_key.
 * I.e. Lowest numerical sort_key is first in list.
 * In order to locate largest keys first in list we negate the key size with
 * (max_size - size).
 */
static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio)
{
        return ((max_size - size) << 24) | (user << 16) | prio;
}

/* calculate the address of the next rule after this (lower address and prio) */
static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri)
{
        return ((addr - ri->size) /  ri->size) * ri->size;
}

/* Assign a unique rule id and autogenerate one if id == 0 */
static u32 vcap_set_rule_id(struct vcap_rule_internal *ri)
{
        if (ri->data.id != 0)
                return ri->data.id;

        for (u32 next_id = 1; next_id < ~0; ++next_id) {
                if (!vcap_rule_exists(ri->vctrl, next_id)) {
                        ri->data.id = next_id;
                        break;
                }
        }
        return ri->data.id;
}

static int vcap_insert_rule(struct vcap_rule_internal *ri,
                            struct vcap_rule_move *move)
{
        int sw_count = ri->vctrl->vcaps[ri->admin->vtype].sw_count;
        struct vcap_rule_internal *duprule, *iter, *elem = NULL;
        struct vcap_admin *admin = ri->admin;
        u32 addr;

        ri->sort_key = vcap_sort_key(sw_count, ri->size, ri->data.user,
                                     ri->data.priority);

        /* Insert the new rule in the list of rule based on the sort key
         * If the rule needs to be  inserted between existing rules then move
         * these rules to make room for the new rule and update their start
         * address.
         */
        list_for_each_entry(iter, &admin->rules, list) {
                if (ri->sort_key < iter->sort_key) {
                        elem = iter;
                        break;
                }
        }

        if (!elem) {
                ri->addr = vcap_next_rule_addr(admin->last_used_addr, ri);
                admin->last_used_addr = ri->addr;

                /* Add a copy of the rule to the VCAP list */
                duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
                if (IS_ERR(duprule))
                        return PTR_ERR(duprule);

                list_add_tail(&duprule->list, &admin->rules);
                return 0;
        }

        /* Reuse the space of the current rule */
        addr = elem->addr + elem->size;
        ri->addr = vcap_next_rule_addr(addr, ri);
        addr = ri->addr;

        /* Add a copy of the rule to the VCAP list */
        duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
        if (IS_ERR(duprule))
                return PTR_ERR(duprule);

        /* Add before the current entry */
        list_add_tail(&duprule->list, &elem->list);

        /* Update the current rule */
        elem->addr = vcap_next_rule_addr(addr, elem);
        addr = elem->addr;

        /* Update the address in the remaining rules in the list */
        list_for_each_entry_continue(elem, &admin->rules, list) {
                elem->addr = vcap_next_rule_addr(addr, elem);
                addr = elem->addr;
        }

        /* Update the move info */
        move->addr = admin->last_used_addr;
        move->count = ri->addr - addr;
        move->offset = admin->last_used_addr - addr;
        admin->last_used_addr = addr;
        return 0;
}

static void vcap_move_rules(struct vcap_rule_internal *ri,
                            struct vcap_rule_move *move)
{
        ri->vctrl->ops->move(ri->ndev, ri->admin, move->addr,
                         move->offset, move->count);
}

/* Check if the chain is already used to enable a VCAP lookup for this port */
static bool vcap_is_chain_used(struct vcap_control *vctrl,
                               struct net_device *ndev, int src_cid)
{
        struct vcap_enabled_port *eport;
        struct vcap_admin *admin;

        list_for_each_entry(admin, &vctrl->list, list)
                list_for_each_entry(eport, &admin->enabled, list)
                        if (eport->src_cid == src_cid && eport->ndev == ndev)
                                return true;

        return false;
}

/* Fetch the next chain in the enabled list for the port */
static int vcap_get_next_chain(struct vcap_control *vctrl,
                               struct net_device *ndev,
                               int dst_cid)
{
        struct vcap_enabled_port *eport;
        struct vcap_admin *admin;

        list_for_each_entry(admin, &vctrl->list, list) {
                list_for_each_entry(eport, &admin->enabled, list) {
                        if (eport->ndev != ndev)
                                continue;
                        if (eport->src_cid == dst_cid)
                                return eport->dst_cid;
                }
        }

        return 0;
}

static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev,
                            int dst_cid)
{
        int cid = rounddown(dst_cid, VCAP_CID_LOOKUP_SIZE);
        struct vcap_enabled_port *eport = NULL;
        struct vcap_enabled_port *elem;
        struct vcap_admin *admin;
        int tmp;

        if (cid == 0) /* Chain zero is always available */
                return true;

        /* Find first entry that starts from chain 0*/
        list_for_each_entry(admin, &vctrl->list, list) {
                list_for_each_entry(elem, &admin->enabled, list) {
                        if (elem->src_cid == 0 && elem->ndev == ndev) {
                                eport = elem;
                                break;
                        }
                }
                if (eport)
                        break;
        }

        if (!eport)
                return false;

        tmp = eport->dst_cid;
        while (tmp != cid && tmp != 0)
                tmp = vcap_get_next_chain(vctrl, ndev, tmp);

        return !!tmp;
}

/* Internal clients can always store their rules in HW
 * External clients can store their rules if the chain is enabled all
 * the way from chain 0, otherwise the rule will be cached until
 * the chain is enabled.
 */
static void vcap_rule_set_state(struct vcap_rule_internal *ri)
{
        if (ri->data.user <= VCAP_USER_QOS)
                ri->state = VCAP_RS_PERMANENT;
        else if (vcap_path_exist(ri->vctrl, ri->ndev, ri->data.vcap_chain_id))
                ri->state = VCAP_RS_ENABLED;
        else
                ri->state = VCAP_RS_DISABLED;
}

/* Encode and write a validated rule to the VCAP */
int vcap_add_rule(struct vcap_rule *rule)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_rule_move move = {0};
        struct vcap_counter ctr = {0};
        int ret;

        ret = vcap_api_check(ri->vctrl);
        if (ret)
                return ret;
        /* Insert the new rule in the list of vcap rules */
        mutex_lock(&ri->admin->lock);

        vcap_rule_set_state(ri);
        ret = vcap_insert_rule(ri, &move);
        if (ret < 0) {
                pr_err("%s:%d: could not insert rule in vcap list: %d\n",
                       __func__, __LINE__, ret);
                goto out;
        }
        if (move.count > 0)
                vcap_move_rules(ri, &move);

        /* Set the counter to zero */
        ret = vcap_write_counter(ri, &ctr);
        if (ret)
                goto out;

        if (ri->state == VCAP_RS_DISABLED) {
                /* Erase the rule area */
                ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size);
                goto out;
        }

        vcap_erase_cache(ri);
        ret = vcap_encode_rule(ri);
        if (ret) {
                pr_err("%s:%d: rule encoding error: %d\n", __func__, __LINE__, ret);
                goto out;
        }

        ret = vcap_write_rule(ri);
        if (ret) {
                pr_err("%s:%d: rule write error: %d\n", __func__, __LINE__, ret);
                goto out;
        }
out:
        mutex_unlock(&ri->admin->lock);
        return ret;
}
EXPORT_SYMBOL_GPL(vcap_add_rule);

/* Allocate a new rule with the provided arguments */
struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl,
                                  struct net_device *ndev, int vcap_chain_id,
                                  enum vcap_user user, u16 priority,
                                  u32 id)
{
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;
        int err, maxsize;

        err = vcap_api_check(vctrl);
        if (err)
                return ERR_PTR(err);
        if (!ndev)
                return ERR_PTR(-ENODEV);
        /* Get the VCAP instance */
        admin = vcap_find_admin(vctrl, vcap_chain_id);
        if (!admin)
                return ERR_PTR(-ENOENT);
        /* Sanity check that this VCAP is supported on this platform */
        if (vctrl->vcaps[admin->vtype].rows == 0)
                return ERR_PTR(-EINVAL);

        mutex_lock(&admin->lock);
        /* Check if a rule with this id already exists */
        if (vcap_rule_exists(vctrl, id)) {
                err = -EINVAL;
                goto out_unlock;
        }

        /* Check if there is room for the rule in the block(s) of the VCAP */
        maxsize = vctrl->vcaps[admin->vtype].sw_count; /* worst case rule size */
        if (vcap_rule_space(admin, maxsize)) {
                err = -ENOSPC;
                goto out_unlock;
        }

        /* Create a container for the rule and return it */
        ri = kzalloc_obj(*ri);
        if (!ri) {
                err = -ENOMEM;
                goto out_unlock;
        }

        ri->data.vcap_chain_id = vcap_chain_id;
        ri->data.user = user;
        ri->data.priority = priority;
        ri->data.id = id;
        ri->data.keyset = VCAP_KFS_NO_VALUE;
        ri->data.actionset = VCAP_AFS_NO_VALUE;
        INIT_LIST_HEAD(&ri->list);
        INIT_LIST_HEAD(&ri->data.keyfields);
        INIT_LIST_HEAD(&ri->data.actionfields);
        ri->ndev = ndev;
        ri->admin = admin; /* refer to the vcap instance */
        ri->vctrl = vctrl; /* refer to the client */

        if (vcap_set_rule_id(ri) == 0) {
                err = -EINVAL;
                goto out_free;
        }

        mutex_unlock(&admin->lock);
        return (struct vcap_rule *)ri;

out_free:
        kfree(ri);
out_unlock:
        mutex_unlock(&admin->lock);
        return ERR_PTR(err);

}
EXPORT_SYMBOL_GPL(vcap_alloc_rule);

/* Free mem of a rule owned by client after the rule as been added to the VCAP */
void vcap_free_rule(struct vcap_rule *rule)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_actionfield *caf, *next_caf;
        struct vcap_client_keyfield *ckf, *next_ckf;

        /* Deallocate the list of keys and actions */
        list_for_each_entry_safe(ckf, next_ckf, &ri->data.keyfields, ctrl.list) {
                list_del(&ckf->ctrl.list);
                kfree(ckf);
        }
        list_for_each_entry_safe(caf, next_caf, &ri->data.actionfields, ctrl.list) {
                list_del(&caf->ctrl.list);
                kfree(caf);
        }
        /* Deallocate the rule */
        kfree(rule);
}
EXPORT_SYMBOL_GPL(vcap_free_rule);

/* Decode a rule from the VCAP cache and return a copy */
struct vcap_rule *vcap_decode_rule(struct vcap_rule_internal *elem)
{
        struct vcap_rule_internal *ri;
        int err;

        ri = vcap_dup_rule(elem, elem->state == VCAP_RS_DISABLED);
        if (IS_ERR(ri))
                return ERR_CAST(ri);

        if (ri->state == VCAP_RS_DISABLED)
                goto out;

        err = vcap_read_rule(ri);
        if (err)
                return ERR_PTR(err);

        err = vcap_decode_keyset(ri);
        if (err)
                return ERR_PTR(err);

        err = vcap_decode_actionset(ri);
        if (err)
                return ERR_PTR(err);

out:
        return &ri->data;
}

struct vcap_rule *vcap_get_rule(struct vcap_control *vctrl, u32 id)
{
        struct vcap_rule_internal *elem;
        struct vcap_rule *rule;
        int err;

        err = vcap_api_check(vctrl);
        if (err)
                return ERR_PTR(err);

        elem = vcap_get_locked_rule(vctrl, id);
        if (!elem)
                return ERR_PTR(-ENOENT);

        rule = vcap_decode_rule(elem);
        mutex_unlock(&elem->admin->lock);
        return rule;
}
EXPORT_SYMBOL_GPL(vcap_get_rule);

/* Update existing rule */
int vcap_mod_rule(struct vcap_rule *rule)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_counter ctr;
        int err;

        err = vcap_api_check(ri->vctrl);
        if (err)
                return err;

        if (!vcap_get_locked_rule(ri->vctrl, ri->data.id))
                return -ENOENT;

        vcap_rule_set_state(ri);
        if (ri->state == VCAP_RS_DISABLED)
                goto out;

        /* Encode the bitstreams to the VCAP cache */
        vcap_erase_cache(ri);
        err = vcap_encode_rule(ri);
        if (err)
                goto out;

        err = vcap_write_rule(ri);
        if (err)
                goto out;

        memset(&ctr, 0, sizeof(ctr));
        err =  vcap_write_counter(ri, &ctr);

out:
        mutex_unlock(&ri->admin->lock);
        return err;
}
EXPORT_SYMBOL_GPL(vcap_mod_rule);

/* Return the alignment offset for a new rule address */
static int vcap_valid_rule_move(struct vcap_rule_internal *el, int offset)
{
        return (el->addr + offset) % el->size;
}

/* Update the rule address with an offset */
static void vcap_adjust_rule_addr(struct vcap_rule_internal *el, int offset)
{
        el->addr += offset;
}

/* Rules needs to be moved to fill the gap of the deleted rule */
static int vcap_fill_rule_gap(struct vcap_rule_internal *ri)
{
        struct vcap_admin *admin = ri->admin;
        struct vcap_rule_internal *elem;
        struct vcap_rule_move move;
        int gap = 0, offset = 0;

        /* If the first rule is deleted: Move other rules to the top */
        if (list_is_first(&ri->list, &admin->rules))
                offset = admin->last_valid_addr + 1 - ri->addr - ri->size;

        /* Locate gaps between odd size rules and adjust the move */
        elem = ri;
        list_for_each_entry_continue(elem, &admin->rules, list)
                gap += vcap_valid_rule_move(elem, ri->size);

        /* Update the address in the remaining rules in the list */
        elem = ri;
        list_for_each_entry_continue(elem, &admin->rules, list)
                vcap_adjust_rule_addr(elem, ri->size + gap + offset);

        /* Update the move info */
        move.addr = admin->last_used_addr;
        move.count = ri->addr - admin->last_used_addr - gap;
        move.offset = -(ri->size + gap + offset);

        /* Do the actual move operation */
        vcap_move_rules(ri, &move);

        return gap + offset;
}

/* Delete rule in a VCAP instance */
int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id)
{
        struct vcap_rule_internal *ri, *elem;
        struct vcap_admin *admin;
        int gap = 0, err;

        /* This will later also handle rule moving */
        if (!ndev)
                return -ENODEV;
        err = vcap_api_check(vctrl);
        if (err)
                return err;
        /* Look for the rule id in all vcaps */
        ri = vcap_get_locked_rule(vctrl, id);
        if (!ri)
                return -ENOENT;

        admin = ri->admin;

        if (ri->addr > admin->last_used_addr)
                gap = vcap_fill_rule_gap(ri);

        /* Delete the rule from the list of rules and the cache */
        list_del(&ri->list);
        vctrl->ops->init(ndev, admin, admin->last_used_addr, ri->size + gap);
        vcap_free_rule(&ri->data);

        /* Update the last used address, set to default when no rules */
        if (list_empty(&admin->rules)) {
                admin->last_used_addr = admin->last_valid_addr + 1;
        } else {
                elem = list_last_entry(&admin->rules, struct vcap_rule_internal,
                                       list);
                admin->last_used_addr = elem->addr;
        }

        mutex_unlock(&admin->lock);
        return err;
}
EXPORT_SYMBOL_GPL(vcap_del_rule);

/* Delete all rules in the VCAP instance */
int vcap_del_rules(struct vcap_control *vctrl, struct vcap_admin *admin)
{
        struct vcap_enabled_port *eport, *next_eport;
        struct vcap_rule_internal *ri, *next_ri;
        int ret = vcap_api_check(vctrl);

        if (ret)
                return ret;

        mutex_lock(&admin->lock);
        list_for_each_entry_safe(ri, next_ri, &admin->rules, list) {
                vctrl->ops->init(ri->ndev, admin, ri->addr, ri->size);
                list_del(&ri->list);
                vcap_free_rule(&ri->data);
        }
        admin->last_used_addr = admin->last_valid_addr;

        /* Remove list of enabled ports */
        list_for_each_entry_safe(eport, next_eport, &admin->enabled, list) {
                list_del(&eport->list);
                kfree(eport);
        }
        mutex_unlock(&admin->lock);

        return 0;
}
EXPORT_SYMBOL_GPL(vcap_del_rules);

/* Find a client key field in a rule */
static struct vcap_client_keyfield *
vcap_find_keyfield(struct vcap_rule *rule, enum vcap_key_field key)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_keyfield *ckf;

        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
                if (ckf->ctrl.key == key)
                        return ckf;
        return NULL;
}

/* Find information on a key field in a rule */
const struct vcap_field *vcap_lookup_keyfield(struct vcap_rule *rule,
                                              enum vcap_key_field key)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        enum vcap_keyfield_set keyset = rule->keyset;
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_field *fields;

        if (keyset == VCAP_KFS_NO_VALUE)
                return NULL;
        fields = vcap_keyfields(ri->vctrl, vt, keyset);
        if (!fields)
                return NULL;
        return &fields[key];
}
EXPORT_SYMBOL_GPL(vcap_lookup_keyfield);

/* Check if the keyfield is already in the rule */
static bool vcap_keyfield_unique(struct vcap_rule *rule,
                                 enum vcap_key_field key)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_client_keyfield *ckf;

        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
                if (ckf->ctrl.key == key)
                        return false;
        return true;
}

/* Check if the keyfield is in the keyset */
static bool vcap_keyfield_match_keyset(struct vcap_rule *rule,
                                       enum vcap_key_field key)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        enum vcap_keyfield_set keyset = rule->keyset;
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_field *fields;

        /* the field is accepted if the rule has no keyset yet */
        if (keyset == VCAP_KFS_NO_VALUE)
                return true;
        fields = vcap_keyfields(ri->vctrl, vt, keyset);
        if (!fields)
                return false;
        /* if there is a width there is a way */
        return fields[key].width > 0;
}

static int vcap_rule_add_key(struct vcap_rule *rule,
                             enum vcap_key_field key,
                             enum vcap_field_type ftype,
                             struct vcap_client_keyfield_data *data)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_keyfield *field;

        if (!vcap_keyfield_unique(rule, key)) {
                pr_warn("%s:%d: keyfield %s is already in the rule\n",
                        __func__, __LINE__,
                        vcap_keyfield_name(ri->vctrl, key));
                return -EINVAL;
        }

        if (!vcap_keyfield_match_keyset(rule, key)) {
                pr_err("%s:%d: keyfield %s does not belong in the rule keyset\n",
                       __func__, __LINE__,
                       vcap_keyfield_name(ri->vctrl, key));
                return -EINVAL;
        }

        field = kzalloc_obj(*field);
        if (!field)
                return -ENOMEM;
        memcpy(&field->data, data, sizeof(field->data));
        field->ctrl.key = key;
        field->ctrl.type = ftype;
        list_add_tail(&field->ctrl.list, &rule->keyfields);
        return 0;
}

static void vcap_rule_set_key_bitsize(struct vcap_u1_key *u1, enum vcap_bit val)
{
        switch (val) {
        case VCAP_BIT_0:
                u1->value = 0;
                u1->mask = 1;
                break;
        case VCAP_BIT_1:
                u1->value = 1;
                u1->mask = 1;
                break;
        case VCAP_BIT_ANY:
                u1->value = 0;
                u1->mask = 0;
                break;
        }
}

/* Add a bit key with value and mask to the rule */
int vcap_rule_add_key_bit(struct vcap_rule *rule, enum vcap_key_field key,
                          enum vcap_bit val)
{
        struct vcap_client_keyfield_data data;

        vcap_rule_set_key_bitsize(&data.u1, val);
        return vcap_rule_add_key(rule, key, VCAP_FIELD_BIT, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_key_bit);

/* Add a 32 bit key field with value and mask to the rule */
int vcap_rule_add_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
                          u32 value, u32 mask)
{
        struct vcap_client_keyfield_data data;

        data.u32.value = value;
        data.u32.mask = mask;
        return vcap_rule_add_key(rule, key, VCAP_FIELD_U32, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_key_u32);

/* Add a 48 bit key with value and mask to the rule */
int vcap_rule_add_key_u48(struct vcap_rule *rule, enum vcap_key_field key,
                          struct vcap_u48_key *fieldval)
{
        struct vcap_client_keyfield_data data;

        memcpy(&data.u48, fieldval, sizeof(data.u48));
        return vcap_rule_add_key(rule, key, VCAP_FIELD_U48, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_key_u48);

/* Add a 72 bit key with value and mask to the rule */
int vcap_rule_add_key_u72(struct vcap_rule *rule, enum vcap_key_field key,
                          struct vcap_u72_key *fieldval)
{
        struct vcap_client_keyfield_data data;

        memcpy(&data.u72, fieldval, sizeof(data.u72));
        return vcap_rule_add_key(rule, key, VCAP_FIELD_U72, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_key_u72);

/* Add a 128 bit key with value and mask to the rule */
int vcap_rule_add_key_u128(struct vcap_rule *rule, enum vcap_key_field key,
                           struct vcap_u128_key *fieldval)
{
        struct vcap_client_keyfield_data data;

        memcpy(&data.u128, fieldval, sizeof(data.u128));
        return vcap_rule_add_key(rule, key, VCAP_FIELD_U128, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_key_u128);

int vcap_rule_get_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
                          u32 *value, u32 *mask)
{
        struct vcap_client_keyfield *ckf;

        ckf = vcap_find_keyfield(rule, key);
        if (!ckf)
                return -ENOENT;

        *value = ckf->data.u32.value;
        *mask = ckf->data.u32.mask;

        return 0;
}
EXPORT_SYMBOL_GPL(vcap_rule_get_key_u32);

/* Find a client action field in a rule */
struct vcap_client_actionfield *
vcap_find_actionfield(struct vcap_rule *rule, enum vcap_action_field act)
{
        struct vcap_rule_internal *ri = (struct vcap_rule_internal *)rule;
        struct vcap_client_actionfield *caf;

        list_for_each_entry(caf, &ri->data.actionfields, ctrl.list)
                if (caf->ctrl.action == act)
                        return caf;
        return NULL;
}
EXPORT_SYMBOL_GPL(vcap_find_actionfield);

/* Check if the actionfield is already in the rule */
static bool vcap_actionfield_unique(struct vcap_rule *rule,
                                    enum vcap_action_field act)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        const struct vcap_client_actionfield *caf;

        list_for_each_entry(caf, &ri->data.actionfields, ctrl.list)
                if (caf->ctrl.action == act)
                        return false;
        return true;
}

/* Check if the actionfield is in the actionset */
static bool vcap_actionfield_match_actionset(struct vcap_rule *rule,
                                             enum vcap_action_field action)
{
        enum vcap_actionfield_set actionset = rule->actionset;
        struct vcap_rule_internal *ri = to_intrule(rule);
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_field *fields;

        /* the field is accepted if the rule has no actionset yet */
        if (actionset == VCAP_AFS_NO_VALUE)
                return true;
        fields = vcap_actionfields(ri->vctrl, vt, actionset);
        if (!fields)
                return false;
        /* if there is a width there is a way */
        return fields[action].width > 0;
}

static int vcap_rule_add_action(struct vcap_rule *rule,
                                enum vcap_action_field action,
                                enum vcap_field_type ftype,
                                struct vcap_client_actionfield_data *data)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_actionfield *field;

        if (!vcap_actionfield_unique(rule, action)) {
                pr_warn("%s:%d: actionfield %s is already in the rule\n",
                        __func__, __LINE__,
                        vcap_actionfield_name(ri->vctrl, action));
                return -EINVAL;
        }

        if (!vcap_actionfield_match_actionset(rule, action)) {
                pr_err("%s:%d: actionfield %s does not belong in the rule actionset\n",
                       __func__, __LINE__,
                       vcap_actionfield_name(ri->vctrl, action));
                return -EINVAL;
        }

        field = kzalloc_obj(*field);
        if (!field)
                return -ENOMEM;
        memcpy(&field->data, data, sizeof(field->data));
        field->ctrl.action = action;
        field->ctrl.type = ftype;
        list_add_tail(&field->ctrl.list, &rule->actionfields);
        return 0;
}

static void vcap_rule_set_action_bitsize(struct vcap_u1_action *u1,
                                         enum vcap_bit val)
{
        switch (val) {
        case VCAP_BIT_0:
                u1->value = 0;
                break;
        case VCAP_BIT_1:
                u1->value = 1;
                break;
        case VCAP_BIT_ANY:
                u1->value = 0;
                break;
        }
}

/* Add a bit action with value to the rule */
int vcap_rule_add_action_bit(struct vcap_rule *rule,
                             enum vcap_action_field action,
                             enum vcap_bit val)
{
        struct vcap_client_actionfield_data data;

        vcap_rule_set_action_bitsize(&data.u1, val);
        return vcap_rule_add_action(rule, action, VCAP_FIELD_BIT, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_action_bit);

/* Add a 32 bit action field with value to the rule */
int vcap_rule_add_action_u32(struct vcap_rule *rule,
                             enum vcap_action_field action,
                             u32 value)
{
        struct vcap_client_actionfield_data data;

        data.u32.value = value;
        return vcap_rule_add_action(rule, action, VCAP_FIELD_U32, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_action_u32);

/* Add a 72 bit action field with value to the rule */
int vcap_rule_add_action_u72(struct vcap_rule *rule,
                             enum vcap_action_field action,
                             struct vcap_u72_action *fieldval)
{
        struct vcap_client_actionfield_data data;

        memcpy(&data.u72, fieldval, sizeof(data.u72));
        return vcap_rule_add_action(rule, action, VCAP_FIELD_U72, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_add_action_u72);

static int vcap_read_counter(struct vcap_rule_internal *ri,
                             struct vcap_counter *ctr)
{
        struct vcap_admin *admin = ri->admin;

        ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ, VCAP_SEL_COUNTER,
                               ri->addr);
        ri->vctrl->ops->cache_read(ri->ndev, admin, VCAP_SEL_COUNTER,
                                   ri->counter_id, 0);
        ctr->value = admin->cache.counter;
        ctr->sticky = admin->cache.sticky;
        return 0;
}

/* Copy to host byte order */
void vcap_netbytes_copy(u8 *dst, u8 *src, int count)
{
        int idx;

        for (idx = 0; idx < count; ++idx, ++dst)
                *dst = src[count - idx - 1];
}
EXPORT_SYMBOL_GPL(vcap_netbytes_copy);

/* Convert validation error code into tc extack error message */
void vcap_set_tc_exterr(struct flow_cls_offload *fco, struct vcap_rule *vrule)
{
        switch (vrule->exterr) {
        case VCAP_ERR_NONE:
                break;
        case VCAP_ERR_NO_ADMIN:
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "Missing VCAP instance");
                break;
        case VCAP_ERR_NO_NETDEV:
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "Missing network interface");
                break;
        case VCAP_ERR_NO_KEYSET_MATCH:
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "No keyset matched the filter keys");
                break;
        case VCAP_ERR_NO_ACTIONSET_MATCH:
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "No actionset matched the filter actions");
                break;
        case VCAP_ERR_NO_PORT_KEYSET_MATCH:
                NL_SET_ERR_MSG_MOD(fco->common.extack,
                                   "No port keyset matched the filter keys");
                break;
        }
}
EXPORT_SYMBOL_GPL(vcap_set_tc_exterr);

/* Write a rule to VCAP HW to enable it */
static int vcap_enable_rule(struct vcap_rule_internal *ri)
{
        struct vcap_client_actionfield *af, *naf;
        struct vcap_client_keyfield *kf, *nkf;
        int err;

        vcap_erase_cache(ri);
        err = vcap_encode_rule(ri);
        if (err)
                goto out;
        err = vcap_write_rule(ri);
        if (err)
                goto out;

        /* Deallocate the list of keys and actions */
        list_for_each_entry_safe(kf, nkf, &ri->data.keyfields, ctrl.list) {
                list_del(&kf->ctrl.list);
                kfree(kf);
        }
        list_for_each_entry_safe(af, naf, &ri->data.actionfields, ctrl.list) {
                list_del(&af->ctrl.list);
                kfree(af);
        }
        ri->state = VCAP_RS_ENABLED;
out:
        return err;
}

/* Enable all disabled rules for a specific chain/port in the VCAP HW */
static int vcap_enable_rules(struct vcap_control *vctrl,
                             struct net_device *ndev, int chain)
{
        int next_chain = chain + VCAP_CID_LOOKUP_SIZE;
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;
        int err = 0;

        list_for_each_entry(admin, &vctrl->list, list) {
                if (!(chain >= admin->first_cid && chain <= admin->last_cid))
                        continue;

                /* Found the admin, now find the offloadable rules */
                mutex_lock(&admin->lock);
                list_for_each_entry(ri, &admin->rules, list) {
                        /* Is the rule in the lookup defined by the chain */
                        if (!(ri->data.vcap_chain_id >= chain &&
                              ri->data.vcap_chain_id < next_chain)) {
                                continue;
                        }

                        if (ri->ndev != ndev)
                                continue;

                        if (ri->state != VCAP_RS_DISABLED)
                                continue;

                        err = vcap_enable_rule(ri);
                        if (err)
                                break;
                }
                mutex_unlock(&admin->lock);
                if (err)
                        break;
        }
        return err;
}

/* Read and erase a rule from VCAP HW to disable it */
static int vcap_disable_rule(struct vcap_rule_internal *ri)
{
        int err;

        err = vcap_read_rule(ri);
        if (err)
                return err;
        err = vcap_decode_keyset(ri);
        if (err)
                return err;
        err = vcap_decode_actionset(ri);
        if (err)
                return err;

        ri->state = VCAP_RS_DISABLED;
        ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size);
        return 0;
}

/* Disable all enabled rules for a specific chain/port in the VCAP HW */
static int vcap_disable_rules(struct vcap_control *vctrl,
                              struct net_device *ndev, int chain)
{
        struct vcap_rule_internal *ri;
        struct vcap_admin *admin;
        int err = 0;

        list_for_each_entry(admin, &vctrl->list, list) {
                if (!(chain >= admin->first_cid && chain <= admin->last_cid))
                        continue;

                /* Found the admin, now find the rules on the chain */
                mutex_lock(&admin->lock);
                list_for_each_entry(ri, &admin->rules, list) {
                        if (ri->data.vcap_chain_id != chain)
                                continue;

                        if (ri->ndev != ndev)
                                continue;

                        if (ri->state != VCAP_RS_ENABLED)
                                continue;

                        err = vcap_disable_rule(ri);
                        if (err)
                                break;
                }
                mutex_unlock(&admin->lock);
                if (err)
                        break;
        }
        return err;
}

/* Check if this port is already enabled for this VCAP instance */
static bool vcap_is_enabled(struct vcap_control *vctrl, struct net_device *ndev,
                            int dst_cid)
{
        struct vcap_enabled_port *eport;
        struct vcap_admin *admin;

        list_for_each_entry(admin, &vctrl->list, list)
                list_for_each_entry(eport, &admin->enabled, list)
                        if (eport->dst_cid == dst_cid && eport->ndev == ndev)
                                return true;

        return false;
}

/* Enable this port and chain id in a VCAP instance */
static int vcap_enable(struct vcap_control *vctrl, struct net_device *ndev,
                       unsigned long cookie, int src_cid, int dst_cid)
{
        struct vcap_enabled_port *eport;
        struct vcap_admin *admin;

        if (src_cid >= dst_cid)
                return -EFAULT;

        admin = vcap_find_admin(vctrl, dst_cid);
        if (!admin)
                return -ENOENT;

        eport = kzalloc_obj(*eport);
        if (!eport)
                return -ENOMEM;

        eport->ndev = ndev;
        eport->cookie = cookie;
        eport->src_cid = src_cid;
        eport->dst_cid = dst_cid;
        mutex_lock(&admin->lock);
        list_add_tail(&eport->list, &admin->enabled);
        mutex_unlock(&admin->lock);

        if (vcap_path_exist(vctrl, ndev, src_cid)) {
                /* Enable chained lookups */
                while (dst_cid) {
                        admin = vcap_find_admin(vctrl, dst_cid);
                        if (!admin)
                                return -ENOENT;

                        vcap_enable_rules(vctrl, ndev, dst_cid);
                        dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid);
                }
        }
        return 0;
}

/* Disable this port and chain id for a VCAP instance */
static int vcap_disable(struct vcap_control *vctrl, struct net_device *ndev,
                        unsigned long cookie)
{
        struct vcap_enabled_port *elem, *eport = NULL;
        struct vcap_admin *found = NULL, *admin;
        int dst_cid;

        list_for_each_entry(admin, &vctrl->list, list) {
                list_for_each_entry(elem, &admin->enabled, list) {
                        if (elem->cookie == cookie && elem->ndev == ndev) {
                                eport = elem;
                                found = admin;
                                break;
                        }
                }
                if (eport)
                        break;
        }

        if (!eport)
                return -ENOENT;

        /* Disable chained lookups */
        dst_cid = eport->dst_cid;
        while (dst_cid) {
                admin = vcap_find_admin(vctrl, dst_cid);
                if (!admin)
                        return -ENOENT;

                vcap_disable_rules(vctrl, ndev, dst_cid);
                dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid);
        }

        mutex_lock(&found->lock);
        list_del(&eport->list);
        mutex_unlock(&found->lock);
        kfree(eport);
        return 0;
}

/* Enable/Disable the VCAP instance lookups */
int vcap_enable_lookups(struct vcap_control *vctrl, struct net_device *ndev,
                        int src_cid, int dst_cid, unsigned long cookie,
                        bool enable)
{
        int err;

        err = vcap_api_check(vctrl);
        if (err)
                return err;

        if (!ndev)
                return -ENODEV;

        /* Source and destination must be the first chain in a lookup */
        if (src_cid % VCAP_CID_LOOKUP_SIZE)
                return -EFAULT;
        if (dst_cid % VCAP_CID_LOOKUP_SIZE)
                return -EFAULT;

        if (enable) {
                if (vcap_is_enabled(vctrl, ndev, dst_cid))
                        return -EADDRINUSE;
                if (vcap_is_chain_used(vctrl, ndev, src_cid))
                        return -EADDRNOTAVAIL;
                err = vcap_enable(vctrl, ndev, cookie, src_cid, dst_cid);
        } else {
                err = vcap_disable(vctrl, ndev, cookie);
        }

        return err;
}
EXPORT_SYMBOL_GPL(vcap_enable_lookups);

/* Is this chain id the last lookup of all VCAPs */
bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress)
{
        struct vcap_admin *admin;
        int lookup;

        if (vcap_api_check(vctrl))
                return false;

        admin = vcap_find_admin(vctrl, cid);
        if (!admin)
                return false;

        if (!vcap_admin_is_last(vctrl, admin, ingress))
                return false;

        /* This must be the last lookup in this VCAP type */
        lookup = vcap_chain_id_to_lookup(admin, cid);
        return lookup == admin->lookups - 1;
}
EXPORT_SYMBOL_GPL(vcap_is_last_chain);

/* Set a rule counter id (for certain vcaps only) */
void vcap_rule_set_counter_id(struct vcap_rule *rule, u32 counter_id)
{
        struct vcap_rule_internal *ri = to_intrule(rule);

        ri->counter_id = counter_id;
}
EXPORT_SYMBOL_GPL(vcap_rule_set_counter_id);

int vcap_rule_set_counter(struct vcap_rule *rule, struct vcap_counter *ctr)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        int err;

        err = vcap_api_check(ri->vctrl);
        if (err)
                return err;
        if (!ctr) {
                pr_err("%s:%d: counter is missing\n", __func__, __LINE__);
                return -EINVAL;
        }

        mutex_lock(&ri->admin->lock);
        err = vcap_write_counter(ri, ctr);
        mutex_unlock(&ri->admin->lock);

        return err;
}
EXPORT_SYMBOL_GPL(vcap_rule_set_counter);

int vcap_rule_get_counter(struct vcap_rule *rule, struct vcap_counter *ctr)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        int err;

        err = vcap_api_check(ri->vctrl);
        if (err)
                return err;
        if (!ctr) {
                pr_err("%s:%d: counter is missing\n", __func__, __LINE__);
                return -EINVAL;
        }

        mutex_lock(&ri->admin->lock);
        err = vcap_read_counter(ri, ctr);
        mutex_unlock(&ri->admin->lock);

        return err;
}
EXPORT_SYMBOL_GPL(vcap_rule_get_counter);

/* Get a copy of a client key field */
static int vcap_rule_get_key(struct vcap_rule *rule,
                             enum vcap_key_field key,
                             struct vcap_client_keyfield *ckf)
{
        struct vcap_client_keyfield *field;

        field = vcap_find_keyfield(rule, key);
        if (!field)
                return -EINVAL;
        memcpy(ckf, field, sizeof(*ckf));
        INIT_LIST_HEAD(&ckf->ctrl.list);
        return 0;
}

/* Find a keyset having the same size as the provided rule, where the keyset
 * does not have a type id.
 */
static int vcap_rule_get_untyped_keyset(struct vcap_rule_internal *ri,
                                        struct vcap_keyset_list *matches)
{
        struct vcap_control *vctrl = ri->vctrl;
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_set *keyfield_set;
        int idx;

        keyfield_set = vctrl->vcaps[vt].keyfield_set;
        for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
                if (keyfield_set[idx].sw_per_item == ri->keyset_sw &&
                    keyfield_set[idx].type_id == (u8)-1) {
                        vcap_keyset_list_add(matches, idx);
                        return 0;
                }
        }
        return -EINVAL;
}

/* Get the keysets that matches the rule key type/mask */
int vcap_rule_get_keysets(struct vcap_rule_internal *ri,
                          struct vcap_keyset_list *matches)
{
        struct vcap_control *vctrl = ri->vctrl;
        enum vcap_type vt = ri->admin->vtype;
        const struct vcap_set *keyfield_set;
        struct vcap_client_keyfield kf = {};
        u32 value, mask;
        int err, idx;

        err = vcap_rule_get_key(&ri->data, VCAP_KF_TYPE, &kf);
        if (err)
                return vcap_rule_get_untyped_keyset(ri, matches);

        if (kf.ctrl.type == VCAP_FIELD_BIT) {
                value = kf.data.u1.value;
                mask = kf.data.u1.mask;
        } else if (kf.ctrl.type == VCAP_FIELD_U32) {
                value = kf.data.u32.value;
                mask = kf.data.u32.mask;
        } else {
                return -EINVAL;
        }

        keyfield_set = vctrl->vcaps[vt].keyfield_set;
        for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
                if (keyfield_set[idx].sw_per_item != ri->keyset_sw)
                        continue;

                if (keyfield_set[idx].type_id == (u8)-1) {
                        vcap_keyset_list_add(matches, idx);
                        continue;
                }

                if ((keyfield_set[idx].type_id & mask) == value)
                        vcap_keyset_list_add(matches, idx);
        }
        if (matches->cnt > 0)
                return 0;

        return -EINVAL;
}

/* Collect packet counts from all rules with the same cookie */
int vcap_get_rule_count_by_cookie(struct vcap_control *vctrl,
                                  struct vcap_counter *ctr, u64 cookie)
{
        struct vcap_rule_internal *ri;
        struct vcap_counter temp = {};
        struct vcap_admin *admin;
        int err;

        err = vcap_api_check(vctrl);
        if (err)
                return err;

        /* Iterate all rules in each VCAP instance */
        list_for_each_entry(admin, &vctrl->list, list) {
                mutex_lock(&admin->lock);
                list_for_each_entry(ri, &admin->rules, list) {
                        if (ri->data.cookie != cookie)
                                continue;

                        err = vcap_read_counter(ri, &temp);
                        if (err)
                                goto unlock;
                        ctr->value += temp.value;

                        /* Reset the rule counter */
                        temp.value = 0;
                        temp.sticky = 0;
                        err = vcap_write_counter(ri, &temp);
                        if (err)
                                goto unlock;
                }
                mutex_unlock(&admin->lock);
        }
        return err;

unlock:
        mutex_unlock(&admin->lock);
        return err;
}
EXPORT_SYMBOL_GPL(vcap_get_rule_count_by_cookie);

static int vcap_rule_mod_key(struct vcap_rule *rule,
                             enum vcap_key_field key,
                             enum vcap_field_type ftype,
                             struct vcap_client_keyfield_data *data)
{
        struct vcap_client_keyfield *field;

        field = vcap_find_keyfield(rule, key);
        if (!field)
                return vcap_rule_add_key(rule, key, ftype, data);
        memcpy(&field->data, data, sizeof(field->data));
        return 0;
}

/* Modify a 32 bit key field with value and mask in the rule */
int vcap_rule_mod_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
                          u32 value, u32 mask)
{
        struct vcap_client_keyfield_data data;

        data.u32.value = value;
        data.u32.mask = mask;
        return vcap_rule_mod_key(rule, key, VCAP_FIELD_U32, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_mod_key_u32);

/* Remove a key field with value and mask in the rule */
int vcap_rule_rem_key(struct vcap_rule *rule, enum vcap_key_field key)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_keyfield *field;

        field = vcap_find_keyfield(rule, key);
        if (!field) {
                pr_err("%s:%d: key %s is not in the rule\n",
                       __func__, __LINE__, vcap_keyfield_name(ri->vctrl, key));
                return -EINVAL;
        }
        /* Deallocate the key field */
        list_del(&field->ctrl.list);
        kfree(field);
        return 0;
}
EXPORT_SYMBOL_GPL(vcap_rule_rem_key);

static int vcap_rule_mod_action(struct vcap_rule *rule,
                                enum vcap_action_field action,
                                enum vcap_field_type ftype,
                                struct vcap_client_actionfield_data *data)
{
        struct vcap_client_actionfield *field;

        field = vcap_find_actionfield(rule, action);
        if (!field)
                return vcap_rule_add_action(rule, action, ftype, data);
        memcpy(&field->data, data, sizeof(field->data));
        return 0;
}

/* Modify a 32 bit action field with value in the rule */
int vcap_rule_mod_action_u32(struct vcap_rule *rule,
                             enum vcap_action_field action,
                             u32 value)
{
        struct vcap_client_actionfield_data data;

        data.u32.value = value;
        return vcap_rule_mod_action(rule, action, VCAP_FIELD_U32, &data);
}
EXPORT_SYMBOL_GPL(vcap_rule_mod_action_u32);

/* Drop keys in a keylist and any keys that are not supported by the keyset */
int vcap_filter_rule_keys(struct vcap_rule *rule,
                          enum vcap_key_field keylist[], int length,
                          bool drop_unsupported)
{
        struct vcap_rule_internal *ri = to_intrule(rule);
        struct vcap_client_keyfield *ckf, *next_ckf;
        const struct vcap_field *fields;
        enum vcap_key_field key;
        int err = 0;
        int idx;

        if (length > 0) {
                err = -EEXIST;
                list_for_each_entry_safe(ckf, next_ckf,
                                         &ri->data.keyfields, ctrl.list) {
                        key = ckf->ctrl.key;
                        for (idx = 0; idx < length; ++idx)
                                if (key == keylist[idx]) {
                                        list_del(&ckf->ctrl.list);
                                        kfree(ckf);
                                        idx++;
                                        err = 0;
                                }
                }
        }
        if (drop_unsupported) {
                err = -EEXIST;
                fields = vcap_keyfields(ri->vctrl, ri->admin->vtype,
                                        rule->keyset);
                if (!fields)
                        return err;
                list_for_each_entry_safe(ckf, next_ckf,
                                         &ri->data.keyfields, ctrl.list) {
                        key = ckf->ctrl.key;
                        if (fields[key].width == 0) {
                                list_del(&ckf->ctrl.list);
                                kfree(ckf);
                                err = 0;
                        }
                }
        }
        return err;
}
EXPORT_SYMBOL_GPL(vcap_filter_rule_keys);

/* Select the keyset from the list that results in the smallest rule size */
enum vcap_keyfield_set
vcap_select_min_rule_keyset(struct vcap_control *vctrl,
                            enum vcap_type vtype,
                            struct vcap_keyset_list *kslist)
{
        enum vcap_keyfield_set ret = VCAP_KFS_NO_VALUE;
        const struct vcap_set *kset;
        int max = 100, idx;

        for (idx = 0; idx < kslist->cnt; ++idx) {
                kset = vcap_keyfieldset(vctrl, vtype, kslist->keysets[idx]);
                if (!kset)
                        continue;
                if (kset->sw_per_item >= max)
                        continue;
                max = kset->sw_per_item;
                ret = kslist->keysets[idx];
        }
        return ret;
}
EXPORT_SYMBOL_GPL(vcap_select_min_rule_keyset);

/* Make a full copy of an existing rule with a new rule id */
struct vcap_rule *vcap_copy_rule(struct vcap_rule *erule)
{
        struct vcap_rule_internal *ri = to_intrule(erule);
        struct vcap_client_actionfield *caf;
        struct vcap_client_keyfield *ckf;
        struct vcap_rule *rule;
        int err;

        err = vcap_api_check(ri->vctrl);
        if (err)
                return ERR_PTR(err);

        rule = vcap_alloc_rule(ri->vctrl, ri->ndev, ri->data.vcap_chain_id,
                               ri->data.user, ri->data.priority, 0);
        if (IS_ERR(rule))
                return rule;

        list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
                /* Add a key duplicate in the new rule */
                err = vcap_rule_add_key(rule,
                                        ckf->ctrl.key,
                                        ckf->ctrl.type,
                                        &ckf->data);
                if (err)
                        goto err;
        }

        list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
                /* Add a action duplicate in the new rule */
                err = vcap_rule_add_action(rule,
                                           caf->ctrl.action,
                                           caf->ctrl.type,
                                           &caf->data);
                if (err)
                        goto err;
        }
        return rule;
err:
        vcap_free_rule(rule);
        return ERR_PTR(err);
}
EXPORT_SYMBOL_GPL(vcap_copy_rule);

#ifdef CONFIG_VCAP_KUNIT_TEST
#include "vcap_api_kunit.c"
#endif