// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
/* Copyright (C) 2015-2018 Netronome Systems, Inc. */

#include <linux/bitfield.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/workqueue.h>
#include <net/dst_metadata.h>

#include "main.h"
#include "../nfp_net.h"
#include "../nfp_net_repr.h"
#include "./cmsg.h"

static struct nfp_flower_cmsg_hdr *
nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
{
        return (struct nfp_flower_cmsg_hdr *)skb->data;
}

struct sk_buff *
nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
                      enum nfp_flower_cmsg_type_port type, gfp_t flag)
{
        struct nfp_flower_cmsg_hdr *ch;
        struct sk_buff *skb;

        size += NFP_FLOWER_CMSG_HLEN;

        skb = nfp_app_ctrl_msg_alloc(app, size, flag);
        if (!skb)
                return NULL;

        ch = nfp_flower_cmsg_get_hdr(skb);
        ch->pad = 0;
        ch->version = NFP_FLOWER_CMSG_VER1;
        ch->type = type;
        skb_put(skb, size);

        return skb;
}

struct sk_buff *
nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
{
        struct nfp_flower_cmsg_mac_repr *msg;
        struct sk_buff *skb;

        skb = nfp_flower_cmsg_alloc(app, struct_size(msg, ports, num_ports),
                                    NFP_FLOWER_CMSG_TYPE_MAC_REPR, GFP_KERNEL);
        if (!skb)
                return NULL;

        msg = nfp_flower_cmsg_get_data(skb);
        memset(msg->reserved, 0, sizeof(msg->reserved));
        msg->num_ports = num_ports;

        return skb;
}

void
nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
                             unsigned int nbi, unsigned int nbi_port,
                             unsigned int phys_port)
{
        struct nfp_flower_cmsg_mac_repr *msg;

        msg = nfp_flower_cmsg_get_data(skb);
        msg->ports[idx].idx = idx;
        msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
        msg->ports[idx].nbi_port = nbi_port;
        msg->ports[idx].phys_port = phys_port;
}

int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
                            unsigned int mtu, bool mtu_only)
{
        struct nfp_flower_cmsg_portmod *msg;
        struct sk_buff *skb;

        skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
                                    NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
        if (!skb)
                return -ENOMEM;

        msg = nfp_flower_cmsg_get_data(skb);
        msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
        msg->reserved = 0;
        msg->info = carrier_ok;

        if (mtu_only)
                msg->info |= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;

        msg->mtu = cpu_to_be16(mtu);

        nfp_ctrl_tx(repr->app->ctrl, skb);

        return 0;
}

int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
{
        struct nfp_flower_cmsg_portreify *msg;
        struct sk_buff *skb;

        skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
                                    NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
                                    GFP_KERNEL);
        if (!skb)
                return -ENOMEM;

        msg = nfp_flower_cmsg_get_data(skb);
        msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
        msg->reserved = 0;
        msg->info = cpu_to_be16(exists);

        nfp_ctrl_tx(repr->app->ctrl, skb);

        return 0;
}

static bool
nfp_flower_process_mtu_ack(struct nfp_app *app, struct sk_buff *skb)
{
        struct nfp_flower_priv *app_priv = app->priv;
        struct nfp_flower_cmsg_portmod *msg;

        msg = nfp_flower_cmsg_get_data(skb);

        if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
                return false;

        spin_lock_bh(&app_priv->mtu_conf.lock);
        if (!app_priv->mtu_conf.requested_val ||
            app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) ||
            be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
                /* Not an ack for requested MTU change. */
                spin_unlock_bh(&app_priv->mtu_conf.lock);
                return false;
        }

        app_priv->mtu_conf.ack = true;
        app_priv->mtu_conf.requested_val = 0;
        wake_up(&app_priv->mtu_conf.wait_q);
        spin_unlock_bh(&app_priv->mtu_conf.lock);

        return true;
}

static void
nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
{
        struct nfp_flower_cmsg_portmod *msg;
        struct net_device *netdev;
        bool link;

        msg = nfp_flower_cmsg_get_data(skb);
        link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;

        rtnl_lock();
        rcu_read_lock();
        netdev = nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
        rcu_read_unlock();
        if (!netdev) {
                nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
                                     be32_to_cpu(msg->portnum));
                rtnl_unlock();
                return;
        }

        if (link) {
                u16 mtu = be16_to_cpu(msg->mtu);

                netif_carrier_on(netdev);

                /* An MTU of 0 from the firmware should be ignored */
                if (mtu)
                        dev_set_mtu(netdev, mtu);
        } else {
                netif_carrier_off(netdev);
        }
        rtnl_unlock();
}

static void
nfp_flower_cmsg_portreify_rx(struct nfp_app *app, struct sk_buff *skb)
{
        struct nfp_flower_priv *priv = app->priv;
        struct nfp_flower_cmsg_portreify *msg;
        bool exists;

        msg = nfp_flower_cmsg_get_data(skb);

        rcu_read_lock();
        exists = !!nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
        rcu_read_unlock();
        if (!exists) {
                nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
                                     be32_to_cpu(msg->portnum));
                return;
        }

        atomic_inc(&priv->reify_replies);
        wake_up(&priv->reify_wait_queue);
}

