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 {
 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 }