kernel/drivers/net/ethernet/sfc/ethtool.c

   1 /****************************************************************************
   2  * Driver for Solarflare network controllers and boards
   3  * Copyright 2005-2006 Fen Systems Ltd.
   4  * Copyright 2006-2013 Solarflare Communications Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published
   8  * by the Free Software Foundation, incorporated herein by reference.
   9  */
  10
  11 #include <linux/netdevice.h>
  12 #include <linux/ethtool.h>
  13 #include <linux/rtnetlink.h>
  14 #include <linux/in.h>
  15 #include "net_driver.h"
  16 #include "workarounds.h"
  17 #include "selftest.h"
  18 #include "efx.h"
  19 #include "filter.h"
  20 #include "nic.h"
  21
  22 struct efx_sw_stat_desc {
  23         const char *name;
  24         enum {
  25                 EFX_ETHTOOL_STAT_SOURCE_nic,
  26                 EFX_ETHTOOL_STAT_SOURCE_channel,
  27                 EFX_ETHTOOL_STAT_SOURCE_tx_queue
  28         } source;
  29         unsigned offset;
  30         u64(*get_stat) (void *field); /* Reader function */
  31 };
  32
  33 /* Initialiser for a struct efx_sw_stat_desc with type-checking */
  34 #define EFX_ETHTOOL_STAT(stat_name, source_name, field, field_type, \
  35                                 get_stat_function) {                    \
  36         .name = #stat_name,                                             \
  37         .source = EFX_ETHTOOL_STAT_SOURCE_##source_name,                \
  38         .offset = ((((field_type *) 0) ==                               \
  39                       &((struct efx_##source_name *)0)->field) ?        \
  40                     offsetof(struct efx_##source_name, field) :         \
  41                     offsetof(struct efx_##source_name, field)),         \
  42         .get_stat = get_stat_function,                                  \
  43 }
  44
  45 static u64 efx_get_uint_stat(void *field)
  46 {
  47         return *(unsigned int *)field;
  48 }
  49
  50 static u64 efx_get_atomic_stat(void *field)
  51 {
  52         return atomic_read((atomic_t *) field);
  53 }
  54
  55 #define EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(field)                \
  56         EFX_ETHTOOL_STAT(field, nic, field,                     \
  57                          atomic_t, efx_get_atomic_stat)
  58
  59 #define EFX_ETHTOOL_UINT_CHANNEL_STAT(field)                    \
  60         EFX_ETHTOOL_STAT(field, channel, n_##field,             \
  61                          unsigned int, efx_get_uint_stat)
  62
  63 #define EFX_ETHTOOL_UINT_TXQ_STAT(field)                        \
  64         EFX_ETHTOOL_STAT(tx_##field, tx_queue, field,           \
  65                          unsigned int, efx_get_uint_stat)
  66
  67 static const struct efx_sw_stat_desc efx_sw_stat_desc[] = {
  68         EFX_ETHTOOL_UINT_TXQ_STAT(merge_events),
  69         EFX_ETHTOOL_UINT_TXQ_STAT(tso_bursts),
  70         EFX_ETHTOOL_UINT_TXQ_STAT(tso_long_headers),
  71         EFX_ETHTOOL_UINT_TXQ_STAT(tso_packets),
  72         EFX_ETHTOOL_UINT_TXQ_STAT(pushes),
  73         EFX_ETHTOOL_UINT_TXQ_STAT(pio_packets),
  74         EFX_ETHTOOL_ATOMIC_NIC_ERROR_STAT(rx_reset),
  75         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tobe_disc),
  76         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_ip_hdr_chksum_err),
  77         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_tcp_udp_chksum_err),
  78         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_mcast_mismatch),
  79         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_frm_trunc),
  80         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_events),
  81         EFX_ETHTOOL_UINT_CHANNEL_STAT(rx_merge_packets),
  82 };
  83
  84 #define EFX_ETHTOOL_SW_STAT_COUNT ARRAY_SIZE(efx_sw_stat_desc)
  85
  86 #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
  87
  88 /**************************************************************************
  89  *
  90  * Ethtool operations
  91  *
  92  **************************************************************************
  93  */
  94
  95 /* Identify device by flashing LEDs */
  96 static int efx_ethtool_phys_id(struct net_device *net_dev,
  97                                enum ethtool_phys_id_state state)
  98 {
  99         struct efx_nic *efx = netdev_priv(net_dev);
 100         enum efx_led_mode mode = EFX_LED_DEFAULT;
 101
 102         switch (state) {
 103         case ETHTOOL_ID_ON:
 104                 mode = EFX_LED_ON;
 105                 break;
 106         case ETHTOOL_ID_OFF:
 107                 mode = EFX_LED_OFF;
 108                 break;
 109         case ETHTOOL_ID_INACTIVE:
 110                 mode = EFX_LED_DEFAULT;
 111                 break;
 112         case ETHTOOL_ID_ACTIVE:
 113                 return 1;       /* cycle on/off once per second */
 114         }
 115
 116         efx->type->set_id_led(efx, mode);
 117         return 0;
 118 }
 119
 120 /* This must be called with rtnl_lock held. */
 121 static int efx_ethtool_get_settings(struct net_device *net_dev,
 122                                     struct ethtool_cmd *ecmd)
 123 {
 124         struct efx_nic *efx = netdev_priv(net_dev);
 125         struct efx_link_state *link_state = &efx->link_state;
 126
 127         mutex_lock(&efx->mac_lock);
 128         efx->phy_op->get_settings(efx, ecmd);
 129         mutex_unlock(&efx->mac_lock);
 130
 131         /* Both MACs support pause frames (bidirectional and respond-only) */
 132         ecmd->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
 133
 134         if (LOOPBACK_INTERNAL(efx)) {
 135                 ethtool_cmd_speed_set(ecmd, link_state->speed);
 136                 ecmd->duplex = link_state->fd ? DUPLEX_FULL : DUPLEX_HALF;
 137         }
 138
 139         return 0;
 140 }
 141
 142 /* This must be called with rtnl_lock held. */
 143 static int efx_ethtool_set_settings(struct net_device *net_dev,
 144                                     struct ethtool_cmd *ecmd)
 145 {
 146         struct efx_nic *efx = netdev_priv(net_dev);
 147         int rc;
 148
 149         /* GMAC does not support 1000Mbps HD */
 150         if ((ethtool_cmd_speed(ecmd) == SPEED_1000) &&
 151             (ecmd->duplex != DUPLEX_FULL)) {
 152                 netif_dbg(efx, drv, efx->net_dev,
 153                           "rejecting unsupported 1000Mbps HD setting\n");
 154                 return -EINVAL;
 155         }
 156
 157         mutex_lock(&efx->mac_lock);
 158         rc = efx->phy_op->set_settings(efx, ecmd);
 159         mutex_unlock(&efx->mac_lock);
 160         return rc;
 161 }
 162
 163 static void efx_ethtool_get_drvinfo(struct net_device *net_dev,
 164                                     struct ethtool_drvinfo *info)
 165 {
 166         struct efx_nic *efx = netdev_priv(net_dev);
 167
 168         strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
 169         strlcpy(info->version, EFX_DRIVER_VERSION, sizeof(info->version));
 170         if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0)
 171                 efx_mcdi_print_fwver(efx, info->fw_version,
 172                                      sizeof(info->fw_version));
 173         strlcpy(info->bus_info, pci_name(efx->pci_dev), sizeof(info->bus_info));
 174 }
 175
 176 static int efx_ethtool_get_regs_len(struct net_device *net_dev)
 177 {
 178         return efx_nic_get_regs_len(netdev_priv(net_dev));
 179 }
 180
 181 static void efx_ethtool_get_regs(struct net_device *net_dev,
 182                                  struct ethtool_regs *regs, void *buf)
 183 {
 184         struct efx_nic *efx = netdev_priv(net_dev);
 185
 186         regs->version = efx->type->revision;
 187         efx_nic_get_regs(efx, buf);
 188 }
 189
 190 static u32 efx_ethtool_get_msglevel(struct net_device *net_dev)
 191 {
 192         struct efx_nic *efx = netdev_priv(net_dev);
 193         return efx->msg_enable;
 194 }
 195
 196 static void efx_ethtool_set_msglevel(struct net_device *net_dev, u32 msg_enable)
 197 {
 198         struct efx_nic *efx = netdev_priv(net_dev);
 199         efx->msg_enable = msg_enable;
 200 }
 201
 202 /**
 203  * efx_fill_test - fill in an individual self-test entry
 204  * @test_index:         Index of the test
 205  * @strings:            Ethtool strings, or %NULL
 206  * @data:               Ethtool test results, or %NULL
 207  * @test:               Pointer to test result (used only if data != %NULL)
 208  * @unit_format:        Unit name format (e.g. "chan\%d")
 209  * @unit_id:            Unit id (e.g. 0 for "chan0")
 210  * @test_format:        Test name format (e.g. "loopback.\%s.tx.sent")
 211  * @test_id:            Test id (e.g. "PHYXS" for "loopback.PHYXS.tx_sent")
 212  *
 213  * Fill in an individual self-test entry.
 214  */
 215 static void efx_fill_test(unsigned int test_index, u8 *strings, u64 *data,
 216                           int *test, const char *unit_format, int unit_id,
 217                           const char *test_format, const char *test_id)
 218 {
 219         char unit_str[ETH_GSTRING_LEN], test_str[ETH_GSTRING_LEN];
 220
 221         /* Fill data value, if applicable */
 222         if (data)
 223                 data[test_index] = *test;
 224
 225         /* Fill string, if applicable */
 226         if (strings) {
 227                 if (strchr(unit_format, '%'))
 228                         snprintf(unit_str, sizeof(unit_str),
 229                                  unit_format, unit_id);
 230                 else
 231                         strcpy(unit_str, unit_format);
 232                 snprintf(test_str, sizeof(test_str), test_format, test_id);
 233                 snprintf(strings + test_index * ETH_GSTRING_LEN,
 234                          ETH_GSTRING_LEN,
 235                          "%-6s %-24s", unit_str, test_str);
 236         }
 237 }
 238
 239 #define EFX_CHANNEL_NAME(_channel) "chan%d", _channel->channel
 240 #define EFX_TX_QUEUE_NAME(_tx_queue) "txq%d", _tx_queue->queue
 241 #define EFX_RX_QUEUE_NAME(_rx_queue) "rxq%d", _rx_queue->queue
 242 #define EFX_LOOPBACK_NAME(_mode, _counter)                      \
 243         "loopback.%s." _counter, STRING_TABLE_LOOKUP(_mode, efx_loopback_mode)
 244
 245 /**
 246  * efx_fill_loopback_test - fill in a block of loopback self-test entries
 247  * @efx:                Efx NIC
 248  * @lb_tests:           Efx loopback self-test results structure
 249  * @mode:               Loopback test mode
 250  * @test_index:         Starting index of the test
 251  * @strings:            Ethtool strings, or %NULL
 252  * @data:               Ethtool test results, or %NULL
 253  *
 254  * Fill in a block of loopback self-test entries.  Return new test
 255  * index.
 256  */
 257 static int efx_fill_loopback_test(struct efx_nic *efx,
 258                                   struct efx_loopback_self_tests *lb_tests,
 259                                   enum efx_loopback_mode mode,
 260                                   unsigned int test_index,
 261                                   u8 *strings, u64 *data)
 262 {
 263         struct efx_channel *channel =
 264                 efx_get_channel(efx, efx->tx_channel_offset);
 265         struct efx_tx_queue *tx_queue;
 266
 267         efx_for_each_channel_tx_queue(tx_queue, channel) {
 268                 efx_fill_test(test_index++, strings, data,
 269                               &lb_tests->tx_sent[tx_queue->queue],
 270                               EFX_TX_QUEUE_NAME(tx_queue),
 271                               EFX_LOOPBACK_NAME(mode, "tx_sent"));
 272                 efx_fill_test(test_index++, strings, data,
 273                               &lb_tests->tx_done[tx_queue->queue],
 274                               EFX_TX_QUEUE_NAME(tx_queue),
 275                               EFX_LOOPBACK_NAME(mode, "tx_done"));
 276         }
 277         efx_fill_test(test_index++, strings, data,
 278                       &lb_tests->rx_good,
 279                       "rx", 0,
 280                       EFX_LOOPBACK_NAME(mode, "rx_good"));
 281         efx_fill_test(test_index++, strings, data,
 282                       &lb_tests->rx_bad,
 283                       "rx", 0,
 284                       EFX_LOOPBACK_NAME(mode, "rx_bad"));
 285
 286         return test_index;
 287 }
 288
 289 /**
 290  * efx_ethtool_fill_self_tests - get self-test details
 291  * @efx:                Efx NIC
 292  * @tests:              Efx self-test results structure, or %NULL
 293  * @strings:            Ethtool strings, or %NULL
 294  * @data:               Ethtool test results, or %NULL
 295  *
 296  * Get self-test number of strings, strings, and/or test results.
 297  * Return number of strings (== number of test results).
 298  *
 299  * The reason for merging these three functions is to make sure that
 300  * they can never be inconsistent.
 301  */
 302 static int efx_ethtool_fill_self_tests(struct efx_nic *efx,
 303                                        struct efx_self_tests *tests,
 304                                        u8 *strings, u64 *data)
 305 {
 306         struct efx_channel *channel;
 307         unsigned int n = 0, i;
 308         enum efx_loopback_mode mode;
 309
 310         efx_fill_test(n++, strings, data, &tests->phy_alive,
 311                       "phy", 0, "alive", NULL);
 312         efx_fill_test(n++, strings, data, &tests->nvram,
 313                       "core", 0, "nvram", NULL);
 314         efx_fill_test(n++, strings, data, &tests->interrupt,
 315                       "core", 0, "interrupt", NULL);
 316
 317         /* Event queues */
 318         efx_for_each_channel(channel, efx) {
 319                 efx_fill_test(n++, strings, data,
 320                               &tests->eventq_dma[channel->channel],
 321                               EFX_CHANNEL_NAME(channel),
 322                               "eventq.dma", NULL);
 323                 efx_fill_test(n++, strings, data,
 324                               &tests->eventq_int[channel->channel],
 325                               EFX_CHANNEL_NAME(channel),
 326                               "eventq.int", NULL);
 327         }
 328
 329         efx_fill_test(n++, strings, data, &tests->memory,
 330                       "core", 0, "memory", NULL);
 331         efx_fill_test(n++, strings, data, &tests->registers,
 332                       "core", 0, "registers", NULL);
 333
 334         if (efx->phy_op->run_tests != NULL) {
 335                 EFX_BUG_ON_PARANOID(efx->phy_op->test_name == NULL);
 336
 337                 for (i = 0; true; ++i) {
 338                         const char *name;
 339
 340                         EFX_BUG_ON_PARANOID(i >= EFX_MAX_PHY_TESTS);
 341                         name = efx->phy_op->test_name(efx, i);
 342                         if (name == NULL)
 343                                 break;
 344
 345                         efx_fill_test(n++, strings, data, &tests->phy_ext[i],
 346                                       "phy", 0, name, NULL);
 347                 }
 348         }
 349
 350         /* Loopback tests */
 351         for (mode = LOOPBACK_NONE; mode <= LOOPBACK_TEST_MAX; mode++) {
 352                 if (!(efx->loopback_modes & (1 << mode)))
 353                         continue;
 354                 n = efx_fill_loopback_test(efx,
 355                                            &tests->loopback[mode], mode, n,
 356                                            strings, data);
 357         }
 358
 359         return n;
 360 }
 361
 362 static size_t efx_describe_per_queue_stats(struct efx_nic *efx, u8 *strings)
 363 {
 364         size_t n_stats = 0;
 365         struct efx_channel *channel;
 366
 367         efx_for_each_channel(channel, efx) {
 368                 if (efx_channel_has_tx_queues(channel)) {
 369                         n_stats++;
 370                         if (strings != NULL) {
 371                                 snprintf(strings, ETH_GSTRING_LEN,
 372                                          "tx-%u.tx_packets",
 373                                          channel->tx_queue[0].queue /
 374                                          EFX_TXQ_TYPES);
 375
 376                                 strings += ETH_GSTRING_LEN;
 377                         }
 378                 }
 379         }
 380         efx_for_each_channel(channel, efx) {
 381                 if (efx_channel_has_rx_queue(channel)) {
 382                         n_stats++;
 383                         if (strings != NULL) {
 384                                 snprintf(strings, ETH_GSTRING_LEN,
 385                                          "rx-%d.rx_packets", channel->channel);
 386                                 strings += ETH_GSTRING_LEN;
 387                         }
 388                 }
 389         }
 390         return n_stats;
 391 }
 392
 393 static int efx_ethtool_get_sset_count(struct net_device *net_dev,
 394                                       int string_set)
 395 {
 396         struct efx_nic *efx = netdev_priv(net_dev);
 397
 398         switch (string_set) {
 399         case ETH_SS_STATS:
 400                 return efx->type->describe_stats(efx, NULL) +
 401                        EFX_ETHTOOL_SW_STAT_COUNT +
 402                        efx_describe_per_queue_stats(efx, NULL) +
 403                        efx_ptp_describe_stats(efx, NULL);
 404         case ETH_SS_TEST:
 405                 return efx_ethtool_fill_self_tests(efx, NULL, NULL, NULL);
 406         default:
 407                 return -EINVAL;
 408         }
 409 }
 410
 411 static void efx_ethtool_get_strings(struct net_device *net_dev,
 412                                     u32 string_set, u8 *strings)
 413 {
 414         struct efx_nic *efx = netdev_priv(net_dev);
 415         int i;
 416
 417         switch (string_set) {
 418         case ETH_SS_STATS:
 419                 strings += (efx->type->describe_stats(efx, strings) *
 420                             ETH_GSTRING_LEN);
 421                 for (i = 0; i < EFX_ETHTOOL_SW_STAT_COUNT; i++)
 422                         strlcpy(strings + i * ETH_GSTRING_LEN,
 423                                 efx_sw_stat_desc[i].name, ETH_GSTRING_LEN);
 424                 strings += EFX_ETHTOOL_SW_STAT_COUNT * ETH_GSTRING_LEN;
 425                 strings += (efx_describe_per_queue_stats(efx, strings) *
 426                             ETH_GSTRING_LEN);
 427                 efx_ptp_describe_stats(efx, strings);
 428                 break;
 429         case ETH_SS_TEST:
 430                 efx_ethtool_fill_self_tests(efx, NULL, strings, NULL);
 431                 break;
 432         default:
 433                 /* No other string sets */
 434                 break;
 435         }
 436 }
 437
 438 static void efx_ethtool_get_stats(struct net_device *net_dev,
 439                                   struct ethtool_stats *stats,
 440                                   u64 *data)
 441 {
 442         struct efx_nic *efx = netdev_priv(net_dev);
 443         const struct efx_sw_stat_desc *stat;
 444         struct efx_channel *channel;
 445         struct efx_tx_queue *tx_queue;
 446         struct efx_rx_queue *rx_queue;
 447         int i;
 448
 449         spin_lock_bh(&efx->stats_lock);
 450
 451         /* Get NIC statistics */
 452         data += efx->type->update_stats(efx, data, NULL);
 453
 454         /* Get software statistics */
 455         for (i = 0; i < EFX_ETHTOOL_SW_STAT_COUNT; i++) {
 456                 stat = &efx_sw_stat_desc[i];
 457                 switch (stat->source) {
 458                 case EFX_ETHTOOL_STAT_SOURCE_nic:
 459                         data[i] = stat->get_stat((void *)efx + stat->offset);
 460                         break;
 461                 case EFX_ETHTOOL_STAT_SOURCE_channel:
 462                         data[i] = 0;
 463                         efx_for_each_channel(channel, efx)
 464                                 data[i] += stat->get_stat((void *)channel +
 465                                                           stat->offset);
 466                         break;
 467                 case EFX_ETHTOOL_STAT_SOURCE_tx_queue:
 468                         data[i] = 0;
 469                         efx_for_each_channel(channel, efx) {
 470                                 efx_for_each_channel_tx_queue(tx_queue, channel)
 471                                         data[i] +=
 472                                                 stat->get_stat((void *)tx_queue
 473                                                                + stat->offset);
 474                         }
 475                         break;
 476                 }
 477         }
 478         data += EFX_ETHTOOL_SW_STAT_COUNT;
 479
 480         spin_unlock_bh(&efx->stats_lock);
 481
 482         efx_for_each_channel(channel, efx) {
 483                 if (efx_channel_has_tx_queues(channel)) {
 484                         *data = 0;
 485                         efx_for_each_channel_tx_queue(tx_queue, channel) {
 486                                 *data += tx_queue->tx_packets;
 487                         }
 488                         data++;
 489                 }
 490         }
 491         efx_for_each_channel(channel, efx) {
 492                 if (efx_channel_has_rx_queue(channel)) {
 493                         *data = 0;
 494                         efx_for_each_channel_rx_queue(rx_queue, channel) {
 495                                 *data += rx_queue->rx_packets;
 496                         }
 497                         data++;
 498                 }
 499         }
 500
 501         efx_ptp_update_stats(efx, data);
 502 }
 503
 504 static void efx_ethtool_self_test(struct net_device *net_dev,
 505                                   struct ethtool_test *test, u64 *data)
 506 {
 507         struct efx_nic *efx = netdev_priv(net_dev);
 508         struct efx_self_tests *efx_tests;
 509         bool already_up;
 510         int rc = -ENOMEM;
 511
 512         efx_tests = kzalloc(sizeof(*efx_tests), GFP_KERNEL);
 513         if (!efx_tests)
 514                 goto fail;
 515
 516         if (efx->state != STATE_READY) {
 517                 rc = -EBUSY;
 518                 goto out;
 519         }
 520
 521         netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
 522                    (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
 523
 524         /* We need rx buffers and interrupts. */
 525         already_up = (efx->net_dev->flags & IFF_UP);
 526         if (!already_up) {
 527                 rc = dev_open(efx->net_dev);
 528                 if (rc) {
 529                         netif_err(efx, drv, efx->net_dev,
 530                                   "failed opening device.\n");
 531                         goto out;
 532                 }
 533         }
 534
 535         rc = efx_selftest(efx, efx_tests, test->flags);
 536
 537         if (!already_up)
 538                 dev_close(efx->net_dev);
 539
 540         netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
 541                    rc == 0 ? "passed" : "failed",
 542                    (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
 543
 544 out:
 545         efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data);
 546         kfree(efx_tests);
 547 fail:
 548         if (rc)
 549                 test->flags |= ETH_TEST_FL_FAILED;
 550 }
 551
 552 /* Restart autonegotiation */
 553 static int efx_ethtool_nway_reset(struct net_device *net_dev)
 554 {
 555         struct efx_nic *efx = netdev_priv(net_dev);
 556
 557         return mdio45_nway_restart(&efx->mdio);
 558 }
 559
 560 /*
 561  * Each channel has a single IRQ and moderation timer, started by any
 562  * completion (or other event).  Unless the module parameter
 563  * separate_tx_channels is set, IRQs and moderation are therefore
 564  * shared between RX and TX completions.  In this case, when RX IRQ
 565  * moderation is explicitly changed then TX IRQ moderation is
 566  * automatically changed too, but otherwise we fail if the two values
 567  * are requested to be different.
 568  *
 569  * The hardware does not support a limit on the number of completions
 570  * before an IRQ, so we do not use the max_frames fields.  We should
 571  * report and require that max_frames == (usecs != 0), but this would
 572  * invalidate existing user documentation.
 573  *
 574  * The hardware does not have distinct settings for interrupt
 575  * moderation while the previous IRQ is being handled, so we should
 576  * not use the 'irq' fields.  However, an earlier developer
 577  * misunderstood the meaning of the 'irq' fields and the driver did
 578  * not support the standard fields.  To avoid invalidating existing
 579  * user documentation, we report and accept changes through either the
 580  * standard or 'irq' fields.  If both are changed at the same time, we
 581  * prefer the standard field.
 582  *
 583  * We implement adaptive IRQ moderation, but use a different algorithm
 584  * from that assumed in the definition of struct ethtool_coalesce.
 585  * Therefore we do not use any of the adaptive moderation parameters
 586  * in it.
 587  */
 588
 589 static int efx_ethtool_get_coalesce(struct net_device *net_dev,
 590                                     struct ethtool_coalesce *coalesce)
 591 {
 592         struct efx_nic *efx = netdev_priv(net_dev);
 593         unsigned int tx_usecs, rx_usecs;
 594         bool rx_adaptive;
 595
 596         efx_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &rx_adaptive);
 597
 598         coalesce->tx_coalesce_usecs = tx_usecs;
 599         coalesce->tx_coalesce_usecs_irq = tx_usecs;
 600         coalesce->rx_coalesce_usecs = rx_usecs;
 601         coalesce->rx_coalesce_usecs_irq = rx_usecs;
 602         coalesce->use_adaptive_rx_coalesce = rx_adaptive;
 603
 604         return 0;
 605 }
 606
 607 static int efx_ethtool_set_coalesce(struct net_device *net_dev,
 608                                     struct ethtool_coalesce *coalesce)
 609 {
 610         struct efx_nic *efx = netdev_priv(net_dev);
 611         struct efx_channel *channel;
 612         unsigned int tx_usecs, rx_usecs;
 613         bool adaptive, rx_may_override_tx;
 614         int rc;
 615
 616         if (coalesce->use_adaptive_tx_coalesce)
 617                 return -EINVAL;
 618
 619         efx_get_irq_moderation(efx, &tx_usecs, &rx_usecs, &adaptive);
 620
 621         if (coalesce->rx_coalesce_usecs != rx_usecs)
 622                 rx_usecs = coalesce->rx_coalesce_usecs;
 623         else
 624                 rx_usecs = coalesce->rx_coalesce_usecs_irq;
 625
 626         adaptive = coalesce->use_adaptive_rx_coalesce;
 627
 628         /* If channels are shared, TX IRQ moderation can be quietly
 629          * overridden unless it is changed from its old value.
 630          */
 631         rx_may_override_tx = (coalesce->tx_coalesce_usecs == tx_usecs &&
 632                               coalesce->tx_coalesce_usecs_irq == tx_usecs);
 633         if (coalesce->tx_coalesce_usecs != tx_usecs)
 634                 tx_usecs = coalesce->tx_coalesce_usecs;
 635         else
 636                 tx_usecs = coalesce->tx_coalesce_usecs_irq;
 637
 638         rc = efx_init_irq_moderation(efx, tx_usecs, rx_usecs, adaptive,
 639                                      rx_may_override_tx);
 640         if (rc != 0)
 641                 return rc;
 642
 643         efx_for_each_channel(channel, efx)
 644                 efx->type->push_irq_moderation(channel);
 645
 646         return 0;
 647 }
 648
 649 static void efx_ethtool_get_ringparam(struct net_device *net_dev,
 650                                       struct ethtool_ringparam *ring)
 651 {
 652         struct efx_nic *efx = netdev_priv(net_dev);
 653
 654         ring->rx_max_pending = EFX_MAX_DMAQ_SIZE;
 655         ring->tx_max_pending = EFX_TXQ_MAX_ENT(efx);
 656         ring->rx_pending = efx->rxq_entries;
 657         ring->tx_pending = efx->txq_entries;
 658 }
 659
 660 static int efx_ethtool_set_ringparam(struct net_device *net_dev,
 661                                      struct ethtool_ringparam *ring)
 662 {
 663         struct efx_nic *efx = netdev_priv(net_dev);
 664         u32 txq_entries;
 665
 666         if (ring->rx_mini_pending || ring->rx_jumbo_pending ||
 667             ring->rx_pending > EFX_MAX_DMAQ_SIZE ||
 668             ring->tx_pending > EFX_TXQ_MAX_ENT(efx))
 669                 return -EINVAL;
 670
 671         if (ring->rx_pending < EFX_RXQ_MIN_ENT) {
 672                 netif_err(efx, drv, efx->net_dev,
 673                           "RX queues cannot be smaller than %u\n",
 674                           EFX_RXQ_MIN_ENT);
 675                 return -EINVAL;
 676         }
 677
 678         txq_entries = max(ring->tx_pending, EFX_TXQ_MIN_ENT(efx));
 679         if (txq_entries != ring->tx_pending)
 680                 netif_warn(efx, drv, efx->net_dev,
 681                            "increasing TX queue size to minimum of %u\n",
 682                            txq_entries);
 683
 684         return efx_realloc_channels(efx, ring->rx_pending, txq_entries);
 685 }
 686
 687 static int efx_ethtool_set_pauseparam(struct net_device *net_dev,
 688                                       struct ethtool_pauseparam *pause)
 689 {
 690         struct efx_nic *efx = netdev_priv(net_dev);
 691         u8 wanted_fc, old_fc;
 692         u32 old_adv;
 693         int rc = 0;
 694
 695         mutex_lock(&efx->mac_lock);
 696
 697         wanted_fc = ((pause->rx_pause ? EFX_FC_RX : 0) |
 698                      (pause->tx_pause ? EFX_FC_TX : 0) |
 699                      (pause->autoneg ? EFX_FC_AUTO : 0));
 700
 701         if ((wanted_fc & EFX_FC_TX) && !(wanted_fc & EFX_FC_RX)) {
 702                 netif_dbg(efx, drv, efx->net_dev,
 703                           "Flow control unsupported: tx ON rx OFF\n");
 704                 rc = -EINVAL;
 705                 goto out;
 706         }
 707
 708         if ((wanted_fc & EFX_FC_AUTO) && !efx->link_advertising) {
 709                 netif_dbg(efx, drv, efx->net_dev,
 710                           "Autonegotiation is disabled\n");
 711                 rc = -EINVAL;
 712                 goto out;
 713         }
 714
 715         /* Hook for Falcon bug 11482 workaround */
 716         if (efx->type->prepare_enable_fc_tx &&
 717             (wanted_fc & EFX_FC_TX) && !(efx->wanted_fc & EFX_FC_TX))
 718                 efx->type->prepare_enable_fc_tx(efx);
 719
 720         old_adv = efx->link_advertising;
 721         old_fc = efx->wanted_fc;
 722         efx_link_set_wanted_fc(efx, wanted_fc);
 723         if (efx->link_advertising != old_adv ||
 724             (efx->wanted_fc ^ old_fc) & EFX_FC_AUTO) {
 725                 rc = efx->phy_op->reconfigure(efx);
 726                 if (rc) {
 727                         netif_err(efx, drv, efx->net_dev,
 728                                   "Unable to advertise requested flow "
 729                                   "control setting\n");
 730                         goto out;
 731                 }
 732         }
 733
 734         /* Reconfigure the MAC. The PHY *may* generate a link state change event
 735          * if the user just changed the advertised capabilities, but there's no
 736          * harm doing this twice */
 737         efx->type->reconfigure_mac(efx);
 738
 739 out:
 740         mutex_unlock(&efx->mac_lock);
 741
 742         return rc;
 743 }
 744
 745 static void efx_ethtool_get_pauseparam(struct net_device *net_dev,
 746                                        struct ethtool_pauseparam *pause)
 747 {
 748         struct efx_nic *efx = netdev_priv(net_dev);
 749
 750         pause->rx_pause = !!(efx->wanted_fc & EFX_FC_RX);
 751         pause->tx_pause = !!(efx->wanted_fc & EFX_FC_TX);
 752         pause->autoneg = !!(efx->wanted_fc & EFX_FC_AUTO);
 753 }
 754
 755 static void efx_ethtool_get_wol(struct net_device *net_dev,
 756                                 struct ethtool_wolinfo *wol)
 757 {
 758         struct efx_nic *efx = netdev_priv(net_dev);
 759         return efx->type->get_wol(efx, wol);
 760 }
 761
 762
 763 static int efx_ethtool_set_wol(struct net_device *net_dev,
 764                                struct ethtool_wolinfo *wol)
 765 {
 766         struct efx_nic *efx = netdev_priv(net_dev);
 767         return efx->type->set_wol(efx, wol->wolopts);
 768 }
 769
 770 static int efx_ethtool_reset(struct net_device *net_dev, u32 *flags)
 771 {
 772         struct efx_nic *efx = netdev_priv(net_dev);
 773         int rc;
 774
 775         rc = efx->type->map_reset_flags(flags);
 776         if (rc < 0)
 777                 return rc;
 778
 779         return efx_reset(efx, rc);
 780 }
 781
 782 /* MAC address mask including only I/G bit */
 783 static const u8 mac_addr_ig_mask[ETH_ALEN] __aligned(2) = {0x01, 0, 0, 0, 0, 0};
 784
 785 #define IP4_ADDR_FULL_MASK      ((__force __be32)~0)
 786 #define PORT_FULL_MASK          ((__force __be16)~0)
 787 #define ETHER_TYPE_FULL_MASK    ((__force __be16)~0)
 788
 789 static int efx_ethtool_get_class_rule(struct efx_nic *efx,
 790                                       struct ethtool_rx_flow_spec *rule)
 791 {
 792         struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
 793         struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
 794         struct ethhdr *mac_entry = &rule->h_u.ether_spec;
 795         struct ethhdr *mac_mask = &rule->m_u.ether_spec;
 796         struct efx_filter_spec spec;
 797         int rc;
 798
 799         rc = efx_filter_get_filter_safe(efx, EFX_FILTER_PRI_MANUAL,
 800                                         rule->location, &spec);
 801         if (rc)
 802                 return rc;
 803
 804         if (spec.dmaq_id == EFX_FILTER_RX_DMAQ_ID_DROP)
 805                 rule->ring_cookie = RX_CLS_FLOW_DISC;
 806         else
 807                 rule->ring_cookie = spec.dmaq_id;
 808
 809         if ((spec.match_flags & EFX_FILTER_MATCH_ETHER_TYPE) &&
 810             spec.ether_type == htons(ETH_P_IP) &&
 811             (spec.match_flags & EFX_FILTER_MATCH_IP_PROTO) &&
 812             (spec.ip_proto == IPPROTO_TCP || spec.ip_proto == IPPROTO_UDP) &&
 813             !(spec.match_flags &
 814               ~(EFX_FILTER_MATCH_ETHER_TYPE | EFX_FILTER_MATCH_OUTER_VID |
 815                 EFX_FILTER_MATCH_LOC_HOST | EFX_FILTER_MATCH_REM_HOST |
 816                 EFX_FILTER_MATCH_IP_PROTO |
 817                 EFX_FILTER_MATCH_LOC_PORT | EFX_FILTER_MATCH_REM_PORT))) {
 818                 rule->flow_type = ((spec.ip_proto == IPPROTO_TCP) ?
 819                                    TCP_V4_FLOW : UDP_V4_FLOW);
 820                 if (spec.match_flags & EFX_FILTER_MATCH_LOC_HOST) {
 821                         ip_entry->ip4dst = spec.loc_host[0];
 822                         ip_mask->ip4dst = IP4_ADDR_FULL_MASK;
 823                 }
 824                 if (spec.match_flags & EFX_FILTER_MATCH_REM_HOST) {
 825                         ip_entry->ip4src = spec.rem_host[0];
 826                         ip_mask->ip4src = IP4_ADDR_FULL_MASK;
 827                 }
 828                 if (spec.match_flags & EFX_FILTER_MATCH_LOC_PORT) {
 829                         ip_entry->pdst = spec.loc_port;
 830                         ip_mask->pdst = PORT_FULL_MASK;
 831                 }
 832                 if (spec.match_flags & EFX_FILTER_MATCH_REM_PORT) {
 833                         ip_entry->psrc = spec.rem_port;
 834                         ip_mask->psrc = PORT_FULL_MASK;
 835                 }
 836         } else if (!(spec.match_flags &
 837                      ~(EFX_FILTER_MATCH_LOC_MAC | EFX_FILTER_MATCH_LOC_MAC_IG |
 838                        EFX_FILTER_MATCH_REM_MAC | EFX_FILTER_MATCH_ETHER_TYPE |
 839                        EFX_FILTER_MATCH_OUTER_VID))) {
 840                 rule->flow_type = ETHER_FLOW;
 841                 if (spec.match_flags &
 842                     (EFX_FILTER_MATCH_LOC_MAC | EFX_FILTER_MATCH_LOC_MAC_IG)) {
 843                         ether_addr_copy(mac_entry->h_dest, spec.loc_mac);
 844                         if (spec.match_flags & EFX_FILTER_MATCH_LOC_MAC)
 845                                 eth_broadcast_addr(mac_mask->h_dest);
 846                         else
 847                                 ether_addr_copy(mac_mask->h_dest,
 848                                                 mac_addr_ig_mask);
 849                 }
 850                 if (spec.match_flags & EFX_FILTER_MATCH_REM_MAC) {
 851                         ether_addr_copy(mac_entry->h_source, spec.rem_mac);
 852                         eth_broadcast_addr(mac_mask->h_source);
 853                 }
 854                 if (spec.match_flags & EFX_FILTER_MATCH_ETHER_TYPE) {
 855                         mac_entry->h_proto = spec.ether_type;
 856                         mac_mask->h_proto = ETHER_TYPE_FULL_MASK;
 857                 }
 858         } else {
 859                 /* The above should handle all filters that we insert */
 860                 WARN_ON(1);
 861                 return -EINVAL;
 862         }
 863
 864         if (spec.match_flags & EFX_FILTER_MATCH_OUTER_VID) {
 865                 rule->flow_type |= FLOW_EXT;
 866                 rule->h_ext.vlan_tci = spec.outer_vid;
 867                 rule->m_ext.vlan_tci = htons(0xfff);
 868         }
 869
 870         return rc;
 871 }
 872
 873 static int
 874 efx_ethtool_get_rxnfc(struct net_device *net_dev,
 875                       struct ethtool_rxnfc *info, u32 *rule_locs)
 876 {
 877         struct efx_nic *efx = netdev_priv(net_dev);
 878
 879         switch (info->cmd) {
 880         case ETHTOOL_GRXRINGS:
 881                 info->data = efx->n_rx_channels;
 882                 return 0;
 883
 884         case ETHTOOL_GRXFH: {
 885                 unsigned min_revision = 0;
 886
 887                 info->data = 0;
 888                 switch (info->flow_type) {
 889                 case TCP_V4_FLOW:
 890                         info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 891                         /* fall through */
 892                 case UDP_V4_FLOW:
 893                 case SCTP_V4_FLOW:
 894                 case AH_ESP_V4_FLOW:
 895                 case IPV4_FLOW:
 896                         info->data |= RXH_IP_SRC | RXH_IP_DST;
 897                         min_revision = EFX_REV_FALCON_B0;
 898                         break;
 899                 case TCP_V6_FLOW:
 900                         info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 901                         /* fall through */
 902                 case UDP_V6_FLOW:
 903                 case SCTP_V6_FLOW:
 904                 case AH_ESP_V6_FLOW:
 905                 case IPV6_FLOW:
 906                         info->data |= RXH_IP_SRC | RXH_IP_DST;
 907                         min_revision = EFX_REV_SIENA_A0;
 908                         break;
 909                 default:
 910                         break;
 911                 }
 912                 if (efx_nic_rev(efx) < min_revision)
 913                         info->data = 0;
 914                 return 0;
 915         }
 916
 917         case ETHTOOL_GRXCLSRLCNT:
 918                 info->data = efx_filter_get_rx_id_limit(efx);
 919                 if (info->data == 0)
 920                         return -EOPNOTSUPP;
 921                 info->data |= RX_CLS_LOC_SPECIAL;
 922                 info->rule_cnt =
 923                         efx_filter_count_rx_used(efx, EFX_FILTER_PRI_MANUAL);
 924                 return 0;
 925
 926         case ETHTOOL_GRXCLSRULE:
 927                 if (efx_filter_get_rx_id_limit(efx) == 0)
 928                         return -EOPNOTSUPP;
 929                 return efx_ethtool_get_class_rule(efx, &info->fs);
 930
 931         case ETHTOOL_GRXCLSRLALL: {
 932                 s32 rc;
 933                 info->data = efx_filter_get_rx_id_limit(efx);
 934                 if (info->data == 0)
 935                         return -EOPNOTSUPP;
 936                 rc = efx_filter_get_rx_ids(efx, EFX_FILTER_PRI_MANUAL,
 937                                            rule_locs, info->rule_cnt);
 938                 if (rc < 0)
 939                         return rc;
 940                 info->rule_cnt = rc;
 941                 return 0;
 942         }
 943
 944         default:
 945                 return -EOPNOTSUPP;
 946         }
 947 }
 948
 949 static int efx_ethtool_set_class_rule(struct efx_nic *efx,
 950                                       struct ethtool_rx_flow_spec *rule)
 951 {
 952         struct ethtool_tcpip4_spec *ip_entry = &rule->h_u.tcp_ip4_spec;
 953         struct ethtool_tcpip4_spec *ip_mask = &rule->m_u.tcp_ip4_spec;
 954         struct ethhdr *mac_entry = &rule->h_u.ether_spec;
 955         struct ethhdr *mac_mask = &rule->m_u.ether_spec;
 956         struct efx_filter_spec spec;
 957         int rc;
 958
 959         /* Check that user wants us to choose the location */
 960         if (rule->location != RX_CLS_LOC_ANY)
 961                 return -EINVAL;
 962
 963         /* Range-check ring_cookie */
 964         if (rule->ring_cookie >= efx->n_rx_channels &&
 965             rule->ring_cookie != RX_CLS_FLOW_DISC)
 966                 return -EINVAL;
 967
 968         /* Check for unsupported extensions */
 969         if ((rule->flow_type & FLOW_EXT) &&
 970             (rule->m_ext.vlan_etype || rule->m_ext.data[0] ||
 971              rule->m_ext.data[1]))
 972                 return -EINVAL;
 973
 974         efx_filter_init_rx(&spec, EFX_FILTER_PRI_MANUAL,
 975                            efx->rx_scatter ? EFX_FILTER_FLAG_RX_SCATTER : 0,
 976                            (rule->ring_cookie == RX_CLS_FLOW_DISC) ?
 977                            EFX_FILTER_RX_DMAQ_ID_DROP : rule->ring_cookie);
 978
 979         switch (rule->flow_type & ~FLOW_EXT) {
 980         case TCP_V4_FLOW:
 981         case UDP_V4_FLOW:
 982                 spec.match_flags = (EFX_FILTER_MATCH_ETHER_TYPE |
 983                                     EFX_FILTER_MATCH_IP_PROTO);
 984                 spec.ether_type = htons(ETH_P_IP);
 985                 spec.ip_proto = ((rule->flow_type & ~FLOW_EXT) == TCP_V4_FLOW ?
 986                                  IPPROTO_TCP : IPPROTO_UDP);
 987                 if (ip_mask->ip4dst) {
 988                         if (ip_mask->ip4dst != IP4_ADDR_FULL_MASK)
 989                                 return -EINVAL;
 990                         spec.match_flags |= EFX_FILTER_MATCH_LOC_HOST;
 991                         spec.loc_host[0] = ip_entry->ip4dst;
 992                 }
 993                 if (ip_mask->ip4src) {
 994                         if (ip_mask->ip4src != IP4_ADDR_FULL_MASK)
 995                                 return -EINVAL;
 996                         spec.match_flags |= EFX_FILTER_MATCH_REM_HOST;
 997                         spec.rem_host[0] = ip_entry->ip4src;
 998                 }
 999                 if (ip_mask->pdst) {
1000                         if (ip_mask->pdst != PORT_FULL_MASK)
1001                                 return -EINVAL;
1002                         spec.match_flags |= EFX_FILTER_MATCH_LOC_PORT;
1003                         spec.loc_port = ip_entry->pdst;
1004                 }
1005                 if (ip_mask->psrc) {
1006                         if (ip_mask->psrc != PORT_FULL_MASK)
1007                                 return -EINVAL;
1008                         spec.match_flags |= EFX_FILTER_MATCH_REM_PORT;
1009                         spec.rem_port = ip_entry->psrc;
1010                 }
1011                 if (ip_mask->tos)
1012                         return -EINVAL;
1013                 break;
1014
1015         case ETHER_FLOW:
1016                 if (!is_zero_ether_addr(mac_mask->h_dest)) {
1017                         if (ether_addr_equal(mac_mask->h_dest,
1018                                              mac_addr_ig_mask))
1019                                 spec.match_flags |= EFX_FILTER_MATCH_LOC_MAC_IG;
1020                         else if (is_broadcast_ether_addr(mac_mask->h_dest))
1021                                 spec.match_flags |= EFX_FILTER_MATCH_LOC_MAC;
1022                         else
1023                                 return -EINVAL;
1024                         ether_addr_copy(spec.loc_mac, mac_entry->h_dest);
1025                 }
1026                 if (!is_zero_ether_addr(mac_mask->h_source)) {
1027                         if (!is_broadcast_ether_addr(mac_mask->h_source))
1028                                 return -EINVAL;
1029                         spec.match_flags |= EFX_FILTER_MATCH_REM_MAC;
1030                         ether_addr_copy(spec.rem_mac, mac_entry->h_source);
1031                 }
1032                 if (mac_mask->h_proto) {
1033                         if (mac_mask->h_proto != ETHER_TYPE_FULL_MASK)
1034                                 return -EINVAL;
1035                         spec.match_flags |= EFX_FILTER_MATCH_ETHER_TYPE;
1036                         spec.ether_type = mac_entry->h_proto;
1037                 }
1038                 break;
1039
1040         default:
1041                 return -EINVAL;
1042         }
1043
1044         if ((rule->flow_type & FLOW_EXT) && rule->m_ext.vlan_tci) {
1045                 if (rule->m_ext.vlan_tci != htons(0xfff))
1046                         return -EINVAL;
1047                 spec.match_flags |= EFX_FILTER_MATCH_OUTER_VID;
1048                 spec.outer_vid = rule->h_ext.vlan_tci;
1049         }
1050
1051         rc = efx_filter_insert_filter(efx, &spec, true);
1052         if (rc < 0)
1053                 return rc;
1054
1055         rule->location = rc;
1056         return 0;
1057 }
1058
1059 static int efx_ethtool_set_rxnfc(struct net_device *net_dev,
1060                                  struct ethtool_rxnfc *info)
1061 {
1062         struct efx_nic *efx = netdev_priv(net_dev);
1063
1064         if (efx_filter_get_rx_id_limit(efx) == 0)
1065                 return -EOPNOTSUPP;
1066
1067         switch (info->cmd) {
1068         case ETHTOOL_SRXCLSRLINS:
1069                 return efx_ethtool_set_class_rule(efx, &info->fs);
1070
1071         case ETHTOOL_SRXCLSRLDEL:
1072                 return efx_filter_remove_id_safe(efx, EFX_FILTER_PRI_MANUAL,
1073                                                  info->fs.location);
1074
1075         default:
1076                 return -EOPNOTSUPP;
1077         }
1078 }
1079
1080 static u32 efx_ethtool_get_rxfh_indir_size(struct net_device *net_dev)
1081 {
1082         struct efx_nic *efx = netdev_priv(net_dev);
1083
1084         return ((efx_nic_rev(efx) < EFX_REV_FALCON_B0 ||
1085                  efx->n_rx_channels == 1) ?
1086                 0 : ARRAY_SIZE(efx->rx_indir_table));
1087 }
1088
1089 static int efx_ethtool_get_rxfh(struct net_device *net_dev, u32 *indir, u8 *key,
1090                                 u8 *hfunc)
1091 {
1092         struct efx_nic *efx = netdev_priv(net_dev);
1093
1094         if (hfunc)
1095                 *hfunc = ETH_RSS_HASH_TOP;
1096         if (indir)
1097                 memcpy(indir, efx->rx_indir_table, sizeof(efx->rx_indir_table));
1098         return 0;
1099 }
1100
1101 static int efx_ethtool_set_rxfh(struct net_device *net_dev, const u32 *indir,
1102                                 const u8 *key, const u8 hfunc)
1103 {
1104         struct efx_nic *efx = netdev_priv(net_dev);
1105
1106         /* We do not allow change in unsupported parameters */
1107         if (key ||
1108             (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1109                 return -EOPNOTSUPP;
1110         if (!indir)
1111                 return 0;
1112         memcpy(efx->rx_indir_table, indir, sizeof(efx->rx_indir_table));
1113         efx->type->rx_push_rss_config(efx);
1114         return 0;
1115 }
1116
1117 static int efx_ethtool_get_ts_info(struct net_device *net_dev,
1118                                    struct ethtool_ts_info *ts_info)
1119 {
1120         struct efx_nic *efx = netdev_priv(net_dev);
1121
1122         /* Software capabilities */
1123         ts_info->so_timestamping = (SOF_TIMESTAMPING_RX_SOFTWARE |
1124                                     SOF_TIMESTAMPING_SOFTWARE);
1125         ts_info->phc_index = -1;
1126
1127         efx_ptp_get_ts_info(efx, ts_info);
1128         return 0;
1129 }
1130
1131 static int efx_ethtool_get_module_eeprom(struct net_device *net_dev,
1132                                          struct ethtool_eeprom *ee,
1133                                          u8 *data)
1134 {
1135         struct efx_nic *efx = netdev_priv(net_dev);
1136         int ret;
1137
1138         if (!efx->phy_op || !efx->phy_op->get_module_eeprom)
1139                 return -EOPNOTSUPP;
1140
1141         mutex_lock(&efx->mac_lock);
1142         ret = efx->phy_op->get_module_eeprom(efx, ee, data);
1143         mutex_unlock(&efx->mac_lock);
1144
1145         return ret;
1146 }
1147
1148 static int efx_ethtool_get_module_info(struct net_device *net_dev,
1149                                        struct ethtool_modinfo *modinfo)
1150 {
1151         struct efx_nic *efx = netdev_priv(net_dev);
1152         int ret;
1153
1154         if (!efx->phy_op || !efx->phy_op->get_module_info)
1155                 return -EOPNOTSUPP;
1156
1157         mutex_lock(&efx->mac_lock);
1158         ret = efx->phy_op->get_module_info(efx, modinfo);
1159         mutex_unlock(&efx->mac_lock);
1160
1161         return ret;
1162 }
1163
1164 const struct ethtool_ops efx_ethtool_ops = {
1165         .get_settings           = efx_ethtool_get_settings,
1166         .set_settings           = efx_ethtool_set_settings,
1167         .get_drvinfo            = efx_ethtool_get_drvinfo,
1168         .get_regs_len           = efx_ethtool_get_regs_len,
1169         .get_regs               = efx_ethtool_get_regs,
1170         .get_msglevel           = efx_ethtool_get_msglevel,
1171         .set_msglevel           = efx_ethtool_set_msglevel,
1172         .nway_reset             = efx_ethtool_nway_reset,
1173         .get_link               = ethtool_op_get_link,
1174         .get_coalesce           = efx_ethtool_get_coalesce,
1175         .set_coalesce           = efx_ethtool_set_coalesce,
1176         .get_ringparam          = efx_ethtool_get_ringparam,
1177         .set_ringparam          = efx_ethtool_set_ringparam,
1178         .get_pauseparam         = efx_ethtool_get_pauseparam,
1179         .set_pauseparam         = efx_ethtool_set_pauseparam,
1180         .get_sset_count         = efx_ethtool_get_sset_count,
1181         .self_test              = efx_ethtool_self_test,
1182         .get_strings            = efx_ethtool_get_strings,
1183         .set_phys_id            = efx_ethtool_phys_id,
1184         .get_ethtool_stats      = efx_ethtool_get_stats,
1185         .get_wol                = efx_ethtool_get_wol,
1186         .set_wol                = efx_ethtool_set_wol,
1187         .reset                  = efx_ethtool_reset,
1188         .get_rxnfc              = efx_ethtool_get_rxnfc,
1189         .set_rxnfc              = efx_ethtool_set_rxnfc,
1190         .get_rxfh_indir_size    = efx_ethtool_get_rxfh_indir_size,
1191         .get_rxfh               = efx_ethtool_get_rxfh,
1192         .set_rxfh               = efx_ethtool_set_rxfh,
1193         .get_ts_info            = efx_ethtool_get_ts_info,
1194         .get_module_info        = efx_ethtool_get_module_info,
1195         .get_module_eeprom      = efx_ethtool_get_module_eeprom,
1196 };