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