drivers/net/ethernet/netronome/nfp/nfp_net_ethtool.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 /*
  35  * nfp_net_ethtool.c
  36  * Netronome network device driver: ethtool support
  37  * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
  38  *          Jason McMullan <jason.mcmullan@netronome.com>
  39  *          Rolf Neugebauer <rolf.neugebauer@netronome.com>
  40  *          Brad Petrus <brad.petrus@netronome.com>
  41  */
  42
  43 #include <linux/bitfield.h>
  44 #include <linux/kernel.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/interrupt.h>
  48 #include <linux/pci.h>
  49 #include <linux/ethtool.h>
  50
  51 #include "nfpcore/nfp.h"
  52 #include "nfpcore/nfp_nsp.h"
  53 #include "nfp_app.h"
  54 #include "nfp_net_ctrl.h"
  55 #include "nfp_net.h"
  56 #include "nfp_port.h"
  57
  58 enum nfp_dump_diag {
  59         NFP_DUMP_NSP_DIAG = 0,
  60 };
  61
  62 struct nfp_et_stat {
  63         char name[ETH_GSTRING_LEN];
  64         int off;
  65 };
  66
  67 static const struct nfp_et_stat nfp_net_et_stats[] = {
  68         /* Stats from the device */
  69         { "dev_rx_discards",    NFP_NET_CFG_STATS_RX_DISCARDS },
  70         { "dev_rx_errors",      NFP_NET_CFG_STATS_RX_ERRORS },
  71         { "dev_rx_bytes",       NFP_NET_CFG_STATS_RX_OCTETS },
  72         { "dev_rx_uc_bytes",    NFP_NET_CFG_STATS_RX_UC_OCTETS },
  73         { "dev_rx_mc_bytes",    NFP_NET_CFG_STATS_RX_MC_OCTETS },
  74         { "dev_rx_bc_bytes",    NFP_NET_CFG_STATS_RX_BC_OCTETS },
  75         { "dev_rx_pkts",        NFP_NET_CFG_STATS_RX_FRAMES },
  76         { "dev_rx_mc_pkts",     NFP_NET_CFG_STATS_RX_MC_FRAMES },
  77         { "dev_rx_bc_pkts",     NFP_NET_CFG_STATS_RX_BC_FRAMES },
  78
  79         { "dev_tx_discards",    NFP_NET_CFG_STATS_TX_DISCARDS },
  80         { "dev_tx_errors",      NFP_NET_CFG_STATS_TX_ERRORS },
  81         { "dev_tx_bytes",       NFP_NET_CFG_STATS_TX_OCTETS },
  82         { "dev_tx_uc_bytes",    NFP_NET_CFG_STATS_TX_UC_OCTETS },
  83         { "dev_tx_mc_bytes",    NFP_NET_CFG_STATS_TX_MC_OCTETS },
  84         { "dev_tx_bc_bytes",    NFP_NET_CFG_STATS_TX_BC_OCTETS },
  85         { "dev_tx_pkts",        NFP_NET_CFG_STATS_TX_FRAMES },
  86         { "dev_tx_mc_pkts",     NFP_NET_CFG_STATS_TX_MC_FRAMES },
  87         { "dev_tx_bc_pkts",     NFP_NET_CFG_STATS_TX_BC_FRAMES },
  88
  89         { "bpf_pass_pkts",      NFP_NET_CFG_STATS_APP0_FRAMES },
  90         { "bpf_pass_bytes",     NFP_NET_CFG_STATS_APP0_BYTES },
  91         /* see comments in outro functions in nfp_bpf_jit.c to find out
  92          * how different BPF modes use app-specific counters
  93          */
  94         { "bpf_app1_pkts",      NFP_NET_CFG_STATS_APP1_FRAMES },
  95         { "bpf_app1_bytes",     NFP_NET_CFG_STATS_APP1_BYTES },
  96         { "bpf_app2_pkts",      NFP_NET_CFG_STATS_APP2_FRAMES },
  97         { "bpf_app2_bytes",     NFP_NET_CFG_STATS_APP2_BYTES },
  98         { "bpf_app3_pkts",      NFP_NET_CFG_STATS_APP3_FRAMES },
  99         { "bpf_app3_bytes",     NFP_NET_CFG_STATS_APP3_BYTES },
 100 };
 101
 102 static const struct nfp_et_stat nfp_mac_et_stats[] = {
 103         { "rx_octets",                  NFP_MAC_STATS_RX_IN_OCTETS, },
 104         { "rx_frame_too_long_errors",
 105                         NFP_MAC_STATS_RX_FRAME_TOO_LONG_ERRORS, },
 106         { "rx_range_length_errors",     NFP_MAC_STATS_RX_RANGE_LENGTH_ERRORS, },
 107         { "rx_vlan_reveive_ok",         NFP_MAC_STATS_RX_VLAN_REVEIVE_OK, },
 108         { "rx_errors",                  NFP_MAC_STATS_RX_IN_ERRORS, },
 109         { "rx_broadcast_pkts",          NFP_MAC_STATS_RX_IN_BROADCAST_PKTS, },
 110         { "rx_drop_events",             NFP_MAC_STATS_RX_DROP_EVENTS, },
 111         { "rx_alignment_errors",        NFP_MAC_STATS_RX_ALIGNMENT_ERRORS, },
 112         { "rx_pause_mac_ctrl_frames",
 113                         NFP_MAC_STATS_RX_PAUSE_MAC_CTRL_FRAMES, },
 114         { "rx_frames_received_ok",      NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK, },
 115         { "rx_frame_check_sequence_errors",
 116                         NFP_MAC_STATS_RX_FRAME_CHECK_SEQUENCE_ERRORS, },
 117         { "rx_unicast_pkts",            NFP_MAC_STATS_RX_UNICAST_PKTS, },
 118         { "rx_multicast_pkts",          NFP_MAC_STATS_RX_MULTICAST_PKTS, },
 119         { "rx_pkts",                    NFP_MAC_STATS_RX_PKTS, },
 120         { "rx_undersize_pkts",          NFP_MAC_STATS_RX_UNDERSIZE_PKTS, },
 121         { "rx_pkts_64_octets",          NFP_MAC_STATS_RX_PKTS_64_OCTETS, },
 122         { "rx_pkts_65_to_127_octets",
 123                         NFP_MAC_STATS_RX_PKTS_65_TO_127_OCTETS, },
 124         { "rx_pkts_128_to_255_octets",
 125                         NFP_MAC_STATS_RX_PKTS_128_TO_255_OCTETS, },
 126         { "rx_pkts_256_to_511_octets",
 127                         NFP_MAC_STATS_RX_PKTS_256_TO_511_OCTETS, },
 128         { "rx_pkts_512_to_1023_octets",
 129                         NFP_MAC_STATS_RX_PKTS_512_TO_1023_OCTETS, },
 130         { "rx_pkts_1024_to_1518_octets",
 131                         NFP_MAC_STATS_RX_PKTS_1024_TO_1518_OCTETS, },
 132         { "rx_pkts_1519_to_max_octets",
 133                         NFP_MAC_STATS_RX_PKTS_1519_TO_MAX_OCTETS, },
 134         { "rx_jabbers",                 NFP_MAC_STATS_RX_JABBERS, },
 135         { "rx_fragments",               NFP_MAC_STATS_RX_FRAGMENTS, },
 136         { "rx_oversize_pkts",           NFP_MAC_STATS_RX_OVERSIZE_PKTS, },
 137         { "rx_pause_frames_class0",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS0, },
 138         { "rx_pause_frames_class1",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS1, },
 139         { "rx_pause_frames_class2",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS2, },
 140         { "rx_pause_frames_class3",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS3, },
 141         { "rx_pause_frames_class4",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS4, },
 142         { "rx_pause_frames_class5",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS5, },
 143         { "rx_pause_frames_class6",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS6, },
 144         { "rx_pause_frames_class7",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS7, },
 145         { "rx_mac_ctrl_frames_received",
 146                         NFP_MAC_STATS_RX_MAC_CTRL_FRAMES_RECEIVED, },
 147         { "rx_mac_head_drop",           NFP_MAC_STATS_RX_MAC_HEAD_DROP, },
 148         { "tx_queue_drop",              NFP_MAC_STATS_TX_QUEUE_DROP, },
 149         { "tx_octets",                  NFP_MAC_STATS_TX_OUT_OCTETS, },
 150         { "tx_vlan_transmitted_ok",     NFP_MAC_STATS_TX_VLAN_TRANSMITTED_OK, },
 151         { "tx_errors",                  NFP_MAC_STATS_TX_OUT_ERRORS, },
 152         { "tx_broadcast_pkts",          NFP_MAC_STATS_TX_BROADCAST_PKTS, },
 153         { "tx_pause_mac_ctrl_frames",
 154                         NFP_MAC_STATS_TX_PAUSE_MAC_CTRL_FRAMES, },
 155         { "tx_frames_transmitted_ok",
 156                         NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK, },
 157         { "tx_unicast_pkts",            NFP_MAC_STATS_TX_UNICAST_PKTS, },
 158         { "tx_multicast_pkts",          NFP_MAC_STATS_TX_MULTICAST_PKTS, },
 159         { "tx_pkts_64_octets",          NFP_MAC_STATS_TX_PKTS_64_OCTETS, },
 160         { "tx_pkts_65_to_127_octets",
 161                         NFP_MAC_STATS_TX_PKTS_65_TO_127_OCTETS, },
 162         { "tx_pkts_128_to_255_octets",
 163                         NFP_MAC_STATS_TX_PKTS_128_TO_255_OCTETS, },
 164         { "tx_pkts_256_to_511_octets",
 165                         NFP_MAC_STATS_TX_PKTS_256_TO_511_OCTETS, },
 166         { "tx_pkts_512_to_1023_octets",
 167                         NFP_MAC_STATS_TX_PKTS_512_TO_1023_OCTETS, },
 168         { "tx_pkts_1024_to_1518_octets",
 169                         NFP_MAC_STATS_TX_PKTS_1024_TO_1518_OCTETS, },
 170         { "tx_pkts_1519_to_max_octets",
 171                         NFP_MAC_STATS_TX_PKTS_1519_TO_MAX_OCTETS, },
 172         { "tx_pause_frames_class0",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS0, },
 173         { "tx_pause_frames_class1",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS1, },
 174         { "tx_pause_frames_class2",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS2, },
 175         { "tx_pause_frames_class3",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS3, },
 176         { "tx_pause_frames_class4",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS4, },
 177         { "tx_pause_frames_class5",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS5, },
 178         { "tx_pause_frames_class6",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS6, },
 179         { "tx_pause_frames_class7",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS7, },
 180 };
 181
 182 #define NN_ET_GLOBAL_STATS_LEN ARRAY_SIZE(nfp_net_et_stats)
 183 #define NN_ET_SWITCH_STATS_LEN 9
 184 #define NN_ET_RVEC_GATHER_STATS 7
 185
 186 static void nfp_net_get_nspinfo(struct nfp_app *app, char *version)
 187 {
 188         struct nfp_nsp *nsp;
 189
 190         if (!app)
 191                 return;
 192
 193         nsp = nfp_nsp_open(app->cpp);
 194         if (IS_ERR(nsp))
 195                 return;
 196
 197         snprintf(version, ETHTOOL_FWVERS_LEN, "%hu.%hu",
 198                  nfp_nsp_get_abi_ver_major(nsp),
 199                  nfp_nsp_get_abi_ver_minor(nsp));
 200
 201         nfp_nsp_close(nsp);
 202 }
 203
 204 static void
 205 nfp_get_drvinfo(struct nfp_app *app, struct pci_dev *pdev,
 206                 const char *vnic_version, struct ethtool_drvinfo *drvinfo)
 207 {
 208         char nsp_version[ETHTOOL_FWVERS_LEN] = {};
 209
 210         strlcpy(drvinfo->driver, pdev->driver->name, sizeof(drvinfo->driver));
 211         strlcpy(drvinfo->version, nfp_driver_version, sizeof(drvinfo->version));
 212
 213         nfp_net_get_nspinfo(app, nsp_version);
 214         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 215                  "%s %s %s %s", vnic_version, nsp_version,
 216                  nfp_app_mip_name(app), nfp_app_name(app));
 217 }
 218
 219 static void
 220 nfp_net_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
 221 {
 222         char vnic_version[ETHTOOL_FWVERS_LEN] = {};
 223         struct nfp_net *nn = netdev_priv(netdev);
 224
 225         snprintf(vnic_version, sizeof(vnic_version), "%d.%d.%d.%d",
 226                  nn->fw_ver.resv, nn->fw_ver.class,
 227                  nn->fw_ver.major, nn->fw_ver.minor);
 228         strlcpy(drvinfo->bus_info, pci_name(nn->pdev),
 229                 sizeof(drvinfo->bus_info));
 230
 231         nfp_get_drvinfo(nn->app, nn->pdev, vnic_version, drvinfo);
 232 }
 233
 234 static void
 235 nfp_app_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
 236 {
 237         struct nfp_app *app;
 238
 239         app = nfp_app_from_netdev(netdev);
 240         if (!app)
 241                 return;
 242
 243         nfp_get_drvinfo(app, app->pdev, "*", drvinfo);
 244 }
 245
 246 /**
 247  * nfp_net_get_link_ksettings - Get Link Speed settings
 248  * @netdev:     network interface device structure
 249  * @cmd:        ethtool command
 250  *
 251  * Reports speed settings based on info in the BAR provided by the fw.
 252  */
 253 static int
 254 nfp_net_get_link_ksettings(struct net_device *netdev,
 255                            struct ethtool_link_ksettings *cmd)
 256 {
 257         static const u32 ls_to_ethtool[] = {
 258                 [NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED] = 0,
 259                 [NFP_NET_CFG_STS_LINK_RATE_UNKNOWN]     = SPEED_UNKNOWN,
 260                 [NFP_NET_CFG_STS_LINK_RATE_1G]          = SPEED_1000,
 261                 [NFP_NET_CFG_STS_LINK_RATE_10G]         = SPEED_10000,
 262                 [NFP_NET_CFG_STS_LINK_RATE_25G]         = SPEED_25000,
 263                 [NFP_NET_CFG_STS_LINK_RATE_40G]         = SPEED_40000,
 264                 [NFP_NET_CFG_STS_LINK_RATE_50G]         = SPEED_50000,
 265                 [NFP_NET_CFG_STS_LINK_RATE_100G]        = SPEED_100000,
 266         };
 267         struct nfp_eth_table_port *eth_port;
 268         struct nfp_port *port;
 269         struct nfp_net *nn;
 270         u32 sts, ls;
 271
 272         /* Init to unknowns */
 273         ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE);
 274         ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
 275         ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
 276         cmd->base.port = PORT_OTHER;
 277         cmd->base.speed = SPEED_UNKNOWN;
 278         cmd->base.duplex = DUPLEX_UNKNOWN;
 279
 280         port = nfp_port_from_netdev(netdev);
 281         eth_port = nfp_port_get_eth_port(port);
 282         if (eth_port)
 283                 cmd->base.autoneg = eth_port->aneg != NFP_ANEG_DISABLED ?
 284                         AUTONEG_ENABLE : AUTONEG_DISABLE;
 285
 286         if (!netif_carrier_ok(netdev))
 287                 return 0;
 288
 289         /* Use link speed from ETH table if available, otherwise try the BAR */
 290         if (eth_port) {
 291                 cmd->base.port = eth_port->port_type;
 292                 cmd->base.speed = eth_port->speed;
 293                 cmd->base.duplex = DUPLEX_FULL;
 294                 return 0;
 295         }
 296
 297         if (!nfp_netdev_is_nfp_net(netdev))
 298                 return -EOPNOTSUPP;
 299         nn = netdev_priv(netdev);
 300
 301         sts = nn_readl(nn, NFP_NET_CFG_STS);
 302
 303         ls = FIELD_GET(NFP_NET_CFG_STS_LINK_RATE, sts);
 304         if (ls == NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED)
 305                 return -EOPNOTSUPP;
 306
 307         if (ls == NFP_NET_CFG_STS_LINK_RATE_UNKNOWN ||
 308             ls >= ARRAY_SIZE(ls_to_ethtool))
 309                 return 0;
 310
 311         cmd->base.speed = ls_to_ethtool[ls];
 312         cmd->base.duplex = DUPLEX_FULL;
 313
 314         return 0;
 315 }
 316
 317 static int
 318 nfp_net_set_link_ksettings(struct net_device *netdev,
 319                            const struct ethtool_link_ksettings *cmd)
 320 {
 321         struct nfp_eth_table_port *eth_port;
 322         struct nfp_port *port;
 323         struct nfp_nsp *nsp;
 324         int err;
 325
 326         port = nfp_port_from_netdev(netdev);
 327         eth_port = __nfp_port_get_eth_port(port);
 328         if (!eth_port)
 329                 return -EOPNOTSUPP;
 330
 331         if (netif_running(netdev)) {
 332                 netdev_warn(netdev, "Changing settings not allowed on an active interface. It may cause the port to be disabled until reboot.\n");
 333                 return -EBUSY;
 334         }
 335
 336         nsp = nfp_eth_config_start(port->app->cpp, eth_port->index);
 337         if (IS_ERR(nsp))
 338                 return PTR_ERR(nsp);
 339
 340         err = __nfp_eth_set_aneg(nsp, cmd->base.autoneg == AUTONEG_ENABLE ?
 341                                  NFP_ANEG_AUTO : NFP_ANEG_DISABLED);
 342         if (err)
 343                 goto err_bad_set;
 344         if (cmd->base.speed != SPEED_UNKNOWN) {
 345                 u32 speed = cmd->base.speed / eth_port->lanes;
 346
 347                 err = __nfp_eth_set_speed(nsp, speed);
 348                 if (err)
 349                         goto err_bad_set;
 350         }
 351
 352         err = nfp_eth_config_commit_end(nsp);
 353         if (err > 0)
 354                 return 0; /* no change */
 355
 356         nfp_net_refresh_port_table(port);
 357
 358         return err;
 359
 360 err_bad_set:
 361         nfp_eth_config_cleanup_end(nsp);
 362         return err;
 363 }
 364
 365 static void nfp_net_get_ringparam(struct net_device *netdev,
 366                                   struct ethtool_ringparam *ring)
 367 {
 368         struct nfp_net *nn = netdev_priv(netdev);
 369
 370         ring->rx_max_pending = NFP_NET_MAX_RX_DESCS;
 371         ring->tx_max_pending = NFP_NET_MAX_TX_DESCS;
 372         ring->rx_pending = nn->dp.rxd_cnt;
 373         ring->tx_pending = nn->dp.txd_cnt;
 374 }
 375
 376 static int nfp_net_set_ring_size(struct nfp_net *nn, u32 rxd_cnt, u32 txd_cnt)
 377 {
 378         struct nfp_net_dp *dp;
 379
 380         dp = nfp_net_clone_dp(nn);
 381         if (!dp)
 382                 return -ENOMEM;
 383
 384         dp->rxd_cnt = rxd_cnt;
 385         dp->txd_cnt = txd_cnt;
 386
 387         return nfp_net_ring_reconfig(nn, dp, NULL);
 388 }
 389
 390 static int nfp_net_set_ringparam(struct net_device *netdev,
 391                                  struct ethtool_ringparam *ring)
 392 {
 393         struct nfp_net *nn = netdev_priv(netdev);
 394         u32 rxd_cnt, txd_cnt;
 395
 396         /* We don't have separate queues/rings for small/large frames. */
 397         if (ring->rx_mini_pending || ring->rx_jumbo_pending)
 398                 return -EINVAL;
 399
 400         /* Round up to supported values */
 401         rxd_cnt = roundup_pow_of_two(ring->rx_pending);
 402         txd_cnt = roundup_pow_of_two(ring->tx_pending);
 403
 404         if (rxd_cnt < NFP_NET_MIN_RX_DESCS || rxd_cnt > NFP_NET_MAX_RX_DESCS ||
 405             txd_cnt < NFP_NET_MIN_TX_DESCS || txd_cnt > NFP_NET_MAX_TX_DESCS)
 406                 return -EINVAL;
 407
 408         if (nn->dp.rxd_cnt == rxd_cnt && nn->dp.txd_cnt == txd_cnt)
 409                 return 0;
 410
 411         nn_dbg(nn, "Change ring size: RxQ %u->%u, TxQ %u->%u\n",
 412                nn->dp.rxd_cnt, rxd_cnt, nn->dp.txd_cnt, txd_cnt);
 413
 414         return nfp_net_set_ring_size(nn, rxd_cnt, txd_cnt);
 415 }
 416
 417 static __printf(2, 3) u8 *nfp_pr_et(u8 *data, const char *fmt, ...)
 418 {
 419         va_list args;
 420
 421         va_start(args, fmt);
 422         vsnprintf(data, ETH_GSTRING_LEN, fmt, args);
 423         va_end(args);
 424
 425         return data + ETH_GSTRING_LEN;
 426 }
 427
 428 static unsigned int nfp_vnic_get_sw_stats_count(struct net_device *netdev)
 429 {
 430         struct nfp_net *nn = netdev_priv(netdev);
 431
 432         return NN_ET_RVEC_GATHER_STATS + nn->dp.num_r_vecs * 3;
 433 }
 434
 435 static u8 *nfp_vnic_get_sw_stats_strings(struct net_device *netdev, u8 *data)
 436 {
 437         struct nfp_net *nn = netdev_priv(netdev);
 438         int i;
 439
 440         for (i = 0; i < nn->dp.num_r_vecs; i++) {
 441                 data = nfp_pr_et(data, "rvec_%u_rx_pkts", i);
 442                 data = nfp_pr_et(data, "rvec_%u_tx_pkts", i);
 443                 data = nfp_pr_et(data, "rvec_%u_tx_busy", i);
 444         }
 445
 446         data = nfp_pr_et(data, "hw_rx_csum_ok");
 447         data = nfp_pr_et(data, "hw_rx_csum_inner_ok");
 448         data = nfp_pr_et(data, "hw_rx_csum_err");
 449         data = nfp_pr_et(data, "hw_tx_csum");
 450         data = nfp_pr_et(data, "hw_tx_inner_csum");
 451         data = nfp_pr_et(data, "tx_gather");
 452         data = nfp_pr_et(data, "tx_lso");
 453
 454         return data;
 455 }
 456
 457 static u64 *nfp_vnic_get_sw_stats(struct net_device *netdev, u64 *data)
 458 {
 459         u64 gathered_stats[NN_ET_RVEC_GATHER_STATS] = {};
 460         struct nfp_net *nn = netdev_priv(netdev);
 461         u64 tmp[NN_ET_RVEC_GATHER_STATS];
 462         unsigned int i, j;
 463
 464         for (i = 0; i < nn->dp.num_r_vecs; i++) {
 465                 unsigned int start;
 466
 467                 do {
 468                         start = u64_stats_fetch_begin(&nn->r_vecs[i].rx_sync);
 469                         data[0] = nn->r_vecs[i].rx_pkts;
 470                         tmp[0] = nn->r_vecs[i].hw_csum_rx_ok;
 471                         tmp[1] = nn->r_vecs[i].hw_csum_rx_inner_ok;
 472                         tmp[2] = nn->r_vecs[i].hw_csum_rx_error;
 473                 } while (u64_stats_fetch_retry(&nn->r_vecs[i].rx_sync, start));
 474
 475                 do {
 476                         start = u64_stats_fetch_begin(&nn->r_vecs[i].tx_sync);
 477                         data[1] = nn->r_vecs[i].tx_pkts;
 478                         data[2] = nn->r_vecs[i].tx_busy;
 479                         tmp[3] = nn->r_vecs[i].hw_csum_tx;
 480                         tmp[4] = nn->r_vecs[i].hw_csum_tx_inner;
 481                         tmp[5] = nn->r_vecs[i].tx_gather;
 482                         tmp[6] = nn->r_vecs[i].tx_lso;
 483                 } while (u64_stats_fetch_retry(&nn->r_vecs[i].tx_sync, start));
 484
 485                 data += 3;
 486
 487                 for (j = 0; j < NN_ET_RVEC_GATHER_STATS; j++)
 488                         gathered_stats[j] += tmp[j];
 489         }
 490
 491         for (j = 0; j < NN_ET_RVEC_GATHER_STATS; j++)
 492                 *data++ = gathered_stats[j];
 493
 494         return data;
 495 }
 496
 497 static unsigned int
 498 nfp_vnic_get_hw_stats_count(unsigned int rx_rings, unsigned int tx_rings)
 499 {
 500         return NN_ET_GLOBAL_STATS_LEN + (rx_rings + tx_rings) * 2;
 501 }
 502
 503 static u8 *
 504 nfp_vnic_get_hw_stats_strings(u8 *data, unsigned int rx_rings,
 505                               unsigned int tx_rings, bool repr)
 506 {
 507         int swap_off, i;
 508
 509         BUILD_BUG_ON(NN_ET_GLOBAL_STATS_LEN < NN_ET_SWITCH_STATS_LEN * 2);
 510         /* If repr is true first add SWITCH_STATS_LEN and then subtract it
 511          * effectively swapping the RX and TX statistics (giving us the RX
 512          * and TX from perspective of the switch).
 513          */
 514         swap_off = repr * NN_ET_SWITCH_STATS_LEN;
 515
 516         for (i = 0; i < NN_ET_SWITCH_STATS_LEN; i++)
 517                 data = nfp_pr_et(data, nfp_net_et_stats[i + swap_off].name);
 518
 519         for (i = NN_ET_SWITCH_STATS_LEN; i < NN_ET_SWITCH_STATS_LEN * 2; i++)
 520                 data = nfp_pr_et(data, nfp_net_et_stats[i - swap_off].name);
 521
 522         for (i = NN_ET_SWITCH_STATS_LEN * 2; i < NN_ET_GLOBAL_STATS_LEN; i++)
 523                 data = nfp_pr_et(data, nfp_net_et_stats[i].name);
 524
 525         for (i = 0; i < tx_rings; i++) {
 526                 data = nfp_pr_et(data, "txq_%u_pkts", i);
 527                 data = nfp_pr_et(data, "txq_%u_bytes", i);
 528         }
 529
 530         for (i = 0; i < rx_rings; i++) {
 531                 data = nfp_pr_et(data, "rxq_%u_pkts", i);
 532                 data = nfp_pr_et(data, "rxq_%u_bytes", i);
 533         }
 534
 535         return data;
 536 }
 537
 538 static u64 *
 539 nfp_vnic_get_hw_stats(u64 *data, u8 __iomem *mem,
 540                       unsigned int rx_rings, unsigned int tx_rings)
 541 {
 542         unsigned int i;
 543
 544         for (i = 0; i < NN_ET_GLOBAL_STATS_LEN; i++)
 545                 *data++ = readq(mem + nfp_net_et_stats[i].off);
 546
 547         for (i = 0; i < tx_rings; i++) {
 548                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i));
 549                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i) + 8);
 550         }
 551
 552         for (i = 0; i < rx_rings; i++) {
 553                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i));
 554                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i) + 8);
 555         }
 556
 557         return data;
 558 }
 559
 560 static unsigned int nfp_mac_get_stats_count(struct net_device *netdev)
 561 {
 562         struct nfp_port *port;
 563
 564         port = nfp_port_from_netdev(netdev);
 565         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 566                 return 0;
 567
 568         return ARRAY_SIZE(nfp_mac_et_stats);
 569 }
 570
 571 static u8 *nfp_mac_get_stats_strings(struct net_device *netdev, u8 *data)
 572 {
 573         struct nfp_port *port;
 574         unsigned int i;
 575
 576         port = nfp_port_from_netdev(netdev);
 577         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 578                 return data;
 579
 580         for (i = 0; i < ARRAY_SIZE(nfp_mac_et_stats); i++)
 581                 data = nfp_pr_et(data, "mac.%s", nfp_mac_et_stats[i].name);
 582
 583         return data;
 584 }
 585
 586 static u64 *nfp_mac_get_stats(struct net_device *netdev, u64 *data)
 587 {
 588         struct nfp_port *port;
 589         unsigned int i;
 590
 591         port = nfp_port_from_netdev(netdev);
 592         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 593                 return data;
 594
 595         for (i = 0; i < ARRAY_SIZE(nfp_mac_et_stats); i++)
 596                 *data++ = readq(port->eth_stats + nfp_mac_et_stats[i].off);
 597
 598         return data;
 599 }
 600
 601 static void nfp_net_get_strings(struct net_device *netdev,
 602                                 u32 stringset, u8 *data)
 603 {
 604         struct nfp_net *nn = netdev_priv(netdev);
 605
 606         switch (stringset) {
 607         case ETH_SS_STATS:
 608                 data = nfp_vnic_get_sw_stats_strings(netdev, data);
 609                 data = nfp_vnic_get_hw_stats_strings(data, nn->dp.num_rx_rings,
 610                                                      nn->dp.num_tx_rings,
 611                                                      false);
 612                 data = nfp_mac_get_stats_strings(netdev, data);
 613                 break;
 614         }
 615 }
 616
 617 static void
 618 nfp_net_get_stats(struct net_device *netdev, struct ethtool_stats *stats,
 619                   u64 *data)
 620 {
 621         struct nfp_net *nn = netdev_priv(netdev);
 622
 623         data = nfp_vnic_get_sw_stats(netdev, data);
 624         data = nfp_vnic_get_hw_stats(data, nn->dp.ctrl_bar,
 625                                      nn->dp.num_rx_rings, nn->dp.num_tx_rings);
 626         data = nfp_mac_get_stats(netdev, data);
 627 }
 628
 629 static int nfp_net_get_sset_count(struct net_device *netdev, int sset)
 630 {
 631         struct nfp_net *nn = netdev_priv(netdev);
 632
 633         switch (sset) {
 634         case ETH_SS_STATS:
 635                 return nfp_vnic_get_sw_stats_count(netdev) +
 636                        nfp_vnic_get_hw_stats_count(nn->dp.num_rx_rings,
 637                                                    nn->dp.num_tx_rings) +
 638                        nfp_mac_get_stats_count(netdev);
 639         default:
 640                 return -EOPNOTSUPP;
 641         }
 642 }
 643
 644 static void nfp_port_get_strings(struct net_device *netdev,
 645                                  u32 stringset, u8 *data)
 646 {
 647         struct nfp_port *port = nfp_port_from_netdev(netdev);
 648
 649         switch (stringset) {
 650         case ETH_SS_STATS:
 651                 if (nfp_port_is_vnic(port))
 652                         data = nfp_vnic_get_hw_stats_strings(data, 0, 0, true);
 653                 else
 654                         data = nfp_mac_get_stats_strings(netdev, data);
 655                 break;
 656         }
 657 }
 658
 659 static void
 660 nfp_port_get_stats(struct net_device *netdev, struct ethtool_stats *stats,
 661                    u64 *data)
 662 {
 663         struct nfp_port *port = nfp_port_from_netdev(netdev);
 664
 665         if (nfp_port_is_vnic(port))
 666                 data = nfp_vnic_get_hw_stats(data, port->vnic, 0, 0);
 667         else
 668                 data = nfp_mac_get_stats(netdev, data);
 669 }
 670
 671 static int nfp_port_get_sset_count(struct net_device *netdev, int sset)
 672 {
 673         struct nfp_port *port = nfp_port_from_netdev(netdev);
 674         unsigned int count;
 675
 676         switch (sset) {
 677         case ETH_SS_STATS:
 678                 if (nfp_port_is_vnic(port))
 679                         count = nfp_vnic_get_hw_stats_count(0, 0);
 680                 else
 681                         count = nfp_mac_get_stats_count(netdev);
 682                 return count;
 683         default:
 684                 return -EOPNOTSUPP;
 685         }
 686 }
 687
 688 /* RX network flow classification (RSS, filters, etc)
 689  */
 690 static u32 ethtool_flow_to_nfp_flag(u32 flow_type)
 691 {
 692         static const u32 xlate_ethtool_to_nfp[IPV6_FLOW + 1] = {
 693                 [TCP_V4_FLOW]   = NFP_NET_CFG_RSS_IPV4_TCP,
 694                 [TCP_V6_FLOW]   = NFP_NET_CFG_RSS_IPV6_TCP,
 695                 [UDP_V4_FLOW]   = NFP_NET_CFG_RSS_IPV4_UDP,
 696                 [UDP_V6_FLOW]   = NFP_NET_CFG_RSS_IPV6_UDP,
 697                 [IPV4_FLOW]     = NFP_NET_CFG_RSS_IPV4,
 698                 [IPV6_FLOW]     = NFP_NET_CFG_RSS_IPV6,
 699         };
 700
 701         if (flow_type >= ARRAY_SIZE(xlate_ethtool_to_nfp))
 702                 return 0;
 703
 704         return xlate_ethtool_to_nfp[flow_type];
 705 }
 706
 707 static int nfp_net_get_rss_hash_opts(struct nfp_net *nn,
 708                                      struct ethtool_rxnfc *cmd)
 709 {
 710         u32 nfp_rss_flag;
 711
 712         cmd->data = 0;
 713
 714         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 715                 return -EOPNOTSUPP;
 716
 717         nfp_rss_flag = ethtool_flow_to_nfp_flag(cmd->flow_type);
 718         if (!nfp_rss_flag)
 719                 return -EINVAL;
 720
 721         cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 722         if (nn->rss_cfg & nfp_rss_flag)
 723                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 724
 725         return 0;
 726 }
 727
 728 static int nfp_net_get_rxnfc(struct net_device *netdev,
 729                              struct ethtool_rxnfc *cmd, u32 *rule_locs)
 730 {
 731         struct nfp_net *nn = netdev_priv(netdev);
 732
 733         switch (cmd->cmd) {
 734         case ETHTOOL_GRXRINGS:
 735                 cmd->data = nn->dp.num_rx_rings;
 736                 return 0;
 737         case ETHTOOL_GRXFH:
 738                 return nfp_net_get_rss_hash_opts(nn, cmd);
 739         default:
 740                 return -EOPNOTSUPP;
 741         }
 742 }
 743
 744 static int nfp_net_set_rss_hash_opt(struct nfp_net *nn,
 745                                     struct ethtool_rxnfc *nfc)
 746 {
 747         u32 new_rss_cfg = nn->rss_cfg;
 748         u32 nfp_rss_flag;
 749         int err;
 750
 751         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 752                 return -EOPNOTSUPP;
 753
 754         /* RSS only supports IP SA/DA and L4 src/dst ports  */
 755         if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
 756                           RXH_L4_B_0_1 | RXH_L4_B_2_3))
 757                 return -EINVAL;
 758
 759         /* We need at least the IP SA/DA fields for hashing */
 760         if (!(nfc->data & RXH_IP_SRC) ||
 761             !(nfc->data & RXH_IP_DST))
 762                 return -EINVAL;
 763
 764         nfp_rss_flag = ethtool_flow_to_nfp_flag(nfc->flow_type);
 765         if (!nfp_rss_flag)
 766                 return -EINVAL;
 767
 768         switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 769         case 0:
 770                 new_rss_cfg &= ~nfp_rss_flag;
 771                 break;
 772         case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 773                 new_rss_cfg |= nfp_rss_flag;
 774                 break;
 775         default:
 776                 return -EINVAL;
 777         }
 778
 779         new_rss_cfg |= FIELD_PREP(NFP_NET_CFG_RSS_HFUNC, nn->rss_hfunc);
 780         new_rss_cfg |= NFP_NET_CFG_RSS_MASK;
 781
 782         if (new_rss_cfg == nn->rss_cfg)
 783                 return 0;
 784
 785         writel(new_rss_cfg, nn->dp.ctrl_bar + NFP_NET_CFG_RSS_CTRL);
 786         err = nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_RSS);
 787         if (err)
 788                 return err;
 789
 790         nn->rss_cfg = new_rss_cfg;
 791
 792         nn_dbg(nn, "Changed RSS config to 0x%x\n", nn->rss_cfg);
 793         return 0;
 794 }
 795
 796 static int nfp_net_set_rxnfc(struct net_device *netdev,
 797                              struct ethtool_rxnfc *cmd)
 798 {
 799         struct nfp_net *nn = netdev_priv(netdev);
 800
 801         switch (cmd->cmd) {
 802         case ETHTOOL_SRXFH:
 803                 return nfp_net_set_rss_hash_opt(nn, cmd);
 804         default:
 805                 return -EOPNOTSUPP;
 806         }
 807 }
 808
 809 static u32 nfp_net_get_rxfh_indir_size(struct net_device *netdev)
 810 {
 811         struct nfp_net *nn = netdev_priv(netdev);
 812
 813         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 814                 return 0;
 815
 816         return ARRAY_SIZE(nn->rss_itbl);
 817 }
 818
 819 static u32 nfp_net_get_rxfh_key_size(struct net_device *netdev)
 820 {
 821         struct nfp_net *nn = netdev_priv(netdev);
 822
 823         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 824                 return -EOPNOTSUPP;
 825
 826         return nfp_net_rss_key_sz(nn);
 827 }
 828
 829 static int nfp_net_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
 830                             u8 *hfunc)
 831 {
 832         struct nfp_net *nn = netdev_priv(netdev);
 833         int i;
 834
 835         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 836                 return -EOPNOTSUPP;
 837
 838         if (indir)
 839                 for (i = 0; i < ARRAY_SIZE(nn->rss_itbl); i++)
 840                         indir[i] = nn->rss_itbl[i];
 841         if (key)
 842                 memcpy(key, nn->rss_key, nfp_net_rss_key_sz(nn));
 843         if (hfunc) {
 844                 *hfunc = nn->rss_hfunc;
 845                 if (*hfunc >= 1 << ETH_RSS_HASH_FUNCS_COUNT)
 846                         *hfunc = ETH_RSS_HASH_UNKNOWN;
 847         }
 848
 849         return 0;
 850 }
 851
 852 static int nfp_net_set_rxfh(struct net_device *netdev,
 853                             const u32 *indir, const u8 *key,
 854                             const u8 hfunc)
 855 {
 856         struct nfp_net *nn = netdev_priv(netdev);
 857         int i;
 858
 859         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY) ||
 860             !(hfunc == ETH_RSS_HASH_NO_CHANGE || hfunc == nn->rss_hfunc))
 861                 return -EOPNOTSUPP;
 862
 863         if (!key && !indir)
 864                 return 0;
 865
 866         if (key) {
 867                 memcpy(nn->rss_key, key, nfp_net_rss_key_sz(nn));
 868                 nfp_net_rss_write_key(nn);
 869         }
 870         if (indir) {
 871                 for (i = 0; i < ARRAY_SIZE(nn->rss_itbl); i++)
 872                         nn->rss_itbl[i] = indir[i];
 873
 874                 nfp_net_rss_write_itbl(nn);
 875         }
 876
 877         return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_RSS);
 878 }
 879
 880 /* Dump BAR registers
 881  */
 882 static int nfp_net_get_regs_len(struct net_device *netdev)
 883 {
 884         return NFP_NET_CFG_BAR_SZ;
 885 }
 886
 887 static void nfp_net_get_regs(struct net_device *netdev,
 888                              struct ethtool_regs *regs, void *p)
 889 {
 890         struct nfp_net *nn = netdev_priv(netdev);
 891         u32 *regs_buf = p;
 892         int i;
 893
 894         regs->version = nn_readl(nn, NFP_NET_CFG_VERSION);
 895
 896         for (i = 0; i < NFP_NET_CFG_BAR_SZ / sizeof(u32); i++)
 897                 regs_buf[i] = readl(nn->dp.ctrl_bar + (i * sizeof(u32)));
 898 }
 899
 900 static int nfp_net_get_coalesce(struct net_device *netdev,
 901                                 struct ethtool_coalesce *ec)
 902 {
 903         struct nfp_net *nn = netdev_priv(netdev);
 904
 905         if (!(nn->cap & NFP_NET_CFG_CTRL_IRQMOD))
 906                 return -EINVAL;
 907
 908         ec->rx_coalesce_usecs       = nn->rx_coalesce_usecs;
 909         ec->rx_max_coalesced_frames = nn->rx_coalesce_max_frames;
 910         ec->tx_coalesce_usecs       = nn->tx_coalesce_usecs;
 911         ec->tx_max_coalesced_frames = nn->tx_coalesce_max_frames;
 912
 913         return 0;
 914 }
 915
 916 /* Other debug dumps
 917  */
 918 static int
 919 nfp_dump_nsp_diag(struct nfp_app *app, struct ethtool_dump *dump, void *buffer)
 920 {
 921         struct nfp_resource *res;
 922         int ret;
 923
 924         if (!app)
 925                 return -EOPNOTSUPP;
 926
 927         dump->version = 1;
 928         dump->flag = NFP_DUMP_NSP_DIAG;
 929
 930         res = nfp_resource_acquire(app->cpp, NFP_RESOURCE_NSP_DIAG);
 931         if (IS_ERR(res))
 932                 return PTR_ERR(res);
 933
 934         if (buffer) {
 935                 if (dump->len != nfp_resource_size(res)) {
 936                         ret = -EINVAL;
 937                         goto exit_release;
 938                 }
 939
 940                 ret = nfp_cpp_read(app->cpp, nfp_resource_cpp_id(res),
 941                                    nfp_resource_address(res),
 942                                    buffer, dump->len);
 943                 if (ret != dump->len)
 944                         ret = ret < 0 ? ret : -EIO;
 945                 else
 946                         ret = 0;
 947         } else {
 948                 dump->len = nfp_resource_size(res);
 949                 ret = 0;
 950         }
 951 exit_release:
 952         nfp_resource_release(res);
 953
 954         return ret;
 955 }
 956
 957 static int nfp_app_set_dump(struct net_device *netdev, struct ethtool_dump *val)
 958 {
 959         struct nfp_app *app = nfp_app_from_netdev(netdev);
 960
 961         if (!app)
 962                 return -EOPNOTSUPP;
 963
 964         if (val->flag != NFP_DUMP_NSP_DIAG)
 965                 return -EINVAL;
 966
 967         return 0;
 968 }
 969
 970 static int
 971 nfp_app_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
 972 {
 973         return nfp_dump_nsp_diag(nfp_app_from_netdev(netdev), dump, NULL);
 974 }
 975
 976 static int
 977 nfp_app_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
 978                       void *buffer)
 979 {
 980         return nfp_dump_nsp_diag(nfp_app_from_netdev(netdev), dump, buffer);
 981 }
 982
 983 static int nfp_net_set_coalesce(struct net_device *netdev,
 984                                 struct ethtool_coalesce *ec)
 985 {
 986         struct nfp_net *nn = netdev_priv(netdev);
 987         unsigned int factor;
 988
 989         if (ec->rx_coalesce_usecs_irq ||
 990             ec->rx_max_coalesced_frames_irq ||
 991             ec->tx_coalesce_usecs_irq ||
 992             ec->tx_max_coalesced_frames_irq ||
 993             ec->stats_block_coalesce_usecs ||
 994             ec->use_adaptive_rx_coalesce ||
 995             ec->use_adaptive_tx_coalesce ||
 996             ec->pkt_rate_low ||
 997             ec->rx_coalesce_usecs_low ||
 998             ec->rx_max_coalesced_frames_low ||
 999             ec->tx_coalesce_usecs_low ||
1000             ec->tx_max_coalesced_frames_low ||
1001             ec->pkt_rate_high ||
1002             ec->rx_coalesce_usecs_high ||
1003             ec->rx_max_coalesced_frames_high ||
1004             ec->tx_coalesce_usecs_high ||
1005             ec->tx_max_coalesced_frames_high ||
1006             ec->rate_sample_interval)
1007                 return -EOPNOTSUPP;
1008
1009         /* Compute factor used to convert coalesce '_usecs' parameters to
1010          * ME timestamp ticks.  There are 16 ME clock cycles for each timestamp
1011          * count.
1012          */
1013         factor = nn->me_freq_mhz / 16;
1014
1015         /* Each pair of (usecs, max_frames) fields specifies that interrupts
1016          * should be coalesced until
1017          *      (usecs > 0 && time_since_first_completion >= usecs) ||
1018          *      (max_frames > 0 && completed_frames >= max_frames)
1019          *
1020          * It is illegal to set both usecs and max_frames to zero as this would
1021          * cause interrupts to never be generated.  To disable coalescing, set
1022          * usecs = 0 and max_frames = 1.
1023          *
1024          * Some implementations ignore the value of max_frames and use the
1025          * condition time_since_first_completion >= usecs
1026          */
1027
1028         if (!(nn->cap & NFP_NET_CFG_CTRL_IRQMOD))
1029                 return -EINVAL;
1030
1031         /* ensure valid configuration */
1032         if (!ec->rx_coalesce_usecs && !ec->rx_max_coalesced_frames)
1033                 return -EINVAL;
1034
1035         if (!ec->tx_coalesce_usecs && !ec->tx_max_coalesced_frames)
1036                 return -EINVAL;
1037
1038         if (ec->rx_coalesce_usecs * factor >= ((1 << 16) - 1))
1039                 return -EINVAL;
1040
1041         if (ec->tx_coalesce_usecs * factor >= ((1 << 16) - 1))
1042                 return -EINVAL;
1043
1044         if (ec->rx_max_coalesced_frames >= ((1 << 16) - 1))
1045                 return -EINVAL;
1046
1047         if (ec->tx_max_coalesced_frames >= ((1 << 16) - 1))
1048                 return -EINVAL;
1049
1050         /* configuration is valid */
1051         nn->rx_coalesce_usecs      = ec->rx_coalesce_usecs;
1052         nn->rx_coalesce_max_frames = ec->rx_max_coalesced_frames;
1053         nn->tx_coalesce_usecs      = ec->tx_coalesce_usecs;
1054         nn->tx_coalesce_max_frames = ec->tx_max_coalesced_frames;
1055
1056         /* write configuration to device */
1057         nfp_net_coalesce_write_cfg(nn);
1058         return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_IRQMOD);
1059 }
1060
1061 static void nfp_net_get_channels(struct net_device *netdev,
1062                                  struct ethtool_channels *channel)
1063 {
1064         struct nfp_net *nn = netdev_priv(netdev);
1065         unsigned int num_tx_rings;
1066
1067         num_tx_rings = nn->dp.num_tx_rings;
1068         if (nn->dp.xdp_prog)
1069                 num_tx_rings -= nn->dp.num_rx_rings;
1070
1071         channel->max_rx = min(nn->max_rx_rings, nn->max_r_vecs);
1072         channel->max_tx = min(nn->max_tx_rings, nn->max_r_vecs);
1073         channel->max_combined = min(channel->max_rx, channel->max_tx);
1074         channel->max_other = NFP_NET_NON_Q_VECTORS;
1075         channel->combined_count = min(nn->dp.num_rx_rings, num_tx_rings);
1076         channel->rx_count = nn->dp.num_rx_rings - channel->combined_count;
1077         channel->tx_count = num_tx_rings - channel->combined_count;
1078         channel->other_count = NFP_NET_NON_Q_VECTORS;
1079 }
1080
1081 static int nfp_net_set_num_rings(struct nfp_net *nn, unsigned int total_rx,
1082                                  unsigned int total_tx)
1083 {
1084         struct nfp_net_dp *dp;
1085
1086         dp = nfp_net_clone_dp(nn);
1087         if (!dp)
1088                 return -ENOMEM;
1089
1090         dp->num_rx_rings = total_rx;
1091         dp->num_tx_rings = total_tx;
1092         /* nfp_net_check_config() will catch num_tx_rings > nn->max_tx_rings */
1093         if (dp->xdp_prog)
1094                 dp->num_tx_rings += total_rx;
1095
1096         return nfp_net_ring_reconfig(nn, dp, NULL);
1097 }
1098
1099 static int nfp_net_set_channels(struct net_device *netdev,
1100                                 struct ethtool_channels *channel)
1101 {
1102         struct nfp_net *nn = netdev_priv(netdev);
1103         unsigned int total_rx, total_tx;
1104
1105         /* Reject unsupported */
1106         if (!channel->combined_count ||
1107             channel->other_count != NFP_NET_NON_Q_VECTORS ||
1108             (channel->rx_count && channel->tx_count))
1109                 return -EINVAL;
1110
1111         total_rx = channel->combined_count + channel->rx_count;
1112         total_tx = channel->combined_count + channel->tx_count;
1113
1114         if (total_rx > min(nn->max_rx_rings, nn->max_r_vecs) ||
1115             total_tx > min(nn->max_tx_rings, nn->max_r_vecs))
1116                 return -EINVAL;
1117
1118         return nfp_net_set_num_rings(nn, total_rx, total_tx);
1119 }
1120
1121 static const struct ethtool_ops nfp_net_ethtool_ops = {
1122         .get_drvinfo            = nfp_net_get_drvinfo,
1123         .get_link               = ethtool_op_get_link,
1124         .get_ringparam          = nfp_net_get_ringparam,
1125         .set_ringparam          = nfp_net_set_ringparam,
1126         .get_strings            = nfp_net_get_strings,
1127         .get_ethtool_stats      = nfp_net_get_stats,
1128         .get_sset_count         = nfp_net_get_sset_count,
1129         .get_rxnfc              = nfp_net_get_rxnfc,
1130         .set_rxnfc              = nfp_net_set_rxnfc,
1131         .get_rxfh_indir_size    = nfp_net_get_rxfh_indir_size,
1132         .get_rxfh_key_size      = nfp_net_get_rxfh_key_size,
1133         .get_rxfh               = nfp_net_get_rxfh,
1134         .set_rxfh               = nfp_net_set_rxfh,
1135         .get_regs_len           = nfp_net_get_regs_len,
1136         .get_regs               = nfp_net_get_regs,
1137         .set_dump               = nfp_app_set_dump,
1138         .get_dump_flag          = nfp_app_get_dump_flag,
1139         .get_dump_data          = nfp_app_get_dump_data,
1140         .get_coalesce           = nfp_net_get_coalesce,
1141         .set_coalesce           = nfp_net_set_coalesce,
1142         .get_channels           = nfp_net_get_channels,
1143         .set_channels           = nfp_net_set_channels,
1144         .get_link_ksettings     = nfp_net_get_link_ksettings,
1145         .set_link_ksettings     = nfp_net_set_link_ksettings,
1146 };
1147
1148 const struct ethtool_ops nfp_port_ethtool_ops = {
1149         .get_drvinfo            = nfp_app_get_drvinfo,
1150         .get_link               = ethtool_op_get_link,
1151         .get_strings            = nfp_port_get_strings,
1152         .get_ethtool_stats      = nfp_port_get_stats,
1153         .get_sset_count         = nfp_port_get_sset_count,
1154         .set_dump               = nfp_app_set_dump,
1155         .get_dump_flag          = nfp_app_get_dump_flag,
1156         .get_dump_data          = nfp_app_get_dump_data,
1157 };
1158
1159 void nfp_net_set_ethtool_ops(struct net_device *netdev)
1160 {
1161         netdev->ethtool_ops = &nfp_net_ethtool_ops;
1162 }