drivers/net/ethernet/netronome/nfp/nfp_net_repr.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4 #include <linux/etherdevice.h>
   5 #include <linux/io-64-nonatomic-hi-lo.h>
   6 #include <linux/lockdep.h>
   7 #include <net/dst_metadata.h>
   8
   9 #include "nfpcore/nfp_cpp.h"
  10 #include "nfpcore/nfp_nsp.h"
  11 #include "nfp_app.h"
  12 #include "nfp_main.h"
  13 #include "nfp_net.h"
  14 #include "nfp_net_ctrl.h"
  15 #include "nfp_net_repr.h"
  16 #include "nfp_net_sriov.h"
  17 #include "nfp_port.h"
  18
  19 struct net_device *
  20 nfp_repr_get_locked(struct nfp_app *app, struct nfp_reprs *set, unsigned int id)
  21 {
  22         return rcu_dereference_protected(set->reprs[id],
  23                                          lockdep_is_held(&app->pf->lock));
  24 }
  25
  26 static void
  27 nfp_repr_inc_tx_stats(struct net_device *netdev, unsigned int len,
  28                       int tx_status)
  29 {
  30         struct nfp_repr *repr = netdev_priv(netdev);
  31         struct nfp_repr_pcpu_stats *stats;
  32
  33         if (unlikely(tx_status != NET_XMIT_SUCCESS &&
  34                      tx_status != NET_XMIT_CN)) {
  35                 this_cpu_inc(repr->stats->tx_drops);
  36                 return;
  37         }
  38
  39         stats = this_cpu_ptr(repr->stats);
  40         u64_stats_update_begin(&stats->syncp);
  41         stats->tx_packets++;
  42         stats->tx_bytes += len;
  43         u64_stats_update_end(&stats->syncp);
  44 }
  45
  46 void nfp_repr_inc_rx_stats(struct net_device *netdev, unsigned int len)
  47 {
  48         struct nfp_repr *repr = netdev_priv(netdev);
  49         struct nfp_repr_pcpu_stats *stats;
  50
  51         stats = this_cpu_ptr(repr->stats);
  52         u64_stats_update_begin(&stats->syncp);
  53         stats->rx_packets++;
  54         stats->rx_bytes += len;
  55         u64_stats_update_end(&stats->syncp);
  56 }
  57
  58 static void
  59 nfp_repr_phy_port_get_stats64(struct nfp_port *port,
  60                               struct rtnl_link_stats64 *stats)
  61 {
  62         u8 __iomem *mem = port->eth_stats;
  63
  64         stats->tx_packets = readq(mem + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK);
  65         stats->tx_bytes = readq(mem + NFP_MAC_STATS_TX_OUT_OCTETS);
  66         stats->tx_dropped = readq(mem + NFP_MAC_STATS_TX_OUT_ERRORS);
  67
  68         stats->rx_packets = readq(mem + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK);
  69         stats->rx_bytes = readq(mem + NFP_MAC_STATS_RX_IN_OCTETS);
  70         stats->rx_dropped = readq(mem + NFP_MAC_STATS_RX_IN_ERRORS);
  71 }
  72
  73 static void
  74 nfp_repr_vnic_get_stats64(struct nfp_port *port,
  75                           struct rtnl_link_stats64 *stats)
  76 {
  77         /* TX and RX stats are flipped as we are returning the stats as seen
  78          * at the switch port corresponding to the VF.
  79          */
  80         stats->tx_packets = readq(port->vnic + NFP_NET_CFG_STATS_RX_FRAMES);
  81         stats->tx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_RX_OCTETS);
  82         stats->tx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_RX_DISCARDS);
  83
  84         stats->rx_packets = readq(port->vnic + NFP_NET_CFG_STATS_TX_FRAMES);
  85         stats->rx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_TX_OCTETS);
  86         stats->rx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_TX_DISCARDS);
  87 }
  88
  89 static void
  90 nfp_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
  91 {
  92         struct nfp_repr *repr = netdev_priv(netdev);
  93
  94         if (WARN_ON(!repr->port))
  95                 return;
  96
  97         switch (repr->port->type) {
  98         case NFP_PORT_PHYS_PORT:
  99                 if (!__nfp_port_get_eth_port(repr->port))
 100                         break;
 101                 nfp_repr_phy_port_get_stats64(repr->port, stats);
 102                 break;
 103         case NFP_PORT_PF_PORT:
 104         case NFP_PORT_VF_PORT:
 105                 nfp_repr_vnic_get_stats64(repr->port, stats);
 106         default:
 107                 break;
 108         }
 109 }
 110
 111 static bool
 112 nfp_repr_has_offload_stats(const struct net_device *dev, int attr_id)
 113 {
 114         switch (attr_id) {
 115         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 116                 return true;
 117         }
 118
 119         return false;
 120 }
 121
 122 static int
 123 nfp_repr_get_host_stats64(const struct net_device *netdev,
 124                           struct rtnl_link_stats64 *stats)
 125 {
 126         struct nfp_repr *repr = netdev_priv(netdev);
 127         int i;
 128
 129         for_each_possible_cpu(i) {
 130                 u64 tbytes, tpkts, tdrops, rbytes, rpkts;
 131                 struct nfp_repr_pcpu_stats *repr_stats;
 132                 unsigned int start;
 133
 134                 repr_stats = per_cpu_ptr(repr->stats, i);
 135                 do {
 136                         start = u64_stats_fetch_begin_irq(&repr_stats->syncp);
 137                         tbytes = repr_stats->tx_bytes;
 138                         tpkts = repr_stats->tx_packets;
 139                         tdrops = repr_stats->tx_drops;
 140                         rbytes = repr_stats->rx_bytes;
 141                         rpkts = repr_stats->rx_packets;
 142                 } while (u64_stats_fetch_retry_irq(&repr_stats->syncp, start));
 143
 144                 stats->tx_bytes += tbytes;
 145                 stats->tx_packets += tpkts;
 146                 stats->tx_dropped += tdrops;
 147                 stats->rx_bytes += rbytes;
 148                 stats->rx_packets += rpkts;
 149         }
 150
 151         return 0;
 152 }
 153
 154 static int
 155 nfp_repr_get_offload_stats(int attr_id, const struct net_device *dev,
 156                            void *stats)
 157 {
 158         switch (attr_id) {
 159         case IFLA_OFFLOAD_XSTATS_CPU_HIT:
 160                 return nfp_repr_get_host_stats64(dev, stats);
 161         }
 162
 163         return -EINVAL;
 164 }
 165
 166 static int nfp_repr_change_mtu(struct net_device *netdev, int new_mtu)
 167 {
 168         struct nfp_repr *repr = netdev_priv(netdev);
 169         int err;
 170
 171         err = nfp_app_check_mtu(repr->app, netdev, new_mtu);
 172         if (err)
 173                 return err;
 174
 175         err = nfp_app_repr_change_mtu(repr->app, netdev, new_mtu);
 176         if (err)
 177                 return err;
 178
 179         netdev->mtu = new_mtu;
 180
 181         return 0;
 182 }
 183
 184 static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev)
 185 {
 186         struct nfp_repr *repr = netdev_priv(netdev);
 187         unsigned int len = skb->len;
 188         int ret;
 189
 190         skb_dst_drop(skb);
 191         dst_hold((struct dst_entry *)repr->dst);
 192         skb_dst_set(skb, (struct dst_entry *)repr->dst);
 193         skb->dev = repr->dst->u.port_info.lower_dev;
 194
 195         ret = dev_queue_xmit(skb);
 196         nfp_repr_inc_tx_stats(netdev, len, ret);
 197
 198         return NETDEV_TX_OK;
 199 }
 200
 201 static int nfp_repr_stop(struct net_device *netdev)
 202 {
 203         struct nfp_repr *repr = netdev_priv(netdev);
 204         int err;
 205
 206         err = nfp_app_repr_stop(repr->app, repr);
 207         if (err)
 208                 return err;
 209
 210         nfp_port_configure(netdev, false);
 211         return 0;
 212 }
 213
 214 static int nfp_repr_open(struct net_device *netdev)
 215 {
 216         struct nfp_repr *repr = netdev_priv(netdev);
 217         int err;
 218
 219         err = nfp_port_configure(netdev, true);
 220         if (err)
 221                 return err;
 222
 223         err = nfp_app_repr_open(repr->app, repr);
 224         if (err)
 225                 goto err_port_disable;
 226
 227         return 0;
 228
 229 err_port_disable:
 230         nfp_port_configure(netdev, false);
 231         return err;
 232 }
 233
 234 static netdev_features_t
 235 nfp_repr_fix_features(struct net_device *netdev, netdev_features_t features)
 236 {
 237         struct nfp_repr *repr = netdev_priv(netdev);
 238         netdev_features_t old_features = features;
 239         netdev_features_t lower_features;
 240         struct net_device *lower_dev;
 241
 242         lower_dev = repr->dst->u.port_info.lower_dev;
 243
 244         lower_features = lower_dev->features;
 245         if (lower_features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM))
 246                 lower_features |= NETIF_F_HW_CSUM;
 247
 248         features = netdev_intersect_features(features, lower_features);
 249         features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_HW_TC);
 250         features |= NETIF_F_LLTX;
 251
 252         return features;
 253 }
 254
 255 const struct net_device_ops nfp_repr_netdev_ops = {
 256         .ndo_init               = nfp_app_ndo_init,
 257         .ndo_uninit             = nfp_app_ndo_uninit,
 258         .ndo_open               = nfp_repr_open,
 259         .ndo_stop               = nfp_repr_stop,
 260         .ndo_start_xmit         = nfp_repr_xmit,
 261         .ndo_change_mtu         = nfp_repr_change_mtu,
 262         .ndo_get_stats64        = nfp_repr_get_stats64,
 263         .ndo_has_offload_stats  = nfp_repr_has_offload_stats,
 264         .ndo_get_offload_stats  = nfp_repr_get_offload_stats,
 265         .ndo_get_phys_port_name = nfp_port_get_phys_port_name,
 266         .ndo_setup_tc           = nfp_port_setup_tc,
 267         .ndo_set_vf_mac         = nfp_app_set_vf_mac,
 268         .ndo_set_vf_vlan        = nfp_app_set_vf_vlan,
 269         .ndo_set_vf_spoofchk    = nfp_app_set_vf_spoofchk,
 270         .ndo_set_vf_trust       = nfp_app_set_vf_trust,
 271         .ndo_get_vf_config      = nfp_app_get_vf_config,
 272         .ndo_set_vf_link_state  = nfp_app_set_vf_link_state,
 273         .ndo_fix_features       = nfp_repr_fix_features,
 274         .ndo_set_features       = nfp_port_set_features,
 275         .ndo_set_mac_address    = eth_mac_addr,
 276         .ndo_get_port_parent_id = nfp_port_get_port_parent_id,
 277         .ndo_get_devlink_port   = nfp_devlink_get_devlink_port,
 278 };
 279
 280 void
 281 nfp_repr_transfer_features(struct net_device *netdev, struct net_device *lower)
 282 {
 283         struct nfp_repr *repr = netdev_priv(netdev);
 284
 285         if (repr->dst->u.port_info.lower_dev != lower)
 286                 return;
 287
 288         netdev->gso_max_size = lower->gso_max_size;
 289         netdev->gso_max_segs = lower->gso_max_segs;
 290
 291         netdev_update_features(netdev);
 292 }
 293
 294 static void nfp_repr_clean(struct nfp_repr *repr)
 295 {
 296         unregister_netdev(repr->netdev);
 297         nfp_app_repr_clean(repr->app, repr->netdev);
 298         dst_release((struct dst_entry *)repr->dst);
 299         nfp_port_free(repr->port);
 300 }
 301
 302 static struct lock_class_key nfp_repr_netdev_xmit_lock_key;
 303 static struct lock_class_key nfp_repr_netdev_addr_lock_key;
 304
 305 static void nfp_repr_set_lockdep_class_one(struct net_device *dev,
 306                                            struct netdev_queue *txq,
 307                                            void *_unused)
 308 {
 309         lockdep_set_class(&txq->_xmit_lock, &nfp_repr_netdev_xmit_lock_key);
 310 }
 311
 312 static void nfp_repr_set_lockdep_class(struct net_device *dev)
 313 {
 314         lockdep_set_class(&dev->addr_list_lock, &nfp_repr_netdev_addr_lock_key);
 315         netdev_for_each_tx_queue(dev, nfp_repr_set_lockdep_class_one, NULL);
 316 }
 317
 318 int nfp_repr_init(struct nfp_app *app, struct net_device *netdev,
 319                   u32 cmsg_port_id, struct nfp_port *port,
 320                   struct net_device *pf_netdev)
 321 {
 322         struct nfp_repr *repr = netdev_priv(netdev);
 323         struct nfp_net *nn = netdev_priv(pf_netdev);
 324         u32 repr_cap = nn->tlv_caps.repr_cap;
 325         int err;
 326
 327         nfp_repr_set_lockdep_class(netdev);
 328
 329         repr->port = port;
 330         repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL);
 331         if (!repr->dst)
 332                 return -ENOMEM;
 333         repr->dst->u.port_info.port_id = cmsg_port_id;
 334         repr->dst->u.port_info.lower_dev = pf_netdev;
 335
 336         netdev->netdev_ops = &nfp_repr_netdev_ops;
 337         netdev->ethtool_ops = &nfp_port_ethtool_ops;
 338
 339         netdev->max_mtu = pf_netdev->max_mtu;
 340
 341         /* Set features the lower device can support with representors */
 342         if (repr_cap & NFP_NET_CFG_CTRL_LIVE_ADDR)
 343                 netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
 344
 345         netdev->hw_features = NETIF_F_HIGHDMA;
 346         if (repr_cap & NFP_NET_CFG_CTRL_RXCSUM_ANY)
 347                 netdev->hw_features |= NETIF_F_RXCSUM;
 348         if (repr_cap & NFP_NET_CFG_CTRL_TXCSUM)
 349                 netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
 350         if (repr_cap & NFP_NET_CFG_CTRL_GATHER)
 351                 netdev->hw_features |= NETIF_F_SG;
 352         if ((repr_cap & NFP_NET_CFG_CTRL_LSO && nn->fw_ver.major > 2) ||
 353             repr_cap & NFP_NET_CFG_CTRL_LSO2)
 354                 netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6;
 355         if (repr_cap & NFP_NET_CFG_CTRL_RSS_ANY)
 356                 netdev->hw_features |= NETIF_F_RXHASH;
 357         if (repr_cap & NFP_NET_CFG_CTRL_VXLAN) {
 358                 if (repr_cap & NFP_NET_CFG_CTRL_LSO)
 359                         netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL;
 360         }
 361         if (repr_cap & NFP_NET_CFG_CTRL_NVGRE) {
 362                 if (repr_cap & NFP_NET_CFG_CTRL_LSO)
 363                         netdev->hw_features |= NETIF_F_GSO_GRE;
 364         }
 365         if (repr_cap & (NFP_NET_CFG_CTRL_VXLAN | NFP_NET_CFG_CTRL_NVGRE))
 366                 netdev->hw_enc_features = netdev->hw_features;
 367
 368         netdev->vlan_features = netdev->hw_features;
 369
 370         if (repr_cap & NFP_NET_CFG_CTRL_RXVLAN)
 371                 netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX;
 372         if (repr_cap & NFP_NET_CFG_CTRL_TXVLAN) {
 373                 if (repr_cap & NFP_NET_CFG_CTRL_LSO2)
 374                         netdev_warn(netdev, "Device advertises both TSO2 and TXVLAN. Refusing to enable TXVLAN.\n");
 375                 else
 376                         netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX;
 377         }
 378         if (repr_cap & NFP_NET_CFG_CTRL_CTAG_FILTER)
 379                 netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 380
 381         netdev->features = netdev->hw_features;
 382
 383         /* Advertise but disable TSO by default. */
 384         netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
 385         netdev->gso_max_segs = NFP_NET_LSO_MAX_SEGS;
 386
 387         netdev->priv_flags |= IFF_NO_QUEUE | IFF_DISABLE_NETPOLL;
 388         netdev->features |= NETIF_F_LLTX;
 389
 390         if (nfp_app_has_tc(app)) {
 391                 netdev->features |= NETIF_F_HW_TC;
 392                 netdev->hw_features |= NETIF_F_HW_TC;
 393         }
 394
 395         err = nfp_app_repr_init(app, netdev);
 396         if (err)
 397                 goto err_clean;
 398
 399         err = register_netdev(netdev);
 400         if (err)
 401                 goto err_repr_clean;
 402
 403         return 0;
 404
 405 err_repr_clean:
 406         nfp_app_repr_clean(app, netdev);
 407 err_clean:
 408         dst_release((struct dst_entry *)repr->dst);
 409         return err;
 410 }
 411
 412 static void __nfp_repr_free(struct nfp_repr *repr)
 413 {
 414         free_percpu(repr->stats);
 415         free_netdev(repr->netdev);
 416 }
 417
 418 void nfp_repr_free(struct net_device *netdev)
 419 {
 420         __nfp_repr_free(netdev_priv(netdev));
 421 }
 422
 423 struct net_device *
 424 nfp_repr_alloc_mqs(struct nfp_app *app, unsigned int txqs, unsigned int rxqs)
 425 {
 426         struct net_device *netdev;
 427         struct nfp_repr *repr;
 428
 429         netdev = alloc_etherdev_mqs(sizeof(*repr), txqs, rxqs);
 430         if (!netdev)
 431                 return NULL;
 432
 433         netif_carrier_off(netdev);
 434
 435         repr = netdev_priv(netdev);
 436         repr->netdev = netdev;
 437         repr->app = app;
 438
 439         repr->stats = netdev_alloc_pcpu_stats(struct nfp_repr_pcpu_stats);
 440         if (!repr->stats)
 441                 goto err_free_netdev;
 442
 443         return netdev;
 444
 445 err_free_netdev:
 446         free_netdev(netdev);
 447         return NULL;
 448 }
 449
 450 void nfp_repr_clean_and_free(struct nfp_repr *repr)
 451 {
 452         nfp_info(repr->app->cpp, "Destroying Representor(%s)\n",
 453                  repr->netdev->name);
 454         nfp_repr_clean(repr);
 455         __nfp_repr_free(repr);
 456 }
 457
 458 void nfp_reprs_clean_and_free(struct nfp_app *app, struct nfp_reprs *reprs)
 459 {
 460         struct net_device *netdev;
 461         unsigned int i;
 462
 463         for (i = 0; i < reprs->num_reprs; i++) {
 464                 netdev = nfp_repr_get_locked(app, reprs, i);
 465                 if (netdev)
 466                         nfp_repr_clean_and_free(netdev_priv(netdev));
 467         }
 468
 469         kfree(reprs);
 470 }
 471
 472 void
 473 nfp_reprs_clean_and_free_by_type(struct nfp_app *app, enum nfp_repr_type type)
 474 {
 475         struct net_device *netdev;
 476         struct nfp_reprs *reprs;
 477         int i;
 478
 479         reprs = rcu_dereference_protected(app->reprs[type],
 480                                           lockdep_is_held(&app->pf->lock));
 481         if (!reprs)
 482                 return;
 483
 484         /* Preclean must happen before we remove the reprs reference from the
 485          * app below.
 486          */
 487         for (i = 0; i < reprs->num_reprs; i++) {
 488                 netdev = nfp_repr_get_locked(app, reprs, i);
 489                 if (netdev)
 490                         nfp_app_repr_preclean(app, netdev);
 491         }
 492
 493         reprs = nfp_app_reprs_set(app, type, NULL);
 494
 495         synchronize_rcu();
 496         nfp_reprs_clean_and_free(app, reprs);
 497 }
 498
 499 struct nfp_reprs *nfp_reprs_alloc(unsigned int num_reprs)
 500 {
 501         struct nfp_reprs *reprs;
 502
 503         reprs = kzalloc(sizeof(*reprs) +
 504                         num_reprs * sizeof(struct net_device *), GFP_KERNEL);
 505         if (!reprs)
 506                 return NULL;
 507         reprs->num_reprs = num_reprs;
 508
 509         return reprs;
 510 }
 511
 512 int nfp_reprs_resync_phys_ports(struct nfp_app *app)
 513 {
 514         struct net_device *netdev;
 515         struct nfp_reprs *reprs;
 516         struct nfp_repr *repr;
 517         int i;
 518
 519         reprs = nfp_reprs_get_locked(app, NFP_REPR_TYPE_PHYS_PORT);
 520         if (!reprs)
 521                 return 0;
 522
 523         for (i = 0; i < reprs->num_reprs; i++) {
 524                 netdev = nfp_repr_get_locked(app, reprs, i);
 525                 if (!netdev)
 526                         continue;
 527
 528                 repr = netdev_priv(netdev);
 529                 if (repr->port->type != NFP_PORT_INVALID)
 530                         continue;
 531
 532                 nfp_app_repr_preclean(app, netdev);
 533                 rtnl_lock();
 534                 rcu_assign_pointer(reprs->reprs[i], NULL);
 535                 rtnl_unlock();
 536                 synchronize_rcu();
 537                 nfp_repr_clean(repr);
 538         }
 539
 540         return 0;
 541 }