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

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2015-2018 Netronome Systems, Inc. */
   3
   4 /*
   5  * nfp_net_ethtool.c
   6  * Netronome network device driver: ethtool support
   7  * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
   8  *          Jason McMullan <jason.mcmullan@netronome.com>
   9  *          Rolf Neugebauer <rolf.neugebauer@netronome.com>
  10  *          Brad Petrus <brad.petrus@netronome.com>
  11  */
  12
  13 #include <linux/bitfield.h>
  14 #include <linux/kernel.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/pci.h>
  19 #include <linux/ethtool.h>
  20 #include <linux/firmware.h>
  21 #include <linux/sfp.h>
  22
  23 #include "nfpcore/nfp.h"
  24 #include "nfpcore/nfp_dev.h"
  25 #include "nfpcore/nfp_nsp.h"
  26 #include "nfp_app.h"
  27 #include "nfp_main.h"
  28 #include "nfp_net_ctrl.h"
  29 #include "nfp_net_dp.h"
  30 #include "nfp_net.h"
  31 #include "nfp_port.h"
  32
  33 struct nfp_et_stat {
  34         char name[ETH_GSTRING_LEN];
  35         int off;
  36 };
  37
  38 static const struct nfp_et_stat nfp_net_et_stats[] = {
  39         /* Stats from the device */
  40         { "dev_rx_discards",    NFP_NET_CFG_STATS_RX_DISCARDS },
  41         { "dev_rx_errors",      NFP_NET_CFG_STATS_RX_ERRORS },
  42         { "dev_rx_bytes",       NFP_NET_CFG_STATS_RX_OCTETS },
  43         { "dev_rx_uc_bytes",    NFP_NET_CFG_STATS_RX_UC_OCTETS },
  44         { "dev_rx_mc_bytes",    NFP_NET_CFG_STATS_RX_MC_OCTETS },
  45         { "dev_rx_bc_bytes",    NFP_NET_CFG_STATS_RX_BC_OCTETS },
  46         { "dev_rx_pkts",        NFP_NET_CFG_STATS_RX_FRAMES },
  47         { "dev_rx_mc_pkts",     NFP_NET_CFG_STATS_RX_MC_FRAMES },
  48         { "dev_rx_bc_pkts",     NFP_NET_CFG_STATS_RX_BC_FRAMES },
  49
  50         { "dev_tx_discards",    NFP_NET_CFG_STATS_TX_DISCARDS },
  51         { "dev_tx_errors",      NFP_NET_CFG_STATS_TX_ERRORS },
  52         { "dev_tx_bytes",       NFP_NET_CFG_STATS_TX_OCTETS },
  53         { "dev_tx_uc_bytes",    NFP_NET_CFG_STATS_TX_UC_OCTETS },
  54         { "dev_tx_mc_bytes",    NFP_NET_CFG_STATS_TX_MC_OCTETS },
  55         { "dev_tx_bc_bytes",    NFP_NET_CFG_STATS_TX_BC_OCTETS },
  56         { "dev_tx_pkts",        NFP_NET_CFG_STATS_TX_FRAMES },
  57         { "dev_tx_mc_pkts",     NFP_NET_CFG_STATS_TX_MC_FRAMES },
  58         { "dev_tx_bc_pkts",     NFP_NET_CFG_STATS_TX_BC_FRAMES },
  59
  60         { "bpf_pass_pkts",      NFP_NET_CFG_STATS_APP0_FRAMES },
  61         { "bpf_pass_bytes",     NFP_NET_CFG_STATS_APP0_BYTES },
  62         /* see comments in outro functions in nfp_bpf_jit.c to find out
  63          * how different BPF modes use app-specific counters
  64          */
  65         { "bpf_app1_pkts",      NFP_NET_CFG_STATS_APP1_FRAMES },
  66         { "bpf_app1_bytes",     NFP_NET_CFG_STATS_APP1_BYTES },
  67         { "bpf_app2_pkts",      NFP_NET_CFG_STATS_APP2_FRAMES },
  68         { "bpf_app2_bytes",     NFP_NET_CFG_STATS_APP2_BYTES },
  69         { "bpf_app3_pkts",      NFP_NET_CFG_STATS_APP3_FRAMES },
  70         { "bpf_app3_bytes",     NFP_NET_CFG_STATS_APP3_BYTES },
  71 };
  72
  73 static const struct nfp_et_stat nfp_mac_et_stats[] = {
  74         { "rx_octets",                  NFP_MAC_STATS_RX_IN_OCTETS, },
  75         { "rx_frame_too_long_errors",
  76                         NFP_MAC_STATS_RX_FRAME_TOO_LONG_ERRORS, },
  77         { "rx_range_length_errors",     NFP_MAC_STATS_RX_RANGE_LENGTH_ERRORS, },
  78         { "rx_vlan_received_ok",        NFP_MAC_STATS_RX_VLAN_RECEIVED_OK, },
  79         { "rx_errors",                  NFP_MAC_STATS_RX_IN_ERRORS, },
  80         { "rx_broadcast_pkts",          NFP_MAC_STATS_RX_IN_BROADCAST_PKTS, },
  81         { "rx_drop_events",             NFP_MAC_STATS_RX_DROP_EVENTS, },
  82         { "rx_alignment_errors",        NFP_MAC_STATS_RX_ALIGNMENT_ERRORS, },
  83         { "rx_pause_mac_ctrl_frames",
  84                         NFP_MAC_STATS_RX_PAUSE_MAC_CTRL_FRAMES, },
  85         { "rx_frames_received_ok",      NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK, },
  86         { "rx_frame_check_sequence_errors",
  87                         NFP_MAC_STATS_RX_FRAME_CHECK_SEQUENCE_ERRORS, },
  88         { "rx_unicast_pkts",            NFP_MAC_STATS_RX_UNICAST_PKTS, },
  89         { "rx_multicast_pkts",          NFP_MAC_STATS_RX_MULTICAST_PKTS, },
  90         { "rx_pkts",                    NFP_MAC_STATS_RX_PKTS, },
  91         { "rx_undersize_pkts",          NFP_MAC_STATS_RX_UNDERSIZE_PKTS, },
  92         { "rx_pkts_64_octets",          NFP_MAC_STATS_RX_PKTS_64_OCTETS, },
  93         { "rx_pkts_65_to_127_octets",
  94                         NFP_MAC_STATS_RX_PKTS_65_TO_127_OCTETS, },
  95         { "rx_pkts_128_to_255_octets",
  96                         NFP_MAC_STATS_RX_PKTS_128_TO_255_OCTETS, },
  97         { "rx_pkts_256_to_511_octets",
  98                         NFP_MAC_STATS_RX_PKTS_256_TO_511_OCTETS, },
  99         { "rx_pkts_512_to_1023_octets",
 100                         NFP_MAC_STATS_RX_PKTS_512_TO_1023_OCTETS, },
 101         { "rx_pkts_1024_to_1518_octets",
 102                         NFP_MAC_STATS_RX_PKTS_1024_TO_1518_OCTETS, },
 103         { "rx_pkts_1519_to_max_octets",
 104                         NFP_MAC_STATS_RX_PKTS_1519_TO_MAX_OCTETS, },
 105         { "rx_jabbers",                 NFP_MAC_STATS_RX_JABBERS, },
 106         { "rx_fragments",               NFP_MAC_STATS_RX_FRAGMENTS, },
 107         { "rx_oversize_pkts",           NFP_MAC_STATS_RX_OVERSIZE_PKTS, },
 108         { "rx_pause_frames_class0",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS0, },
 109         { "rx_pause_frames_class1",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS1, },
 110         { "rx_pause_frames_class2",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS2, },
 111         { "rx_pause_frames_class3",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS3, },
 112         { "rx_pause_frames_class4",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS4, },
 113         { "rx_pause_frames_class5",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS5, },
 114         { "rx_pause_frames_class6",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS6, },
 115         { "rx_pause_frames_class7",     NFP_MAC_STATS_RX_PAUSE_FRAMES_CLASS7, },
 116         { "rx_mac_ctrl_frames_received",
 117                         NFP_MAC_STATS_RX_MAC_CTRL_FRAMES_RECEIVED, },
 118         { "rx_mac_head_drop",           NFP_MAC_STATS_RX_MAC_HEAD_DROP, },
 119         { "tx_queue_drop",              NFP_MAC_STATS_TX_QUEUE_DROP, },
 120         { "tx_octets",                  NFP_MAC_STATS_TX_OUT_OCTETS, },
 121         { "tx_vlan_transmitted_ok",     NFP_MAC_STATS_TX_VLAN_TRANSMITTED_OK, },
 122         { "tx_errors",                  NFP_MAC_STATS_TX_OUT_ERRORS, },
 123         { "tx_broadcast_pkts",          NFP_MAC_STATS_TX_BROADCAST_PKTS, },
 124         { "tx_pause_mac_ctrl_frames",
 125                         NFP_MAC_STATS_TX_PAUSE_MAC_CTRL_FRAMES, },
 126         { "tx_frames_transmitted_ok",
 127                         NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK, },
 128         { "tx_unicast_pkts",            NFP_MAC_STATS_TX_UNICAST_PKTS, },
 129         { "tx_multicast_pkts",          NFP_MAC_STATS_TX_MULTICAST_PKTS, },
 130         { "tx_pkts_64_octets",          NFP_MAC_STATS_TX_PKTS_64_OCTETS, },
 131         { "tx_pkts_65_to_127_octets",
 132                         NFP_MAC_STATS_TX_PKTS_65_TO_127_OCTETS, },
 133         { "tx_pkts_128_to_255_octets",
 134                         NFP_MAC_STATS_TX_PKTS_128_TO_255_OCTETS, },
 135         { "tx_pkts_256_to_511_octets",
 136                         NFP_MAC_STATS_TX_PKTS_256_TO_511_OCTETS, },
 137         { "tx_pkts_512_to_1023_octets",
 138                         NFP_MAC_STATS_TX_PKTS_512_TO_1023_OCTETS, },
 139         { "tx_pkts_1024_to_1518_octets",
 140                         NFP_MAC_STATS_TX_PKTS_1024_TO_1518_OCTETS, },
 141         { "tx_pkts_1519_to_max_octets",
 142                         NFP_MAC_STATS_TX_PKTS_1519_TO_MAX_OCTETS, },
 143         { "tx_pause_frames_class0",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS0, },
 144         { "tx_pause_frames_class1",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS1, },
 145         { "tx_pause_frames_class2",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS2, },
 146         { "tx_pause_frames_class3",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS3, },
 147         { "tx_pause_frames_class4",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS4, },
 148         { "tx_pause_frames_class5",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS5, },
 149         { "tx_pause_frames_class6",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS6, },
 150         { "tx_pause_frames_class7",     NFP_MAC_STATS_TX_PAUSE_FRAMES_CLASS7, },
 151 };
 152
 153 static const char nfp_tlv_stat_names[][ETH_GSTRING_LEN] = {
 154         [1]     = "dev_rx_discards",
 155         [2]     = "dev_rx_errors",
 156         [3]     = "dev_rx_bytes",
 157         [4]     = "dev_rx_uc_bytes",
 158         [5]     = "dev_rx_mc_bytes",
 159         [6]     = "dev_rx_bc_bytes",
 160         [7]     = "dev_rx_pkts",
 161         [8]     = "dev_rx_mc_pkts",
 162         [9]     = "dev_rx_bc_pkts",
 163
 164         [10]    = "dev_tx_discards",
 165         [11]    = "dev_tx_errors",
 166         [12]    = "dev_tx_bytes",
 167         [13]    = "dev_tx_uc_bytes",
 168         [14]    = "dev_tx_mc_bytes",
 169         [15]    = "dev_tx_bc_bytes",
 170         [16]    = "dev_tx_pkts",
 171         [17]    = "dev_tx_mc_pkts",
 172         [18]    = "dev_tx_bc_pkts",
 173 };
 174
 175 #define NN_ET_GLOBAL_STATS_LEN ARRAY_SIZE(nfp_net_et_stats)
 176 #define NN_ET_SWITCH_STATS_LEN 9
 177 #define NN_RVEC_GATHER_STATS    13
 178 #define NN_RVEC_PER_Q_STATS     3
 179 #define NN_CTRL_PATH_STATS      4
 180
 181 #define SFP_SFF_REV_COMPLIANCE  1
 182
 183 static void nfp_net_get_nspinfo(struct nfp_app *app, char *version)
 184 {
 185         struct nfp_nsp *nsp;
 186
 187         if (!app)
 188                 return;
 189
 190         nsp = nfp_nsp_open(app->cpp);
 191         if (IS_ERR(nsp))
 192                 return;
 193
 194         snprintf(version, ETHTOOL_FWVERS_LEN, "%hu.%hu",
 195                  nfp_nsp_get_abi_ver_major(nsp),
 196                  nfp_nsp_get_abi_ver_minor(nsp));
 197
 198         nfp_nsp_close(nsp);
 199 }
 200
 201 static void
 202 nfp_get_drvinfo(struct nfp_app *app, struct pci_dev *pdev,
 203                 const char *vnic_version, struct ethtool_drvinfo *drvinfo)
 204 {
 205         char nsp_version[ETHTOOL_FWVERS_LEN] = {};
 206
 207         strlcpy(drvinfo->driver, dev_driver_string(&pdev->dev),
 208                 sizeof(drvinfo->driver));
 209         nfp_net_get_nspinfo(app, nsp_version);
 210         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 211                  "%s %s %s %s", vnic_version, nsp_version,
 212                  nfp_app_mip_name(app), nfp_app_name(app));
 213 }
 214
 215 static void
 216 nfp_net_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
 217 {
 218         char vnic_version[ETHTOOL_FWVERS_LEN] = {};
 219         struct nfp_net *nn = netdev_priv(netdev);
 220
 221         snprintf(vnic_version, sizeof(vnic_version), "%d.%d.%d.%d",
 222                  nn->fw_ver.extend, nn->fw_ver.class,
 223                  nn->fw_ver.major, nn->fw_ver.minor);
 224         strlcpy(drvinfo->bus_info, pci_name(nn->pdev),
 225                 sizeof(drvinfo->bus_info));
 226
 227         nfp_get_drvinfo(nn->app, nn->pdev, vnic_version, drvinfo);
 228 }
 229
 230 static void
 231 nfp_app_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
 232 {
 233         struct nfp_app *app = nfp_app_from_netdev(netdev);
 234
 235         strlcpy(drvinfo->bus_info, pci_name(app->pdev),
 236                 sizeof(drvinfo->bus_info));
 237         nfp_get_drvinfo(app, app->pdev, "*", drvinfo);
 238 }
 239
 240 static void
 241 nfp_net_set_fec_link_mode(struct nfp_eth_table_port *eth_port,
 242                           struct ethtool_link_ksettings *c)
 243 {
 244         unsigned int modes;
 245
 246         ethtool_link_ksettings_add_link_mode(c, supported, FEC_NONE);
 247         if (!nfp_eth_can_support_fec(eth_port)) {
 248                 ethtool_link_ksettings_add_link_mode(c, advertising, FEC_NONE);
 249                 return;
 250         }
 251
 252         modes = nfp_eth_supported_fec_modes(eth_port);
 253         if (modes & NFP_FEC_BASER) {
 254                 ethtool_link_ksettings_add_link_mode(c, supported, FEC_BASER);
 255                 ethtool_link_ksettings_add_link_mode(c, advertising, FEC_BASER);
 256         }
 257
 258         if (modes & NFP_FEC_REED_SOLOMON) {
 259                 ethtool_link_ksettings_add_link_mode(c, supported, FEC_RS);
 260                 ethtool_link_ksettings_add_link_mode(c, advertising, FEC_RS);
 261         }
 262 }
 263
 264 /**
 265  * nfp_net_get_link_ksettings - Get Link Speed settings
 266  * @netdev:     network interface device structure
 267  * @cmd:        ethtool command
 268  *
 269  * Reports speed settings based on info in the BAR provided by the fw.
 270  */
 271 static int
 272 nfp_net_get_link_ksettings(struct net_device *netdev,
 273                            struct ethtool_link_ksettings *cmd)
 274 {
 275         static const u32 ls_to_ethtool[] = {
 276                 [NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED] = 0,
 277                 [NFP_NET_CFG_STS_LINK_RATE_UNKNOWN]     = SPEED_UNKNOWN,
 278                 [NFP_NET_CFG_STS_LINK_RATE_1G]          = SPEED_1000,
 279                 [NFP_NET_CFG_STS_LINK_RATE_10G]         = SPEED_10000,
 280                 [NFP_NET_CFG_STS_LINK_RATE_25G]         = SPEED_25000,
 281                 [NFP_NET_CFG_STS_LINK_RATE_40G]         = SPEED_40000,
 282                 [NFP_NET_CFG_STS_LINK_RATE_50G]         = SPEED_50000,
 283                 [NFP_NET_CFG_STS_LINK_RATE_100G]        = SPEED_100000,
 284         };
 285         struct nfp_eth_table_port *eth_port;
 286         struct nfp_port *port;
 287         struct nfp_net *nn;
 288         u32 sts, ls;
 289
 290         /* Init to unknowns */
 291         ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE);
 292         cmd->base.port = PORT_OTHER;
 293         cmd->base.speed = SPEED_UNKNOWN;
 294         cmd->base.duplex = DUPLEX_UNKNOWN;
 295
 296         port = nfp_port_from_netdev(netdev);
 297         eth_port = nfp_port_get_eth_port(port);
 298         if (eth_port) {
 299                 ethtool_link_ksettings_add_link_mode(cmd, supported, Pause);
 300                 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
 301                 cmd->base.autoneg = eth_port->aneg != NFP_ANEG_DISABLED ?
 302                         AUTONEG_ENABLE : AUTONEG_DISABLE;
 303                 nfp_net_set_fec_link_mode(eth_port, cmd);
 304         }
 305
 306         if (!netif_carrier_ok(netdev))
 307                 return 0;
 308
 309         /* Use link speed from ETH table if available, otherwise try the BAR */
 310         if (eth_port) {
 311                 cmd->base.port = eth_port->port_type;
 312                 cmd->base.speed = eth_port->speed;
 313                 cmd->base.duplex = DUPLEX_FULL;
 314                 return 0;
 315         }
 316
 317         if (!nfp_netdev_is_nfp_net(netdev))
 318                 return -EOPNOTSUPP;
 319         nn = netdev_priv(netdev);
 320
 321         sts = nn_readl(nn, NFP_NET_CFG_STS);
 322
 323         ls = FIELD_GET(NFP_NET_CFG_STS_LINK_RATE, sts);
 324         if (ls == NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED)
 325                 return -EOPNOTSUPP;
 326
 327         if (ls == NFP_NET_CFG_STS_LINK_RATE_UNKNOWN ||
 328             ls >= ARRAY_SIZE(ls_to_ethtool))
 329                 return 0;
 330
 331         cmd->base.speed = ls_to_ethtool[ls];
 332         cmd->base.duplex = DUPLEX_FULL;
 333
 334         return 0;
 335 }
 336
 337 static int
 338 nfp_net_set_link_ksettings(struct net_device *netdev,
 339                            const struct ethtool_link_ksettings *cmd)
 340 {
 341         struct nfp_eth_table_port *eth_port;
 342         struct nfp_port *port;
 343         struct nfp_nsp *nsp;
 344         int err;
 345
 346         port = nfp_port_from_netdev(netdev);
 347         eth_port = __nfp_port_get_eth_port(port);
 348         if (!eth_port)
 349                 return -EOPNOTSUPP;
 350
 351         if (netif_running(netdev)) {
 352                 netdev_warn(netdev, "Changing settings not allowed on an active interface. It may cause the port to be disabled until driver reload.\n");
 353                 return -EBUSY;
 354         }
 355
 356         nsp = nfp_eth_config_start(port->app->cpp, eth_port->index);
 357         if (IS_ERR(nsp))
 358                 return PTR_ERR(nsp);
 359
 360         err = __nfp_eth_set_aneg(nsp, cmd->base.autoneg == AUTONEG_ENABLE ?
 361                                  NFP_ANEG_AUTO : NFP_ANEG_DISABLED);
 362         if (err)
 363                 goto err_bad_set;
 364         if (cmd->base.speed != SPEED_UNKNOWN) {
 365                 u32 speed = cmd->base.speed / eth_port->lanes;
 366
 367                 err = __nfp_eth_set_speed(nsp, speed);
 368                 if (err)
 369                         goto err_bad_set;
 370         }
 371
 372         err = nfp_eth_config_commit_end(nsp);
 373         if (err > 0)
 374                 return 0; /* no change */
 375
 376         nfp_net_refresh_port_table(port);
 377
 378         return err;
 379
 380 err_bad_set:
 381         nfp_eth_config_cleanup_end(nsp);
 382         return err;
 383 }
 384
 385 static void nfp_net_get_ringparam(struct net_device *netdev,
 386                                   struct ethtool_ringparam *ring,
 387                                   struct kernel_ethtool_ringparam *kernel_ring,
 388                                   struct netlink_ext_ack *extack)
 389 {
 390         struct nfp_net *nn = netdev_priv(netdev);
 391         u32 qc_max = nn->dev_info->max_qc_size;
 392
 393         ring->rx_max_pending = qc_max;
 394         ring->tx_max_pending = qc_max / nn->dp.ops->tx_min_desc_per_pkt;
 395         ring->rx_pending = nn->dp.rxd_cnt;
 396         ring->tx_pending = nn->dp.txd_cnt;
 397 }
 398
 399 static int nfp_net_set_ring_size(struct nfp_net *nn, u32 rxd_cnt, u32 txd_cnt)
 400 {
 401         struct nfp_net_dp *dp;
 402
 403         dp = nfp_net_clone_dp(nn);
 404         if (!dp)
 405                 return -ENOMEM;
 406
 407         dp->rxd_cnt = rxd_cnt;
 408         dp->txd_cnt = txd_cnt;
 409
 410         return nfp_net_ring_reconfig(nn, dp, NULL);
 411 }
 412
 413 static int nfp_net_set_ringparam(struct net_device *netdev,
 414                                  struct ethtool_ringparam *ring,
 415                                  struct kernel_ethtool_ringparam *kernel_ring,
 416                                  struct netlink_ext_ack *extack)
 417 {
 418         u32 tx_dpp, qc_min, qc_max, rxd_cnt, txd_cnt;
 419         struct nfp_net *nn = netdev_priv(netdev);
 420
 421         /* We don't have separate queues/rings for small/large frames. */
 422         if (ring->rx_mini_pending || ring->rx_jumbo_pending)
 423                 return -EINVAL;
 424
 425         qc_min = nn->dev_info->min_qc_size;
 426         qc_max = nn->dev_info->max_qc_size;
 427         tx_dpp = nn->dp.ops->tx_min_desc_per_pkt;
 428         /* Round up to supported values */
 429         rxd_cnt = roundup_pow_of_two(ring->rx_pending);
 430         txd_cnt = roundup_pow_of_two(ring->tx_pending);
 431
 432         if (rxd_cnt < qc_min || rxd_cnt > qc_max ||
 433             txd_cnt < qc_min / tx_dpp || txd_cnt > qc_max / tx_dpp)
 434                 return -EINVAL;
 435
 436         if (nn->dp.rxd_cnt == rxd_cnt && nn->dp.txd_cnt == txd_cnt)
 437                 return 0;
 438
 439         nn_dbg(nn, "Change ring size: RxQ %u->%u, TxQ %u->%u\n",
 440                nn->dp.rxd_cnt, rxd_cnt, nn->dp.txd_cnt, txd_cnt);
 441
 442         return nfp_net_set_ring_size(nn, rxd_cnt, txd_cnt);
 443 }
 444
 445 static unsigned int nfp_vnic_get_sw_stats_count(struct net_device *netdev)
 446 {
 447         struct nfp_net *nn = netdev_priv(netdev);
 448
 449         return NN_RVEC_GATHER_STATS + nn->max_r_vecs * NN_RVEC_PER_Q_STATS +
 450                 NN_CTRL_PATH_STATS;
 451 }
 452
 453 static u8 *nfp_vnic_get_sw_stats_strings(struct net_device *netdev, u8 *data)
 454 {
 455         struct nfp_net *nn = netdev_priv(netdev);
 456         int i;
 457
 458         for (i = 0; i < nn->max_r_vecs; i++) {
 459                 ethtool_sprintf(&data, "rvec_%u_rx_pkts", i);
 460                 ethtool_sprintf(&data, "rvec_%u_tx_pkts", i);
 461                 ethtool_sprintf(&data, "rvec_%u_tx_busy", i);
 462         }
 463
 464         ethtool_sprintf(&data, "hw_rx_csum_ok");
 465         ethtool_sprintf(&data, "hw_rx_csum_inner_ok");
 466         ethtool_sprintf(&data, "hw_rx_csum_complete");
 467         ethtool_sprintf(&data, "hw_rx_csum_err");
 468         ethtool_sprintf(&data, "rx_replace_buf_alloc_fail");
 469         ethtool_sprintf(&data, "rx_tls_decrypted_packets");
 470         ethtool_sprintf(&data, "hw_tx_csum");
 471         ethtool_sprintf(&data, "hw_tx_inner_csum");
 472         ethtool_sprintf(&data, "tx_gather");
 473         ethtool_sprintf(&data, "tx_lso");
 474         ethtool_sprintf(&data, "tx_tls_encrypted_packets");
 475         ethtool_sprintf(&data, "tx_tls_ooo");
 476         ethtool_sprintf(&data, "tx_tls_drop_no_sync_data");
 477
 478         ethtool_sprintf(&data, "hw_tls_no_space");
 479         ethtool_sprintf(&data, "rx_tls_resync_req_ok");
 480         ethtool_sprintf(&data, "rx_tls_resync_req_ign");
 481         ethtool_sprintf(&data, "rx_tls_resync_sent");
 482
 483         return data;
 484 }
 485
 486 static u64 *nfp_vnic_get_sw_stats(struct net_device *netdev, u64 *data)
 487 {
 488         u64 gathered_stats[NN_RVEC_GATHER_STATS] = {};
 489         struct nfp_net *nn = netdev_priv(netdev);
 490         u64 tmp[NN_RVEC_GATHER_STATS];
 491         unsigned int i, j;
 492
 493         for (i = 0; i < nn->max_r_vecs; i++) {
 494                 unsigned int start;
 495
 496                 do {
 497                         start = u64_stats_fetch_begin(&nn->r_vecs[i].rx_sync);
 498                         data[0] = nn->r_vecs[i].rx_pkts;
 499                         tmp[0] = nn->r_vecs[i].hw_csum_rx_ok;
 500                         tmp[1] = nn->r_vecs[i].hw_csum_rx_inner_ok;
 501                         tmp[2] = nn->r_vecs[i].hw_csum_rx_complete;
 502                         tmp[3] = nn->r_vecs[i].hw_csum_rx_error;
 503                         tmp[4] = nn->r_vecs[i].rx_replace_buf_alloc_fail;
 504                         tmp[5] = nn->r_vecs[i].hw_tls_rx;
 505                 } while (u64_stats_fetch_retry(&nn->r_vecs[i].rx_sync, start));
 506
 507                 do {
 508                         start = u64_stats_fetch_begin(&nn->r_vecs[i].tx_sync);
 509                         data[1] = nn->r_vecs[i].tx_pkts;
 510                         data[2] = nn->r_vecs[i].tx_busy;
 511                         tmp[6] = nn->r_vecs[i].hw_csum_tx;
 512                         tmp[7] = nn->r_vecs[i].hw_csum_tx_inner;
 513                         tmp[8] = nn->r_vecs[i].tx_gather;
 514                         tmp[9] = nn->r_vecs[i].tx_lso;
 515                         tmp[10] = nn->r_vecs[i].hw_tls_tx;
 516                         tmp[11] = nn->r_vecs[i].tls_tx_fallback;
 517                         tmp[12] = nn->r_vecs[i].tls_tx_no_fallback;
 518                 } while (u64_stats_fetch_retry(&nn->r_vecs[i].tx_sync, start));
 519
 520                 data += NN_RVEC_PER_Q_STATS;
 521
 522                 for (j = 0; j < NN_RVEC_GATHER_STATS; j++)
 523                         gathered_stats[j] += tmp[j];
 524         }
 525
 526         for (j = 0; j < NN_RVEC_GATHER_STATS; j++)
 527                 *data++ = gathered_stats[j];
 528
 529         *data++ = atomic_read(&nn->ktls_no_space);
 530         *data++ = atomic_read(&nn->ktls_rx_resync_req);
 531         *data++ = atomic_read(&nn->ktls_rx_resync_ign);
 532         *data++ = atomic_read(&nn->ktls_rx_resync_sent);
 533
 534         return data;
 535 }
 536
 537 static unsigned int nfp_vnic_get_hw_stats_count(unsigned int num_vecs)
 538 {
 539         return NN_ET_GLOBAL_STATS_LEN + num_vecs * 4;
 540 }
 541
 542 static u8 *
 543 nfp_vnic_get_hw_stats_strings(u8 *data, unsigned int num_vecs, bool repr)
 544 {
 545         int swap_off, i;
 546
 547         BUILD_BUG_ON(NN_ET_GLOBAL_STATS_LEN < NN_ET_SWITCH_STATS_LEN * 2);
 548         /* If repr is true first add SWITCH_STATS_LEN and then subtract it
 549          * effectively swapping the RX and TX statistics (giving us the RX
 550          * and TX from perspective of the switch).
 551          */
 552         swap_off = repr * NN_ET_SWITCH_STATS_LEN;
 553
 554         for (i = 0; i < NN_ET_SWITCH_STATS_LEN; i++)
 555                 ethtool_sprintf(&data, nfp_net_et_stats[i + swap_off].name);
 556
 557         for (i = NN_ET_SWITCH_STATS_LEN; i < NN_ET_SWITCH_STATS_LEN * 2; i++)
 558                 ethtool_sprintf(&data, nfp_net_et_stats[i - swap_off].name);
 559
 560         for (i = NN_ET_SWITCH_STATS_LEN * 2; i < NN_ET_GLOBAL_STATS_LEN; i++)
 561                 ethtool_sprintf(&data, nfp_net_et_stats[i].name);
 562
 563         for (i = 0; i < num_vecs; i++) {
 564                 ethtool_sprintf(&data, "rxq_%u_pkts", i);
 565                 ethtool_sprintf(&data, "rxq_%u_bytes", i);
 566                 ethtool_sprintf(&data, "txq_%u_pkts", i);
 567                 ethtool_sprintf(&data, "txq_%u_bytes", i);
 568         }
 569
 570         return data;
 571 }
 572
 573 static u64 *
 574 nfp_vnic_get_hw_stats(u64 *data, u8 __iomem *mem, unsigned int num_vecs)
 575 {
 576         unsigned int i;
 577
 578         for (i = 0; i < NN_ET_GLOBAL_STATS_LEN; i++)
 579                 *data++ = readq(mem + nfp_net_et_stats[i].off);
 580
 581         for (i = 0; i < num_vecs; i++) {
 582                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i));
 583                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i) + 8);
 584                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i));
 585                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i) + 8);
 586         }
 587
 588         return data;
 589 }
 590
 591 static unsigned int nfp_vnic_get_tlv_stats_count(struct nfp_net *nn)
 592 {
 593         return nn->tlv_caps.vnic_stats_cnt + nn->max_r_vecs * 4;
 594 }
 595
 596 static u8 *nfp_vnic_get_tlv_stats_strings(struct nfp_net *nn, u8 *data)
 597 {
 598         unsigned int i, id;
 599         u8 __iomem *mem;
 600         u64 id_word = 0;
 601
 602         mem = nn->dp.ctrl_bar + nn->tlv_caps.vnic_stats_off;
 603         for (i = 0; i < nn->tlv_caps.vnic_stats_cnt; i++) {
 604                 if (!(i % 4))
 605                         id_word = readq(mem + i * 2);
 606
 607                 id = (u16)id_word;
 608                 id_word >>= 16;
 609
 610                 if (id < ARRAY_SIZE(nfp_tlv_stat_names) &&
 611                     nfp_tlv_stat_names[id][0]) {
 612                         memcpy(data, nfp_tlv_stat_names[id], ETH_GSTRING_LEN);
 613                         data += ETH_GSTRING_LEN;
 614                 } else {
 615                         ethtool_sprintf(&data, "dev_unknown_stat%u", id);
 616                 }
 617         }
 618
 619         for (i = 0; i < nn->max_r_vecs; i++) {
 620                 ethtool_sprintf(&data, "rxq_%u_pkts", i);
 621                 ethtool_sprintf(&data, "rxq_%u_bytes", i);
 622                 ethtool_sprintf(&data, "txq_%u_pkts", i);
 623                 ethtool_sprintf(&data, "txq_%u_bytes", i);
 624         }
 625
 626         return data;
 627 }
 628
 629 static u64 *nfp_vnic_get_tlv_stats(struct nfp_net *nn, u64 *data)
 630 {
 631         u8 __iomem *mem;
 632         unsigned int i;
 633
 634         mem = nn->dp.ctrl_bar + nn->tlv_caps.vnic_stats_off;
 635         mem += roundup(2 * nn->tlv_caps.vnic_stats_cnt, 8);
 636         for (i = 0; i < nn->tlv_caps.vnic_stats_cnt; i++)
 637                 *data++ = readq(mem + i * 8);
 638
 639         mem = nn->dp.ctrl_bar;
 640         for (i = 0; i < nn->max_r_vecs; i++) {
 641                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i));
 642                 *data++ = readq(mem + NFP_NET_CFG_RXR_STATS(i) + 8);
 643                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i));
 644                 *data++ = readq(mem + NFP_NET_CFG_TXR_STATS(i) + 8);
 645         }
 646
 647         return data;
 648 }
 649
 650 static unsigned int nfp_mac_get_stats_count(struct net_device *netdev)
 651 {
 652         struct nfp_port *port;
 653
 654         port = nfp_port_from_netdev(netdev);
 655         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 656                 return 0;
 657
 658         return ARRAY_SIZE(nfp_mac_et_stats);
 659 }
 660
 661 static u8 *nfp_mac_get_stats_strings(struct net_device *netdev, u8 *data)
 662 {
 663         struct nfp_port *port;
 664         unsigned int i;
 665
 666         port = nfp_port_from_netdev(netdev);
 667         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 668                 return data;
 669
 670         for (i = 0; i < ARRAY_SIZE(nfp_mac_et_stats); i++)
 671                 ethtool_sprintf(&data, "mac.%s", nfp_mac_et_stats[i].name);
 672
 673         return data;
 674 }
 675
 676 static u64 *nfp_mac_get_stats(struct net_device *netdev, u64 *data)
 677 {
 678         struct nfp_port *port;
 679         unsigned int i;
 680
 681         port = nfp_port_from_netdev(netdev);
 682         if (!__nfp_port_get_eth_port(port) || !port->eth_stats)
 683                 return data;
 684
 685         for (i = 0; i < ARRAY_SIZE(nfp_mac_et_stats); i++)
 686                 *data++ = readq(port->eth_stats + nfp_mac_et_stats[i].off);
 687
 688         return data;
 689 }
 690
 691 static void nfp_net_get_strings(struct net_device *netdev,
 692                                 u32 stringset, u8 *data)
 693 {
 694         struct nfp_net *nn = netdev_priv(netdev);
 695
 696         switch (stringset) {
 697         case ETH_SS_STATS:
 698                 data = nfp_vnic_get_sw_stats_strings(netdev, data);
 699                 if (!nn->tlv_caps.vnic_stats_off)
 700                         data = nfp_vnic_get_hw_stats_strings(data,
 701                                                              nn->max_r_vecs,
 702                                                              false);
 703                 else
 704                         data = nfp_vnic_get_tlv_stats_strings(nn, data);
 705                 data = nfp_mac_get_stats_strings(netdev, data);
 706                 data = nfp_app_port_get_stats_strings(nn->port, data);
 707                 break;
 708         }
 709 }
 710
 711 static void
 712 nfp_net_get_stats(struct net_device *netdev, struct ethtool_stats *stats,
 713                   u64 *data)
 714 {
 715         struct nfp_net *nn = netdev_priv(netdev);
 716
 717         data = nfp_vnic_get_sw_stats(netdev, data);
 718         if (!nn->tlv_caps.vnic_stats_off)
 719                 data = nfp_vnic_get_hw_stats(data, nn->dp.ctrl_bar,
 720                                              nn->max_r_vecs);
 721         else
 722                 data = nfp_vnic_get_tlv_stats(nn, data);
 723         data = nfp_mac_get_stats(netdev, data);
 724         data = nfp_app_port_get_stats(nn->port, data);
 725 }
 726
 727 static int nfp_net_get_sset_count(struct net_device *netdev, int sset)
 728 {
 729         struct nfp_net *nn = netdev_priv(netdev);
 730         unsigned int cnt;
 731
 732         switch (sset) {
 733         case ETH_SS_STATS:
 734                 cnt = nfp_vnic_get_sw_stats_count(netdev);
 735                 if (!nn->tlv_caps.vnic_stats_off)
 736                         cnt += nfp_vnic_get_hw_stats_count(nn->max_r_vecs);
 737                 else
 738                         cnt += nfp_vnic_get_tlv_stats_count(nn);
 739                 cnt += nfp_mac_get_stats_count(netdev);
 740                 cnt += nfp_app_port_get_stats_count(nn->port);
 741                 return cnt;
 742         default:
 743                 return -EOPNOTSUPP;
 744         }
 745 }
 746
 747 static void nfp_port_get_strings(struct net_device *netdev,
 748                                  u32 stringset, u8 *data)
 749 {
 750         struct nfp_port *port = nfp_port_from_netdev(netdev);
 751
 752         switch (stringset) {
 753         case ETH_SS_STATS:
 754                 if (nfp_port_is_vnic(port))
 755                         data = nfp_vnic_get_hw_stats_strings(data, 0, true);
 756                 else
 757                         data = nfp_mac_get_stats_strings(netdev, data);
 758                 data = nfp_app_port_get_stats_strings(port, data);
 759                 break;
 760         }
 761 }
 762
 763 static void
 764 nfp_port_get_stats(struct net_device *netdev, struct ethtool_stats *stats,
 765                    u64 *data)
 766 {
 767         struct nfp_port *port = nfp_port_from_netdev(netdev);
 768
 769         if (nfp_port_is_vnic(port))
 770                 data = nfp_vnic_get_hw_stats(data, port->vnic, 0);
 771         else
 772                 data = nfp_mac_get_stats(netdev, data);
 773         data = nfp_app_port_get_stats(port, data);
 774 }
 775
 776 static int nfp_port_get_sset_count(struct net_device *netdev, int sset)
 777 {
 778         struct nfp_port *port = nfp_port_from_netdev(netdev);
 779         unsigned int count;
 780
 781         switch (sset) {
 782         case ETH_SS_STATS:
 783                 if (nfp_port_is_vnic(port))
 784                         count = nfp_vnic_get_hw_stats_count(0);
 785                 else
 786                         count = nfp_mac_get_stats_count(netdev);
 787                 count += nfp_app_port_get_stats_count(port);
 788                 return count;
 789         default:
 790                 return -EOPNOTSUPP;
 791         }
 792 }
 793
 794 static int nfp_port_fec_ethtool_to_nsp(u32 fec)
 795 {
 796         switch (fec) {
 797         case ETHTOOL_FEC_AUTO:
 798                 return NFP_FEC_AUTO_BIT;
 799         case ETHTOOL_FEC_OFF:
 800                 return NFP_FEC_DISABLED_BIT;
 801         case ETHTOOL_FEC_RS:
 802                 return NFP_FEC_REED_SOLOMON_BIT;
 803         case ETHTOOL_FEC_BASER:
 804                 return NFP_FEC_BASER_BIT;
 805         default:
 806                 /* NSP only supports a single mode at a time */
 807                 return -EOPNOTSUPP;
 808         }
 809 }
 810
 811 static u32 nfp_port_fec_nsp_to_ethtool(u32 fec)
 812 {
 813         u32 result = 0;
 814
 815         if (fec & NFP_FEC_AUTO)
 816                 result |= ETHTOOL_FEC_AUTO;
 817         if (fec & NFP_FEC_BASER)
 818                 result |= ETHTOOL_FEC_BASER;
 819         if (fec & NFP_FEC_REED_SOLOMON)
 820                 result |= ETHTOOL_FEC_RS;
 821         if (fec & NFP_FEC_DISABLED)
 822                 result |= ETHTOOL_FEC_OFF;
 823
 824         return result ?: ETHTOOL_FEC_NONE;
 825 }
 826
 827 static int
 828 nfp_port_get_fecparam(struct net_device *netdev,
 829                       struct ethtool_fecparam *param)
 830 {
 831         struct nfp_eth_table_port *eth_port;
 832         struct nfp_port *port;
 833
 834         param->active_fec = ETHTOOL_FEC_NONE;
 835         param->fec = ETHTOOL_FEC_NONE;
 836
 837         port = nfp_port_from_netdev(netdev);
 838         eth_port = nfp_port_get_eth_port(port);
 839         if (!eth_port)
 840                 return -EOPNOTSUPP;
 841
 842         if (!nfp_eth_can_support_fec(eth_port))
 843                 return 0;
 844
 845         param->fec = nfp_port_fec_nsp_to_ethtool(eth_port->fec_modes_supported);
 846         param->active_fec = nfp_port_fec_nsp_to_ethtool(eth_port->fec);
 847
 848         return 0;
 849 }
 850
 851 static int
 852 nfp_port_set_fecparam(struct net_device *netdev,
 853                       struct ethtool_fecparam *param)
 854 {
 855         struct nfp_eth_table_port *eth_port;
 856         struct nfp_port *port;
 857         int err, fec;
 858
 859         port = nfp_port_from_netdev(netdev);
 860         eth_port = nfp_port_get_eth_port(port);
 861         if (!eth_port)
 862                 return -EOPNOTSUPP;
 863
 864         if (!nfp_eth_can_support_fec(eth_port))
 865                 return -EOPNOTSUPP;
 866
 867         fec = nfp_port_fec_ethtool_to_nsp(param->fec);
 868         if (fec < 0)
 869                 return fec;
 870
 871         err = nfp_eth_set_fec(port->app->cpp, eth_port->index, fec);
 872         if (!err)
 873                 /* Only refresh if we did something */
 874                 nfp_net_refresh_port_table(port);
 875
 876         return err < 0 ? err : 0;
 877 }
 878
 879 /* RX network flow classification (RSS, filters, etc)
 880  */
 881 static u32 ethtool_flow_to_nfp_flag(u32 flow_type)
 882 {
 883         static const u32 xlate_ethtool_to_nfp[IPV6_FLOW + 1] = {
 884                 [TCP_V4_FLOW]   = NFP_NET_CFG_RSS_IPV4_TCP,
 885                 [TCP_V6_FLOW]   = NFP_NET_CFG_RSS_IPV6_TCP,
 886                 [UDP_V4_FLOW]   = NFP_NET_CFG_RSS_IPV4_UDP,
 887                 [UDP_V6_FLOW]   = NFP_NET_CFG_RSS_IPV6_UDP,
 888                 [IPV4_FLOW]     = NFP_NET_CFG_RSS_IPV4,
 889                 [IPV6_FLOW]     = NFP_NET_CFG_RSS_IPV6,
 890         };
 891
 892         if (flow_type >= ARRAY_SIZE(xlate_ethtool_to_nfp))
 893                 return 0;
 894
 895         return xlate_ethtool_to_nfp[flow_type];
 896 }
 897
 898 static int nfp_net_get_rss_hash_opts(struct nfp_net *nn,
 899                                      struct ethtool_rxnfc *cmd)
 900 {
 901         u32 nfp_rss_flag;
 902
 903         cmd->data = 0;
 904
 905         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 906                 return -EOPNOTSUPP;
 907
 908         nfp_rss_flag = ethtool_flow_to_nfp_flag(cmd->flow_type);
 909         if (!nfp_rss_flag)
 910                 return -EINVAL;
 911
 912         cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 913         if (nn->rss_cfg & nfp_rss_flag)
 914                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 915
 916         return 0;
 917 }
 918
 919 static int nfp_net_get_rxnfc(struct net_device *netdev,
 920                              struct ethtool_rxnfc *cmd, u32 *rule_locs)
 921 {
 922         struct nfp_net *nn = netdev_priv(netdev);
 923
 924         switch (cmd->cmd) {
 925         case ETHTOOL_GRXRINGS:
 926                 cmd->data = nn->dp.num_rx_rings;
 927                 return 0;
 928         case ETHTOOL_GRXFH:
 929                 return nfp_net_get_rss_hash_opts(nn, cmd);
 930         default:
 931                 return -EOPNOTSUPP;
 932         }
 933 }
 934
 935 static int nfp_net_set_rss_hash_opt(struct nfp_net *nn,
 936                                     struct ethtool_rxnfc *nfc)
 937 {
 938         u32 new_rss_cfg = nn->rss_cfg;
 939         u32 nfp_rss_flag;
 940         int err;
 941
 942         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
 943                 return -EOPNOTSUPP;
 944
 945         /* RSS only supports IP SA/DA and L4 src/dst ports  */
 946         if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
 947                           RXH_L4_B_0_1 | RXH_L4_B_2_3))
 948                 return -EINVAL;
 949
 950         /* We need at least the IP SA/DA fields for hashing */
 951         if (!(nfc->data & RXH_IP_SRC) ||
 952             !(nfc->data & RXH_IP_DST))
 953                 return -EINVAL;
 954
 955         nfp_rss_flag = ethtool_flow_to_nfp_flag(nfc->flow_type);
 956         if (!nfp_rss_flag)
 957                 return -EINVAL;
 958
 959         switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
 960         case 0:
 961                 new_rss_cfg &= ~nfp_rss_flag;
 962                 break;
 963         case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
 964                 new_rss_cfg |= nfp_rss_flag;
 965                 break;
 966         default:
 967                 return -EINVAL;
 968         }
 969
 970         new_rss_cfg |= FIELD_PREP(NFP_NET_CFG_RSS_HFUNC, nn->rss_hfunc);
 971         new_rss_cfg |= NFP_NET_CFG_RSS_MASK;
 972
 973         if (new_rss_cfg == nn->rss_cfg)
 974                 return 0;
 975
 976         writel(new_rss_cfg, nn->dp.ctrl_bar + NFP_NET_CFG_RSS_CTRL);
 977         err = nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_RSS);
 978         if (err)
 979                 return err;
 980
 981         nn->rss_cfg = new_rss_cfg;
 982
 983         nn_dbg(nn, "Changed RSS config to 0x%x\n", nn->rss_cfg);
 984         return 0;
 985 }
 986
 987 static int nfp_net_set_rxnfc(struct net_device *netdev,
 988                              struct ethtool_rxnfc *cmd)
 989 {
 990         struct nfp_net *nn = netdev_priv(netdev);
 991
 992         switch (cmd->cmd) {
 993         case ETHTOOL_SRXFH:
 994                 return nfp_net_set_rss_hash_opt(nn, cmd);
 995         default:
 996                 return -EOPNOTSUPP;
 997         }
 998 }
 999