static void
nfp_flower_cmsg_merge_hint_rx(struct nfp_app *app, struct sk_buff *skb)
{
        unsigned int msg_len = nfp_flower_cmsg_get_data_len(skb);
        struct nfp_flower_cmsg_merge_hint *msg;
        struct nfp_fl_payload *sub_flows[2];
        struct nfp_flower_priv *priv;
        int err, i, flow_cnt;

        msg = nfp_flower_cmsg_get_data(skb);
        /* msg->count starts at 0 and always assumes at least 1 entry. */
        flow_cnt = msg->count + 1;

        if (msg_len < struct_size(msg, flow, flow_cnt)) {
                nfp_flower_cmsg_warn(app, "Merge hint ctrl msg too short - %d bytes but expect %zd\n",
                                     msg_len, struct_size(msg, flow, flow_cnt));
                return;
        }

        if (flow_cnt != 2) {
                nfp_flower_cmsg_warn(app, "Merge hint contains %d flows - two are expected\n",
                                     flow_cnt);
                return;
        }

        priv = app->priv;
        mutex_lock(&priv->nfp_fl_lock);
        for (i = 0; i < flow_cnt; i++) {
                u32 ctx = be32_to_cpu(msg->flow[i].host_ctx);

                sub_flows[i] = nfp_flower_get_fl_payload_from_ctx(app, ctx);
                if (!sub_flows[i]) {
                        nfp_flower_cmsg_warn(app, "Invalid flow in merge hint\n");
                        goto err_mutex_unlock;
                }
        }

        err = nfp_flower_merge_offloaded_flows(app, sub_flows[0], sub_flows[1]);
        /* Only warn on memory fail. Hint veto will not break functionality. */
        if (err == -ENOMEM)
                nfp_flower_cmsg_warn(app, "Flow merge memory fail.\n");

err_mutex_unlock:
        mutex_unlock(&priv->nfp_fl_lock);
}

static void
nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
{
        struct nfp_flower_priv *app_priv = app->priv;
        struct nfp_flower_cmsg_hdr *cmsg_hdr;
        enum nfp_flower_cmsg_type_port type;
        bool skb_stored = false;

        cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

        type = cmsg_hdr->type;
        switch (type) {
        case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
                nfp_flower_cmsg_portmod_rx(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_MERGE_HINT:
                if (app_priv->flower_en_feats & NFP_FL_ENABLE_FLOW_MERGE) {
                        nfp_flower_cmsg_merge_hint_rx(app, skb);
                        break;
                }
                goto err_default;
        case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
                nfp_tunnel_request_route_v4(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_NO_NEIGH_V6:
                nfp_tunnel_request_route_v6(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
                nfp_tunnel_keep_alive(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS_V6:
                nfp_tunnel_keep_alive_v6(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_QOS_STATS:
                nfp_flower_stats_rlim_reply(app, skb);
                break;
        case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
                if (app_priv->flower_en_feats & NFP_FL_ENABLE_LAG) {
                        skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
                        break;
                }
                fallthrough;
        default:
err_default:
                nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
                                     type);
                goto out;
        }

        if (!skb_stored)
                dev_consume_skb_any(skb);
        return;
out:
        dev_kfree_skb_any(skb);
}

void nfp_flower_cmsg_process_rx(struct work_struct *work)
{
        struct sk_buff_head cmsg_joined;
        struct nfp_flower_priv *priv;
        struct sk_buff *skb;

        priv = container_of(work, struct nfp_flower_priv, cmsg_work);
        skb_queue_head_init(&cmsg_joined);

        spin_lock_bh(&priv->cmsg_skbs_high.lock);
        skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
        spin_unlock_bh(&priv->cmsg_skbs_high.lock);

        spin_lock_bh(&priv->cmsg_skbs_low.lock);
        skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
        spin_unlock_bh(&priv->cmsg_skbs_low.lock);

        while ((skb = __skb_dequeue(&cmsg_joined)))
                nfp_flower_cmsg_process_one_rx(priv->app, skb);
}

static void
nfp_flower_queue_ctl_msg(struct nfp_app *app, struct sk_buff *skb, int type)
{
        struct nfp_flower_priv *priv = app->priv;
        struct sk_buff_head *skb_head;

        if (type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
                skb_head = &priv->cmsg_skbs_high;
        else
                skb_head = &priv->cmsg_skbs_low;

        if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
                nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
                dev_kfree_skb_any(skb);
                return;
        }

        skb_queue_tail(skb_head, skb);
        schedule_work(&priv->cmsg_work);
}

void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
{
        struct nfp_flower_cmsg_hdr *cmsg_hdr;

        cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);

        if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
                nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
                                     cmsg_hdr->version);
                dev_kfree_skb_any(skb);
                return;
        }

        if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
                /* We need to deal with stats updates from HW asap */
                nfp_flower_rx_flow_stats(app, skb);
                dev_consume_skb_any(skb);
        } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
                   nfp_flower_process_mtu_ack(app, skb)) {
                /* Handle MTU acks outside wq to prevent RTNL conflict. */
                dev_consume_skb_any(skb);
        } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH ||
                   cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6) {
                /* Acks from the NFP that the route is added - ignore. */
                dev_consume_skb_any(skb);
        } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY) {
                /* Handle REIFY acks outside wq to prevent RTNL conflict. */
                nfp_flower_cmsg_portreify_rx(app, skb);
                dev_consume_skb_any(skb);
        } else {
                nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
        }
}