1 /******************************************************************************* 2 * 3 * Intel Ethernet Controller XL710 Family Linux Driver 4 * Copyright(c) 2013 Intel Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License along with 16 * this program; if not, write to the Free Software Foundation, Inc., 17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * The full GNU General Public License is included in this distribution in 20 * the file called "COPYING". 21 * 22 * Contact Information: 23 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 24 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 25 * 26 ******************************************************************************/ 27 28 /* ethtool support for i40e */ 29 30 #include "i40e.h" 31 #include "i40e_diag.h" 32 33 struct i40e_stats { 34 char stat_string[ETH_GSTRING_LEN]; 35 int sizeof_stat; 36 int stat_offset; 37 }; 38 39 #define I40E_STAT(_type, _name, _stat) { \ 40 .stat_string = _name, \ 41 .sizeof_stat = FIELD_SIZEOF(_type, _stat), \ 42 .stat_offset = offsetof(_type, _stat) \ 43 } 44 #define I40E_NETDEV_STAT(_net_stat) \ 45 I40E_STAT(struct net_device_stats, #_net_stat, _net_stat) 46 #define I40E_PF_STAT(_name, _stat) \ 47 I40E_STAT(struct i40e_pf, _name, _stat) 48 #define I40E_VSI_STAT(_name, _stat) \ 49 I40E_STAT(struct i40e_vsi, _name, _stat) 50 51 static const struct i40e_stats i40e_gstrings_net_stats[] = { 52 I40E_NETDEV_STAT(rx_packets), 53 I40E_NETDEV_STAT(tx_packets), 54 I40E_NETDEV_STAT(rx_bytes), 55 I40E_NETDEV_STAT(tx_bytes), 56 I40E_NETDEV_STAT(rx_errors), 57 I40E_NETDEV_STAT(tx_errors), 58 I40E_NETDEV_STAT(rx_dropped), 59 I40E_NETDEV_STAT(tx_dropped), 60 I40E_NETDEV_STAT(multicast), 61 I40E_NETDEV_STAT(collisions), 62 I40E_NETDEV_STAT(rx_length_errors), 63 I40E_NETDEV_STAT(rx_crc_errors), 64 }; 65 66 /* These PF_STATs might look like duplicates of some NETDEV_STATs, 67 * but they are separate. This device supports Virtualization, and 68 * as such might have several netdevs supporting VMDq and FCoE going 69 * through a single port. The NETDEV_STATs are for individual netdevs 70 * seen at the top of the stack, and the PF_STATs are for the physical 71 * function at the bottom of the stack hosting those netdevs. 72 * 73 * The PF_STATs are appended to the netdev stats only when ethtool -S 74 * is queried on the base PF netdev, not on the VMDq or FCoE netdev. 75 */ 76 static struct i40e_stats i40e_gstrings_stats[] = { 77 I40E_PF_STAT("rx_bytes", stats.eth.rx_bytes), 78 I40E_PF_STAT("tx_bytes", stats.eth.tx_bytes), 79 I40E_PF_STAT("rx_errors", stats.eth.rx_errors), 80 I40E_PF_STAT("tx_errors", stats.eth.tx_errors), 81 I40E_PF_STAT("rx_dropped", stats.eth.rx_discards), 82 I40E_PF_STAT("tx_dropped", stats.eth.tx_discards), 83 I40E_PF_STAT("tx_dropped_link_down", stats.tx_dropped_link_down), 84 I40E_PF_STAT("crc_errors", stats.crc_errors), 85 I40E_PF_STAT("illegal_bytes", stats.illegal_bytes), 86 I40E_PF_STAT("mac_local_faults", stats.mac_local_faults), 87 I40E_PF_STAT("mac_remote_faults", stats.mac_remote_faults), 88 I40E_PF_STAT("rx_length_errors", stats.rx_length_errors), 89 I40E_PF_STAT("link_xon_rx", stats.link_xon_rx), 90 I40E_PF_STAT("link_xoff_rx", stats.link_xoff_rx), 91 I40E_PF_STAT("link_xon_tx", stats.link_xon_tx), 92 I40E_PF_STAT("link_xoff_tx", stats.link_xoff_tx), 93 I40E_PF_STAT("rx_size_64", stats.rx_size_64), 94 I40E_PF_STAT("rx_size_127", stats.rx_size_127), 95 I40E_PF_STAT("rx_size_255", stats.rx_size_255), 96 I40E_PF_STAT("rx_size_511", stats.rx_size_511), 97 I40E_PF_STAT("rx_size_1023", stats.rx_size_1023), 98 I40E_PF_STAT("rx_size_1522", stats.rx_size_1522), 99 I40E_PF_STAT("rx_size_big", stats.rx_size_big), 100 I40E_PF_STAT("tx_size_64", stats.tx_size_64), 101 I40E_PF_STAT("tx_size_127", stats.tx_size_127), 102 I40E_PF_STAT("tx_size_255", stats.tx_size_255), 103 I40E_PF_STAT("tx_size_511", stats.tx_size_511), 104 I40E_PF_STAT("tx_size_1023", stats.tx_size_1023), 105 I40E_PF_STAT("tx_size_1522", stats.tx_size_1522), 106 I40E_PF_STAT("tx_size_big", stats.tx_size_big), 107 I40E_PF_STAT("rx_undersize", stats.rx_undersize), 108 I40E_PF_STAT("rx_fragments", stats.rx_fragments), 109 I40E_PF_STAT("rx_oversize", stats.rx_oversize), 110 I40E_PF_STAT("rx_jabber", stats.rx_jabber), 111 I40E_PF_STAT("VF_admin_queue_requests", vf_aq_requests), 112 }; 113 114 #define I40E_QUEUE_STATS_LEN(n) \ 115 ((((struct i40e_netdev_priv *)netdev_priv((n)))->vsi->num_queue_pairs + \ 116 ((struct i40e_netdev_priv *)netdev_priv((n)))->vsi->num_queue_pairs) * 2) 117 #define I40E_GLOBAL_STATS_LEN ARRAY_SIZE(i40e_gstrings_stats) 118 #define I40E_NETDEV_STATS_LEN ARRAY_SIZE(i40e_gstrings_net_stats) 119 #define I40E_VSI_STATS_LEN(n) (I40E_NETDEV_STATS_LEN + \ 120 I40E_QUEUE_STATS_LEN((n))) 121 #define I40E_PFC_STATS_LEN ( \ 122 (FIELD_SIZEOF(struct i40e_pf, stats.priority_xoff_rx) + \ 123 FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_rx) + \ 124 FIELD_SIZEOF(struct i40e_pf, stats.priority_xoff_tx) + \ 125 FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_tx) + \ 126 FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_2_xoff)) \ 127 / sizeof(u64)) 128 #define I40E_PF_STATS_LEN(n) (I40E_GLOBAL_STATS_LEN + \ 129 I40E_PFC_STATS_LEN + \ 130 I40E_VSI_STATS_LEN((n))) 131 132 enum i40e_ethtool_test_id { 133 I40E_ETH_TEST_REG = 0, 134 I40E_ETH_TEST_EEPROM, 135 I40E_ETH_TEST_INTR, 136 I40E_ETH_TEST_LOOPBACK, 137 I40E_ETH_TEST_LINK, 138 }; 139 140 static const char i40e_gstrings_test[][ETH_GSTRING_LEN] = { 141 "Register test (offline)", 142 "Eeprom test (offline)", 143 "Interrupt test (offline)", 144 "Loopback test (offline)", 145 "Link test (on/offline)" 146 }; 147 148 #define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN) 149 150 /** 151 * i40e_get_settings - Get Link Speed and Duplex settings 152 * @netdev: network interface device structure 153 * @ecmd: ethtool command 154 * 155 * Reports speed/duplex settings based on media_type 156 **/ 157 static int i40e_get_settings(struct net_device *netdev, 158 struct ethtool_cmd *ecmd) 159 { 160 struct i40e_netdev_priv *np = netdev_priv(netdev); 161 struct i40e_pf *pf = np->vsi->back; 162 struct i40e_hw *hw = &pf->hw; 163 struct i40e_link_status *hw_link_info = &hw->phy.link_info; 164 bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP; 165 u32 link_speed = hw_link_info->link_speed; 166 167 /* hardware is either in 40G mode or 10G mode 168 * NOTE: this section initializes supported and advertising 169 */ 170 switch (hw_link_info->phy_type) { 171 case I40E_PHY_TYPE_40GBASE_CR4: 172 case I40E_PHY_TYPE_40GBASE_CR4_CU: 173 ecmd->supported = SUPPORTED_40000baseCR4_Full; 174 ecmd->advertising = ADVERTISED_40000baseCR4_Full; 175 break; 176 case I40E_PHY_TYPE_40GBASE_KR4: 177 ecmd->supported = SUPPORTED_40000baseKR4_Full; 178 ecmd->advertising = ADVERTISED_40000baseKR4_Full; 179 break; 180 case I40E_PHY_TYPE_40GBASE_SR4: 181 ecmd->supported = SUPPORTED_40000baseSR4_Full; 182 ecmd->advertising = ADVERTISED_40000baseSR4_Full; 183 break; 184 case I40E_PHY_TYPE_40GBASE_LR4: 185 ecmd->supported = SUPPORTED_40000baseLR4_Full; 186 ecmd->advertising = ADVERTISED_40000baseLR4_Full; 187 break; 188 case I40E_PHY_TYPE_10GBASE_KX4: 189 ecmd->supported = SUPPORTED_10000baseKX4_Full; 190 ecmd->advertising = ADVERTISED_10000baseKX4_Full; 191 break; 192 case I40E_PHY_TYPE_10GBASE_KR: 193 ecmd->supported = SUPPORTED_10000baseKR_Full; 194 ecmd->advertising = ADVERTISED_10000baseKR_Full; 195 break; 196 case I40E_PHY_TYPE_10GBASE_T: 197 default: 198 ecmd->supported = SUPPORTED_10000baseT_Full; 199 ecmd->advertising = ADVERTISED_10000baseT_Full; 200 break; 201 } 202 203 /* for now just say autoneg all the time */ 204 ecmd->supported |= SUPPORTED_Autoneg; 205 206 if (hw->phy.media_type == I40E_MEDIA_TYPE_BACKPLANE) { 207 ecmd->supported |= SUPPORTED_Backplane; 208 ecmd->advertising |= ADVERTISED_Backplane; 209 ecmd->port = PORT_NONE; 210 } else if (hw->phy.media_type == I40E_MEDIA_TYPE_BASET) { 211 ecmd->supported |= SUPPORTED_TP; 212 ecmd->advertising |= ADVERTISED_TP; 213 ecmd->port = PORT_TP; 214 } else { 215 ecmd->supported |= SUPPORTED_FIBRE; 216 ecmd->advertising |= ADVERTISED_FIBRE; 217 ecmd->port = PORT_FIBRE; 218 } 219 220 ecmd->transceiver = XCVR_EXTERNAL; 221 222 if (link_up) { 223 switch (link_speed) { 224 case I40E_LINK_SPEED_40GB: 225 /* need a SPEED_40000 in ethtool.h */ 226 ethtool_cmd_speed_set(ecmd, 40000); 227 break; 228 case I40E_LINK_SPEED_10GB: 229 ethtool_cmd_speed_set(ecmd, SPEED_10000); 230 break; 231 default: 232 break; 233 } 234 ecmd->duplex = DUPLEX_FULL; 235 } else { 236 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN); 237 ecmd->duplex = DUPLEX_UNKNOWN; 238 } 239 240 return 0; 241 } 242 243 /** 244 * i40e_get_pauseparam - Get Flow Control status 245 * Return tx/rx-pause status 246 **/ 247 static void i40e_get_pauseparam(struct net_device *netdev, 248 struct ethtool_pauseparam *pause) 249 { 250 struct i40e_netdev_priv *np = netdev_priv(netdev); 251 struct i40e_pf *pf = np->vsi->back; 252 struct i40e_hw *hw = &pf->hw; 253 struct i40e_link_status *hw_link_info = &hw->phy.link_info; 254 255 pause->autoneg = 256 ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ? 257 AUTONEG_ENABLE : AUTONEG_DISABLE); 258 259 pause->rx_pause = 0; 260 pause->tx_pause = 0; 261 if (hw_link_info->an_info & I40E_AQ_LINK_PAUSE_RX) 262 pause->rx_pause = 1; 263 if (hw_link_info->an_info & I40E_AQ_LINK_PAUSE_TX) 264 pause->tx_pause = 1; 265 } 266 267 static u32 i40e_get_msglevel(struct net_device *netdev) 268 { 269 struct i40e_netdev_priv *np = netdev_priv(netdev); 270 struct i40e_pf *pf = np->vsi->back; 271 272 return pf->msg_enable; 273 } 274 275 static void i40e_set_msglevel(struct net_device *netdev, u32 data) 276 { 277 struct i40e_netdev_priv *np = netdev_priv(netdev); 278 struct i40e_pf *pf = np->vsi->back; 279 280 if (I40E_DEBUG_USER & data) 281 pf->hw.debug_mask = data; 282 pf->msg_enable = data; 283 } 284 285 static int i40e_get_regs_len(struct net_device *netdev) 286 { 287 int reg_count = 0; 288 int i; 289 290 for (i = 0; i40e_reg_list[i].offset != 0; i++) 291 reg_count += i40e_reg_list[i].elements; 292 293 return reg_count * sizeof(u32); 294 } 295 296 static void i40e_get_regs(struct net_device *netdev, struct ethtool_regs *regs, 297 void *p) 298 { 299 struct i40e_netdev_priv *np = netdev_priv(netdev); 300 struct i40e_pf *pf = np->vsi->back; 301 struct i40e_hw *hw = &pf->hw; 302 u32 *reg_buf = p; 303 int i, j, ri; 304 u32 reg; 305 306 /* Tell ethtool which driver-version-specific regs output we have. 307 * 308 * At some point, if we have ethtool doing special formatting of 309 * this data, it will rely on this version number to know how to 310 * interpret things. Hence, this needs to be updated if/when the 311 * diags register table is changed. 312 */ 313 regs->version = 1; 314 315 /* loop through the diags reg table for what to print */ 316 ri = 0; 317 for (i = 0; i40e_reg_list[i].offset != 0; i++) { 318 for (j = 0; j < i40e_reg_list[i].elements; j++) { 319 reg = i40e_reg_list[i].offset 320 + (j * i40e_reg_list[i].stride); 321 reg_buf[ri++] = rd32(hw, reg); 322 } 323 } 324 325 } 326 327 static int i40e_get_eeprom(struct net_device *netdev, 328 struct ethtool_eeprom *eeprom, u8 *bytes) 329 { 330 struct i40e_netdev_priv *np = netdev_priv(netdev); 331 struct i40e_hw *hw = &np->vsi->back->hw; 332 int first_word, last_word; 333 u16 i, eeprom_len; 334 u16 *eeprom_buff; 335 int ret_val = 0; 336 337 if (eeprom->len == 0) 338 return -EINVAL; 339 340 eeprom->magic = hw->vendor_id | (hw->device_id << 16); 341 342 first_word = eeprom->offset >> 1; 343 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 344 eeprom_len = last_word - first_word + 1; 345 346 eeprom_buff = kmalloc(sizeof(u16) * eeprom_len, GFP_KERNEL); 347 if (!eeprom_buff) 348 return -ENOMEM; 349 350 ret_val = i40e_read_nvm_buffer(hw, first_word, &eeprom_len, 351 eeprom_buff); 352 if (eeprom_len == 0) { 353 kfree(eeprom_buff); 354 return -EACCES; 355 } 356 357 /* Device's eeprom is always little-endian, word addressable */ 358 for (i = 0; i < eeprom_len; i++) 359 le16_to_cpus(&eeprom_buff[i]); 360 361 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len); 362 kfree(eeprom_buff); 363 364 return ret_val; 365 } 366 367 static int i40e_get_eeprom_len(struct net_device *netdev) 368 { 369 struct i40e_netdev_priv *np = netdev_priv(netdev); 370 struct i40e_hw *hw = &np->vsi->back->hw; 371 372 return hw->nvm.sr_size * 2; 373 } 374 375 static void i40e_get_drvinfo(struct net_device *netdev, 376 struct ethtool_drvinfo *drvinfo) 377 { 378 struct i40e_netdev_priv *np = netdev_priv(netdev); 379 struct i40e_vsi *vsi = np->vsi; 380 struct i40e_pf *pf = vsi->back; 381 382 strlcpy(drvinfo->driver, i40e_driver_name, sizeof(drvinfo->driver)); 383 strlcpy(drvinfo->version, i40e_driver_version_str, 384 sizeof(drvinfo->version)); 385 strlcpy(drvinfo->fw_version, i40e_fw_version_str(&pf->hw), 386 sizeof(drvinfo->fw_version)); 387 strlcpy(drvinfo->bus_info, pci_name(pf->pdev), 388 sizeof(drvinfo->bus_info)); 389 } 390 391 static void i40e_get_ringparam(struct net_device *netdev, 392 struct ethtool_ringparam *ring) 393 { 394 struct i40e_netdev_priv *np = netdev_priv(netdev); 395 struct i40e_pf *pf = np->vsi->back; 396 struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi]; 397 398 ring->rx_max_pending = I40E_MAX_NUM_DESCRIPTORS; 399 ring->tx_max_pending = I40E_MAX_NUM_DESCRIPTORS; 400 ring->rx_mini_max_pending = 0; 401 ring->rx_jumbo_max_pending = 0; 402 ring->rx_pending = vsi->rx_rings[0]->count; 403 ring->tx_pending = vsi->tx_rings[0]->count; 404 ring->rx_mini_pending = 0; 405 ring->rx_jumbo_pending = 0; 406 } 407 408 static int i40e_set_ringparam(struct net_device *netdev, 409 struct ethtool_ringparam *ring) 410 { 411 struct i40e_ring *tx_rings = NULL, *rx_rings = NULL; 412 struct i40e_netdev_priv *np = netdev_priv(netdev); 413 struct i40e_vsi *vsi = np->vsi; 414 struct i40e_pf *pf = vsi->back; 415 u32 new_rx_count, new_tx_count; 416 int i, err = 0; 417 418 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) 419 return -EINVAL; 420 421 new_tx_count = clamp_t(u32, ring->tx_pending, 422 I40E_MIN_NUM_DESCRIPTORS, 423 I40E_MAX_NUM_DESCRIPTORS); 424 new_tx_count = ALIGN(new_tx_count, I40E_REQ_DESCRIPTOR_MULTIPLE); 425 426 new_rx_count = clamp_t(u32, ring->rx_pending, 427 I40E_MIN_NUM_DESCRIPTORS, 428 I40E_MAX_NUM_DESCRIPTORS); 429 new_rx_count = ALIGN(new_rx_count, I40E_REQ_DESCRIPTOR_MULTIPLE); 430 431 /* if nothing to do return success */ 432 if ((new_tx_count == vsi->tx_rings[0]->count) && 433 (new_rx_count == vsi->rx_rings[0]->count)) 434 return 0; 435 436 while (test_and_set_bit(__I40E_CONFIG_BUSY, &pf->state)) 437 usleep_range(1000, 2000); 438 439 if (!netif_running(vsi->netdev)) { 440 /* simple case - set for the next time the netdev is started */ 441 for (i = 0; i < vsi->num_queue_pairs; i++) { 442 vsi->tx_rings[i]->count = new_tx_count; 443 vsi->rx_rings[i]->count = new_rx_count; 444 } 445 goto done; 446 } 447 448 /* We can't just free everything and then setup again, 449 * because the ISRs in MSI-X mode get passed pointers 450 * to the Tx and Rx ring structs. 451 */ 452 453 /* alloc updated Tx resources */ 454 if (new_tx_count != vsi->tx_rings[0]->count) { 455 netdev_info(netdev, 456 "Changing Tx descriptor count from %d to %d.\n", 457 vsi->tx_rings[0]->count, new_tx_count); 458 tx_rings = kcalloc(vsi->alloc_queue_pairs, 459 sizeof(struct i40e_ring), GFP_KERNEL); 460 if (!tx_rings) { 461 err = -ENOMEM; 462 goto done; 463 } 464 465 for (i = 0; i < vsi->num_queue_pairs; i++) { 466 /* clone ring and setup updated count */ 467 tx_rings[i] = *vsi->tx_rings[i]; 468 tx_rings[i].count = new_tx_count; 469 err = i40e_setup_tx_descriptors(&tx_rings[i]); 470 if (err) { 471 while (i) { 472 i--; 473 i40e_free_tx_resources(&tx_rings[i]); 474 } 475 kfree(tx_rings); 476 tx_rings = NULL; 477 478 goto done; 479 } 480 } 481 } 482 483 /* alloc updated Rx resources */ 484 if (new_rx_count != vsi->rx_rings[0]->count) { 485 netdev_info(netdev, 486 "Changing Rx descriptor count from %d to %d\n", 487 vsi->rx_rings[0]->count, new_rx_count); 488 rx_rings = kcalloc(vsi->alloc_queue_pairs, 489 sizeof(struct i40e_ring), GFP_KERNEL); 490 if (!rx_rings) { 491 err = -ENOMEM; 492 goto free_tx; 493 } 494 495 for (i = 0; i < vsi->num_queue_pairs; i++) { 496 /* clone ring and setup updated count */ 497 rx_rings[i] = *vsi->rx_rings[i]; 498 rx_rings[i].count = new_rx_count; 499 err = i40e_setup_rx_descriptors(&rx_rings[i]); 500 if (err) { 501 while (i) { 502 i--; 503 i40e_free_rx_resources(&rx_rings[i]); 504 } 505 kfree(rx_rings); 506 rx_rings = NULL; 507 508 goto free_tx; 509 } 510 } 511 } 512 513 /* Bring interface down, copy in the new ring info, 514 * then restore the interface 515 */ 516 i40e_down(vsi); 517 518 if (tx_rings) { 519 for (i = 0; i < vsi->num_queue_pairs; i++) { 520 i40e_free_tx_resources(vsi->tx_rings[i]); 521 *vsi->tx_rings[i] = tx_rings[i]; 522 } 523 kfree(tx_rings); 524 tx_rings = NULL; 525 } 526 527 if (rx_rings) { 528 for (i = 0; i < vsi->num_queue_pairs; i++) { 529 i40e_free_rx_resources(vsi->rx_rings[i]); 530 *vsi->rx_rings[i] = rx_rings[i]; 531 } 532 kfree(rx_rings); 533 rx_rings = NULL; 534 } 535 536 i40e_up(vsi); 537 538 free_tx: 539 /* error cleanup if the Rx allocations failed after getting Tx */ 540 if (tx_rings) { 541 for (i = 0; i < vsi->num_queue_pairs; i++) 542 i40e_free_tx_resources(&tx_rings[i]); 543 kfree(tx_rings); 544 tx_rings = NULL; 545 } 546 547 done: 548 clear_bit(__I40E_CONFIG_BUSY, &pf->state); 549 550 return err; 551 } 552 553 static int i40e_get_sset_count(struct net_device *netdev, int sset) 554 { 555 struct i40e_netdev_priv *np = netdev_priv(netdev); 556 struct i40e_vsi *vsi = np->vsi; 557 struct i40e_pf *pf = vsi->back; 558 559 switch (sset) { 560 case ETH_SS_TEST: 561 return I40E_TEST_LEN; 562 case ETH_SS_STATS: 563 if (vsi == pf->vsi[pf->lan_vsi]) 564 return I40E_PF_STATS_LEN(netdev); 565 else 566 return I40E_VSI_STATS_LEN(netdev); 567 default: 568 return -EOPNOTSUPP; 569 } 570 } 571 572 static void i40e_get_ethtool_stats(struct net_device *netdev, 573 struct ethtool_stats *stats, u64 *data) 574 { 575 struct i40e_netdev_priv *np = netdev_priv(netdev); 576 struct i40e_vsi *vsi = np->vsi; 577 struct i40e_pf *pf = vsi->back; 578 int i = 0; 579 char *p; 580 int j; 581 struct rtnl_link_stats64 *net_stats = i40e_get_vsi_stats_struct(vsi); 582 unsigned int start; 583 584 i40e_update_stats(vsi); 585 586 for (j = 0; j < I40E_NETDEV_STATS_LEN; j++) { 587 p = (char *)net_stats + i40e_gstrings_net_stats[j].stat_offset; 588 data[i++] = (i40e_gstrings_net_stats[j].sizeof_stat == 589 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 590 } 591 rcu_read_lock(); 592 for (j = 0; j < vsi->num_queue_pairs; j++, i += 4) { 593 struct i40e_ring *tx_ring = ACCESS_ONCE(vsi->tx_rings[j]); 594 struct i40e_ring *rx_ring; 595 596 if (!tx_ring) 597 continue; 598 599 /* process Tx ring statistics */ 600 do { 601 start = u64_stats_fetch_begin_bh(&tx_ring->syncp); 602 data[i] = tx_ring->stats.packets; 603 data[i + 1] = tx_ring->stats.bytes; 604 } while (u64_stats_fetch_retry_bh(&tx_ring->syncp, start)); 605 606 /* Rx ring is the 2nd half of the queue pair */ 607 rx_ring = &tx_ring[1]; 608 do { 609 start = u64_stats_fetch_begin_bh(&rx_ring->syncp); 610 data[i + 2] = rx_ring->stats.packets; 611 data[i + 3] = rx_ring->stats.bytes; 612 } while (u64_stats_fetch_retry_bh(&rx_ring->syncp, start)); 613 } 614 rcu_read_unlock(); 615 if (vsi == pf->vsi[pf->lan_vsi]) { 616 for (j = 0; j < I40E_GLOBAL_STATS_LEN; j++) { 617 p = (char *)pf + i40e_gstrings_stats[j].stat_offset; 618 data[i++] = (i40e_gstrings_stats[j].sizeof_stat == 619 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 620 } 621 for (j = 0; j < I40E_MAX_USER_PRIORITY; j++) { 622 data[i++] = pf->stats.priority_xon_tx[j]; 623 data[i++] = pf->stats.priority_xoff_tx[j]; 624 } 625 for (j = 0; j < I40E_MAX_USER_PRIORITY; j++) { 626 data[i++] = pf->stats.priority_xon_rx[j]; 627 data[i++] = pf->stats.priority_xoff_rx[j]; 628 } 629 for (j = 0; j < I40E_MAX_USER_PRIORITY; j++) 630 data[i++] = pf->stats.priority_xon_2_xoff[j]; 631 } 632 } 633 634 static void i40e_get_strings(struct net_device *netdev, u32 stringset, 635 u8 *data) 636 { 637 struct i40e_netdev_priv *np = netdev_priv(netdev); 638 struct i40e_vsi *vsi = np->vsi; 639 struct i40e_pf *pf = vsi->back; 640 char *p = (char *)data; 641 int i; 642 643 switch (stringset) { 644 case ETH_SS_TEST: 645 for (i = 0; i < I40E_TEST_LEN; i++) { 646 memcpy(data, i40e_gstrings_test[i], ETH_GSTRING_LEN); 647 data += ETH_GSTRING_LEN; 648 } 649 break; 650 case ETH_SS_STATS: 651 for (i = 0; i < I40E_NETDEV_STATS_LEN; i++) { 652 snprintf(p, ETH_GSTRING_LEN, "%s", 653 i40e_gstrings_net_stats[i].stat_string); 654 p += ETH_GSTRING_LEN; 655 } 656 for (i = 0; i < vsi->num_queue_pairs; i++) { 657 snprintf(p, ETH_GSTRING_LEN, "tx-%u.tx_packets", i); 658 p += ETH_GSTRING_LEN; 659 snprintf(p, ETH_GSTRING_LEN, "tx-%u.tx_bytes", i); 660 p += ETH_GSTRING_LEN; 661 snprintf(p, ETH_GSTRING_LEN, "rx-%u.rx_packets", i); 662 p += ETH_GSTRING_LEN; 663 snprintf(p, ETH_GSTRING_LEN, "rx-%u.rx_bytes", i); 664 p += ETH_GSTRING_LEN; 665 } 666 if (vsi == pf->vsi[pf->lan_vsi]) { 667 for (i = 0; i < I40E_GLOBAL_STATS_LEN; i++) { 668 snprintf(p, ETH_GSTRING_LEN, "port.%s", 669 i40e_gstrings_stats[i].stat_string); 670 p += ETH_GSTRING_LEN; 671 } 672 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) { 673 snprintf(p, ETH_GSTRING_LEN, 674 "port.tx_priority_%u_xon", i); 675 p += ETH_GSTRING_LEN; 676 snprintf(p, ETH_GSTRING_LEN, 677 "port.tx_priority_%u_xoff", i); 678 p += ETH_GSTRING_LEN; 679 } 680 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) { 681 snprintf(p, ETH_GSTRING_LEN, 682 "port.rx_priority_%u_xon", i); 683 p += ETH_GSTRING_LEN; 684 snprintf(p, ETH_GSTRING_LEN, 685 "port.rx_priority_%u_xoff", i); 686 p += ETH_GSTRING_LEN; 687 } 688 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) { 689 snprintf(p, ETH_GSTRING_LEN, 690 "port.rx_priority_%u_xon_2_xoff", i); 691 p += ETH_GSTRING_LEN; 692 } 693 } 694 /* BUG_ON(p - data != I40E_STATS_LEN * ETH_GSTRING_LEN); */ 695 break; 696 } 697 } 698 699 static int i40e_get_ts_info(struct net_device *dev, 700 struct ethtool_ts_info *info) 701 { 702 return ethtool_op_get_ts_info(dev, info); 703 } 704 705 static int i40e_link_test(struct i40e_pf *pf, u64 *data) 706 { 707 if (i40e_get_link_status(&pf->hw)) 708 *data = 0; 709 else 710 *data = 1; 711 712 return *data; 713 } 714 715 static int i40e_reg_test(struct i40e_pf *pf, u64 *data) 716 { 717 i40e_status ret; 718 719 ret = i40e_diag_reg_test(&pf->hw); 720 *data = ret; 721 722 return ret; 723 } 724 725 static int i40e_eeprom_test(struct i40e_pf *pf, u64 *data) 726 { 727 i40e_status ret; 728 729 ret = i40e_diag_eeprom_test(&pf->hw); 730 *data = ret; 731 732 return ret; 733 } 734 735 static int i40e_intr_test(struct i40e_pf *pf, u64 *data) 736 { 737 *data = -ENOSYS; 738 739 return *data; 740 } 741 742 static int i40e_loopback_test(struct i40e_pf *pf, u64 *data) 743 { 744 *data = -ENOSYS; 745 746 return *data; 747 } 748 749 static void i40e_diag_test(struct net_device *netdev, 750 struct ethtool_test *eth_test, u64 *data) 751 { 752 struct i40e_netdev_priv *np = netdev_priv(netdev); 753 struct i40e_pf *pf = np->vsi->back; 754 755 set_bit(__I40E_TESTING, &pf->state); 756 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 757 /* Offline tests */ 758 759 netdev_info(netdev, "offline testing starting\n"); 760 761 /* Link test performed before hardware reset 762 * so autoneg doesn't interfere with test result 763 */ 764 netdev_info(netdev, "link test starting\n"); 765 if (i40e_link_test(pf, &data[I40E_ETH_TEST_LINK])) 766 eth_test->flags |= ETH_TEST_FL_FAILED; 767 768 netdev_info(netdev, "register test starting\n"); 769 if (i40e_reg_test(pf, &data[I40E_ETH_TEST_REG])) 770 eth_test->flags |= ETH_TEST_FL_FAILED; 771 772 i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED)); 773 netdev_info(netdev, "eeprom test starting\n"); 774 if (i40e_eeprom_test(pf, &data[I40E_ETH_TEST_EEPROM])) 775 eth_test->flags |= ETH_TEST_FL_FAILED; 776 777 i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED)); 778 netdev_info(netdev, "interrupt test starting\n"); 779 if (i40e_intr_test(pf, &data[I40E_ETH_TEST_INTR])) 780 eth_test->flags |= ETH_TEST_FL_FAILED; 781 782 i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED)); 783 netdev_info(netdev, "loopback test starting\n"); 784 if (i40e_loopback_test(pf, &data[I40E_ETH_TEST_LOOPBACK])) 785 eth_test->flags |= ETH_TEST_FL_FAILED; 786 787 } else { 788 netdev_info(netdev, "online test starting\n"); 789 /* Online tests */ 790 if (i40e_link_test(pf, &data[I40E_ETH_TEST_LINK])) 791 eth_test->flags |= ETH_TEST_FL_FAILED; 792 793 /* Offline only tests, not run in online; pass by default */ 794 data[I40E_ETH_TEST_REG] = 0; 795 data[I40E_ETH_TEST_EEPROM] = 0; 796 data[I40E_ETH_TEST_INTR] = 0; 797 data[I40E_ETH_TEST_LOOPBACK] = 0; 798 799 clear_bit(__I40E_TESTING, &pf->state); 800 } 801 } 802 803 static void i40e_get_wol(struct net_device *netdev, 804 struct ethtool_wolinfo *wol) 805 { 806 wol->supported = 0; 807 wol->wolopts = 0; 808 } 809 810 static int i40e_nway_reset(struct net_device *netdev) 811 { 812 /* restart autonegotiation */ 813 struct i40e_netdev_priv *np = netdev_priv(netdev); 814 struct i40e_pf *pf = np->vsi->back; 815 struct i40e_hw *hw = &pf->hw; 816 i40e_status ret = 0; 817 818 ret = i40e_aq_set_link_restart_an(hw, NULL); 819 if (ret) { 820 netdev_info(netdev, "link restart failed, aq_err=%d\n", 821 pf->hw.aq.asq_last_status); 822 return -EIO; 823 } 824 825 return 0; 826 } 827 828 static int i40e_set_phys_id(struct net_device *netdev, 829 enum ethtool_phys_id_state state) 830 { 831 struct i40e_netdev_priv *np = netdev_priv(netdev); 832 struct i40e_pf *pf = np->vsi->back; 833 struct i40e_hw *hw = &pf->hw; 834 int blink_freq = 2; 835 836 switch (state) { 837 case ETHTOOL_ID_ACTIVE: 838 pf->led_status = i40e_led_get(hw); 839 return blink_freq; 840 case ETHTOOL_ID_ON: 841 i40e_led_set(hw, 0xF); 842 break; 843 case ETHTOOL_ID_OFF: 844 i40e_led_set(hw, 0x0); 845 break; 846 case ETHTOOL_ID_INACTIVE: 847 i40e_led_set(hw, pf->led_status); 848 break; 849 } 850 851 return 0; 852 } 853 854 /* NOTE: i40e hardware uses a conversion factor of 2 for Interrupt 855 * Throttle Rate (ITR) ie. ITR(1) = 2us ITR(10) = 20 us, and also 856 * 125us (8000 interrupts per second) == ITR(62) 857 */ 858 859 static int i40e_get_coalesce(struct net_device *netdev, 860 struct ethtool_coalesce *ec) 861 { 862 struct i40e_netdev_priv *np = netdev_priv(netdev); 863 struct i40e_vsi *vsi = np->vsi; 864 865 ec->tx_max_coalesced_frames_irq = vsi->work_limit; 866 ec->rx_max_coalesced_frames_irq = vsi->work_limit; 867 868 if (ITR_IS_DYNAMIC(vsi->rx_itr_setting)) 869 ec->rx_coalesce_usecs = 1; 870 else 871 ec->rx_coalesce_usecs = vsi->rx_itr_setting; 872 873 if (ITR_IS_DYNAMIC(vsi->tx_itr_setting)) 874 ec->tx_coalesce_usecs = 1; 875 else 876 ec->tx_coalesce_usecs = vsi->tx_itr_setting; 877 878 return 0; 879 } 880 881 static int i40e_set_coalesce(struct net_device *netdev, 882 struct ethtool_coalesce *ec) 883 { 884 struct i40e_netdev_priv *np = netdev_priv(netdev); 885 struct i40e_q_vector *q_vector; 886 struct i40e_vsi *vsi = np->vsi; 887 struct i40e_pf *pf = vsi->back; 888 struct i40e_hw *hw = &pf->hw; 889 u16 vector; 890 int i; 891 892 if (ec->tx_max_coalesced_frames_irq || ec->rx_max_coalesced_frames_irq) 893 vsi->work_limit = ec->tx_max_coalesced_frames_irq; 894 895 switch (ec->rx_coalesce_usecs) { 896 case 0: 897 vsi->rx_itr_setting = 0; 898 break; 899 case 1: 900 vsi->rx_itr_setting = (I40E_ITR_DYNAMIC | 901 ITR_REG_TO_USEC(I40E_ITR_RX_DEF)); 902 break; 903 default: 904 if ((ec->rx_coalesce_usecs < (I40E_MIN_ITR << 1)) || 905 (ec->rx_coalesce_usecs > (I40E_MAX_ITR << 1))) 906 return -EINVAL; 907 vsi->rx_itr_setting = ec->rx_coalesce_usecs; 908 break; 909 } 910 911 switch (ec->tx_coalesce_usecs) { 912 case 0: 913 vsi->tx_itr_setting = 0; 914 break; 915 case 1: 916 vsi->tx_itr_setting = (I40E_ITR_DYNAMIC | 917 ITR_REG_TO_USEC(I40E_ITR_TX_DEF)); 918 break; 919 default: 920 if ((ec->tx_coalesce_usecs < (I40E_MIN_ITR << 1)) || 921 (ec->tx_coalesce_usecs > (I40E_MAX_ITR << 1))) 922 return -EINVAL; 923 vsi->tx_itr_setting = ec->tx_coalesce_usecs; 924 break; 925 } 926 927 vector = vsi->base_vector; 928 for (i = 0; i < vsi->num_q_vectors; i++, vector++) { 929 q_vector = vsi->q_vectors[i]; 930 q_vector->rx.itr = ITR_TO_REG(vsi->rx_itr_setting); 931 wr32(hw, I40E_PFINT_ITRN(0, vector - 1), q_vector->rx.itr); 932 q_vector->tx.itr = ITR_TO_REG(vsi->tx_itr_setting); 933 wr32(hw, I40E_PFINT_ITRN(1, vector - 1), q_vector->tx.itr); 934 i40e_flush(hw); 935 } 936 937 return 0; 938 } 939 940 /** 941 * i40e_get_rss_hash_opts - Get RSS hash Input Set for each flow type 942 * @pf: pointer to the physical function struct 943 * @cmd: ethtool rxnfc command 944 * 945 * Returns Success if the flow is supported, else Invalid Input. 946 **/ 947 static int i40e_get_rss_hash_opts(struct i40e_pf *pf, struct ethtool_rxnfc *cmd) 948 { 949 cmd->data = 0; 950 951 /* Report default options for RSS on i40e */ 952 switch (cmd->flow_type) { 953 case TCP_V4_FLOW: 954 case UDP_V4_FLOW: 955 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 956 /* fall through to add IP fields */ 957 case SCTP_V4_FLOW: 958 case AH_ESP_V4_FLOW: 959 case AH_V4_FLOW: 960 case ESP_V4_FLOW: 961 case IPV4_FLOW: 962 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 963 break; 964 case TCP_V6_FLOW: 965 case UDP_V6_FLOW: 966 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 967 /* fall through to add IP fields */ 968 case SCTP_V6_FLOW: 969 case AH_ESP_V6_FLOW: 970 case AH_V6_FLOW: 971 case ESP_V6_FLOW: 972 case IPV6_FLOW: 973 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 974 break; 975 default: 976 return -EINVAL; 977 } 978 979 return 0; 980 } 981 982 /** 983 * i40e_get_rxnfc - command to get RX flow classification rules 984 * @netdev: network interface device structure 985 * @cmd: ethtool rxnfc command 986 * 987 * Returns Success if the command is supported. 988 **/ 989 static int i40e_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd, 990 u32 *rule_locs) 991 { 992 struct i40e_netdev_priv *np = netdev_priv(netdev); 993 struct i40e_vsi *vsi = np->vsi; 994 struct i40e_pf *pf = vsi->back; 995 int ret = -EOPNOTSUPP; 996 997 switch (cmd->cmd) { 998 case ETHTOOL_GRXRINGS: 999 cmd->data = vsi->alloc_queue_pairs; 1000 ret = 0; 1001 break; 1002 case ETHTOOL_GRXFH: 1003 ret = i40e_get_rss_hash_opts(pf, cmd); 1004 break; 1005 case ETHTOOL_GRXCLSRLCNT: 1006 ret = 0; 1007 break; 1008 case ETHTOOL_GRXCLSRULE: 1009 ret = 0; 1010 break; 1011 case ETHTOOL_GRXCLSRLALL: 1012 cmd->data = 500; 1013 ret = 0; 1014 default: 1015 break; 1016 } 1017 1018 return ret; 1019 } 1020 1021 /** 1022 * i40e_set_rss_hash_opt - Enable/Disable flow types for RSS hash 1023 * @pf: pointer to the physical function struct 1024 * @cmd: ethtool rxnfc command 1025 * 1026 * Returns Success if the flow input set is supported. 1027 **/ 1028 static int i40e_set_rss_hash_opt(struct i40e_pf *pf, struct ethtool_rxnfc *nfc) 1029 { 1030 struct i40e_hw *hw = &pf->hw; 1031 u64 hena = (u64)rd32(hw, I40E_PFQF_HENA(0)) | 1032 ((u64)rd32(hw, I40E_PFQF_HENA(1)) << 32); 1033 1034 /* RSS does not support anything other than hashing 1035 * to queues on src and dst IPs and ports 1036 */ 1037 if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST | 1038 RXH_L4_B_0_1 | RXH_L4_B_2_3)) 1039 return -EINVAL; 1040 1041 /* We need at least the IP SRC and DEST fields for hashing */ 1042 if (!(nfc->data & RXH_IP_SRC) || 1043 !(nfc->data & RXH_IP_DST)) 1044 return -EINVAL; 1045 1046 switch (nfc->flow_type) { 1047 case TCP_V4_FLOW: 1048 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1049 case 0: 1050 hena &= ~((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_TCP); 1051 break; 1052 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1053 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_TCP); 1054 break; 1055 default: 1056 return -EINVAL; 1057 } 1058 break; 1059 case TCP_V6_FLOW: 1060 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1061 case 0: 1062 hena &= ~((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_TCP); 1063 break; 1064 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1065 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_TCP); 1066 break; 1067 default: 1068 return -EINVAL; 1069 } 1070 break; 1071 case UDP_V4_FLOW: 1072 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1073 case 0: 1074 hena &= 1075 ~(((u64)1 << I40E_FILTER_PCTYPE_NONF_UNICAST_IPV4_UDP) | 1076 ((u64)1 << I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV4_UDP) | 1077 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4)); 1078 break; 1079 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1080 hena |= 1081 (((u64)1 << I40E_FILTER_PCTYPE_NONF_UNICAST_IPV4_UDP) | 1082 ((u64)1 << I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV4_UDP) | 1083 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4)); 1084 break; 1085 default: 1086 return -EINVAL; 1087 } 1088 break; 1089 case UDP_V6_FLOW: 1090 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1091 case 0: 1092 hena &= 1093 ~(((u64)1 << I40E_FILTER_PCTYPE_NONF_UNICAST_IPV6_UDP) | 1094 ((u64)1 << I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV6_UDP) | 1095 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6)); 1096 break; 1097 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1098 hena |= 1099 (((u64)1 << I40E_FILTER_PCTYPE_NONF_UNICAST_IPV6_UDP) | 1100 ((u64)1 << I40E_FILTER_PCTYPE_NONF_MULTICAST_IPV6_UDP) | 1101 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6)); 1102 break; 1103 default: 1104 return -EINVAL; 1105 } 1106 break; 1107 case AH_ESP_V4_FLOW: 1108 case AH_V4_FLOW: 1109 case ESP_V4_FLOW: 1110 case SCTP_V4_FLOW: 1111 if ((nfc->data & RXH_L4_B_0_1) || 1112 (nfc->data & RXH_L4_B_2_3)) 1113 return -EINVAL; 1114 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_OTHER); 1115 break; 1116 case AH_ESP_V6_FLOW: 1117 case AH_V6_FLOW: 1118 case ESP_V6_FLOW: 1119 case SCTP_V6_FLOW: 1120 if ((nfc->data & RXH_L4_B_0_1) || 1121 (nfc->data & RXH_L4_B_2_3)) 1122 return -EINVAL; 1123 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_OTHER); 1124 break; 1125 case IPV4_FLOW: 1126 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_OTHER) | 1127 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4); 1128 break; 1129 case IPV6_FLOW: 1130 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_OTHER) | 1131 ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6); 1132 break; 1133 default: 1134 return -EINVAL; 1135 } 1136 1137 wr32(hw, I40E_PFQF_HENA(0), (u32)hena); 1138 wr32(hw, I40E_PFQF_HENA(1), (u32)(hena >> 32)); 1139 i40e_flush(hw); 1140 1141 return 0; 1142 } 1143 1144 #define IP_HEADER_OFFSET 14 1145 /** 1146 * i40e_add_del_fdir_udpv4 - Add/Remove UDPv4 Flow Director filters for 1147 * a specific flow spec 1148 * @vsi: pointer to the targeted VSI 1149 * @fd_data: the flow director data required from the FDir descriptor 1150 * @ethtool_rx_flow_spec: the flow spec 1151 * @add: true adds a filter, false removes it 1152 * 1153 * Returns 0 if the filters were successfully added or removed 1154 **/ 1155 static int i40e_add_del_fdir_udpv4(struct i40e_vsi *vsi, 1156 struct i40e_fdir_data *fd_data, 1157 struct ethtool_rx_flow_spec *fsp, bool add) 1158 { 1159 struct i40e_pf *pf = vsi->back; 1160 struct udphdr *udp; 1161 struct iphdr *ip; 1162 bool err = false; 1163 int ret; 1164 int i; 1165 1166 ip = (struct iphdr *)(fd_data->raw_packet + IP_HEADER_OFFSET); 1167 udp = (struct udphdr *)(fd_data->raw_packet + IP_HEADER_OFFSET 1168 + sizeof(struct iphdr)); 1169 1170 ip->saddr = fsp->h_u.tcp_ip4_spec.ip4src; 1171 ip->daddr = fsp->h_u.tcp_ip4_spec.ip4dst; 1172 udp->source = fsp->h_u.tcp_ip4_spec.psrc; 1173 udp->dest = fsp->h_u.tcp_ip4_spec.pdst; 1174 1175 for (i = I40E_FILTER_PCTYPE_NONF_UNICAST_IPV4_UDP; 1176 i <= I40E_FILTER_PCTYPE_NONF_IPV4_UDP; i++) { 1177 fd_data->pctype = i; 1178 ret = i40e_program_fdir_filter(fd_data, pf, add); 1179 1180 if (ret) { 1181 dev_info(&pf->pdev->dev, 1182 "Filter command send failed for PCTYPE %d (ret = %d)\n", 1183 fd_data->pctype, ret); 1184 err = true; 1185 } else { 1186 dev_info(&pf->pdev->dev, 1187 "Filter OK for PCTYPE %d (ret = %d)\n", 1188 fd_data->pctype, ret); 1189 } 1190 } 1191 1192 return err ? -EOPNOTSUPP : 0; 1193 } 1194 1195 /** 1196 * i40e_add_del_fdir_tcpv4 - Add/Remove TCPv4 Flow Director filters for 1197 * a specific flow spec 1198 * @vsi: pointer to the targeted VSI 1199 * @fd_data: the flow director data required from the FDir descriptor 1200 * @ethtool_rx_flow_spec: the flow spec 1201 * @add: true adds a filter, false removes it 1202 * 1203 * Returns 0 if the filters were successfully added or removed 1204 **/ 1205 static int i40e_add_del_fdir_tcpv4(struct i40e_vsi *vsi, 1206 struct i40e_fdir_data *fd_data, 1207 struct ethtool_rx_flow_spec *fsp, bool add) 1208 { 1209 struct i40e_pf *pf = vsi->back; 1210 struct tcphdr *tcp; 1211 struct iphdr *ip; 1212 bool err = false; 1213 int ret; 1214 1215 ip = (struct iphdr *)(fd_data->raw_packet + IP_HEADER_OFFSET); 1216 tcp = (struct tcphdr *)(fd_data->raw_packet + IP_HEADER_OFFSET 1217 + sizeof(struct iphdr)); 1218 1219 ip->daddr = fsp->h_u.tcp_ip4_spec.ip4dst; 1220 tcp->dest = fsp->h_u.tcp_ip4_spec.pdst; 1221 1222 fd_data->pctype = I40E_FILTER_PCTYPE_NONF_IPV4_TCP_SYN; 1223 ret = i40e_program_fdir_filter(fd_data, pf, add); 1224 1225 if (ret) { 1226 dev_info(&pf->pdev->dev, 1227 "Filter command send failed for PCTYPE %d (ret = %d)\n", 1228 fd_data->pctype, ret); 1229 err = true; 1230 } else { 1231 dev_info(&pf->pdev->dev, "Filter OK for PCTYPE %d (ret = %d)\n", 1232 fd_data->pctype, ret); 1233 } 1234 1235 ip->saddr = fsp->h_u.tcp_ip4_spec.ip4src; 1236 tcp->source = fsp->h_u.tcp_ip4_spec.psrc; 1237 1238 fd_data->pctype = I40E_FILTER_PCTYPE_NONF_IPV4_TCP; 1239 1240 ret = i40e_program_fdir_filter(fd_data, pf, add); 1241 if (ret) { 1242 dev_info(&pf->pdev->dev, 1243 "Filter command send failed for PCTYPE %d (ret = %d)\n", 1244 fd_data->pctype, ret); 1245 err = true; 1246 } else { 1247 dev_info(&pf->pdev->dev, "Filter OK for PCTYPE %d (ret = %d)\n", 1248 fd_data->pctype, ret); 1249 } 1250 1251 return err ? -EOPNOTSUPP : 0; 1252 } 1253 1254 /** 1255 * i40e_add_del_fdir_sctpv4 - Add/Remove SCTPv4 Flow Director filters for 1256 * a specific flow spec 1257 * @vsi: pointer to the targeted VSI 1258 * @fd_data: the flow director data required from the FDir descriptor 1259 * @ethtool_rx_flow_spec: the flow spec 1260 * @add: true adds a filter, false removes it 1261 * 1262 * Returns 0 if the filters were successfully added or removed 1263 **/ 1264 static int i40e_add_del_fdir_sctpv4(struct i40e_vsi *vsi, 1265 struct i40e_fdir_data *fd_data, 1266 struct ethtool_rx_flow_spec *fsp, bool add) 1267 { 1268 return -EOPNOTSUPP; 1269 } 1270 1271 /** 1272 * i40e_add_del_fdir_ipv4 - Add/Remove IPv4 Flow Director filters for 1273 * a specific flow spec 1274 * @vsi: pointer to the targeted VSI 1275 * @fd_data: the flow director data required for the FDir descriptor 1276 * @fsp: the ethtool flow spec 1277 * @add: true adds a filter, false removes it 1278 * 1279 * Returns 0 if the filters were successfully added or removed 1280 **/ 1281 static int i40e_add_del_fdir_ipv4(struct i40e_vsi *vsi, 1282 struct i40e_fdir_data *fd_data, 1283 struct ethtool_rx_flow_spec *fsp, bool add) 1284 { 1285 struct i40e_pf *pf = vsi->back; 1286 struct iphdr *ip; 1287 bool err = false; 1288 int ret; 1289 int i; 1290 1291 ip = (struct iphdr *)(fd_data->raw_packet + IP_HEADER_OFFSET); 1292 1293 ip->saddr = fsp->h_u.usr_ip4_spec.ip4src; 1294 ip->daddr = fsp->h_u.usr_ip4_spec.ip4dst; 1295 ip->protocol = fsp->h_u.usr_ip4_spec.proto; 1296 1297 for (i = I40E_FILTER_PCTYPE_NONF_IPV4_OTHER; 1298 i <= I40E_FILTER_PCTYPE_FRAG_IPV4; i++) { 1299 fd_data->pctype = i; 1300 ret = i40e_program_fdir_filter(fd_data, pf, add); 1301 1302 if (ret) { 1303 dev_info(&pf->pdev->dev, 1304 "Filter command send failed for PCTYPE %d (ret = %d)\n", 1305 fd_data->pctype, ret); 1306 err = true; 1307 } else { 1308 dev_info(&pf->pdev->dev, 1309 "Filter OK for PCTYPE %d (ret = %d)\n", 1310 fd_data->pctype, ret); 1311 } 1312 } 1313 1314 return err ? -EOPNOTSUPP : 0; 1315 } 1316 1317 /** 1318 * i40e_add_del_fdir_ethtool - Add/Remove Flow Director filters for 1319 * a specific flow spec based on their protocol 1320 * @vsi: pointer to the targeted VSI 1321 * @cmd: command to get or set RX flow classification rules 1322 * @add: true adds a filter, false removes it 1323 * 1324 * Returns 0 if the filters were successfully added or removed 1325 **/ 1326 static int i40e_add_del_fdir_ethtool(struct i40e_vsi *vsi, 1327 struct ethtool_rxnfc *cmd, bool add) 1328 { 1329 struct i40e_fdir_data fd_data; 1330 int ret = -EINVAL; 1331 struct i40e_pf *pf; 1332 struct ethtool_rx_flow_spec *fsp = 1333 (struct ethtool_rx_flow_spec *)&cmd->fs; 1334 1335 if (!vsi) 1336 return -EINVAL; 1337 1338 pf = vsi->back; 1339 1340 if ((fsp->ring_cookie != RX_CLS_FLOW_DISC) && 1341 (fsp->ring_cookie >= vsi->num_queue_pairs)) 1342 return -EINVAL; 1343 1344 /* Populate the Flow Director that we have at the moment 1345 * and allocate the raw packet buffer for the calling functions 1346 */ 1347 fd_data.raw_packet = kzalloc(I40E_FDIR_MAX_RAW_PACKET_LOOKUP, 1348 GFP_KERNEL); 1349 1350 if (!fd_data.raw_packet) { 1351 dev_info(&pf->pdev->dev, "Could not allocate memory\n"); 1352 return -ENOMEM; 1353 } 1354 1355 fd_data.q_index = fsp->ring_cookie; 1356 fd_data.flex_off = 0; 1357 fd_data.pctype = 0; 1358 fd_data.dest_vsi = vsi->id; 1359 fd_data.dest_ctl = 0; 1360 fd_data.fd_status = 0; 1361 fd_data.cnt_index = 0; 1362 fd_data.fd_id = 0; 1363 1364 switch (fsp->flow_type & ~FLOW_EXT) { 1365 case TCP_V4_FLOW: 1366 ret = i40e_add_del_fdir_tcpv4(vsi, &fd_data, fsp, add); 1367 break; 1368 case UDP_V4_FLOW: 1369 ret = i40e_add_del_fdir_udpv4(vsi, &fd_data, fsp, add); 1370 break; 1371 case SCTP_V4_FLOW: 1372 ret = i40e_add_del_fdir_sctpv4(vsi, &fd_data, fsp, add); 1373 break; 1374 case IPV4_FLOW: 1375 ret = i40e_add_del_fdir_ipv4(vsi, &fd_data, fsp, add); 1376 break; 1377 case IP_USER_FLOW: 1378 switch (fsp->h_u.usr_ip4_spec.proto) { 1379 case IPPROTO_TCP: 1380 ret = i40e_add_del_fdir_tcpv4(vsi, &fd_data, fsp, add); 1381 break; 1382 case IPPROTO_UDP: 1383 ret = i40e_add_del_fdir_udpv4(vsi, &fd_data, fsp, add); 1384 break; 1385 case IPPROTO_SCTP: 1386 ret = i40e_add_del_fdir_sctpv4(vsi, &fd_data, fsp, add); 1387 break; 1388 default: 1389 ret = i40e_add_del_fdir_ipv4(vsi, &fd_data, fsp, add); 1390 break; 1391 } 1392 break; 1393 default: 1394 dev_info(&pf->pdev->dev, "Could not specify spec type\n"); 1395 ret = -EINVAL; 1396 } 1397 1398 kfree(fd_data.raw_packet); 1399 fd_data.raw_packet = NULL; 1400 1401 return ret; 1402 } 1403 /** 1404 * i40e_set_rxnfc - command to set RX flow classification rules 1405 * @netdev: network interface device structure 1406 * @cmd: ethtool rxnfc command 1407 * 1408 * Returns Success if the command is supported. 1409 **/ 1410 static int i40e_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd) 1411 { 1412 struct i40e_netdev_priv *np = netdev_priv(netdev); 1413 struct i40e_vsi *vsi = np->vsi; 1414 struct i40e_pf *pf = vsi->back; 1415 int ret = -EOPNOTSUPP; 1416 1417 switch (cmd->cmd) { 1418 case ETHTOOL_SRXFH: 1419 ret = i40e_set_rss_hash_opt(pf, cmd); 1420 break; 1421 case ETHTOOL_SRXCLSRLINS: 1422 ret = i40e_add_del_fdir_ethtool(vsi, cmd, true); 1423 break; 1424 case ETHTOOL_SRXCLSRLDEL: 1425 ret = i40e_add_del_fdir_ethtool(vsi, cmd, false); 1426 break; 1427 default: 1428 break; 1429 } 1430 1431 return ret; 1432 } 1433 1434 static const struct ethtool_ops i40e_ethtool_ops = { 1435 .get_settings = i40e_get_settings, 1436 .get_drvinfo = i40e_get_drvinfo, 1437 .get_regs_len = i40e_get_regs_len, 1438 .get_regs = i40e_get_regs, 1439 .nway_reset = i40e_nway_reset, 1440 .get_link = ethtool_op_get_link, 1441 .get_wol = i40e_get_wol, 1442 .get_eeprom_len = i40e_get_eeprom_len, 1443 .get_eeprom = i40e_get_eeprom, 1444 .get_ringparam = i40e_get_ringparam, 1445 .set_ringparam = i40e_set_ringparam, 1446 .get_pauseparam = i40e_get_pauseparam, 1447 .get_msglevel = i40e_get_msglevel, 1448 .set_msglevel = i40e_set_msglevel, 1449 .get_rxnfc = i40e_get_rxnfc, 1450 .set_rxnfc = i40e_set_rxnfc, 1451 .self_test = i40e_diag_test, 1452 .get_strings = i40e_get_strings, 1453 .set_phys_id = i40e_set_phys_id, 1454 .get_sset_count = i40e_get_sset_count, 1455 .get_ethtool_stats = i40e_get_ethtool_stats, 1456 .get_coalesce = i40e_get_coalesce, 1457 .set_coalesce = i40e_set_coalesce, 1458 .get_ts_info = i40e_get_ts_info, 1459 }; 1460 1461 void i40e_set_ethtool_ops(struct net_device *netdev) 1462 { 1463 SET_ETHTOOL_OPS(netdev, &i40e_ethtool_ops); 1464 } 1465