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