// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2020 Marvell International Ltd. All rights reserved */

#include <linux/rhashtable.h>

#include "prestera.h"
#include "prestera_hw.h"
#include "prestera_acl.h"
#include "prestera_span.h"

struct prestera_acl {
        struct prestera_switch *sw;
        struct list_head rules;
};

struct prestera_acl_ruleset {
        struct rhashtable rule_ht;
        struct prestera_switch *sw;
        u16 id;
};

struct prestera_acl_rule {
        struct rhash_head ht_node;
        struct list_head list;
        struct list_head match_list;
        struct list_head action_list;
        struct prestera_flow_block *block;
        unsigned long cookie;
        u32 priority;
        u8 n_actions;
        u8 n_matches;
        u32 id;
};

static const struct rhashtable_params prestera_acl_rule_ht_params = {
        .key_len = sizeof(unsigned long),
        .key_offset = offsetof(struct prestera_acl_rule, cookie),
        .head_offset = offsetof(struct prestera_acl_rule, ht_node),
        .automatic_shrinking = true,
};

static struct prestera_acl_ruleset *
prestera_acl_ruleset_create(struct prestera_switch *sw)
{
        struct prestera_acl_ruleset *ruleset;
        int err;

        ruleset = kzalloc(sizeof(*ruleset), GFP_KERNEL);
        if (!ruleset)
                return ERR_PTR(-ENOMEM);

        err = rhashtable_init(&ruleset->rule_ht, &prestera_acl_rule_ht_params);
        if (err)
                goto err_rhashtable_init;

        err = prestera_hw_acl_ruleset_create(sw, &ruleset->id);
        if (err)
                goto err_ruleset_create;

        ruleset->sw = sw;

        return ruleset;

err_ruleset_create:
        rhashtable_destroy(&ruleset->rule_ht);
err_rhashtable_init:
        kfree(ruleset);
        return ERR_PTR(err);
}

static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)
{
        prestera_hw_acl_ruleset_del(ruleset->sw, ruleset->id);
        rhashtable_destroy(&ruleset->rule_ht);
        kfree(ruleset);
}

struct prestera_flow_block *
prestera_acl_block_create(struct prestera_switch *sw, struct net *net)
{
        struct prestera_flow_block *block;

        block = kzalloc(sizeof(*block), GFP_KERNEL);
        if (!block)
                return NULL;
        INIT_LIST_HEAD(&block->binding_list);
        block->net = net;
        block->sw = sw;

        block->ruleset = prestera_acl_ruleset_create(sw);
        if (IS_ERR(block->ruleset)) {
                kfree(block);
                return NULL;
        }

        return block;
}

void prestera_acl_block_destroy(struct prestera_flow_block *block)
{
        prestera_acl_ruleset_destroy(block->ruleset);
        WARN_ON(!list_empty(&block->binding_list));
        kfree(block);
}

static struct prestera_flow_block_binding *
prestera_acl_block_lookup(struct prestera_flow_block *block,
                          struct prestera_port *port)
{
        struct prestera_flow_block_binding *binding;

        list_for_each_entry(binding, &block->binding_list, list)
                if (binding->port == port)
                        return binding;

        return NULL;
}

int prestera_acl_block_bind(struct prestera_flow_block *block,
                            struct prestera_port *port)
{
        struct prestera_flow_block_binding *binding;
        int err;

        if (WARN_ON(prestera_acl_block_lookup(block, port)))
                return -EEXIST;

        binding = kzalloc(sizeof(*binding), GFP_KERNEL);
        if (!binding)
                return -ENOMEM;
        binding->span_id = PRESTERA_SPAN_INVALID_ID;
        binding->port = port;

        err = prestera_hw_acl_port_bind(port, block->ruleset->id);
        if (err)
                goto err_rules_bind;

        list_add(&binding->list, &block->binding_list);
        return 0;

err_rules_bind:
        kfree(binding);
        return err;
}

int prestera_acl_block_unbind(struct prestera_flow_block *block,
                              struct prestera_port *port)
{
        struct prestera_flow_block_binding *binding;

        binding = prestera_acl_block_lookup(block, port);
        if (!binding)
                return -ENOENT;

        list_del(&binding->list);

        prestera_hw_acl_port_unbind(port, block->ruleset->id);

        kfree(binding);
        return 0;
}

struct prestera_acl_ruleset *
prestera_acl_block_ruleset_get(struct prestera_flow_block *block)
{
        return block->ruleset;
}

u16 prestera_acl_rule_ruleset_id_get(const struct prestera_acl_rule *rule)
{
        return rule->block->ruleset->id;
}

struct net *prestera_acl_block_net(struct prestera_flow_block *block)
{
        return block->net;
}

struct prestera_switch *prestera_acl_block_sw(struct prestera_flow_block *block)
{
        return block->sw;
}

struct prestera_acl_rule *
prestera_acl_rule_lookup(struct prestera_acl_ruleset *ruleset,
                         unsigned long cookie)
{
        return rhashtable_lookup_fast(&ruleset->rule_ht, &cookie,
                                      prestera_acl_rule_ht_params);
}

