[linux-2.6-block.git] / drivers / net / ethernet / netronome / nfp / flower / main.c

/*
 * Copyright (C) 2017 Netronome Systems, Inc.
 *
 * This software is dual licensed under the GNU General License Version 2,
 * June 1991 as shown in the file COPYING in the top-level directory of this
 * source tree or the BSD 2-Clause License provided below.  You have the
 * option to license this software under the complete terms of either license.
 *
 * The BSD 2-Clause License:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      1. Redistributions of source code must retain the above
 *         copyright notice, this list of conditions and the following
 *         disclaimer.
 *
 *      2. Redistributions in binary form must reproduce the above
 *         copyright notice, this list of conditions and the following
 *         disclaimer in the documentation and/or other materials
 *         provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/etherdevice.h>
#include <linux/lockdep.h>
#include <linux/pci.h>
#include <linux/skbuff.h>
#include <linux/vmalloc.h>
#include <net/devlink.h>
#include <net/dst_metadata.h>

#include "main.h"
#include "../nfpcore/nfp_cpp.h"
#include "../nfpcore/nfp_nffw.h"
#include "../nfpcore/nfp_nsp.h"
#include "../nfp_app.h"
#include "../nfp_main.h"
#include "../nfp_net.h"
#include "../nfp_net_repr.h"
#include "../nfp_port.h"
#include "./cmsg.h"

#define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL

#define NFP_FLOWER_FRAME_HEADROOM	158

static const char *nfp_flower_extra_cap(struct nfp_app *app, struct nfp_net *nn)
{
	return "FLOWER";
}

static enum devlink_eswitch_mode eswitch_mode_get(struct nfp_app *app)
{
	return DEVLINK_ESWITCH_MODE_SWITCHDEV;
}

static enum nfp_repr_type
nfp_flower_repr_get_type_and_port(struct nfp_app *app, u32 port_id, u8 *port)
{
	switch (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port_id)) {
	case NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT:
		*port = FIELD_GET(NFP_FLOWER_CMSG_PORT_PHYS_PORT_NUM,
				  port_id);
		return NFP_REPR_TYPE_PHYS_PORT;

	case NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT:
		*port = FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC, port_id);
		if (FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC_TYPE, port_id) ==
		    NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF)
			return NFP_REPR_TYPE_PF;
		else
			return NFP_REPR_TYPE_VF;
	}

	return NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC;
}

static struct net_device *
nfp_flower_repr_get(struct nfp_app *app, u32 port_id)
{
	enum nfp_repr_type repr_type;
	struct nfp_reprs *reprs;
	u8 port = 0;

	repr_type = nfp_flower_repr_get_type_and_port(app, port_id, &port);

	reprs = rcu_dereference(app->reprs[repr_type]);
	if (!reprs)
		return NULL;

	if (port >= reprs->num_reprs)
		return NULL;

	return rcu_dereference(reprs->reprs[port]);
}

static int
nfp_flower_reprs_reify(struct nfp_app *app, enum nfp_repr_type type,
		       bool exists)
{
	struct nfp_reprs *reprs;
	int i, err, count = 0;

	reprs = rcu_dereference_protected(app->reprs[type],
					  lockdep_is_held(&app->pf->lock));
	if (!reprs)
		return 0;

	for (i = 0; i < reprs->num_reprs; i++) {
		struct net_device *netdev;

		netdev = nfp_repr_get_locked(app, reprs, i);
		if (netdev) {
			struct nfp_repr *repr = netdev_priv(netdev);

			err = nfp_flower_cmsg_portreify(repr, exists);
			if (err)
				return err;
			count++;
		}
	}

	return count;
}

static int
nfp_flower_wait_repr_reify(struct nfp_app *app, atomic_t *replies, int tot_repl)
{
	struct nfp_flower_priv *priv = app->priv;
	int err;

	if (!tot_repl)
		return 0;

	lockdep_assert_held(&app->pf->lock);
	err = wait_event_interruptible_timeout(priv->reify_wait_queue,
					       atomic_read(replies) >= tot_repl,
					       msecs_to_jiffies(10));
	if (err <= 0) {
		nfp_warn(app->cpp, "Not all reprs responded to reify\n");
		return -EIO;
	}

	return 0;
}

static int
nfp_flower_repr_netdev_open(struct nfp_app *app, struct nfp_repr *repr)
{
	int err;

	err = nfp_flower_cmsg_portmod(repr, true, repr->netdev->mtu, false);
	if (err)
		return err;

	netif_tx_wake_all_queues(repr->netdev);

	return 0;
}

static int
nfp_flower_repr_netdev_stop(struct nfp_app *app, struct nfp_repr *repr)
{
	netif_tx_disable(repr->netdev);

	return nfp_flower_cmsg_portmod(repr, false, repr->netdev->mtu, false);
}

static int
nfp_flower_repr_netdev_init(struct nfp_app *app, struct net_device *netdev)
{
	return tc_setup_cb_egdev_register(netdev,
					  nfp_flower_setup_tc_egress_cb,
					  netdev_priv(netdev));
}

static void
nfp_flower_repr_netdev_clean(struct nfp_app *app, struct net_device *netdev)
{
	tc_setup_cb_egdev_unregister(netdev, nfp_flower_setup_tc_egress_cb,
				     netdev_priv(netdev));
}

static void
nfp_flower_repr_netdev_preclean(struct nfp_app *app, struct net_device *netdev)
{
	struct nfp_repr *repr = netdev_priv(netdev);
	struct nfp_flower_priv *priv = app->priv;
	atomic_t *replies = &priv->reify_replies;
	int err;

	atomic_set(replies, 0);
	err = nfp_flower_cmsg_portreify(repr, false);
	if (err) {
		nfp_warn(app->cpp, "Failed to notify firmware about repr destruction\n");
		return;
	}

	nfp_flower_wait_repr_reify(app, replies, 1);
}

static void nfp_flower_sriov_disable(struct nfp_app *app)
{
	struct nfp_flower_priv *priv = app->priv;

	if (!priv->nn)
		return;

	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
}

static int
nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
			    enum nfp_flower_cmsg_port_vnic_type vnic_type,
			    enum nfp_repr_type repr_type, unsigned int cnt)
{
	u8 nfp_pcie = nfp_cppcore_pcie_unit(app->pf->cpp);
	struct nfp_flower_priv *priv = app->priv;
	atomic_t *replies = &priv->reify_replies;
	enum nfp_port_type port_type;
	struct nfp_reprs *reprs;
	int i, err, reify_cnt;
	const u8 queue = 0;

	port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT :
						    NFP_PORT_VF_PORT;

	reprs = nfp_reprs_alloc(cnt);
	if (!reprs)
		return -ENOMEM;

	for (i = 0; i < cnt; i++) {
		struct net_device *repr;
		struct nfp_port *port;
		u32 port_id;

		repr = nfp_repr_alloc(app);
		if (!repr) {
			err = -ENOMEM;
			goto err_reprs_clean;
		}
		RCU_INIT_POINTER(reprs->reprs[i], repr);

		/* For now we only support 1 PF */
		WARN_ON(repr_type == NFP_REPR_TYPE_PF && i);

		port = nfp_port_alloc(app, port_type, repr);
		if (repr_type == NFP_REPR_TYPE_PF) {
			port->pf_id = i;
			port->vnic = priv->nn->dp.ctrl_bar;
		} else {
			port->pf_id = 0;
			port->vf_id = i;
			port->vnic =
				app->pf->vf_cfg_mem + i * NFP_NET_CFG_BAR_SZ;
		}

		eth_hw_addr_random(repr);

		port_id = nfp_flower_cmsg_pcie_port(nfp_pcie, vnic_type,
						    i, queue);
		err = nfp_repr_init(app, repr,
				    port_id, port, priv->nn->dp.netdev);
		if (err) {
			nfp_port_free(port);
			goto err_reprs_clean;
		}

		nfp_info(app->cpp, "%s%d Representor(%s) created\n",
			 repr_type == NFP_REPR_TYPE_PF ? "PF" : "VF", i,
			 repr->name);
	}

	nfp_app_reprs_set(app, repr_type, reprs);

	atomic_set(replies, 0);
	reify_cnt = nfp_flower_reprs_reify(app, repr_type, true);
	if (reify_cnt < 0) {
		err = reify_cnt;
		nfp_warn(app->cpp, "Failed to notify firmware about repr creation\n");
		goto err_reprs_remove;
	}

	err = nfp_flower_wait_repr_reify(app, replies, reify_cnt);
	if (err)
		goto err_reprs_remove;

	return 0;
