drivers/net/ethernet/intel/i40e/i40e_ethtool.c

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