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