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