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

   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>
  35 #include <linux/pci.h>
  36 #include <linux/skbuff.h>
  37 #include <linux/vmalloc.h>
  38 #include <net/devlink.h>
  39 #include <net/dst_metadata.h>
  40
  41 #include "main.h"
  42 #include "../nfpcore/nfp_cpp.h"
  43 #include "../nfpcore/nfp_nffw.h"
  44 #include "../nfpcore/nfp_nsp.h"
  45 #include "../nfp_app.h"
  46 #include "../nfp_main.h"
  47 #include "../nfp_net.h"
  48 #include "../nfp_net_repr.h"
  49 #include "../nfp_port.h"
  50 #include "./cmsg.h"
  51
  52 #define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL
  53
  54 static const char *nfp_flower_extra_cap(struct nfp_app *app, struct nfp_net *nn)
  55 {
  56         return "FLOWER";
  57 }
  58
  59 static enum devlink_eswitch_mode eswitch_mode_get(struct nfp_app *app)
  60 {
  61         return DEVLINK_ESWITCH_MODE_SWITCHDEV;
  62 }
  63
  64 static enum nfp_repr_type
  65 nfp_flower_repr_get_type_and_port(struct nfp_app *app, u32 port_id, u8 *port)
  66 {
  67         switch (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port_id)) {
  68         case NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT:
  69                 *port = FIELD_GET(NFP_FLOWER_CMSG_PORT_PHYS_PORT_NUM,
  70                                   port_id);
  71                 return NFP_REPR_TYPE_PHYS_PORT;
  72
  73         case NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT:
  74                 *port = FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC, port_id);
  75                 if (FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC_TYPE, port_id) ==
  76                     NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF)
  77                         return NFP_REPR_TYPE_PF;
  78                 else
  79                         return NFP_REPR_TYPE_VF;
  80         }
  81
  82         return NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC;
  83 }
  84
  85 static struct net_device *
  86 nfp_flower_repr_get(struct nfp_app *app, u32 port_id)
  87 {
  88         enum nfp_repr_type repr_type;
  89         struct nfp_reprs *reprs;
  90         u8 port = 0;
  91
  92         repr_type = nfp_flower_repr_get_type_and_port(app, port_id, &port);
  93
  94         reprs = rcu_dereference(app->reprs[repr_type]);
  95         if (!reprs)
  96                 return NULL;
  97
  98         if (port >= reprs->num_reprs)
  99                 return NULL;
 100
 101         return reprs->reprs[port];
 102 }
 103
 104 static int
 105 nfp_flower_repr_netdev_open(struct nfp_app *app, struct nfp_repr *repr)
 106 {
 107         int err;
 108
 109         err = nfp_flower_cmsg_portmod(repr, true);
 110         if (err)
 111                 return err;
 112
 113         netif_carrier_on(repr->netdev);
 114         netif_tx_wake_all_queues(repr->netdev);
 115
 116         return 0;
 117 }
 118
 119 static int
 120 nfp_flower_repr_netdev_stop(struct nfp_app *app, struct nfp_repr *repr)
 121 {
 122         netif_carrier_off(repr->netdev);
 123         netif_tx_disable(repr->netdev);
 124
 125         return nfp_flower_cmsg_portmod(repr, false);
 126 }
 127
 128 static void nfp_flower_sriov_disable(struct nfp_app *app)
 129 {
 130         struct nfp_flower_priv *priv = app->priv;
 131
 132         if (!priv->nn)
 133                 return;
 134
 135         nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
 136 }
 137
 138 static int
 139 nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
 140                             enum nfp_flower_cmsg_port_vnic_type vnic_type,
 141                             enum nfp_repr_type repr_type, unsigned int cnt)
 142 {
 143         u8 nfp_pcie = nfp_cppcore_pcie_unit(app->pf->cpp);
 144         struct nfp_flower_priv *priv = app->priv;
 145         enum nfp_port_type port_type;
 146         struct nfp_reprs *reprs;
 147         const u8 queue = 0;
 148         int i, err;
 149
 150         port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT :
 151                                                     NFP_PORT_VF_PORT;
 152
 153         reprs = nfp_reprs_alloc(cnt);
 154         if (!reprs)
 155                 return -ENOMEM;
 156
 157         for (i = 0; i < cnt; i++) {
 158                 struct nfp_port *port;
 159                 u32 port_id;
 160
 161                 reprs->reprs[i] = nfp_repr_alloc(app);
 162                 if (!reprs->reprs[i]) {
 163                         err = -ENOMEM;
 164                         goto err_reprs_clean;
 165                 }
 166
 167                 /* For now we only support 1 PF */
 168                 WARN_ON(repr_type == NFP_REPR_TYPE_PF && i);
 169
 170                 port = nfp_port_alloc(app, port_type, reprs->reprs[i]);
 171                 if (repr_type == NFP_REPR_TYPE_PF) {
 172                         port->pf_id = i;
 173                         port->vnic = priv->nn->dp.ctrl_bar;
 174                 } else {
 175                         port->pf_id = 0;
 176                         port->vf_id = i;
 177                         port->vnic =
 178                                 app->pf->vf_cfg_mem + i * NFP_NET_CFG_BAR_SZ;
 179                 }
 180
 181                 eth_hw_addr_random(reprs->reprs[i]);
 182
 183                 port_id = nfp_flower_cmsg_pcie_port(nfp_pcie, vnic_type,
 184                                                     i, queue);
 185                 err = nfp_repr_init(app, reprs->reprs[i],
 186                                     port_id, port, priv->nn->dp.netdev);
 187                 if (err) {
 188                         nfp_port_free(port);
 189                         goto err_reprs_clean;
 190                 }
 191
 192                 nfp_info(app->cpp, "%s%d Representor(%s) created\n",
 193                          repr_type == NFP_REPR_TYPE_PF ? "PF" : "VF", i,
 194                          reprs->reprs[i]->name);
 195         }
 196
 197         nfp_app_reprs_set(app, repr_type, reprs);
 198
 199         return 0;
 200 err_reprs_clean:
 201         nfp_reprs_clean_and_free(reprs);
 202         return err;
 203 }
 204
 205 static int nfp_flower_sriov_enable(struct nfp_app *app, int num_vfs)
 206 {
 207         struct nfp_flower_priv *priv = app->priv;
 208
 209         if (!priv->nn)
 210                 return 0;
 211
 212         return nfp_flower_spawn_vnic_reprs(app,
 213                                            NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
 214                                            NFP_REPR_TYPE_VF, num_vfs);
 215 }
 216
 217 static int
 218 nfp_flower_spawn_phy_reprs(struct nfp_app *app, struct nfp_flower_priv *priv)
 219 {
 220         struct nfp_eth_table *eth_tbl = app->pf->eth_tbl;
 221         struct sk_buff *ctrl_skb;
 222         struct nfp_reprs *reprs;
 223         unsigned int i;
 224         int err;
 225
 226         ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count);
 227         if (!ctrl_skb)
 228                 return -ENOMEM;
 229
 230         reprs = nfp_reprs_alloc(eth_tbl->max_index + 1);
 231         if (!reprs) {
 232                 err = -ENOMEM;
 233                 goto err_free_ctrl_skb;
 234         }
 235
 236         for (i = 0; i < eth_tbl->count; i++) {
 237                 unsigned int phys_port = eth_tbl->ports[i].index;
 238                 struct nfp_port *port;
 239                 u32 cmsg_port_id;
 240
 241                 reprs->reprs[phys_port] = nfp_repr_alloc(app);
 242                 if (!reprs->reprs[phys_port]) {
 243                         err = -ENOMEM;
 244                         goto err_reprs_clean;
 245                 }
 246
 247                 port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT,
 248                                       reprs->reprs[phys_port]);
 249                 if (IS_ERR(port)) {
 250                         err = PTR_ERR(port);
 251                         goto err_reprs_clean;
 252                 }
 253                 err = nfp_port_init_phy_port(app->pf, app, port, i);
 254                 if (err) {
 255                         nfp_port_free(port);
 256                         goto err_reprs_clean;
 257                 }
 258
 259                 SET_NETDEV_DEV(reprs->reprs[phys_port], &priv->nn->pdev->dev);
 260                 nfp_net_get_mac_addr(app->pf, port);
 261
 262                 cmsg_port_id = nfp_flower_cmsg_phys_port(phys_port);
 263                 err = nfp_repr_init(app, reprs->reprs[phys_port],
 264                                     cmsg_port_id, port, priv->nn->dp.netdev);
 265                 if (err) {
 266                         nfp_port_free(port);
 267                         goto err_reprs_clean;
 268                 }
 269
 270                 nfp_flower_cmsg_mac_repr_add(ctrl_skb, i,
 271                                              eth_tbl->ports[i].nbi,
 272                                              eth_tbl->ports[i].base,
 273                                              phys_port);
 274
 275                 nfp_info(app->cpp, "Phys Port %d Representor(%s) created\n",
 276                          phys_port, reprs->reprs[phys_port]->name);
 277         }
 278
 279         nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs);
 280
 281         /* The MAC_REPR control message should be sent after the MAC
 282          * representors are registered using nfp_app_reprs_set().  This is
 283          * because the firmware may respond with control messages for the
 284          * MAC representors, f.e. to provide the driver with information
 285          * about their state, and without registration the driver will drop
 286          * any such messages.
 287          */
 288         nfp_ctrl_tx(app->ctrl, ctrl_skb);
 289
 290         return 0;
 291 err_reprs_clean:
 292         nfp_reprs_clean_and_free(reprs);
 293 err_free_ctrl_skb:
 294         kfree_skb(ctrl_skb);
 295         return err;
 296 }
 297
 298 static int nfp_flower_vnic_alloc(struct nfp_app *app, struct nfp_net *nn,
 299                                  unsigned int id)
 300 {
 301         if (id > 0) {
 302                 nfp_warn(app->cpp, "FlowerNIC doesn't support more than one data vNIC\n");
 303                 goto err_invalid_port;
 304         }
 305
 306         eth_hw_addr_random(nn->dp.netdev);
 307         netif_keep_dst(nn->dp.netdev);
 308
 309         return 0;
 310
 311 err_invalid_port:
 312         nn->port = nfp_port_alloc(app, NFP_PORT_INVALID, nn->dp.netdev);
 313         return PTR_ERR_OR_ZERO(nn->port);
 314 }
 315
 316 static void nfp_flower_vnic_clean(struct nfp_app *app, struct nfp_net *nn)
 317 {
 318         struct nfp_flower_priv *priv = app->priv;
 319
 320         if (app->pf->num_vfs)
 321                 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
 322         nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
 323         nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
 324
 325         priv->nn = NULL;
 326 }
 327
 328 static int nfp_flower_vnic_init(struct nfp_app *app, struct nfp_net *nn)
 329 {
 330         struct nfp_flower_priv *priv = app->priv;
 331         int err;
 332
 333         priv->nn = nn;
 334
 335         err = nfp_flower_spawn_phy_reprs(app, app->priv);
 336         if (err)
 337                 goto err_clear_nn;
 338
 339         err = nfp_flower_spawn_vnic_reprs(app,
 340                                           NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF,
 341                                           NFP_REPR_TYPE_PF, 1);
 342         if (err)
 343                 goto err_destroy_reprs_phy;
 344
 345         if (app->pf->num_vfs) {
 346                 err = nfp_flower_spawn_vnic_reprs(app,
 347                                                   NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
 348                                                   NFP_REPR_TYPE_VF,
 349                                                   app->pf->num_vfs);
 350                 if (err)
 351                         goto err_destroy_reprs_pf;
 352         }
 353
 354         return 0;
 355
 356 err_destroy_reprs_pf:
 357         nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
 358 err_destroy_reprs_phy:
 359         nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
 360 err_clear_nn:
 361         priv->nn = NULL;
 362         return err;
 363 }
 364
 365 static int nfp_flower_init(struct nfp_app *app)
 366 {
 367         const struct nfp_pf *pf = app->pf;
 368         struct nfp_flower_priv *app_priv;
 369         u64 version;
 370         int err;
 371
 372         if (!pf->eth_tbl) {
 373                 nfp_warn(app->cpp, "FlowerNIC requires eth table\n");
 374                 return -EINVAL;
 375         }
 376
 377         if (!pf->mac_stats_bar) {
 378                 nfp_warn(app->cpp, "FlowerNIC requires mac_stats BAR\n");
 379                 return -EINVAL;
 380         }
 381
 382         if (!pf->vf_cfg_bar) {
 383                 nfp_warn(app->cpp, "FlowerNIC requires vf_cfg BAR\n");
 384                 return -EINVAL;
 385         }
 386
 387         version = nfp_rtsym_read_le(app->pf->rtbl, "hw_flower_version", &err);
 388         if (err) {
 389                 nfp_warn(app->cpp, "FlowerNIC requires hw_flower_version memory symbol\n");
 390                 return err;
 391         }
 392
 393         /* We need to ensure hardware has enough flower capabilities. */
 394         if (version != NFP_FLOWER_ALLOWED_VER) {
 395                 nfp_warn(app->cpp, "FlowerNIC: unsupported firmware version\n");
 396                 return -EINVAL;
 397         }
 398
 399         app_priv = vzalloc(sizeof(struct nfp_flower_priv));
 400         if (!app_priv)
 401                 return -ENOMEM;
 402
 403         app->priv = app_priv;
 404         app_priv->app = app;
 405         skb_queue_head_init(&app_priv->cmsg_skbs);
 406         INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx);
 407
 408         err = nfp_flower_metadata_init(app);
 409         if (err)
 410                 goto err_free_app_priv;
 411
 412         return 0;
 413
 414 err_free_app_priv:
 415         vfree(app->priv);
 416         return err;
 417 }
 418
 419 static void nfp_flower_clean(struct nfp_app *app)
 420 {
 421         struct nfp_flower_priv *app_priv = app->priv;
 422
 423         skb_queue_purge(&app_priv->cmsg_skbs);
 424         flush_work(&app_priv->cmsg_work);
 425
 426         nfp_flower_metadata_cleanup(app);
 427         vfree(app->priv);
 428         app->priv = NULL;
 429 }
 430
 431 static int nfp_flower_start(struct nfp_app *app)
 432 {
 433         return nfp_tunnel_config_start(app);
 434 }
 435
 436 static void nfp_flower_stop(struct nfp_app *app)
 437 {
 438         nfp_tunnel_config_stop(app);
 439 }
 440
 441 const struct nfp_app_type app_flower = {
 442         .id             = NFP_APP_FLOWER_NIC,
 443         .name           = "flower",
 444         .ctrl_has_meta  = true,
 445
 446         .extra_cap      = nfp_flower_extra_cap,
 447
 448         .init           = nfp_flower_init,
 449         .clean          = nfp_flower_clean,
 450
 451         .vnic_alloc     = nfp_flower_vnic_alloc,
 452         .vnic_init      = nfp_flower_vnic_init,
 453         .vnic_clean     = nfp_flower_vnic_clean,
 454
 455         .repr_open      = nfp_flower_repr_netdev_open,
 456         .repr_stop      = nfp_flower_repr_netdev_stop,
 457
 458         .start          = nfp_flower_start,
 459         .stop           = nfp_flower_stop,
 460
 461         .ctrl_msg_rx    = nfp_flower_cmsg_rx,
 462
 463         .sriov_enable   = nfp_flower_sriov_enable,
 464         .sriov_disable  = nfp_flower_sriov_disable,
 465
 466         .eswitch_mode_get  = eswitch_mode_get,
 467         .repr_get       = nfp_flower_repr_get,
 468
 469         .setup_tc       = nfp_flower_setup_tc,
 470 };