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 22struct 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 45static u64 efx_get_uint_stat(void *field) 46{ 47 return *(unsigned int *)field; 48} 49 50static 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 67static 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 */ 96static 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. */ 121static 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. */ 143static 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 163static 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 176static 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 181static 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 190static 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 196static 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 */ 215static 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 */ 257static 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 */ 302static 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 362static 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 393static 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 411static 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 438static 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 504static 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 544out: 545 efx_ethtool_fill_self_tests(efx, efx_tests, NULL, data); 546 kfree(efx_tests); 547fail: 548 if (rc) 549 test->flags |= ETH_TEST_FL_FAILED; 550} 551 552/* Restart autonegotiation */ 553static 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 589static 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 607static 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 649static 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 660static 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 687static 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 739out: 740 mutex_unlock(&efx->mac_lock); 741 742 return rc; 743} 744 745static 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 755static 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 763static 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 770static 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 */ 783static 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 789static 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 873static int 874efx_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 949static 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 1059static 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 1080static 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 1089static int efx_ethtool_get_rxfh(struct net_device *net_dev, u32 *indir, u8 *key) 1090{ 1091 struct efx_nic *efx = netdev_priv(net_dev); 1092 1093 memcpy(indir, efx->rx_indir_table, sizeof(efx->rx_indir_table)); 1094 return 0; 1095} 1096 1097static int efx_ethtool_set_rxfh(struct net_device *net_dev, 1098 const u32 *indir, const u8 *key) 1099{ 1100 struct efx_nic *efx = netdev_priv(net_dev); 1101 1102 memcpy(efx->rx_indir_table, indir, sizeof(efx->rx_indir_table)); 1103 efx->type->rx_push_rss_config(efx); 1104 return 0; 1105} 1106 1107static int efx_ethtool_get_ts_info(struct net_device *net_dev, 1108 struct ethtool_ts_info *ts_info) 1109{ 1110 struct efx_nic *efx = netdev_priv(net_dev); 1111 1112 /* Software capabilities */ 1113 ts_info->so_timestamping = (SOF_TIMESTAMPING_RX_SOFTWARE | 1114 SOF_TIMESTAMPING_SOFTWARE); 1115 ts_info->phc_index = -1; 1116 1117 efx_ptp_get_ts_info(efx, ts_info); 1118 return 0; 1119} 1120 1121static int efx_ethtool_get_module_eeprom(struct net_device *net_dev, 1122 struct ethtool_eeprom *ee, 1123 u8 *data) 1124{ 1125 struct efx_nic *efx = netdev_priv(net_dev); 1126 int ret; 1127 1128 if (!efx->phy_op || !efx->phy_op->get_module_eeprom) 1129 return -EOPNOTSUPP; 1130 1131 mutex_lock(&efx->mac_lock); 1132 ret = efx->phy_op->get_module_eeprom(efx, ee, data); 1133 mutex_unlock(&efx->mac_lock); 1134 1135 return ret; 1136} 1137 1138static int efx_ethtool_get_module_info(struct net_device *net_dev, 1139 struct ethtool_modinfo *modinfo) 1140{ 1141 struct efx_nic *efx = netdev_priv(net_dev); 1142 int ret; 1143 1144 if (!efx->phy_op || !efx->phy_op->get_module_info) 1145 return -EOPNOTSUPP; 1146 1147 mutex_lock(&efx->mac_lock); 1148 ret = efx->phy_op->get_module_info(efx, modinfo); 1149 mutex_unlock(&efx->mac_lock); 1150 1151 return ret; 1152} 1153 1154const struct ethtool_ops efx_ethtool_ops = { 1155 .get_settings = efx_ethtool_get_settings, 1156 .set_settings = efx_ethtool_set_settings, 1157 .get_drvinfo = efx_ethtool_get_drvinfo, 1158 .get_regs_len = efx_ethtool_get_regs_len, 1159 .get_regs = efx_ethtool_get_regs, 1160 .get_msglevel = efx_ethtool_get_msglevel, 1161 .set_msglevel = efx_ethtool_set_msglevel, 1162 .nway_reset = efx_ethtool_nway_reset, 1163 .get_link = ethtool_op_get_link, 1164 .get_coalesce = efx_ethtool_get_coalesce, 1165 .set_coalesce = efx_ethtool_set_coalesce, 1166 .get_ringparam = efx_ethtool_get_ringparam, 1167 .set_ringparam = efx_ethtool_set_ringparam, 1168 .get_pauseparam = efx_ethtool_get_pauseparam, 1169 .set_pauseparam = efx_ethtool_set_pauseparam, 1170 .get_sset_count = efx_ethtool_get_sset_count, 1171 .self_test = efx_ethtool_self_test, 1172 .get_strings = efx_ethtool_get_strings, 1173 .set_phys_id = efx_ethtool_phys_id, 1174 .get_ethtool_stats = efx_ethtool_get_stats, 1175 .get_wol = efx_ethtool_get_wol, 1176 .set_wol = efx_ethtool_set_wol, 1177 .reset = efx_ethtool_reset, 1178 .get_rxnfc = efx_ethtool_get_rxnfc, 1179 .set_rxnfc = efx_ethtool_set_rxnfc, 1180 .get_rxfh_indir_size = efx_ethtool_get_rxfh_indir_size, 1181 .get_rxfh = efx_ethtool_get_rxfh, 1182 .set_rxfh = efx_ethtool_set_rxfh, 1183 .get_ts_info = efx_ethtool_get_ts_info, 1184 .get_module_info = efx_ethtool_get_module_info, 1185 .get_module_eeprom = efx_ethtool_get_module_eeprom, 1186}; 1187