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