nfp: flower: implement the PORT_REIFY message

The PORT_REIFY message indicates whether reprs have been created or
when they are about to be destroyed. This is necessary so firmware
can know which state the driver is in, e.g. the firmware will not send
any control messages related to ports when the reprs are destroyed.

This prevents nuisance warning messages printed whenever the firmware
sends updates for non-existent reprs.

Signed-off-by: Dirk van der Merwe <dirk.vandermerwe@netronome.com>
Reviewed-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/netronome/nfp/flower/cmsg.c b/drivers/net/ethernet/netronome/nfp/flower/cmsg.c
index e98bb9cdb6a37f3e1e3b3529f39ae24e491dabc0..615314d9e7c627b22eb76d29b75e337356846ab0 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/cmsg.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/cmsg.c
@@ -125,6 +125,27 @@ int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok)
        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 void
 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
 {
@@ -160,6 +181,28 @@ nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
        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_repr_get(app, be32_to_cpu(msg->portnum));
+       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_interruptible(&priv->reify_wait_queue);
+}
+
 static void
 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
 {
@@ -176,6 +219,9 @@ nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
 
        type = cmsg_hdr->type;
        switch (type) {
+       case NFP_FLOWER_CMSG_TYPE_PORT_REIFY:
+               nfp_flower_cmsg_portreify_rx(app, skb);
+               break;
        case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
                nfp_flower_cmsg_portmod_rx(app, skb);
                break;

diff --git a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h
index 992d2eec1019217ad1ccc59f0f1dfcaa5b8de73e..adfe474c2cf0714afe49c9b2a89fef3d604744bd 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/cmsg.h
+++ b/drivers/net/ethernet/netronome/nfp/flower/cmsg.h
@@ -350,6 +350,7 @@ struct nfp_flower_cmsg_hdr {
 enum nfp_flower_cmsg_type_port {
        NFP_FLOWER_CMSG_TYPE_FLOW_ADD =         0,
        NFP_FLOWER_CMSG_TYPE_FLOW_DEL =         2,
+       NFP_FLOWER_CMSG_TYPE_PORT_REIFY =       6,
        NFP_FLOWER_CMSG_TYPE_MAC_REPR =         7,
        NFP_FLOWER_CMSG_TYPE_PORT_MOD =         8,
        NFP_FLOWER_CMSG_TYPE_NO_NEIGH =         10,
@@ -386,6 +387,15 @@ struct nfp_flower_cmsg_portmod {
 
 #define NFP_FLOWER_CMSG_PORTMOD_INFO_LINK      BIT(0)
 
+/* NFP_FLOWER_CMSG_TYPE_PORT_REIFY */
+struct nfp_flower_cmsg_portreify {
+       __be32 portnum;
+       u16 reserved;
+       __be16 info;
+};
+
+#define NFP_FLOWER_CMSG_PORTREIFY_INFO_EXIST   BIT(0)
+
 enum nfp_flower_cmsg_port_type {
        NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC =      0x0,
        NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT =   0x1,
@@ -444,6 +454,7 @@ nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
                             unsigned int nbi, unsigned int nbi_port,
                             unsigned int phys_port);
 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok);
+int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists);
 void nfp_flower_cmsg_process_rx(struct work_struct *work);
 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb);
 struct sk_buff *

diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.c b/drivers/net/ethernet/netronome/nfp/flower/main.c
index 252d19236ad851430bc31b38604cceb15bf7aa74..67c40681536549087619b7481ccb533d3547eda6 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/main.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/main.c
@@ -32,6 +32,7 @@
  */
 
 #include <linux/etherdevice.h>
+#include <linux/lockdep.h>
 #include <linux/pci.h>
 #include <linux/skbuff.h>
 #include <linux/vmalloc.h>
@@ -101,6 +102,52 @@ nfp_flower_repr_get(struct nfp_app *app, u32 port_id)
        return 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++)
+               if (reprs->reprs[i]) {
+                       struct nfp_repr *repr = netdev_priv(reprs->reprs[i]);
+
+                       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)
 {
@@ -138,6 +185,24 @@ nfp_flower_repr_netdev_clean(struct nfp_app *app, struct net_device *netdev)
                                     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;
@@ -155,10 +220,11 @@ nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
 {
        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;
-       int i, err;
 
        port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT :
                                                    NFP_PORT_VF_PORT;
@@ -209,7 +275,21 @@ nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
 
        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(reprs);
        return err;
@@ -231,10 +311,11 @@ 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;
-       int err;
 
        ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count);
        if (!ctrl_skb)
@@ -291,16 +372,30 @@ nfp_flower_spawn_phy_reprs(struct nfp_app *app, struct nfp_flower_priv *priv)
 
        nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs);
 
-       /* The MAC_REPR control message should be sent after the MAC
+       /* 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(reprs);
 err_free_ctrl_skb:
@@ -417,6 +512,7 @@ static int nfp_flower_init(struct nfp_app *app)
        app_priv->app = app;
        skb_queue_head_init(&app_priv->cmsg_skbs);
        INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx);
+       init_waitqueue_head(&app_priv->reify_wait_queue);
 
        err = nfp_flower_metadata_init(app);
        if (err)
@@ -474,6 +570,7 @@ const struct nfp_app_type app_flower = {
        .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,

diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.h b/drivers/net/ethernet/netronome/nfp/flower/main.h
index 6e3937a0b708b57394b395dc303cb427f3033118..332ff0fdc038dea3471822b64eacfb6953c941fc 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/main.h
+++ b/drivers/net/ethernet/netronome/nfp/flower/main.h
@@ -102,6 +102,9 @@ struct nfp_fl_stats_id {
  * @nfp_mac_off_count: Number of MACs in address list
  * @nfp_tun_mac_nb:    Notifier to monitor link state
  * @nfp_tun_neigh_nb:  Notifier to monitor neighbour state
+ * @reify_replies:     atomically stores the number of replies received
+ *                     from firmware for repr reify
+ * @reify_wait_queue:  wait queue for repr reify response counting
  */
 struct nfp_flower_priv {
        struct nfp_app *app;
@@ -127,6 +130,8 @@ struct nfp_flower_priv {
        int nfp_mac_off_count;
        struct notifier_block nfp_tun_mac_nb;
        struct notifier_block nfp_tun_neigh_nb;
+       atomic_t reify_replies;
+       wait_queue_head_t reify_wait_queue;
 };
 
 struct nfp_fl_key_ls {