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