drivers/net/ethernet/netronome/nfp/flower/cmsg.c

   1 /*
   2  * Copyright (C) 2015-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/bitfield.h>
  35 #include <linux/netdevice.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/workqueue.h>
  38 #include <net/dst_metadata.h>
  39
  40 #include "main.h"
  41 #include "../nfpcore/nfp_cpp.h"
  42 #include "../nfp_net.h"
  43 #include "../nfp_net_repr.h"
  44 #include "./cmsg.h"
  45
  46 #define nfp_flower_cmsg_warn(app, fmt, args...)                         \
  47         do {                                                            \
  48                 if (net_ratelimit())                                    \
  49                         nfp_warn((app)->cpp, fmt, ## args);             \
  50         } while (0)
  51
  52 static struct nfp_flower_cmsg_hdr *
  53 nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
  54 {
  55         return (struct nfp_flower_cmsg_hdr *)skb->data;
  56 }
  57
  58 struct sk_buff *
  59 nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
  60                       enum nfp_flower_cmsg_type_port type)
  61 {
  62         struct nfp_flower_cmsg_hdr *ch;
  63         struct sk_buff *skb;
  64
  65         size += NFP_FLOWER_CMSG_HLEN;
  66
  67         skb = nfp_app_ctrl_msg_alloc(app, size, GFP_KERNEL);
  68         if (!skb)
  69                 return NULL;
  70
  71         ch = nfp_flower_cmsg_get_hdr(skb);
  72         ch->pad = 0;
  73         ch->version = NFP_FLOWER_CMSG_VER1;
  74         ch->type = type;
  75         skb_put(skb, size);
  76
  77         return skb;
  78 }
  79
  80 struct sk_buff *
  81 nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
  82 {
  83         struct nfp_flower_cmsg_mac_repr *msg;
  84         struct sk_buff *skb;
  85         unsigned int size;
  86
  87         size = sizeof(*msg) + num_ports * sizeof(msg->ports[0]);
  88         skb = nfp_flower_cmsg_alloc(app, size, NFP_FLOWER_CMSG_TYPE_MAC_REPR);
  89         if (!skb)
  90                 return NULL;
  91
  92         msg = nfp_flower_cmsg_get_data(skb);
  93         memset(msg->reserved, 0, sizeof(msg->reserved));
  94         msg->num_ports = num_ports;
  95
  96         return skb;
  97 }
  98
  99 void
 100 nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
 101                              unsigned int nbi, unsigned int nbi_port,
 102                              unsigned int phys_port)
 103 {
 104         struct nfp_flower_cmsg_mac_repr *msg;
 105
 106         msg = nfp_flower_cmsg_get_data(skb);
 107         msg->ports[idx].idx = idx;
 108         msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
 109         msg->ports[idx].nbi_port = nbi_port;
 110         msg->ports[idx].phys_port = phys_port;
 111 }
 112
 113 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok)
 114 {
 115         struct nfp_flower_cmsg_portmod *msg;
 116         struct sk_buff *skb;
 117
 118         skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
 119                                     NFP_FLOWER_CMSG_TYPE_PORT_MOD);
 120         if (!skb)
 121                 return -ENOMEM;
 122
 123         msg = nfp_flower_cmsg_get_data(skb);
 124         msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
 125         msg->reserved = 0;
 126         msg->info = carrier_ok;
 127         msg->mtu = cpu_to_be16(repr->netdev->mtu);
 128
 129         nfp_ctrl_tx(repr->app->ctrl, skb);
 130
 131         return 0;
 132 }
 133
 134 static void
 135 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
 136 {
 137         struct nfp_flower_cmsg_portmod *msg;
 138         struct net_device *netdev;
 139         bool link;
 140
 141         msg = nfp_flower_cmsg_get_data(skb);
 142         link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;
 143
 144         rtnl_lock();
 145         rcu_read_lock();
 146         netdev = nfp_app_repr_get(app, be32_to_cpu(msg->portnum));
 147         rcu_read_unlock();
 148         if (!netdev) {
 149                 nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
 150                                      be32_to_cpu(msg->portnum));
 151                 rtnl_unlock();
 152                 return;
 153         }
 154
 155         if (link) {
 156                 u16 mtu = be16_to_cpu(msg->mtu);
 157
 158                 netif_carrier_on(netdev);
 159
 160                 /* An MTU of 0 from the firmware should be ignored */
 161                 if (mtu)
 162                         dev_set_mtu(netdev, mtu);
 163         } else {
 164                 netif_carrier_off(netdev);
 165         }
 166         rtnl_unlock();
 167 }
 168
 169 static void
 170 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
 171 {
 172         struct nfp_flower_cmsg_hdr *cmsg_hdr;
 173         enum nfp_flower_cmsg_type_port type;
 174
 175         cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
 176
 177         if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
 178                 nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
 179                                      cmsg_hdr->version);
 180                 goto out;
 181         }
 182
 183         type = cmsg_hdr->type;
 184         switch (type) {
 185         case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
 186                 nfp_flower_cmsg_portmod_rx(app, skb);
 187                 break;
 188         case NFP_FLOWER_CMSG_TYPE_FLOW_STATS:
 189                 nfp_flower_rx_flow_stats(app, skb);
 190                 break;
 191         default:
 192                 nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
 193                                      type);
 194                 goto out;
 195         }
 196
 197         dev_consume_skb_any(skb);
 198         return;
 199 out:
 200         dev_kfree_skb_any(skb);
 201 }
 202
 203 void nfp_flower_cmsg_process_rx(struct work_struct *work)
 204 {
 205         struct nfp_flower_priv *priv;
 206         struct sk_buff *skb;
 207
 208         priv = container_of(work, struct nfp_flower_priv, cmsg_work);
 209
 210         while ((skb = skb_dequeue(&priv->cmsg_skbs)))
 211                 nfp_flower_cmsg_process_one_rx(priv->app, skb);
 212 }
 213
 214 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
 215 {
 216         struct nfp_flower_priv *priv = app->priv;
 217
 218         skb_queue_tail(&priv->cmsg_skbs, skb);
 219         schedule_work(&priv->cmsg_work);
 220 }