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 (qlcnic_83xx_check(adapter))
 490                 qlcnic_83xx_get_port_type(adapter);
 491
 492         if (adapter->ahw->port_type != QLCNIC_GBE)
 493                 return -EOPNOTSUPP;
 494
 495         if (qlcnic_83xx_check(adapter))
 496                 ret = qlcnic_83xx_set_link_ksettings(adapter, ecmd);
 497         else
 498                 ret = qlcnic_set_port_config(adapter, ecmd);
 499
 500         if (!ret)
 501                 return ret;
 502
 503         adapter->ahw->link_speed = ecmd->base.speed;
 504         adapter->ahw->link_duplex = ecmd->base.duplex;
 505         adapter->ahw->link_autoneg = ecmd->base.autoneg;
 506
 507         if (!netif_running(dev))
 508                 return 0;
 509
 510         dev->netdev_ops->ndo_stop(dev);
 511         return dev->netdev_ops->ndo_open(dev);
 512 }
 513
 514 static int qlcnic_82xx_get_registers(struct qlcnic_adapter *adapter,
 515                                      u32 *regs_buff)
 516 {
 517         int i, j = 0, err = 0;
 518
 519         for (i = QLCNIC_DEV_INFO_SIZE + 1; diag_registers[j] != -1; j++, i++)
 520                 regs_buff[i] = QLC_SHARED_REG_RD32(adapter, diag_registers[j]);
 521         j = 0;
 522         while (ext_diag_registers[j] != -1)
 523                 regs_buff[i++] = QLCRD32(adapter, ext_diag_registers[j++],
 524                                          &err);
 525         return i;
 526 }
 527
 528 static void
 529 qlcnic_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 530 {
 531         struct qlcnic_adapter *adapter = netdev_priv(dev);
 532         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
 533         struct qlcnic_host_sds_ring *sds_ring;
 534         struct qlcnic_host_rds_ring *rds_rings;
 535         struct qlcnic_host_tx_ring *tx_ring;
 536         u32 *regs_buff = p;
 537         int ring, i = 0;
 538
 539         memset(p, 0, qlcnic_get_regs_len(dev));
 540
 541         regs->version = (QLCNIC_ETHTOOL_REGS_VER << 24) |
 542                 (adapter->ahw->revision_id << 16) | (adapter->pdev)->device;
 543
 544         regs_buff[0] = (0xcafe0000 | (QLCNIC_DEV_INFO_SIZE & 0xffff));
 545         regs_buff[1] = QLCNIC_MGMT_API_VERSION;
 546
 547         if (adapter->ahw->capabilities & QLC_83XX_ESWITCH_CAPABILITY)
 548                 regs_buff[2] = adapter->ahw->max_vnic_func;
 549
 550         if (qlcnic_82xx_check(adapter))
 551                 i = qlcnic_82xx_get_registers(adapter, regs_buff);
 552         else
 553                 i = qlcnic_83xx_get_registers(adapter, regs_buff);
 554
 555         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
 556                 return;
 557
 558         /* Marker btw regs and TX ring count */
 559         regs_buff[i++] = 0xFFEFCDAB;
 560
 561         regs_buff[i++] = adapter->drv_tx_rings; /* No. of TX ring */
 562         for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
 563                 tx_ring = &adapter->tx_ring[ring];
 564                 regs_buff[i++] = le32_to_cpu(*(tx_ring->hw_consumer));
 565                 regs_buff[i++] = tx_ring->sw_consumer;
 566                 regs_buff[i++] = readl(tx_ring->crb_cmd_producer);
 567                 regs_buff[i++] = tx_ring->producer;
 568                 if (tx_ring->crb_intr_mask)
 569                         regs_buff[i++] = readl(tx_ring->crb_intr_mask);
 570                 else
 571                         regs_buff[i++] = QLCNIC_TX_INTR_NOT_CONFIGURED;
 572         }
 573
 574         regs_buff[i++] = adapter->max_rds_rings; /* No. of RX ring */
 575         for (ring = 0; ring < adapter->max_rds_rings; ring++) {
 576                 rds_rings = &recv_ctx->rds_rings[ring];
 577                 regs_buff[i++] = readl(rds_rings->crb_rcv_producer);
 578                 regs_buff[i++] = rds_rings->producer;
 579         }
 580
 581         regs_buff[i++] = adapter->drv_sds_rings; /* No. of SDS ring */
 582         for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
 583                 sds_ring = &(recv_ctx->sds_rings[ring]);
 584                 regs_buff[i++] = readl(sds_ring->crb_sts_consumer);
 585                 regs_buff[i++] = sds_ring->consumer;
 586                 regs_buff[i++] = readl(sds_ring->crb_intr_mask);
 587         }
 588 }
 589
 590 static u32 qlcnic_test_link(struct net_device *dev)
 591 {
 592         struct qlcnic_adapter *adapter = netdev_priv(dev);
 593         int err = 0;
 594         u32 val;
 595
 596         if (qlcnic_83xx_check(adapter)) {
 597                 val = qlcnic_83xx_test_link(adapter);
 598                 return (val & 1) ? 0 : 1;
 599         }
 600         val = QLCRD32(adapter, CRB_XG_STATE_P3P, &err);
 601         if (err == -EIO)
 602                 return err;
 603         val = XG_LINK_STATE_P3P(adapter->ahw->pci_func, val);
 604         return (val == XG_LINK_UP_P3P) ? 0 : 1;
 605 }
 606
 607 static int
 608 qlcnic_get_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
 609                       u8 *bytes)
 610 {
 611         struct qlcnic_adapter *adapter = netdev_priv(dev);
 612         int offset;
 613         int ret = -1;
 614
 615         if (qlcnic_83xx_check(adapter))
 616                 return 0;
 617         if (eeprom->len == 0)
 618                 return -EINVAL;
 619
 620         eeprom->magic = (adapter->pdev)->vendor |
 621                         ((adapter->pdev)->device << 16);
 622         offset = eeprom->offset;
 623
 624         if (qlcnic_82xx_check(adapter))
 625                 ret = qlcnic_rom_fast_read_words(adapter, offset, bytes,
 626                                                  eeprom->len);
 627         if (ret < 0)
 628                 return ret;
 629
 630         return 0;
 631 }
 632
 633 static void
 634 qlcnic_get_ringparam(struct net_device *dev,
 635                 struct ethtool_ringparam *ring)
 636 {
 637         struct qlcnic_adapter *adapter = netdev_priv(dev);
 638
 639         ring->rx_pending = adapter->num_rxd;
 640         ring->rx_jumbo_pending = adapter->num_jumbo_rxd;
 641         ring->tx_pending = adapter->num_txd;
 642
 643         ring->rx_max_pending = adapter->max_rxd;
 644         ring->rx_jumbo_max_pending = adapter->max_jumbo_rxd;
 645         ring->tx_max_pending = MAX_CMD_DESCRIPTORS;
 646 }
 647
 648 static u32
 649 qlcnic_validate_ringparam(u32 val, u32 min, u32 max, char *r_name)
 650 {
 651         u32 num_desc;
 652         num_desc = max(val, min);
 653         num_desc = min(num_desc, max);
 654         num_desc = roundup_pow_of_two(num_desc);
 655
 656         if (val != num_desc) {
 657                 printk(KERN_INFO "%s: setting %s ring size %d instead of %d\n",
 658                        qlcnic_driver_name, r_name, num_desc, val);
 659         }
 660
 661         return num_desc;
 662 }
 663
 664 static int
 665 qlcnic_set_ringparam(struct net_device *dev,
 666                 struct ethtool_ringparam *ring)
 667 {
 668         struct qlcnic_adapter *adapter = netdev_priv(dev);
 669         u16 num_rxd, num_jumbo_rxd, num_txd;
 670
 671         if (ring->rx_mini_pending)
 672                 return -EOPNOTSUPP;
 673
 674         num_rxd = qlcnic_validate_ringparam(ring->rx_pending,
 675                         MIN_RCV_DESCRIPTORS, adapter->max_rxd, "rx");
 676
 677         num_jumbo_rxd = qlcnic_validate_ringparam(ring->rx_jumbo_pending,
 678                         MIN_JUMBO_DESCRIPTORS, adapter->max_jumbo_rxd,
 679                                                 "rx jumbo");
 680
 681         num_txd = qlcnic_validate_ringparam(ring->tx_pending,
 682                         MIN_CMD_DESCRIPTORS, MAX_CMD_DESCRIPTORS, "tx");
 683
 684         if (num_rxd == adapter->num_rxd && num_txd == adapter->num_txd &&
 685                         num_jumbo_rxd == adapter->num_jumbo_rxd)
 686                 return 0;
 687
 688         adapter->num_rxd = num_rxd;
 689         adapter->num_jumbo_rxd = num_jumbo_rxd;
 690         adapter->num_txd = num_txd;
 691
 692         return qlcnic_reset_context(adapter);
 693 }
 694
 695 static int qlcnic_validate_ring_count(struct qlcnic_adapter *adapter,
 696                                       u8 rx_ring, u8 tx_ring)
 697 {
 698         if (rx_ring == 0 || tx_ring == 0)
 699                 return -EINVAL;
 700
 701         if (rx_ring != 0) {
 702                 if (rx_ring > adapter->max_sds_rings) {
 703                         netdev_err(adapter->netdev,
 704                                    "Invalid ring count, SDS ring count %d should not be greater than max %d driver sds rings.\n",
 705                                    rx_ring, adapter->max_sds_rings);
 706                         return -EINVAL;
 707                 }
 708         }
 709
 710          if (tx_ring != 0) {
 711                 if (tx_ring > adapter->max_tx_rings) {
 712                         netdev_err(adapter->netdev,
 713                                    "Invalid ring count, Tx ring count %d should not be greater than max %d driver Tx rings.\n",
 714                                    tx_ring, adapter->max_tx_rings);
 715                         return -EINVAL;
 716                 }
 717         }
 718
 719         return 0;
 720 }
 721
 722 static void qlcnic_get_channels(struct net_device *dev,
 723                 struct ethtool_channels *channel)
 724 {
 725         struct qlcnic_adapter *adapter = netdev_priv(dev);
 726
 727         channel->max_rx = adapter->max_sds_rings;
 728         channel->max_tx = adapter->max_tx_rings;
 729         channel->rx_count = adapter->drv_sds_rings;
 730         channel->tx_count = adapter->drv_tx_rings;
 731 }
 732
 733 static int qlcnic_set_channels(struct net_device *dev,
 734                                struct ethtool_channels *channel)
 735 {
 736         struct qlcnic_adapter *adapter = netdev_priv(dev);
 737         int err;
 738
 739         if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
 740                 netdev_err(dev, "No RSS/TSS support in non MSI-X mode\n");
 741                 return -EINVAL;
 742         }
 743
 744         if (channel->other_count || channel->combined_count)
 745                 return -EINVAL;
 746
 747         err = qlcnic_validate_ring_count(adapter, channel->rx_count,
 748                                          channel->tx_count);
 749         if (err)
 750                 return err;
 751
 752         if (adapter->drv_sds_rings != channel->rx_count) {
 753                 err = qlcnic_validate_rings(adapter, channel->rx_count,
 754                                             QLCNIC_RX_QUEUE);
 755                 if (err) {
 756                         netdev_err(dev, "Unable to configure %u SDS rings\n",
 757                                    channel->rx_count);
 758                         return err;
 759                 }
 760                 adapter->drv_rss_rings = channel->rx_count;
 761         }
 762
 763         if (adapter->drv_tx_rings != channel->tx_count) {
 764                 err = qlcnic_validate_rings(adapter, channel->tx_count,
 765                                             QLCNIC_TX_QUEUE);
 766                 if (err) {
 767                         netdev_err(dev, "Unable to configure %u Tx rings\n",
 768                                    channel->tx_count);
 769                         return err;
 770                 }
 771                 adapter->drv_tss_rings = channel->tx_count;
 772         }
 773
 774         adapter->flags |= QLCNIC_TSS_RSS;
 775
 776         err = qlcnic_setup_rings(adapter);
 777         netdev_info(dev, "Allocated %d SDS rings and %d Tx rings\n",
 778                     adapter->drv_sds_rings, adapter->drv_tx_rings);
 779
 780         return err;
 781 }
 782
 783 static void
 784 qlcnic_get_pauseparam(struct net_device *netdev,
 785                           struct ethtool_pauseparam *pause)
 786 {
 787         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 788         int port = adapter->ahw->physical_port;
 789         int err = 0;
 790         __u32 val;
 791
 792         if (qlcnic_83xx_check(adapter)) {
 793                 qlcnic_83xx_get_pauseparam(adapter, pause);
 794                 return;
 795         }
 796         if (adapter->ahw->port_type == QLCNIC_GBE) {
 797                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
 798                         return;
 799                 /* get flow control settings */
 800                 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err);
 801                 if (err == -EIO)
 802                         return;
 803                 pause->rx_pause = qlcnic_gb_get_rx_flowctl(val);
 804                 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err);
 805                 if (err == -EIO)
 806                         return;
 807                 switch (port) {
 808                 case 0:
 809                         pause->tx_pause = !(qlcnic_gb_get_gb0_mask(val));
 810                         break;
 811                 case 1:
 812                         pause->tx_pause = !(qlcnic_gb_get_gb1_mask(val));
 813                         break;
 814                 case 2:
 815                         pause->tx_pause = !(qlcnic_gb_get_gb2_mask(val));
 816                         break;
 817                 case 3:
 818                 default:
 819                         pause->tx_pause = !(qlcnic_gb_get_gb3_mask(val));
 820                         break;
 821                 }
 822         } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
 823                 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
 824                         return;
 825                 pause->rx_pause = 1;
 826                 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err);
 827                 if (err == -EIO)
 828                         return;
 829                 if (port == 0)
 830                         pause->tx_pause = !(qlcnic_xg_get_xg0_mask(val));
 831                 else
 832                         pause->tx_pause = !(qlcnic_xg_get_xg1_mask(val));
 833         } else {
 834                 dev_err(&netdev->dev, "Unknown board type: %x\n",
 835                                         adapter->ahw->port_type);
 836         }
 837 }
 838
 839 static int
 840 qlcnic_set_pauseparam(struct net_device *netdev,
 841                           struct ethtool_pauseparam *pause)
 842 {
 843         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 844         int port = adapter->ahw->physical_port;
 845         int err = 0;
 846         __u32 val;
 847
 848         if (qlcnic_83xx_check(adapter))
 849                 return qlcnic_83xx_set_pauseparam(adapter, pause);
 850
 851         /* read mode */
 852         if (adapter->ahw->port_type == QLCNIC_GBE) {
 853                 if ((port < 0) || (port > QLCNIC_NIU_MAX_GBE_PORTS))
 854                         return -EIO;
 855                 /* set flow control */
 856                 val = QLCRD32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), &err);
 857                 if (err == -EIO)
 858                         return err;
 859
 860                 if (pause->rx_pause)
 861                         qlcnic_gb_rx_flowctl(val);
 862                 else
 863                         qlcnic_gb_unset_rx_flowctl(val);
 864
 865                 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port),
 866                                 val);
 867                 QLCWR32(adapter, QLCNIC_NIU_GB_MAC_CONFIG_0(port), val);
 868                 /* set autoneg */
 869                 val = QLCRD32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, &err);
 870                 if (err == -EIO)
 871                         return err;
 872                 switch (port) {
 873                 case 0:
 874                         if (pause->tx_pause)
 875                                 qlcnic_gb_unset_gb0_mask(val);
 876                         else
 877                                 qlcnic_gb_set_gb0_mask(val);
 878                         break;
 879                 case 1:
 880                         if (pause->tx_pause)
 881                                 qlcnic_gb_unset_gb1_mask(val);
 882                         else
 883                                 qlcnic_gb_set_gb1_mask(val);
 884                         break;
 885                 case 2:
 886                         if (pause->tx_pause)
 887                                 qlcnic_gb_unset_gb2_mask(val);
 888                         else
 889                                 qlcnic_gb_set_gb2_mask(val);
 890                         break;
 891                 case 3:
 892                 default:
 893                         if (pause->tx_pause)
 894                                 qlcnic_gb_unset_gb3_mask(val);
 895                         else
 896                                 qlcnic_gb_set_gb3_mask(val);
 897                         break;
 898                 }
 899                 QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, val);
 900         } else if (adapter->ahw->port_type == QLCNIC_XGBE) {
 901                 if (!pause->rx_pause || pause->autoneg)
 902                         return -EOPNOTSUPP;
 903
 904                 if ((port < 0) || (port > QLCNIC_NIU_MAX_XG_PORTS))
 905                         return -EIO;
 906
 907                 val = QLCRD32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, &err);
 908                 if (err == -EIO)
 909                         return err;
 910                 if (port == 0) {
 911                         if (pause->tx_pause)
 912                                 qlcnic_xg_unset_xg0_mask(val);
 913                         else
 914                                 qlcnic_xg_set_xg0_mask(val);
 915                 } else {
 916                         if (pause->tx_pause)
 917                                 qlcnic_xg_unset_xg1_mask(val);
 918                         else
 919                                 qlcnic_xg_set_xg1_mask(val);
 920                 }
 921                 QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, val);
 922         } else {
 923                 dev_err(&netdev->dev, "Unknown board type: %x\n",
 924                                 adapter->ahw->port_type);
 925         }
 926         return 0;
 927 }
 928
 929 static int qlcnic_reg_test(struct net_device *dev)
 930 {
 931         struct qlcnic_adapter *adapter = netdev_priv(dev);
 932         u32 data_read;
 933         int err = 0;
 934
 935         if (qlcnic_83xx_check(adapter))
 936                 return qlcnic_83xx_reg_test(adapter);
 937
 938         data_read = QLCRD32(adapter, QLCNIC_PCIX_PH_REG(0), &err);
 939         if (err == -EIO)
 940                 return err;
 941         if ((data_read & 0xffff) != adapter->pdev->vendor)
 942                 return 1;
 943
 944         return 0;
 945 }
 946
 947 static int qlcnic_eeprom_test(struct net_device *dev)
 948 {
 949         struct qlcnic_adapter *adapter = netdev_priv(dev);
 950
 951         if (qlcnic_82xx_check(adapter))
 952                 return 0;
 953
 954         return qlcnic_83xx_flash_test(adapter);
 955 }
 956
 957 static int qlcnic_get_sset_count(struct net_device *dev, int sset)
 958 {
 959
 960         struct qlcnic_adapter *adapter = netdev_priv(dev);
 961         switch (sset) {
 962         case ETH_SS_TEST:
 963                 return QLCNIC_TEST_LEN;
 964         case ETH_SS_STATS:
 965                 return qlcnic_dev_statistics_len(adapter);
 966         default:
 967                 return -EOPNOTSUPP;
 968         }
 969 }
 970
 971 static int qlcnic_irq_test(struct net_device *netdev)
 972 {
 973         struct qlcnic_adapter *adapter = netdev_priv(netdev);
 974         struct qlcnic_hardware_context *ahw = adapter->ahw;
 975         struct qlcnic_cmd_args cmd;
 976         int ret, drv_sds_rings = adapter->drv_sds_rings;
 977         int drv_tx_rings = adapter->drv_tx_rings;
 978
 979         if (qlcnic_83xx_check(adapter))
 980                 return qlcnic_83xx_interrupt_test(netdev);
 981
 982         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
 983                 return -EIO;
 984
 985         ret = qlcnic_diag_alloc_res(netdev, QLCNIC_INTERRUPT_TEST);
 986         if (ret)
 987                 goto clear_diag_irq;
 988
 989         ahw->diag_cnt = 0;
 990         ret = qlcnic_alloc_mbx_args(&cmd, adapter, QLCNIC_CMD_INTRPT_TEST);
 991         if (ret)
 992                 goto free_diag_res;
 993
 994         cmd.req.arg[1] = ahw->pci_func;
 995         ret = qlcnic_issue_cmd(adapter, &cmd);
 996         if (ret)
 997                 goto done;
 998
 999         usleep_range(1000, 12000);
1000         ret = !ahw->diag_cnt;
1001
1002 done:
1003         qlcnic_free_mbx_args(&cmd);
1004
1005 free_diag_res:
1006         qlcnic_diag_free_res(netdev, drv_sds_rings);
1007
1008 clear_diag_irq:
1009         adapter->drv_sds_rings = drv_sds_rings;
1010         adapter->drv_tx_rings = drv_tx_rings;
1011         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1012
1013         return ret;
1014 }
1015
1016 #define QLCNIC_ILB_PKT_SIZE             64
1017 #define QLCNIC_NUM_ILB_PKT              16
1018 #define QLCNIC_ILB_MAX_RCV_LOOP         10
1019 #define QLCNIC_LB_PKT_POLL_DELAY_MSEC   1
1020 #define QLCNIC_LB_PKT_POLL_COUNT        20
1021
1022 static void qlcnic_create_loopback_buff(unsigned char *data, u8 mac[])
1023 {
1024         unsigned char random_data[] = {0xa8, 0x06, 0x45, 0x00};
1025
1026         memset(data, 0x4e, QLCNIC_ILB_PKT_SIZE);
1027
1028         memcpy(data, mac, ETH_ALEN);
1029         memcpy(data + ETH_ALEN, mac, ETH_ALEN);
1030
1031         memcpy(data + 2 * ETH_ALEN, random_data, sizeof(random_data));
1032 }
1033
1034 int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[])
1035 {
1036         unsigned char buff[QLCNIC_ILB_PKT_SIZE];
1037         qlcnic_create_loopback_buff(buff, mac);
1038         return memcmp(data, buff, QLCNIC_ILB_PKT_SIZE);
1039 }
1040
1041 int qlcnic_do_lb_test(struct qlcnic_adapter *adapter, u8 mode)
1042 {
1043         struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1044         struct qlcnic_host_sds_ring *sds_ring = &recv_ctx->sds_rings[0];
1045         struct sk_buff *skb;
1046         int i, loop, cnt = 0;
1047
1048         for (i = 0; i < QLCNIC_NUM_ILB_PKT; i++) {
1049                 skb = netdev_alloc_skb(adapter->netdev, QLCNIC_ILB_PKT_SIZE);
1050                 if (!skb)
1051                         break;
1052                 qlcnic_create_loopback_buff(skb->data, adapter->mac_addr);
1053                 skb_put(skb, QLCNIC_ILB_PKT_SIZE);
1054                 adapter->ahw->diag_cnt = 0;
1055                 qlcnic_xmit_frame(skb, adapter->netdev);
1056                 loop = 0;
1057
1058                 do {
1059                         msleep(QLCNIC_LB_PKT_POLL_DELAY_MSEC);
1060                         qlcnic_process_rcv_ring_diag(sds_ring);
1061                         if (loop++ > QLCNIC_LB_PKT_POLL_COUNT)
1062                                 break;
1063                 } while (!adapter->ahw->diag_cnt);
1064
1065                 dev_kfree_skb_any(skb);
1066
1067                 if (!adapter->ahw->diag_cnt)
1068                         dev_warn(&adapter->pdev->dev,
1069                                  "LB Test: packet #%d was not received\n",
1070                                  i + 1);
1071                 else
1072                         cnt++;
1073         }
1074         if (cnt != i) {
1075                 dev_err(&adapter->pdev->dev,
1076                         "LB Test: failed, TX[%d], RX[%d]\n", i, cnt);
1077                 if (mode != QLCNIC_ILB_MODE)
1078                         dev_warn(&adapter->pdev->dev,
1079                                  "WARNING: Please check loopback cable\n");
1080                 return -1;
1081         }
1082         return 0;
1083 }
1084
1085 static int qlcnic_loopback_test(struct net_device *netdev, u8 mode)
1086 {
1087         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1088         int drv_tx_rings = adapter->drv_tx_rings;
1089         int drv_sds_rings = adapter->drv_sds_rings;
1090         struct qlcnic_host_sds_ring *sds_ring;
1091         struct qlcnic_hardware_context *ahw = adapter->ahw;
1092         int loop = 0;
1093         int ret;
1094
1095         if (qlcnic_83xx_check(adapter))
1096                 return qlcnic_83xx_loopback_test(netdev, mode);
1097
1098         if (!(ahw->capabilities & QLCNIC_FW_CAPABILITY_MULTI_LOOPBACK)) {
1099                 dev_info(&adapter->pdev->dev,
1100                          "Firmware do not support loopback test\n");
1101                 return -EOPNOTSUPP;
1102         }
1103
1104         dev_warn(&adapter->pdev->dev, "%s loopback test in progress\n",
1105                  mode == QLCNIC_ILB_MODE ? "internal" : "external");
1106         if (ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
1107                 dev_warn(&adapter->pdev->dev,
1108                          "Loopback test not supported in nonprivileged mode\n");
1109                 return 0;
1110         }
1111
1112         if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
1113                 return -EBUSY;
1114
1115         ret = qlcnic_diag_alloc_res(netdev, QLCNIC_LOOPBACK_TEST);
1116         if (ret)
1117                 goto clear_it;
1118
1119         sds_ring = &adapter->recv_ctx->sds_rings[0];
1120         ret = qlcnic_set_lb_mode(adapter, mode);
1121         if (ret)
1122                 goto free_res;
1123
1124         ahw->diag_cnt = 0;
1125         do {
1126                 msleep(500);
1127                 qlcnic_process_rcv_ring_diag(sds_ring);
1128                 if (loop++ > QLCNIC_ILB_MAX_RCV_LOOP) {
1129                         netdev_info(netdev,
1130                                     "Firmware didn't sent link up event to loopback request\n");
1131                         ret = -ETIMEDOUT;
1132                         goto free_res;
1133                 } else if (adapter->ahw->diag_cnt) {
1134                         ret = adapter->ahw->diag_cnt;
1135                         goto free_res;
1136                 }
1137         } while (!QLCNIC_IS_LB_CONFIGURED(ahw->loopback_state));
1138
1139         ret = qlcnic_do_lb_test(adapter, mode);
1140
1141         qlcnic_clear_lb_mode(adapter, mode);
1142
1143  free_res:
1144         qlcnic_diag_free_res(netdev, drv_sds_rings);
1145
1146  clear_it:
1147         adapter->drv_sds_rings = drv_sds_rings;
1148         adapter->drv_tx_rings = drv_tx_rings;
1149         clear_bit(__QLCNIC_RESETTING, &adapter->state);
1150         return ret;
1151 }
1152
1153 static void
1154 qlcnic_diag_test(struct net_device *dev, struct ethtool_test *eth_test,
1155                      u64 *data)
1156 {
1157         memset(data, 0, sizeof(u64) * QLCNIC_TEST_LEN);
1158
1159         data[0] = qlcnic_reg_test(dev);
1160         if (data[0])
1161                 eth_test->flags |= ETH_TEST_FL_FAILED;
1162
1163         data[1] = (u64) qlcnic_test_link(dev);
1164         if (data[1])
1165                 eth_test->flags |= ETH_TEST_FL_FAILED;
1166
1167         if (eth_test->flags & ETH_TEST_FL_OFFLINE) {
1168                 data[2] = qlcnic_irq_test(dev);
1169                 if (data[2])
1170                         eth_test->flags |= ETH_TEST_FL_FAILED;
1171
1172                 data[3] = qlcnic_loopback_test(dev, QLCNIC_ILB_MODE);
1173                 if (data[3])
1174                         eth_test->flags |= ETH_TEST_FL_FAILED;
1175
1176                 if (eth_test->flags & ETH_TEST_FL_EXTERNAL_LB) {
1177                         data[4] = qlcnic_loopback_test(dev, QLCNIC_ELB_MODE);
1178                         if (data[4])
1179                                 eth_test->flags |= ETH_TEST_FL_FAILED;
1180                         eth_test->flags |= ETH_TEST_FL_EXTERNAL_LB_DONE;
1181                 }
1182
1183                 data[5] = qlcnic_eeprom_test(dev);
1184                 if (data[5])
1185                         eth_test->flags |= ETH_TEST_FL_FAILED;
1186         }
1187 }
1188
1189 static void
1190 qlcnic_get_strings(struct net_device *dev, u32 stringset, u8 *data)
1191 {
1192         struct qlcnic_adapter *adapter = netdev_priv(dev);
1193         int index, i, num_stats;
1194
1195         switch (stringset) {
1196         case ETH_SS_TEST:
1197                 memcpy(data, *qlcnic_gstrings_test,
1198                        QLCNIC_TEST_LEN * ETH_GSTRING_LEN);
1199                 break;
1200         case ETH_SS_STATS:
1201                 num_stats = ARRAY_SIZE(qlcnic_tx_queue_stats_strings);
1202                 for (i = 0; i < adapter->drv_tx_rings; i++) {
1203                         for (index = 0; index < num_stats; index++) {
1204                                 sprintf(data, "tx_queue_%d %s", i,
1205                                         qlcnic_tx_queue_stats_strings[index]);
1206                                 data += ETH_GSTRING_LEN;
1207                         }
1208                 }
1209
1210                 for (index = 0; index < QLCNIC_STATS_LEN; index++) {
1211                         memcpy(data + index * ETH_GSTRING_LEN,
1212                                qlcnic_gstrings_stats[index].stat_string,
1213                                ETH_GSTRING_LEN);
1214                 }
1215
1216                 if (qlcnic_83xx_check(adapter)) {
1217                         num_stats = ARRAY_SIZE(qlcnic_83xx_tx_stats_strings);
1218                         for (i = 0; i < num_stats; i++, index++)
1219                                 memcpy(data + index * ETH_GSTRING_LEN,
1220                                        qlcnic_83xx_tx_stats_strings[i],
1221                                        ETH_GSTRING_LEN);
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                         num_stats = ARRAY_SIZE(qlcnic_83xx_rx_stats_strings);
1228                         for (i = 0; i < num_stats; i++, index++)
1229                                 memcpy(data + index * ETH_GSTRING_LEN,
1230                                        qlcnic_83xx_rx_stats_strings[i],
1231                                        ETH_GSTRING_LEN);
1232                         return;
1233                 } else {
1234                         num_stats = ARRAY_SIZE(qlcnic_83xx_mac_stats_strings);
1235                         for (i = 0; i < num_stats; i++, index++)
1236                                 memcpy(data + index * ETH_GSTRING_LEN,
1237                                        qlcnic_83xx_mac_stats_strings[i],
1238                                        ETH_GSTRING_LEN);
1239                 }
1240                 if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1241                         return;
1242                 num_stats = ARRAY_SIZE(qlcnic_device_gstrings_stats);
1243                 for (i = 0; i < num_stats; index++, i++) {
1244                         memcpy(data + index * ETH_GSTRING_LEN,
1245                                qlcnic_device_gstrings_stats[i],
1246                                ETH_GSTRING_LEN);
1247                 }
1248         }
1249 }
1250
1251 static u64 *qlcnic_fill_stats(u64 *data, void *stats, int type)
1252 {
1253         if (type == QLCNIC_MAC_STATS) {
1254                 struct qlcnic_mac_statistics *mac_stats =
1255                                         (struct qlcnic_mac_statistics *)stats;
1256                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_frames);
1257                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bytes);
1258                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_mcast_pkts);
1259                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_bcast_pkts);
1260                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_pause_cnt);
1261                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_ctrl_pkt);
1262                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_64b_pkts);
1263                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_127b_pkts);
1264                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_255b_pkts);
1265                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_511b_pkts);
1266                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1023b_pkts);
1267                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_lt_1518b_pkts);
1268                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_tx_gt_1518b_pkts);
1269                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_frames);
1270                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bytes);
1271                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_mcast_pkts);
1272                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_bcast_pkts);
1273                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_pause_cnt);
1274                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_ctrl_pkt);
1275                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_64b_pkts);
1276                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_127b_pkts);
1277                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_255b_pkts);
1278                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_511b_pkts);
1279                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1023b_pkts);
1280                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_lt_1518b_pkts);
1281                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_gt_1518b_pkts);
1282                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_error);
1283                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_small);
1284                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_length_large);
1285                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_jabber);
1286                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_dropped);
1287                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_rx_crc_error);
1288                 *data++ = QLCNIC_FILL_STATS(mac_stats->mac_align_error);
1289         } else if (type == QLCNIC_ESW_STATS) {
1290                 struct __qlcnic_esw_statistics *esw_stats =
1291                                 (struct __qlcnic_esw_statistics *)stats;
1292                 *data++ = QLCNIC_FILL_STATS(esw_stats->unicast_frames);
1293                 *data++ = QLCNIC_FILL_STATS(esw_stats->multicast_frames);
1294                 *data++ = QLCNIC_FILL_STATS(esw_stats->broadcast_frames);
1295                 *data++ = QLCNIC_FILL_STATS(esw_stats->dropped_frames);
1296                 *data++ = QLCNIC_FILL_STATS(esw_stats->errors);
1297                 *data++ = QLCNIC_FILL_STATS(esw_stats->local_frames);
1298                 *data++ = QLCNIC_FILL_STATS(esw_stats->numbytes);
1299         }
1300         return data;
1301 }
1302
1303 void qlcnic_update_stats(struct qlcnic_adapter *adapter)
1304 {
1305         struct qlcnic_tx_queue_stats tx_stats;
1306         struct qlcnic_host_tx_ring *tx_ring;
1307         int ring;
1308
1309         memset(&tx_stats, 0, sizeof(tx_stats));
1310         for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
1311                 tx_ring = &adapter->tx_ring[ring];
1312                 tx_stats.xmit_on += tx_ring->tx_stats.xmit_on;
1313                 tx_stats.xmit_off += tx_ring->tx_stats.xmit_off;
1314                 tx_stats.xmit_called += tx_ring->tx_stats.xmit_called;
1315                 tx_stats.xmit_finished += tx_ring->tx_stats.xmit_finished;
1316                 tx_stats.tx_bytes += tx_ring->tx_stats.tx_bytes;
1317         }
1318
1319         adapter->stats.xmit_on = tx_stats.xmit_on;
1320         adapter->stats.xmit_off = tx_stats.xmit_off;
1321         adapter->stats.xmitcalled = tx_stats.xmit_called;
1322         adapter->stats.xmitfinished = tx_stats.xmit_finished;
1323         adapter->stats.txbytes = tx_stats.tx_bytes;
1324 }
1325
1326 static u64 *qlcnic_fill_tx_queue_stats(u64 *data, void *stats)
1327 {
1328         struct qlcnic_host_tx_ring *tx_ring;
1329
1330         tx_ring = (struct qlcnic_host_tx_ring *)stats;
1331
1332         *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_on);
1333         *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_off);
1334         *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_called);
1335         *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.xmit_finished);
1336         *data++ = QLCNIC_FILL_STATS(tx_ring->tx_stats.tx_bytes);
1337
1338         return data;
1339 }
1340
1341 static void qlcnic_get_ethtool_stats(struct net_device *dev,
1342                                      struct ethtool_stats *stats, u64 *data)
1343 {
1344         struct qlcnic_adapter *adapter = netdev_priv(dev);
1345         struct qlcnic_host_tx_ring *tx_ring;
1346         struct qlcnic_esw_statistics port_stats;
1347         struct qlcnic_mac_statistics mac_stats;
1348         int index, ret, length, size, ring;
1349         char *p;
1350
1351         memset(data, 0, stats->n_stats * sizeof(u64));
1352
1353         for (ring = 0, index = 0; ring < adapter->drv_tx_rings; ring++) {
1354                 if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
1355                         tx_ring = &adapter->tx_ring[ring];
1356                         data = qlcnic_fill_tx_queue_stats(data, tx_ring);
1357                         qlcnic_update_stats(adapter);
1358                 } else {
1359                         data += QLCNIC_TX_STATS_LEN;
1360                 }
1361         }
1362
1363         length = QLCNIC_STATS_LEN;
1364         for (index = 0; index < length; index++) {
1365                 p = (char *)adapter + qlcnic_gstrings_stats[index].stat_offset;
1366                 size = qlcnic_gstrings_stats[index].sizeof_stat;
1367                 *data++ = (size == sizeof(u64)) ? (*(u64 *)p) : ((*(u32 *)p));
1368         }
1369
1370         if (qlcnic_83xx_check(adapter)) {
1371                 if (adapter->ahw->linkup)
1372                         qlcnic_83xx_get_stats(adapter, data);
1373                 return;
1374         } else {
1375                 /* Retrieve MAC statistics from firmware */
1376                 memset(&mac_stats, 0, sizeof(struct qlcnic_mac_statistics));
1377                 qlcnic_get_mac_stats(adapter, &mac_stats);
1378                 data = qlcnic_fill_stats(data, &mac_stats, QLCNIC_MAC_STATS);
1379         }
1380
1381         if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1382                 return;
1383
1384         memset(&port_stats, 0, sizeof(struct qlcnic_esw_statistics));
1385         ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1386                         QLCNIC_QUERY_RX_COUNTER, &port_stats.rx);
1387         if (ret)
1388                 return;
1389
1390         data = qlcnic_fill_stats(data, &port_stats.rx, QLCNIC_ESW_STATS);
1391         ret = qlcnic_get_port_stats(adapter, adapter->ahw->pci_func,
1392                         QLCNIC_QUERY_TX_COUNTER, &port_stats.tx);
1393         if (ret)
1394                 return;
1395
1396         qlcnic_fill_stats(data, &port_stats.tx, QLCNIC_ESW_STATS);
1397 }
1398
1399 static int qlcnic_set_led(struct net_device *dev,
1400                           enum ethtool_phys_id_state state)
1401 {
1402         struct qlcnic_adapter *adapter = netdev_priv(dev);
1403         int drv_sds_rings = adapter->drv_sds_rings;
1404         int err = -EIO, active = 1;
1405
1406         if (qlcnic_83xx_check(adapter))
1407                 return qlcnic_83xx_set_led(dev, state);
1408
1409         if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
1410                 netdev_warn(dev, "LED test not supported for non "
1411                                 "privilege function\n");
1412                 return -EOPNOTSUPP;
1413         }
1414
1415         switch (state) {
1416         case ETHTOOL_ID_ACTIVE:
1417                 if (test_and_set_bit(__QLCNIC_LED_ENABLE, &adapter->state))
1418                         return -EBUSY;
1419
1420                 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1421                         break;
1422
1423                 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1424                         if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1425                                 break;
1426                         set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1427                 }
1428
1429                 if (adapter->nic_ops->config_led(adapter, 1, 0xf) == 0) {
1430                         err = 0;
1431                         break;
1432                 }
1433
1434                 dev_err(&adapter->pdev->dev,
1435                         "Failed to set LED blink state.\n");
1436                 break;
1437
1438         case ETHTOOL_ID_INACTIVE:
1439                 active = 0;
1440
1441                 if (test_bit(__QLCNIC_RESETTING, &adapter->state))
1442                         break;
1443
1444                 if (!test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
1445                         if (qlcnic_diag_alloc_res(dev, QLCNIC_LED_TEST))
1446                                 break;
1447                         set_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state);
1448                 }
1449
1450                 if (adapter->nic_ops->config_led(adapter, 0, 0xf))
1451                         dev_err(&adapter->pdev->dev,
1452                                 "Failed to reset LED blink state.\n");
1453
1454                 break;
1455
1456         default:
1457                 return -EINVAL;
1458         }
1459
1460         if (test_and_clear_bit(__QLCNIC_DIAG_RES_ALLOC, &adapter->state))
1461                 qlcnic_diag_free_res(dev, drv_sds_rings);
1462
1463         if (!active || err)
1464                 clear_bit(__QLCNIC_LED_ENABLE, &adapter->state);
1465
1466         return err;
1467 }
1468
1469 static void
1470 qlcnic_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1471 {
1472         struct qlcnic_adapter *adapter = netdev_priv(dev);
1473         u32 wol_cfg;
1474         int err = 0;
1475
1476         if (qlcnic_83xx_check(adapter))
1477                 return;
1478         wol->supported = 0;
1479         wol->wolopts = 0;
1480
1481         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err);
1482         if (err == -EIO)
1483                 return;
1484         if (wol_cfg & (1UL << adapter->portnum))
1485                 wol->supported |= WAKE_MAGIC;
1486
1487         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err);
1488         if (wol_cfg & (1UL << adapter->portnum))
1489                 wol->wolopts |= WAKE_MAGIC;
1490 }
1491
1492 static int
1493 qlcnic_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1494 {
1495         struct qlcnic_adapter *adapter = netdev_priv(dev);
1496         u32 wol_cfg;
1497         int err = 0;
1498
1499         if (qlcnic_83xx_check(adapter))
1500                 return -EOPNOTSUPP;
1501         if (wol->wolopts & ~WAKE_MAGIC)
1502                 return -EINVAL;
1503
1504         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG_NV, &err);
1505         if (err == -EIO)
1506                 return err;
1507         if (!(wol_cfg & (1 << adapter->portnum)))
1508                 return -EOPNOTSUPP;
1509
1510         wol_cfg = QLCRD32(adapter, QLCNIC_WOL_CONFIG, &err);
1511         if (err == -EIO)
1512                 return err;
1513         if (wol->wolopts & WAKE_MAGIC)
1514                 wol_cfg |= 1UL << adapter->portnum;
1515         else
1516                 wol_cfg &= ~(1UL << adapter->portnum);
1517
1518         QLCWR32(adapter, QLCNIC_WOL_CONFIG, wol_cfg);
1519
1520         return 0;
1521 }
1522
1523 /*
1524  * Set the coalescing parameters. Currently only normal is supported.
1525  * If rx_coalesce_usecs == 0 or rx_max_coalesced_frames == 0 then set the
1526  * firmware coalescing to default.
1527  */
1528 static int qlcnic_set_intr_coalesce(struct net_device *netdev,
1529                         struct ethtool_coalesce *ethcoal)
1530 {
1531         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1532         int err;
1533
1534         if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
1535                 return -EINVAL;
1536
1537         /*
1538         * Return Error if unsupported values or
1539         * unsupported parameters are set.
1540         */
1541         if (ethcoal->rx_coalesce_usecs > 0xffff ||
1542             ethcoal->rx_max_coalesced_frames > 0xffff ||
1543             ethcoal->tx_coalesce_usecs > 0xffff ||
1544             ethcoal->tx_max_coalesced_frames > 0xffff ||
1545             ethcoal->rx_coalesce_usecs_irq ||
1546             ethcoal->rx_max_coalesced_frames_irq ||
1547             ethcoal->tx_coalesce_usecs_irq ||
1548             ethcoal->tx_max_coalesced_frames_irq ||
1549             ethcoal->stats_block_coalesce_usecs ||
1550             ethcoal->use_adaptive_rx_coalesce ||
1551             ethcoal->use_adaptive_tx_coalesce ||
1552             ethcoal->pkt_rate_low ||
1553             ethcoal->rx_coalesce_usecs_low ||
1554             ethcoal->rx_max_coalesced_frames_low ||
1555             ethcoal->tx_coalesce_usecs_low ||
1556             ethcoal->tx_max_coalesced_frames_low ||
1557             ethcoal->pkt_rate_high ||
1558             ethcoal->rx_coalesce_usecs_high ||
1559             ethcoal->rx_max_coalesced_frames_high ||
1560             ethcoal->tx_coalesce_usecs_high ||
1561             ethcoal->tx_max_coalesced_frames_high)
1562                 return -EINVAL;
1563
1564         err = qlcnic_config_intr_coalesce(adapter, ethcoal);
1565
1566         return err;
1567 }
1568
1569 static int qlcnic_get_intr_coalesce(struct net_device *netdev,
1570                         struct ethtool_coalesce *ethcoal)
1571 {
1572         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1573
1574         if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1575                 return -EINVAL;
1576
1577         ethcoal->rx_coalesce_usecs = adapter->ahw->coal.rx_time_us;
1578         ethcoal->rx_max_coalesced_frames = adapter->ahw->coal.rx_packets;
1579         ethcoal->tx_coalesce_usecs = adapter->ahw->coal.tx_time_us;
1580         ethcoal->tx_max_coalesced_frames = adapter->ahw->coal.tx_packets;
1581
1582         return 0;
1583 }
1584
1585 static u32 qlcnic_get_msglevel(struct net_device *netdev)
1586 {
1587         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1588
1589         return adapter->ahw->msg_enable;
1590 }
1591
1592 static void qlcnic_set_msglevel(struct net_device *netdev, u32 msglvl)
1593 {
1594         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1595
1596         adapter->ahw->msg_enable = msglvl;
1597 }
1598
1599 int qlcnic_enable_fw_dump_state(struct qlcnic_adapter *adapter)
1600 {
1601         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1602         u32 val;
1603
1604         if (qlcnic_84xx_check(adapter)) {
1605                 if (qlcnic_83xx_lock_driver(adapter))
1606                         return -EBUSY;
1607
1608                 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1609                 val &= ~QLC_83XX_IDC_DISABLE_FW_DUMP;
1610                 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1611
1612                 qlcnic_83xx_unlock_driver(adapter);
1613         } else {
1614                 fw_dump->enable = true;
1615         }
1616
1617         dev_info(&adapter->pdev->dev, "FW dump enabled\n");
1618
1619         return 0;
1620 }
1621
1622 static int qlcnic_disable_fw_dump_state(struct qlcnic_adapter *adapter)
1623 {
1624         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1625         u32 val;
1626
1627         if (qlcnic_84xx_check(adapter)) {
1628                 if (qlcnic_83xx_lock_driver(adapter))
1629                         return -EBUSY;
1630
1631                 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1632                 val |= QLC_83XX_IDC_DISABLE_FW_DUMP;
1633                 QLCWRX(adapter->ahw, QLC_83XX_IDC_CTRL, val);
1634
1635                 qlcnic_83xx_unlock_driver(adapter);
1636         } else {
1637                 fw_dump->enable = false;
1638         }
1639
1640         dev_info(&adapter->pdev->dev, "FW dump disabled\n");
1641
1642         return 0;
1643 }
1644
1645 bool qlcnic_check_fw_dump_state(struct qlcnic_adapter *adapter)
1646 {
1647         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1648         bool state;
1649         u32 val;
1650
1651         if (qlcnic_84xx_check(adapter)) {
1652                 val = QLCRDX(adapter->ahw, QLC_83XX_IDC_CTRL);
1653                 state = (val & QLC_83XX_IDC_DISABLE_FW_DUMP) ? false : true;
1654         } else {
1655                 state = fw_dump->enable;
1656         }
1657
1658         return state;
1659 }
1660
1661 static int
1662 qlcnic_get_dump_flag(struct net_device *netdev, struct ethtool_dump *dump)
1663 {
1664         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1665         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1666
1667         if (!fw_dump->tmpl_hdr) {
1668                 netdev_err(adapter->netdev, "FW Dump not supported\n");
1669                 return -ENOTSUPP;
1670         }
1671
1672         if (fw_dump->clr)
1673                 dump->len = fw_dump->tmpl_hdr_size + fw_dump->size;
1674         else
1675                 dump->len = 0;
1676
1677         if (!qlcnic_check_fw_dump_state(adapter))
1678                 dump->flag = ETH_FW_DUMP_DISABLE;
1679         else
1680                 dump->flag = fw_dump->cap_mask;
1681
1682         dump->version = adapter->fw_version;
1683         return 0;
1684 }
1685
1686 static int
1687 qlcnic_get_dump_data(struct net_device *netdev, struct ethtool_dump *dump,
1688                         void *buffer)
1689 {
1690         int i, copy_sz;
1691         u32 *hdr_ptr;
1692         __le32 *data;
1693         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1694         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1695
1696         if (!fw_dump->tmpl_hdr) {
1697                 netdev_err(netdev, "FW Dump not supported\n");
1698                 return -ENOTSUPP;
1699         }
1700
1701         if (!fw_dump->clr) {
1702                 netdev_info(netdev, "Dump not available\n");
1703                 return -EINVAL;
1704         }
1705
1706         /* Copy template header first */
1707         copy_sz = fw_dump->tmpl_hdr_size;
1708         hdr_ptr = (u32 *)fw_dump->tmpl_hdr;
1709         data = buffer;
1710         for (i = 0; i < copy_sz/sizeof(u32); i++)
1711                 *data++ = cpu_to_le32(*hdr_ptr++);
1712
1713         /* Copy captured dump data */
1714         memcpy(buffer + copy_sz, fw_dump->data, fw_dump->size);
1715         dump->len = copy_sz + fw_dump->size;
1716         dump->flag = fw_dump->cap_mask;
1717
1718         /* Free dump area once data has been captured */
1719         vfree(fw_dump->data);
1720         fw_dump->data = NULL;
1721         fw_dump->clr = 0;
1722         netdev_info(netdev, "extracted the FW dump Successfully\n");
1723         return 0;
1724 }
1725
1726 static int qlcnic_set_dump_mask(struct qlcnic_adapter *adapter, u32 mask)
1727 {
1728         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1729         struct net_device *netdev = adapter->netdev;
1730
1731         if (!qlcnic_check_fw_dump_state(adapter)) {
1732                 netdev_info(netdev,
1733                             "Can not change driver mask to 0x%x. FW dump not enabled\n",
1734                             mask);
1735                 return -EOPNOTSUPP;
1736         }
1737
1738         fw_dump->cap_mask = mask;
1739
1740         /* Store new capture mask in template header as well*/
1741         qlcnic_store_cap_mask(adapter, fw_dump->tmpl_hdr, mask);
1742
1743         netdev_info(netdev, "Driver mask changed to: 0x%x\n", mask);
1744         return 0;
1745 }
1746
1747 static int
1748 qlcnic_set_dump(struct net_device *netdev, struct ethtool_dump *val)
1749 {
1750         struct qlcnic_adapter *adapter = netdev_priv(netdev);
1751         struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
1752         bool valid_mask = false;
1753         int i, ret = 0;
1754
1755         switch (val->flag) {
1756         case QLCNIC_FORCE_FW_DUMP_KEY:
1757                 if (!fw_dump->tmpl_hdr) {
1758                         netdev_err(netdev, "FW dump not supported\n");
1759                         ret = -EOPNOTSUPP;
1760                         break;
1761                 }
1762
1763                 if (!qlcnic_check_fw_dump_state(adapter)) {
1764                         netdev_info(netdev, "FW dump not enabled\n");
1765                         ret = -EOPNOTSUPP;
1766                         break;
1767                 }
1768
1769                 if (fw_dump->clr) {
1770                         netdev_info(netdev,
1771                                     "Previous dump not cleared, not forcing dump\n");
1772                         break;
1773                 }
1774
1775                 netdev_info(netdev, "Forcing a FW dump\n");
1776                 qlcnic_dev_request_reset(adapter, val->flag);
1777                 break;
1778         case QLCNIC_DISABLE_FW_DUMP:
1779                 if (!fw_dump->tmpl_hdr) {
1780                         netdev_err(netdev, "FW dump not supported\n");
1781                         ret = -EOPNOTSUPP;
1782                         break;
1783                 }
1784
1785                 ret = qlcnic_disable_fw_dump_state(adapter);
1786                 break;
1787
1788         case QLCNIC_ENABLE_FW_DUMP:
1789                 if (!fw_dump->tmpl_hdr) {
1790                         netdev_err(netdev, "FW dump not supported\n");
1791                         ret = -EOPNOTSUPP;
1792                         break;
1793                 }
1794
1795                 ret = qlcnic_enable_fw_dump_state(adapter);
1796                 break;
1797
1798         case QLCNIC_FORCE_FW_RESET:
1799                 netdev_info(netdev, "Forcing a FW reset\n");
1800                 qlcnic_dev_request_reset(adapter, val->flag);
1801                 adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
1802                 break;
1803
1804         case QLCNIC_SET_QUIESCENT:
1805         case QLCNIC_RESET_QUIESCENT:
1806                 if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state))
1807                         netdev_info(netdev, "Device is in non-operational state\n");
1808                 break;
1809
1810         default:
1811                 if (!fw_dump->tmpl_hdr) {
1812                         netdev_err(netdev, "FW dump not supported\n");
1813                         ret = -EOPNOTSUPP;
1814                         break;
1815                 }
1816
1817                 for (i = 0; i < ARRAY_SIZE(qlcnic_fw_dump_level); i++) {
1818                         if (val->flag == qlcnic_fw_dump_level[i]) {
1819                                 valid_mask = true;
1820                                 break;
1821                         }
1822                 }
1823
1824                 if (valid_mask) {
1825                         ret = qlcnic_set_dump_mask(adapter, val->flag);
1826                 } else {
1827                         netdev_info(netdev, "Invalid dump level: 0x%x\n",
1828                                     val->flag);
1829                         ret = -EINVAL;
1830                 }
1831         }
1832         return ret;
1833 }
1834
1835 const struct ethtool_ops qlcnic_ethtool_ops = {
1836         .get_drvinfo = qlcnic_get_drvinfo,
1837         .get_regs_len = qlcnic_get_regs_len,
1838         .get_regs = qlcnic_get_regs,
1839         .get_link = ethtool_op_get_link,
1840         .get_eeprom_len = qlcnic_get_eeprom_len,
1841         .get_eeprom = qlcnic_get_eeprom,
1842         .get_ringparam = qlcnic_get_ringparam,
1843         .set_ringparam = qlcnic_set_ringparam,
1844         .get_channels = qlcnic_get_channels,
1845         .set_channels = qlcnic_set_channels,
1846         .get_pauseparam = qlcnic_get_pauseparam,
1847         .set_pauseparam = qlcnic_set_pauseparam,
1848         .get_wol = qlcnic_get_wol,
1849         .set_wol = qlcnic_set_wol,
1850         .self_test = qlcnic_diag_test,
1851         .get_strings = qlcnic_get_strings,
1852         .get_ethtool_stats = qlcnic_get_ethtool_stats,
1853         .get_sset_count = qlcnic_get_sset_count,
1854         .get_coalesce = qlcnic_get_intr_coalesce,
1855         .set_coalesce = qlcnic_set_intr_coalesce,
1856         .set_phys_id = qlcnic_set_led,
1857         .set_msglevel = qlcnic_set_msglevel,
1858         .get_msglevel = qlcnic_get_msglevel,
1859         .get_dump_flag = qlcnic_get_dump_flag,
1860         .get_dump_data = qlcnic_get_dump_data,
1861         .set_dump = qlcnic_set_dump,
1862         .get_link_ksettings = qlcnic_get_link_ksettings,
1863         .set_link_ksettings = qlcnic_set_link_ksettings,
1864 };
1865
1866 const struct ethtool_ops qlcnic_sriov_vf_ethtool_ops = {
1867         .get_drvinfo            = qlcnic_get_drvinfo,
1868         .get_regs_len           = qlcnic_get_regs_len,
1869         .get_regs               = qlcnic_get_regs,
1870         .get_link               = ethtool_op_get_link,
1871         .get_eeprom_len         = qlcnic_get_eeprom_len,
1872         .get_eeprom             = qlcnic_get_eeprom,
1873         .get_ringparam          = qlcnic_get_ringparam,
1874         .set_ringparam          = qlcnic_set_ringparam,
1875         .get_channels           = qlcnic_get_channels,
1876         .get_pauseparam         = qlcnic_get_pauseparam,
1877         .get_wol                = qlcnic_get_wol,
1878         .get_strings            = qlcnic_get_strings,
1879         .get_ethtool_stats      = qlcnic_get_ethtool_stats,
1880         .get_sset_count         = qlcnic_get_sset_count,
1881         .get_coalesce           = qlcnic_get_intr_coalesce,
1882         .set_coalesce           = qlcnic_set_intr_coalesce,
1883         .set_msglevel           = qlcnic_set_msglevel,
1884         .get_msglevel           = qlcnic_get_msglevel,
1885         .get_link_ksettings     = qlcnic_get_link_ksettings,
1886 };
1887
1888 const struct ethtool_ops qlcnic_ethtool_failed_ops = {
1889         .get_drvinfo            = qlcnic_get_drvinfo,
1890         .set_msglevel           = qlcnic_set_msglevel,
1891         .get_msglevel           = qlcnic_get_msglevel,
1892         .set_dump               = qlcnic_set_dump,
1893         .get_link_ksettings     = qlcnic_get_link_ksettings,
1894 };