drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c

   1 /*
   2  * QLogic qlcnic NIC Driver
   3  * Copyright (c) 2009-2013 QLogic Corporation
   4  *
   5  * See LICENSE.qlcnic for copyright and licensing details.
   6  */
   7
   8 #include <linux/types.h>
   9 #include <linux/delay.h>
  10 #include <linux/pci.h>
  11 #include <linux/io.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/ethtool.h>
  14
  15 #include "qlcnic.h"
  16
  17 struct qlcnic_stats {
  18         char stat_string[ETH_GSTRING_LEN];
  19         int sizeof_stat;
  20         int stat_offset;
  21 };
  22
  23 #define QLC_SIZEOF(m) FIELD_SIZEOF(struct qlcnic_adapter, m)
  24 #define QLC_OFF(m) offsetof(struct qlcnic_adapter, m)
  25 static const u32 qlcnic_fw_dump_level[] = {
  26         0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff
  27 };
  28
  29 static const struct qlcnic_stats qlcnic_gstrings_stats[] = {
  30         {"xmit_called", QLC_SIZEOF(stats.xmitcalled),
  31                 QLC_OFF(stats.xmitcalled)},
  32         {"xmit_finished", QLC_SIZEOF(stats.xmitfinished),
  33                 QLC_OFF(stats.xmitfinished)},
  34         {"rx_dropped", QLC_SIZEOF(stats.rxdropped), QLC_OFF(stats.rxdropped)},
  35         {"tx_dropped", QLC_SIZEOF(stats.txdropped), QLC_OFF(stats.txdropped)},
  36         {"csummed", QLC_SIZEOF(stats.csummed), QLC_OFF(stats.csummed)},
  37         {"rx_pkts", QLC_SIZEOF(stats.rx_pkts), QLC_OFF(stats.rx_pkts)},
  38         {"lro_pkts", QLC_SIZEOF(stats.lro_pkts), QLC_OFF(stats.lro_pkts)},
  39         {"rx_bytes", QLC_SIZEOF(stats.rxbytes), QLC_OFF(stats.rxbytes)},
  40         {"tx_bytes", QLC_SIZEOF(stats.txbytes), QLC_OFF(stats.txbytes)},
  41         {"lrobytes", QLC_SIZEOF(stats.lrobytes), QLC_OFF(stats.lrobytes)},
  42         {"lso_frames", QLC_SIZEOF(stats.lso_frames), QLC_OFF(stats.lso_frames)},
  43         {"xmit_on", QLC_SIZEOF(stats.xmit_on), QLC_OFF(stats.xmit_on)},
  44         {"xmit_off", QLC_SIZEOF(stats.xmit_off), QLC_OFF(stats.xmit_off)},
  45         {"skb_alloc_failure", QLC_SIZEOF(stats.skb_alloc_failure),
  46          QLC_OFF(stats.skb_alloc_failure)},
  47         {"null rxbuf", QLC_SIZEOF(stats.null_rxbuf), QLC_OFF(stats.null_rxbuf)},
  48         {"rx dma map error", QLC_SIZEOF(stats.rx_dma_map_error),
  49                                          QLC_OFF(stats.rx_dma_map_error)},
  50         {"tx dma map error", QLC_SIZEOF(stats.tx_dma_map_error),
  51                                          QLC_OFF(stats.tx_dma_map_error)},
  52         {"mac_filter_limit_overrun", QLC_SIZEOF(stats.mac_filter_limit_overrun),
  53                                 QLC_OFF(stats.mac_filter_limit_overrun)},
  54         {"spurious intr", QLC_SIZEOF(stats.spurious_intr),
  55          QLC_OFF(stats.spurious_intr)},
  56
  57 };
  58
  59 static const char qlcnic_device_gstrings_stats[][ETH_GSTRING_LEN] = {
  60         "rx unicast frames",
  61         "rx multicast frames",
  62         "rx broadcast frames",
  63         "rx dropped frames",
  64         "rx errors",
  65         "rx local frames",
  66         "rx numbytes",
  67         "tx unicast frames",
  68         "tx multicast frames",
  69         "tx broadcast frames",
  70         "tx dropped frames",
  71         "tx errors",
  72         "tx local frames",
  73         "tx numbytes",
  74 };
  75
  76 static const char qlcnic_83xx_tx_stats_strings[][ETH_GSTRING_LEN] = {
  77         "ctx_tx_bytes",
  78         "ctx_tx_pkts",
  79         "ctx_tx_errors",
  80         "ctx_tx_dropped_pkts",
  81         "ctx_tx_num_buffers",
  82 };
  83
  84 static const char qlcnic_83xx_mac_stats_strings[][ETH_GSTRING_LEN] = {
  85         "mac_tx_frames",
  86         "mac_tx_bytes",
  87         "mac_tx_mcast_pkts",
  88         "mac_tx_bcast_pkts",
  89         "mac_tx_pause_cnt",
  90         "mac_tx_ctrl_pkt",
  91         "mac_tx_lt_64b_pkts",
  92         "mac_tx_lt_127b_pkts",
  93         "mac_tx_lt_255b_pkts",
  94         "mac_tx_lt_511b_pkts",
  95         "mac_tx_lt_1023b_pkts",
  96         "mac_tx_lt_1518b_pkts",
  97         "mac_tx_gt_1518b_pkts",
  98         "mac_rx_frames",
  99         "mac_rx_bytes",
 100         "mac_rx_mcast_pkts",
 101         "mac_rx_bcast_pkts",
 102         "mac_rx_pause_cnt",
 103         "mac_rx_ctrl_pkt",
 104         "mac_rx_lt_64b_pkts",
 105         "mac_rx_lt_127b_pkts",
 106         "mac_rx_lt_255b_pkts",
 107         "mac_rx_lt_511b_pkts",
 108         "mac_rx_lt_1023b_pkts",
 109         "mac_rx_lt_1518b_pkts",
 110         "mac_rx_gt_1518b_pkts",
 111         "mac_rx_length_error",
 112         "mac_rx_length_small",
 113         "mac_rx_length_large",
 114         "mac_rx_jabber",
 115         "mac_rx_dropped",
 116         "mac_crc_error",
 117         "mac_align_error",
 118         "eswitch_frames",
 119         "eswitch_bytes",
 120         "eswitch_multicast_frames",
 121         "eswitch_broadcast_frames",
 122         "eswitch_unicast_frames",
 123         "eswitch_error_free_frames",
 124         "eswitch_error_free_bytes",
 125 };
 126
 127 #define QLCNIC_STATS_LEN        ARRAY_SIZE(qlcnic_gstrings_stats)
 128 static const char qlcnic_83xx_rx_stats_strings[][ETH_GSTRING_LEN] = {
 129         "ctx_rx_bytes",
 130         "ctx_rx_pkts",
 131         "ctx_lro_pkt_cnt",
 132         "ctx_ip_csum_error",
 133         "ctx_rx_pkts_wo_ctx",
 134         "ctx_rx_pkts_drop_wo_sds_on_card",
 135         "ctx_rx_pkts_drop_wo_sds_on_host",
 136         "ctx_rx_osized_pkts",
 137         "ctx_rx_pkts_dropped_wo_rds",
 138         "ctx_rx_unexpected_mcast_pkts",
 139         "ctx_invalid_mac_address",
 140         "ctx_rx_rds_ring_prim_attempted",
 141         "ctx_rx_rds_ring_prim_success",
 142         "ctx_num_lro_flows_added",
 143         "ctx_num_lro_flows_removed",
 144         "ctx_num_lro_flows_active",
 145         "ctx_pkts_dropped_unknown",
 146 };
 147
 148 static const char qlcnic_gstrings_test[][ETH_GSTRING_LEN] = {
 149         "Register_Test_on_offline",
 150         "Link_Test_on_offline",
 151         "Interrupt_Test_offline",
 152         "Internal_Loopback_offline",
 153         "EEPROM_Test_offline"
 154 };
 155
 156 #define QLCNIC_TEST_LEN ARRAY_SIZE(qlcnic_gstrings_test)
 157
 158 static inline int qlcnic_82xx_statistics(void)
 159 {
 160         return ARRAY_SIZE(qlcnic_device_gstrings_stats) +
 161                ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
 162 }
 163
 164 static inline int qlcnic_83xx_statistics(void)
 165 {
 166         return ARRAY_SIZE(qlcnic_83xx_tx_stats_strings) +
 167                ARRAY_SIZE(qlcnic_83xx_mac_stats_strings) +
 168                ARRAY_SIZE(qlcnic_83xx_rx_stats_strings);
 169 }
 170
 171 static int qlcnic_dev_statistics_len(struct qlcnic_adapter *adapter)
 172 {
 173         if (qlcnic_82xx_check(adapter))
 174                 return qlcnic_82xx_statistics();
 175         else if (qlcnic_83xx_check(adapter))
 176                 return qlcnic_83xx_statistics();
 177         else
 178                 return -1;
 179 }
 180
 181 #define QLCNIC_RING_REGS_COUNT  20
 182 #define QLCNIC_RING_REGS_LEN    (QLCNIC_RING_REGS_COUNT * sizeof(u32))
 183 #define QLCNIC_MAX_EEPROM_LEN   1024
 184
 185 static const u32 diag_registers[] = {
 186         QLCNIC_CMDPEG_STATE,
 187         QLCNIC_RCVPEG_STATE,
 188         QLCNIC_FW_CAPABILITIES,
 189         QLCNIC_CRB_DRV_ACTIVE,
 190         QLCNIC_CRB_DEV_STATE,
 191         QLCNIC_CRB_DRV_STATE,
 192         QLCNIC_CRB_DRV_SCRATCH,
 193         QLCNIC_CRB_DEV_PARTITION_INFO,
 194         QLCNIC_CRB_DRV_IDC_VER,
 195         QLCNIC_PEG_ALIVE_COUNTER,
 196         QLCNIC_PEG_HALT_STATUS1,
 197         QLCNIC_PEG_HALT_STATUS2,
 198         -1
 199 };
 200
 201
 202 static const u32 ext_diag_registers[] = {
 203         CRB_XG_STATE_P3P,
 204         ISR_INT_STATE_REG,
 205         QLCNIC_CRB_PEG_NET_0+0x3c,
 206         QLCNIC_CRB_PEG_NET_1+0x3c,
 207         QLCNIC_CRB_PEG_NET_2+0x3c,
 208         QLCNIC_CRB_PEG_NET_4+0x3c,
 209         -1
 210 };
 211
 212 #define QLCNIC_MGMT_API_VERSION 2
 213 #define QLCNIC_ETHTOOL_REGS_VER 3
 214
 215 static int qlcnic_get_regs_len(struct net_device *dev)
 216 {
 217         struct qlcnic_adapter *adapter = netdev_priv(dev);
 218         u32 len;
 219
 220         if (qlcnic_83xx_check(adapter))
 221                 len = qlcnic_83xx_get_regs_len(adapter);
 222         else
 223                 len = sizeof(ext_diag_registers) + sizeof(diag_registers);
 224
 225         return QLCNIC_RING_REGS_LEN + len + QLCNIC_DEV_INFO_SIZE + 1;
 226 }
 227
 228 static int qlcnic_get_eeprom_len(struct net_device *dev)
 229 {
 230         return QLCNIC_FLASH_TOTAL_SIZE;
 231 }
 232
 233 static void
 234 qlcnic_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo)
 235 {
 236         struct qlcnic_adapter *adapter = netdev_priv(dev);
 237         u32 fw_major, fw_minor, fw_build;
 238         fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
 239         fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
 240         fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
 241         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 242                 "%d.%d.%d", fw_major, fw_minor, fw_build);
 243
 244         strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 245                 sizeof(drvinfo->bus_info));
 246         strlcpy(drvinfo->driver, qlcnic_driver_name, sizeof(drvinfo->driver));
 247         strlcpy(drvinfo->version, QLCNIC_LINUX_VERSIONID,
 248                 sizeof(drvinfo->version));
 249 }
 250
 251 static int
 252 qlcnic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 253 {
 254         struct qlcnic_adapter *adapter = netdev_priv(dev);
 255
 256         if (qlcnic_82xx_check(adapter))
 257                 return qlcnic_82xx_get_settings(adapter, ecmd);
 258         else if (qlcnic_83xx_check(adapter))
 259                 return qlcnic_83xx_get_settings(adapter, ecmd);
 260
 261         return -EIO;
 262 }
 263
 264 int qlcnic_82xx_get_settings(struct qlcnic_adapter *adapter,
 265                              struct ethtool_cmd *ecmd)
 266 {
 267         struct qlcnic_hardware_context *ahw = adapter->ahw;
 268         u32 speed, reg;
 269         int check_sfp_module = 0;
 270         u16 pcifn = ahw->pci_func;
 271
 272         /* read which mode */
 273         if (adapter->ahw->port_type == QLCNIC_GBE) {
 274                 ecmd->supported = (SUPPORTED_10baseT_Half |
 275                                    SUPPORTED_10baseT_Full |
 276                                    SUPPORTED_100baseT_Half |
 277                                    SUPPORTED_100baseT_Full |
 278                                    SUPPORTED_1000baseT_Half |
 279                                    SUPPORTED_1000baseT_Full);
 280
 281                 ecmd->advertising = (ADVERTISED_100baseT_Half |
 282                                      ADVERTISED_100baseT_Full |
 283                                      ADVERTISED_1000baseT_Half |
 284                                      ADVERTISED_1000baseT_Full);
 285
 286                 ethtool_cmd_speed_set(ecmd, adapter->ahw->link_speed);
 287                 ecmd->duplex = adapter->ahw->link_duplex;
 288                 ecmd->autoneg = adapter->ahw->link_autoneg;
 289
 290         } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
 291                 u32 val = 0;
 292                 val = QLCRD32(adapter, QLCNIC_PORT_MODE_ADDR);
 293
 294                 if (val == QLCNIC_PORT_MODE_802_3_AP) {
 295                         ecmd->supported = SUPPORTED_1000baseT_Full;
 296                         ecmd->advertising = ADVERTISED_1000baseT_Full;
 297                 } else {
 298                         ecmd->supported = SUPPORTED_10000baseT_Full;
 299                         ecmd->advertising = ADVERTISED_10000baseT_Full;
 300                 }
 301
 302                 if (netif_running(adapter->netdev) && ahw->has_link_events) {
 303                         reg = QLCRD32(adapter, P3P_LINK_SPEED_REG(pcifn));
 304                         speed = P3P_LINK_SPEED_VAL(pcifn, reg);
 305                         ahw->link_speed = speed * P3P_LINK_SPEED_MHZ;
 306                         ethtool_cmd_speed_set(ecmd, ahw->link_speed);
 307                         ecmd->autoneg = ahw->link_autoneg;
 308                         ecmd->duplex = ahw->link_duplex;
 309                         goto skip;
 310                 }
 311
 312                 ethtool_cmd_speed_set(ecmd, SPEED_UNKNOWN);
 313                 ecmd->duplex = DUPLEX_UNKNOWN;
 314                 ecmd->autoneg = AUTONEG_DISABLE;
 315         } else
 316                 return -EIO;
 317
 318 skip:
 319         ecmd->phy_address = adapter->ahw->physical_port;
 320         ecmd->transceiver = XCVR_EXTERNAL;
 321
 322         switch (adapter->ahw->board_type) {
 323         case QLCNIC_BRDTYPE_P3P_REF_QG:
 324         case QLCNIC_BRDTYPE_P3P_4_GB:
 325         case QLCNIC_BRDTYPE_P3P_4_GB_MM:
 326
 327                 ecmd->supported |= SUPPORTED_Autoneg;
 328                 ecmd->advertising |= ADVERTISED_Autoneg;
 329         case QLCNIC_BRDTYPE_P3P_10G_CX4:
 330         case QLCNIC_BRDTYPE_P3P_10G_CX4_LP:
 331         case QLCNIC_BRDTYPE_P3P_10000_BASE_T:
 332                 ecmd->supported |= SUPPORTED_TP;
 333                 ecmd->advertising |= ADVERTISED_TP;
 334                 ecmd->port = PORT_TP;
 335                 ecmd->autoneg =  adapter->ahw->link_autoneg;
 336                 break;
 337         case QLCNIC_BRDTYPE_P3P_IMEZ:
 338         case QLCNIC_BRDTYPE_P3P_XG_LOM:
 339         case QLCNIC_BRDTYPE_P3P_HMEZ:
 340                 ecmd->supported |= SUPPORTED_MII;
 341                 ecmd->advertising |= ADVERTISED_MII;
 342                 ecmd->port = PORT_MII;
 343                 ecmd->autoneg = AUTONEG_DISABLE;
 344                 break;
 345         case QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS:
 346         case QLCNIC_BRDTYPE_P3P_10G_SFP_CT:
 347         case QLCNIC_BRDTYPE_P3P_10G_SFP_QT:
 348                 ecmd->advertising |= ADVERTISED_TP;
 349                 ecmd->supported |= SUPPORTED_TP;
 350                 check_sfp_module = netif_running(adapter->netdev) &&
 351                                    ahw->has_link_events;
 352         case QLCNIC_BRDTYPE_P3P_10G_XFP:
 353                 ecmd->supported |= SUPPORTED_FIBRE;
 354                 ecmd->advertising |= ADVERTISED_FIBRE;
 355                 ecmd->port = PORT_FIBRE;
 356                 ecmd->autoneg = AUTONEG_DISABLE;
 357                 break;
 358         case QLCNIC_BRDTYPE_P3P_10G_TP:
 359                 if (adapter->ahw->port_type == QLCNIC_XGBE) {
 360                         ecmd->autoneg = AUTONEG_DISABLE;
 361                         ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
 362                         ecmd->advertising |=
 363                                 (ADVERTISED_FIBRE | ADVERTISED_TP);
 364                         ecmd->port = PORT_FIBRE;
 365                         check_sfp_module = netif_running(adapter->netdev) &&
 366                                            ahw->has_link_events;
 367                 } else {
 368                         ecmd->autoneg = AUTONEG_ENABLE;
 369                         ecmd->supported |= (SUPPORTED_TP | SUPPORTED_Autoneg);
 370                         ecmd->advertising |=
 371                                 (ADVERTISED_TP | ADVERTISED_Autoneg);
 372                         ecmd->port = PORT_TP;
 373                 }
 374                 break;
 375         default:
 376                 dev_err(&adapter->pdev->dev, "Unsupported board model %d\n",
 377                         adapter->ahw->board_type);
 378                 return -EIO;
 379         }
 380
 381         if (check_sfp_module) {
 382                 switch (adapter->ahw->module_type) {
 383                 case LINKEVENT_MODULE_OPTICAL_UNKNOWN:
 384                 case LINKEVENT_MODULE_OPTICAL_SRLR:
 385                 case LINKEVENT_MODULE_OPTICAL_LRM:
 386                 case LINKEVENT_MODULE_OPTICAL_SFP_1G:
 387                         ecmd->port = PORT_FIBRE;
 388                         break;
 389                 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLE:
 390                 case LINKEVENT_MODULE_TWINAX_UNSUPPORTED_CABLELEN:
 391                 case LINKEVENT_MODULE_TWINAX:
 392                         ecmd->port = PORT_TP;
 393                         break;
 394                 default:
 395                         ecmd->port = PORT_OTHER;
 396                 }
 397         }
 398
 399         return 0;
 400 }
 401
 402 static int qlcnic_set_port_config(struct qlcnic_adapter *adapter,
 403                                   struct ethtool_cmd *ecmd)
 404 {
 405         u32 ret = 0, config = 0;
 406         /* read which mode */
 407         if (ecmd->duplex)
 408                 config |= 0x1;
 409
 410         if (ecmd->autoneg)
 411                 config |= 0x2;
 412
 413         switch (ethtool_cmd_speed(ecmd)) {
 414         case SPEED_10:
 415                 config |= (0 << 8);
 416                 break;
 417         case SPEED_100:
 418                 config |= (1 << 8);
 419                 break;
 420         case SPEED_1000:
 421                 config |= (10 << 8);
 422                 break;
 423         default:
 424                 return -EIO;
 425         }
 426
 427         ret = qlcnic_fw_cmd_set_port(adapter, config);
 428
 429         if (ret == QLCNIC_RCODE_NOT_SUPPORTED)
 430                 return -EOPNOTSUPP;
 431         else if (ret)
 432                 return -EIO;
 433         return ret;
 434 }
 435
 436 static int qlcnic_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 437 {
 438         u32 ret = 0;
 439         struct qlcnic_adapter *adapter = netdev_priv(dev);
 440
 441         if (adapter->ahw->port_type != QLCNIC_GBE)
 442                 return -EOPNOTSUPP;
 443
 444         if (qlcnic_83xx_check(adapter))
 445                 ret = qlcnic_83xx_set_settings(adapter, ecmd);
 446         else
 447                 ret = qlcnic_set_port_config(adapter, ecmd);
 448
 449         if (!ret)
 450                 return ret;
 451
 452         adapter->ahw->link_speed = ethtool_cmd_speed(ecmd);
 453         adapter->ahw->link_duplex = ecmd->duplex;
 454         adapter->ahw->link_autoneg = ecmd->autoneg;
 455
 456         if (!netif_running(dev))
 457                 return 0;
 458
 459         dev->netdev_ops->ndo_stop(dev);
 460         return dev->netdev_ops->ndo_open(dev);
 461 }
 462
 463 static int qlcnic_82xx_get_registers(struct qlcnic_adapter *adapter,
 464                                      u32 *regs_buff)
 465 {
 466         int i, j = 0;
 467
 468         for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++)
 469                 regs_buff[i] = QLC_SHARED_REG_RD32(adapter, diag_registers[j]);
 470         j = 0;
 471         while (ext_diag_registers[j] != -1)
 472                 regs_buff[i++] = QLCRD32(adapter, ext_diag_registers[j++]);
 473         return i;
 474 }
 475
 476 static void
 477 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 478 {
 479         struct qlcnic_adapter *adapter = netdev_priv(dev);
 480         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 481         struct qlcnic_host_sds_ring *sds_ring;
 482         u32 *regs_buff = p;
 483         int ring, i = 0;
 484
 485         memset(p, 0, qlcnic_get_regs_len(dev));
 486
 487         regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
 488                 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
 489
 490         regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
 491         regs_buff[1] = QLCNIC_MGMT_API_VERSION;
 492
 493         if (qlcnic_82xx_check(adapter))
 494                 i = qlcnic_82xx_get_registers(adapter, regs_buff);
 495         else
 496                 i = qlcnic_83xx_get_registers(adapter, regs_buff);
 497
 498         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
 499                 return;
 500
 501         regs_buff[i++] = 0xFFEFCDAB; /* Marker btw regs and ring count*/
 502
 503         regs_buff[i++] = 1; /* No. of tx ring */
 504         regs_buff[i++] = le32_to_cpu(*(adapter->tx_ring->hw_consumer));
 505         regs_buff[i++] = readl(adapter->tx_ring->crb_cmd_producer);
 506
 507         regs_buff[i++] = 2; /* No. of rx ring */
 508         regs_buff[i++] = readl(recv_ctx->rds_rings[0].crb_rcv_producer);
 509         regs_buff[i++] = readl(recv_ctx->rds_rings[1].crb_rcv_producer);
 510
 511         regs_buff[i++] = adapter->max_sds_rings;
 512
 513         for (ring = 0; ring < adapter->max_sds_rings; ring++) {
 514                 sds_ring = &(recv_ctx->sds_rings[ring]);
 515                 regs_buff[i++] = readl(sds_ring->crb_sts_consumer);
 516         }
 517 }
 518
 519 static u32 qlcnic_test_link(struct net_device *dev)
 520 {
 521         struct qlcnic_adapter *adapter = netdev_priv(dev);
 522         u32 val;
 523
 524         if (qlcnic_83xx_check(adapter)) {
 525                 val = qlcnic_83xx_test_link(adapter);
 526                 return (val & 1) ? 0 : 1;
 527         }
 528         val = QLCRD32(adapter, CRB_XG_STATE_P3P);
 529         val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
 530         return (val == XG_LINK_UP_P3P) ? 0 : 1;
 531 }
 532
 533 static int
 534 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 535                       u8 *bytes)
 536 {
 537         struct qlcnic_adapter *adapter = netdev_priv(dev);
 538         int offset;
 539         int ret = -1;
 540
 541         if (qlcnic_83xx_check(adapter))
 542                 return 0;
 543         if (eeprom->len == 0)
 544                 return -EINVAL;
 545
 546         eeprom->magic = (adapter->pdev)->vendor |
 547                         ((adapter->pdev)->device << 16);
 548         offset = eeprom->offset;
 549
 550         if (qlcnic_82xx_check(adapter))
 551                 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes,
 552                                                  eeprom->len);
 553         if (ret < 0)
 554                 return ret;
 555
 556         return 0;
 557 }
 558
 559 static void
 560 qlcnic_get_ringparam(struct net_device *dev,
 561                 struct ethtool_ringparam *ring)
 562 {
 563         struct qlcnic_adapter *adapter = netdev_priv(dev);
 564
 565         ring->rx_pending = adapter->num_rxd;
 566         ring->rx_jumbo_pending = adapter->num_jumbo_rxd;
 567         ring->tx_pending = adapter->num_txd;
 568
 569         ring->rx_max_pending = adapter->max_rxd;
 570         ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd;
 571         ring->tx_max_pending = MAX_CMD_DESCRIPTORS;
 572 }
 573
 574 static u32
 575 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
 576 {
 577         u32 num_desc;
 578         num_desc = max(val, min);
 579         num_desc = min(num_desc, max);
 580         num_desc = roundup_pow_of_two(num_desc);
 581
 582         if (val != num_desc) {
 583                 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
 584                        qlcnic_driver_name, r_name, num_desc, val);
 585         }
 586
 587         return num_desc;
 588 }
 589
 590 static int
 591 qlcnic_set_ringparam(struct net_device *dev,
 592                 struct ethtool_ringparam *ring)
 593 {
 594         struct qlcnic_adapter *adapter = netdev_priv(dev);
 595         u16 num_rxd, num_jumbo_rxd, num_txd;
 596
 597         if (ring->rx_mini_pending)
 598                 return -EOPNOTSUPP;
 599
 600         num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
 601                         MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
 602
 603         num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
 604                         MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
 605                                                 "rx jumbo");
 606
 607         num_txd = qlcnic_validate_ringparam(ring->tx_pending,
 608                         MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
 609
 610         if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
 611                         num_jumbo_rxd == adapter->num_jumbo_rxd)
 612                 return 0;
 613
 614         adapter->num_rxd = num_rxd;
 615         adapter->num_jumbo_rxd = num_jumbo_rxd;
 616         adapter->num_txd = num_txd;
 617
 618         return qlcnic_reset_context(adapter);
 619 }
 620
 621 static void qlcnic_get_channels(struct net_device *dev,
 622                 struct ethtool_channels *channel)
 623 {
 624         int min;
 625         struct qlcnic_adapter *adapter = netdev_priv(dev);
 626
 627         min = min_t(int, adapter->ahw->max_rx_ques, num_online_cpus());
 628         channel->max_rx = rounddown_pow_of_two(min);
 629         channel->max_tx = adapter->ahw->max_tx_ques;
 630
 631         channel->rx_count = adapter->max_sds_rings;
 632         channel->tx_count = adapter->ahw->max_tx_ques;
 633 }
 634
 635 static int qlcnic_set_channels(struct net_device *dev,
 636                 struct ethtool_channels *channel)
 637 {
 638         struct qlcnic_adapter *adapter = netdev_priv(dev);
 639         int err;
 640
 641         if (channel->other_count || channel->combined_count ||
 642             channel->tx_count != channel->max_tx)
 643                 return -EINVAL;
 644
 645         err = qlcnic_validate_max_rss(adapter, channel->rx_count);
 646         if (err)
 647                 return err;
 648
 649         err = qlcnic_set_max_rss(adapter, channel->rx_count, 0);
 650         netdev_info(dev, "allocated 0x%x sds rings\n",
 651                                  adapter->max_sds_rings);
 652         return err;
 653 }
 654
 655 static void
 656 qlcnic_get_pauseparam(struct net_device *netdev,
 657                           struct ethtool_pauseparam *pause)
 658 {
 659         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 660         int port = adapter->ahw->physical_port;
 661         __u32 val;
 662
 663         if (qlcnic_83xx_check(adapter)) {
 664                 qlcnic_83xx_get_pauseparam(adapter, pause);
 665                 return;
 666         }
 667         if (adapter->ahw->port_type == QLCNIC_GBE) {
 668                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
 669                         return;
 670                 /* get flow control settings */
 671                 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
 672                 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
 673                 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
 674                 switch (port) {
 675                 case 0:
 676                         pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
 677                         break;
 678                 case 1:
 679                         pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
 680                         break;
 681                 case 2:
 682                         pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
 683                         break;
 684                 case 3:
 685                 default:
 686                         pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
 687                         break;
 688                 }
 689         } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
 690                 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
 691                         return;
 692                 pause->rx_pause = 1;
 693                 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
 694                 if (port == 0)
 695                         pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
 696                 else
 697                         pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
 698         } else {
 699                 dev_err(&netdev->dev, "Unknown board type: %x\n",
 700                                         adapter->ahw->port_type);
 701         }
 702 }
 703
 704 static int
 705 qlcnic_set_pauseparam(struct net_device *netdev,
 706                           struct ethtool_pauseparam *pause)
 707 {
 708         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 709         int port = adapter->ahw->physical_port;
 710         __u32 val;
 711
 712         if (qlcnic_83xx_check(adapter))
 713                 return qlcnic_83xx_set_pauseparam(adapter, pause);
 714
 715         /* read mode */
 716         if (adapter->ahw->port_type == QLCNIC_GBE) {
 717                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
 718                         return -EIO;
 719                 /* set flow control */
 720                 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port));
 721
 722                 if (pause->rx_pause)
 723                         qlcnic_gb_rx_flowctl(val);
 724                 else
 725                         qlcnic_gb_unset_rx_flowctl(val);
 726
 727                 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
 728                                 val);
 729                 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), val);
 730                 /* set autoneg */
 731                 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL);
 732                 switch (port) {
 733                 case 0:
 734                         if (pause->tx_pause)
 735                                 qlcnic_gb_unset_gb0_mask(val);
 736                         else
 737                                 qlcnic_gb_set_gb0_mask(val);
 738                         break;
 739                 case 1:
 740                         if (pause->tx_pause)
 741                                 qlcnic_gb_unset_gb1_mask(val);
 742                         else
 743                                 qlcnic_gb_set_gb1_mask(val);
 744                         break;
 745                 case 2:
 746                         if (pause->tx_pause)
 747                                 qlcnic_gb_unset_gb2_mask(val);
 748                         else
 749                                 qlcnic_gb_set_gb2_mask(val);
 750                         break;
 751                 case 3:
 752                 default:
 753                         if (pause->tx_pause)
 754                                 qlcnic_gb_unset_gb3_mask(val);
 755                         else
 756                                 qlcnic_gb_set_gb3_mask(val);
 757                         break;
 758                 }
 759                 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
 760         } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
 761                 if (!pause->rx_pause || pause->autoneg)
 762                         return -EOPNOTSUPP;
 763
 764                 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
 765                         return -EIO;
 766
 767                 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL);
 768                 if (port == 0) {
 769                         if (pause->tx_pause)
 770                                 qlcnic_xg_unset_xg0_mask(val);
 771                         else
 772                                 qlcnic_xg_set_xg0_mask(val);
 773                 } else {
 774                         if (pause->tx_pause)
 775                                 qlcnic_xg_unset_xg1_mask(val);
 776                         else
 777                                 qlcnic_xg_set_xg1_mask(val);
 778                 }
 779                 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
 780         } else {
 781                 dev_err(&netdev->dev, "Unknown board type: %x\n",
 782                                 adapter->ahw->port_type);
 783         }
 784         return 0;
 785 }
 786
 787 static int qlcnic_reg_test(struct net_device *dev)
 788 {
 789         struct qlcnic_adapter *adapter = netdev_priv(dev);
 790         u32 data_read;
 791
 792         if (qlcnic_83xx_check(adapter))
 793                 return qlcnic_83xx_reg_test(adapter);
 794
 795         data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0));
 796         if ((data_read & 0xffff) != adapter->pdev->vendor)
 797                 return 1;
 798
 799         return 0;
 800 }
 801
 802 static int qlcnic_eeprom_test(struct net_device *dev)
 803 {
 804         struct qlcnic_adapter *adapter = netdev_priv(dev);
 805
 806         if (qlcnic_82xx_check(adapter))
 807                 return 0;
 808
 809         return qlcnic_83xx_flash_test(adapter);
 810 }
 811
 812 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
 813 {
 814         int len;
 815
 816         struct qlcnic_adapter *adapter = netdev_priv(dev);
 817         switch (sset) {
 818         case ETH_SS_TEST:
 819                 return QLCNIC_TEST_LEN;
 820         case ETH_SS_STATS:
 821                 len = qlcnic_dev_statistics_len(adapter) + QLCNIC_STATS_LEN;
 822                 if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
 823                     qlcnic_83xx_check(adapter))
 824                         return len;
 825                 return qlcnic_82xx_statistics();
 826         default:
 827                 return -EOPNOTSUPP;
 828         }
 829 }
 830
 831 static int qlcnic_irq_test(struct net_device *netdev)
 832 {
 833         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 834         struct qlcnic_hardware_context *ahw = adapter->ahw;
 835         struct qlcnic_cmd_args cmd;
 836         int ret, max_sds_rings = adapter->max_sds_rings;
 837
 838         if (qlcnic_83xx_check(adapter))
 839                 return qlcnic_83xx_interrupt_test(netdev);
 840
 841         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 842                 return -EIO;
 843
 844         ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
 845         if (ret)
 846                 goto clear_diag_irq;
 847
 848         ahw->diag_cnt = 0;
 849         ret = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_INTRPT_TEST);
 850         if (ret)
 851                 goto free_diag_res;
 852
 853         cmd.req.arg[1] = ahw->pci_func;
 854         ret = qlcnic_issue_cmd(adapter, &cmd);
 855         if (ret)
 856                 goto done;
 857
 858         usleep_range(1000, 12000);
 859         ret = !ahw->diag_cnt;
 860
 861 done:
 862         qlcnic_free_mbx_args(&cmd);
 863
 864 free_diag_res:
 865         qlcnic_diag_free_res(netdev, max_sds_rings);
 866
 867 clear_diag_irq:
 868         adapter->max_sds_rings = max_sds_rings;
 869         clear_bit(__QLCNIC_RESETTING, &adapter->state);
 870         return ret;
 871 }
 872
 873 #define QLCNIC_ILB_PKT_SIZE             64
 874 #define QLCNIC_NUM_ILB_PKT              16
 875 #define QLCNIC_ILB_MAX_RCV_LOOP         10
 876 #define QLCNIC_LB_PKT_POLL_DELAY_MSEC   1
 877 #define QLCNIC_LB_PKT_POLL_COUNT        20
 878
 879 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[])
 880 {
 881         unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00};
 882
 883         memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE);
 884
 885         memcpy(data, mac, ETH_ALEN);
 886         memcpy(data + ETH_ALEN, mac, ETH_ALEN);
 887
 888         memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data));
 889 }
 890
 891 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[])
 892 {
 893         unsigned char buff[QLCNIC_ILB_PKT_SIZE];
 894         qlcnic_create_loopback_buff(buff, mac);
 895         return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE);
 896 }
 897
 898 int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode)
 899 {
 900         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 901         struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0];
 902         struct sk_buff *skb;
 903         int i, loop, cnt = 0;
 904
 905         for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) {
 906                 skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE);
 907                 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr);
 908                 skb_put(skb, QLCNIC_ILB_PKT_SIZE);
 909                 adapter->ahw->diag_cnt = 0;
 910                 qlcnic_xmit_frame(skb, adapter->netdev);
 911                 loop = 0;
 912
 913                 do {
 914                         msleep(QLCNIC_LB_PKT_POLL_DELAY_MSEC);
 915                         qlcnic_process_rcv_ring_diag(sds_ring);
 916                         if (loop++ > QLCNIC_LB_PKT_POLL_COUNT)
 917                                 break;
 918                 } while (!adapter->ahw->diag_cnt);
 919
 920                 dev_kfree_skb_any(skb);
 921
 922                 if (!adapter->ahw->diag_cnt)
 923                         dev_warn(&adapter->pdev->dev,
 924                                  "LB Test: packet #%d was not received\n",
 925                                  i + 1);
 926                 else
 927                         cnt++;
 928         }
 929         if (cnt != i) {
 930                 dev_err(&adapter->pdev->dev,
 931                         "LB Test: failed, TX[%d], RX[%d]\n", i, cnt);
 932                 if (mode != QLCNIC_ILB_MODE)
 933                         dev_warn(&adapter->pdev->dev,
 934                                  "WARNING: Please check loopback cable\n");
 935                 return -1;
 936         }
 937         return 0;
 938 }
 939
 940 int qlcnic_loopback_test(struct net_device *netdev, u8 mode)
 941 {
 942         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 943         int max_sds_rings = adapter->max_sds_rings;
 944         struct qlcnic_host_sds_ring *sds_ring;
 945         struct qlcnic_hardware_context *ahw = adapter->ahw;
 946         int loop = 0;
 947         int ret;
 948
 949         if (qlcnic_83xx_check(adapter))
 950                 return qlcnic_83xx_loopback_test(netdev, mode);
 951
 952         if (!(ahw->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) {
 953                 dev_info(&adapter->pdev->dev,
 954                          "Firmware do not support loopback test\n");
 955                 return -EOPNOTSUPP;
 956         }
 957
 958         dev_warn(&adapter->pdev->dev, "%s loopback test in progress\n",
 959                  mode == QLCNIC_ILB_MODE ? "internal" : "external");
 960         if (ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
 961                 dev_warn(&adapter->pdev->dev,
 962                          "Loopback test not supported in nonprivileged mode\n");
 963                 return 0;
 964         }
 965
 966         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 967                 return -EBUSY;
 968
 969         ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST);
 970         if (ret)
 971                 goto clear_it;
 972
 973         sds_ring = &adapter->recv_ctx->sds_rings[0];
 974         ret = qlcnic_set_lb_mode(adapter, mode);
 975         if (ret)
 976                 goto free_res;
 977
 978         ahw->diag_cnt = 0;
 979         do {
 980                 msleep(500);
 981                 qlcnic_process_rcv_ring_diag(sds_ring);
 982                 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) {
 983                         netdev_info(netdev, "firmware didnt respond to loopback"
 984                                 " configure request\n");
 985                         ret = -QLCNIC_FW_NOT_RESPOND;
 986                         goto free_res;
 987                 } else if (adapter->ahw->diag_cnt) {
 988                         ret = adapter->ahw->diag_cnt;
 989                         goto free_res;
 990                 }
 991         } while (!QLCNIC_IS_LB_CONFIGURED(ahw->loopback_state));
 992
 993         ret = qlcnic_do_lb_test(adapter, mode);
 994
 995         qlcnic_clear_lb_mode(adapter, mode);
 996
 997  free_res:
 998         qlcnic_diag_free_res(netdev, max_sds_rings);
 999
