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

   1 /*******************************************************************************
   2  *
   3  * Intel Ethernet Controller XL710 Family Linux Driver
   4  * Copyright(c) 2013 - 2014 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
  16  * with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * The full GNU General Public License is included in this distribution in
  19  * the file called "COPYING".
  20  *
  21  * Contact Information:
  22  * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
  23  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  24  *
  25  ******************************************************************************/
  26
  27 /* ethtool support for i40e */
  28
  29 #include "i40e.h"
  30 #include "i40e_diag.h"
  31
  32 struct i40e_stats {
  33         char stat_string[ETH_GSTRING_LEN];
  34         int sizeof_stat;
  35         int stat_offset;
  36 };
  37
  38 #define I40E_STAT(_type, _name, _stat) { \
  39         .stat_string = _name, \
  40         .sizeof_stat = FIELD_SIZEOF(_type, _stat), \
  41         .stat_offset = offsetof(_type, _stat) \
  42 }
  43 #define I40E_NETDEV_STAT(_net_stat) \
  44                 I40E_STAT(struct net_device_stats, #_net_stat, _net_stat)
  45 #define I40E_PF_STAT(_name, _stat) \
  46                 I40E_STAT(struct i40e_pf, _name, _stat)
  47 #define I40E_VSI_STAT(_name, _stat) \
  48                 I40E_STAT(struct i40e_vsi, _name, _stat)
  49 #define I40E_VEB_STAT(_name, _stat) \
  50                 I40E_STAT(struct i40e_veb, _name, _stat)
  51
  52 static const struct i40e_stats i40e_gstrings_net_stats[] = {
  53         I40E_NETDEV_STAT(rx_packets),
  54         I40E_NETDEV_STAT(tx_packets),
  55         I40E_NETDEV_STAT(rx_bytes),
  56         I40E_NETDEV_STAT(tx_bytes),
  57         I40E_NETDEV_STAT(rx_errors),
  58         I40E_NETDEV_STAT(tx_errors),
  59         I40E_NETDEV_STAT(rx_dropped),
  60         I40E_NETDEV_STAT(tx_dropped),
  61         I40E_NETDEV_STAT(collisions),
  62         I40E_NETDEV_STAT(rx_length_errors),
  63         I40E_NETDEV_STAT(rx_crc_errors),
  64 };
  65
  66 static const struct i40e_stats i40e_gstrings_veb_stats[] = {
  67         I40E_VEB_STAT("rx_bytes", stats.rx_bytes),
  68         I40E_VEB_STAT("tx_bytes", stats.tx_bytes),
  69         I40E_VEB_STAT("rx_unicast", stats.rx_unicast),
  70         I40E_VEB_STAT("tx_unicast", stats.tx_unicast),
  71         I40E_VEB_STAT("rx_multicast", stats.rx_multicast),
  72         I40E_VEB_STAT("tx_multicast", stats.tx_multicast),
  73         I40E_VEB_STAT("rx_broadcast", stats.rx_broadcast),
  74         I40E_VEB_STAT("tx_broadcast", stats.tx_broadcast),
  75         I40E_VEB_STAT("rx_discards", stats.rx_discards),
  76         I40E_VEB_STAT("tx_discards", stats.tx_discards),
  77         I40E_VEB_STAT("tx_errors", stats.tx_errors),
  78         I40E_VEB_STAT("rx_unknown_protocol", stats.rx_unknown_protocol),
  79 };
  80
  81 static const struct i40e_stats i40e_gstrings_misc_stats[] = {
  82         I40E_VSI_STAT("rx_unicast", eth_stats.rx_unicast),
  83         I40E_VSI_STAT("tx_unicast", eth_stats.tx_unicast),
  84         I40E_VSI_STAT("rx_multicast", eth_stats.rx_multicast),
  85         I40E_VSI_STAT("tx_multicast", eth_stats.tx_multicast),
  86         I40E_VSI_STAT("rx_broadcast", eth_stats.rx_broadcast),
  87         I40E_VSI_STAT("tx_broadcast", eth_stats.tx_broadcast),
  88         I40E_VSI_STAT("rx_unknown_protocol", eth_stats.rx_unknown_protocol),
  89 };
  90
  91 static int i40e_add_fdir_ethtool(struct i40e_vsi *vsi,
  92                                  struct ethtool_rxnfc *cmd);
  93
  94 /* These PF_STATs might look like duplicates of some NETDEV_STATs,
  95  * but they are separate.  This device supports Virtualization, and
  96  * as such might have several netdevs supporting VMDq and FCoE going
  97  * through a single port.  The NETDEV_STATs are for individual netdevs
  98  * seen at the top of the stack, and the PF_STATs are for the physical
  99  * function at the bottom of the stack hosting those netdevs.
 100  *
 101  * The PF_STATs are appended to the netdev stats only when ethtool -S
 102  * is queried on the base PF netdev, not on the VMDq or FCoE netdev.
 103  */
 104 static struct i40e_stats i40e_gstrings_stats[] = {
 105         I40E_PF_STAT("rx_bytes", stats.eth.rx_bytes),
 106         I40E_PF_STAT("tx_bytes", stats.eth.tx_bytes),
 107         I40E_PF_STAT("rx_unicast", stats.eth.rx_unicast),
 108         I40E_PF_STAT("tx_unicast", stats.eth.tx_unicast),
 109         I40E_PF_STAT("rx_multicast", stats.eth.rx_multicast),
 110         I40E_PF_STAT("tx_multicast", stats.eth.tx_multicast),
 111         I40E_PF_STAT("rx_broadcast", stats.eth.rx_broadcast),
 112         I40E_PF_STAT("tx_broadcast", stats.eth.tx_broadcast),
 113         I40E_PF_STAT("tx_errors", stats.eth.tx_errors),
 114         I40E_PF_STAT("rx_dropped", stats.eth.rx_discards),
 115         I40E_PF_STAT("tx_dropped", stats.eth.tx_discards),
 116         I40E_PF_STAT("tx_dropped_link_down", stats.tx_dropped_link_down),
 117         I40E_PF_STAT("crc_errors", stats.crc_errors),
 118         I40E_PF_STAT("illegal_bytes", stats.illegal_bytes),
 119         I40E_PF_STAT("mac_local_faults", stats.mac_local_faults),
 120         I40E_PF_STAT("mac_remote_faults", stats.mac_remote_faults),
 121         I40E_PF_STAT("tx_timeout", tx_timeout_count),
 122         I40E_PF_STAT("rx_csum_bad", hw_csum_rx_error),
 123         I40E_PF_STAT("rx_length_errors", stats.rx_length_errors),
 124         I40E_PF_STAT("link_xon_rx", stats.link_xon_rx),
 125         I40E_PF_STAT("link_xoff_rx", stats.link_xoff_rx),
 126         I40E_PF_STAT("link_xon_tx", stats.link_xon_tx),
 127         I40E_PF_STAT("link_xoff_tx", stats.link_xoff_tx),
 128         I40E_PF_STAT("rx_size_64", stats.rx_size_64),
 129         I40E_PF_STAT("rx_size_127", stats.rx_size_127),
 130         I40E_PF_STAT("rx_size_255", stats.rx_size_255),
 131         I40E_PF_STAT("rx_size_511", stats.rx_size_511),
 132         I40E_PF_STAT("rx_size_1023", stats.rx_size_1023),
 133         I40E_PF_STAT("rx_size_1522", stats.rx_size_1522),
 134         I40E_PF_STAT("rx_size_big", stats.rx_size_big),
 135         I40E_PF_STAT("tx_size_64", stats.tx_size_64),
 136         I40E_PF_STAT("tx_size_127", stats.tx_size_127),
 137         I40E_PF_STAT("tx_size_255", stats.tx_size_255),
 138         I40E_PF_STAT("tx_size_511", stats.tx_size_511),
 139         I40E_PF_STAT("tx_size_1023", stats.tx_size_1023),
 140         I40E_PF_STAT("tx_size_1522", stats.tx_size_1522),
 141         I40E_PF_STAT("tx_size_big", stats.tx_size_big),
 142         I40E_PF_STAT("rx_undersize", stats.rx_undersize),
 143         I40E_PF_STAT("rx_fragments", stats.rx_fragments),
 144         I40E_PF_STAT("rx_oversize", stats.rx_oversize),
 145         I40E_PF_STAT("rx_jabber", stats.rx_jabber),
 146         I40E_PF_STAT("VF_admin_queue_requests", vf_aq_requests),
 147         I40E_PF_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
 148         I40E_PF_STAT("fdir_atr_match", stats.fd_atr_match),
 149         I40E_PF_STAT("fdir_sb_match", stats.fd_sb_match),
 150
 151         /* LPI stats */
 152         I40E_PF_STAT("tx_lpi_status", stats.tx_lpi_status),
 153         I40E_PF_STAT("rx_lpi_status", stats.rx_lpi_status),
 154         I40E_PF_STAT("tx_lpi_count", stats.tx_lpi_count),
 155         I40E_PF_STAT("rx_lpi_count", stats.rx_lpi_count),
 156 };
 157
 158 #define I40E_QUEUE_STATS_LEN(n) \
 159         (((struct i40e_netdev_priv *)netdev_priv((n)))->vsi->num_queue_pairs \
 160             * 2 /* Tx and Rx together */                                     \
 161             * (sizeof(struct i40e_queue_stats) / sizeof(u64)))
 162 #define I40E_GLOBAL_STATS_LEN   ARRAY_SIZE(i40e_gstrings_stats)
 163 #define I40E_NETDEV_STATS_LEN   ARRAY_SIZE(i40e_gstrings_net_stats)
 164 #define I40E_MISC_STATS_LEN     ARRAY_SIZE(i40e_gstrings_misc_stats)
 165 #define I40E_VSI_STATS_LEN(n)   (I40E_NETDEV_STATS_LEN + \
 166                                  I40E_MISC_STATS_LEN + \
 167                                  I40E_QUEUE_STATS_LEN((n)))
 168 #define I40E_PFC_STATS_LEN ( \
 169                 (FIELD_SIZEOF(struct i40e_pf, stats.priority_xoff_rx) + \
 170                  FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_rx) + \
 171                  FIELD_SIZEOF(struct i40e_pf, stats.priority_xoff_tx) + \
 172                  FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_tx) + \
 173                  FIELD_SIZEOF(struct i40e_pf, stats.priority_xon_2_xoff)) \
 174                  / sizeof(u64))
 175 #define I40E_VEB_STATS_LEN      ARRAY_SIZE(i40e_gstrings_veb_stats)
 176 #define I40E_PF_STATS_LEN(n)    (I40E_GLOBAL_STATS_LEN + \
 177                                  I40E_PFC_STATS_LEN + \
 178                                  I40E_VSI_STATS_LEN((n)))
 179
 180 enum i40e_ethtool_test_id {
 181         I40E_ETH_TEST_REG = 0,
 182         I40E_ETH_TEST_EEPROM,
 183         I40E_ETH_TEST_INTR,
 184         I40E_ETH_TEST_LOOPBACK,
 185         I40E_ETH_TEST_LINK,
 186 };
 187
 188 static const char i40e_gstrings_test[][ETH_GSTRING_LEN] = {
 189         "Register test  (offline)",
 190         "Eeprom test    (offline)",
 191         "Interrupt test (offline)",
 192         "Loopback test  (offline)",
 193         "Link test   (on/offline)"
 194 };
 195
 196 #define I40E_TEST_LEN (sizeof(i40e_gstrings_test) / ETH_GSTRING_LEN)
 197
 198 /**
 199  * i40e_get_settings - Get Link Speed and Duplex settings
 200  * @netdev: network interface device structure
 201  * @ecmd: ethtool command
 202  *
 203  * Reports speed/duplex settings based on media_type
 204  **/
 205 static int i40e_get_settings(struct net_device *netdev,
 206                              struct ethtool_cmd *ecmd)
 207 {
 208         struct i40e_netdev_priv *np = netdev_priv(netdev);
 209         struct i40e_pf *pf = np->vsi->back;
 210         struct i40e_hw *hw = &pf->hw;
 211         struct i40e_link_status *hw_link_info = &hw->phy.link_info;
 212         bool link_up = hw_link_info->link_info & I40E_AQ_LINK_UP;
 213         u32 link_speed = hw_link_info->link_speed;
 214
 215         /* hardware is either in 40G mode or 10G mode
 216          * NOTE: this section initializes supported and advertising
 217          */
 218         switch (hw_link_info->phy_type) {
 219         case I40E_PHY_TYPE_40GBASE_CR4:
 220         case I40E_PHY_TYPE_40GBASE_CR4_CU:
 221                 ecmd->supported = SUPPORTED_40000baseCR4_Full;
 222                 ecmd->advertising = ADVERTISED_40000baseCR4_Full;
 223                 break;
 224         case I40E_PHY_TYPE_40GBASE_KR4:
 225                 ecmd->supported = SUPPORTED_40000baseKR4_Full;
 226                 ecmd->advertising = ADVERTISED_40000baseKR4_Full;
 227                 break;
 228         case I40E_PHY_TYPE_40GBASE_SR4:
 229                 ecmd->supported = SUPPORTED_40000baseSR4_Full;
 230                 ecmd->advertising = ADVERTISED_40000baseSR4_Full;
 231                 break;
 232         case I40E_PHY_TYPE_40GBASE_LR4:
 233                 ecmd->supported = SUPPORTED_40000baseLR4_Full;
 234                 ecmd->advertising = ADVERTISED_40000baseLR4_Full;
 235                 break;
 236         case I40E_PHY_TYPE_10GBASE_KX4:
 237                 ecmd->supported = SUPPORTED_10000baseKX4_Full;
 238                 ecmd->advertising = ADVERTISED_10000baseKX4_Full;
 239                 break;
 240         case I40E_PHY_TYPE_10GBASE_KR:
 241                 ecmd->supported = SUPPORTED_10000baseKR_Full;
 242                 ecmd->advertising = ADVERTISED_10000baseKR_Full;
 243                 break;
 244         default:
 245                 if (i40e_is_40G_device(hw->device_id)) {
 246                         ecmd->supported = SUPPORTED_40000baseSR4_Full;
 247                         ecmd->advertising = ADVERTISED_40000baseSR4_Full;
 248                 } else {
 249                         ecmd->supported = SUPPORTED_10000baseT_Full;
 250                         ecmd->advertising = ADVERTISED_10000baseT_Full;
 251                 }
 252                 break;
 253         }
 254
 255         ecmd->supported |= SUPPORTED_Autoneg;
 256         ecmd->advertising |= ADVERTISED_Autoneg;
 257         ecmd->autoneg = ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ?
 258                           AUTONEG_ENABLE : AUTONEG_DISABLE);
 259
 260         switch (hw->phy.media_type) {
 261         case I40E_MEDIA_TYPE_BACKPLANE:
 262                 ecmd->supported |= SUPPORTED_Backplane;
 263                 ecmd->advertising |= ADVERTISED_Backplane;
 264                 ecmd->port = PORT_NONE;
 265                 break;
 266         case I40E_MEDIA_TYPE_BASET:
 267                 ecmd->supported |= SUPPORTED_TP;
 268                 ecmd->advertising |= ADVERTISED_TP;
 269                 ecmd->port = PORT_TP;
 270                 break;
 271         case I40E_MEDIA_TYPE_DA:
 272         case I40E_MEDIA_TYPE_CX4:
 273                 ecmd->supported |= SUPPORTED_FIBRE;
 274                 ecmd->advertising |= ADVERTISED_FIBRE;
 275                 ecmd->port = PORT_DA;
 276                 break;
 277         case I40E_MEDIA_TYPE_FIBER:
 278                 ecmd->supported |= SUPPORTED_FIBRE;
 279                 ecmd->advertising |= ADVERTISED_FIBRE;
 280                 ecmd->port = PORT_FIBRE;
 281                 break;
 282         case I40E_MEDIA_TYPE_UNKNOWN:
 283         default:
 284                 ecmd->port = PORT_OTHER;
 285                 break;
 286         }
 287
 288         ecmd->transceiver = XCVR_EXTERNAL;
 289
 290         if (link_up) {
 291                 switch (link_speed) {
 292                 case I40E_LINK_SPEED_40GB:
 293                         /* need a SPEED_40000 in ethtool.h */
 294                         ethtool_cmd_speed_set(ecmd, 40000);
 295                         break;
 296                 case I40E_LINK_SPEED_10GB:
 297                         ethtool_cmd_speed_set(ecmd, SPEED_10000);
 298                         break;
 299                 default:
 300                         break;
 301                 }
 302                 ecmd->duplex = DUPLEX_FULL;
 303         } else {
 304                 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
 305                 ecmd->duplex = DUPLEX_UNKNOWN;
 306         }
 307
 308         return 0;
 309 }
 310
 311 /**
 312  * i40e_get_pauseparam -  Get Flow Control status
 313  * Return tx/rx-pause status
 314  **/
 315 static void i40e_get_pauseparam(struct net_device *netdev,
 316                                 struct ethtool_pauseparam *pause)
 317 {
 318         struct i40e_netdev_priv *np = netdev_priv(netdev);
 319         struct i40e_pf *pf = np->vsi->back;
 320         struct i40e_hw *hw = &pf->hw;
 321         struct i40e_link_status *hw_link_info = &hw->phy.link_info;
 322
 323         pause->autoneg =
 324                 ((hw_link_info->an_info & I40E_AQ_AN_COMPLETED) ?
 325                   AUTONEG_ENABLE : AUTONEG_DISABLE);
 326
 327         if (hw->fc.current_mode == I40E_FC_RX_PAUSE) {
 328                 pause->rx_pause = 1;
 329         } else if (hw->fc.current_mode == I40E_FC_TX_PAUSE) {
 330                 pause->tx_pause = 1;
 331         } else if (hw->fc.current_mode == I40E_FC_FULL) {
 332                 pause->rx_pause = 1;
 333                 pause->tx_pause = 1;
 334         }
 335 }
 336
 337 static u32 i40e_get_msglevel(struct net_device *netdev)
 338 {
 339         struct i40e_netdev_priv *np = netdev_priv(netdev);
 340         struct i40e_pf *pf = np->vsi->back;
 341
 342         return pf->msg_enable;
 343 }
 344
 345 static void i40e_set_msglevel(struct net_device *netdev, u32 data)
 346 {
 347         struct i40e_netdev_priv *np = netdev_priv(netdev);
 348         struct i40e_pf *pf = np->vsi->back;
 349
 350         if (I40E_DEBUG_USER & data)
 351                 pf->hw.debug_mask = data;
 352         pf->msg_enable = data;
 353 }
 354
 355 static int i40e_get_regs_len(struct net_device *netdev)
 356 {
 357         int reg_count = 0;
 358         int i;
 359
 360         for (i = 0; i40e_reg_list[i].offset != 0; i++)
 361                 reg_count += i40e_reg_list[i].elements;
 362
 363         return reg_count * sizeof(u32);
 364 }
 365
 366 static void i40e_get_regs(struct net_device *netdev, struct ethtool_regs *regs,
 367                           void *p)
 368 {
 369         struct i40e_netdev_priv *np = netdev_priv(netdev);
 370         struct i40e_pf *pf = np->vsi->back;
 371         struct i40e_hw *hw = &pf->hw;
 372         u32 *reg_buf = p;
 373         int i, j, ri;
 374         u32 reg;
 375
 376         /* Tell ethtool which driver-version-specific regs output we have.
 377          *
 378          * At some point, if we have ethtool doing special formatting of
 379          * this data, it will rely on this version number to know how to
 380          * interpret things.  Hence, this needs to be updated if/when the
 381          * diags register table is changed.
 382          */
 383         regs->version = 1;
 384
 385         /* loop through the diags reg table for what to print */
 386         ri = 0;
 387         for (i = 0; i40e_reg_list[i].offset != 0; i++) {
 388                 for (j = 0; j < i40e_reg_list[i].elements; j++) {
 389                         reg = i40e_reg_list[i].offset
 390                                 + (j * i40e_reg_list[i].stride);
 391                         reg_buf[ri++] = rd32(hw, reg);
 392                 }
 393         }
 394
 395 }
 396
 397 static int i40e_get_eeprom(struct net_device *netdev,
 398                            struct ethtool_eeprom *eeprom, u8 *bytes)
 399 {
 400         struct i40e_netdev_priv *np = netdev_priv(netdev);
 401         struct i40e_hw *hw = &np->vsi->back->hw;
 402         struct i40e_pf *pf = np->vsi->back;
 403         int ret_val = 0, len;
 404         u8 *eeprom_buff;
 405         u16 i, sectors;
 406         bool last;
 407 #define I40E_NVM_SECTOR_SIZE  4096
 408         if (eeprom->len == 0)
 409                 return -EINVAL;
 410
 411         eeprom->magic = hw->vendor_id | (hw->device_id << 16);
 412
 413         eeprom_buff = kzalloc(eeprom->len, GFP_KERNEL);
 414         if (!eeprom_buff)
 415                 return -ENOMEM;
 416
 417         ret_val = i40e_acquire_nvm(hw, I40E_RESOURCE_READ);
 418         if (ret_val) {
 419                 dev_info(&pf->pdev->dev,
 420                          "Failed Acquiring NVM resource for read err=%d status=0x%x\n",
 421                          ret_val, hw->aq.asq_last_status);
 422                 goto free_buff;
 423         }
 424
 425         sectors = eeprom->len / I40E_NVM_SECTOR_SIZE;
 426         sectors += (eeprom->len % I40E_NVM_SECTOR_SIZE) ? 1 : 0;
 427         len = I40E_NVM_SECTOR_SIZE;
 428         last = false;
 429         for (i = 0; i < sectors; i++) {
 430                 if (i == (sectors - 1)) {
 431                         len = eeprom->len - (I40E_NVM_SECTOR_SIZE * i);
 432                         last = true;
 433                 }
 434                 ret_val = i40e_aq_read_nvm(hw, 0x0,
 435                                 eeprom->offset + (I40E_NVM_SECTOR_SIZE * i),
 436                                 len,
 437                                 eeprom_buff + (I40E_NVM_SECTOR_SIZE * i),
 438                                 last, NULL);
 439                 if (ret_val) {
 440                         dev_info(&pf->pdev->dev,
 441                                  "read NVM failed err=%d status=0x%x\n",
 442                                  ret_val, hw->aq.asq_last_status);
 443                         goto release_nvm;
 444                 }
 445         }
 446
 447 release_nvm:
 448         i40e_release_nvm(hw);
 449         memcpy(bytes, eeprom_buff, eeprom->len);
 450 free_buff:
 451         kfree(eeprom_buff);
 452         return ret_val;
 453 }
 454
 455 static int i40e_get_eeprom_len(struct net_device *netdev)
 456 {
 457         struct i40e_netdev_priv *np = netdev_priv(netdev);
 458         struct i40e_hw *hw = &np->vsi->back->hw;
 459         u32 val;
 460
 461         val = (rd32(hw, I40E_GLPCI_LBARCTRL)
 462                 & I40E_GLPCI_LBARCTRL_FL_SIZE_MASK)
 463                 >> I40E_GLPCI_LBARCTRL_FL_SIZE_SHIFT;
 464         /* register returns value in power of 2, 64Kbyte chunks. */
 465         val = (64 * 1024) * (1 << val);
 466         return val;
 467 }
 468
 469 static void i40e_get_drvinfo(struct net_device *netdev,
 470                              struct ethtool_drvinfo *drvinfo)
 471 {
 472         struct i40e_netdev_priv *np = netdev_priv(netdev);
 473         struct i40e_vsi *vsi = np->vsi;
 474         struct i40e_pf *pf = vsi->back;
 475
 476         strlcpy(drvinfo->driver, i40e_driver_name, sizeof(drvinfo->driver));
 477         strlcpy(drvinfo->version, i40e_driver_version_str,
 478                 sizeof(drvinfo->version));
 479         strlcpy(drvinfo->fw_version, i40e_fw_version_str(&pf->hw),
 480                 sizeof(drvinfo->fw_version));
 481         strlcpy(drvinfo->bus_info, pci_name(pf->pdev),
 482                 sizeof(drvinfo->bus_info));
 483 }
 484
 485 static void i40e_get_ringparam(struct net_device *netdev,
 486                                struct ethtool_ringparam *ring)
 487 {
 488         struct i40e_netdev_priv *np = netdev_priv(netdev);
 489         struct i40e_pf *pf = np->vsi->back;
 490         struct i40e_vsi *vsi = pf->vsi[pf->lan_vsi];
 491
 492         ring->rx_max_pending = I40E_MAX_NUM_DESCRIPTORS;
 493         ring->tx_max_pending = I40E_MAX_NUM_DESCRIPTORS;
 494         ring->rx_mini_max_pending = 0;
 495         ring->rx_jumbo_max_pending = 0;
 496         ring->rx_pending = vsi->rx_rings[0]->count;
 497         ring->tx_pending = vsi->tx_rings[0]->count;
 498         ring->rx_mini_pending = 0;
 499         ring->rx_jumbo_pending = 0;
 500 }
 501
 502 static int i40e_set_ringparam(struct net_device *netdev,
 503                               struct ethtool_ringparam *ring)
 504 {
 505         struct i40e_ring *tx_rings = NULL, *rx_rings = NULL;
 506         struct i40e_netdev_priv *np = netdev_priv(netdev);
 507         struct i40e_vsi *vsi = np->vsi;
 508         struct i40e_pf *pf = vsi->back;
 509         u32 new_rx_count, new_tx_count;
 510         int i, err = 0;
 511
 512         if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 513                 return -EINVAL;
 514
 515         if (ring->tx_pending > I40E_MAX_NUM_DESCRIPTORS ||
 516             ring->tx_pending < I40E_MIN_NUM_DESCRIPTORS ||
 517             ring->rx_pending > I40E_MAX_NUM_DESCRIPTORS ||
 518             ring->rx_pending < I40E_MIN_NUM_DESCRIPTORS) {
 519                 netdev_info(netdev,
 520                             "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d]\n",
 521                             ring->tx_pending, ring->rx_pending,
 522                             I40E_MIN_NUM_DESCRIPTORS, I40E_MAX_NUM_DESCRIPTORS);
 523                 return -EINVAL;
 524         }
 525
 526         new_tx_count = ALIGN(ring->tx_pending, I40E_REQ_DESCRIPTOR_MULTIPLE);
 527         new_rx_count = ALIGN(ring->rx_pending, I40E_REQ_DESCRIPTOR_MULTIPLE);
 528
 529         /* if nothing to do return success */
 530         if ((new_tx_count == vsi->tx_rings[0]->count) &&
 531             (new_rx_count == vsi->rx_rings[0]->count))
 532                 return 0;
 533
 534         while (test_and_set_bit(__I40E_CONFIG_BUSY, &pf->state))
 535                 usleep_range(1000, 2000);
 536
 537         if (!netif_running(vsi->netdev)) {
 538                 /* simple case - set for the next time the netdev is started */
 539                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 540                         vsi->tx_rings[i]->count = new_tx_count;
 541                         vsi->rx_rings[i]->count = new_rx_count;
 542                 }
 543                 goto done;
 544         }
 545
 546         /* We can't just free everything and then setup again,
 547          * because the ISRs in MSI-X mode get passed pointers
 548          * to the Tx and Rx ring structs.
 549          */
 550
 551         /* alloc updated Tx resources */
 552         if (new_tx_count != vsi->tx_rings[0]->count) {
 553                 netdev_info(netdev,
 554                             "Changing Tx descriptor count from %d to %d.\n",
 555                             vsi->tx_rings[0]->count, new_tx_count);
 556                 tx_rings = kcalloc(vsi->alloc_queue_pairs,
 557                                    sizeof(struct i40e_ring), GFP_KERNEL);
 558                 if (!tx_rings) {
 559                         err = -ENOMEM;
 560                         goto done;
 561                 }
 562
 563                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 564                         /* clone ring and setup updated count */
 565                         tx_rings[i] = *vsi->tx_rings[i];
 566                         tx_rings[i].count = new_tx_count;
 567                         err = i40e_setup_tx_descriptors(&tx_rings[i]);
 568                         if (err) {
 569                                 while (i) {
 570                                         i--;
 571                                         i40e_free_tx_resources(&tx_rings[i]);
 572                                 }
 573                                 kfree(tx_rings);
 574                                 tx_rings = NULL;
 575
 576                                 goto done;
 577                         }
 578                 }
 579         }
 580
 581         /* alloc updated Rx resources */
 582         if (new_rx_count != vsi->rx_rings[0]->count) {
 583                 netdev_info(netdev,
 584                             "Changing Rx descriptor count from %d to %d\n",
 585                             vsi->rx_rings[0]->count, new_rx_count);
 586                 rx_rings = kcalloc(vsi->alloc_queue_pairs,
 587                                    sizeof(struct i40e_ring), GFP_KERNEL);
 588                 if (!rx_rings) {
 589                         err = -ENOMEM;
 590                         goto free_tx;
 591                 }
 592
 593                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 594                         /* clone ring and setup updated count */
 595                         rx_rings[i] = *vsi->rx_rings[i];
 596                         rx_rings[i].count = new_rx_count;
 597                         err = i40e_setup_rx_descriptors(&rx_rings[i]);
 598                         if (err) {
 599                                 while (i) {
 600                                         i--;
 601                                         i40e_free_rx_resources(&rx_rings[i]);
 602                                 }
 603                                 kfree(rx_rings);
 604                                 rx_rings = NULL;
 605
 606                                 goto free_tx;
 607                         }
 608                 }
 609         }
 610
 611         /* Bring interface down, copy in the new ring info,
 612          * then restore the interface
 613          */
 614         i40e_down(vsi);
 615
 616         if (tx_rings) {
 617                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 618                         i40e_free_tx_resources(vsi->tx_rings[i]);
 619                         *vsi->tx_rings[i] = tx_rings[i];
 620                 }
 621                 kfree(tx_rings);
 622                 tx_rings = NULL;
 623         }
 624
 625         if (rx_rings) {
 626                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 627                         i40e_free_rx_resources(vsi->rx_rings[i]);
 628                         *vsi->rx_rings[i] = rx_rings[i];
 629                 }
 630                 kfree(rx_rings);
 631                 rx_rings = NULL;
 632         }
 633
 634         i40e_up(vsi);
 635
 636 free_tx:
 637         /* error cleanup if the Rx allocations failed after getting Tx */
 638         if (tx_rings) {
 639                 for (i = 0; i < vsi->num_queue_pairs; i++)
 640                         i40e_free_tx_resources(&tx_rings[i]);
 641                 kfree(tx_rings);
 642                 tx_rings = NULL;
 643         }
 644
 645 done:
 646         clear_bit(__I40E_CONFIG_BUSY, &pf->state);
 647
 648         return err;
 649 }
 650
 651 static int i40e_get_sset_count(struct net_device *netdev, int sset)
 652 {
 653         struct i40e_netdev_priv *np = netdev_priv(netdev);
 654         struct i40e_vsi *vsi = np->vsi;
 655         struct i40e_pf *pf = vsi->back;
 656
 657         switch (sset) {
 658         case ETH_SS_TEST:
 659                 return I40E_TEST_LEN;
 660         case ETH_SS_STATS:
 661                 if (vsi == pf->vsi[pf->lan_vsi]) {
 662                         int len = I40E_PF_STATS_LEN(netdev);
 663
 664                         if (pf->lan_veb != I40E_NO_VEB)
 665                                 len += I40E_VEB_STATS_LEN;
 666                         return len;
 667                 } else {
 668                         return I40E_VSI_STATS_LEN(netdev);
 669                 }
 670         default:
 671                 return -EOPNOTSUPP;
 672         }
 673 }
 674
 675 static void i40e_get_ethtool_stats(struct net_device *netdev,
 676                                    struct ethtool_stats *stats, u64 *data)
 677 {
 678         struct i40e_netdev_priv *np = netdev_priv(netdev);
 679         struct i40e_ring *tx_ring, *rx_ring;
 680         struct i40e_vsi *vsi = np->vsi;
 681         struct i40e_pf *pf = vsi->back;
 682         int i = 0;
 683         char *p;
 684         int j;
 685         struct rtnl_link_stats64 *net_stats = i40e_get_vsi_stats_struct(vsi);
 686         unsigned int start;
 687
 688         i40e_update_stats(vsi);
 689
 690         for (j = 0; j < I40E_NETDEV_STATS_LEN; j++) {
 691                 p = (char *)net_stats + i40e_gstrings_net_stats[j].stat_offset;
 692                 data[i++] = (i40e_gstrings_net_stats[j].sizeof_stat ==
 693                         sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 694         }
 695         for (j = 0; j < I40E_MISC_STATS_LEN; j++) {
 696                 p = (char *)vsi + i40e_gstrings_misc_stats[j].stat_offset;
 697                 data[i++] = (i40e_gstrings_misc_stats[j].sizeof_stat ==
 698                             sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 699         }
 700         rcu_read_lock();
 701         for (j = 0; j < vsi->num_queue_pairs; j++) {
 702                 tx_ring = ACCESS_ONCE(vsi->tx_rings[j]);
 703
 704                 if (!tx_ring)
 705                         continue;
 706
 707                 /* process Tx ring statistics */
 708                 do {
 709                         start = u64_stats_fetch_begin_irq(&tx_ring->syncp);
 710                         data[i] = tx_ring->stats.packets;
 711                         data[i + 1] = tx_ring->stats.bytes;
 712                 } while (u64_stats_fetch_retry_irq(&tx_ring->syncp, start));
 713                 i += 2;
 714
 715                 /* Rx ring is the 2nd half of the queue pair */
 716                 rx_ring = &tx_ring[1];
 717                 do {
 718                         start = u64_stats_fetch_begin_irq(&rx_ring->syncp);
 719                         data[i] = rx_ring->stats.packets;
 720                         data[i + 1] = rx_ring->stats.bytes;
 721                 } while (u64_stats_fetch_retry_irq(&rx_ring->syncp, start));
 722                 i += 2;
 723         }
 724         rcu_read_unlock();
 725         if (vsi != pf->vsi[pf->lan_vsi])
 726                 return;
 727
 728         if (pf->lan_veb != I40E_NO_VEB) {
 729                 struct i40e_veb *veb = pf->veb[pf->lan_veb];
 730                 for (j = 0; j < I40E_VEB_STATS_LEN; j++) {
 731                         p = (char *)veb;
 732                         p += i40e_gstrings_veb_stats[j].stat_offset;
 733                         data[i++] = (i40e_gstrings_veb_stats[j].sizeof_stat ==
 734                                      sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 735                 }
 736         }
 737         for (j = 0; j < I40E_GLOBAL_STATS_LEN; j++) {
 738                 p = (char *)pf + i40e_gstrings_stats[j].stat_offset;
 739                 data[i++] = (i40e_gstrings_stats[j].sizeof_stat ==
 740                              sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
 741         }
 742         for (j = 0; j < I40E_MAX_USER_PRIORITY; j++) {
 743                 data[i++] = pf->stats.priority_xon_tx[j];
 744                 data[i++] = pf->stats.priority_xoff_tx[j];
 745         }
 746         for (j = 0; j < I40E_MAX_USER_PRIORITY; j++) {
 747                 data[i++] = pf->stats.priority_xon_rx[j];
 748                 data[i++] = pf->stats.priority_xoff_rx[j];
 749         }
 750         for (j = 0; j < I40E_MAX_USER_PRIORITY; j++)
 751                 data[i++] = pf->stats.priority_xon_2_xoff[j];
 752 }
 753
 754 static void i40e_get_strings(struct net_device *netdev, u32 stringset,
 755                              u8 *data)
 756 {
 757         struct i40e_netdev_priv *np = netdev_priv(netdev);
 758         struct i40e_vsi *vsi = np->vsi;
 759         struct i40e_pf *pf = vsi->back;
 760         char *p = (char *)data;
 761         int i;
 762
 763         switch (stringset) {
 764         case ETH_SS_TEST:
 765                 for (i = 0; i < I40E_TEST_LEN; i++) {
 766                         memcpy(data, i40e_gstrings_test[i], ETH_GSTRING_LEN);
 767                         data += ETH_GSTRING_LEN;
 768                 }
 769                 break;
 770         case ETH_SS_STATS:
 771                 for (i = 0; i < I40E_NETDEV_STATS_LEN; i++) {
 772                         snprintf(p, ETH_GSTRING_LEN, "%s",
 773                                  i40e_gstrings_net_stats[i].stat_string);
 774                         p += ETH_GSTRING_LEN;
 775                 }
 776                 for (i = 0; i < I40E_MISC_STATS_LEN; i++) {
 777                         snprintf(p, ETH_GSTRING_LEN, "%s",
 778                                  i40e_gstrings_misc_stats[i].stat_string);
 779                         p += ETH_GSTRING_LEN;
 780                 }
 781                 for (i = 0; i < vsi->num_queue_pairs; i++) {
 782                         snprintf(p, ETH_GSTRING_LEN, "tx-%u.tx_packets", i);
 783                         p += ETH_GSTRING_LEN;
 784                         snprintf(p, ETH_GSTRING_LEN, "tx-%u.tx_bytes", i);
 785                         p += ETH_GSTRING_LEN;
 786                         snprintf(p, ETH_GSTRING_LEN, "rx-%u.rx_packets", i);
 787                         p += ETH_GSTRING_LEN;
 788                         snprintf(p, ETH_GSTRING_LEN, "rx-%u.rx_bytes", i);
 789                         p += ETH_GSTRING_LEN;
 790                 }
 791                 if (vsi != pf->vsi[pf->lan_vsi])
 792                         return;
 793
 794                 if (pf->lan_veb != I40E_NO_VEB) {
 795                         for (i = 0; i < I40E_VEB_STATS_LEN; i++) {
 796                                 snprintf(p, ETH_GSTRING_LEN, "veb.%s",
 797                                         i40e_gstrings_veb_stats[i].stat_string);
 798                                 p += ETH_GSTRING_LEN;
 799                         }
 800                 }
 801                 for (i = 0; i < I40E_GLOBAL_STATS_LEN; i++) {
 802                         snprintf(p, ETH_GSTRING_LEN, "port.%s",
 803                                  i40e_gstrings_stats[i].stat_string);
 804                         p += ETH_GSTRING_LEN;
 805                 }
 806                 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
 807                         snprintf(p, ETH_GSTRING_LEN,
 808                                  "port.tx_priority_%u_xon", i);
 809                         p += ETH_GSTRING_LEN;
 810                         snprintf(p, ETH_GSTRING_LEN,
 811                                  "port.tx_priority_%u_xoff", i);
 812                         p += ETH_GSTRING_LEN;
 813                 }
 814                 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
 815                         snprintf(p, ETH_GSTRING_LEN,
 816                                  "port.rx_priority_%u_xon", i);
 817                         p += ETH_GSTRING_LEN;
 818                         snprintf(p, ETH_GSTRING_LEN,
 819                                  "port.rx_priority_%u_xoff", i);
 820                         p += ETH_GSTRING_LEN;
 821                 }
 822                 for (i = 0; i < I40E_MAX_USER_PRIORITY; i++) {
 823                         snprintf(p, ETH_GSTRING_LEN,
 824                                  "port.rx_priority_%u_xon_2_xoff", i);
 825                         p += ETH_GSTRING_LEN;
 826                 }
 827                 /* BUG_ON(p - data != I40E_STATS_LEN * ETH_GSTRING_LEN); */
 828                 break;
 829         }
 830 }
 831
 832 static int i40e_get_ts_info(struct net_device *dev,
 833                             struct ethtool_ts_info *info)
 834 {
 835         struct i40e_pf *pf = i40e_netdev_to_pf(dev);
 836
 837         info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
 838                                 SOF_TIMESTAMPING_RX_SOFTWARE |
 839                                 SOF_TIMESTAMPING_SOFTWARE |
 840                                 SOF_TIMESTAMPING_TX_HARDWARE |
 841                                 SOF_TIMESTAMPING_RX_HARDWARE |
 842                                 SOF_TIMESTAMPING_RAW_HARDWARE;
 843
 844         if (pf->ptp_clock)
 845                 info->phc_index = ptp_clock_index(pf->ptp_clock);
 846         else
 847                 info->phc_index = -1;
 848
 849         info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON);
 850
 851         info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
 852                            (1 << HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |
 853                            (1 << HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |
 854                            (1 << HWTSTAMP_FILTER_PTP_V2_EVENT) |
 855                            (1 << HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
 856                            (1 << HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |
 857                            (1 << HWTSTAMP_FILTER_PTP_V2_SYNC) |
 858                            (1 << HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |
 859                            (1 << HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |
 860                            (1 << HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |
 861                            (1 << HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |
 862                            (1 << HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ);
 863
 864         return 0;
 865 }
 866
 867 static int i40e_link_test(struct net_device *netdev, u64 *data)
 868 {
 869         struct i40e_netdev_priv *np = netdev_priv(netdev);
 870         struct i40e_pf *pf = np->vsi->back;
 871
 872         netif_info(pf, hw, netdev, "link test\n");
 873         if (i40e_get_link_status(&pf->hw))
 874                 *data = 0;
 875         else
 876                 *data = 1;
 877
 878         return *data;
 879 }
 880
 881 static int i40e_reg_test(struct net_device *netdev, u64 *data)
 882 {
 883         struct i40e_netdev_priv *np = netdev_priv(netdev);
 884         struct i40e_pf *pf = np->vsi->back;
 885
 886         netif_info(pf, hw, netdev, "register test\n");
 887         *data = i40e_diag_reg_test(&pf->hw);
 888
 889         return *data;
 890 }
 891
 892 static int i40e_eeprom_test(struct net_device *netdev, u64 *data)
 893 {
 894         struct i40e_netdev_priv *np = netdev_priv(netdev);
 895         struct i40e_pf *pf = np->vsi->back;
 896
 897         netif_info(pf, hw, netdev, "eeprom test\n");
 898         *data = i40e_diag_eeprom_test(&pf->hw);
 899
 900         return *data;
 901 }
 902
 903 static int i40e_intr_test(struct net_device *netdev, u64 *data)
 904 {
 905         struct i40e_netdev_priv *np = netdev_priv(netdev);
 906         struct i40e_pf *pf = np->vsi->back;
 907         u16 swc_old = pf->sw_int_count;
 908
 909         netif_info(pf, hw, netdev, "interrupt test\n");
 910         wr32(&pf->hw, I40E_PFINT_DYN_CTL0,
 911              (I40E_PFINT_DYN_CTL0_INTENA_MASK |
 912               I40E_PFINT_DYN_CTL0_SWINT_TRIG_MASK));
 913         usleep_range(1000, 2000);
 914         *data = (swc_old == pf->sw_int_count);
 915
 916         return *data;
 917 }
 918
 919 static int i40e_loopback_test(struct net_device *netdev, u64 *data)
 920 {
 921         struct i40e_netdev_priv *np = netdev_priv(netdev);
 922         struct i40e_pf *pf = np->vsi->back;
 923
 924         netif_info(pf, hw, netdev, "loopback test not implemented\n");
 925         *data = 0;
 926
 927         return *data;
 928 }
 929
 930 static void i40e_diag_test(struct net_device *netdev,
 931                            struct ethtool_test *eth_test, u64 *data)
 932 {
 933         struct i40e_netdev_priv *np = netdev_priv(netdev);
 934         struct i40e_pf *pf = np->vsi->back;
 935
 936         if (eth_test->flags == ETH_TEST_FL_OFFLINE) {
 937                 /* Offline tests */
 938                 netif_info(pf, drv, netdev, "offline testing starting\n");
 939
 940                 set_bit(__I40E_TESTING, &pf->state);
 941
 942                 /* Link test performed before hardware reset
 943                  * so autoneg doesn't interfere with test result
 944                  */
 945                 if (i40e_link_test(netdev, &data[I40E_ETH_TEST_LINK]))
 946                         eth_test->flags |= ETH_TEST_FL_FAILED;
 947
 948                 if (i40e_eeprom_test(netdev, &data[I40E_ETH_TEST_EEPROM]))
 949                         eth_test->flags |= ETH_TEST_FL_FAILED;
 950
 951                 if (i40e_intr_test(netdev, &data[I40E_ETH_TEST_INTR]))
 952                         eth_test->flags |= ETH_TEST_FL_FAILED;
 953
 954                 if (i40e_loopback_test(netdev, &data[I40E_ETH_TEST_LOOPBACK]))
 955                         eth_test->flags |= ETH_TEST_FL_FAILED;
 956
 957                 /* run reg test last, a reset is required after it */
 958                 if (i40e_reg_test(netdev, &data[I40E_ETH_TEST_REG]))
 959                         eth_test->flags |= ETH_TEST_FL_FAILED;
 960
 961                 clear_bit(__I40E_TESTING, &pf->state);
 962                 i40e_do_reset(pf, (1 << __I40E_PF_RESET_REQUESTED));
 963         } else {
 964                 /* Online tests */
 965                 netif_info(pf, drv, netdev, "online testing starting\n");
 966
 967                 if (i40e_link_test(netdev, &data[I40E_ETH_TEST_LINK]))
 968                         eth_test->flags |= ETH_TEST_FL_FAILED;
 969
 970                 /* Offline only tests, not run in online; pass by default */
 971                 data[I40E_ETH_TEST_REG] = 0;
 972                 data[I40E_ETH_TEST_EEPROM] = 0;
 973                 data[I40E_ETH_TEST_INTR] = 0;
 974                 data[I40E_ETH_TEST_LOOPBACK] = 0;
 975         }
 976
 977         netif_info(pf, drv, netdev, "testing finished\n");
 978 }
 979
 980 static void i40e_get_wol(struct net_device *netdev,
 981                          struct ethtool_wolinfo *wol)
 982 {
 983         struct i40e_netdev_priv *np = netdev_priv(netdev);
 984         struct i40e_pf *pf = np->vsi->back;
 985         struct i40e_hw *hw = &pf->hw;
 986         u16 wol_nvm_bits;
 987
 988         /* NVM bit on means WoL disabled for the port */
 989         i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, &wol_nvm_bits);
 990         if ((1 << hw->port) & wol_nvm_bits) {
 991                 wol->supported = 0;
 992                 wol->wolopts = 0;
 993         } else {
 994                 wol->supported = WAKE_MAGIC;
 995                 wol->wolopts = (pf->wol_en ? WAKE_MAGIC : 0);
 996         }
 997 }
 998
 999 static int i40e_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
1000 {
1001         struct i40e_netdev_priv *np = netdev_priv(netdev);
1002         struct i40e_pf *pf = np->vsi->back;
1003         struct i40e_hw *hw = &pf->hw;
1004         u16 wol_nvm_bits;
1005
1006         /* NVM bit on means WoL disabled for the port */
1007         i40e_read_nvm_word(hw, I40E_SR_NVM_WAKE_ON_LAN, &wol_nvm_bits);
1008         if (((1 << hw->port) & wol_nvm_bits))
1009                 return -EOPNOTSUPP;
1010
1011         /* only magic packet is supported */
1012         if (wol->wolopts && (wol->wolopts != WAKE_MAGIC))
1013                 return -EOPNOTSUPP;
1014
1015         /* is this a new value? */
1016         if (pf->wol_en != !!wol->wolopts) {
1017                 pf->wol_en = !!wol->wolopts;
1018                 device_set_wakeup_enable(&pf->pdev->dev, pf->wol_en);
1019         }
1020
1021         return 0;
1022 }
1023
1024 static int i40e_nway_reset(struct net_device *netdev)
1025 {
1026         /* restart autonegotiation */
1027         struct i40e_netdev_priv *np = netdev_priv(netdev);
1028         struct i40e_pf *pf = np->vsi->back;
1029         struct i40e_hw *hw = &pf->hw;
1030         i40e_status ret = 0;
1031
1032         ret = i40e_aq_set_link_restart_an(hw, NULL);
1033         if (ret) {
1034                 netdev_info(netdev, "link restart failed, aq_err=%d\n",
1035                             pf->hw.aq.asq_last_status);
1036                 return -EIO;
1037         }
1038
1039         return 0;
1040 }
1041
1042 static int i40e_set_phys_id(struct net_device *netdev,
1043                             enum ethtool_phys_id_state state)
1044 {
1045         struct i40e_netdev_priv *np = netdev_priv(netdev);
1046         struct i40e_pf *pf = np->vsi->back;
1047         struct i40e_hw *hw = &pf->hw;
1048         int blink_freq = 2;
1049
1050         switch (state) {
1051         case ETHTOOL_ID_ACTIVE:
1052                 pf->led_status = i40e_led_get(hw);
1053                 return blink_freq;
1054         case ETHTOOL_ID_ON:
1055                 i40e_led_set(hw, 0xF, false);
1056                 break;
1057         case ETHTOOL_ID_OFF:
1058                 i40e_led_set(hw, 0x0, false);
1059                 break;
1060         case ETHTOOL_ID_INACTIVE:
1061                 i40e_led_set(hw, pf->led_status, false);
1062                 break;
1063         }
1064
1065         return 0;
1066 }
1067
1068 /* NOTE: i40e hardware uses a conversion factor of 2 for Interrupt
1069  * Throttle Rate (ITR) ie. ITR(1) = 2us ITR(10) = 20 us, and also
1070  * 125us (8000 interrupts per second) == ITR(62)
1071  */
1072
1073 static int i40e_get_coalesce(struct net_device *netdev,
1074                              struct ethtool_coalesce *ec)
1075 {
1076         struct i40e_netdev_priv *np = netdev_priv(netdev);
1077         struct i40e_vsi *vsi = np->vsi;
1078
1079         ec->tx_max_coalesced_frames_irq = vsi->work_limit;
1080         ec->rx_max_coalesced_frames_irq = vsi->work_limit;
1081
1082         if (ITR_IS_DYNAMIC(vsi->rx_itr_setting))
1083                 ec->use_adaptive_rx_coalesce = 1;
1084
1085         if (ITR_IS_DYNAMIC(vsi->tx_itr_setting))
1086                 ec->use_adaptive_tx_coalesce = 1;
1087
1088         ec->rx_coalesce_usecs = vsi->rx_itr_setting & ~I40E_ITR_DYNAMIC;
1089         ec->tx_coalesce_usecs = vsi->tx_itr_setting & ~I40E_ITR_DYNAMIC;
1090
1091         return 0;
1092 }
1093
1094 static int i40e_set_coalesce(struct net_device *netdev,
1095                              struct ethtool_coalesce *ec)
1096 {
1097         struct i40e_netdev_priv *np = netdev_priv(netdev);
1098         struct i40e_q_vector *q_vector;
1099         struct i40e_vsi *vsi = np->vsi;
1100         struct i40e_pf *pf = vsi->back;
1101         struct i40e_hw *hw = &pf->hw;
1102         u16 vector;
1103         int i;
1104
1105         if (ec->tx_max_coalesced_frames_irq || ec->rx_max_coalesced_frames_irq)
1106                 vsi->work_limit = ec->tx_max_coalesced_frames_irq;
1107
1108         if ((ec->rx_coalesce_usecs >= (I40E_MIN_ITR << 1)) &&
1109             (ec->rx_coalesce_usecs <= (I40E_MAX_ITR << 1)))
1110                 vsi->rx_itr_setting = ec->rx_coalesce_usecs;
1111         else
1112                 return -EINVAL;
1113
1114         if ((ec->tx_coalesce_usecs >= (I40E_MIN_ITR << 1)) &&
1115             (ec->tx_coalesce_usecs <= (I40E_MAX_ITR << 1)))
1116                 vsi->tx_itr_setting = ec->tx_coalesce_usecs;
1117         else
1118                 return -EINVAL;
1119
1120         if (ec->use_adaptive_rx_coalesce)
1121                 vsi->rx_itr_setting |= I40E_ITR_DYNAMIC;
1122         else
1123                 vsi->rx_itr_setting &= ~I40E_ITR_DYNAMIC;
1124
1125         if (ec->use_adaptive_tx_coalesce)
1126                 vsi->tx_itr_setting |= I40E_ITR_DYNAMIC;
1127         else
1128                 vsi->tx_itr_setting &= ~I40E_ITR_DYNAMIC;
1129
1130         vector = vsi->base_vector;
1131         for (i = 0; i < vsi->num_q_vectors; i++, vector++) {
1132                 q_vector = vsi->q_vectors[i];
1133                 q_vector->rx.itr = ITR_TO_REG(vsi->rx_itr_setting);
1134                 wr32(hw, I40E_PFINT_ITRN(0, vector - 1), q_vector->rx.itr);
1135                 q_vector->tx.itr = ITR_TO_REG(vsi->tx_itr_setting);
1136                 wr32(hw, I40E_PFINT_ITRN(1, vector - 1), q_vector->tx.itr);
1137                 i40e_flush(hw);
1138         }
1139
1140         return 0;
1141 }
1142
1143 /**
1144  * i40e_get_rss_hash_opts - Get RSS hash Input Set for each flow type
1145  * @pf: pointer to the physical function struct
1146  * @cmd: ethtool rxnfc command
1147  *
1148  * Returns Success if the flow is supported, else Invalid Input.
1149  **/
1150 static int i40e_get_rss_hash_opts(struct i40e_pf *pf, struct ethtool_rxnfc *cmd)
1151 {
1152         cmd->data = 0;
1153
1154         /* Report default options for RSS on i40e */
1155         switch (cmd->flow_type) {
1156         case TCP_V4_FLOW:
1157         case UDP_V4_FLOW:
1158                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1159         /* fall through to add IP fields */
1160         case SCTP_V4_FLOW:
1161         case AH_ESP_V4_FLOW:
1162         case AH_V4_FLOW:
1163         case ESP_V4_FLOW:
1164         case IPV4_FLOW:
1165                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1166                 break;
1167         case TCP_V6_FLOW:
1168         case UDP_V6_FLOW:
1169                 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1170         /* fall through to add IP fields */
1171         case SCTP_V6_FLOW:
1172         case AH_ESP_V6_FLOW:
1173         case AH_V6_FLOW:
1174         case ESP_V6_FLOW:
1175         case IPV6_FLOW:
1176                 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1177                 break;
1178         default:
1179                 return -EINVAL;
1180         }
1181
1182         return 0;
1183 }
1184
1185 /**
1186  * i40e_get_ethtool_fdir_all - Populates the rule count of a command
1187  * @pf: Pointer to the physical function struct
1188  * @cmd: The command to get or set Rx flow classification rules
1189  * @rule_locs: Array of used rule locations
1190  *
1191  * This function populates both the total and actual rule count of
1192  * the ethtool flow classification command
1193  *
1194  * Returns 0 on success or -EMSGSIZE if entry not found
1195  **/
1196 static int i40e_get_ethtool_fdir_all(struct i40e_pf *pf,
1197                                      struct ethtool_rxnfc *cmd,
1198                                      u32 *rule_locs)
1199 {
1200         struct i40e_fdir_filter *rule;
1201         struct hlist_node *node2;
1202         int cnt = 0;
1203
1204         /* report total rule count */
1205         cmd->data = i40e_get_fd_cnt_all(pf);
1206
1207         hlist_for_each_entry_safe(rule, node2,
1208                                   &pf->fdir_filter_list, fdir_node) {
1209                 if (cnt == cmd->rule_cnt)
1210                         return -EMSGSIZE;
1211
1212                 rule_locs[cnt] = rule->fd_id;
1213                 cnt++;
1214         }
1215
1216         cmd->rule_cnt = cnt;
1217
1218         return 0;
1219 }
1220
1221 /**
1222  * i40e_get_ethtool_fdir_entry - Look up a filter based on Rx flow
1223  * @pf: Pointer to the physical function struct
1224  * @cmd: The command to get or set Rx flow classification rules
1225  *
1226  * This function looks up a filter based on the Rx flow classification
1227  * command and fills the flow spec info for it if found
1228  *
1229  * Returns 0 on success or -EINVAL if filter not found
1230  **/
1231 static int i40e_get_ethtool_fdir_entry(struct i40e_pf *pf,
1232                                        struct ethtool_rxnfc *cmd)
1233 {
1234         struct ethtool_rx_flow_spec *fsp =
1235                         (struct ethtool_rx_flow_spec *)&cmd->fs;
1236         struct i40e_fdir_filter *rule = NULL;
1237         struct hlist_node *node2;
1238
1239         hlist_for_each_entry_safe(rule, node2,
1240                                   &pf->fdir_filter_list, fdir_node) {
1241                 if (fsp->location <= rule->fd_id)
1242                         break;
1243         }
1244
1245         if (!rule || fsp->location != rule->fd_id)
1246                 return -EINVAL;
1247
1248         fsp->flow_type = rule->flow_type;
1249         if (fsp->flow_type == IP_USER_FLOW) {
1250                 fsp->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
1251                 fsp->h_u.usr_ip4_spec.proto = 0;
1252                 fsp->m_u.usr_ip4_spec.proto = 0;
1253         }
1254
1255         /* Reverse the src and dest notion, since the HW views them from
1256          * Tx perspective where as the user expects it from Rx filter view.
1257          */
1258         fsp->h_u.tcp_ip4_spec.psrc = rule->dst_port;
1259         fsp->h_u.tcp_ip4_spec.pdst = rule->src_port;
1260         fsp->h_u.tcp_ip4_spec.ip4src = rule->dst_ip[0];
1261         fsp->h_u.tcp_ip4_spec.ip4dst = rule->src_ip[0];
1262
1263         if (rule->dest_ctl == I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET)
1264                 fsp->ring_cookie = RX_CLS_FLOW_DISC;
1265         else
1266                 fsp->ring_cookie = rule->q_index;
1267
1268         return 0;
1269 }
1270
1271 /**
1272  * i40e_get_rxnfc - command to get RX flow classification rules
1273  * @netdev: network interface device structure
1274  * @cmd: ethtool rxnfc command
1275  *
1276  * Returns Success if the command is supported.
1277  **/
1278 static int i40e_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,
1279                           u32 *rule_locs)
1280 {
1281         struct i40e_netdev_priv *np = netdev_priv(netdev);
1282         struct i40e_vsi *vsi = np->vsi;
1283         struct i40e_pf *pf = vsi->back;
1284         int ret = -EOPNOTSUPP;
1285
1286         switch (cmd->cmd) {
1287         case ETHTOOL_GRXRINGS:
1288                 cmd->data = vsi->alloc_queue_pairs;
1289                 ret = 0;
1290                 break;
1291         case ETHTOOL_GRXFH:
1292                 ret = i40e_get_rss_hash_opts(pf, cmd);
1293                 break;
1294         case ETHTOOL_GRXCLSRLCNT:
1295                 cmd->rule_cnt = pf->fdir_pf_active_filters;
1296                 /* report total rule count */
1297                 cmd->data = i40e_get_fd_cnt_all(pf);
1298                 ret = 0;
1299                 break;
1300         case ETHTOOL_GRXCLSRULE:
1301                 ret = i40e_get_ethtool_fdir_entry(pf, cmd);
1302                 break;
1303         case ETHTOOL_GRXCLSRLALL:
1304                 ret = i40e_get_ethtool_fdir_all(pf, cmd, rule_locs);
1305                 break;
1306         default:
1307                 break;
1308         }
1309
1310         return ret;
1311 }
1312
1313 /**
1314  * i40e_set_rss_hash_opt - Enable/Disable flow types for RSS hash
1315  * @pf: pointer to the physical function struct
1316  * @cmd: ethtool rxnfc command
1317  *
1318  * Returns Success if the flow input set is supported.
1319  **/
1320 static int i40e_set_rss_hash_opt(struct i40e_pf *pf, struct ethtool_rxnfc *nfc)
1321 {
1322         struct i40e_hw *hw = &pf->hw;
1323         u64 hena = (u64)rd32(hw, I40E_PFQF_HENA(0)) |
1324                    ((u64)rd32(hw, I40E_PFQF_HENA(1)) << 32);
1325
1326         /* RSS does not support anything other than hashing
1327          * to queues on src and dst IPs and ports
1328          */
1329         if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
1330                           RXH_L4_B_0_1 | RXH_L4_B_2_3))
1331                 return -EINVAL;
1332
1333         /* We need at least the IP SRC and DEST fields for hashing */
1334         if (!(nfc->data & RXH_IP_SRC) ||
1335             !(nfc->data & RXH_IP_DST))
1336                 return -EINVAL;
1337
1338         switch (nfc->flow_type) {
1339         case TCP_V4_FLOW:
1340                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1341                 case 0:
1342                         hena &= ~((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_TCP);
1343                         break;
1344                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1345                         hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_TCP);
1346                         break;
1347                 default:
1348                         return -EINVAL;
1349                 }
1350                 break;
1351         case TCP_V6_FLOW:
1352                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1353                 case 0:
1354                         hena &= ~((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_TCP);
1355                         break;
1356                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1357                         hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_TCP);
1358                         break;
1359                 default:
1360                         return -EINVAL;
1361                 }
1362                 break;
1363         case UDP_V4_FLOW:
1364                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1365                 case 0:
1366                         hena &= ~(((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_UDP) |
1367                                   ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4));
1368                         break;
1369                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1370                         hena |= (((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_UDP) |
1371                                   ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4));
1372                         break;
1373                 default:
1374                         return -EINVAL;
1375                 }
1376                 break;
1377         case UDP_V6_FLOW:
1378                 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1379                 case 0:
1380                         hena &= ~(((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_UDP) |
1381                                   ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6));
1382                         break;
1383                 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1384                         hena |= (((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_UDP) |
1385                                  ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6));
1386                         break;
1387                 default:
1388                         return -EINVAL;
1389                 }
1390                 break;
1391         case AH_ESP_V4_FLOW:
1392         case AH_V4_FLOW:
1393         case ESP_V4_FLOW:
1394         case SCTP_V4_FLOW:
1395                 if ((nfc->data & RXH_L4_B_0_1) ||
1396                     (nfc->data & RXH_L4_B_2_3))
1397                         return -EINVAL;
1398                 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_OTHER);
1399                 break;
1400         case AH_ESP_V6_FLOW:
1401         case AH_V6_FLOW:
1402         case ESP_V6_FLOW:
1403         case SCTP_V6_FLOW:
1404                 if ((nfc->data & RXH_L4_B_0_1) ||
1405                     (nfc->data & RXH_L4_B_2_3))
1406                         return -EINVAL;
1407                 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_OTHER);
1408                 break;
1409         case IPV4_FLOW:
1410                 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV4_OTHER) |
1411                         ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV4);
1412                 break;
1413         case IPV6_FLOW:
1414                 hena |= ((u64)1 << I40E_FILTER_PCTYPE_NONF_IPV6_OTHER) |
1415                         ((u64)1 << I40E_FILTER_PCTYPE_FRAG_IPV6);
1416                 break;
1417         default:
1418                 return -EINVAL;
1419         }
1420
1421         wr32(hw, I40E_PFQF_HENA(0), (u32)hena);
1422         wr32(hw, I40E_PFQF_HENA(1), (u32)(hena >> 32));
1423         i40e_flush(hw);
1424
1425         return 0;
1426 }
1427
1428 /**
1429  * i40e_match_fdir_input_set - Match a new filter against an existing one
1430  * @rule: The filter already added
1431  * @input: The new filter to comapre against
1432  *
1433  * Returns true if the two input set match
1434  **/
1435 static bool i40e_match_fdir_input_set(struct i40e_fdir_filter *rule,
1436                                       struct i40e_fdir_filter *input)
1437 {
1438         if ((rule->dst_ip[0] != input->dst_ip[0]) ||
1439             (rule->src_ip[0] != input->src_ip[0]) ||
1440             (rule->dst_port != input->dst_port) ||
1441             (rule->src_port != input->src_port))
1442                 return false;
1443         return true;
1444 }
1445
1446 /**
1447  * i40e_update_ethtool_fdir_entry - Updates the fdir filter entry
1448  * @vsi: Pointer to the targeted VSI
1449  * @input: The filter to update or NULL to indicate deletion
1450  * @sw_idx: Software index to the filter
1451  * @cmd: The command to get or set Rx flow classification rules
1452  *
1453  * This function updates (or deletes) a Flow Director entry from
1454  * the hlist of the corresponding PF
1455  *
1456  * Returns 0 on success
1457  **/
1458 static int i40e_update_ethtool_fdir_entry(struct i40e_vsi *vsi,
1459                                           struct i40e_fdir_filter *input,
1460                                           u16 sw_idx,
1461                                           struct ethtool_rxnfc *cmd)
1462 {
1463         struct i40e_fdir_filter *rule, *parent;
1464         struct i40e_pf *pf = vsi->back;
1465         struct hlist_node *node2;
1466         int err = -EINVAL;
1467
1468         parent = NULL;
1469         rule = NULL;
1470
1471         hlist_for_each_entry_safe(rule, node2,
1472                                   &pf->fdir_filter_list, fdir_node) {
1473                 /* hash found, or no matching entry */
1474                 if (rule->fd_id >= sw_idx)
1475                         break;
1476                 parent = rule;
1477         }
1478
1479         /* if there is an old rule occupying our place remove it */
1480         if (rule && (rule->fd_id == sw_idx)) {
1481                 if (input && !i40e_match_fdir_input_set(rule, input))
1482                         err = i40e_add_del_fdir(vsi, rule, false);
1483                 else if (!input)
1484                         err = i40e_add_del_fdir(vsi, rule, false);
1485                 hlist_del(&rule->fdir_node);
1486                 kfree(rule);
1487                 pf->fdir_pf_active_filters--;
1488         }
1489
1490         /* If no input this was a delete, err should be 0 if a rule was
1491          * successfully found and removed from the list else -EINVAL
1492          */
1493         if (!input)
1494                 return err;
1495
1496         /* initialize node and set software index */
1497         INIT_HLIST_NODE(&input->fdir_node);
1498
1499         /* add filter to the list */
1500         if (parent)
1501                 hlist_add_after(&parent->fdir_node, &input->fdir_node);
1502         else
1503                 hlist_add_head(&input->fdir_node,
1504                                &pf->fdir_filter_list);
1505
1506         /* update counts */
1507         pf->fdir_pf_active_filters++;
1508
1509         return 0;
1510 }
1511
1512 /**
1513  * i40e_del_fdir_entry - Deletes a Flow Director filter entry
1514  * @vsi: Pointer to the targeted VSI
1515  * @cmd: The command to get or set Rx flow classification rules
1516  *
1517  * The function removes a Flow Director filter entry from the
1518  * hlist of the corresponding PF
1519  *
1520  * Returns 0 on success
1521  */
1522 static int i40e_del_fdir_entry(struct i40e_vsi *vsi,
1523                                struct ethtool_rxnfc *cmd)
1524 {
1525         struct ethtool_rx_flow_spec *fsp =
1526                 (struct ethtool_rx_flow_spec *)&cmd->fs;
1527         struct i40e_pf *pf = vsi->back;
1528         int ret = 0;
1529
1530         ret = i40e_update_ethtool_fdir_entry(vsi, NULL, fsp->location, cmd);
1531
1532         i40e_fdir_check_and_reenable(pf);
1533         return ret;
1534 }
1535
1536 /**
1537  * i40e_add_fdir_ethtool - Add/Remove Flow Director filters
1538  * @vsi: pointer to the targeted VSI
1539  * @cmd: command to get or set RX flow classification rules
1540  *
1541  * Add Flow Director filters for a specific flow spec based on their
1542  * protocol.  Returns 0 if the filters were successfully added.
1543  **/
1544 static int i40e_add_fdir_ethtool(struct i40e_vsi *vsi,
1545                                  struct ethtool_rxnfc *cmd)
1546 {
1547         struct ethtool_rx_flow_spec *fsp;
1548         struct i40e_fdir_filter *input;
1549         struct i40e_pf *pf;
1550         int ret = -EINVAL;
1551
1552         if (!vsi)
1553                 return -EINVAL;
1554
1555         pf = vsi->back;
1556
1557         if (!(pf->flags & I40E_FLAG_FD_SB_ENABLED))
1558                 return -EOPNOTSUPP;
1559
1560         if (pf->auto_disable_flags & I40E_FLAG_FD_SB_ENABLED)
1561                 return -ENOSPC;
1562
1563         fsp = (struct ethtool_rx_flow_spec *)&cmd->fs;
1564
1565         if (fsp->location >= (pf->hw.func_caps.fd_filters_best_effort +
1566                               pf->hw.func_caps.fd_filters_guaranteed)) {
1567                 return -EINVAL;
1568         }
1569
1570         if ((fsp->ring_cookie != RX_CLS_FLOW_DISC) &&
1571             (fsp->ring_cookie >= vsi->num_queue_pairs))
1572                 return -EINVAL;
1573
1574         input = kzalloc(sizeof(*input), GFP_KERNEL);
1575
1576         if (!input)
1577                 return -ENOMEM;
1578
1579         input->fd_id = fsp->location;
1580
1581         if (fsp->ring_cookie == RX_CLS_FLOW_DISC)
1582                 input->dest_ctl = I40E_FILTER_PROGRAM_DESC_DEST_DROP_PACKET;
1583         else
1584                 input->dest_ctl =
1585                              I40E_FILTER_PROGRAM_DESC_DEST_DIRECT_PACKET_QINDEX;
1586
1587         input->q_index = fsp->ring_cookie;
1588         input->flex_off = 0;
1589         input->pctype = 0;
1590         input->dest_vsi = vsi->id;
1591         input->fd_status = I40E_FILTER_PROGRAM_DESC_FD_STATUS_FD_ID;
1592         input->cnt_index  = pf->fd_sb_cnt_idx;
1593         input->flow_type = fsp->flow_type;
1594         input->ip4_proto = fsp->h_u.usr_ip4_spec.proto;
1595
1596         /* Reverse the src and dest notion, since the HW expects them to be from
1597          * Tx perspective where as the input from user is from Rx filter view.
1598          */
1599         input->dst_port = fsp->h_u.tcp_ip4_spec.psrc;
1600         input->src_port = fsp->h_u.tcp_ip4_spec.pdst;
1601         input->dst_ip[0] = fsp->h_u.tcp_ip4_spec.ip4src;
1602         input->src_ip[0] = fsp->h_u.tcp_ip4_spec.ip4dst;
1603
1604         ret = i40e_add_del_fdir(vsi, input, true);
1605         if (ret)
1606                 kfree(input);
1607         else
1608                 i40e_update_ethtool_fdir_entry(vsi, input, fsp->location, NULL);
1609
1610         return ret;
1611 }
1612
1613 /**
1614  * i40e_set_rxnfc - command to set RX flow classification rules
1615  * @netdev: network interface device structure
1616  * @cmd: ethtool rxnfc command
1617  *
1618  * Returns Success if the command is supported.
1619  **/
1620 static int i40e_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)
1621 {
1622         struct i40e_netdev_priv *np = netdev_priv(netdev);
1623         struct i40e_vsi *vsi = np->vsi;
1624         struct i40e_pf *pf = vsi->back;
1625         int ret = -EOPNOTSUPP;
1626
1627         switch (cmd->cmd) {
1628         case ETHTOOL_SRXFH:
1629                 ret = i40e_set_rss_hash_opt(pf, cmd);
1630                 break;
1631         case ETHTOOL_SRXCLSRLINS:
1632                 ret = i40e_add_fdir_ethtool(vsi, cmd);
1633                 break;
1634         case ETHTOOL_SRXCLSRLDEL:
1635                 ret = i40e_del_fdir_entry(vsi, cmd);
1636                 break;
1637         default:
1638                 break;
1639         }
1640
1641         return ret;
1642 }
1643
1644 /**
1645  * i40e_max_channels - get Max number of combined channels supported
1646  * @vsi: vsi pointer
1647  **/
1648 static unsigned int i40e_max_channels(struct i40e_vsi *vsi)
1649 {
1650         /* TODO: This code assumes DCB and FD is disabled for now. */
1651         return vsi->alloc_queue_pairs;
1652 }
1653
1654 /**
1655  * i40e_get_channels - Get the current channels enabled and max supported etc.
1656  * @netdev: network interface device structure
1657  * @ch: ethtool channels structure
1658  *
1659  * We don't support separate tx and rx queues as channels. The other count
1660  * represents how many queues are being used for control. max_combined counts
1661  * how many queue pairs we can support. They may not be mapped 1 to 1 with
1662  * q_vectors since we support a lot more queue pairs than q_vectors.
1663  **/
1664 static void i40e_get_channels(struct net_device *dev,
1665                                struct ethtool_channels *ch)
1666 {
1667         struct i40e_netdev_priv *np = netdev_priv(dev);
1668         struct i40e_vsi *vsi = np->vsi;
1669         struct i40e_pf *pf = vsi->back;
1670
1671         /* report maximum channels */
1672         ch->max_combined = i40e_max_channels(vsi);
1673
1674         /* report info for other vector */
1675         ch->other_count = (pf->flags & I40E_FLAG_FD_SB_ENABLED) ? 1 : 0;
1676         ch->max_other = ch->other_count;
1677
1678         /* Note: This code assumes DCB is disabled for now. */
1679         ch->combined_count = vsi->num_queue_pairs;
1680 }
1681
1682 /**
1683  * i40e_set_channels - Set the new channels count.
1684  * @netdev: network interface device structure
1685  * @ch: ethtool channels structure
1686  *
1687  * The new channels count may not be the same as requested by the user
1688  * since it gets rounded down to a power of 2 value.
1689  **/
1690 static int i40e_set_channels(struct net_device *dev,
1691                               struct ethtool_channels *ch)
1692 {
1693         struct i40e_netdev_priv *np = netdev_priv(dev);
1694         unsigned int count = ch->combined_count;
1695         struct i40e_vsi *vsi = np->vsi;
1696         struct i40e_pf *pf = vsi->back;
1697         int new_count;
1698
1699         /* We do not support setting channels for any other VSI at present */
1700         if (vsi->type != I40E_VSI_MAIN)
1701                 return -EINVAL;
1702
1703         /* verify they are not requesting separate vectors */
1704         if (!count || ch->rx_count || ch->tx_count)
1705                 return -EINVAL;
1706
1707         /* verify other_count has not changed */
1708         if (ch->other_count != ((pf->flags & I40E_FLAG_FD_SB_ENABLED) ? 1 : 0))
1709                 return -EINVAL;
1710
1711         /* verify the number of channels does not exceed hardware limits */
1712         if (count > i40e_max_channels(vsi))
1713                 return -EINVAL;
1714
1715         /* update feature limits from largest to smallest supported values */
1716         /* TODO: Flow director limit, DCB etc */
1717
1718         /* cap RSS limit */
1719         if (count > pf->rss_size_max)
1720                 count = pf->rss_size_max;
1721
1722         /* use rss_reconfig to rebuild with new queue count and update traffic
1723          * class queue mapping
1724          */
1725         new_count = i40e_reconfig_rss_queues(pf, count);
1726         if (new_count > 0)
1727                 return 0;
1728         else
1729                 return -EINVAL;
1730 }
1731
1732 static const struct ethtool_ops i40e_ethtool_ops = {
1733         .get_settings           = i40e_get_settings,
1734         .get_drvinfo            = i40e_get_drvinfo,
1735         .get_regs_len           = i40e_get_regs_len,
1736         .get_regs               = i40e_get_regs,
1737         .nway_reset             = i40e_nway_reset,
1738         .get_link               = ethtool_op_get_link,
1739         .get_wol                = i40e_get_wol,
1740         .set_wol                = i40e_set_wol,
1741         .get_eeprom_len         = i40e_get_eeprom_len,
1742         .get_eeprom             = i40e_get_eeprom,
1743         .get_ringparam          = i40e_get_ringparam,
1744         .set_ringparam          = i40e_set_ringparam,
1745         .get_pauseparam         = i40e_get_pauseparam,
1746         .get_msglevel           = i40e_get_msglevel,
1747         .set_msglevel           = i40e_set_msglevel,
1748         .get_rxnfc              = i40e_get_rxnfc,
1749         .set_rxnfc              = i40e_set_rxnfc,
1750         .self_test              = i40e_diag_test,
1751         .get_strings            = i40e_get_strings,
1752         .set_phys_id            = i40e_set_phys_id,
1753         .get_sset_count         = i40e_get_sset_count,
1754         .get_ethtool_stats      = i40e_get_ethtool_stats,
1755         .get_coalesce           = i40e_get_coalesce,
1756         .set_coalesce           = i40e_set_coalesce,
1757         .get_channels           = i40e_get_channels,
1758         .set_channels           = i40e_set_channels,
1759         .get_ts_info            = i40e_get_ts_info,
1760 };
1761
1762 void i40e_set_ethtool_ops(struct net_device *netdev)
1763 {
1764         netdev->ethtool_ops = &i40e_ethtool_ops;
1765 }