err_reprs_remove:
	reprs = nfp_app_reprs_set(app, repr_type, NULL);
err_reprs_clean:
	nfp_reprs_clean_and_free(app, reprs);
	return err;
}

static int nfp_flower_sriov_enable(struct nfp_app *app, int num_vfs)
{
	struct nfp_flower_priv *priv = app->priv;

	if (!priv->nn)
		return 0;

	return nfp_flower_spawn_vnic_reprs(app,
					   NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
					   NFP_REPR_TYPE_VF, num_vfs);
}

static int
nfp_flower_spawn_phy_reprs(struct nfp_app *app, struct nfp_flower_priv *priv)
{
	struct nfp_eth_table *eth_tbl = app->pf->eth_tbl;
	atomic_t *replies = &priv->reify_replies;
	struct sk_buff *ctrl_skb;
	struct nfp_reprs *reprs;
	int err, reify_cnt;
	unsigned int i;

	ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count);
	if (!ctrl_skb)
		return -ENOMEM;

	reprs = nfp_reprs_alloc(eth_tbl->max_index + 1);
	if (!reprs) {
		err = -ENOMEM;
		goto err_free_ctrl_skb;
	}

	for (i = 0; i < eth_tbl->count; i++) {
		unsigned int phys_port = eth_tbl->ports[i].index;
		struct net_device *repr;
		struct nfp_port *port;
		u32 cmsg_port_id;

		repr = nfp_repr_alloc(app);
		if (!repr) {
			err = -ENOMEM;
			goto err_reprs_clean;
		}
		RCU_INIT_POINTER(reprs->reprs[phys_port], repr);

		port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT, repr);
		if (IS_ERR(port)) {
			err = PTR_ERR(port);
			goto err_reprs_clean;
		}
		err = nfp_port_init_phy_port(app->pf, app, port, i);
		if (err) {
			nfp_port_free(port);
			goto err_reprs_clean;
		}

		SET_NETDEV_DEV(repr, &priv->nn->pdev->dev);
		nfp_net_get_mac_addr(app->pf, repr, port);

		cmsg_port_id = nfp_flower_cmsg_phys_port(phys_port);
		err = nfp_repr_init(app, repr,
				    cmsg_port_id, port, priv->nn->dp.netdev);
		if (err) {
			nfp_port_free(port);
			goto err_reprs_clean;
		}

		nfp_flower_cmsg_mac_repr_add(ctrl_skb, i,
					     eth_tbl->ports[i].nbi,
					     eth_tbl->ports[i].base,
					     phys_port);

		nfp_info(app->cpp, "Phys Port %d Representor(%s) created\n",
			 phys_port, repr->name);
	}

	nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs);

	/* The REIFY/MAC_REPR control messages should be sent after the MAC
	 * representors are registered using nfp_app_reprs_set().  This is
	 * because the firmware may respond with control messages for the
	 * MAC representors, f.e. to provide the driver with information
	 * about their state, and without registration the driver will drop
	 * any such messages.
	 */
	atomic_set(replies, 0);
	reify_cnt = nfp_flower_reprs_reify(app, NFP_REPR_TYPE_PHYS_PORT, true);
	if (reify_cnt < 0) {
		err = reify_cnt;
		nfp_warn(app->cpp, "Failed to notify firmware about repr creation\n");
		goto err_reprs_remove;
	}

	err = nfp_flower_wait_repr_reify(app, replies, reify_cnt);
	if (err)
		goto err_reprs_remove;

	nfp_ctrl_tx(app->ctrl, ctrl_skb);

	return 0;
err_reprs_remove:
	reprs = nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, NULL);
err_reprs_clean:
	nfp_reprs_clean_and_free(app, reprs);
err_free_ctrl_skb:
	kfree_skb(ctrl_skb);
	return err;
}

