1 /* 2 * Copyright (C) 2013-2015 Chelsio Communications. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * The full GNU General Public License is included in this distribution in 14 * the file called "COPYING". 15 * 16 */ 17 18 #include <linux/firmware.h> 19 #include <linux/mdio.h> 20 21 #include "cxgb4.h" 22 #include "t4_regs.h" 23 #include "t4fw_api.h" 24 25 #define EEPROM_MAGIC 0x38E2F10C 26 27 static u32 get_msglevel(struct net_device *dev) 28 { 29 return netdev2adap(dev)->msg_enable; 30 } 31 32 static void set_msglevel(struct net_device *dev, u32 val) 33 { 34 netdev2adap(dev)->msg_enable = val; 35 } 36 37 static const char stats_strings[][ETH_GSTRING_LEN] = { 38 "TxOctetsOK ", 39 "TxFramesOK ", 40 "TxBroadcastFrames ", 41 "TxMulticastFrames ", 42 "TxUnicastFrames ", 43 "TxErrorFrames ", 44 45 "TxFrames64 ", 46 "TxFrames65To127 ", 47 "TxFrames128To255 ", 48 "TxFrames256To511 ", 49 "TxFrames512To1023 ", 50 "TxFrames1024To1518 ", 51 "TxFrames1519ToMax ", 52 53 "TxFramesDropped ", 54 "TxPauseFrames ", 55 "TxPPP0Frames ", 56 "TxPPP1Frames ", 57 "TxPPP2Frames ", 58 "TxPPP3Frames ", 59 "TxPPP4Frames ", 60 "TxPPP5Frames ", 61 "TxPPP6Frames ", 62 "TxPPP7Frames ", 63 64 "RxOctetsOK ", 65 "RxFramesOK ", 66 "RxBroadcastFrames ", 67 "RxMulticastFrames ", 68 "RxUnicastFrames ", 69 70 "RxFramesTooLong ", 71 "RxJabberErrors ", 72 "RxFCSErrors ", 73 "RxLengthErrors ", 74 "RxSymbolErrors ", 75 "RxRuntFrames ", 76 77 "RxFrames64 ", 78 "RxFrames65To127 ", 79 "RxFrames128To255 ", 80 "RxFrames256To511 ", 81 "RxFrames512To1023 ", 82 "RxFrames1024To1518 ", 83 "RxFrames1519ToMax ", 84 85 "RxPauseFrames ", 86 "RxPPP0Frames ", 87 "RxPPP1Frames ", 88 "RxPPP2Frames ", 89 "RxPPP3Frames ", 90 "RxPPP4Frames ", 91 "RxPPP5Frames ", 92 "RxPPP6Frames ", 93 "RxPPP7Frames ", 94 95 "RxBG0FramesDropped ", 96 "RxBG1FramesDropped ", 97 "RxBG2FramesDropped ", 98 "RxBG3FramesDropped ", 99 "RxBG0FramesTrunc ", 100 "RxBG1FramesTrunc ", 101 "RxBG2FramesTrunc ", 102 "RxBG3FramesTrunc ", 103 104 "TSO ", 105 "TxCsumOffload ", 106 "RxCsumGood ", 107 "VLANextractions ", 108 "VLANinsertions ", 109 "GROpackets ", 110 "GROmerged ", 111 "WriteCoalSuccess ", 112 "WriteCoalFail ", 113 }; 114 115 static int get_sset_count(struct net_device *dev, int sset) 116 { 117 switch (sset) { 118 case ETH_SS_STATS: 119 return ARRAY_SIZE(stats_strings); 120 default: 121 return -EOPNOTSUPP; 122 } 123 } 124 125 static int get_regs_len(struct net_device *dev) 126 { 127 struct adapter *adap = netdev2adap(dev); 128 129 return t4_get_regs_len(adap); 130 } 131 132 static int get_eeprom_len(struct net_device *dev) 133 { 134 return EEPROMSIZE; 135 } 136 137 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 138 { 139 struct adapter *adapter = netdev2adap(dev); 140 u32 exprom_vers; 141 142 strlcpy(info->driver, cxgb4_driver_name, sizeof(info->driver)); 143 strlcpy(info->version, cxgb4_driver_version, 144 sizeof(info->version)); 145 strlcpy(info->bus_info, pci_name(adapter->pdev), 146 sizeof(info->bus_info)); 147 148 if (adapter->params.fw_vers) 149 snprintf(info->fw_version, sizeof(info->fw_version), 150 "%u.%u.%u.%u, TP %u.%u.%u.%u", 151 FW_HDR_FW_VER_MAJOR_G(adapter->params.fw_vers), 152 FW_HDR_FW_VER_MINOR_G(adapter->params.fw_vers), 153 FW_HDR_FW_VER_MICRO_G(adapter->params.fw_vers), 154 FW_HDR_FW_VER_BUILD_G(adapter->params.fw_vers), 155 FW_HDR_FW_VER_MAJOR_G(adapter->params.tp_vers), 156 FW_HDR_FW_VER_MINOR_G(adapter->params.tp_vers), 157 FW_HDR_FW_VER_MICRO_G(adapter->params.tp_vers), 158 FW_HDR_FW_VER_BUILD_G(adapter->params.tp_vers)); 159 160 if (!t4_get_exprom_version(adapter, &exprom_vers)) 161 snprintf(info->erom_version, sizeof(info->erom_version), 162 "%u.%u.%u.%u", 163 FW_HDR_FW_VER_MAJOR_G(exprom_vers), 164 FW_HDR_FW_VER_MINOR_G(exprom_vers), 165 FW_HDR_FW_VER_MICRO_G(exprom_vers), 166 FW_HDR_FW_VER_BUILD_G(exprom_vers)); 167 } 168 169 static void get_strings(struct net_device *dev, u32 stringset, u8 *data) 170 { 171 if (stringset == ETH_SS_STATS) 172 memcpy(data, stats_strings, sizeof(stats_strings)); 173 } 174 175 /* port stats maintained per queue of the port. They should be in the same 176 * order as in stats_strings above. 177 */ 178 struct queue_port_stats { 179 u64 tso; 180 u64 tx_csum; 181 u64 rx_csum; 182 u64 vlan_ex; 183 u64 vlan_ins; 184 u64 gro_pkts; 185 u64 gro_merged; 186 }; 187 188 static void collect_sge_port_stats(const struct adapter *adap, 189 const struct port_info *p, 190 struct queue_port_stats *s) 191 { 192 int i; 193 const struct sge_eth_txq *tx = &adap->sge.ethtxq[p->first_qset]; 194 const struct sge_eth_rxq *rx = &adap->sge.ethrxq[p->first_qset]; 195 196 memset(s, 0, sizeof(*s)); 197 for (i = 0; i < p->nqsets; i++, rx++, tx++) { 198 s->tso += tx->tso; 199 s->tx_csum += tx->tx_cso; 200 s->rx_csum += rx->stats.rx_cso; 201 s->vlan_ex += rx->stats.vlan_ex; 202 s->vlan_ins += tx->vlan_ins; 203 s->gro_pkts += rx->stats.lro_pkts; 204 s->gro_merged += rx->stats.lro_merged; 205 } 206 } 207 208 static void get_stats(struct net_device *dev, struct ethtool_stats *stats, 209 u64 *data) 210 { 211 struct port_info *pi = netdev_priv(dev); 212 struct adapter *adapter = pi->adapter; 213 u32 val1, val2; 214 215 t4_get_port_stats(adapter, pi->tx_chan, (struct port_stats *)data); 216 217 data += sizeof(struct port_stats) / sizeof(u64); 218 collect_sge_port_stats(adapter, pi, (struct queue_port_stats *)data); 219 data += sizeof(struct queue_port_stats) / sizeof(u64); 220 if (!is_t4(adapter->params.chip)) { 221 t4_write_reg(adapter, SGE_STAT_CFG_A, STATSOURCE_T5_V(7)); 222 val1 = t4_read_reg(adapter, SGE_STAT_TOTAL_A); 223 val2 = t4_read_reg(adapter, SGE_STAT_MATCH_A); 224 *data = val1 - val2; 225 data++; 226 *data = val2; 227 data++; 228 } else { 229 memset(data, 0, 2 * sizeof(u64)); 230 *data += 2; 231 } 232 } 233 234 static void get_regs(struct net_device *dev, struct ethtool_regs *regs, 235 void *buf) 236 { 237 struct adapter *adap = netdev2adap(dev); 238 size_t buf_size; 239 240 buf_size = t4_get_regs_len(adap); 241 regs->version = mk_adap_vers(adap); 242 t4_get_regs(adap, buf, buf_size); 243 } 244 245 static int restart_autoneg(struct net_device *dev) 246 { 247 struct port_info *p = netdev_priv(dev); 248 249 if (!netif_running(dev)) 250 return -EAGAIN; 251 if (p->link_cfg.autoneg != AUTONEG_ENABLE) 252 return -EINVAL; 253 t4_restart_aneg(p->adapter, p->adapter->fn, p->tx_chan); 254 return 0; 255 } 256 257 static int identify_port(struct net_device *dev, 258 enum ethtool_phys_id_state state) 259 { 260 unsigned int val; 261 struct adapter *adap = netdev2adap(dev); 262 263 if (state == ETHTOOL_ID_ACTIVE) 264 val = 0xffff; 265 else if (state == ETHTOOL_ID_INACTIVE) 266 val = 0; 267 else 268 return -EINVAL; 269 270 return t4_identify_port(adap, adap->fn, netdev2pinfo(dev)->viid, val); 271 } 272 273 static unsigned int from_fw_linkcaps(enum fw_port_type type, unsigned int caps) 274 { 275 unsigned int v = 0; 276 277 if (type == FW_PORT_TYPE_BT_SGMII || type == FW_PORT_TYPE_BT_XFI || 278 type == FW_PORT_TYPE_BT_XAUI) { 279 v |= SUPPORTED_TP; 280 if (caps & FW_PORT_CAP_SPEED_100M) 281 v |= SUPPORTED_100baseT_Full; 282 if (caps & FW_PORT_CAP_SPEED_1G) 283 v |= SUPPORTED_1000baseT_Full; 284 if (caps & FW_PORT_CAP_SPEED_10G) 285 v |= SUPPORTED_10000baseT_Full; 286 } else if (type == FW_PORT_TYPE_KX4 || type == FW_PORT_TYPE_KX) { 287 v |= SUPPORTED_Backplane; 288 if (caps & FW_PORT_CAP_SPEED_1G) 289 v |= SUPPORTED_1000baseKX_Full; 290 if (caps & FW_PORT_CAP_SPEED_10G) 291 v |= SUPPORTED_10000baseKX4_Full; 292 } else if (type == FW_PORT_TYPE_KR) { 293 v |= SUPPORTED_Backplane | SUPPORTED_10000baseKR_Full; 294 } else if (type == FW_PORT_TYPE_BP_AP) { 295 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC | 296 SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full; 297 } else if (type == FW_PORT_TYPE_BP4_AP) { 298 v |= SUPPORTED_Backplane | SUPPORTED_10000baseR_FEC | 299 SUPPORTED_10000baseKR_Full | SUPPORTED_1000baseKX_Full | 300 SUPPORTED_10000baseKX4_Full; 301 } else if (type == FW_PORT_TYPE_FIBER_XFI || 302 type == FW_PORT_TYPE_FIBER_XAUI || 303 type == FW_PORT_TYPE_SFP || 304 type == FW_PORT_TYPE_QSFP_10G || 305 type == FW_PORT_TYPE_QSA) { 306 v |= SUPPORTED_FIBRE; 307 if (caps & FW_PORT_CAP_SPEED_1G) 308 v |= SUPPORTED_1000baseT_Full; 309 if (caps & FW_PORT_CAP_SPEED_10G) 310 v |= SUPPORTED_10000baseT_Full; 311 } else if (type == FW_PORT_TYPE_BP40_BA || 312 type == FW_PORT_TYPE_QSFP) { 313 v |= SUPPORTED_40000baseSR4_Full; 314 v |= SUPPORTED_FIBRE; 315 } 316 317 if (caps & FW_PORT_CAP_ANEG) 318 v |= SUPPORTED_Autoneg; 319 return v; 320 } 321 322 static unsigned int to_fw_linkcaps(unsigned int caps) 323 { 324 unsigned int v = 0; 325 326 if (caps & ADVERTISED_100baseT_Full) 327 v |= FW_PORT_CAP_SPEED_100M; 328 if (caps & ADVERTISED_1000baseT_Full) 329 v |= FW_PORT_CAP_SPEED_1G; 330 if (caps & ADVERTISED_10000baseT_Full) 331 v |= FW_PORT_CAP_SPEED_10G; 332 if (caps & ADVERTISED_40000baseSR4_Full) 333 v |= FW_PORT_CAP_SPEED_40G; 334 return v; 335 } 336 337 static int get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 338 { 339 const struct port_info *p = netdev_priv(dev); 340 341 if (p->port_type == FW_PORT_TYPE_BT_SGMII || 342 p->port_type == FW_PORT_TYPE_BT_XFI || 343 p->port_type == FW_PORT_TYPE_BT_XAUI) { 344 cmd->port = PORT_TP; 345 } else if (p->port_type == FW_PORT_TYPE_FIBER_XFI || 346 p->port_type == FW_PORT_TYPE_FIBER_XAUI) { 347 cmd->port = PORT_FIBRE; 348 } else if (p->port_type == FW_PORT_TYPE_SFP || 349 p->port_type == FW_PORT_TYPE_QSFP_10G || 350 p->port_type == FW_PORT_TYPE_QSA || 351 p->port_type == FW_PORT_TYPE_QSFP) { 352 if (p->mod_type == FW_PORT_MOD_TYPE_LR || 353 p->mod_type == FW_PORT_MOD_TYPE_SR || 354 p->mod_type == FW_PORT_MOD_TYPE_ER || 355 p->mod_type == FW_PORT_MOD_TYPE_LRM) 356 cmd->port = PORT_FIBRE; 357 else if (p->mod_type == FW_PORT_MOD_TYPE_TWINAX_PASSIVE || 358 p->mod_type == FW_PORT_MOD_TYPE_TWINAX_ACTIVE) 359 cmd->port = PORT_DA; 360 else 361 cmd->port = PORT_OTHER; 362 } else { 363 cmd->port = PORT_OTHER; 364 } 365 366 if (p->mdio_addr >= 0) { 367 cmd->phy_address = p->mdio_addr; 368 cmd->transceiver = XCVR_EXTERNAL; 369 cmd->mdio_support = p->port_type == FW_PORT_TYPE_BT_SGMII ? 370 MDIO_SUPPORTS_C22 : MDIO_SUPPORTS_C45; 371 } else { 372 cmd->phy_address = 0; /* not really, but no better option */ 373 cmd->transceiver = XCVR_INTERNAL; 374 cmd->mdio_support = 0; 375 } 376 377 cmd->supported = from_fw_linkcaps(p->port_type, p->link_cfg.supported); 378 cmd->advertising = from_fw_linkcaps(p->port_type, 379 p->link_cfg.advertising); 380 ethtool_cmd_speed_set(cmd, 381 netif_carrier_ok(dev) ? p->link_cfg.speed : 0); 382 cmd->duplex = DUPLEX_FULL; 383 cmd->autoneg = p->link_cfg.autoneg; 384 cmd->maxtxpkt = 0; 385 cmd->maxrxpkt = 0; 386 return 0; 387 } 388 389 static unsigned int speed_to_caps(int speed) 390 { 391 if (speed == 100) 392 return FW_PORT_CAP_SPEED_100M; 393 if (speed == 1000) 394 return FW_PORT_CAP_SPEED_1G; 395 if (speed == 10000) 396 return FW_PORT_CAP_SPEED_10G; 397 if (speed == 40000) 398 return FW_PORT_CAP_SPEED_40G; 399 return 0; 400 } 401 402 static int set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 403 { 404 unsigned int cap; 405 struct port_info *p = netdev_priv(dev); 406 struct link_config *lc = &p->link_cfg; 407 u32 speed = ethtool_cmd_speed(cmd); 408 409 if (cmd->duplex != DUPLEX_FULL) /* only full-duplex supported */ 410 return -EINVAL; 411 412 if (!(lc->supported & FW_PORT_CAP_ANEG)) { 413 /* PHY offers a single speed. See if that's what's 414 * being requested. 415 */ 416 if (cmd->autoneg == AUTONEG_DISABLE && 417 (lc->supported & speed_to_caps(speed))) 418 return 0; 419 return -EINVAL; 420 } 421 422 if (cmd->autoneg == AUTONEG_DISABLE) { 423 cap = speed_to_caps(speed); 424 425 if (!(lc->supported & cap) || 426 (speed == 1000) || 427 (speed == 10000) || 428 (speed == 40000)) 429 return -EINVAL; 430 lc->requested_speed = cap; 431 lc->advertising = 0; 432 } else { 433 cap = to_fw_linkcaps(cmd->advertising); 434 if (!(lc->supported & cap)) 435 return -EINVAL; 436 lc->requested_speed = 0; 437 lc->advertising = cap | FW_PORT_CAP_ANEG; 438 } 439 lc->autoneg = cmd->autoneg; 440 441 if (netif_running(dev)) 442 return t4_link_start(p->adapter, p->adapter->fn, p->tx_chan, 443 lc); 444 return 0; 445 } 446 447 static void get_pauseparam(struct net_device *dev, 448 struct ethtool_pauseparam *epause) 449 { 450 struct port_info *p = netdev_priv(dev); 451 452 epause->autoneg = (p->link_cfg.requested_fc & PAUSE_AUTONEG) != 0; 453 epause->rx_pause = (p->link_cfg.fc & PAUSE_RX) != 0; 454 epause->tx_pause = (p->link_cfg.fc & PAUSE_TX) != 0; 455 } 456 457 static int set_pauseparam(struct net_device *dev, 458 struct ethtool_pauseparam *epause) 459 { 460 struct port_info *p = netdev_priv(dev); 461 struct link_config *lc = &p->link_cfg; 462 463 if (epause->autoneg == AUTONEG_DISABLE) 464 lc->requested_fc = 0; 465 else if (lc->supported & FW_PORT_CAP_ANEG) 466 lc->requested_fc = PAUSE_AUTONEG; 467 else 468 return -EINVAL; 469 470 if (epause->rx_pause) 471 lc->requested_fc |= PAUSE_RX; 472 if (epause->tx_pause) 473 lc->requested_fc |= PAUSE_TX; 474 if (netif_running(dev)) 475 return t4_link_start(p->adapter, p->adapter->fn, p->tx_chan, 476 lc); 477 return 0; 478 } 479 480 static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e) 481 { 482 const struct port_info *pi = netdev_priv(dev); 483 const struct sge *s = &pi->adapter->sge; 484 485 e->rx_max_pending = MAX_RX_BUFFERS; 486 e->rx_mini_max_pending = MAX_RSPQ_ENTRIES; 487 e->rx_jumbo_max_pending = 0; 488 e->tx_max_pending = MAX_TXQ_ENTRIES; 489 490 e->rx_pending = s->ethrxq[pi->first_qset].fl.size - 8; 491 e->rx_mini_pending = s->ethrxq[pi->first_qset].rspq.size; 492 e->rx_jumbo_pending = 0; 493 e->tx_pending = s->ethtxq[pi->first_qset].q.size; 494 } 495 496 static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e) 497 { 498 int i; 499 const struct port_info *pi = netdev_priv(dev); 500 struct adapter *adapter = pi->adapter; 501 struct sge *s = &adapter->sge; 502 503 if (e->rx_pending > MAX_RX_BUFFERS || e->rx_jumbo_pending || 504 e->tx_pending > MAX_TXQ_ENTRIES || 505 e->rx_mini_pending > MAX_RSPQ_ENTRIES || 506 e->rx_mini_pending < MIN_RSPQ_ENTRIES || 507 e->rx_pending < MIN_FL_ENTRIES || e->tx_pending < MIN_TXQ_ENTRIES) 508 return -EINVAL; 509 510 if (adapter->flags & FULL_INIT_DONE) 511 return -EBUSY; 512 513 for (i = 0; i < pi->nqsets; ++i) { 514 s->ethtxq[pi->first_qset + i].q.size = e->tx_pending; 515 s->ethrxq[pi->first_qset + i].fl.size = e->rx_pending + 8; 516 s->ethrxq[pi->first_qset + i].rspq.size = e->rx_mini_pending; 517 } 518 return 0; 519 } 520 521 /** 522 * set_rx_intr_params - set a net devices's RX interrupt holdoff paramete! 523 * @dev: the network device 524 * @us: the hold-off time in us, or 0 to disable timer 525 * @cnt: the hold-off packet count, or 0 to disable counter 526 * 527 * Set the RX interrupt hold-off parameters for a network device. 528 */ 529 static int set_rx_intr_params(struct net_device *dev, 530 unsigned int us, unsigned int cnt) 531 { 532 int i, err; 533 struct port_info *pi = netdev_priv(dev); 534 struct adapter *adap = pi->adapter; 535 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 536 537 for (i = 0; i < pi->nqsets; i++, q++) { 538 err = cxgb4_set_rspq_intr_params(&q->rspq, us, cnt); 539 if (err) 540 return err; 541 } 542 return 0; 543 } 544 545 static int set_adaptive_rx_setting(struct net_device *dev, int adaptive_rx) 546 { 547 int i; 548 struct port_info *pi = netdev_priv(dev); 549 struct adapter *adap = pi->adapter; 550 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 551 552 for (i = 0; i < pi->nqsets; i++, q++) 553 q->rspq.adaptive_rx = adaptive_rx; 554 555 return 0; 556 } 557 558 static int get_adaptive_rx_setting(struct net_device *dev) 559 { 560 struct port_info *pi = netdev_priv(dev); 561 struct adapter *adap = pi->adapter; 562 struct sge_eth_rxq *q = &adap->sge.ethrxq[pi->first_qset]; 563 564 return q->rspq.adaptive_rx; 565 } 566 567 static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c) 568 { 569 set_adaptive_rx_setting(dev, c->use_adaptive_rx_coalesce); 570 return set_rx_intr_params(dev, c->rx_coalesce_usecs, 571 c->rx_max_coalesced_frames); 572 } 573 574 static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c) 575 { 576 const struct port_info *pi = netdev_priv(dev); 577 const struct adapter *adap = pi->adapter; 578 const struct sge_rspq *rq = &adap->sge.ethrxq[pi->first_qset].rspq; 579 580 c->rx_coalesce_usecs = qtimer_val(adap, rq); 581 c->rx_max_coalesced_frames = (rq->intr_params & QINTR_CNT_EN) ? 582 adap->sge.counter_val[rq->pktcnt_idx] : 0; 583 c->use_adaptive_rx_coalesce = get_adaptive_rx_setting(dev); 584 return 0; 585 } 586 587 /** 588 * eeprom_ptov - translate a physical EEPROM address to virtual 589 * @phys_addr: the physical EEPROM address 590 * @fn: the PCI function number 591 * @sz: size of function-specific area 592 * 593 * Translate a physical EEPROM address to virtual. The first 1K is 594 * accessed through virtual addresses starting at 31K, the rest is 595 * accessed through virtual addresses starting at 0. 596 * 597 * The mapping is as follows: 598 * [0..1K) -> [31K..32K) 599 * [1K..1K+A) -> [31K-A..31K) 600 * [1K+A..ES) -> [0..ES-A-1K) 601 * 602 * where A = @fn * @sz, and ES = EEPROM size. 603 */ 604 static int eeprom_ptov(unsigned int phys_addr, unsigned int fn, unsigned int sz) 605 { 606 fn *= sz; 607 if (phys_addr < 1024) 608 return phys_addr + (31 << 10); 609 if (phys_addr < 1024 + fn) 610 return 31744 - fn + phys_addr - 1024; 611 if (phys_addr < EEPROMSIZE) 612 return phys_addr - 1024 - fn; 613 return -EINVAL; 614 } 615 616 /* The next two routines implement eeprom read/write from physical addresses. 617 */ 618 static int eeprom_rd_phys(struct adapter *adap, unsigned int phys_addr, u32 *v) 619 { 620 int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE); 621 622 if (vaddr >= 0) 623 vaddr = pci_read_vpd(adap->pdev, vaddr, sizeof(u32), v); 624 return vaddr < 0 ? vaddr : 0; 625 } 626 627 static int eeprom_wr_phys(struct adapter *adap, unsigned int phys_addr, u32 v) 628 { 629 int vaddr = eeprom_ptov(phys_addr, adap->fn, EEPROMPFSIZE); 630 631 if (vaddr >= 0) 632 vaddr = pci_write_vpd(adap->pdev, vaddr, sizeof(u32), &v); 633 return vaddr < 0 ? vaddr : 0; 634 } 635 636 #define EEPROM_MAGIC 0x38E2F10C 637 638 static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e, 639 u8 *data) 640 { 641 int i, err = 0; 642 struct adapter *adapter = netdev2adap(dev); 643 u8 *buf = kmalloc(EEPROMSIZE, GFP_KERNEL); 644 645 if (!buf) 646 return -ENOMEM; 647 648 e->magic = EEPROM_MAGIC; 649 for (i = e->offset & ~3; !err && i < e->offset + e->len; i += 4) 650 err = eeprom_rd_phys(adapter, i, (u32 *)&buf[i]); 651 652 if (!err) 653 memcpy(data, buf + e->offset, e->len); 654 kfree(buf); 655 return err; 656 } 657 658 static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom, 659 u8 *data) 660 { 661 u8 *buf; 662 int err = 0; 663 u32 aligned_offset, aligned_len, *p; 664 struct adapter *adapter = netdev2adap(dev); 665 666 if (eeprom->magic != EEPROM_MAGIC) 667 return -EINVAL; 668 669 aligned_offset = eeprom->offset & ~3; 670 aligned_len = (eeprom->len + (eeprom->offset & 3) + 3) & ~3; 671 672 if (adapter->fn > 0) { 673 u32 start = 1024 + adapter->fn * EEPROMPFSIZE; 674 675 if (aligned_offset < start || 676 aligned_offset + aligned_len > start + EEPROMPFSIZE) 677 return -EPERM; 678 } 679 680 if (aligned_offset != eeprom->offset || aligned_len != eeprom->len) { 681 /* RMW possibly needed for first or last words. 682 */ 683 buf = kmalloc(aligned_len, GFP_KERNEL); 684 if (!buf) 685 return -ENOMEM; 686 err = eeprom_rd_phys(adapter, aligned_offset, (u32 *)buf); 687 if (!err && aligned_len > 4) 688 err = eeprom_rd_phys(adapter, 689 aligned_offset + aligned_len - 4, 690 (u32 *)&buf[aligned_len - 4]); 691 if (err) 692 goto out; 693 memcpy(buf + (eeprom->offset & 3), data, eeprom->len); 694 } else { 695 buf = data; 696 } 697 698 err = t4_seeprom_wp(adapter, false); 699 if (err) 700 goto out; 701 702 for (p = (u32 *)buf; !err && aligned_len; aligned_len -= 4, p++) { 703 err = eeprom_wr_phys(adapter, aligned_offset, *p); 704 aligned_offset += 4; 705 } 706 707 if (!err) 708 err = t4_seeprom_wp(adapter, true); 709 out: 710 if (buf != data) 711 kfree(buf); 712 return err; 713 } 714 715 static int set_flash(struct net_device *netdev, struct ethtool_flash *ef) 716 { 717 int ret; 718 const struct firmware *fw; 719 struct adapter *adap = netdev2adap(netdev); 720 unsigned int mbox = PCIE_FW_MASTER_M + 1; 721 722 ef->data[sizeof(ef->data) - 1] = '\0'; 723 ret = request_firmware(&fw, ef->data, adap->pdev_dev); 724 if (ret < 0) 725 return ret; 726 727 /* If the adapter has been fully initialized then we'll go ahead and 728 * try to get the firmware's cooperation in upgrading to the new 729 * firmware image otherwise we'll try to do the entire job from the 730 * host ... and we always "force" the operation in this path. 731 */ 732 if (adap->flags & FULL_INIT_DONE) 733 mbox = adap->mbox; 734 735 ret = t4_fw_upgrade(adap, mbox, fw->data, fw->size, 1); 736 release_firmware(fw); 737 if (!ret) 738 dev_info(adap->pdev_dev, 739 "loaded firmware %s, reload cxgb4 driver\n", ef->data); 740 return ret; 741 } 742 743 #define WOL_SUPPORTED (WAKE_BCAST | WAKE_MAGIC) 744 #define BCAST_CRC 0xa0ccc1a6 745 746 static void get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 747 { 748 wol->supported = WAKE_BCAST | WAKE_MAGIC; 749 wol->wolopts = netdev2adap(dev)->wol; 750 memset(&wol->sopass, 0, sizeof(wol->sopass)); 751 } 752 753 static int set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 754 { 755 int err = 0; 756 struct port_info *pi = netdev_priv(dev); 757 758 if (wol->wolopts & ~WOL_SUPPORTED) 759 return -EINVAL; 760 t4_wol_magic_enable(pi->adapter, pi->tx_chan, 761 (wol->wolopts & WAKE_MAGIC) ? dev->dev_addr : NULL); 762 if (wol->wolopts & WAKE_BCAST) { 763 err = t4_wol_pat_enable(pi->adapter, pi->tx_chan, 0xfe, ~0ULL, 764 ~0ULL, 0, false); 765 if (!err) 766 err = t4_wol_pat_enable(pi->adapter, pi->tx_chan, 1, 767 ~6ULL, ~0ULL, BCAST_CRC, true); 768 } else { 769 t4_wol_pat_enable(pi->adapter, pi->tx_chan, 0, 0, 0, 0, false); 770 } 771 return err; 772 } 773 774 static u32 get_rss_table_size(struct net_device *dev) 775 { 776 const struct port_info *pi = netdev_priv(dev); 777 778 return pi->rss_size; 779 } 780 781 static int get_rss_table(struct net_device *dev, u32 *p, u8 *key, u8 *hfunc) 782 { 783 const struct port_info *pi = netdev_priv(dev); 784 unsigned int n = pi->rss_size; 785 786 if (hfunc) 787 *hfunc = ETH_RSS_HASH_TOP; 788 if (!p) 789 return 0; 790 while (n--) 791 p[n] = pi->rss[n]; 792 return 0; 793 } 794 795 static int set_rss_table(struct net_device *dev, const u32 *p, const u8 *key, 796 const u8 hfunc) 797 { 798 unsigned int i; 799 struct port_info *pi = netdev_priv(dev); 800 801 /* We require at least one supported parameter to be changed and no 802 * change in any of the unsupported parameters 803 */ 804 if (key || 805 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)) 806 return -EOPNOTSUPP; 807 if (!p) 808 return 0; 809 810 for (i = 0; i < pi->rss_size; i++) 811 pi->rss[i] = p[i]; 812 if (pi->adapter->flags & FULL_INIT_DONE) 813 return cxgb4_write_rss(pi, pi->rss); 814 return 0; 815 } 816 817 static int get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *info, 818 u32 *rules) 819 { 820 const struct port_info *pi = netdev_priv(dev); 821 822 switch (info->cmd) { 823 case ETHTOOL_GRXFH: { 824 unsigned int v = pi->rss_mode; 825 826 info->data = 0; 827 switch (info->flow_type) { 828 case TCP_V4_FLOW: 829 if (v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) 830 info->data = RXH_IP_SRC | RXH_IP_DST | 831 RXH_L4_B_0_1 | RXH_L4_B_2_3; 832 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 833 info->data = RXH_IP_SRC | RXH_IP_DST; 834 break; 835 case UDP_V4_FLOW: 836 if ((v & FW_RSS_VI_CONFIG_CMD_IP4FOURTUPEN_F) && 837 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F)) 838 info->data = RXH_IP_SRC | RXH_IP_DST | 839 RXH_L4_B_0_1 | RXH_L4_B_2_3; 840 else if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 841 info->data = RXH_IP_SRC | RXH_IP_DST; 842 break; 843 case SCTP_V4_FLOW: 844 case AH_ESP_V4_FLOW: 845 case IPV4_FLOW: 846 if (v & FW_RSS_VI_CONFIG_CMD_IP4TWOTUPEN_F) 847 info->data = RXH_IP_SRC | RXH_IP_DST; 848 break; 849 case TCP_V6_FLOW: 850 if (v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) 851 info->data = RXH_IP_SRC | RXH_IP_DST | 852 RXH_L4_B_0_1 | RXH_L4_B_2_3; 853 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 854 info->data = RXH_IP_SRC | RXH_IP_DST; 855 break; 856 case UDP_V6_FLOW: 857 if ((v & FW_RSS_VI_CONFIG_CMD_IP6FOURTUPEN_F) && 858 (v & FW_RSS_VI_CONFIG_CMD_UDPEN_F)) 859 info->data = RXH_IP_SRC | RXH_IP_DST | 860 RXH_L4_B_0_1 | RXH_L4_B_2_3; 861 else if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 862 info->data = RXH_IP_SRC | RXH_IP_DST; 863 break; 864 case SCTP_V6_FLOW: 865 case AH_ESP_V6_FLOW: 866 case IPV6_FLOW: 867 if (v & FW_RSS_VI_CONFIG_CMD_IP6TWOTUPEN_F) 868 info->data = RXH_IP_SRC | RXH_IP_DST; 869 break; 870 } 871 return 0; 872 } 873 case ETHTOOL_GRXRINGS: 874 info->data = pi->nqsets; 875 return 0; 876 } 877 return -EOPNOTSUPP; 878 } 879 880 static const struct ethtool_ops cxgb_ethtool_ops = { 881 .get_settings = get_settings, 882 .set_settings = set_settings, 883 .get_drvinfo = get_drvinfo, 884 .get_msglevel = get_msglevel, 885 .set_msglevel = set_msglevel, 886 .get_ringparam = get_sge_param, 887 .set_ringparam = set_sge_param, 888 .get_coalesce = get_coalesce, 889 .set_coalesce = set_coalesce, 890 .get_eeprom_len = get_eeprom_len, 891 .get_eeprom = get_eeprom, 892 .set_eeprom = set_eeprom, 893 .get_pauseparam = get_pauseparam, 894 .set_pauseparam = set_pauseparam, 895 .get_link = ethtool_op_get_link, 896 .get_strings = get_strings, 897 .set_phys_id = identify_port, 898 .nway_reset = restart_autoneg, 899 .get_sset_count = get_sset_count, 900 .get_ethtool_stats = get_stats, 901 .get_regs_len = get_regs_len, 902 .get_regs = get_regs, 903 .get_wol = get_wol, 904 .set_wol = set_wol, 905 .get_rxnfc = get_rxnfc, 906 .get_rxfh_indir_size = get_rss_table_size, 907 .get_rxfh = get_rss_table, 908 .set_rxfh = set_rss_table, 909 .flash_device = set_flash, 910 }; 911 912 void cxgb4_set_ethtool_ops(struct net_device *netdev) 913 { 914 netdev->ethtool_ops = &cxgb_ethtool_ops; 915 } 916