struct prestera_acl_rule *
prestera_acl_rule_create(struct prestera_flow_block *block,
                         unsigned long cookie)
{
        struct prestera_acl_rule *rule;

        rule = kzalloc(sizeof(*rule), GFP_KERNEL);
        if (!rule)
                return ERR_PTR(-ENOMEM);

        INIT_LIST_HEAD(&rule->match_list);
        INIT_LIST_HEAD(&rule->action_list);
        rule->cookie = cookie;
        rule->block = block;

        return rule;
}

struct list_head *
prestera_acl_rule_match_list_get(struct prestera_acl_rule *rule)
{
        return &rule->match_list;
}

struct list_head *
prestera_acl_rule_action_list_get(struct prestera_acl_rule *rule)
{
        return &rule->action_list;
}

int prestera_acl_rule_action_add(struct prestera_acl_rule *rule,
                                 struct prestera_acl_rule_action_entry *entry)
{
        struct prestera_acl_rule_action_entry *a_entry;

        a_entry = kmalloc(sizeof(*a_entry), GFP_KERNEL);
        if (!a_entry)
                return -ENOMEM;

        memcpy(a_entry, entry, sizeof(*entry));
        list_add(&a_entry->list, &rule->action_list);

        rule->n_actions++;
        return 0;
}

u8 prestera_acl_rule_action_len(struct prestera_acl_rule *rule)
{
        return rule->n_actions;
}

u32 prestera_acl_rule_priority_get(struct prestera_acl_rule *rule)
{
        return rule->priority;
}

void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,
                                    u32 priority)
{
        rule->priority = priority;
}

int prestera_acl_rule_match_add(struct prestera_acl_rule *rule,
                                struct prestera_acl_rule_match_entry *entry)
{
        struct prestera_acl_rule_match_entry *m_entry;

        m_entry = kmalloc(sizeof(*m_entry), GFP_KERNEL);
        if (!m_entry)
                return -ENOMEM;

        memcpy(m_entry, entry, sizeof(*entry));
        list_add(&m_entry->list, &rule->match_list);

        rule->n_matches++;
        return 0;
}

u8 prestera_acl_rule_match_len(struct prestera_acl_rule *rule)
{
        return rule->n_matches;
}

void prestera_acl_rule_destroy(struct prestera_acl_rule *rule)
{
        struct prestera_acl_rule_action_entry *a_entry;
        struct prestera_acl_rule_match_entry *m_entry;
        struct list_head *pos, *n;

        list_for_each_safe(pos, n, &rule->match_list) {
                m_entry = list_entry(pos, typeof(*m_entry), list);
                list_del(pos);
                kfree(m_entry);
        }

        list_for_each_safe(pos, n, &rule->action_list) {
                a_entry = list_entry(pos, typeof(*a_entry), list);
                list_del(pos);
                kfree(a_entry);
        }

        kfree(rule);
}

int prestera_acl_rule_add(struct prestera_switch *sw,
                          struct prestera_acl_rule *rule)
{
        u32 rule_id;
        int err;

        /* try to add rule to hash table first */
        err = rhashtable_insert_fast(&rule->block->ruleset->rule_ht,
                                     &rule->ht_node,
                                     prestera_acl_rule_ht_params);
        if (err)
                return err;

        /* add rule to hw */
        err = prestera_hw_acl_rule_add(sw, rule, &rule_id);
        if (err)
                goto err_rule_add;

        rule->id = rule_id;

        list_add_tail(&rule->list, &sw->acl->rules);

        return 0;

err_rule_add:
        rhashtable_remove_fast(&rule->block->ruleset->rule_ht, &rule->ht_node,
                               prestera_acl_rule_ht_params);
        return err;
}

void prestera_acl_rule_del(struct prestera_switch *sw,
                           struct prestera_acl_rule *rule)
{
        rhashtable_remove_fast(&rule->block->ruleset->rule_ht, &rule->ht_node,
                               prestera_acl_rule_ht_params);
        list_del(&rule->list);
        prestera_hw_acl_rule_del(sw, rule->id);
}

int prestera_acl_rule_get_stats(struct prestera_switch *sw,
                                struct prestera_acl_rule *rule,
                                u64 *packets, u64 *bytes, u64 *last_use)
{
        u64 current_packets;
        u64 current_bytes;
        int err;

        err = prestera_hw_acl_rule_stats_get(sw, rule->id, &current_packets,
                                             &current_bytes);
        if (err)
                return err;

        *packets = current_packets;
        *bytes = current_bytes;
        *last_use = jiffies;

        return 0;
}

int prestera_acl_init(struct prestera_switch *sw)
{
        struct prestera_acl *acl;

        acl = kzalloc(sizeof(*acl), GFP_KERNEL);
        if (!acl)
                return -ENOMEM;

        INIT_LIST_HEAD(&acl->rules);
        sw->acl = acl;
        acl->sw = sw;

        return 0;
}

void prestera_acl_fini(struct prestera_switch *sw)
{
        struct prestera_acl *acl = sw->acl;

        WARN_ON(!list_empty(&acl->rules));
        kfree(acl);
}