static int nfp_flower_vnic_alloc(struct nfp_app *app, struct nfp_net *nn,
				 unsigned int id)
{
	if (id > 0) {
		nfp_warn(app->cpp, "FlowerNIC doesn't support more than one data vNIC\n");
		goto err_invalid_port;
	}

	eth_hw_addr_random(nn->dp.netdev);
	netif_keep_dst(nn->dp.netdev);

	return 0;

err_invalid_port:
	nn->port = nfp_port_alloc(app, NFP_PORT_INVALID, nn->dp.netdev);
	return PTR_ERR_OR_ZERO(nn->port);
}

static void nfp_flower_vnic_clean(struct nfp_app *app, struct nfp_net *nn)
{
	struct nfp_flower_priv *priv = app->priv;

	if (app->pf->num_vfs)
		nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);

	priv->nn = NULL;
}

static int nfp_flower_vnic_init(struct nfp_app *app, struct nfp_net *nn)
{
	struct nfp_flower_priv *priv = app->priv;
	int err;

	priv->nn = nn;

	err = nfp_flower_spawn_phy_reprs(app, app->priv);
	if (err)
		goto err_clear_nn;

	err = nfp_flower_spawn_vnic_reprs(app,
					  NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF,
					  NFP_REPR_TYPE_PF, 1);
	if (err)
		goto err_destroy_reprs_phy;

	if (app->pf->num_vfs) {
		err = nfp_flower_spawn_vnic_reprs(app,
						  NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
						  NFP_REPR_TYPE_VF,
						  app->pf->num_vfs);
		if (err)
			goto err_destroy_reprs_pf;
	}

	return 0;

err_destroy_reprs_pf:
	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
err_destroy_reprs_phy:
	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
err_clear_nn:
	priv->nn = NULL;
	return err;
}

static int nfp_flower_init(struct nfp_app *app)
{
	const struct nfp_pf *pf = app->pf;
	struct nfp_flower_priv *app_priv;
	u64 version, features;
	int err;

	if (!pf->eth_tbl) {
		nfp_warn(app->cpp, "FlowerNIC requires eth table\n");
		return -EINVAL;
	}

	if (!pf->mac_stats_bar) {
		nfp_warn(app->cpp, "FlowerNIC requires mac_stats BAR\n");
		return -EINVAL;
	}

	if (!pf->vf_cfg_bar) {
		nfp_warn(app->cpp, "FlowerNIC requires vf_cfg BAR\n");
		return -EINVAL;
	}

	version = nfp_rtsym_read_le(app->pf->rtbl, "hw_flower_version", &err);
	if (err) {
		nfp_warn(app->cpp, "FlowerNIC requires hw_flower_version memory symbol\n");
		return err;
	}

	/* We need to ensure hardware has enough flower capabilities. */
	if (version != NFP_FLOWER_ALLOWED_VER) {
		nfp_warn(app->cpp, "FlowerNIC: unsupported firmware version\n");
		return -EINVAL;
	}

	app_priv = vzalloc(sizeof(struct nfp_flower_priv));
	if (!app_priv)
		return -ENOMEM;

	app->priv = app_priv;
	app_priv->app = app;
	skb_queue_head_init(&app_priv->cmsg_skbs_high);
	skb_queue_head_init(&app_priv->cmsg_skbs_low);
	INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx);
	init_waitqueue_head(&app_priv->reify_wait_queue);

	init_waitqueue_head(&app_priv->mtu_conf.wait_q);
	spin_lock_init(&app_priv->mtu_conf.lock);

	err = nfp_flower_metadata_init(app);
	if (err)
		goto err_free_app_priv;

	/* Extract the extra features supported by the firmware. */
	features = nfp_rtsym_read_le(app->pf->rtbl,
				     "_abi_flower_extra_features", &err);
	if (err)
		app_priv->flower_ext_feats = 0;
	else
		app_priv->flower_ext_feats = features;

	return 0;

err_free_app_priv:
	vfree(app->priv);
	return err;
}

static void nfp_flower_clean(struct nfp_app *app)
{
	struct nfp_flower_priv *app_priv = app->priv;

	skb_queue_purge(&app_priv->cmsg_skbs_high);
	skb_queue_purge(&app_priv->cmsg_skbs_low);
	flush_work(&app_priv->cmsg_work);

	nfp_flower_metadata_cleanup(app);
	vfree(app->priv);
	app->priv = NULL;
}

static int
nfp_flower_check_mtu(struct nfp_app *app, struct net_device *netdev,
		     int new_mtu)
{
	/* The flower fw reserves NFP_FLOWER_FRAME_HEADROOM bytes of the
	 * supported max MTU to allow for appending tunnel headers. To prevent
	 * unexpected behaviour this needs to be accounted for.
	 */
	if (new_mtu > netdev->max_mtu - NFP_FLOWER_FRAME_HEADROOM) {
		nfp_err(app->cpp, "New MTU (%d) is not valid\n", new_mtu);
		return -EINVAL;
	}

	return 0;
}

static bool nfp_flower_check_ack(struct nfp_flower_priv *app_priv)
{
	bool ret;

	spin_lock_bh(&app_priv->mtu_conf.lock);
	ret = app_priv->mtu_conf.ack;
	spin_unlock_bh(&app_priv->mtu_conf.lock);

	return ret;
}

static int
nfp_flower_repr_change_mtu(struct nfp_app *app, struct net_device *netdev,
			   int new_mtu)
{
	struct nfp_flower_priv *app_priv = app->priv;
	struct nfp_repr *repr = netdev_priv(netdev);
	int err, ack;

	/* Only need to config FW for physical port MTU change. */
	if (repr->port->type != NFP_PORT_PHYS_PORT)
		return 0;

	if (!(app_priv->flower_ext_feats & NFP_FL_NBI_MTU_SETTING)) {
		nfp_err(app->cpp, "Physical port MTU setting not supported\n");
		return -EINVAL;
	}

	spin_lock_bh(&app_priv->mtu_conf.lock);
	app_priv->mtu_conf.ack = false;
	app_priv->mtu_conf.requested_val = new_mtu;
	app_priv->mtu_conf.portnum = repr->dst->u.port_info.port_id;
	spin_unlock_bh(&app_priv->mtu_conf.lock);

	err = nfp_flower_cmsg_portmod(repr, netif_carrier_ok(netdev), new_mtu,
				      true);
	if (err) {
		spin_lock_bh(&app_priv->mtu_conf.lock);
		app_priv->mtu_conf.requested_val = 0;
		spin_unlock_bh(&app_priv->mtu_conf.lock);
		return err;
	}

	/* Wait for fw to ack the change. */
	ack = wait_event_timeout(app_priv->mtu_conf.wait_q,
				 nfp_flower_check_ack(app_priv),
				 msecs_to_jiffies(10));

	if (!ack) {
		spin_lock_bh(&app_priv->mtu_conf.lock);
		app_priv->mtu_conf.requested_val = 0;
		spin_unlock_bh(&app_priv->mtu_conf.lock);
		nfp_warn(app->cpp, "MTU change not verified with fw\n");
		return -EIO;
	}

	return 0;
}

