1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2013-2015 Chelsio Communications. All rights reserved. 4 */ 5 6#include <linux/firmware.h> 7#include <linux/mdio.h> 8 9#include "cxgb4.h" 10#include "t4_regs.h" 11#include "t4fw_api.h" 12#include "cxgb4_cudbg.h" 13#include "cxgb4_filter.h" 14#include "cxgb4_tc_flower.h" 15 16#define EEPROM_MAGIC 0x38E2F10C 17 18static u32 get_msglevel(struct net_device *dev) 19{ 20 return netdev2adap(dev)->msg_enable; 21} 22 23static void set_msglevel(struct net_device *dev, u32 val) 24{ 25 netdev2adap(dev)->msg_enable = val; 26} 27 28enum cxgb4_ethtool_tests { 29 CXGB4_ETHTOOL_LB_TEST, 30 CXGB4_ETHTOOL_MAX_TEST, 31}; 32 33static const char cxgb4_selftest_strings[CXGB4_ETHTOOL_MAX_TEST][ETH_GSTRING_LEN] = { 34 "Loop back test (offline)", 35}; 36 37static const char * const flash_region_strings[] = { 38 "All", 39 "Firmware", 40 "PHY Firmware", 41 "Boot", 42 "Boot CFG", 43}; 44 45static const char stats_strings[][ETH_GSTRING_LEN] = { 46 "tx_octets_ok ", 47 "tx_frames_ok ", 48 "tx_broadcast_frames ", 49 "tx_multicast_frames ", 50 "tx_unicast_frames ", 51 "tx_error_frames ", 52 53 "tx_frames_64 ", 54 "tx_frames_65_to_127 ", 55 "tx_frames_128_to_255 ", 56 "tx_frames_256_to_511 ", 57 "tx_frames_512_to_1023 ", 58 "tx_frames_1024_to_1518 ", 59 "tx_frames_1519_to_max ", 60 61 "tx_frames_dropped ", 62 "tx_pause_frames ", 63 "tx_ppp0_frames ", 64 "tx_ppp1_frames ", 65 "tx_ppp2_frames ", 66 "tx_ppp3_frames ", 67 "tx_ppp4_frames ", 68 "tx_ppp5_frames ", 69 "tx_ppp6_frames ", 70 "tx_ppp7_frames ", 71 72 "rx_octets_ok ", 73 "rx_frames_ok ", 74 "rx_broadcast_frames ", 75 "rx_multicast_frames ", 76 "rx_unicast_frames ", 77 78 "rx_frames_too_long ", 79 "rx_jabber_errors ", 80 "rx_fcs_errors ", 81 "rx_length_errors ", 82 "rx_symbol_errors ", 83 "rx_runt_frames ", 84 85 "rx_frames_64 ", 86 "rx_frames_65_to_127 ", 87 "rx_frames_128_to_255 ", 88 "rx_frames_256_to_511 ", 89 "rx_frames_512_to_1023 ", 90 "rx_frames_1024_to_1518 ", 91 "rx_frames_1519_to_max ", 92 93 "rx_pause_frames ", 94 "rx_ppp0_frames ", 95 "rx_ppp1_frames ", 96 "rx_ppp2_frames ", 97 "rx_ppp3_frames ", 98 "rx_ppp4_frames ", 99 "rx_ppp5_frames ", 100 "rx_ppp6_frames ", 101 "rx_ppp7_frames ", 102 103 "rx_bg0_frames_dropped ", 104 "rx_bg1_frames_dropped ", 105 "rx_bg2_frames_dropped ", 106 "rx_bg3_frames_dropped ", 107 "rx_bg0_frames_trunc ", 108 "rx_bg1_frames_trunc ", 109 "rx_bg2_frames_trunc ", 110 "rx_bg3_frames_trunc ", 111 112 "tso ", 113 "uso ", 114 "tx_csum_offload ", 115 "rx_csum_good ", 116 "vlan_extractions ", 117 "vlan_insertions ", 118 "gro_packets ", 119 "gro_merged ", 120#if IS_ENABLED(CONFIG_CHELSIO_TLS_DEVICE) 121 "tx_tls_encrypted_packets", 122 "tx_tls_encrypted_bytes ", 123 "tx_tls_ctx ", 124 "tx_tls_ooo ", 125 "tx_tls_skip_no_sync_data", 126 "tx_tls_drop_no_sync_data", 127 "tx_tls_drop_bypass_req ", 128#endif 129}; 130 131static char adapter_stats_strings[][ETH_GSTRING_LEN] = { 132 "db_drop ", 133 "db_full ", 134 "db_empty ", 135 "write_coal_success ", 136 "write_coal_fail ", 137}; 138 139static char loopback_stats_strings[][ETH_GSTRING_LEN] = { 140 "-------Loopback----------- ", 141 "octets_ok ", 142 "frames_ok ", 143 "bcast_frames ", 144 "mcast_frames ", 145 "ucast_frames ", 146 "error_frames ", 147 "frames_64 ", 148 "frames_65_to_127 ", 149 "frames_128_to_255 ", 150 "frames_256_to_511 ", 151 "frames_512_to_1023 ", 152 "frames_1024_to_1518 ", 153 "frames_1519_to_max ", 154 "frames_dropped ", 155 "bg0_frames_dropped ", 156 "bg1_frames_dropped ", 157 "bg2_frames_dropped ", 158 "bg3_frames_dropped ", 159 "bg0_frames_trunc ", 160 "bg1_frames_trunc ", 161 "bg2_frames_trunc ", 162 "bg3_frames_trunc ", 163}; 164 165static const char cxgb4_priv_flags_strings[][ETH_GSTRING_LEN] = { 166 [PRIV_FLAG_PORT_TX_VM_BIT] = "port_tx_vm_wr", 167}; 168 169static int get_sset_count(struct net_device *dev, int sset) 170{ 171 switch (sset) { 172 case ETH_SS_STATS: 173 return ARRAY_SIZE(stats_strings) + 174 ARRAY_SIZE(adapter_stats_strings) + 175 ARRAY_SIZE(loopback_stats_strings); 176 case ETH_SS_PRIV_FLAGS: 177 return ARRAY_SIZE(cxgb4_priv_flags_strings); 178 case ETH_SS_TEST: 179 return ARRAY_SIZE(cxgb4_selftest_strings); 180 default: 181 return -EOPNOTSUPP; 182 } 183} 184 185static int get_regs_len(struct net_device *dev) 186{ 187 struct adapter *adap = netdev2adap(dev); 188 189 return t4_get_regs_len(adap); 190} 191 192static int get_eeprom_len(struct net_device *dev) 193{ 194 return EEPROMSIZE; 195} 196 197static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 198{ 199 struct adapter *adapter = netdev2adap(dev); 200 u32 exprom_vers; 201 202 strscpy(info->driver, cxgb4_driver_name, sizeof(info->driver)); 203 strscpy(info->bus_info, pci_name(adapter->pdev), 204 sizeof(info->bus_info)); 205 info->regdump_len = get_regs_len(dev); 206 207 if (adapter->params.fw_vers) 208 snprintf(info->fw_version, sizeof(info->fw_version), 209 "%u.%u.%u.%u, TP %u.%u.%u.%u", 210 FW_HDR_FW_VER_MAJOR_G(adapter->params.fw_vers), 211 FW_HDR_FW_VER_MINOR_G(adapter->params.fw_vers), 212 FW_HDR_FW_VER_MICRO_G(adapter->params.fw_vers), 213 FW_HDR_FW_VER_BUILD_G(adapter->params.fw_vers), 214 FW_HDR_FW_VER_MAJOR_G(adapter->params.tp_vers), 215 FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers), 216 FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers), 217 FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers)); 218 219 if (!t4_get_exprom_version(adapter, &exprom_vers)) 220 snprintf(info->erom_version, sizeof(info->erom_version), 221 "%u.%u.%u.%u", 222 FW_HDR_FW_VER_MAJOR_G(exprom_vers), 223 FW_HDR_FW_VER_MINOR_G(exprom_vers), 224 FW_HDR_FW_VER_MICRO_G(exprom_vers), 225 FW_HDR_FW_VER_BUILD_G(exprom_vers)); 226 info->n_priv_flags = ARRAY_SIZE(cxgb4_priv_flags_strings); 227} 228 229static void get_strings(struct net_device *dev, u32 stringset, u8 *data) 230{ 231 if (stringset == ETH_SS_STATS) { 232 memcpy(data, stats_strings, sizeof(stats_strings)); 233 data += sizeof(stats_strings); 234 memcpy(data, adapter_stats_strings, 235 sizeof(adapter_stats_strings)); 236 data += sizeof(adapter_stats_strings); 237 memcpy(data, loopback_stats_strings, 238 sizeof(loopback_stats_strings)); 239 } else if (stringset == ETH_SS_PRIV_FLAGS) { 240 memcpy(data, cxgb4_priv_flags_strings, 241 sizeof(cxgb4_priv_flags_strings)); 242 } else if (stringset == ETH_SS_TEST) { 243 memcpy(data, cxgb4_selftest_strings, 244 sizeof(cxgb4_selftest_strings)); 245 } 246} 247 248/* port stats maintained per queue of the port. They should be in the same 249 * order as in stats_strings above. 250 */ 251struct queue_port_stats { 252 u64 tso; 253 u64 uso; 254 u64 tx_csum; 255 u64 rx_csum; 256 u64 vlan_ex; 257 u64 vlan_ins; 258 u64 gro_pkts; 259 u64 gro_merged; 260#if IS_ENABLED(CONFIG_CHELSIO_TLS_DEVICE) 261 u64 tx_tls_encrypted_packets; 262 u64 tx_tls_encrypted_bytes; 263 u64 tx_tls_ctx; 264 u64 tx_tls_ooo; 265 u64 tx_tls_skip_no_sync_data; 266 u64 tx_tls_drop_no_sync_data; 267 u64 tx_tls_drop_bypass_req; 268#endif 269}; 270 271struct adapter_stats { 272 u64 db_drop; 273 u64 db_full; 274 u64 db_empty; 275 u64 wc_success; 276 u64 wc_fail; 277}; 278 279static void collect_sge_port_stats(const struct adapter *adap, 280 const struct port_info *p, 281 struct queue_port_stats *s) 282{ 283 const struct sge_eth_txq *tx = &adap->sge.ethtxq[p->first_qset]; 284 const struct sge_eth_rxq *rx = &adap->sge.ethrxq[p->first_qset]; 285#if IS_ENABLED(CONFIG_CHELSIO_TLS_DEVICE) 286 const struct ch_ktls_port_stats_debug *ktls_stats; 287#endif 288 struct sge_eohw_txq *eohw_tx; 289 unsigned int i; 290 291 memset(s, 0, sizeof(*s)); 292 for (i = 0; i < p->nqsets; i++, rx++, tx++) { 293 s->tso += tx->tso; 294 s->uso += tx->uso; 295 s->tx_csum += tx->tx_cso; 296 s->rx_csum += rx->stats.rx_cso; 297 s->vlan_ex += rx->stats.vlan_ex; 298 s->vlan_ins += tx->vlan_ins; 299 s->gro_pkts += rx->stats.lro_pkts; 300 s->gro_merged += rx->stats.lro_merged; 301 } 302 303 if (adap->sge.eohw_txq) { 304 eohw_tx = &adap->sge.eohw_txq[p->first_qset]; 305 for (i = 0; i < p->nqsets; i++, eohw_tx++) { 306 s->tso += eohw_tx->tso; 307 s->uso += eohw_tx->uso; 308 s->tx_csum += eohw_tx->tx_cso; 309 s->vlan_ins += eohw_tx->vlan_ins; 310 } 311 } 312#if IS_ENABLED(CONFIG_CHELSIO_TLS_DEVICE) 313 ktls_stats = &adap->ch_ktls_stats.ktls_port[p->port_id]; 314 s->tx_tls_encrypted_packets = 315 atomic64_read(&ktls_stats->ktls_tx_encrypted_packets); 316 s->tx_tls_encrypted_bytes = 317 atomic64_read(&ktls_stats->ktls_tx_encrypted_bytes); 318 s->tx_tls_ctx = atomic64_read(&ktls_stats->ktls_tx_ctx); 319 s->tx_tls_ooo = atomic64_read(&ktls_stats->ktls_tx_ooo); 320 s->tx_tls_skip_no_sync_data = 321 atomic64_read(&ktls_stats->ktls_tx_skip_no_sync_data); 322 s->tx_tls_drop_no_sync_data = 323 atomic64_read(&ktls_stats->ktls_tx_drop_no_sync_data); 324 s->tx_tls_drop_bypass_req = 325 atomic64_read(&ktls_stats->ktls_tx_drop_bypass_req); 326#endif 327} 328 329static void collect_adapter_stats(struct adapter *adap, struct adapter_stats *s) 330{ 331 u64 val1, val2; 332 333 memset(s, 0, sizeof(*s)); 334 335 s->db_drop = adap->db_stats.db_drop; 336 s->db_full = adap->db_stats.db_full; 337 s->db_empty = adap->db_stats.db_empty; 338 339 if (!is_t4(adap->params.chip)) { 340 int v; 341 342 v = t4_read_reg(adap, SGE_STAT_CFG_A); 343 if (STATSOURCE_T5_G(v) == 7) { 344 val2 = t4_read_reg(adap, SGE_STAT_MATCH_A); 345 val1 = t4_read_reg(adap, SGE_STAT_TOTAL_A); 346 s->wc_success = val1 - val2; 347 s->wc_fail = val2; 348 } 349 } 350} 351 352static void get_stats(struct net_device *dev, struct ethtool_stats *stats, 353 u64 *data) 354{ 355 struct port_info *pi = netdev_priv(dev); 356 struct adapter *adapter = pi->adapter; 357 struct lb_port_stats s; 358 int i; 359 u64 *p0; 360 361 t4_get_port_stats_offset(adapter, pi->tx_chan, 362 (struct port_stats *)data, 363 &pi->stats_base); 364 365 data += sizeof(struct port_stats) / sizeof(u64); 366 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data); 367 data += sizeof(struct queue_port_stats) / sizeof(u64); 368 collect_adapter_stats(adapter, (struct adapter_stats *)data); 369 data += sizeof(struct adapter_stats) / sizeof(u64); 370 371 *data++ = (u64)pi->port_id; 372 memset(&s, 0, sizeof(s)); 373 t4_get_lb_stats(adapter, pi->port_id, &s); 374 375 p0 = &s.octets; 376 for (i = 0; i < ARRAY_SIZE(loopback_stats_strings) - 1; i++) 377 *data++ = (unsigned long long)*p0++; 378} 379 380static void get_regs(struct net_device *dev, struct ethtool_regs *regs, 381 void *buf) 382{ 383 struct adapter *adap = netdev2adap(dev); 384 size_t buf_size; 385 386 buf_size = t4_get_regs_len(adap); 387 regs->version = mk_adap_vers(adap); 388 t4_get_regs(adap, buf, buf_size); 389} 390 391static int restart_autoneg(struct net_device *dev) 392{ 393 struct port_info *p = netdev_priv(dev); 394 395 if (!netif_running(dev)) 396 return -EAGAIN; 397 if (p->link_cfg.autoneg != AUTONEG_ENABLE) 398 return -EINVAL; 399 t4_restart_aneg(p->adapter, p->adapter->pf, p->tx_chan); 400 return 0; 401} 402 403static int identify_port(struct net_device *dev, 404 enum ethtool_phys_id_state state) 405{ 406 unsigned int val; 407 struct adapter *adap = netdev2adap(dev); 408 409 if (state == ETHTOOL_ID_ACTIVE) 410 val = 0xffff; 411 else if (state == ETHTOOL_ID_INACTIVE) 412 val = 0; 413 else 414 return -EINVAL; 415 416 return t4_identify_port(adap, adap->pf, netdev2pinfo(dev)->viid, val); 417} 418 419/** 420 * from_fw_port_mod_type - translate Firmware Port/Module type to Ethtool 421 * @port_type: Firmware Port Type 422 * @mod_type: Firmware Module Type 423 * 424 * Translate Firmware Port/Module type to Ethtool Port Type. 425 */ 426static int from_fw_port_mod_type(enum fw_port_type port_type, 427 enum fw_port_module_type mod_type) 428{ 429 if (port_type == FW_PORT_TYPE_BT_SGMII || 430 port_type == FW_PORT_TYPE_BT_XFI || 431 port_type == FW_PORT_TYPE_BT_XAUI) { 432 return PORT_TP; 433 } else if (port_type == FW_PORT_TYPE_FIBER_XFI || 434 port_type == FW_PORT_TYPE_FIBER_XAUI) { 435 return PORT_FIBRE; 436 } else if (port_type == FW_PORT_TYPE_SFP || 437 port_type == FW_PORT_TYPE_QSFP_10G || 438 port_type == FW_PORT_TYPE_QSA || 439 port_type == FW_PORT_TYPE_QSFP || 440 port_type == FW_PORT_TYPE_CR4_QSFP || 441 port_type == FW_PORT_TYPE_CR_QSFP || 442 port_type == FW_PORT_TYPE_CR2_QSFP || 443 port_type == FW_PORT_TYPE_SFP28) { 444 if (mod_type == FW_PORT_MOD_TYPE_LR || 445 mod_type == FW_PORT_MOD_TYPE_SR || 446 mod_type == FW_PORT_MOD_TYPE_ER || 447 mod_type == FW_PORT_MOD_TYPE_LRM) 448 return PORT_FIBRE; 449 else if (mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE || 450 mod_type == FW_PORT_MOD_TYPE_TWINAX_ACTIVE) 451 return PORT_DA; 452 else 453 return PORT_OTHER; 454 } else if (port_type == FW_PORT_TYPE_KR4_100G || 455 port_type == FW_PORT_TYPE_KR_SFP28 || 456 port_type == FW_PORT_TYPE_KR_XLAUI) { 457 return PORT_NONE; 458 } 459 460 return PORT_OTHER; 461} 462 463/** 464 * speed_to_fw_caps - translate Port Speed to Firmware Port Capabilities 465 * @speed: speed in Kb/s 466 * 467 * Translates a specific Port Speed into a Firmware Port Capabilities 468 * value. 469 */ 470static unsigned int speed_to_fw_caps(int speed) 471{ 472 if (speed == 100) 473 return FW_PORT_CAP32_SPEED_100M; 474 if (speed == 1000) 475 return FW_PORT_CAP32_SPEED_1G; 476 if (speed == 10000) 477 return FW_PORT_CAP32_SPEED_10G; 478 if (speed == 25000) 479 return FW_PORT_CAP32_SPEED_25G; 480 if (speed == 40000) 481 return FW_PORT_CAP32_SPEED_40G; 482 if (speed == 50000) 483 return FW_PORT_CAP32_SPEED_50G; 484 if (speed == 100000) 485 return FW_PORT_CAP32_SPEED_100G; 486 if (speed == 200000) 487 return FW_PORT_CAP32_SPEED_200G; 488 if (speed == 400000) 489 return FW_PORT_CAP32_SPEED_400G; 490 return 0; 491} 492 493/** 494 * fw_caps_to_lmm - translate Firmware to ethtool Link Mode Mask 495 * @port_type: Firmware Port Type 496 * @fw_caps: Firmware Port Capabilities 497 * @link_mode_mask: ethtool Link Mode Mask 498 * 499 * Translate a Firmware Port Capabilities specification to an ethtool 500 * Link Mode Mask. 501 */ 502static void fw_caps_to_lmm(enum fw_port_type port_type, 503 fw_port_cap32_t fw_caps, 504 unsigned long *link_mode_mask) 505{ 506 #define SET_LMM(__lmm_name) \ 507 do { \ 508 __set_bit(ETHTOOL_LINK_MODE_ ## __lmm_name ## _BIT, \ 509 link_mode_mask); \ 510 } while (0) 511 512 #define FW_CAPS_TO_LMM(__fw_name, __lmm_name) \ 513 do { \ 514 if (fw_caps & FW_PORT_CAP32_ ## __fw_name) \ 515 SET_LMM(__lmm_name); \ 516 } while (0) 517 518 switch (port_type) { 519 case FW_PORT_TYPE_BT_SGMII: 520 case FW_PORT_TYPE_BT_XFI: 521 case FW_PORT_TYPE_BT_XAUI: 522 SET_LMM(TP); 523 FW_CAPS_TO_LMM(SPEED_100M, 100baseT_Full); 524 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 525 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); 526 break; 527 528 case FW_PORT_TYPE_KX4: 529 case FW_PORT_TYPE_KX: 530 SET_LMM(Backplane); 531 FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); 532 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKX4_Full); 533 break; 534 535 case FW_PORT_TYPE_KR: 536 SET_LMM(Backplane); 537 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 538 break; 539 540 case FW_PORT_TYPE_BP_AP: 541 SET_LMM(Backplane); 542 FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); 543 FW_CAPS_TO_LMM(SPEED_10G, 10000baseR_FEC); 544 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 545 break; 546 547 case FW_PORT_TYPE_BP4_AP: 548 SET_LMM(Backplane); 549 FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); 550 FW_CAPS_TO_LMM(SPEED_10G, 10000baseR_FEC); 551 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 552 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKX4_Full); 553 break; 554 555 case FW_PORT_TYPE_FIBER_XFI: 556 case FW_PORT_TYPE_FIBER_XAUI: 557 case FW_PORT_TYPE_SFP: 558 case FW_PORT_TYPE_QSFP_10G: 559 case FW_PORT_TYPE_QSA: 560 SET_LMM(FIBRE); 561 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 562 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); 563 break; 564 565 case FW_PORT_TYPE_BP40_BA: 566 case FW_PORT_TYPE_QSFP: 567 SET_LMM(FIBRE); 568 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 569 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); 570 FW_CAPS_TO_LMM(SPEED_40G, 40000baseSR4_Full); 571 break; 572 573 case FW_PORT_TYPE_CR_QSFP: 574 case FW_PORT_TYPE_SFP28: 575 SET_LMM(FIBRE); 576 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 577 FW_CAPS_TO_LMM(SPEED_10G, 10000baseT_Full); 578 FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full); 579 break; 580 581 case FW_PORT_TYPE_KR_SFP28: 582 SET_LMM(Backplane); 583 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 584 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 585 FW_CAPS_TO_LMM(SPEED_25G, 25000baseKR_Full); 586 break; 587 588 case FW_PORT_TYPE_KR_XLAUI: 589 SET_LMM(Backplane); 590 FW_CAPS_TO_LMM(SPEED_1G, 1000baseKX_Full); 591 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 592 FW_CAPS_TO_LMM(SPEED_40G, 40000baseKR4_Full); 593 break; 594 595 case FW_PORT_TYPE_CR2_QSFP: 596 SET_LMM(FIBRE); 597 FW_CAPS_TO_LMM(SPEED_50G, 50000baseSR2_Full); 598 break; 599 600 case FW_PORT_TYPE_KR4_100G: 601 case FW_PORT_TYPE_CR4_QSFP: 602 SET_LMM(FIBRE); 603 FW_CAPS_TO_LMM(SPEED_1G, 1000baseT_Full); 604 FW_CAPS_TO_LMM(SPEED_10G, 10000baseKR_Full); 605 FW_CAPS_TO_LMM(SPEED_40G, 40000baseSR4_Full); 606 FW_CAPS_TO_LMM(SPEED_25G, 25000baseCR_Full); 607 FW_CAPS_TO_LMM(SPEED_50G, 50000baseCR2_Full); 608 FW_CAPS_TO_LMM(SPEED_100G, 100000baseCR4_Full); 609 break; 610 611 default: 612 break; 613 } 614 615 if (fw_caps & FW_PORT_CAP32_FEC_V(FW_PORT_CAP32_FEC_M)) { 616 FW_CAPS_TO_LMM(FEC_RS, FEC_RS); 617 FW_CAPS_TO_LMM(FEC_BASER_RS, FEC_BASER); 618 } else { 619 SET_LMM(FEC_NONE); 620 } 621 622 FW_CAPS_TO_LMM(ANEG, Autoneg); 623 FW_CAPS_TO_LMM(802_3_PAUSE, Pause); 624 FW_CAPS_TO_LMM(802_3_ASM_DIR, Asym_Pause); 625 626 #undef FW_CAPS_TO_LMM 627 #undef SET_LMM 628} 629 630/** 631 * lmm_to_fw_caps - translate ethtool Link Mode Mask to Firmware 632 * capabilities 633 * @link_mode_mask: ethtool Link Mode Mask 634 * 635 * Translate ethtool Link Mode Mask into a Firmware Port capabilities 636 * value. 637 */ 638static unsigned int lmm_to_fw_caps(const unsigned long *link_mode_mask) 639{ 640 unsigned int fw_caps = 0; 641 642 #define LMM_TO_FW_CAPS(__lmm_name, __fw_name) \ 643 do { \ 644 if (test_bit(ETHTOOL_LINK_MODE_ ## __lmm_name ## _BIT, \ 645 link_mode_mask)) \ 646 fw_caps |= FW_PORT_CAP32_ ## __fw_name; \ 647 } while (0) 648 649 LMM_TO_FW_CAPS(100baseT_Full, SPEED_100M); 650 LMM_TO_FW_CAPS(1000baseT_Full, SPEED_1G); 651 LMM_TO_FW_CAPS(10000baseT_Full, SPEED_10G); 652 LMM_TO_FW_CAPS(40000baseSR4_Full, SPEED_40G); 653 LMM_TO_FW_CAPS(25000baseCR_Full, SPEED_25G); 654 LMM_TO_FW_CAPS(50000baseCR2_Full, SPEED_50G); 655 LMM_TO_FW_CAPS(100000baseCR4_Full, SPEED_100G); 656 657 #undef LMM_TO_FW_CAPS 658 659 return fw_caps; 660} 661 662static int get_link_ksettings(struct net_device *dev, 663 struct ethtool_link_ksettings *link_ksettings) 664{ 665 struct port_info *pi = netdev_priv(dev); 666 struct ethtool_link_settings *base = &link_ksettings->base; 667 668 /* For the nonce, the Firmware doesn't send up Port State changes 669 * when the Virtual Interface attached to the Port is down. So 670 * if it's down, let's grab any changes. 671 */ 672 if (!netif_running(dev)) 673 (void)t4_update_port_info(pi); 674 675 ethtool_link_ksettings_zero_link_mode(link_ksettings, supported); 676 ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising); 677 ethtool_link_ksettings_zero_link_mode(link_ksettings, lp_advertising); 678 679 base->port = from_fw_port_mod_type(pi->port_type, pi->mod_type); 680 681 if (pi->mdio_addr >= 0) { 682 base->phy_address = pi->mdio_addr; 683 base->mdio_support = (pi->port_type == FW_PORT_TYPE_BT_SGMII 684 ? ETH_MDIO_SUPPORTS_C22 685 : ETH_MDIO_SUPPORTS_C45); 686 } else { 687 base->phy_address = 255; 688 base->mdio_support = 0; 689 } 690 691 fw_caps_to_lmm(pi->port_type, pi->link_cfg.pcaps, 692 link_ksettings->link_modes.supported); 693 fw_caps_to_lmm(pi->port_type, 694 t4_link_acaps(pi->adapter, 695 pi->lport, 696 &pi->link_cfg), 697 link_ksettings->link_modes.advertising); 698 fw_caps_to_lmm(pi->port_type, pi->link_cfg.lpacaps, 699 link_ksettings->link_modes.lp_advertising); 700 701 base->speed = (netif_carrier_ok(dev) 702 ? pi->link_cfg.speed 703 : SPEED_UNKNOWN); 704 base->duplex = DUPLEX_FULL; 705 706 base->autoneg = pi->link_cfg.autoneg; 707 if (pi->link_cfg.pcaps & FW_PORT_CAP32_ANEG) 708 ethtool_link_ksettings_add_link_mode(link_ksettings, 709 supported, Autoneg); 710 if (pi->link_cfg.autoneg) 711 ethtool_link_ksettings_add_link_mode(link_ksettings, 712 advertising, Autoneg); 713 714 return 0; 715} 716 717static int set_link_ksettings(struct net_device *dev, 718 const struct ethtool_link_ksettings *link_ksettings) 719{ 720 struct port_info *pi = netdev_priv(dev); 721 struct link_config *lc = &pi->link_cfg; 722 const struct ethtool_link_settings *base = &link_ksettings->base; 723 struct link_config old_lc; 724 unsigned int fw_caps; 725 int ret = 0; 726 727 /* only full-duplex supported */ 728 if (base->duplex != DUPLEX_FULL) 729 return -EINVAL; 730 731 old_lc = *lc; 732 if (!(lc->pcaps & FW_PORT_CAP32_ANEG) || 733 base->autoneg == AUTONEG_DISABLE) { 734 fw_caps = speed_to_fw_caps(base->speed); 735 736 /* Speed must be supported by Physical Port Capabilities. */ 737 if (!(lc->pcaps & fw_caps)) 738 return -EINVAL; 739 740 lc->speed_caps = fw_caps; 741 lc->acaps = fw_caps; 742 } else { 743 fw_caps = 744 lmm_to_fw_caps(link_ksettings->link_modes.advertising); 745 if (!(lc->pcaps & fw_caps)) 746 return -EINVAL; 747 lc->speed_caps = 0; 748 lc->acaps = fw_caps | FW_PORT_CAP32_ANEG; 749 } 750 lc->autoneg = base->autoneg; 751 752 /* If the firmware rejects the Link Configuration request, back out 753 * the changes and report the error. 754 */ 755 ret = t4_link_l1cfg(pi->adapter, pi->adapter->mbox, pi->tx_chan, lc); 756 if (ret) 757 *lc = old_lc; 758 759 return ret; 760} 761 762/* Translate the Firmware FEC value into the ethtool value. */ 763static inline unsigned int fwcap_to_eth_fec(unsigned int fw_fec) 764{ 765 unsigned int eth_fec = 0; 766 767 if (fw_fec & FW_PORT_CAP32_FEC_RS) 768 eth_fec |= ETHTOOL_FEC_RS; 769 if (fw_fec & FW_PORT_CAP32_FEC_BASER_RS) 770 eth_fec |= ETHTOOL_FEC_BASER; 771 772 /* if nothing is set, then FEC is off */ 773 if (!eth_fec) 774 eth_fec = ETHTOOL_FEC_OFF; 775 776 return eth_fec; 777} 778 779/* Translate Common Code FEC value into ethtool value. */ 780static inline unsigned int cc_to_eth_fec(unsigned int cc_fec) 781{ 782 unsigned int eth_fec = 0; 783 784 if (cc_fec & FEC_AUTO) 785 eth_fec |= ETHTOOL_FEC_AUTO; 786 if (cc_fec & FEC_RS) 787 eth_fec |= ETHTOOL_FEC_RS; 788 if (cc_fec & FEC_BASER_RS) 789 eth_fec |= ETHTOOL_FEC_BASER; 790 791 /* if nothing is set, then FEC is off */ 792 if (!eth_fec) 793 eth_fec = ETHTOOL_FEC_OFF; 794 795 return eth_fec; 796} 797 798/* Translate ethtool FEC value into Common Code value. */ 799static inline unsigned int eth_to_cc_fec(unsigned int eth_fec) 800{ 801 unsigned int cc_fec = 0; 802 803 if (eth_fec & ETHTOOL_FEC_OFF) 804 return cc_fec; 805 806 if (eth_fec & ETHTOOL_FEC_AUTO) 807 cc_fec |= FEC_AUTO; 808 if (eth_fec & ETHTOOL_FEC_RS) 809 cc_fec |= FEC_RS; 810 if (eth_fec & ETHTOOL_FEC_BASER) 811 cc_fec |= FEC_BASER_RS; 812 813 return cc_fec; 814} 815 816static int get_fecparam(struct net_device *dev, struct ethtool_fecparam *fec) 817{ 818 const struct port_info *pi = netdev_priv(dev); 819 const struct link_config *lc = &pi->link_cfg; 820 821 /* Translate the Firmware FEC Support into the ethtool value. We 822 * always support IEEE 802.3 "automatic" selection of Link FEC type if 823 * any FEC is supported. 824 */ 825 fec->fec = fwcap_to_eth_fec(lc->pcaps); 826 if (fec->fec != ETHTOOL_FEC_OFF) 827 fec->fec |= ETHTOOL_FEC_AUTO; 828 829 /* Translate the current internal FEC parameters into the 830 * ethtool values. 831 */ 832 fec->active_fec = cc_to_eth_fec(lc->fec); 833 834 return 0; 835} 836 837static int set_fecparam(struct net_device *dev, struct ethtool_fecparam *fec) 838{ 839 struct port_info *pi = netdev_priv(dev); 840 struct link_config *lc = &pi->link_cfg; 841 struct link_config old_lc; 842 int ret; 843 844 /* Save old Link Configuration in case the L1 Configure below 845 * fails. 846 */ 847 old_lc = *lc; 848 849 /* Try to perform the L1 Configure and return the result of that 850 * effort. If it fails, revert the attempted change. 851 */ 852 lc->requested_fec = eth_to_cc_fec(fec->fec); 853 ret = t4_link_l1cfg(pi->adapter, pi->adapter->mbox, 854 pi->tx_chan, lc); 855 if (ret) 856 *lc = old_lc; 857 return ret; 858} 859 860static void get_pauseparam(struct net_device *dev, 861 struct ethtool_pauseparam *epause) 862{ 863 struct port_info *p = netdev_priv(dev); 864 865 epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0; 866 epause->rx_pause = (p->link_cfg.advertised_fc & PAUSE_RX) != 0; 867 epause->tx_pause = (p->link_cfg.advertised_fc & PAUSE_TX) != 0; 868} 869 870static int set_pauseparam(struct net_device *dev, 871 struct ethtool_pauseparam *epause) 872{ 873 struct port_info *p = netdev_priv(dev); 874 struct link_config *lc = &p->link_cfg; 875 876 if (epause->autoneg == AUTONEG_DISABLE) 877 lc->requested_fc = 0; 878 else if (lc->pcaps & FW_PORT_CAP32_ANEG) 879 lc->requested_fc = PAUSE_AUTONEG; 880 else 881 return -EINVAL; 882 883 if (epause->rx_pause) 884 lc->requested_fc |= PAUSE_RX; 885 if (epause->tx_pause) 886 lc->requested_fc |= PAUSE_TX; 887 if (netif_running(dev)) 888 return t4_link_l1cfg(p->adapter, p->adapter->mbox, p->tx_chan, 889 lc); 890 return 0; 891} 892 893static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e, 894 struct kernel_ethtool_ringparam *kernel_e, 895 struct netlink_ext_ack *extack) 896{ 897 const struct port_info *pi = netdev_priv(dev); 898 const struct sge *s = &pi->adapter->sge; 899 900 e->rx_max_pending = MAX_RX_BUFFERS; 901 e->rx_mini_max_pending = MAX_RSPQ_ENTRIES; 902 e->rx_jumbo_max_pending = 0; 903 e->tx_max_pending = MAX_TXQ_ENTRIES; 904 905 e->rx_pending = s->ethrxq[pi->first_qset].fl.size - 8; 906 e->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size; 907 e->rx_jumbo_pending = 0; 908 e->tx_pending = s->ethtxq[pi->first_qset].q.size; 909} 910 911static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e, 912 struct kernel_ethtool_ringparam *kernel_e, 913 struct netlink_ext_ack *extack) 914{ 915 int i; 916 const struct port_info *pi = netdev_priv(dev); 917 struct adapter *adapter = pi->adapter; 918 struct sge *s = &adapter->sge; 919 920 if (e->rx_pending > MAX_RX_BUFFERS || e->rx_jumbo_pending || 921 e->tx_pending > MAX_TXQ_ENTRIES || 922 e->rx_mini_pending > MAX_RSPQ_ENTRIES || 923 e->rx_mini_pending < MIN_RSPQ_ENTRIES || 924 e->rx_pending < MIN_FL_ENTRIES || e->tx_pending < MIN_TXQ_ENTRIES) 925 return -EINVAL; 926 927 if (adapter->flags & CXGB4_FULL_INIT_DONE) 928 return -EBUSY; 929 930 for (i = 0; i < pi->nqsets; ++i) { 931 s->ethtxq[pi->first_qset + i].q.size = e->tx_pending; 932 s->ethrxq[pi->first_qset + i].fl.size = e->rx_pending + 8; 933 s->ethrxq[pi->first_qset + i].rspq.size = e->rx_mini_pending; 934 } 935 return 0; 936} 937 938/** 939 * set_rx_intr_params - set a net devices's RX interrupt holdoff paramete! 940 * @dev: the network device 941 * @us: the hold-off time in us, or 0 to disable timer 942 * @cnt: the hold-off packet count, or 0 to disable counter 943 * 944 * Set the RX interrupt hold-off parameters for a network device. 945 */ 946static int set_rx_intr_params(struct net_device *dev, 947 unsigned int us, unsigned int cnt) 948{ 949 int i, err; 950 struct port_info *pi = netdev_priv(dev); 951 struct adapter *adap = pi->adapter; 952 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 953 954 for (i = 0; i < pi->nqsets; i++, q++) { 955 err = cxgb4_set_rspq_intr_params(&q->rspq, us, cnt); 956 if (err) 957 return err; 958 } 959 return 0; 960} 961 962static int set_adaptive_rx_setting(struct net_device *dev, int adaptive_rx) 963{ 964 int i; 965 struct port_info *pi = netdev_priv(dev); 966 struct adapter *adap = pi->adapter; 967 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 968 969 for (i = 0; i < pi->nqsets; i++, q++) 970 q->rspq.adaptive_rx = adaptive_rx; 971 972 return 0; 973} 974 975static int get_adaptive_rx_setting(struct net_device *dev) 976{ 977 struct port_info *pi = netdev_priv(dev); 978 struct adapter *adap = pi->adapter; 979 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 980 981 return q->rspq.adaptive_rx; 982} 983 984/* Return the current global Adapter SGE Doorbell Queue Timer Tick for all 985 * Ethernet TX Queues. 986 */ 987static int get_dbqtimer_tick(struct net_device *dev) 988{ 989 struct port_info *pi = netdev_priv(dev); 990 struct adapter *adap = pi->adapter; 991 992 if (!(adap->flags & CXGB4_SGE_DBQ_TIMER)) 993 return 0; 994 995 return adap->sge.dbqtimer_tick; 996} 997 998/* Return the SGE Doorbell Queue Timer Value for the Ethernet TX Queues 999 * associated with a Network Device. 1000 */ 1001static int get_dbqtimer(struct net_device *dev) 1002{ 1003 struct port_info *pi = netdev_priv(dev); 1004 struct adapter *adap = pi->adapter; 1005 struct sge_eth_txq *txq; 1006 1007 txq = &adap->sge.ethtxq[pi->first_qset]; 1008 1009 if (!(adap->flags & CXGB4_SGE_DBQ_TIMER)) 1010 return 0; 1011 1012 /* all of the TX Queues use the same Timer Index */ 1013 return adap->sge.dbqtimer_val[txq->dbqtimerix]; 1014} 1015 1016/* Set the global Adapter SGE Doorbell Queue Timer Tick for all Ethernet TX 1017 * Queues. This is the fundamental "Tick" that sets the scale of values which 1018 * can be used. Individual Ethernet TX Queues index into a relatively small 1019 * array of Tick Multipliers. Changing the base Tick will thus change all of 1020 * the resulting Timer Values associated with those multipliers for all 1021 * Ethernet TX Queues. 1022 */ 1023static int set_dbqtimer_tick(struct net_device *dev, int usecs) 1024{ 1025 struct port_info *pi = netdev_priv(dev); 1026 struct adapter *adap = pi->adapter; 1027 struct sge *s = &adap->sge; 1028 u32 param, val; 1029 int ret; 1030 1031 if (!(adap->flags & CXGB4_SGE_DBQ_TIMER)) 1032 return 0; 1033 1034 /* return early if it's the same Timer Tick we're already using */ 1035 if (s->dbqtimer_tick == usecs) 1036 return 0; 1037 1038 /* attempt to set the new Timer Tick value */ 1039 param = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) | 1040 FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_DBQ_TIMERTICK)); 1041 val = usecs; 1042 ret = t4_set_params(adap, adap->mbox, adap->pf, 0, 1, ¶m, &val); 1043 if (ret) 1044 return ret; 1045 s->dbqtimer_tick = usecs; 1046 1047 /* if successful, reread resulting dependent Timer values */ 1048 ret = t4_read_sge_dbqtimers(adap, ARRAY_SIZE(s->dbqtimer_val), 1049 s->dbqtimer_val); 1050 return ret; 1051} 1052 1053/* Set the SGE Doorbell Queue Timer Value for the Ethernet TX Queues 1054 * associated with a Network Device. There is a relatively small array of 1055 * possible Timer Values so we need to pick the closest value available. 1056 */ 1057static int set_dbqtimer(struct net_device *dev, int usecs) 1058{ 1059 int qix, timerix, min_timerix, delta, min_delta; 1060 struct port_info *pi = netdev_priv(dev); 1061 struct adapter *adap = pi->adapter; 1062 struct sge *s = &adap->sge; 1063 struct sge_eth_txq *txq; 1064 u32 param, val; 1065 int ret; 1066 1067 if (!(adap->flags & CXGB4_SGE_DBQ_TIMER)) 1068 return 0; 1069 1070 /* Find the SGE Doorbell Timer Value that's closest to the requested 1071 * value. 1072 */ 1073 min_delta = INT_MAX; 1074 min_timerix = 0; 1075 for (timerix = 0; timerix < ARRAY_SIZE(s->dbqtimer_val); timerix++) { 1076 delta = s->dbqtimer_val[timerix] - usecs; 1077 if (delta < 0) 1078 delta = -delta; 1079 if (delta < min_delta) { 1080 min_delta = delta; 1081 min_timerix = timerix; 1082 } 1083 } 1084 1085 /* Return early if it's the same Timer Index we're already using. 1086 * We use the same Timer Index for all of the TX Queues for an 1087 * interface so it's only necessary to check the first one. 1088 */ 1089 txq = &s->ethtxq[pi->first_qset]; 1090 if (txq->dbqtimerix == min_timerix) 1091 return 0; 1092 1093 for (qix = 0; qix < pi->nqsets; qix++, txq++) { 1094 if (adap->flags & CXGB4_FULL_INIT_DONE) { 1095 param = 1096 (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DMAQ) | 1097 FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DMAQ_EQ_TIMERIX) | 1098 FW_PARAMS_PARAM_YZ_V(txq->q.cntxt_id)); 1099 val = min_timerix; 1100 ret = t4_set_params(adap, adap->mbox, adap->pf, 0, 1101 1, ¶m, &val); 1102 if (ret) 1103 return ret; 1104 } 1105 txq->dbqtimerix = min_timerix; 1106 } 1107 return 0; 1108} 1109 1110/* Set the global Adapter SGE Doorbell Queue Timer Tick for all Ethernet TX 1111 * Queues and the Timer Value for the Ethernet TX Queues associated with a 1112 * Network Device. Since changing the global Tick changes all of the 1113 * available Timer Values, we need to do this first before selecting the 1114 * resulting closest Timer Value. Moreover, since the Tick is global, 1115 * changing it affects the Timer Values for all Network Devices on the 1116 * adapter. So, before changing the Tick, we grab all of the current Timer 1117 * Values for other Network Devices on this Adapter and then attempt to select 1118 * new Timer Values which are close to the old values ... 1119 */ 1120static int set_dbqtimer_tickval(struct net_device *dev, 1121 int tick_usecs, int timer_usecs) 1122{ 1123 struct port_info *pi = netdev_priv(dev); 1124 struct adapter *adap = pi->adapter; 1125 int timer[MAX_NPORTS]; 1126 unsigned int port; 1127 int ret; 1128 1129 /* Grab the other adapter Network Interface current timers and fill in 1130 * the new one for this Network Interface. 1131 */ 1132 for_each_port(adap, port) 1133 if (port == pi->port_id) 1134 timer[port] = timer_usecs; 1135 else 1136 timer[port] = get_dbqtimer(adap->port[port]); 1137 1138 /* Change the global Tick first ... */ 1139 ret = set_dbqtimer_tick(dev, tick_usecs); 1140 if (ret) 1141 return ret; 1142 1143 /* ... and then set all of the Network Interface Timer Values ... */ 1144 for_each_port(adap, port) { 1145 ret = set_dbqtimer(adap->port[port], timer[port]); 1146 if (ret) 1147 return ret; 1148 } 1149 1150 return 0; 1151} 1152 1153static int set_coalesce(struct net_device *dev, 1154 struct ethtool_coalesce *coalesce, 1155 struct kernel_ethtool_coalesce *kernel_coal, 1156 struct netlink_ext_ack *extack) 1157{ 1158 int ret; 1159 1160 set_adaptive_rx_setting(dev, coalesce->use_adaptive_rx_coalesce); 1161 1162 ret = set_rx_intr_params(dev, coalesce->rx_coalesce_usecs, 1163 coalesce->rx_max_coalesced_frames); 1164 if (ret) 1165 return ret; 1166 1167 return set_dbqtimer_tickval(dev, 1168 coalesce->tx_coalesce_usecs_irq, 1169 coalesce->tx_coalesce_usecs); 1170} 1171 1172static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c, 1173 struct kernel_ethtool_coalesce *kernel_coal, 1174 struct netlink_ext_ack *extack) 1175{ 1176 const struct port_info *pi = netdev_priv(dev); 1177 const struct adapter *adap = pi->adapter; 1178 const struct sge_rspq *rq = &adap->sge.ethrxq[pi->first_qset].rspq; 1179 1180 c->rx_coalesce_usecs = qtimer_val(adap, rq); 1181 c->rx_max_coalesced_frames = (rq->intr_params & QINTR_CNT_EN_F) ? 1182 adap->sge.counter_val[rq->pktcnt_idx] : 0; 1183 c->use_adaptive_rx_coalesce = get_adaptive_rx_setting(dev); 1184 c->tx_coalesce_usecs_irq = get_dbqtimer_tick(dev); 1185 c->tx_coalesce_usecs = get_dbqtimer(dev); 1186 return 0; 1187} 1188 1189/* The next two routines implement eeprom read/write from physical addresses. 1190 */ 1191static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v) 1192{ 1193 int vaddr = t4_eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE); 1194 1195 if (vaddr >= 0) 1196 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v); 1197 return vaddr < 0 ? vaddr : 0; 1198} 1199 1200static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v) 1201{ 1202 int vaddr = t4_eeprom_ptov(phys_addr, adap->pf, EEPROMPFSIZE); 1203 1204 if (vaddr >= 0) 1205 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v); 1206 return vaddr < 0 ? vaddr : 0; 1207} 1208 1209#define EEPROM_MAGIC 0x38E2F10C 1210 1211static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e, 1212 u8 *data) 1213{ 1214 int i, err = 0; 1215 struct adapter *adapter = netdev2adap(dev); 1216 u8 *buf = kvzalloc(EEPROMSIZE, GFP_KERNEL); 1217 1218 if (!buf) 1219 return -ENOMEM; 1220 1221 e->magic = EEPROM_MAGIC; 1222 for (i = e->offset & ~3; !err && i < e->offset + e->len; i += 4) 1223 err = eeprom_rd_phys(adapter, i, (u32 *)&buf[i]); 1224 1225 if (!err) 1226 memcpy(data, buf + e->offset, e->len); 1227 kvfree(buf); 1228 return err; 1229} 1230 1231static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 1232 u8 *data) 1233{ 1234 u8 *buf; 1235 int err = 0; 1236 u32 aligned_offset, aligned_len, *p; 1237 struct adapter *adapter = netdev2adap(dev); 1238 1239 if (eeprom->magic != EEPROM_MAGIC) 1240 return -EINVAL; 1241 1242 aligned_offset = eeprom->offset & ~3; 1243 aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3; 1244 1245 if (adapter->pf > 0) { 1246 u32 start = 1024 + adapter->pf * EEPROMPFSIZE; 1247 1248 if (aligned_offset < start || 1249 aligned_offset + aligned_len > start + EEPROMPFSIZE) 1250 return -EPERM; 1251 } 1252 1253 if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) { 1254 /* RMW possibly needed for first or last words. 1255 */ 1256 buf = kvzalloc(aligned_len, GFP_KERNEL); 1257 if (!buf) 1258 return -ENOMEM; 1259 err = eeprom_rd_phys(adapter, aligned_offset, (u32 *)buf); 1260 if (!err && aligned_len > 4) 1261 err = eeprom_rd_phys(adapter, 1262 aligned_offset + aligned_len - 4, 1263 (u32 *)&buf[aligned_len - 4]); 1264 if (err) 1265 goto out; 1266 memcpy(buf + (eeprom->offset & 3), data, eeprom->len); 1267 } else { 1268 buf = data; 1269 } 1270 1271 err = t4_seeprom_wp(adapter, false); 1272 if (err) 1273 goto out; 1274 1275 for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) { 1276 err = eeprom_wr_phys(adapter, aligned_offset, *p); 1277 aligned_offset += 4; 1278 } 1279 1280 if (!err) 1281 err = t4_seeprom_wp(adapter, true); 1282out: 1283 if (buf != data) 1284 kvfree(buf); 1285 return err; 1286} 1287 1288static int cxgb4_ethtool_flash_bootcfg(struct net_device *netdev, 1289 const u8 *data, u32 size) 1290{ 1291 struct adapter *adap = netdev2adap(netdev); 1292 int ret; 1293 1294 ret = t4_load_bootcfg(adap, data, size); 1295 if (ret) 1296 dev_err(adap->pdev_dev, "Failed to load boot cfg image\n"); 1297 1298 return ret; 1299} 1300 1301static int cxgb4_ethtool_flash_boot(struct net_device *netdev, 1302 const u8 *bdata, u32 size) 1303{ 1304 struct adapter *adap = netdev2adap(netdev); 1305 unsigned int offset; 1306 u8 *data; 1307 int ret; 1308 1309 data = kmemdup(bdata, size, GFP_KERNEL); 1310 if (!data) 1311 return -ENOMEM; 1312 1313 offset = OFFSET_G(t4_read_reg(adap, PF_REG(0, PCIE_PF_EXPROM_OFST_A))); 1314 1315 ret = t4_load_boot(adap, data, offset, size); 1316 if (ret) 1317 dev_err(adap->pdev_dev, "Failed to load boot image\n"); 1318 1319 kfree(data); 1320 return ret; 1321} 1322 1323#define CXGB4_PHY_SIG 0x130000ea 1324 1325static int cxgb4_validate_phy_image(const u8 *data, u32 *size) 1326{ 1327 struct cxgb4_fw_data *header; 1328 1329 header = (struct cxgb4_fw_data *)data; 1330 if (be32_to_cpu(header->signature) != CXGB4_PHY_SIG) 1331 return -EINVAL; 1332 1333 return 0; 1334} 1335 1336static int cxgb4_ethtool_flash_phy(struct net_device *netdev, 1337 const u8 *data, u32 size) 1338{ 1339 struct adapter *adap = netdev2adap(netdev); 1340 int ret; 1341 1342 ret = cxgb4_validate_phy_image(data, NULL); 1343 if (ret) { 1344 dev_err(adap->pdev_dev, "PHY signature mismatch\n"); 1345 return ret; 1346 } 1347 1348 /* We have to RESET the chip/firmware because we need the 1349 * chip in uninitialized state for loading new PHY image. 1350 * Otherwise, the running firmware will only store the PHY 1351 * image in local RAM which will be lost after next reset. 1352 */ 1353 ret = t4_fw_reset(adap, adap->mbox, PIORSTMODE_F | PIORST_F); 1354 if (ret < 0) { 1355 dev_err(adap->pdev_dev, 1356 "Set FW to RESET for flashing PHY FW failed. ret: %d\n", 1357 ret); 1358 return ret; 1359 } 1360 1361 ret = t4_load_phy_fw(adap, MEMWIN_NIC, NULL, data, size); 1362 if (ret < 0) { 1363 dev_err(adap->pdev_dev, "Failed to load PHY FW. ret: %d\n", 1364 ret); 1365 return ret; 1366 } 1367 1368 return 0; 1369} 1370 1371static int cxgb4_ethtool_flash_fw(struct net_device *netdev, 1372 const u8 *data, u32 size) 1373{ 1374 struct adapter *adap = netdev2adap(netdev); 1375 unsigned int mbox = PCIE_FW_MASTER_M + 1; 1376 int ret; 1377 1378 /* If the adapter has been fully initialized then we'll go ahead and 1379 * try to get the firmware's cooperation in upgrading to the new 1380 * firmware image otherwise we'll try to do the entire job from the 1381 * host ... and we always "force" the operation in this path. 1382 */ 1383 if (adap->flags & CXGB4_FULL_INIT_DONE) 1384 mbox = adap->mbox; 1385 1386 ret = t4_fw_upgrade(adap, mbox, data, size, 1); 1387 if (ret) 1388 dev_err(adap->pdev_dev, 1389 "Failed to flash firmware\n"); 1390 1391 return ret; 1392} 1393 1394static int cxgb4_ethtool_flash_region(struct net_device *netdev, 1395 const u8 *data, u32 size, u32 region) 1396{ 1397 struct adapter *adap = netdev2adap(netdev); 1398 int ret; 1399 1400 switch (region) { 1401 case CXGB4_ETHTOOL_FLASH_FW: 1402 ret = cxgb4_ethtool_flash_fw(netdev, data, size); 1403 break; 1404 case CXGB4_ETHTOOL_FLASH_PHY: 1405 ret = cxgb4_ethtool_flash_phy(netdev, data, size); 1406 break; 1407 case CXGB4_ETHTOOL_FLASH_BOOT: 1408 ret = cxgb4_ethtool_flash_boot(netdev, data, size); 1409 break; 1410 case CXGB4_ETHTOOL_FLASH_BOOTCFG: 1411 ret = cxgb4_ethtool_flash_bootcfg(netdev, data, size); 1412 break; 1413 default: 1414 ret = -EOPNOTSUPP; 1415 break; 1416 } 1417 1418 if (!ret) 1419 dev_info(adap->pdev_dev, 1420 "loading %s successful, reload cxgb4 driver\n", 1421 flash_region_strings[region]); 1422 return ret; 1423} 1424 1425#define CXGB4_FW_SIG 0x4368656c 1426#define CXGB4_FW_SIG_OFFSET 0x160 1427 1428static int cxgb4_validate_fw_image(const u8 *data, u32 *size) 1429{ 1430 struct cxgb4_fw_data *header; 1431 1432 header = (struct cxgb4_fw_data *)&data[CXGB4_FW_SIG_OFFSET]; 1433 if (be32_to_cpu(header->signature) != CXGB4_FW_SIG) 1434 return -EINVAL; 1435 1436 if (size) 1437 *size = be16_to_cpu(((struct fw_hdr *)data)->len512) * 512; 1438 1439 return 0; 1440} 1441 1442static int cxgb4_validate_bootcfg_image(const u8 *data, u32 *size) 1443{ 1444 struct cxgb4_bootcfg_data *header; 1445 1446 header = (struct cxgb4_bootcfg_data *)data; 1447 if (le16_to_cpu(header->signature) != BOOT_CFG_SIG) 1448 return -EINVAL; 1449 1450 return 0; 1451} 1452 1453static int cxgb4_validate_boot_image(const u8 *data, u32 *size) 1454{ 1455 struct cxgb4_pci_exp_rom_header *exp_header; 1456 struct cxgb4_pcir_data *pcir_header; 1457 struct legacy_pci_rom_hdr *header; 1458 const u8 *cur_header = data; 1459 u16 pcir_offset; 1460 1461 exp_header = (struct cxgb4_pci_exp_rom_header *)data; 1462 1463 if (le16_to_cpu(exp_header->signature) != BOOT_SIGNATURE) 1464 return -EINVAL; 1465 1466 if (size) { 1467 do { 1468 header = (struct legacy_pci_rom_hdr *)cur_header; 1469 pcir_offset = le16_to_cpu(header->pcir_offset); 1470 pcir_header = (struct cxgb4_pcir_data *)(cur_header + 1471 pcir_offset); 1472 1473 *size += header->size512 * 512; 1474 cur_header += header->size512 * 512; 1475 } while (!(pcir_header->indicator & CXGB4_HDR_INDI)); 1476 } 1477 1478 return 0; 1479} 1480 1481static int cxgb4_ethtool_get_flash_region(const u8 *data, u32 *size) 1482{ 1483 if (!cxgb4_validate_fw_image(data, size)) 1484 return CXGB4_ETHTOOL_FLASH_FW; 1485 if (!cxgb4_validate_boot_image(data, size)) 1486 return CXGB4_ETHTOOL_FLASH_BOOT; 1487 if (!cxgb4_validate_phy_image(data, size)) 1488 return CXGB4_ETHTOOL_FLASH_PHY; 1489 if (!cxgb4_validate_bootcfg_image(data, size)) 1490 return CXGB4_ETHTOOL_FLASH_BOOTCFG; 1491 1492 return -EOPNOTSUPP; 1493} 1494 1495static int set_flash(struct net_device *netdev, struct ethtool_flash *ef) 1496{ 1497 struct adapter *adap = netdev2adap(netdev); 1498 const struct firmware *fw; 1499 unsigned int master; 1500 u8 master_vld = 0; 1501 const u8 *fw_data; 1502 size_t fw_size; 1503 u32 size = 0; 1504 u32 pcie_fw; 1505 int region; 1506 int ret; 1507 1508 pcie_fw = t4_read_reg(adap, PCIE_FW_A); 1509 master = PCIE_FW_MASTER_G(pcie_fw); 1510 if (pcie_fw & PCIE_FW_MASTER_VLD_F) 1511 master_vld = 1; 1512 /* if csiostor is the master return */ 1513 if (master_vld && (master != adap->pf)) { 1514 dev_warn(adap->pdev_dev, 1515 "cxgb4 driver needs to be loaded as MASTER to support FW flash\n"); 1516 return -EOPNOTSUPP; 1517 } 1518 1519 ef->data[sizeof(ef->data) - 1] = '\0'; 1520 ret = request_firmware(&fw, ef->data, adap->pdev_dev); 1521 if (ret < 0) 1522 return ret; 1523 1524 fw_data = fw->data; 1525 fw_size = fw->size; 1526 if (ef->region == ETHTOOL_FLASH_ALL_REGIONS) { 1527 while (fw_size > 0) { 1528 size = 0; 1529 region = cxgb4_ethtool_get_flash_region(fw_data, &size); 1530 if (region < 0 || !size) { 1531 ret = region; 1532 goto out_free_fw; 1533 } 1534 1535 ret = cxgb4_ethtool_flash_region(netdev, fw_data, size, 1536 region); 1537 if (ret) 1538 goto out_free_fw; 1539 1540 fw_data += size; 1541 fw_size -= size; 1542 } 1543 } else { 1544 ret = cxgb4_ethtool_flash_region(netdev, fw_data, fw_size, 1545 ef->region); 1546 } 1547 1548out_free_fw: 1549 release_firmware(fw); 1550 return ret; 1551} 1552 1553static int get_ts_info(struct net_device *dev, struct ethtool_ts_info *ts_info) 1554{ 1555 struct port_info *pi = netdev_priv(dev); 1556 struct adapter *adapter = pi->adapter; 1557 1558 ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE | 1559 SOF_TIMESTAMPING_RX_SOFTWARE | 1560 SOF_TIMESTAMPING_SOFTWARE; 1561 1562 ts_info->so_timestamping |= SOF_TIMESTAMPING_RX_HARDWARE | 1563 SOF_TIMESTAMPING_TX_HARDWARE | 1564 SOF_TIMESTAMPING_RAW_HARDWARE; 1565 1566 ts_info->tx_types = (1 << HWTSTAMP_TX_OFF) | 1567 (1 << HWTSTAMP_TX_ON); 1568 1569 ts_info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) | 1570 (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT) | 1571 (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC) | 1572 (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) | 1573 (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) | 1574 (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ); 1575 1576 if (adapter->ptp_clock) 1577 ts_info->phc_index = ptp_clock_index(adapter->ptp_clock); 1578 else 1579 ts_info->phc_index = -1; 1580 1581 return 0; 1582} 1583 1584static u32 get_rss_table_size(struct net_device *dev) 1585{ 1586 const struct port_info *pi = netdev_priv(dev); 1587 1588 return pi->rss_size; 1589} 1590 1591static int get_rss_table(struct net_device *dev, 1592 struct ethtool_rxfh_param *rxfh) 1593{ 1594 const struct port_info *pi = netdev_priv(dev); 1595 unsigned int n = pi->rss_size; 1596 1597 rxfh->hfunc = ETH_RSS_HASH_TOP; 1598 if (!rxfh->indir) 1599 return 0; 1600 while (n--) 1601 rxfh->indir[n] = pi->rss[n]; 1602 return 0; 1603} 1604 1605static int set_rss_table(struct net_device *dev, 1606 struct ethtool_rxfh_param *rxfh, 1607 struct netlink_ext_ack *extack) 1608{ 1609 unsigned int i; 1610 struct port_info *pi = netdev_priv(dev); 1611 1612 /* We require at least one supported parameter to be changed and no 1613 * change in any of the unsupported parameters 1614 */ 1615 if (rxfh->key || 1616 (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && 1617 rxfh->hfunc != ETH_RSS_HASH_TOP)) 1618 return -EOPNOTSUPP; 1619 if (!rxfh->indir) 1620 return 0; 1621 1622 /* Interface must be brought up atleast once */ 1623 if (pi->adapter->flags & CXGB4_FULL_INIT_DONE) { 1624 for (i = 0; i < pi->rss_size; i++) 1625 pi->rss[i] = rxfh->indir[i]; 1626 1627 return cxgb4_write_rss(pi, pi->rss); 1628 } 1629 1630 return -EPERM; 1631} 1632 1633static struct filter_entry *cxgb4_get_filter_entry(struct adapter *adap, 1634 u32 ftid) 1635{ 1636 struct tid_info *t = &adap->tids; 1637 1638 if (ftid >= t->hpftid_base && ftid < t->hpftid_base + t->nhpftids) 1639 return &t->hpftid_tab[ftid - t->hpftid_base]; 1640 1641 if (ftid >= t->ftid_base && ftid < t->ftid_base + t->nftids) 1642 return &t->ftid_tab[ftid - t->ftid_base]; 1643 1644 return lookup_tid(t, ftid); 1645} 1646 1647static void cxgb4_fill_filter_rule(struct ethtool_rx_flow_spec *fs, 1648 struct ch_filter_specification *dfs) 1649{ 1650 switch (dfs->val.proto) { 1651 case IPPROTO_TCP: 1652 if (dfs->type) 1653 fs->flow_type = TCP_V6_FLOW; 1654 else 1655 fs->flow_type = TCP_V4_FLOW; 1656 break; 1657 case IPPROTO_UDP: 1658 if (dfs->type) 1659 fs->flow_type = UDP_V6_FLOW; 1660 else 1661 fs->flow_type = UDP_V4_FLOW; 1662 break; 1663 } 1664 1665 if (dfs->type) { 1666 fs->h_u.tcp_ip6_spec.psrc = cpu_to_be16(dfs->val.fport); 1667 fs->m_u.tcp_ip6_spec.psrc = cpu_to_be16(dfs->mask.fport); 1668 fs->h_u.tcp_ip6_spec.pdst = cpu_to_be16(dfs->val.lport); 1669 fs->m_u.tcp_ip6_spec.pdst = cpu_to_be16(dfs->mask.lport); 1670 memcpy(&fs->h_u.tcp_ip6_spec.ip6src, &dfs->val.fip[0], 1671 sizeof(fs->h_u.tcp_ip6_spec.ip6src)); 1672 memcpy(&fs->m_u.tcp_ip6_spec.ip6src, &dfs->mask.fip[0], 1673 sizeof(fs->m_u.tcp_ip6_spec.ip6src)); 1674 memcpy(&fs->h_u.tcp_ip6_spec.ip6dst, &dfs->val.lip[0], 1675 sizeof(fs->h_u.tcp_ip6_spec.ip6dst)); 1676 memcpy(&fs->m_u.tcp_ip6_spec.ip6dst, &dfs->mask.lip[0], 1677 sizeof(fs->m_u.tcp_ip6_spec.ip6dst)); 1678 fs->h_u.tcp_ip6_spec.tclass = dfs->val.tos; 1679 fs->m_u.tcp_ip6_spec.tclass = dfs->mask.tos; 1680 } else { 1681 fs->h_u.tcp_ip4_spec.psrc = cpu_to_be16(dfs->val.fport); 1682 fs->m_u.tcp_ip4_spec.psrc = cpu_to_be16(dfs->mask.fport); 1683 fs->h_u.tcp_ip4_spec.pdst = cpu_to_be16(dfs->val.lport); 1684 fs->m_u.tcp_ip4_spec.pdst = cpu_to_be16(dfs->mask.lport); 1685 memcpy(&fs->h_u.tcp_ip4_spec.ip4src, &dfs->val.fip[0], 1686 sizeof(fs->h_u.tcp_ip4_spec.ip4src)); 1687 memcpy(&fs->m_u.tcp_ip4_spec.ip4src, &dfs->mask.fip[0], 1688 sizeof(fs->m_u.tcp_ip4_spec.ip4src)); 1689 memcpy(&fs->h_u.tcp_ip4_spec.ip4dst, &dfs->val.lip[0], 1690 sizeof(fs->h_u.tcp_ip4_spec.ip4dst)); 1691 memcpy(&fs->m_u.tcp_ip4_spec.ip4dst, &dfs->mask.lip[0], 1692 sizeof(fs->m_u.tcp_ip4_spec.ip4dst)); 1693 fs->h_u.tcp_ip4_spec.tos = dfs->val.tos; 1694 fs->m_u.tcp_ip4_spec.tos = dfs->mask.tos; 1695 } 1696 fs->h_ext.vlan_tci = cpu_to_be16(dfs->val.ivlan); 1697 fs->m_ext.vlan_tci = cpu_to_be16(dfs->mask.ivlan); 1698 fs->flow_type |= FLOW_EXT; 1699 1700 if (dfs->action == FILTER_DROP) 1701 fs->ring_cookie = RX_CLS_FLOW_DISC; 1702 else 1703 fs->ring_cookie = dfs->iq; 1704} 1705 1706static int cxgb4_ntuple_get_filter(struct net_device *dev, 1707 struct ethtool_rxnfc *cmd, 1708 unsigned int loc) 1709{ 1710 const struct port_info *pi = netdev_priv(dev); 1711 struct adapter *adap = netdev2adap(dev); 1712 struct filter_entry *f; 1713 int ftid; 1714 1715 if (!(adap->flags & CXGB4_FULL_INIT_DONE)) 1716 return -EAGAIN; 1717 1718 /* Check for maximum filter range */ 1719 if (!adap->ethtool_filters) 1720 return -EOPNOTSUPP; 1721 1722 if (loc >= adap->ethtool_filters->nentries) 1723 return -ERANGE; 1724 1725 if (!test_bit(loc, adap->ethtool_filters->port[pi->port_id].bmap)) 1726 return -ENOENT; 1727 1728 ftid = adap->ethtool_filters->port[pi->port_id].loc_array[loc]; 1729 1730 /* Fetch filter_entry */ 1731 f = cxgb4_get_filter_entry(adap, ftid); 1732 1733 cxgb4_fill_filter_rule(&cmd->fs, &f->fs); 1734 1735 return 0; 1736} 1737 1738static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, 1739 u32 *rules) 1740{ 1741 const struct port_info *pi = netdev_priv(dev); 1742 struct adapter *adap = netdev2adap(dev); 1743 unsigned int count = 0, index = 0; 1744 int ret = 0; 1745 1746 switch (info->cmd) { 1747 case ETHTOOL_GRXFH: { 1748 unsigned int v = pi->rss_mode; 1749 1750 info->data = 0; 1751 switch (info->flow_type) { 1752 case TCP_V4_FLOW: 1753 if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) 1754 info->data = RXH_IP_SRC | RXH_IP_DST | 1755 RXH_L4_B_0_1 | RXH_L4_B_2_3; 1756 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 1757 info->data = RXH_IP_SRC | RXH_IP_DST; 1758 break; 1759 case UDP_V4_FLOW: 1760 if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) && 1761 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F)) 1762 info->data = RXH_IP_SRC | RXH_IP_DST | 1763 RXH_L4_B_0_1 | RXH_L4_B_2_3; 1764 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 1765 info->data = RXH_IP_SRC | RXH_IP_DST; 1766 break; 1767 case SCTP_V4_FLOW: 1768 case AH_ESP_V4_FLOW: 1769 case IPV4_FLOW: 1770 if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 1771 info->data = RXH_IP_SRC | RXH_IP_DST; 1772 break; 1773 case TCP_V6_FLOW: 1774 if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) 1775 info->data = RXH_IP_SRC | RXH_IP_DST | 1776 RXH_L4_B_0_1 | RXH_L4_B_2_3; 1777 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 1778 info->data = RXH_IP_SRC | RXH_IP_DST; 1779 break; 1780 case UDP_V6_FLOW: 1781 if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) && 1782 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F)) 1783 info->data = RXH_IP_SRC | RXH_IP_DST | 1784 RXH_L4_B_0_1 | RXH_L4_B_2_3; 1785 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 1786 info->data = RXH_IP_SRC | RXH_IP_DST; 1787 break; 1788 case SCTP_V6_FLOW: 1789 case AH_ESP_V6_FLOW: 1790 case IPV6_FLOW: 1791 if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 1792 info->data = RXH_IP_SRC | RXH_IP_DST; 1793 break; 1794 } 1795 return 0; 1796 } 1797 case ETHTOOL_GRXRINGS: 1798 info->data = pi->nqsets; 1799 return 0; 1800 case ETHTOOL_GRXCLSRLCNT: 1801 info->rule_cnt = 1802 adap->ethtool_filters->port[pi->port_id].in_use; 1803 return 0; 1804 case ETHTOOL_GRXCLSRULE: 1805 return cxgb4_ntuple_get_filter(dev, info, info->fs.location); 1806 case ETHTOOL_GRXCLSRLALL: 1807 info->data = adap->ethtool_filters->nentries; 1808 while (count < info->rule_cnt) { 1809 ret = cxgb4_ntuple_get_filter(dev, info, index); 1810 if (!ret) 1811 rules[count++] = index; 1812 index++; 1813 } 1814 return 0; 1815 } 1816 1817 return -EOPNOTSUPP; 1818} 1819 1820static int cxgb4_ntuple_del_filter(struct net_device *dev, 1821 struct ethtool_rxnfc *cmd) 1822{ 1823 struct cxgb4_ethtool_filter_info *filter_info; 1824 struct adapter *adapter = netdev2adap(dev); 1825 struct port_info *pi = netdev_priv(dev); 1826 struct filter_entry *f; 1827 u32 filter_id; 1828 int ret; 1829 1830 if (!(adapter->flags & CXGB4_FULL_INIT_DONE)) 1831 return -EAGAIN; /* can still change nfilters */ 1832 1833 if (!adapter->ethtool_filters) 1834 return -EOPNOTSUPP; 1835 1836 if (cmd->fs.location >= adapter->ethtool_filters->nentries) { 1837 dev_err(adapter->pdev_dev, 1838 "Location must be < %u", 1839 adapter->ethtool_filters->nentries); 1840 return -ERANGE; 1841 } 1842 1843 filter_info = &adapter->ethtool_filters->port[pi->port_id]; 1844 1845 if (!test_bit(cmd->fs.location, filter_info->bmap)) 1846 return -ENOENT; 1847 1848 filter_id = filter_info->loc_array[cmd->fs.location]; 1849 f = cxgb4_get_filter_entry(adapter, filter_id); 1850 1851 if (f->fs.prio) 1852 filter_id -= adapter->tids.hpftid_base; 1853 else if (!f->fs.hash) 1854 filter_id -= (adapter->tids.ftid_base - adapter->tids.nhpftids); 1855 1856 ret = cxgb4_flow_rule_destroy(dev, f->fs.tc_prio, &f->fs, filter_id); 1857 if (ret) 1858 goto err; 1859 1860 clear_bit(cmd->fs.location, filter_info->bmap); 1861 filter_info->in_use--; 1862 1863err: 1864 return ret; 1865} 1866 1867/* Add Ethtool n-tuple filters. */ 1868static int cxgb4_ntuple_set_filter(struct net_device *netdev, 1869 struct ethtool_rxnfc *cmd) 1870{ 1871 struct ethtool_rx_flow_spec_input input = {}; 1872 struct cxgb4_ethtool_filter_info *filter_info; 1873 struct adapter *adapter = netdev2adap(netdev); 1874 struct port_info *pi = netdev_priv(netdev); 1875 struct ch_filter_specification fs; 1876 struct ethtool_rx_flow_rule *flow; 1877 u32 tid; 1878 int ret; 1879 1880 if (!(adapter->flags & CXGB4_FULL_INIT_DONE)) 1881 return -EAGAIN; /* can still change nfilters */ 1882 1883 if (!adapter->ethtool_filters) 1884 return -EOPNOTSUPP; 1885 1886 if (cmd->fs.location >= adapter->ethtool_filters->nentries) { 1887 dev_err(adapter->pdev_dev, 1888 "Location must be < %u", 1889 adapter->ethtool_filters->nentries); 1890 return -ERANGE; 1891 } 1892 1893 if (test_bit(cmd->fs.location, 1894 adapter->ethtool_filters->port[pi->port_id].bmap)) 1895 return -EEXIST; 1896 1897 memset(&fs, 0, sizeof(fs)); 1898 1899 input.fs = &cmd->fs; 1900 flow = ethtool_rx_flow_rule_create(&input); 1901 if (IS_ERR(flow)) { 1902 ret = PTR_ERR(flow); 1903 goto exit; 1904 } 1905 1906 fs.hitcnts = 1; 1907 1908 ret = cxgb4_flow_rule_replace(netdev, flow->rule, cmd->fs.location, 1909 NULL, &fs, &tid); 1910 if (ret) 1911 goto free; 1912 1913 filter_info = &adapter->ethtool_filters->port[pi->port_id]; 1914 1915 if (fs.prio) 1916 tid += adapter->tids.hpftid_base; 1917 else if (!fs.hash) 1918 tid += (adapter->tids.ftid_base - adapter->tids.nhpftids); 1919 1920 filter_info->loc_array[cmd->fs.location] = tid; 1921 set_bit(cmd->fs.location, filter_info->bmap); 1922 filter_info->in_use++; 1923 1924free: 1925 ethtool_rx_flow_rule_destroy(flow); 1926exit: 1927 return ret; 1928} 1929 1930static int set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 1931{ 1932 int ret = -EOPNOTSUPP; 1933 1934 switch (cmd->cmd) { 1935 case ETHTOOL_SRXCLSRLINS: 1936 ret = cxgb4_ntuple_set_filter(dev, cmd); 1937 break; 1938 case ETHTOOL_SRXCLSRLDEL: 1939 ret = cxgb4_ntuple_del_filter(dev, cmd); 1940 break; 1941 default: 1942 break; 1943 } 1944 1945 return ret; 1946} 1947 1948static int set_dump(struct net_device *dev, struct ethtool_dump *eth_dump) 1949{ 1950 struct adapter *adapter = netdev2adap(dev); 1951 u32 len = 0; 1952 1953 len = sizeof(struct cudbg_hdr) + 1954 sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY; 1955 len += cxgb4_get_dump_length(adapter, eth_dump->flag); 1956 1957 adapter->eth_dump.flag = eth_dump->flag; 1958 adapter->eth_dump.len = len; 1959 return 0; 1960} 1961 1962static int get_dump_flag(struct net_device *dev, struct ethtool_dump *eth_dump) 1963{ 1964 struct adapter *adapter = netdev2adap(dev); 1965 1966 eth_dump->flag = adapter->eth_dump.flag; 1967 eth_dump->len = adapter->eth_dump.len; 1968 eth_dump->version = adapter->eth_dump.version; 1969 return 0; 1970} 1971 1972static int get_dump_data(struct net_device *dev, struct ethtool_dump *eth_dump, 1973 void *buf) 1974{ 1975 struct adapter *adapter = netdev2adap(dev); 1976 u32 len = 0; 1977 int ret = 0; 1978 1979 if (adapter->eth_dump.flag == CXGB4_ETH_DUMP_NONE) 1980 return -ENOENT; 1981 1982 len = sizeof(struct cudbg_hdr) + 1983 sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY; 1984 len += cxgb4_get_dump_length(adapter, adapter->eth_dump.flag); 1985 if (eth_dump->len < len) 1986 return -ENOMEM; 1987 1988 ret = cxgb4_cudbg_collect(adapter, buf, &len, adapter->eth_dump.flag); 1989 if (ret) 1990 return ret; 1991 1992 eth_dump->flag = adapter->eth_dump.flag; 1993 eth_dump->len = len; 1994 eth_dump->version = adapter->eth_dump.version; 1995 return 0; 1996} 1997 1998static bool cxgb4_fw_mod_type_info_available(unsigned int fw_mod_type) 1999{ 2000 /* Read port module EEPROM as long as it is plugged-in and 2001 * safe to read. 2002 */ 2003 return (fw_mod_type != FW_PORT_MOD_TYPE_NONE && 2004 fw_mod_type != FW_PORT_MOD_TYPE_ERROR); 2005} 2006 2007static int cxgb4_get_module_info(struct net_device *dev, 2008 struct ethtool_modinfo *modinfo) 2009{ 2010 struct port_info *pi = netdev_priv(dev); 2011 u8 sff8472_comp, sff_diag_type, sff_rev; 2012 struct adapter *adapter = pi->adapter; 2013 int ret; 2014 2015 if (!cxgb4_fw_mod_type_info_available(pi->mod_type)) 2016 return -EINVAL; 2017 2018 switch (pi->port_type) { 2019 case FW_PORT_TYPE_SFP: 2020 case FW_PORT_TYPE_QSA: 2021 case FW_PORT_TYPE_SFP28: 2022 ret = t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, 2023 I2C_DEV_ADDR_A0, SFF_8472_COMP_ADDR, 2024 SFF_8472_COMP_LEN, &sff8472_comp); 2025 if (ret) 2026 return ret; 2027 ret = t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, 2028 I2C_DEV_ADDR_A0, SFP_DIAG_TYPE_ADDR, 2029 SFP_DIAG_TYPE_LEN, &sff_diag_type); 2030 if (ret) 2031 return ret; 2032 2033 if (!sff8472_comp || (sff_diag_type & SFP_DIAG_ADDRMODE)) { 2034 modinfo->type = ETH_MODULE_SFF_8079; 2035 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN; 2036 } else { 2037 modinfo->type = ETH_MODULE_SFF_8472; 2038 if (sff_diag_type & SFP_DIAG_IMPLEMENTED) 2039 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN; 2040 else 2041 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN / 2; 2042 } 2043 break; 2044 2045 case FW_PORT_TYPE_QSFP: 2046 case FW_PORT_TYPE_QSFP_10G: 2047 case FW_PORT_TYPE_CR_QSFP: 2048 case FW_PORT_TYPE_CR2_QSFP: 2049 case FW_PORT_TYPE_CR4_QSFP: 2050 ret = t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, 2051 I2C_DEV_ADDR_A0, SFF_REV_ADDR, 2052 SFF_REV_LEN, &sff_rev); 2053 /* For QSFP type ports, revision value >= 3 2054 * means the SFP is 8636 compliant. 2055 */ 2056 if (ret) 2057 return ret; 2058 if (sff_rev >= 0x3) { 2059 modinfo->type = ETH_MODULE_SFF_8636; 2060 modinfo->eeprom_len = ETH_MODULE_SFF_8636_LEN; 2061 } else { 2062 modinfo->type = ETH_MODULE_SFF_8436; 2063 modinfo->eeprom_len = ETH_MODULE_SFF_8436_LEN; 2064 } 2065 break; 2066 2067 default: 2068 return -EINVAL; 2069 } 2070 2071 return 0; 2072} 2073 2074static int cxgb4_get_module_eeprom(struct net_device *dev, 2075 struct ethtool_eeprom *eprom, u8 *data) 2076{ 2077 int ret = 0, offset = eprom->offset, len = eprom->len; 2078 struct port_info *pi = netdev_priv(dev); 2079 struct adapter *adapter = pi->adapter; 2080 2081 memset(data, 0, eprom->len); 2082 if (offset + len <= I2C_PAGE_SIZE) 2083 return t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, 2084 I2C_DEV_ADDR_A0, offset, len, data); 2085 2086 /* offset + len spans 0xa0 and 0xa1 pages */ 2087 if (offset <= I2C_PAGE_SIZE) { 2088 /* read 0xa0 page */ 2089 len = I2C_PAGE_SIZE - offset; 2090 ret = t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, 2091 I2C_DEV_ADDR_A0, offset, len, data); 2092 if (ret) 2093 return ret; 2094 offset = I2C_PAGE_SIZE; 2095 /* Remaining bytes to be read from second page = 2096 * Total length - bytes read from first page 2097 */ 2098 len = eprom->len - len; 2099 } 2100 /* Read additional optical diagnostics from page 0xa2 if supported */ 2101 return t4_i2c_rd(adapter, adapter->mbox, pi->tx_chan, I2C_DEV_ADDR_A2, 2102 offset, len, &data[eprom->len - len]); 2103} 2104 2105static u32 cxgb4_get_priv_flags(struct net_device *netdev) 2106{ 2107 struct port_info *pi = netdev_priv(netdev); 2108 struct adapter *adapter = pi->adapter; 2109 2110 return (adapter->eth_flags | pi->eth_flags); 2111} 2112 2113/** 2114 * set_flags - set/unset specified flags if passed in new_flags 2115 * @cur_flags: pointer to current flags 2116 * @new_flags: new incoming flags 2117 * @flags: set of flags to set/unset 2118 */ 2119static inline void set_flags(u32 *cur_flags, u32 new_flags, u32 flags) 2120{ 2121 *cur_flags = (*cur_flags & ~flags) | (new_flags & flags); 2122} 2123 2124static int cxgb4_set_priv_flags(struct net_device *netdev, u32 flags) 2125{ 2126 struct port_info *pi = netdev_priv(netdev); 2127 struct adapter *adapter = pi->adapter; 2128 2129 set_flags(&adapter->eth_flags, flags, PRIV_FLAGS_ADAP); 2130 set_flags(&pi->eth_flags, flags, PRIV_FLAGS_PORT); 2131 2132 return 0; 2133} 2134 2135static void cxgb4_lb_test(struct net_device *netdev, u64 *lb_status) 2136{ 2137 int dev_state = netif_running(netdev); 2138 2139 if (dev_state) { 2140 netif_tx_stop_all_queues(netdev); 2141 netif_carrier_off(netdev); 2142 } 2143 2144 *lb_status = cxgb4_selftest_lb_pkt(netdev); 2145 2146 if (dev_state) { 2147 netif_tx_start_all_queues(netdev); 2148 netif_carrier_on(netdev); 2149 } 2150} 2151 2152static void cxgb4_self_test(struct net_device *netdev, 2153 struct ethtool_test *eth_test, u64 *data) 2154{ 2155 struct port_info *pi = netdev_priv(netdev); 2156 struct adapter *adap = pi->adapter; 2157 2158 memset(data, 0, sizeof(u64) * CXGB4_ETHTOOL_MAX_TEST); 2159 2160 if (!(adap->flags & CXGB4_FULL_INIT_DONE) || 2161 !(adap->flags & CXGB4_FW_OK)) { 2162 eth_test->flags |= ETH_TEST_FL_FAILED; 2163 return; 2164 } 2165 2166 if (eth_test->flags & ETH_TEST_FL_OFFLINE) 2167 cxgb4_lb_test(netdev, &data[CXGB4_ETHTOOL_LB_TEST]); 2168 2169 if (data[CXGB4_ETHTOOL_LB_TEST]) 2170 eth_test->flags |= ETH_TEST_FL_FAILED; 2171} 2172 2173static const struct ethtool_ops cxgb_ethtool_ops = { 2174 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 2175 ETHTOOL_COALESCE_RX_MAX_FRAMES | 2176 ETHTOOL_COALESCE_TX_USECS_IRQ | 2177 ETHTOOL_COALESCE_USE_ADAPTIVE_RX, 2178 .get_link_ksettings = get_link_ksettings, 2179 .set_link_ksettings = set_link_ksettings, 2180 .get_fecparam = get_fecparam, 2181 .set_fecparam = set_fecparam, 2182 .get_drvinfo = get_drvinfo, 2183 .get_msglevel = get_msglevel, 2184 .set_msglevel = set_msglevel, 2185 .get_ringparam = get_sge_param, 2186 .set_ringparam = set_sge_param, 2187 .get_coalesce = get_coalesce, 2188 .set_coalesce = set_coalesce, 2189 .get_eeprom_len = get_eeprom_len, 2190 .get_eeprom = get_eeprom, 2191 .set_eeprom = set_eeprom, 2192 .get_pauseparam = get_pauseparam, 2193 .set_pauseparam = set_pauseparam, 2194 .get_link = ethtool_op_get_link, 2195 .get_strings = get_strings, 2196 .set_phys_id = identify_port, 2197 .nway_reset = restart_autoneg, 2198 .get_sset_count = get_sset_count, 2199 .get_ethtool_stats = get_stats, 2200 .get_regs_len = get_regs_len, 2201 .get_regs = get_regs, 2202 .get_rxnfc = get_rxnfc, 2203 .set_rxnfc = set_rxnfc, 2204 .get_rxfh_indir_size = get_rss_table_size, 2205 .get_rxfh = get_rss_table, 2206 .set_rxfh = set_rss_table, 2207 .self_test = cxgb4_self_test, 2208 .flash_device = set_flash, 2209 .get_ts_info = get_ts_info, 2210 .set_dump = set_dump, 2211 .get_dump_flag = get_dump_flag, 2212 .get_dump_data = get_dump_data, 2213 .get_module_info = cxgb4_get_module_info, 2214 .get_module_eeprom = cxgb4_get_module_eeprom, 2215 .get_priv_flags = cxgb4_get_priv_flags, 2216 .set_priv_flags = cxgb4_set_priv_flags, 2217}; 2218 2219void cxgb4_cleanup_ethtool_filters(struct adapter *adap) 2220{ 2221 struct cxgb4_ethtool_filter_info *eth_filter_info; 2222 u8 i; 2223 2224 if (!adap->ethtool_filters) 2225 return; 2226 2227 eth_filter_info = adap->ethtool_filters->port; 2228 2229 if (eth_filter_info) { 2230 for (i = 0; i < adap->params.nports; i++) { 2231 kvfree(eth_filter_info[i].loc_array); 2232 bitmap_free(eth_filter_info[i].bmap); 2233 } 2234 kfree(eth_filter_info); 2235 } 2236 2237 kfree(adap->ethtool_filters); 2238} 2239 2240int cxgb4_init_ethtool_filters(struct adapter *adap) 2241{ 2242 struct cxgb4_ethtool_filter_info *eth_filter_info; 2243 struct cxgb4_ethtool_filter *eth_filter; 2244 struct tid_info *tids = &adap->tids; 2245 u32 nentries, i; 2246 int ret; 2247 2248 eth_filter = kzalloc(sizeof(*eth_filter), GFP_KERNEL); 2249 if (!eth_filter) 2250 return -ENOMEM; 2251 2252 eth_filter_info = kcalloc(adap->params.nports, 2253 sizeof(*eth_filter_info), 2254 GFP_KERNEL); 2255 if (!eth_filter_info) { 2256 ret = -ENOMEM; 2257 goto free_eth_filter; 2258 } 2259 2260 eth_filter->port = eth_filter_info; 2261 2262 nentries = tids->nhpftids + tids->nftids; 2263 if (is_hashfilter(adap)) 2264 nentries += tids->nhash + 2265 (adap->tids.stid_base - adap->tids.tid_base); 2266 eth_filter->nentries = nentries; 2267 2268 for (i = 0; i < adap->params.nports; i++) { 2269 eth_filter->port[i].loc_array = kvzalloc(nentries, GFP_KERNEL); 2270 if (!eth_filter->port[i].loc_array) { 2271 ret = -ENOMEM; 2272 goto free_eth_finfo; 2273 } 2274 2275 eth_filter->port[i].bmap = bitmap_zalloc(nentries, GFP_KERNEL); 2276 if (!eth_filter->port[i].bmap) { 2277 ret = -ENOMEM; 2278 goto free_eth_finfo; 2279 } 2280 } 2281 2282 adap->ethtool_filters = eth_filter; 2283 return 0; 2284 2285free_eth_finfo: 2286 while (i-- > 0) { 2287 bitmap_free(eth_filter->port[i].bmap); 2288 kvfree(eth_filter->port[i].loc_array); 2289 } 2290 kfree(eth_filter_info); 2291 2292free_eth_filter: 2293 kfree(eth_filter); 2294 2295 return ret; 2296} 2297 2298void cxgb4_set_ethtool_ops(struct net_device *netdev) 2299{ 2300 netdev->ethtool_ops = &cxgb_ethtool_ops; 2301} 2302