1000 static u32 nfp_net_get_rxfh_indir_size(struct net_device *netdev)
1001 {
1002         struct nfp_net *nn = netdev_priv(netdev);
1003
1004         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
1005                 return 0;
1006
1007         return ARRAY_SIZE(nn->rss_itbl);
1008 }
1009
1010 static u32 nfp_net_get_rxfh_key_size(struct net_device *netdev)
1011 {
1012         struct nfp_net *nn = netdev_priv(netdev);
1013
1014         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
1015                 return -EOPNOTSUPP;
1016
1017         return nfp_net_rss_key_sz(nn);
1018 }
1019
1020 static int nfp_net_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
1021                             u8 *hfunc)
1022 {
1023         struct nfp_net *nn = netdev_priv(netdev);
1024         int i;
1025
1026         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY))
1027                 return -EOPNOTSUPP;
1028
1029         if (indir)
1030                 for (i = 0; i < ARRAY_SIZE(nn->rss_itbl); i++)
1031                         indir[i] = nn->rss_itbl[i];
1032         if (key)
1033                 memcpy(key, nn->rss_key, nfp_net_rss_key_sz(nn));
1034         if (hfunc) {
1035                 *hfunc = nn->rss_hfunc;
1036                 if (*hfunc >= 1 << ETH_RSS_HASH_FUNCS_COUNT)
1037                         *hfunc = ETH_RSS_HASH_UNKNOWN;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int nfp_net_set_rxfh(struct net_device *netdev,
1044                             const u32 *indir, const u8 *key,
1045                             const u8 hfunc)
1046 {
1047         struct nfp_net *nn = netdev_priv(netdev);
1048         int i;
1049
1050         if (!(nn->cap & NFP_NET_CFG_CTRL_RSS_ANY) ||
1051             !(hfunc == ETH_RSS_HASH_NO_CHANGE || hfunc == nn->rss_hfunc))
1052                 return -EOPNOTSUPP;
1053
1054         if (!key && !indir)
1055                 return 0;
1056
1057         if (key) {
1058                 memcpy(nn->rss_key, key, nfp_net_rss_key_sz(nn));
1059                 nfp_net_rss_write_key(nn);
1060         }
1061         if (indir) {
1062                 for (i = 0; i < ARRAY_SIZE(nn->rss_itbl); i++)
1063                         nn->rss_itbl[i] = indir[i];
1064
1065                 nfp_net_rss_write_itbl(nn);
1066         }
1067
1068         return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_RSS);
1069 }
1070
1071 /* Dump BAR registers
1072  */
1073 static int nfp_net_get_regs_len(struct net_device *netdev)
1074 {
1075         return NFP_NET_CFG_BAR_SZ;
1076 }
1077
1078 static void nfp_net_get_regs(struct net_device *netdev,
1079                              struct ethtool_regs *regs, void *p)
1080 {
1081         struct nfp_net *nn = netdev_priv(netdev);
1082         u32 *regs_buf = p;
1083         int i;
1084
1085         regs->version = nn_readl(nn, NFP_NET_CFG_VERSION);
1086
1087         for (i = 0; i < NFP_NET_CFG_BAR_SZ / sizeof(u32); i++)
1088                 regs_buf[i] = readl(nn->dp.ctrl_bar + (i * sizeof(u32)));
1089 }
1090
1091 static int nfp_net_get_coalesce(struct net_device *netdev,
1092                                 struct ethtool_coalesce *ec,
1093                                 struct kernel_ethtool_coalesce *kernel_coal,
1094                                 struct netlink_ext_ack *extack)
1095 {
1096         struct nfp_net *nn = netdev_priv(netdev);
1097
1098         if (!(nn->cap & NFP_NET_CFG_CTRL_IRQMOD))
1099                 return -EINVAL;
1100
1101         ec->use_adaptive_rx_coalesce = nn->rx_coalesce_adapt_on;
1102         ec->use_adaptive_tx_coalesce = nn->tx_coalesce_adapt_on;
1103
1104         ec->rx_coalesce_usecs       = nn->rx_coalesce_usecs;
1105         ec->rx_max_coalesced_frames = nn->rx_coalesce_max_frames;
1106         ec->tx_coalesce_usecs       = nn->tx_coalesce_usecs;
1107         ec->tx_max_coalesced_frames = nn->tx_coalesce_max_frames;
1108
1109         return 0;
1110 }
1111
1112 /* Other debug dumps
1113  */
1114 static int
1115 nfp_dump_nsp_diag(struct nfp_app *app, struct ethtool_dump *dump, void *buffer)
1116 {
1117         struct nfp_resource *res;
1118         int ret;
1119
1120         if (!app)
1121                 return -EOPNOTSUPP;
1122
1123         dump->version = 1;
1124         dump->flag = NFP_DUMP_NSP_DIAG;
1125
1126         res = nfp_resource_acquire(app->cpp, NFP_RESOURCE_NSP_DIAG);
1127         if (IS_ERR(res))
1128                 return PTR_ERR(res);
1129
1130         if (buffer) {
1131                 if (dump->len != nfp_resource_size(res)) {
1132                         ret = -EINVAL;
1133                         goto exit_release;
1134                 }
1135
1136                 ret = nfp_cpp_read(app->cpp, nfp_resource_cpp_id(res),
1137                                    nfp_resource_address(res),
1138                                    buffer, dump->len);
1139                 if (ret != dump->len)
1140                         ret = ret < 0 ? ret : -EIO;
1141                 else
1142                         ret = 0;
1143         } else {
1144                 dump->len = nfp_resource_size(res);
1145                 ret = 0;
1146         }
1147 exit_release:
1148         nfp_resource_release(res);
1149
1150         return ret;
1151 }
1152
1153 /* Set the dump flag/level. Calculate the dump length for flag > 0 only (new TLV
1154  * based dumps), since flag 0 (default) calculates the length in
1155  * nfp_app_get_dump_flag(), and we need to support triggering a level 0 dump
1156  * without setting the flag first, for backward compatibility.
1157  */
1158 static int nfp_app_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1159 {
1160         struct nfp_app *app = nfp_app_from_netdev(netdev);
1161         s64 len;
1162
1163         if (!app)
1164                 return -EOPNOTSUPP;
1165
1166         if (val->flag == NFP_DUMP_NSP_DIAG) {
1167                 app->pf->dump_flag = val->flag;
1168                 return 0;
1169         }
1170
1171         if (!app->pf->dumpspec)
1172                 return -EOPNOTSUPP;
1173
1174         len = nfp_net_dump_calculate_size(app->pf, app->pf->dumpspec,
1175                                           val->flag);
1176         if (len < 0)
1177                 return len;
1178
1179         app->pf->dump_flag = val->flag;
1180         app->pf->dump_len = len;
1181
1182         return 0;
1183 }
1184
1185 static int
1186 nfp_app_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1187 {
1188         struct nfp_app *app = nfp_app_from_netdev(netdev);
1189
1190         if (!app)
1191                 return -EOPNOTSUPP;
1192
1193         if (app->pf->dump_flag == NFP_DUMP_NSP_DIAG)
1194                 return nfp_dump_nsp_diag(app, dump, NULL);
1195
1196         dump->flag = app->pf->dump_flag;
1197         dump->len = app->pf->dump_len;
1198
1199         return 0;
1200 }
1201
1202 static int
1203 nfp_app_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1204                       void *buffer)
1205 {
1206         struct nfp_app *app = nfp_app_from_netdev(netdev);
1207
1208         if (!app)
1209                 return -EOPNOTSUPP;
1210
1211         if (app->pf->dump_flag == NFP_DUMP_NSP_DIAG)
1212                 return nfp_dump_nsp_diag(app, dump, buffer);
1213
1214         dump->flag = app->pf->dump_flag;
1215         dump->len = app->pf->dump_len;
1216
1217         return nfp_net_dump_populate_buffer(app->pf, app->pf->dumpspec, dump,
1218                                             buffer);
1219 }
1220
1221 static int
1222 nfp_port_get_module_info(struct net_device *netdev,
1223                          struct ethtool_modinfo *modinfo)
1224 {
1225         struct nfp_eth_table_port *eth_port;
1226         struct nfp_port *port;
1227         unsigned int read_len;
1228         struct nfp_nsp *nsp;
1229         int err = 0;
1230         u8 data;
1231
1232         port = nfp_port_from_netdev(netdev);
1233         eth_port = nfp_port_get_eth_port(port);
1234         if (!eth_port)
1235                 return -EOPNOTSUPP;
1236
1237         nsp = nfp_nsp_open(port->app->cpp);
1238         if (IS_ERR(nsp)) {
1239                 err = PTR_ERR(nsp);
1240                 netdev_err(netdev, "Failed to access the NSP: %d\n", err);
1241                 return err;
1242         }
1243
1244         if (!nfp_nsp_has_read_module_eeprom(nsp)) {
1245                 netdev_info(netdev, "reading module EEPROM not supported. Please update flash\n");
1246                 err = -EOPNOTSUPP;
1247                 goto exit_close_nsp;
1248         }
1249
1250         switch (eth_port->interface) {
1251         case NFP_INTERFACE_SFP:
1252         case NFP_INTERFACE_SFP28:
1253                 err = nfp_nsp_read_module_eeprom(nsp, eth_port->eth_index,
1254                                                  SFP_SFF8472_COMPLIANCE, &data,
1255                                                  1, &read_len);
1256                 if (err < 0)
1257                         goto exit_close_nsp;
1258
1259                 if (!data) {
1260                         modinfo->type = ETH_MODULE_SFF_8079;
1261                         modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
1262                 } else {
1263                         modinfo->type = ETH_MODULE_SFF_8472;
1264                         modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1265                 }
1266                 break;
1267         case NFP_INTERFACE_QSFP:
1268                 err = nfp_nsp_read_module_eeprom(nsp, eth_port->eth_index,
1269                                                  SFP_SFF_REV_COMPLIANCE, &data,
1270                                                  1, &read_len);
1271                 if (err < 0)
1272                         goto exit_close_nsp;
1273
1274                 if (data < 0x3) {
1275                         modinfo->type = ETH_MODULE_SFF_8436;
1276                         modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN;
1277                 } else {
1278                         modinfo->type = ETH_MODULE_SFF_8636;
1279                         modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
1280                 }
1281                 break;
1282         case NFP_INTERFACE_QSFP28:
1283                 modinfo->type = ETH_MODULE_SFF_8636;
1284                 modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN;
1285                 break;
1286         default:
1287                 netdev_err(netdev, "Unsupported module 0x%x detected\n",
1288                            eth_port->interface);
1289                 err = -EINVAL;
1290         }
1291
1292 exit_close_nsp:
1293         nfp_nsp_close(nsp);
1294         return err;
1295 }
1296
1297 static int
1298 nfp_port_get_module_eeprom(struct net_device *netdev,
1299                            struct ethtool_eeprom *eeprom, u8 *data)
1300 {
1301         struct nfp_eth_table_port *eth_port;
1302         struct nfp_port *port;
1303         struct nfp_nsp *nsp;
1304         int err;
1305
1306         port = nfp_port_from_netdev(netdev);
1307         eth_port = __nfp_port_get_eth_port(port);
1308         if (!eth_port)
1309                 return -EOPNOTSUPP;
1310
1311         nsp = nfp_nsp_open(port->app->cpp);
1312         if (IS_ERR(nsp)) {
1313                 err = PTR_ERR(nsp);
1314                 netdev_err(netdev, "Failed to access the NSP: %d\n", err);
1315                 return err;
1316         }
1317
1318         if (!nfp_nsp_has_read_module_eeprom(nsp)) {
1319                 netdev_info(netdev, "reading module EEPROM not supported. Please update flash\n");
1320                 err = -EOPNOTSUPP;
1321                 goto exit_close_nsp;
1322         }
1323
1324         err = nfp_nsp_read_module_eeprom(nsp, eth_port->eth_index,
1325                                          eeprom->offset, data, eeprom->len,
1326                                          &eeprom->len);
1327         if (err < 0) {
1328                 if (eeprom->len) {
1329                         netdev_warn(netdev,
1330                                     "Incomplete read from module EEPROM: %d\n",
1331                                      err);
1332                         err = 0;
1333                 } else {
1334                         netdev_err(netdev,
1335                                    "Reading from module EEPROM failed: %d\n",
1336                                    err);
1337                 }
1338         }
1339
1340 exit_close_nsp:
1341         nfp_nsp_close(nsp);
1342         return err;
1343 }
1344
1345 static int nfp_net_set_coalesce(struct net_device *netdev,
1346                                 struct ethtool_coalesce *ec,
1347                                 struct kernel_ethtool_coalesce *kernel_coal,
1348                                 struct netlink_ext_ack *extack)
1349 {
1350         struct nfp_net *nn = netdev_priv(netdev);
1351         unsigned int factor;
1352
1353         /* Compute factor used to convert coalesce '_usecs' parameters to
1354          * ME timestamp ticks.  There are 16 ME clock cycles for each timestamp
1355          * count.
1356          */
1357         factor = nn->tlv_caps.me_freq_mhz / 16;
1358
1359         /* Each pair of (usecs, max_frames) fields specifies that interrupts
1360          * should be coalesced until
1361          *      (usecs > 0 && time_since_first_completion >= usecs) ||
1362          *      (max_frames > 0 && completed_frames >= max_frames)
1363          *
1364          * It is illegal to set both usecs and max_frames to zero as this would
1365          * cause interrupts to never be generated.  To disable coalescing, set
1366          * usecs = 0 and max_frames = 1.
1367          *
1368          * Some implementations ignore the value of max_frames and use the
1369          * condition time_since_first_completion >= usecs
1370          */
1371
1372         if (!(nn->cap & NFP_NET_CFG_CTRL_IRQMOD))
1373                 return -EINVAL;
1374
1375         /* ensure valid configuration */
1376         if (!ec->rx_coalesce_usecs && !ec->rx_max_coalesced_frames)
1377                 return -EINVAL;
1378
1379         if (!ec->tx_coalesce_usecs && !ec->tx_max_coalesced_frames)
1380                 return -EINVAL;
1381
1382         if (nfp_net_coalesce_para_check(ec->rx_coalesce_usecs * factor,
1383                                         ec->rx_max_coalesced_frames))
1384                 return -EINVAL;
1385
1386         if (nfp_net_coalesce_para_check(ec->tx_coalesce_usecs * factor,
1387                                         ec->tx_max_coalesced_frames))
1388                 return -EINVAL;
1389
1390         /* configuration is valid */
1391         nn->rx_coalesce_adapt_on = !!ec->use_adaptive_rx_coalesce;
1392         nn->tx_coalesce_adapt_on = !!ec->use_adaptive_tx_coalesce;
1393
1394         nn->rx_coalesce_usecs      = ec->rx_coalesce_usecs;
1395         nn->rx_coalesce_max_frames = ec->rx_max_coalesced_frames;
1396         nn->tx_coalesce_usecs      = ec->tx_coalesce_usecs;
1397         nn->tx_coalesce_max_frames = ec->tx_max_coalesced_frames;
1398
1399         /* write configuration to device */
1400         nfp_net_coalesce_write_cfg(nn);
1401         return nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_IRQMOD);
1402 }
1403
1404 static void nfp_net_get_channels(struct net_device *netdev,
1405                                  struct ethtool_channels *channel)
1406 {
1407         struct nfp_net *nn = netdev_priv(netdev);
1408         unsigned int num_tx_rings;
1409
1410         num_tx_rings = nn->dp.num_tx_rings;
1411         if (nn->dp.xdp_prog)
1412                 num_tx_rings -= nn->dp.num_rx_rings;
1413
1414         channel->max_rx = min(nn->max_rx_rings, nn->max_r_vecs);
1415         channel->max_tx = min(nn->max_tx_rings, nn->max_r_vecs);
1416         channel->max_combined = min(channel->max_rx, channel->max_tx);
1417         channel->max_other = NFP_NET_NON_Q_VECTORS;
1418         channel->combined_count = min(nn->dp.num_rx_rings, num_tx_rings);
1419         channel->rx_count = nn->dp.num_rx_rings - channel->combined_count;
1420         channel->tx_count = num_tx_rings - channel->combined_count;
1421         channel->other_count = NFP_NET_NON_Q_VECTORS;
1422 }
1423
1424 static int nfp_net_set_num_rings(struct nfp_net *nn, unsigned int total_rx,
1425                                  unsigned int total_tx)
1426 {
1427         struct nfp_net_dp *dp;
1428
1429         dp = nfp_net_clone_dp(nn);
1430         if (!dp)
1431                 return -ENOMEM;
1432
1433         dp->num_rx_rings = total_rx;
1434         dp->num_tx_rings = total_tx;
1435         /* nfp_net_check_config() will catch num_tx_rings > nn->max_tx_rings */
1436         if (dp->xdp_prog)
1437                 dp->num_tx_rings += total_rx;
1438
1439         return nfp_net_ring_reconfig(nn, dp, NULL);
1440 }
1441
1442 static int nfp_net_set_channels(struct net_device *netdev,
1443                                 struct ethtool_channels *channel)
1444 {
1445         struct nfp_net *nn = netdev_priv(netdev);
1446         unsigned int total_rx, total_tx;
1447
1448         /* Reject unsupported */
1449         if (channel->other_count != NFP_NET_NON_Q_VECTORS ||
1450             (channel->rx_count && channel->tx_count))
1451                 return -EINVAL;
1452
1453         total_rx = channel->combined_count + channel->rx_count;
1454         total_tx = channel->combined_count + channel->tx_count;
1455
1456         if (total_rx > min(nn->max_rx_rings, nn->max_r_vecs) ||
1457             total_tx > min(nn->max_tx_rings, nn->max_r_vecs))
1458                 return -EINVAL;
1459
1460         return nfp_net_set_num_rings(nn, total_rx, total_tx);
1461 }
1462
1463 static const struct ethtool_ops nfp_net_ethtool_ops = {
1464         .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1465                                      ETHTOOL_COALESCE_MAX_FRAMES |
1466                                      ETHTOOL_COALESCE_USE_ADAPTIVE,
1467         .get_drvinfo            = nfp_net_get_drvinfo,
1468         .get_link               = ethtool_op_get_link,
1469         .get_ringparam          = nfp_net_get_ringparam,
1470         .set_ringparam          = nfp_net_set_ringparam,
1471         .get_strings            = nfp_net_get_strings,
1472         .get_ethtool_stats      = nfp_net_get_stats,
1473         .get_sset_count         = nfp_net_get_sset_count,
1474         .get_rxnfc              = nfp_net_get_rxnfc,
1475         .set_rxnfc              = nfp_net_set_rxnfc,
1476         .get_rxfh_indir_size    = nfp_net_get_rxfh_indir_size,
1477         .get_rxfh_key_size      = nfp_net_get_rxfh_key_size,
1478         .get_rxfh               = nfp_net_get_rxfh,
1479         .set_rxfh               = nfp_net_set_rxfh,
1480         .get_regs_len           = nfp_net_get_regs_len,
1481         .get_regs               = nfp_net_get_regs,
1482         .set_dump               = nfp_app_set_dump,
1483         .get_dump_flag          = nfp_app_get_dump_flag,
1484         .get_dump_data          = nfp_app_get_dump_data,
1485         .get_module_info        = nfp_port_get_module_info,
1486         .get_module_eeprom      = nfp_port_get_module_eeprom,
1487         .get_coalesce           = nfp_net_get_coalesce,
1488         .set_coalesce           = nfp_net_set_coalesce,
1489         .get_channels           = nfp_net_get_channels,
1490         .set_channels           = nfp_net_set_channels,
1491         .get_link_ksettings     = nfp_net_get_link_ksettings,
1492         .set_link_ksettings     = nfp_net_set_link_ksettings,
1493         .get_fecparam           = nfp_port_get_fecparam,
1494         .set_fecparam           = nfp_port_set_fecparam,
1495 };
1496
1497 const struct ethtool_ops nfp_port_ethtool_ops = {
1498         .get_drvinfo            = nfp_app_get_drvinfo,
1499         .get_link               = ethtool_op_get_link,
1500         .get_strings            = nfp_port_get_strings,
1501         .get_ethtool_stats      = nfp_port_get_stats,
1502         .get_sset_count         = nfp_port_get_sset_count,
1503         .set_dump               = nfp_app_set_dump,
1504         .get_dump_flag          = nfp_app_get_dump_flag,
1505         .get_dump_data          = nfp_app_get_dump_data,
1506         .get_module_info        = nfp_port_get_module_info,
1507         .get_module_eeprom      = nfp_port_get_module_eeprom,
1508         .get_link_ksettings     = nfp_net_get_link_ksettings,
1509         .set_link_ksettings     = nfp_net_set_link_ksettings,
1510         .get_fecparam           = nfp_port_get_fecparam,
1511         .set_fecparam           = nfp_port_set_fecparam,
1512 };
1513
1514 void nfp_net_set_ethtool_ops(struct net_device *netdev)
1515 {
1516         netdev->ethtool_ops = &nfp_net_ethtool_ops;
1517 }