static int nfp_flower_start(struct nfp_app *app)
{
	return nfp_tunnel_config_start(app);
}

static void nfp_flower_stop(struct nfp_app *app)
{
	nfp_tunnel_config_stop(app);
}

const struct nfp_app_type app_flower = {
	.id		= NFP_APP_FLOWER_NIC,
	.name		= "flower",

	.ctrl_cap_mask	= ~0U,
	.ctrl_has_meta	= true,

	.extra_cap	= nfp_flower_extra_cap,

	.init		= nfp_flower_init,
	.clean		= nfp_flower_clean,

	.check_mtu	= nfp_flower_check_mtu,
	.repr_change_mtu  = nfp_flower_repr_change_mtu,

	.vnic_alloc	= nfp_flower_vnic_alloc,
	.vnic_init	= nfp_flower_vnic_init,
	.vnic_clean	= nfp_flower_vnic_clean,

	.repr_init	= nfp_flower_repr_netdev_init,
	.repr_preclean	= nfp_flower_repr_netdev_preclean,
	.repr_clean	= nfp_flower_repr_netdev_clean,

	.repr_open	= nfp_flower_repr_netdev_open,
	.repr_stop	= nfp_flower_repr_netdev_stop,

	.start		= nfp_flower_start,
	.stop		= nfp_flower_stop,

	.ctrl_msg_rx	= nfp_flower_cmsg_rx,

	.sriov_enable	= nfp_flower_sriov_enable,
	.sriov_disable	= nfp_flower_sriov_disable,

	.eswitch_mode_get  = eswitch_mode_get,
	.repr_get	= nfp_flower_repr_get,

	.setup_tc	= nfp_flower_setup_tc,
};
Commit	Line	Data
1025351a SH	1	/*
	2	* Copyright (C) 2017 Netronome Systems, Inc.
	3	*
	4	* This software is dual licensed under the GNU General License Version 2,
	5	* June 1991 as shown in the file COPYING in the top-level directory of this
	6	* source tree or the BSD 2-Clause License provided below. You have the
	7	* option to license this software under the complete terms of either license.
	8	*
	9	* The BSD 2-Clause License:
	10	*
	11	* Redistribution and use in source and binary forms, with or
	12	* without modification, are permitted provided that the following
	13	* conditions are met:
	14	*
	15	* 1. Redistributions of source code must retain the above
	16	* copyright notice, this list of conditions and the following
	17	* disclaimer.
	18	*
	19	* 2. Redistributions in binary form must reproduce the above
	20	* copyright notice, this list of conditions and the following
	21	* disclaimer in the documentation and/or other materials
	22	* provided with the distribution.
	23	*
	24	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	25	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	26	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	27	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	28	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	29	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	30	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	31	* SOFTWARE.
	32	*/
	33
	34	#include <linux/etherdevice.h>
d2c2928d	35	#include <linux/lockdep.h>
1025351a SH	36	#include <linux/pci.h>
1025351a SH	37	#include <linux/skbuff.h>
43f84b72	38	#include <linux/vmalloc.h>
1025351a SH	39	#include <net/devlink.h>
	40	#include <net/dst_metadata.h>
	41
8a276873	42	#include "main.h"
1025351a	43	#include "../nfpcore/nfp_cpp.h"
8a276873	44	#include "../nfpcore/nfp_nffw.h"
1025351a SH	45	#include "../nfpcore/nfp_nsp.h"
	46	#include "../nfp_app.h"
	47	#include "../nfp_main.h"
	48	#include "../nfp_net.h"
	49	#include "../nfp_net_repr.h"
	50	#include "../nfp_port.h"
	51	#include "./cmsg.h"
	52
8a276873 PJV	53	#define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL
8a276873 PJV	54
29a5dcae JH	55	#define NFP_FLOWER_FRAME_HEADROOM 158
29a5dcae JH	56
1025351a SH	57	static const char nfp_flower_extra_cap(struct nfp_app app, struct nfp_net *nn)
	58	{
	59	return "FLOWER";
	60	}
	61
	62	static enum devlink_eswitch_mode eswitch_mode_get(struct nfp_app *app)
	63	{
	64	return DEVLINK_ESWITCH_MODE_SWITCHDEV;
	65	}
	66
	67	static enum nfp_repr_type
	68	nfp_flower_repr_get_type_and_port(struct nfp_app app, u32 port_id, u8 port)
	69	{
	70	switch (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port_id)) {
	71	case NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT:
	72	*port = FIELD_GET(NFP_FLOWER_CMSG_PORT_PHYS_PORT_NUM,
	73	port_id);
	74	return NFP_REPR_TYPE_PHYS_PORT;
	75
	76	case NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT:
	77	*port = FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC, port_id);
	78	if (FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC_TYPE, port_id) ==
	79	NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF)
	80	return NFP_REPR_TYPE_PF;
	81	else
	82	return NFP_REPR_TYPE_VF;
	83	}
	84
	85	return NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC;
	86	}
	87
	88	static struct net_device *
	89	nfp_flower_repr_get(struct nfp_app *app, u32 port_id)
	90	{
	91	enum nfp_repr_type repr_type;
	92	struct nfp_reprs *reprs;
	93	u8 port = 0;
	94
	95	repr_type = nfp_flower_repr_get_type_and_port(app, port_id, &port);
	96
	97	reprs = rcu_dereference(app->reprs[repr_type]);
	98	if (!reprs)
	99	return NULL;
	100
	101	if (port >= reprs->num_reprs)
	102	return NULL;
	103
3eb47dfc	104	return rcu_dereference(reprs->reprs[port]);
1025351a SH	105	}
1025351a SH	106
d2c2928d DM	107	static int
	108	nfp_flower_reprs_reify(struct nfp_app *app, enum nfp_repr_type type,
	109	bool exists)
	110	{
	111	struct nfp_reprs *reprs;
	112	int i, err, count = 0;
	113
	114	reprs = rcu_dereference_protected(app->reprs[type],
	115	lockdep_is_held(&app->pf->lock));
	116	if (!reprs)
	117	return 0;
	118
3eb47dfc JK	119	for (i = 0; i < reprs->num_reprs; i++) {
	120	struct net_device *netdev;
	121
	122	netdev = nfp_repr_get_locked(app, reprs, i);
	123	if (netdev) {
	124	struct nfp_repr *repr = netdev_priv(netdev);
d2c2928d DM	125
	126	err = nfp_flower_cmsg_portreify(repr, exists);
	127	if (err)
	128	return err;
	129	count++;
	130	}
3eb47dfc	131	}
d2c2928d DM	132
	133	return count;
	134	}
	135
	136	static int
	137	nfp_flower_wait_repr_reify(struct nfp_app app, atomic_t replies, int tot_repl)
	138	{
	139	struct nfp_flower_priv *priv = app->priv;
	140	int err;
	141
	142	if (!tot_repl)
	143	return 0;
	144
	145	lockdep_assert_held(&app->pf->lock);
	146	err = wait_event_interruptible_timeout(priv->reify_wait_queue,
	147	atomic_read(replies) >= tot_repl,
	148	msecs_to_jiffies(10));
	149	if (err <= 0) {
	150	nfp_warn(app->cpp, "Not all reprs responded to reify\n");
	151	return -EIO;
	152	}
	153
	154	return 0;
	155	}
	156
