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