1000  clear_it:
1001         adapter->max_sds_rings = max_sds_rings;
1002         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1003         return ret;
1004 }
1005
1006 static void
1007 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
1008                      u64 *data)
1009 {
1010         memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
1011
1012         data[0] = qlcnic_reg_test(dev);
1013         if (data[0])
1014                 eth_test->flags |= ETH_TEST_FL_FAILED;
1015
1016         data[1] = (u64) qlcnic_test_link(dev);
1017         if (data[1])
1018                 eth_test->flags |= ETH_TEST_FL_FAILED;
1019
1020         if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
1021                 data[2] = qlcnic_irq_test(dev);
1022                 if (data[2])
1023                         eth_test->flags |= ETH_TEST_FL_FAILED;
1024
1025                 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE);
1026                 if (data[3])
1027                         eth_test->flags |= ETH_TEST_FL_FAILED;
1028
1029                 data[4] = qlcnic_eeprom_test(dev);
1030                 if (data[4])
1031                         eth_test->flags |= ETH_TEST_FL_FAILED;
1032         }
1033 }
1034
1035 static void
1036 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1037 {
1038         struct qlcnic_adapter *adapter = netdev_priv(dev);
1039         int index, i, num_stats;
1040
1041         switch (stringset) {
1042         case ETH_SS_TEST:
1043                 memcpy(data, *qlcnic_gstrings_test,
1044                        QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
1045                 break;
1046         case ETH_SS_STATS:
1047                 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
1048                         memcpy(data + index * ETH_GSTRING_LEN,
1049                                qlcnic_gstrings_stats[index].stat_string,
1050                                ETH_GSTRING_LEN);
1051                 }
1052                 if (qlcnic_83xx_check(adapter)) {
1053                         num_stats = ARRAY_SIZE(qlcnic_83xx_tx_stats_strings);
1054                         for (i = 0; i < num_stats; i++, index++)
1055                                 memcpy(data + index * ETH_GSTRING_LEN,
1056                                        qlcnic_83xx_tx_stats_strings[i],
1057                                        ETH_GSTRING_LEN);
1058                         num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
1059                         for (i = 0; i < num_stats; i++, index++)
1060                                 memcpy(data + index * ETH_GSTRING_LEN,
1061                                        qlcnic_83xx_mac_stats_strings[i],
1062                                        ETH_GSTRING_LEN);
1063                         num_stats = ARRAY_SIZE(qlcnic_83xx_rx_stats_strings);
1064                         for (i = 0; i < num_stats; i++, index++)
1065                                 memcpy(data + index * ETH_GSTRING_LEN,
1066                                        qlcnic_83xx_rx_stats_strings[i],
1067                                        ETH_GSTRING_LEN);
1068                         return;
1069                 } else {
1070                         num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
1071                         for (i = 0; i < num_stats; i++, index++)
1072                                 memcpy(data + index * ETH_GSTRING_LEN,
1073                                        qlcnic_83xx_mac_stats_strings[i],
1074                                        ETH_GSTRING_LEN);
1075                 }
1076                 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1077                         return;
1078                 num_stats = ARRAY_SIZE(qlcnic_device_gstrings_stats);
1079                 for (i = 0; i < num_stats; index++, i++) {
1080                         memcpy(data + index * ETH_GSTRING_LEN,
1081                                qlcnic_device_gstrings_stats[i],
1082                                ETH_GSTRING_LEN);
1083                 }
1084         }
1085 }
1086
1087 static u64 *qlcnic_fill_stats(u64 *data, void *stats, int type)
1088 {
1089         if (type == QLCNIC_MAC_STATS) {
1090                 struct qlcnic_mac_statistics *mac_stats =
1091                                         (struct qlcnic_mac_statistics *)stats;
1092                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames);
1093                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes);
1094                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts);
1095                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts);
1096                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt);
1097                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt);
1098                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts);
1099                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts);
1100                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts);
1101                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts);
1102                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts);
1103                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts);
1104                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts);
1105                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames);
1106                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes);
1107                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts);
1108                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts);
1109                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt);
1110                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt);
1111                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts);
1112                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts);
1113                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts);
1114                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts);
1115                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts);
1116                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts);
1117                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts);
1118                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error);
1119                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small);
1120                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large);
1121                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber);
1122                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped);
1123                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error);
1124                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_align_error);
1125         } else if (type == QLCNIC_ESW_STATS) {
1126                 struct __qlcnic_esw_statistics *esw_stats =
1127                                 (struct __qlcnic_esw_statistics *)stats;
1128                 *data++ = QLCNIC_FILL_STATS(esw_stats->unicast_frames);
1129                 *data++ = QLCNIC_FILL_STATS(esw_stats->multicast_frames);
1130                 *data++ = QLCNIC_FILL_STATS(esw_stats->broadcast_frames);
1131                 *data++ = QLCNIC_FILL_STATS(esw_stats->dropped_frames);
1132                 *data++ = QLCNIC_FILL_STATS(esw_stats->errors);
1133                 *data++ = QLCNIC_FILL_STATS(esw_stats->local_frames);
1134                 *data++ = QLCNIC_FILL_STATS(esw_stats->numbytes);
1135         }
1136         return data;
1137 }
1138
1139 static void qlcnic_get_ethtool_stats(struct net_device *dev,
1140                                      struct ethtool_stats *stats, u64 *data)
1141 {
1142         struct qlcnic_adapter *adapter = netdev_priv(dev);
1143         struct qlcnic_esw_statistics port_stats;
1144         struct qlcnic_mac_statistics mac_stats;
1145         int index, ret, length, size;
1146         char *p;
1147
1148         memset(data, 0, stats->n_stats * sizeof(u64));
1149         length = QLCNIC_STATS_LEN;
1150         for (index = 0; index < length; index++) {
1151                 p = (char *)adapter + qlcnic_gstrings_stats[index].stat_offset;
1152                 size = qlcnic_gstrings_stats[index].sizeof_stat;
1153                 *data++ = (size == sizeof(u64)) ? (*(u64 *)p) : ((*(u32 *)p));
1154         }
1155
1156         if (qlcnic_83xx_check(adapter)) {
1157                 if (adapter->ahw->linkup)
1158                         qlcnic_83xx_get_stats(adapter, data);
1159                 return;
1160         } else {
1161                 /* Retrieve MAC statistics from firmware */
1162                 memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics));
1163                 qlcnic_get_mac_stats(adapter, &mac_stats);
1164                 data = qlcnic_fill_stats(data, &mac_stats, QLCNIC_MAC_STATS);
1165         }
1166
1167         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1168                 return;
1169
1170         memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
1171         ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1172                         QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
1173         if (ret)
1174                 return;
1175
1176         data = qlcnic_fill_stats(data, &port_stats.rx, QLCNIC_ESW_STATS);
1177         ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1178                         QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
1179         if (ret)
1180                 return;
1181
1182         qlcnic_fill_stats(data, &port_stats.tx, QLCNIC_ESW_STATS);
1183 }
1184
1185 static int qlcnic_set_led(struct net_device *dev,
1186                           enum ethtool_phys_id_state state)
1187 {
1188         struct qlcnic_adapter *adapter = netdev_priv(dev);
1189         int max_sds_rings = adapter->max_sds_rings;
1190         int err = -EIO, active = 1;
1191
1192         if (qlcnic_83xx_check(adapter))
1193                 return qlcnic_83xx_set_led(dev, state);
1194
1195         if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
1196                 netdev_warn(dev, "LED test not supported for non "
1197                                 "privilege function\n");
1198                 return -EOPNOTSUPP;
1199         }
1200
1201         switch (state) {
1202         case ETHTOOL_ID_ACTIVE:
1203                 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))
1204                         return -EBUSY;
1205
1206                 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1207                         break;
1208
1209                 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1210                         if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1211                                 break;
1212                         set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1213                 }
1214
1215                 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) {
1216                         err = 0;
1217                         break;
1218                 }
1219
1220                 dev_err(&adapter->pdev->dev,
1221                         "Failed to set LED blink state.\n");
1222                 break;
1223
1224         case ETHTOOL_ID_INACTIVE:
1225                 active = 0;
1226
1227                 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1228                         break;
1229
1230                 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1231                         if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1232                                 break;
1233                         set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1234                 }
1235
1236                 if (adapter->nic_ops->config_led(adapter, 0, 0xf))
1237                         dev_err(&adapter->pdev->dev,
1238                                 "Failed to reset LED blink state.\n");
1239
1240                 break;
1241
1242         default:
1243                 return -EINVAL;
1244         }
1245
1246         if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
1247                 qlcnic_diag_free_res(dev, max_sds_rings);
1248
1249         if (!active || err)
1250                 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
1251
1252         return err;
1253 }
1254
1255 static void
1256 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1257 {
1258         struct qlcnic_adapter *adapter = netdev_priv(dev);
1259         u32 wol_cfg;
1260
1261         if (qlcnic_83xx_check(adapter))
1262                 return;
1263         wol->supported = 0;
1264         wol->wolopts = 0;
1265
1266         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
1267         if (wol_cfg & (1UL << adapter->portnum))
1268                 wol->supported |= WAKE_MAGIC;
1269
1270         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
1271         if (wol_cfg & (1UL << adapter->portnum))
1272                 wol->wolopts |= WAKE_MAGIC;
1273 }
1274
1275 static int
1276 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1277 {
1278         struct qlcnic_adapter *adapter = netdev_priv(dev);
1279         u32 wol_cfg;
1280
1281         if (qlcnic_83xx_check(adapter))
1282                 return -EOPNOTSUPP;
1283         if (wol->wolopts & ~WAKE_MAGIC)
1284                 return -EINVAL;
1285
1286         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV);
1287         if (!(wol_cfg & (1 << adapter->portnum)))
1288                 return -EOPNOTSUPP;
1289
1290         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG);
1291         if (wol->wolopts & WAKE_MAGIC)
1292                 wol_cfg |= 1UL << adapter->portnum;
1293         else
1294                 wol_cfg &= ~(1UL << adapter->portnum);
1295
1296         QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
1297
1298         return 0;
1299 }
1300
1301 /*
1302  * Set the coalescing parameters. Currently only normal is supported.
1303  * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
1304  * firmware coalescing to default.
1305  */
1306 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
1307                         struct ethtool_coalesce *ethcoal)
1308 {
1309         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1310         struct qlcnic_nic_intr_coalesce *coal;
1311         u32 rx_coalesce_usecs, rx_max_frames;
1312         u32 tx_coalesce_usecs, tx_max_frames;
1313
1314         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
1315                 return -EINVAL;
1316
1317         /*
1318         * Return Error if unsupported values or
1319         * unsupported parameters are set.
1320         */
1321         if (ethcoal->rx_coalesce_usecs > 0xffff ||
1322                 ethcoal->rx_max_coalesced_frames > 0xffff ||
1323                 ethcoal->tx_coalesce_usecs > 0xffff ||
1324                 ethcoal->tx_max_coalesced_frames > 0xffff ||
1325                 ethcoal->rx_coalesce_usecs_irq ||
1326                 ethcoal->rx_max_coalesced_frames_irq ||
1327                 ethcoal->tx_coalesce_usecs_irq ||
1328                 ethcoal->tx_max_coalesced_frames_irq ||
1329                 ethcoal->stats_block_coalesce_usecs ||
1330                 ethcoal->use_adaptive_rx_coalesce ||
1331                 ethcoal->use_adaptive_tx_coalesce ||
1332                 ethcoal->pkt_rate_low ||
1333                 ethcoal->rx_coalesce_usecs_low ||
1334                 ethcoal->rx_max_coalesced_frames_low ||
1335                 ethcoal->tx_coalesce_usecs_low ||
1336                 ethcoal->tx_max_coalesced_frames_low ||
1337                 ethcoal->pkt_rate_high ||
1338                 ethcoal->rx_coalesce_usecs_high ||
1339                 ethcoal->rx_max_coalesced_frames_high ||
1340                 ethcoal->tx_coalesce_usecs_high ||
1341                 ethcoal->tx_max_coalesced_frames_high)
1342                 return -EINVAL;
1343
1344         coal = &adapter->ahw->coal;
1345
1346         if (qlcnic_83xx_check(adapter)) {
1347                 if (!ethcoal->tx_coalesce_usecs ||
1348                     !ethcoal->tx_max_coalesced_frames ||
1349                     !ethcoal->rx_coalesce_usecs ||
1350                     !ethcoal->rx_max_coalesced_frames) {
1351                         coal->flag = QLCNIC_INTR_DEFAULT;
1352                         coal->type = QLCNIC_INTR_COAL_TYPE_RX;
1353                         coal->rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1354                         coal->rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1355                         coal->tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
1356                         coal->tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
1357                 } else {
1358                         tx_coalesce_usecs = ethcoal->tx_coalesce_usecs;
1359                         tx_max_frames = ethcoal->tx_max_coalesced_frames;
1360                         rx_coalesce_usecs = ethcoal->rx_coalesce_usecs;
1361                         rx_max_frames = ethcoal->rx_max_coalesced_frames;
1362                         coal->flag = 0;
1363
1364                         if ((coal->rx_time_us == rx_coalesce_usecs) &&
1365                             (coal->rx_packets == rx_max_frames)) {
1366                                 coal->type = QLCNIC_INTR_COAL_TYPE_TX;
1367                                 coal->tx_time_us = tx_coalesce_usecs;
1368                                 coal->tx_packets = tx_max_frames;
1369                         } else if ((coal->tx_time_us == tx_coalesce_usecs) &&
1370                                    (coal->tx_packets == tx_max_frames)) {
1371                                 coal->type = QLCNIC_INTR_COAL_TYPE_RX;
1372                                 coal->rx_time_us = rx_coalesce_usecs;
1373                                 coal->rx_packets = rx_max_frames;
1374                         } else {
1375                                 coal->type = QLCNIC_INTR_COAL_TYPE_RX;
1376                                 coal->rx_time_us = rx_coalesce_usecs;
1377                                 coal->rx_packets = rx_max_frames;
1378                                 coal->tx_time_us = tx_coalesce_usecs;
1379                                 coal->tx_packets = tx_max_frames;
1380                         }
1381                 }
1382         } else {
1383                 if (!ethcoal->rx_coalesce_usecs ||
1384                     !ethcoal->rx_max_coalesced_frames) {
1385                         coal->flag = QLCNIC_INTR_DEFAULT;
1386                         coal->rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1387                         coal->rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1388                 } else {
1389                         coal->flag = 0;
1390                         coal->rx_time_us = ethcoal->rx_coalesce_usecs;
1391                         coal->rx_packets = ethcoal->rx_max_coalesced_frames;
1392                 }
1393         }
1394
1395         qlcnic_config_intr_coalesce(adapter);
1396
1397         return 0;
1398 }
1399
1400 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
1401                         struct ethtool_coalesce *ethcoal)
1402 {
1403         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1404
1405         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1406                 return -EINVAL;
1407
1408         ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
1409         ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
1410         ethcoal->tx_coalesce_usecs = adapter->ahw->coal.tx_time_us;
1411         ethcoal->tx_max_coalesced_frames = adapter->ahw->coal.tx_packets;
1412
1413         return 0;
1414 }
1415
1416 static u32 qlcnic_get_msglevel(struct net_device *netdev)
1417 {
1418         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1419
1420         return adapter->ahw->msg_enable;
1421 }
1422
1423 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
1424 {
1425         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1426
1427         adapter->ahw->msg_enable = msglvl;
1428 }
1429
1430 static int
1431 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1432 {
1433         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1434         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1435
1436         if (!fw_dump->tmpl_hdr) {
1437                 netdev_err(adapter->netdev, "FW Dump not supported\n");
1438                 return -ENOTSUPP;
1439         }
1440
1441         if (fw_dump->clr)
1442                 dump->len = fw_dump->tmpl_hdr->size + fw_dump->size;
1443         else
1444                 dump->len = 0;
1445
1446         if (!fw_dump->enable)
1447                 dump->flag = ETH_FW_DUMP_DISABLE;
1448         else
1449                 dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1450
1451         dump->version = adapter->fw_version;
1452         return 0;
1453 }
1454
1455 static int
1456 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1457                         void *buffer)
1458 {
1459         int i, copy_sz;
1460         u32 *hdr_ptr;
1461         __le32 *data;
1462         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1463         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1464
1465         if (!fw_dump->tmpl_hdr) {
1466                 netdev_err(netdev, "FW Dump not supported\n");
1467                 return -ENOTSUPP;
1468         }
1469
1470         if (!fw_dump->clr) {
1471                 netdev_info(netdev, "Dump not available\n");
1472                 return -EINVAL;
1473         }
1474         /* Copy template header first */
1475         copy_sz = fw_dump->tmpl_hdr->size;
1476         hdr_ptr = (u32 *) fw_dump->tmpl_hdr;
1477         data = buffer;
1478         for (i = 0; i < copy_sz/sizeof(u32); i++)
1479                 *data++ = cpu_to_le32(*hdr_ptr++);
1480
1481         /* Copy captured dump data */
1482         memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1483         dump->len = copy_sz + fw_dump->size;
1484         dump->flag = fw_dump->tmpl_hdr->drv_cap_mask;
1485
1486         /* Free dump area once data has been captured */
1487         vfree(fw_dump->data);
1488         fw_dump->data = NULL;
1489         fw_dump->clr = 0;
1490         netdev_info(netdev, "extracted the FW dump Successfully\n");
1491         return 0;
1492 }
1493
1494 static int
1495 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1496 {
1497         int i;
1498         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1499         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1500         u32 state;
1501
1502         switch (val->flag) {
1503         case QLCNIC_FORCE_FW_DUMP_KEY:
1504                 if (!fw_dump->tmpl_hdr) {
1505                         netdev_err(netdev, "FW dump not supported\n");
1506                         return -ENOTSUPP;
1507                 }
1508                 if (!fw_dump->enable) {
1509                         netdev_info(netdev, "FW dump not enabled\n");
1510                         return 0;
1511                 }
1512                 if (fw_dump->clr) {
1513                         netdev_info(netdev,
1514                         "Previous dump not cleared, not forcing dump\n");
1515                         return 0;
1516                 }
1517                 netdev_info(netdev, "Forcing a FW dump\n");
1518                 qlcnic_dev_request_reset(adapter, val->flag);
1519                 break;
1520         case QLCNIC_DISABLE_FW_DUMP:
1521                 if (fw_dump->enable && fw_dump->tmpl_hdr) {
1522                         netdev_info(netdev, "Disabling FW dump\n");
1523                         fw_dump->enable = 0;
1524                 }
1525                 return 0;
1526         case QLCNIC_ENABLE_FW_DUMP:
1527                 if (!fw_dump->tmpl_hdr) {
1528                         netdev_err(netdev, "FW dump not supported\n");
1529                         return -ENOTSUPP;
1530                 }
1531                 if (!fw_dump->enable) {
1532                         netdev_info(netdev, "Enabling FW dump\n");
1533                         fw_dump->enable = 1;
1534                 }
1535                 return 0;
1536         case QLCNIC_FORCE_FW_RESET:
1537                 netdev_info(netdev, "Forcing a FW reset\n");
1538                 qlcnic_dev_request_reset(adapter, val->flag);
1539                 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
1540                 return 0;
1541         case QLCNIC_SET_QUIESCENT:
1542         case QLCNIC_RESET_QUIESCENT:
1543                 state = QLCRD32(adapter, QLCNIC_CRB_DEV_STATE);
1544                 if (state == QLCNIC_DEV_FAILED || (state == QLCNIC_DEV_BADBAD))
1545                         netdev_info(netdev, "Device in FAILED state\n");
1546                 return 0;
1547         default:
1548                 if (!fw_dump->tmpl_hdr) {
1549                         netdev_err(netdev, "FW dump not supported\n");
1550                         return -ENOTSUPP;
1551                 }
1552                 for (i = 0; i < ARRAY_SIZE(qlcnic_fw_dump_level); i++) {
1553                         if (val->flag == qlcnic_fw_dump_level[i]) {
1554                                 fw_dump->tmpl_hdr->drv_cap_mask =
1555                                                         val->flag;
1556                                 netdev_info(netdev, "Driver mask changed to: 0x%x\n",
1557                                         fw_dump->tmpl_hdr->drv_cap_mask);
1558                                 return 0;
1559                         }
1560                 }
1561                 netdev_info(netdev, "Invalid dump level: 0x%x\n", val->flag);
1562                 return -EINVAL;
1563         }
1564         return 0;
1565 }
1566
1567 const struct ethtool_ops qlcnic_ethtool_ops = {
1568         .get_settings = qlcnic_get_settings,
1569         .set_settings = qlcnic_set_settings,
1570         .get_drvinfo = qlcnic_get_drvinfo,
1571         .get_regs_len = qlcnic_get_regs_len,
1572         .get_regs = qlcnic_get_regs,
1573         .get_link = ethtool_op_get_link,
1574         .get_eeprom_len = qlcnic_get_eeprom_len,
1575         .get_eeprom = qlcnic_get_eeprom,
1576         .get_ringparam = qlcnic_get_ringparam,
1577         .set_ringparam = qlcnic_set_ringparam,
1578         .get_channels = qlcnic_get_channels,
1579         .set_channels = qlcnic_set_channels,
1580         .get_pauseparam = qlcnic_get_pauseparam,
1581         .set_pauseparam = qlcnic_set_pauseparam,
1582         .get_wol = qlcnic_get_wol,
1583         .set_wol = qlcnic_set_wol,
1584         .self_test = qlcnic_diag_test,
1585         .get_strings = qlcnic_get_strings,
1586         .get_ethtool_stats = qlcnic_get_ethtool_stats,
1587         .get_sset_count = qlcnic_get_sset_count,
1588         .get_coalesce = qlcnic_get_intr_coalesce,
1589         .set_coalesce = qlcnic_set_intr_coalesce,
1590         .set_phys_id = qlcnic_set_led,
1591         .set_msglevel = qlcnic_set_msglevel,
1592         .get_msglevel = qlcnic_get_msglevel,
1593         .get_dump_flag = qlcnic_get_dump_flag,
1594         .get_dump_data = qlcnic_get_dump_data,
1595         .set_dump = qlcnic_set_dump,
1596 };
1597
1598 const struct ethtool_ops qlcnic_sriov_vf_ethtool_ops = {
1599         .get_settings           = qlcnic_get_settings,
1600         .get_drvinfo            = qlcnic_get_drvinfo,
1601         .get_regs_len           = qlcnic_get_regs_len,
1602         .get_regs               = qlcnic_get_regs,
1603         .get_link               = ethtool_op_get_link,
1604         .get_eeprom_len         = qlcnic_get_eeprom_len,
1605         .get_eeprom             = qlcnic_get_eeprom,
1606         .get_ringparam          = qlcnic_get_ringparam,
1607         .set_ringparam          = qlcnic_set_ringparam,
1608         .get_channels           = qlcnic_get_channels,
1609         .get_pauseparam         = qlcnic_get_pauseparam,
1610         .get_wol                = qlcnic_get_wol,
1611         .get_strings            = qlcnic_get_strings,
1612         .get_ethtool_stats      = qlcnic_get_ethtool_stats,
1613         .get_sset_count         = qlcnic_get_sset_count,
1614         .get_coalesce           = qlcnic_get_intr_coalesce,
1615         .set_coalesce           = qlcnic_set_intr_coalesce,
1616         .set_msglevel           = qlcnic_set_msglevel,
1617         .get_msglevel           = qlcnic_get_msglevel,
1618 };