5d7c64a7 JK	157	static int
5d7c64a7 JK	158	nfp_flower_repr_netdev_open(struct nfp_app app, struct nfp_repr repr)
1025351a SH	159	{
	160	int err;
	161
29a5dcae	162	err = nfp_flower_cmsg_portmod(repr, true, repr->netdev->mtu, false);
1025351a SH	163	if (err)
	164	return err;
	165
5d7c64a7	166	netif_tx_wake_all_queues(repr->netdev);
1025351a SH	167
	168	return 0;
	169	}
	170
5d7c64a7 JK	171	static int
5d7c64a7 JK	172	nfp_flower_repr_netdev_stop(struct nfp_app app, struct nfp_repr repr)
1025351a	173	{
5d7c64a7	174	netif_tx_disable(repr->netdev);
1025351a	175
29a5dcae	176	return nfp_flower_cmsg_portmod(repr, false, repr->netdev->mtu, false);
1025351a SH	177	}
1025351a SH	178
1a24d4f9 JH	179	static int
	180	nfp_flower_repr_netdev_init(struct nfp_app app, struct net_device netdev)
	181	{
	182	return tc_setup_cb_egdev_register(netdev,
	183	nfp_flower_setup_tc_egress_cb,
	184	netdev_priv(netdev));
	185	}
	186
	187	static void
	188	nfp_flower_repr_netdev_clean(struct nfp_app app, struct net_device netdev)
	189	{
	190	tc_setup_cb_egdev_unregister(netdev, nfp_flower_setup_tc_egress_cb,
	191	netdev_priv(netdev));
	192	}
	193
d2c2928d DM	194	static void
	195	nfp_flower_repr_netdev_preclean(struct nfp_app app, struct net_device netdev)
	196	{
	197	struct nfp_repr *repr = netdev_priv(netdev);
	198	struct nfp_flower_priv *priv = app->priv;
	199	atomic_t *replies = &priv->reify_replies;
	200	int err;
	201
	202	atomic_set(replies, 0);
	203	err = nfp_flower_cmsg_portreify(repr, false);
	204	if (err) {
	205	nfp_warn(app->cpp, "Failed to notify firmware about repr destruction\n");
	206	return;
	207	}
	208
	209	nfp_flower_wait_repr_reify(app, replies, 1);
	210	}
	211
