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