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