24a021ed SH	212	static void nfp_flower_sriov_disable(struct nfp_app *app)
24a021ed SH	213	{
192e6851 JK	214	struct nfp_flower_priv *priv = app->priv;
	215
	216	if (!priv->nn)
	217	return;
	218
24a021ed SH	219	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
	220	}
	221
	222	static int
	223	nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
	224	enum nfp_flower_cmsg_port_vnic_type vnic_type,
	225	enum nfp_repr_type repr_type, unsigned int cnt)
	226	{
	227	u8 nfp_pcie = nfp_cppcore_pcie_unit(app->pf->cpp);
	228	struct nfp_flower_priv *priv = app->priv;
d2c2928d	229	atomic_t *replies = &priv->reify_replies;
38edbf6f	230	enum nfp_port_type port_type;
51ccc37d	231	struct nfp_reprs *reprs;
d2c2928d	232	int i, err, reify_cnt;
24a021ed	233	const u8 queue = 0;
24a021ed	234
38edbf6f JK	235	port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT :
	236	NFP_PORT_VF_PORT;
	237
24a021ed SH	238	reprs = nfp_reprs_alloc(cnt);
	239	if (!reprs)
	240	return -ENOMEM;
	241
	242	for (i = 0; i < cnt; i++) {
3eb47dfc	243	struct net_device *repr;
38edbf6f	244	struct nfp_port *port;
24a021ed SH	245	u32 port_id;
24a021ed SH	246
3eb47dfc JK	247	repr = nfp_repr_alloc(app);
3eb47dfc JK	248	if (!repr) {
24a021ed SH	249	err = -ENOMEM;
	250	goto err_reprs_clean;
	251	}
3eb47dfc	252	RCU_INIT_POINTER(reprs->reprs[i], repr);
24a021ed	253
ef0ec676 JK	254	/* For now we only support 1 PF */
	255	WARN_ON(repr_type == NFP_REPR_TYPE_PF && i);
	256
3eb47dfc	257	port = nfp_port_alloc(app, port_type, repr);
38edbf6f JK	258	if (repr_type == NFP_REPR_TYPE_PF) {
38edbf6f JK	259	port->pf_id = i;
ef0ec676	260	port->vnic = priv->nn->dp.ctrl_bar;
38edbf6f	261	} else {
ef0ec676	262	port->pf_id = 0;
38edbf6f	263	port->vf_id = i;
ef0ec676 JK	264	port->vnic =
ef0ec676 JK	265	app->pf->vf_cfg_mem + i * NFP_NET_CFG_BAR_SZ;
38edbf6f JK	266	}
38edbf6f JK	267
3eb47dfc	268	eth_hw_addr_random(repr);
24a021ed SH	269
	270	port_id = nfp_flower_cmsg_pcie_port(nfp_pcie, vnic_type,
	271	i, queue);
3eb47dfc	272	err = nfp_repr_init(app, repr,
38edbf6f JK	273	port_id, port, priv->nn->dp.netdev);
	274	if (err) {
	275	nfp_port_free(port);
24a021ed	276	goto err_reprs_clean;
38edbf6f	277	}
24a021ed SH	278
	279	nfp_info(app->cpp, "%s%d Representor(%s) created\n",
	280	repr_type == NFP_REPR_TYPE_PF ? "PF" : "VF", i,
3eb47dfc	281	repr->name);
24a021ed SH	282	}
24a021ed SH	283
51ccc37d	284	nfp_app_reprs_set(app, repr_type, reprs);
24a021ed	285
d2c2928d DM	286	atomic_set(replies, 0);
	287	reify_cnt = nfp_flower_reprs_reify(app, repr_type, true);
	288	if (reify_cnt < 0) {
	289	err = reify_cnt;
	290	nfp_warn(app->cpp, "Failed to notify firmware about repr creation\n");
	291	goto err_reprs_remove;
	292	}
	293
	294	err = nfp_flower_wait_repr_reify(app, replies, reify_cnt);
	295	if (err)
	296	goto err_reprs_remove;
	297
24a021ed	298	return 0;
d2c2928d DM	299	err_reprs_remove:
d2c2928d DM	300	reprs = nfp_app_reprs_set(app, repr_type, NULL);
24a021ed	301	err_reprs_clean:
3eb47dfc	302	nfp_reprs_clean_and_free(app, reprs);
24a021ed SH	303	return err;
	304	}
	305
	306	static int nfp_flower_sriov_enable(struct nfp_app *app, int num_vfs)
	307	{
192e6851 JK	308	struct nfp_flower_priv *priv = app->priv;
	309
	310	if (!priv->nn)
	311	return 0;
	312
24a021ed SH	313	return nfp_flower_spawn_vnic_reprs(app,
	314	NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
	315	NFP_REPR_TYPE_VF, num_vfs);
	316	}
	317
24a021ed SH	318	static int
24a021ed SH	319	nfp_flower_spawn_phy_reprs(struct nfp_app app, struct nfp_flower_priv priv)
1025351a SH	320	{
1025351a SH	321	struct nfp_eth_table *eth_tbl = app->pf->eth_tbl;
d2c2928d	322	atomic_t *replies = &priv->reify_replies;
12acb133	323	struct sk_buff *ctrl_skb;
51ccc37d	324	struct nfp_reprs *reprs;
d2c2928d	325	int err, reify_cnt;
1025351a	326	unsigned int i;
1025351a	327
12acb133 SH	328	ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count);
12acb133 SH	329	if (!ctrl_skb)
1025351a SH	330	return -ENOMEM;
1025351a SH	331
12acb133 SH	332	reprs = nfp_reprs_alloc(eth_tbl->max_index + 1);
	333	if (!reprs) {
	334	err = -ENOMEM;
	335	goto err_free_ctrl_skb;
	336	}
	337
1025351a	338	for (i = 0; i < eth_tbl->count; i++) {
12acb133	339	unsigned int phys_port = eth_tbl->ports[i].index;
3eb47dfc	340	struct net_device *repr;
1025351a SH	341	struct nfp_port *port;
	342	u32 cmsg_port_id;
	343
3eb47dfc JK	344	repr = nfp_repr_alloc(app);
3eb47dfc JK	345	if (!repr) {
1025351a SH	346	err = -ENOMEM;
	347	goto err_reprs_clean;
	348	}
3eb47dfc	349	RCU_INIT_POINTER(reprs->reprs[phys_port], repr);
1025351a	350
3eb47dfc	351	port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT, repr);
1025351a SH	352	if (IS_ERR(port)) {
	353	err = PTR_ERR(port);
	354	goto err_reprs_clean;
	355	}
	356	err = nfp_port_init_phy_port(app->pf, app, port, i);
	357	if (err) {
	358	nfp_port_free(port);
	359	goto err_reprs_clean;
	360	}
	361
3eb47dfc	362	SET_NETDEV_DEV(repr, &priv->nn->pdev->dev);
c55ca688	363	nfp_net_get_mac_addr(app->pf, repr, port);
1025351a SH	364
1025351a SH	365	cmsg_port_id = nfp_flower_cmsg_phys_port(phys_port);
3eb47dfc	366	err = nfp_repr_init(app, repr,
1025351a SH	367	cmsg_port_id, port, priv->nn->dp.netdev);
	368	if (err) {
	369	nfp_port_free(port);
	370	goto err_reprs_clean;
	371	}
	372
12acb133 SH	373	nfp_flower_cmsg_mac_repr_add(ctrl_skb, i,
	374	eth_tbl->ports[i].nbi,
	375	eth_tbl->ports[i].base,
	376	phys_port);
	377
1025351a	378	nfp_info(app->cpp, "Phys Port %d Representor(%s) created\n",
3eb47dfc	379	phys_port, repr->name);
1025351a SH	380	}
1025351a SH	381
51ccc37d	382	nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs);
1025351a	383
d2c2928d	384	/* The REIFY/MAC_REPR control messages should be sent after the MAC
12acb133 SH	385	* representors are registered using nfp_app_reprs_set(). This is
	386	* because the firmware may respond with control messages for the
	387	* MAC representors, f.e. to provide the driver with information
	388	* about their state, and without registration the driver will drop
	389	* any such messages.
	390	*/
