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