d2c2928d DM	391	atomic_set(replies, 0);
	392	reify_cnt = nfp_flower_reprs_reify(app, NFP_REPR_TYPE_PHYS_PORT, true);
	393	if (reify_cnt < 0) {
	394	err = reify_cnt;
	395	nfp_warn(app->cpp, "Failed to notify firmware about repr creation\n");
	396	goto err_reprs_remove;
	397	}
	398
	399	err = nfp_flower_wait_repr_reify(app, replies, reify_cnt);
	400	if (err)
	401	goto err_reprs_remove;
	402
12acb133 SH	403	nfp_ctrl_tx(app->ctrl, ctrl_skb);
12acb133 SH	404
1025351a	405	return 0;
d2c2928d DM	406	err_reprs_remove:
d2c2928d DM	407	reprs = nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, NULL);
1025351a	408	err_reprs_clean:
3eb47dfc	409	nfp_reprs_clean_and_free(app, reprs);
12acb133 SH	410	err_free_ctrl_skb:
12acb133 SH	411	kfree_skb(ctrl_skb);
1025351a SH	412	return err;
	413	}
	414
c496291c JK	415	static int nfp_flower_vnic_alloc(struct nfp_app app, struct nfp_net nn,
c496291c JK	416	unsigned int id)
1025351a	417	{
1025351a SH	418	if (id > 0) {
	419	nfp_warn(app->cpp, "FlowerNIC doesn't support more than one data vNIC\n");
	420	goto err_invalid_port;
	421	}
	422
1025351a SH	423	eth_hw_addr_random(nn->dp.netdev);
	424	netif_keep_dst(nn->dp.netdev);
	425
	426	return 0;
	427
	428	err_invalid_port:
	429	nn->port = nfp_port_alloc(app, NFP_PORT_INVALID, nn->dp.netdev);
	430	return PTR_ERR_OR_ZERO(nn->port);
	431	}
	432
c496291c JK	433	static void nfp_flower_vnic_clean(struct nfp_app app, struct nfp_net nn)
	434	{
	435	struct nfp_flower_priv *priv = app->priv;
	436
192e6851 JK	437	if (app->pf->num_vfs)
	438	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
	439	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
	440	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
	441
c496291c JK	442	priv->nn = NULL;
	443	}
	444
	445	static int nfp_flower_vnic_init(struct nfp_app app, struct nfp_net nn)
	446	{
	447	struct nfp_flower_priv *priv = app->priv;
192e6851	448	int err;
c496291c JK	449
	450	priv->nn = nn;
	451
192e6851 JK	452	err = nfp_flower_spawn_phy_reprs(app, app->priv);
	453	if (err)
	454	goto err_clear_nn;
	455
	456	err = nfp_flower_spawn_vnic_reprs(app,
	457	NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF,
	458	NFP_REPR_TYPE_PF, 1);
	459	if (err)
	460	goto err_destroy_reprs_phy;
	461
	462	if (app->pf->num_vfs) {
	463	err = nfp_flower_spawn_vnic_reprs(app,
	464	NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
	465	NFP_REPR_TYPE_VF,
	466	app->pf->num_vfs);
	467	if (err)
	468	goto err_destroy_reprs_pf;
	469	}
	470
c496291c	471	return 0;
192e6851 JK	472
	473	err_destroy_reprs_pf:
	474	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
	475	err_destroy_reprs_phy:
	476	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
	477	err_clear_nn:
	478	priv->nn = NULL;
	479	return err;
c496291c JK	480	}
c496291c JK	481
1025351a SH	482	static int nfp_flower_init(struct nfp_app *app)
	483	{
	484	const struct nfp_pf *pf = app->pf;
b985f870	485	struct nfp_flower_priv *app_priv;
73997348	486	u64 version, features;
8a276873	487	int err;
1025351a SH	488
	489	if (!pf->eth_tbl) {
	490	nfp_warn(app->cpp, "FlowerNIC requires eth table\n");
	491	return -EINVAL;
	492	}
	493
	494	if (!pf->mac_stats_bar) {
	495	nfp_warn(app->cpp, "FlowerNIC requires mac_stats BAR\n");
	496	return -EINVAL;
	497	}
	498
	499	if (!pf->vf_cfg_bar) {
	500	nfp_warn(app->cpp, "FlowerNIC requires vf_cfg BAR\n");
	501	return -EINVAL;
	502	}
	503
8a276873 PJV	504	version = nfp_rtsym_read_le(app->pf->rtbl, "hw_flower_version", &err);
	505	if (err) {
	506	nfp_warn(app->cpp, "FlowerNIC requires hw_flower_version memory symbol\n");
	507	return err;
	508	}
	509
	510	/* We need to ensure hardware has enough flower capabilities. */
	511	if (version != NFP_FLOWER_ALLOWED_VER) {
	512	nfp_warn(app->cpp, "FlowerNIC: unsupported firmware version\n");
	513	return -EINVAL;
	514	}
	515
b985f870 SH	516	app_priv = vzalloc(sizeof(struct nfp_flower_priv));
b985f870 SH	517	if (!app_priv)
9ce6bbbb JK	518	return -ENOMEM;
9ce6bbbb JK	519
b985f870	520	app->priv = app_priv;
c496291c	521	app_priv->app = app;
cf2cbadc PJV	522	skb_queue_head_init(&app_priv->cmsg_skbs_high);
cf2cbadc PJV	523	skb_queue_head_init(&app_priv->cmsg_skbs_low);
b985f870	524	INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx);
d2c2928d	525	init_waitqueue_head(&app_priv->reify_wait_queue);
b985f870	526
29a5dcae JH	527	init_waitqueue_head(&app_priv->mtu_conf.wait_q);
	528	spin_lock_init(&app_priv->mtu_conf.lock);
	529
43f84b72 PJV	530	err = nfp_flower_metadata_init(app);
	531	if (err)
	532	goto err_free_app_priv;
	533
73997348 JH	534	/* Extract the extra features supported by the firmware. */
	535	features = nfp_rtsym_read_le(app->pf->rtbl,
	536	"_abi_flower_extra_features", &err);
	537	if (err)
	538	app_priv->flower_ext_feats = 0;
	539	else
	540	app_priv->flower_ext_feats = features;
	541
1025351a	542	return 0;
43f84b72 PJV	543
	544	err_free_app_priv:
	545	vfree(app->priv);
	546	return err;
1025351a SH	547	}
1025351a SH	548
9ce6bbbb JK	549	static void nfp_flower_clean(struct nfp_app *app)
9ce6bbbb JK	550	{
b985f870 SH	551	struct nfp_flower_priv *app_priv = app->priv;
b985f870 SH	552
cf2cbadc PJV	553	skb_queue_purge(&app_priv->cmsg_skbs_high);
cf2cbadc PJV	554	skb_queue_purge(&app_priv->cmsg_skbs_low);
b985f870 SH	555	flush_work(&app_priv->cmsg_work);
b985f870 SH	556
df7c7dd2	557	nfp_flower_metadata_cleanup(app);
43f84b72	558	vfree(app->priv);
9ce6bbbb JK	559	app->priv = NULL;
	560	}
	561
29a5dcae JH	562	static int
	563	nfp_flower_check_mtu(struct nfp_app app, struct net_device netdev,
	564	int new_mtu)
	565	{
	566	/* The flower fw reserves NFP_FLOWER_FRAME_HEADROOM bytes of the
	567	* supported max MTU to allow for appending tunnel headers. To prevent
	568	* unexpected behaviour this needs to be accounted for.
	569	*/
	570	if (new_mtu > netdev->max_mtu - NFP_FLOWER_FRAME_HEADROOM) {
	571	nfp_err(app->cpp, "New MTU (%d) is not valid\n", new_mtu);
	572	return -EINVAL;
	573	}
	574
	575	return 0;
	576	}
	577
	578	static bool nfp_flower_check_ack(struct nfp_flower_priv *app_priv)
	579	{
	580	bool ret;
	581
	582	spin_lock_bh(&app_priv->mtu_conf.lock);
	583	ret = app_priv->mtu_conf.ack;
	584	spin_unlock_bh(&app_priv->mtu_conf.lock);
	585
	586	return ret;
	587	}
	588
	589	static int
	590	nfp_flower_repr_change_mtu(struct nfp_app app, struct net_device netdev,
	591	int new_mtu)
	592	{
	593	struct nfp_flower_priv *app_priv = app->priv;
	594	struct nfp_repr *repr = netdev_priv(netdev);
	595	int err, ack;
	596
	597	/* Only need to config FW for physical port MTU change. */
	598	if (repr->port->type != NFP_PORT_PHYS_PORT)
	599	return 0;
	600
	601	if (!(app_priv->flower_ext_feats & NFP_FL_NBI_MTU_SETTING)) {
	602	nfp_err(app->cpp, "Physical port MTU setting not supported\n");
	603	return -EINVAL;
	604	}
	605
	606	spin_lock_bh(&app_priv->mtu_conf.lock);
	607	app_priv->mtu_conf.ack = false;
	608	app_priv->mtu_conf.requested_val = new_mtu;
	609	app_priv->mtu_conf.portnum = repr->dst->u.port_info.port_id;
	610	spin_unlock_bh(&app_priv->mtu_conf.lock);
	611
	612	err = nfp_flower_cmsg_portmod(repr, netif_carrier_ok(netdev), new_mtu,
	613	true);
	614	if (err) {
	615	spin_lock_bh(&app_priv->mtu_conf.lock);
	616	app_priv->mtu_conf.requested_val = 0;
	617	spin_unlock_bh(&app_priv->mtu_conf.lock);
	618	return err;
	619	}
	620
	621	/* Wait for fw to ack the change. */
	622	ack = wait_event_timeout(app_priv->mtu_conf.wait_q,
	623	nfp_flower_check_ack(app_priv),
	624	msecs_to_jiffies(10));
	625
626	if (!ack) {
627	spin_lock_bh(&app_priv->mtu_conf.lock);
628	app_priv->mtu_conf.requested_val = 0;
629	spin_unlock_bh(&app_priv->mtu_conf.lock);
630	nfp_warn(app->cpp, "MTU change not verified with fw\n");
631	return -EIO;
632	}
633
634	return 0;
635	}
636
fd0dd1ab JH	637	static int nfp_flower_start(struct nfp_app *app)
	638	{
	639	return nfp_tunnel_config_start(app);
	640	}
	641
	642	static void nfp_flower_stop(struct nfp_app *app)
	643	{
	644	nfp_tunnel_config_stop(app);
	645	}
	646
1025351a SH	647	const struct nfp_app_type app_flower = {
	648	.id = NFP_APP_FLOWER_NIC,
	649	.name = "flower",
78a0a65f JK	650
78a0a65f JK	651	.ctrl_cap_mask = ~0U,
1025351a SH	652	.ctrl_has_meta = true,
	653
	654	.extra_cap = nfp_flower_extra_cap,
	655
	656	.init = nfp_flower_init,
9ce6bbbb	657	.clean = nfp_flower_clean,
1025351a	658
29a5dcae JH	659	.check_mtu = nfp_flower_check_mtu,
	660	.repr_change_mtu = nfp_flower_repr_change_mtu,
	661
c496291c	662	.vnic_alloc = nfp_flower_vnic_alloc,
1025351a	663	.vnic_init = nfp_flower_vnic_init,
c496291c	664	.vnic_clean = nfp_flower_vnic_clean,
1025351a	665
1a24d4f9	666	.repr_init = nfp_flower_repr_netdev_init,
d2c2928d	667	.repr_preclean = nfp_flower_repr_netdev_preclean,
1a24d4f9 JH	668	.repr_clean = nfp_flower_repr_netdev_clean,
1a24d4f9 JH	669
5d7c64a7 JK	670	.repr_open = nfp_flower_repr_netdev_open,
	671	.repr_stop = nfp_flower_repr_netdev_stop,
	672
fd0dd1ab JH	673	.start = nfp_flower_start,
	674	.stop = nfp_flower_stop,
	675
1025351a SH	676	.ctrl_msg_rx = nfp_flower_cmsg_rx,
1025351a SH	677
24a021ed SH	678	.sriov_enable = nfp_flower_sriov_enable,
	679	.sriov_disable = nfp_flower_sriov_disable,
	680
1025351a SH	681	.eswitch_mode_get = eswitch_mode_get,
1025351a SH	682	.repr_get = nfp_flower_repr_get,
8a276873 PJV	683
8a276873 PJV	684	.setup_tc = nfp_flower_setup_tc,
1025351a	685	};