qlcnic_main.c 91.4 KB
Newer Older
1
/*
S
Sritej Velaga 已提交
2
 * QLogic qlcnic NIC Driver
3
 * Copyright (c) 2009-2013 QLogic Corporation
4
 *
S
Sritej Velaga 已提交
5
 * See LICENSE.qlcnic for copyright and licensing details.
6 7 8 9 10 11
 */

#include <linux/vmalloc.h>
#include <linux/interrupt.h>

#include "qlcnic.h"
12
#include "qlcnic_sriov.h"
13
#include "qlcnic_hw.h"
14

15
#include <linux/swab.h>
16
#include <linux/dma-mapping.h>
S
Sony Chacko 已提交
17
#include <linux/if_vlan.h>
18 19 20
#include <net/ip.h>
#include <linux/ipv6.h>
#include <linux/inetdevice.h>
S
Sucheta Chakraborty 已提交
21
#include <linux/aer.h>
22
#include <linux/log2.h>
23
#include <linux/pci.h>
24

25
MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
26 27 28 29 30
MODULE_LICENSE("GPL");
MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);

char qlcnic_driver_name[] = "qlcnic";
31 32
static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
	"Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
33

34
static int qlcnic_mac_learn;
35
module_param(qlcnic_mac_learn, int, 0444);
36 37
MODULE_PARM_DESC(qlcnic_mac_learn,
		 "Mac Filter (0=learning is disabled, 1=Driver learning is enabled, 2=FDB learning is enabled)");
38

39
int qlcnic_use_msi = 1;
40
MODULE_PARM_DESC(use_msi, "MSI interrupt (0=disabled, 1=enabled)");
41
module_param_named(use_msi, qlcnic_use_msi, int, 0444);
42

43
int qlcnic_use_msi_x = 1;
44
MODULE_PARM_DESC(use_msi_x, "MSI-X interrupt (0=disabled, 1=enabled)");
45
module_param_named(use_msi_x, qlcnic_use_msi_x, int, 0444);
46

47
int qlcnic_auto_fw_reset = 1;
48
MODULE_PARM_DESC(auto_fw_reset, "Auto firmware reset (0=disabled, 1=enabled)");
49
module_param_named(auto_fw_reset, qlcnic_auto_fw_reset, int, 0644);
50

51
int qlcnic_load_fw_file;
52
MODULE_PARM_DESC(load_fw_file, "Load firmware from (0=flash, 1=file)");
53
module_param_named(load_fw_file, qlcnic_load_fw_file, int, 0444);
54

55
static int qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
B
Bill Pemberton 已提交
56
static void qlcnic_remove(struct pci_dev *pdev);
57 58 59 60 61 62 63 64 65 66
static int qlcnic_open(struct net_device *netdev);
static int qlcnic_close(struct net_device *netdev);
static void qlcnic_tx_timeout(struct net_device *netdev);
static void qlcnic_attach_work(struct work_struct *work);
static void qlcnic_fwinit_work(struct work_struct *work);
static void qlcnic_fw_poll_work(struct work_struct *work);
#ifdef CONFIG_NET_POLL_CONTROLLER
static void qlcnic_poll_controller(struct net_device *netdev);
#endif

67
static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
68
static void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8);
69 70
static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);

71
static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
72 73 74
static irqreturn_t qlcnic_intr(int irq, void *data);
static irqreturn_t qlcnic_msi_intr(int irq, void *data);
static irqreturn_t qlcnic_msix_intr(int irq, void *data);
S
Sony Chacko 已提交
75
static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
76 77

static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
78 79
static int qlcnic_start_firmware(struct qlcnic_adapter *);

80
static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
81 82
static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
83 84
static int qlcnic_vlan_rx_add(struct net_device *, __be16, u16);
static int qlcnic_vlan_rx_del(struct net_device *, __be16, u16);
85

S
Sony Chacko 已提交
86 87 88 89 90 91 92 93 94 95
static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
{
	struct qlcnic_hardware_context *ahw = adapter->ahw;

	if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
		return ahw->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX;
	else
		return 1;
}

96 97 98 99 100
/*  PCI Device ID Table  */
#define ENTRY(device) \
	{PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
	.class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}

101
static DEFINE_PCI_DEVICE_TABLE(qlcnic_pci_tbl) = {
102
	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
S
Sony Chacko 已提交
103
	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
R
Rajesh Borundia 已提交
104
	ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE834X),
105 106 107 108 109 110
	{0,}
};

MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);


S
Sony Chacko 已提交
111
inline void qlcnic_update_cmd_producer(struct qlcnic_host_tx_ring *tx_ring)
112 113 114 115 116 117 118 119 120 121 122
{
	writel(tx_ring->producer, tx_ring->crb_cmd_producer);
}

static const u32 msi_tgt_status[8] = {
	ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
	ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
	ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
	ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
};

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
static const u32 qlcnic_reg_tbl[] = {
	0x1B20A8,	/* PEG_HALT_STAT1 */
	0x1B20AC,	/* PEG_HALT_STAT2 */
	0x1B20B0,	/* FW_HEARTBEAT */
	0x1B2100,	/* LOCK ID */
	0x1B2128,	/* FW_CAPABILITIES */
	0x1B2138,	/* drv active */
	0x1B2140,	/* dev state */
	0x1B2144,	/* drv state */
	0x1B2148,	/* drv scratch */
	0x1B214C,	/* dev partition info */
	0x1B2174,	/* drv idc ver */
	0x1B2150,	/* fw version major */
	0x1B2154,	/* fw version minor */
	0x1B2158,	/* fw version sub */
	0x1B219C,	/* npar state */
	0x1B21FC,	/* FW_IMG_VALID */
	0x1B2250,	/* CMD_PEG_STATE */
	0x1B233C,	/* RCV_PEG_STATE */
	0x1B23B4,	/* ASIC TEMP */
	0x1B216C,	/* FW api */
	0x1B2170,	/* drv op mode */
	0x13C010,	/* flash lock */
	0x13C014,	/* flash unlock */
};

S
Sony Chacko 已提交
149
static const struct qlcnic_board_info qlcnic_boards[] = {
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x24e,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x243,
	  "8300 Series Single Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x24a,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x246,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x252,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x26e,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x260,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x266,
	  "8300 Series Single Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x269,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x271,
	  "8300 Series Dual Port 10GbE Converged Network Adapter "
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE834X,
	  0x0, 0x0, "8300 Series 1/10GbE Controller" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x203,
	  "8200 Series Single Port 10GbE Converged Network Adapter"
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x207,
	  "8200 Series Dual Port 10GbE Converged Network Adapter"
	  "(TCP/IP Networking)" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x20b,
	  "3200 Series Dual Port 10Gb Intelligent Ethernet Adapter" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x20c,
	  "3200 Series Quad Port 1Gb Intelligent Ethernet Adapter" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x20f,
	  "3200 Series Single Port 10Gb Intelligent Ethernet Adapter" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  0x103c, 0x3733,
	  "NC523SFP 10Gb 2-port Server Adapter" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  0x103c, 0x3346,
	  "CN1000Q Dual Port Converged Network Adapter" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  PCI_VENDOR_ID_QLOGIC,
	  0x210,
	  "QME8242-k 10GbE Dual Port Mezzanine Card" },
	{ PCI_VENDOR_ID_QLOGIC,
	  PCI_DEVICE_ID_QLOGIC_QLE824X,
	  0x0, 0x0, "cLOM8214 1/10GbE Controller" },
S
Sony Chacko 已提交
256 257 258
};

#define NUM_SUPPORTED_BOARDS ARRAY_SIZE(qlcnic_boards)
S
Sony Chacko 已提交
259
#define QLC_MAX_SDS_RINGS	8
S
Sony Chacko 已提交
260

261 262 263
static const
struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;

264
int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
265 266 267 268 269
{
	int size = sizeof(struct qlcnic_host_sds_ring) * count;

	recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);

270
	return recv_ctx->sds_rings == NULL;
271 272
}

273
void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
274 275 276 277 278 279 280
{
	if (recv_ctx->sds_rings != NULL)
		kfree(recv_ctx->sds_rings);

	recv_ctx->sds_rings = NULL;
}

R
Rajesh Borundia 已提交
281
int qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
282
{
283
	u8 mac_addr[ETH_ALEN];
284 285 286
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;

R
Rajesh Borundia 已提交
287
	if (qlcnic_get_mac_address(adapter, mac_addr) != 0)
288 289
		return -EIO;

290
	memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
291 292 293 294
	memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);

	/* set station address */

295
	if (!is_valid_ether_addr(netdev->dev_addr))
296 297 298 299 300 301
		dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
					netdev->dev_addr);

	return 0;
}

M
Manish Chopra 已提交
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
static void qlcnic_delete_adapter_mac(struct qlcnic_adapter *adapter)
{
	struct qlcnic_mac_list_s *cur;
	struct list_head *head;

	list_for_each(head, &adapter->mac_list) {
		cur = list_entry(head, struct qlcnic_mac_list_s, list);
		if (!memcmp(adapter->mac_addr, cur->mac_addr, ETH_ALEN)) {
			qlcnic_sre_macaddr_change(adapter, cur->mac_addr,
						  0, QLCNIC_MAC_DEL);
			list_del(&cur->list);
			kfree(cur);
			return;
		}
	}
}

319 320 321 322 323
static int qlcnic_set_mac(struct net_device *netdev, void *p)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	struct sockaddr *addr = p;

324 325 326
	if (qlcnic_sriov_vf_check(adapter))
		return -EINVAL;

327 328 329
	if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
		return -EOPNOTSUPP;

330
	if (!is_valid_ether_addr(addr->sa_data))
S
Sony Chacko 已提交
331
		return -EINVAL;
332

M
Manish Chopra 已提交
333 334 335
	if (!memcmp(adapter->mac_addr, addr->sa_data, ETH_ALEN))
		return 0;

336
	if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
337 338 339 340
		netif_device_detach(netdev);
		qlcnic_napi_disable(adapter);
	}

M
Manish Chopra 已提交
341
	qlcnic_delete_adapter_mac(adapter);
342 343 344 345
	memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
	qlcnic_set_multi(adapter->netdev);

346
	if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
347 348 349 350 351 352
		netif_device_attach(netdev);
		qlcnic_napi_enable(adapter);
	}
	return 0;
}

353 354
static int qlcnic_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
			struct net_device *netdev, const unsigned char *addr)
355 356 357 358
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	int err = -EOPNOTSUPP;

359 360
	if (!adapter->fdb_mac_learn)
		return ndo_dflt_fdb_del(ndm, tb, netdev, addr);
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379

	if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
		if (is_unicast_ether_addr(addr))
			err = qlcnic_nic_del_mac(adapter, addr);
		else if (is_multicast_ether_addr(addr))
			err = dev_mc_del(netdev, addr);
		else
			err =  -EINVAL;
	}
	return err;
}

static int qlcnic_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
			struct net_device *netdev,
			const unsigned char *addr, u16 flags)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	int err = 0;

380 381
	if (!adapter->fdb_mac_learn)
		return ndo_dflt_fdb_add(ndm, tb, netdev, addr, flags);
382 383 384 385 386 387 388 389 390 391

	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
		pr_info("%s: FDB e-switch is not enabled\n", __func__);
		return -EOPNOTSUPP;
	}

	if (ether_addr_equal(addr, adapter->mac_addr))
		return err;

	if (is_unicast_ether_addr(addr))
392
		err = qlcnic_nic_add_mac(adapter, addr, 0);
393 394 395 396 397 398 399 400 401 402 403 404 405
	else if (is_multicast_ether_addr(addr))
		err = dev_mc_add_excl(netdev, addr);
	else
		err = -EINVAL;

	return err;
}

static int qlcnic_fdb_dump(struct sk_buff *skb, struct netlink_callback *ncb,
			struct net_device *netdev, int idx)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);

406 407
	if (!adapter->fdb_mac_learn)
		return ndo_dflt_fdb_dump(skb, ncb, netdev, idx);
408 409 410 411 412 413 414

	if (adapter->flags & QLCNIC_ESWITCH_ENABLED)
		idx = ndo_dflt_fdb_dump(skb, ncb, netdev, idx);

	return idx;
}

415 416 417 418 419 420 421 422
static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
{
	while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
		usleep_range(10000, 11000);

	cancel_delayed_work_sync(&adapter->fw_work);
}

423 424 425 426 427 428
static const struct net_device_ops qlcnic_netdev_ops = {
	.ndo_open	   = qlcnic_open,
	.ndo_stop	   = qlcnic_close,
	.ndo_start_xmit    = qlcnic_xmit_frame,
	.ndo_get_stats	   = qlcnic_get_stats,
	.ndo_validate_addr = eth_validate_addr,
429
	.ndo_set_rx_mode   = qlcnic_set_multi,
430 431
	.ndo_set_mac_address    = qlcnic_set_mac,
	.ndo_change_mtu	   = qlcnic_change_mtu,
432 433
	.ndo_fix_features  = qlcnic_fix_features,
	.ndo_set_features  = qlcnic_set_features,
434
	.ndo_tx_timeout	   = qlcnic_tx_timeout,
435 436
	.ndo_vlan_rx_add_vid	= qlcnic_vlan_rx_add,
	.ndo_vlan_rx_kill_vid	= qlcnic_vlan_rx_del,
437 438 439
	.ndo_fdb_add		= qlcnic_fdb_add,
	.ndo_fdb_del		= qlcnic_fdb_del,
	.ndo_fdb_dump		= qlcnic_fdb_dump,
440 441 442
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller = qlcnic_poll_controller,
#endif
443 444 445 446
#ifdef CONFIG_QLCNIC_SRIOV
	.ndo_set_vf_mac		= qlcnic_sriov_set_vf_mac,
	.ndo_set_vf_tx_rate	= qlcnic_sriov_set_vf_tx_rate,
	.ndo_get_vf_config	= qlcnic_sriov_get_vf_config,
447
	.ndo_set_vf_vlan	= qlcnic_sriov_set_vf_vlan,
448
	.ndo_set_vf_spoofchk	= qlcnic_sriov_set_vf_spoofchk,
449
#endif
450 451
};

452 453 454 455
static const struct net_device_ops qlcnic_netdev_failed_ops = {
	.ndo_open	   = qlcnic_open,
};

456
static struct qlcnic_nic_template qlcnic_ops = {
457 458 459 460 461 462
	.config_bridged_mode	= qlcnic_config_bridged_mode,
	.config_led		= qlcnic_82xx_config_led,
	.start_firmware		= qlcnic_82xx_start_firmware,
	.request_reset		= qlcnic_82xx_dev_request_reset,
	.cancel_idc_work	= qlcnic_82xx_cancel_idc_work,
	.napi_add		= qlcnic_82xx_napi_add,
S
Sony Chacko 已提交
463
	.napi_del		= qlcnic_82xx_napi_del,
464 465 466 467 468 469 470 471
	.config_ipaddr		= qlcnic_82xx_config_ipaddr,
	.clear_legacy_intr	= qlcnic_82xx_clear_legacy_intr,
};

struct qlcnic_nic_template qlcnic_vf_ops = {
	.config_bridged_mode	= qlcnicvf_config_bridged_mode,
	.config_led		= qlcnicvf_config_led,
	.start_firmware		= qlcnicvf_start_firmware
472 473
};

474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
static struct qlcnic_hardware_ops qlcnic_hw_ops = {
	.read_crb			= qlcnic_82xx_read_crb,
	.write_crb			= qlcnic_82xx_write_crb,
	.read_reg			= qlcnic_82xx_hw_read_wx_2M,
	.write_reg			= qlcnic_82xx_hw_write_wx_2M,
	.get_mac_address		= qlcnic_82xx_get_mac_address,
	.setup_intr			= qlcnic_82xx_setup_intr,
	.alloc_mbx_args			= qlcnic_82xx_alloc_mbx_args,
	.mbx_cmd			= qlcnic_82xx_issue_cmd,
	.get_func_no			= qlcnic_82xx_get_func_no,
	.api_lock			= qlcnic_82xx_api_lock,
	.api_unlock			= qlcnic_82xx_api_unlock,
	.add_sysfs			= qlcnic_82xx_add_sysfs,
	.remove_sysfs			= qlcnic_82xx_remove_sysfs,
	.process_lb_rcv_ring_diag	= qlcnic_82xx_process_rcv_ring_diag,
	.create_rx_ctx			= qlcnic_82xx_fw_cmd_create_rx_ctx,
	.create_tx_ctx			= qlcnic_82xx_fw_cmd_create_tx_ctx,
491 492
	.del_rx_ctx			= qlcnic_82xx_fw_cmd_del_rx_ctx,
	.del_tx_ctx			= qlcnic_82xx_fw_cmd_del_tx_ctx,
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
	.setup_link_event		= qlcnic_82xx_linkevent_request,
	.get_nic_info			= qlcnic_82xx_get_nic_info,
	.get_pci_info			= qlcnic_82xx_get_pci_info,
	.set_nic_info			= qlcnic_82xx_set_nic_info,
	.change_macvlan			= qlcnic_82xx_sre_macaddr_change,
	.napi_enable			= qlcnic_82xx_napi_enable,
	.napi_disable			= qlcnic_82xx_napi_disable,
	.config_intr_coal		= qlcnic_82xx_config_intr_coalesce,
	.config_rss			= qlcnic_82xx_config_rss,
	.config_hw_lro			= qlcnic_82xx_config_hw_lro,
	.config_loopback		= qlcnic_82xx_set_lb_mode,
	.clear_loopback			= qlcnic_82xx_clear_lb_mode,
	.config_promisc_mode		= qlcnic_82xx_nic_set_promisc,
	.change_l2_filter		= qlcnic_82xx_change_filter,
	.get_board_info			= qlcnic_82xx_get_board_info,
508
	.free_mac_list			= qlcnic_82xx_free_mac_list,
509 510
};

511
int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
512 513
{
	struct pci_dev *pdev = adapter->pdev;
S
Sony Chacko 已提交
514
	int err = -1, i;
515 516 517 518 519 520 521 522 523
	int max_tx_rings, tx_vector;

	if (adapter->flags & QLCNIC_TX_INTR_SHARED) {
		max_tx_rings = 0;
		tx_vector = 0;
	} else {
		max_tx_rings = adapter->max_drv_tx_rings;
		tx_vector = 1;
	}
S
Sony Chacko 已提交
524 525 526 527 528

	if (!adapter->msix_entries) {
		adapter->msix_entries = kcalloc(num_msix,
						sizeof(struct msix_entry),
						GFP_KERNEL);
529
		if (!adapter->msix_entries)
S
Sony Chacko 已提交
530 531
			return -ENOMEM;
	}
532 533 534 535

	adapter->max_sds_rings = 1;
	adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);

536
	if (adapter->ahw->msix_supported) {
537
 enable_msix:
S
Sony Chacko 已提交
538 539
		for (i = 0; i < num_msix; i++)
			adapter->msix_entries[i].entry = i;
540 541 542
		err = pci_enable_msix(pdev, adapter->msix_entries, num_msix);
		if (err == 0) {
			adapter->flags |= QLCNIC_MSIX_ENABLED;
S
Sony Chacko 已提交
543 544 545 546 547 548 549 550
			if (qlcnic_83xx_check(adapter)) {
				adapter->ahw->num_msix = num_msix;
				/* subtract mail box and tx ring vectors */
				adapter->max_sds_rings = num_msix -
							 max_tx_rings - 1;
			} else {
				adapter->max_sds_rings = num_msix;
			}
551
			dev_info(&pdev->dev, "using msi-x interrupts\n");
552
			return err;
S
Sony Chacko 已提交
553 554 555 556 557
		} else if (err > 0) {
			dev_info(&pdev->dev,
				 "Unable to allocate %d MSI-X interrupt vectors\n",
				 num_msix);
			if (qlcnic_83xx_check(adapter)) {
558
				if (err < (QLC_83XX_MINIMUM_VECTOR - tx_vector))
S
Sony Chacko 已提交
559
					return err;
560
				err -= (max_tx_rings + 1);
S
Sony Chacko 已提交
561
				num_msix = rounddown_pow_of_two(err);
562
				num_msix += (max_tx_rings + 1);
S
Sony Chacko 已提交
563 564 565 566 567 568
			} else {
				num_msix = rounddown_pow_of_two(err);
			}

			if (num_msix) {
				dev_info(&pdev->dev,
569
					 "Trying to allocate %d MSI-X interrupt vectors\n",
S
Sony Chacko 已提交
570
					 num_msix);
571
				goto enable_msix;
S
Sony Chacko 已提交
572 573
			}
		} else {
574 575
			dev_info(&pdev->dev,
				 "Unable to allocate %d MSI-X interrupt vectors\n",
S
Sony Chacko 已提交
576
				 num_msix);
577 578
		}
	}
S
Sony Chacko 已提交
579

580 581
	return err;
}
582

583
static int qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
584
{
585
	int err = 0;
586
	u32 offset, mask_reg;
587
	const struct qlcnic_legacy_intr_set *legacy_intrp;
588
	struct qlcnic_hardware_context *ahw = adapter->ahw;
589
	struct pci_dev *pdev = adapter->pdev;
590

591
	if (qlcnic_use_msi && !pci_enable_msi(pdev)) {
592
		adapter->flags |= QLCNIC_MSI_ENABLED;
593 594 595
		offset = msi_tgt_status[adapter->ahw->pci_func];
		adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
							    offset);
596 597
		dev_info(&pdev->dev, "using msi interrupts\n");
		adapter->msix_entries[0].vector = pdev->irq;
598
		return err;
599
	}
600 601
	if (qlcnic_use_msi || qlcnic_use_msi_x)
		return -EOPNOTSUPP;
602

603
	legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
604
	adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
605 606 607 608 609 610
	offset = legacy_intrp->tgt_status_reg;
	adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
	mask_reg = legacy_intrp->tgt_mask_reg;
	adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
	adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
	adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
611 612
	dev_info(&pdev->dev, "using legacy interrupts\n");
	adapter->msix_entries[0].vector = pdev->irq;
613
	return err;
614 615
}

616
int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter, u8 num_intr)
617
{
618
	int num_msix, err = 0;
619

620 621 622 623
	if (!num_intr)
		num_intr = QLCNIC_DEF_NUM_STS_DESC_RINGS;

	if (adapter->ahw->msix_supported)
624
		num_msix = rounddown_pow_of_two(min_t(int, num_online_cpus(),
625 626
						num_intr));
	else
627 628
		num_msix = 1;

629 630 631
	err = qlcnic_enable_msix(adapter, num_msix);
	if (err == -ENOMEM || !err)
		return err;
632

633 634 635 636 637
	err = qlcnic_enable_msi_legacy(adapter);
	if (!err)
		return err;

	return -EIO;
638
}
S
Sony Chacko 已提交
639

S
Sony Chacko 已提交
640
void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
641 642 643 644 645
{
	if (adapter->flags & QLCNIC_MSIX_ENABLED)
		pci_disable_msix(adapter->pdev);
	if (adapter->flags & QLCNIC_MSI_ENABLED)
		pci_disable_msi(adapter->pdev);
S
Sony Chacko 已提交
646 647 648 649 650 651 652 653

	kfree(adapter->msix_entries);
	adapter->msix_entries = NULL;

	if (adapter->ahw->intr_tbl) {
		vfree(adapter->ahw->intr_tbl);
		adapter->ahw->intr_tbl = NULL;
	}
654 655
}

656
static void qlcnic_cleanup_pci_map(struct qlcnic_hardware_context *ahw)
657
{
658 659
	if (ahw->pci_base0 != NULL)
		iounmap(ahw->pci_base0);
660 661
}

662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
{
	struct qlcnic_pci_info *pci_info;
	int ret;

	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
		switch (adapter->ahw->port_type) {
		case QLCNIC_GBE:
			adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_GBE_PORTS;
			break;
		case QLCNIC_XGBE:
			adapter->ahw->act_pci_func = QLCNIC_NIU_MAX_XG_PORTS;
			break;
		}
		return 0;
	}

	if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
		return 0;

	pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
	if (!pci_info)
		return -ENOMEM;

	ret = qlcnic_get_pci_info(adapter, pci_info);
	kfree(pci_info);
	return ret;
}
690 691

int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
692
{
D
Dan Carpenter 已提交
693
	struct qlcnic_pci_info *pci_info;
694 695
	int i, ret = 0, j = 0;
	u16 act_pci_func;
696 697
	u8 pfn;

D
Dan Carpenter 已提交
698 699 700 701
	pci_info = kcalloc(QLCNIC_MAX_PCI_FUNC, sizeof(*pci_info), GFP_KERNEL);
	if (!pci_info)
		return -ENOMEM;

702 703 704 705 706 707
	ret = qlcnic_get_pci_info(adapter, pci_info);
	if (ret)
		goto err_pci_info;

	act_pci_func = adapter->ahw->act_pci_func;

708
	adapter->npars = kzalloc(sizeof(struct qlcnic_npar_info) *
709
				 act_pci_func, GFP_KERNEL);
D
Dan Carpenter 已提交
710
	if (!adapter->npars) {
711
		ret = -ENOMEM;
D
Dan Carpenter 已提交
712 713
		goto err_pci_info;
	}
714

715
	adapter->eswitch = kzalloc(sizeof(struct qlcnic_eswitch) *
716 717
				QLCNIC_NIU_MAX_XG_PORTS, GFP_KERNEL);
	if (!adapter->eswitch) {
718
		ret = -ENOMEM;
719
		goto err_npars;
720 721
	}

722 723
	for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++) {
		pfn = pci_info[i].id;
724

725
		if (pfn >= QLCNIC_MAX_PCI_FUNC) {
S
Sony Chacko 已提交
726 727 728
			ret = QL_STATUS_INVALID_PARAM;
			goto err_eswitch;
		}
729 730 731 732 733 734 735 736 737 738 739 740

		if (!pci_info[i].active ||
		    (pci_info[i].type != QLCNIC_TYPE_NIC))
			continue;

		adapter->npars[j].pci_func = pfn;
		adapter->npars[j].active = (u8)pci_info[i].active;
		adapter->npars[j].type = (u8)pci_info[i].type;
		adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
		adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
		adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
		j++;
741 742
	}

S
Sony Chacko 已提交
743
	for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++) {
744
		adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
S
Sony Chacko 已提交
745 746 747
		if (qlcnic_83xx_check(adapter))
			qlcnic_enable_eswitch(adapter, i, 1);
	}
748

D
Dan Carpenter 已提交
749
	kfree(pci_info);
750 751 752
	return 0;

err_eswitch:
753 754
	kfree(adapter->eswitch);
	adapter->eswitch = NULL;
755
err_npars:
756
	kfree(adapter->npars);
757
	adapter->npars = NULL;
D
Dan Carpenter 已提交
758 759
err_pci_info:
	kfree(pci_info);
760 761 762 763

	return ret;
}

764 765 766 767
static int
qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
{
	u8 id;
768
	int ret;
769
	u32 data = QLCNIC_MGMT_FUNC;
770
	struct qlcnic_hardware_context *ahw = adapter->ahw;
771 772 773 774 775

	ret = qlcnic_api_lock(adapter);
	if (ret)
		goto err_lock;

776 777 778 779
	id = ahw->pci_func;
	data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
	data = (data & ~QLC_DEV_SET_DRV(0xf, id)) |
	       QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC, id);
780
	QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
781 782 783 784 785
	qlcnic_api_unlock(adapter);
err_lock:
	return ret;
}

S
Sony Chacko 已提交
786 787
static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
			    const struct pci_device_id *ent)
788 789 790 791
{
	u32 op_mode, priv_level;

	/* Determine FW API version */
S
Sony Chacko 已提交
792 793
	adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
							   QLCNIC_FW_API);
794 795

	/* Find PCI function number */
S
Sony Chacko 已提交
796
	qlcnic_get_func_no(adapter);
797 798

	/* Determine function privilege level */
S
Sony Chacko 已提交
799
	op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
800
	if (op_mode == QLC_DEV_DRV_DEFAULT)
801
		priv_level = QLCNIC_MGMT_FUNC;
802
	else
A
Anirban Chakraborty 已提交
803
		priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
804

805
	if (priv_level == QLCNIC_NON_PRIV_FUNC) {
806
		adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
807 808
		dev_info(&adapter->pdev->dev,
			"HAL Version: %d Non Privileged function\n",
809
			 adapter->ahw->fw_hal_version);
810
		adapter->nic_ops = &qlcnic_vf_ops;
811 812
	} else
		adapter->nic_ops = &qlcnic_ops;
813 814
}

815
#define QLCNIC_82XX_BAR0_LENGTH 0x00200000UL
S
Sony Chacko 已提交
816
#define QLCNIC_83XX_BAR0_LENGTH 0x4000
817 818 819 820 821 822
static void qlcnic_get_bar_length(u32 dev_id, ulong *bar)
{
	switch (dev_id) {
	case PCI_DEVICE_ID_QLOGIC_QLE824X:
		*bar = QLCNIC_82XX_BAR0_LENGTH;
		break;
S
Sony Chacko 已提交
823
	case PCI_DEVICE_ID_QLOGIC_QLE834X:
R
Rajesh Borundia 已提交
824
	case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
S
Sony Chacko 已提交
825 826
		*bar = QLCNIC_83XX_BAR0_LENGTH;
		break;
827 828 829 830 831 832 833
	default:
		*bar = 0;
	}
}

static int qlcnic_setup_pci_map(struct pci_dev *pdev,
				struct qlcnic_hardware_context *ahw)
834
{
835
	u32 offset;
836
	void __iomem *mem_ptr0 = NULL;
837
	unsigned long mem_len, pci_len0 = 0, bar0_len;
838 839 840 841

	/* remap phys address */
	mem_len = pci_resource_len(pdev, 0);

842 843
	qlcnic_get_bar_length(pdev->device, &bar0_len);
	if (mem_len >= bar0_len) {
844 845 846 847 848 849 850 851 852 853 854

		mem_ptr0 = pci_ioremap_bar(pdev, 0);
		if (mem_ptr0 == NULL) {
			dev_err(&pdev->dev, "failed to map PCI bar 0\n");
			return -EIO;
		}
		pci_len0 = mem_len;
	} else {
		return -EIO;
	}

R
Rajesh Borundia 已提交
855
	dev_info(&pdev->dev, "%dKB memory map\n", (int)(mem_len >> 10));
856

857 858 859 860
	ahw->pci_base0 = mem_ptr0;
	ahw->pci_len0 = pci_len0;
	offset = QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(ahw->pci_func));
	qlcnic_get_ioaddr(ahw, offset);
861 862 863 864

	return 0;
}

865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
static inline bool qlcnic_validate_subsystem_id(struct qlcnic_adapter *adapter,
						int index)
{
	struct pci_dev *pdev = adapter->pdev;
	unsigned short subsystem_vendor;
	bool ret = true;

	subsystem_vendor = pdev->subsystem_vendor;

	if (pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X ||
	    pdev->device == PCI_DEVICE_ID_QLOGIC_QLE834X) {
		if (qlcnic_boards[index].sub_vendor == subsystem_vendor &&
		    qlcnic_boards[index].sub_device == pdev->subsystem_device)
			ret = true;
		else
			ret = false;
	}

	return ret;
}

S
Sony Chacko 已提交
886
static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
887 888 889 890 891 892
{
	struct pci_dev *pdev = adapter->pdev;
	int i, found = 0;

	for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
		if (qlcnic_boards[i].vendor == pdev->vendor &&
893 894 895 896
		    qlcnic_boards[i].device == pdev->device &&
		    qlcnic_validate_subsystem_id(adapter, i)) {
			found = 1;
			break;
897 898 899 900
		}
	}

	if (!found)
901
		sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
902 903 904
	else
		sprintf(name, "%pM: %s" , adapter->mac_addr,
			qlcnic_boards[i].short_name);
905 906 907 908 909
}

static void
qlcnic_check_options(struct qlcnic_adapter *adapter)
{
910
	int err;
911
	u32 fw_major, fw_minor, fw_build, prev_fw_version;
912
	struct pci_dev *pdev = adapter->pdev;
913 914
	struct qlcnic_hardware_context *ahw = adapter->ahw;
	struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
915 916

	prev_fw_version = adapter->fw_version;
917

918 919 920
	fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
	fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
	fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
921 922 923

	adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);

924 925 926 927 928 929
	err = qlcnic_get_board_info(adapter);
	if (err) {
		dev_err(&pdev->dev, "Error getting board config info.\n");
		return;
	}
	if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
930 931 932 933 934 935 936 937 938 939
		if (fw_dump->tmpl_hdr == NULL ||
				adapter->fw_version > prev_fw_version) {
			if (fw_dump->tmpl_hdr)
				vfree(fw_dump->tmpl_hdr);
			if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
				dev_info(&pdev->dev,
					"Supports FW dump capability\n");
		}
	}

S
Sony Chacko 已提交
940 941 942
	dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d\n",
		 QLCNIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build);

A
Anirban Chakraborty 已提交
943
	if (adapter->ahw->port_type == QLCNIC_XGBE) {
S
Sony Chacko 已提交
944 945 946 947 948 949 950 951
		if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
			adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
			adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
		} else {
			adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
			adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
		}

952
		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
S
Sony Chacko 已提交
953 954
		adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;

A
Anirban Chakraborty 已提交
955
	} else if (adapter->ahw->port_type == QLCNIC_GBE) {
956 957
		adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
S
Sony Chacko 已提交
958 959
		adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
		adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
960 961
	}

962
	adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
963 964 965

	adapter->num_txd = MAX_CMD_DESCRIPTORS;

966
	adapter->max_rds_rings = MAX_RDS_RINGS;
967 968
}

969 970 971 972 973 974
static int
qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
{
	int err;
	struct qlcnic_info nic_info;

975
	memset(&nic_info, 0, sizeof(struct qlcnic_info));
A
Anirban Chakraborty 已提交
976
	err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
977 978 979
	if (err)
		return err;

980 981 982 983 984
	adapter->ahw->physical_port = (u8)nic_info.phys_port;
	adapter->ahw->switch_mode = nic_info.switch_mode;
	adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
	adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
	adapter->ahw->capabilities = nic_info.capabilities;
985 986 987 988 989 990

	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
		u32 temp;
		temp = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
		adapter->ahw->capabilities2 = temp;
	}
991 992
	adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
	adapter->ahw->max_mtu = nic_info.max_mtu;
993

S
Sony Chacko 已提交
994 995 996 997
	/* Disable NPAR for 83XX */
	if (qlcnic_83xx_check(adapter))
		return err;

998
	if (adapter->ahw->capabilities & BIT_6)
999 1000 1001 1002 1003 1004 1005
		adapter->flags |= QLCNIC_ESWITCH_ENABLED;
	else
		adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;

	return err;
}

1006 1007
void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
			    struct qlcnic_esw_func_cfg *esw_cfg)
1008 1009 1010 1011 1012 1013
{
	if (esw_cfg->discard_tagged)
		adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
	else
		adapter->flags |= QLCNIC_TAGGING_ENABLED;

1014 1015 1016 1017 1018 1019 1020
	if (esw_cfg->vlan_id) {
		adapter->rx_pvid = esw_cfg->vlan_id;
		adapter->tx_pvid = esw_cfg->vlan_id;
	} else {
		adapter->rx_pvid = 0;
		adapter->tx_pvid = 0;
	}
1021 1022
}

1023
static int
1024
qlcnic_vlan_rx_add(struct net_device *netdev, __be16 proto, u16 vid)
1025 1026
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
	int err;

	if (qlcnic_sriov_vf_check(adapter)) {
		err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 1);
		if (err) {
			netdev_err(netdev,
				   "Cannot add VLAN filter for VLAN id %d, err=%d",
				   vid, err);
			return err;
		}
	}

1039
	set_bit(vid, adapter->vlans);
1040
	return 0;
1041 1042
}

1043
static int
1044
qlcnic_vlan_rx_del(struct net_device *netdev, __be16 proto, u16 vid)
1045 1046
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
	int err;

	if (qlcnic_sriov_vf_check(adapter)) {
		err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 0);
		if (err) {
			netdev_err(netdev,
				   "Cannot delete VLAN filter for VLAN id %d, err=%d",
				   vid, err);
			return err;
		}
	}
1058 1059 1060

	qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
	clear_bit(vid, adapter->vlans);
1061
	return 0;
1062 1063
}

1064 1065
void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
				      struct qlcnic_esw_func_cfg *esw_cfg)
1066
{
1067 1068
	adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
				QLCNIC_PROMISC_DISABLED);
1069 1070 1071

	if (esw_cfg->mac_anti_spoof)
		adapter->flags |= QLCNIC_MACSPOOF;
S
Sony Chacko 已提交
1072

1073 1074 1075
	if (!esw_cfg->mac_override)
		adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;

1076 1077
	if (!esw_cfg->promisc_mode)
		adapter->flags |= QLCNIC_PROMISC_DISABLED;
1078 1079
}

1080
int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
1081 1082 1083 1084 1085 1086
{
	struct qlcnic_esw_func_cfg esw_cfg;

	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
		return 0;

A
Anirban Chakraborty 已提交
1087
	esw_cfg.pci_func = adapter->ahw->pci_func;
1088 1089
	if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
			return -EIO;
1090
	qlcnic_set_vlan_config(adapter, &esw_cfg);
1091
	qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
1092
	qlcnic_set_netdev_features(adapter, &esw_cfg);
1093 1094 1095 1096

	return 0;
}

1097 1098
void qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
				struct qlcnic_esw_func_cfg *esw_cfg)
1099 1100
{
	struct net_device *netdev = adapter->netdev;
S
Sony Chacko 已提交
1101 1102 1103

	if (qlcnic_83xx_check(adapter))
		return;
1104

1105 1106 1107 1108
	adapter->offload_flags = esw_cfg->offload_flags;
	adapter->flags |= QLCNIC_APP_CHANGED_FLAGS;
	netdev_update_features(netdev);
	adapter->flags &= ~QLCNIC_APP_CHANGED_FLAGS;
1109 1110
}

1111 1112 1113 1114 1115 1116
static int
qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
{
	u32 op_mode, priv_level;
	int err = 0;

1117 1118 1119 1120
	err = qlcnic_initialize_nic(adapter);
	if (err)
		return err;

1121 1122 1123
	if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
		return 0;

S
Sony Chacko 已提交
1124
	op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
A
Anirban Chakraborty 已提交
1125
	priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1126 1127 1128 1129

	if (op_mode == QLC_DEV_DRV_DEFAULT)
		priv_level = QLCNIC_MGMT_FUNC;
	else
A
Anirban Chakraborty 已提交
1130
		priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1131

1132
	if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1133
		if (priv_level == QLCNIC_MGMT_FUNC) {
1134
			adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
1135 1136 1137 1138 1139 1140 1141
			err = qlcnic_init_pci_info(adapter);
			if (err)
				return err;
			/* Set privilege level for other functions */
			qlcnic_set_function_modes(adapter);
			dev_info(&adapter->pdev->dev,
				"HAL Version: %d, Management function\n",
1142
				 adapter->ahw->fw_hal_version);
1143
		} else if (priv_level == QLCNIC_PRIV_FUNC) {
1144
			adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
1145 1146
			dev_info(&adapter->pdev->dev,
				"HAL Version: %d, Privileged function\n",
1147
				 adapter->ahw->fw_hal_version);
1148
		}
1149
	}
1150 1151 1152 1153 1154 1155

	adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;

	return err;
}

1156
int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
1157 1158 1159 1160 1161
{
	struct qlcnic_esw_func_cfg esw_cfg;
	struct qlcnic_npar_info *npar;
	u8 i;

1162
	if (adapter->need_fw_reset)
1163 1164
		return 0;

1165
	for (i = 0; i < adapter->ahw->act_pci_func; i++) {
1166
		memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
1167
		esw_cfg.pci_func = adapter->npars[i].pci_func;
1168
		esw_cfg.mac_override = BIT_0;
1169
		esw_cfg.promisc_mode = BIT_0;
1170 1171 1172 1173 1174
		if (qlcnic_82xx_check(adapter)) {
			esw_cfg.offload_flags = BIT_0;
			if (QLCNIC_IS_TSO_CAPABLE(adapter))
				esw_cfg.offload_flags |= (BIT_1 | BIT_2);
		}
1175 1176 1177 1178
		if (qlcnic_config_switch_port(adapter, &esw_cfg))
			return -EIO;
		npar = &adapter->npars[i];
		npar->pvid = esw_cfg.vlan_id;
1179
		npar->mac_override = esw_cfg.mac_override;
1180 1181 1182 1183 1184 1185 1186 1187 1188
		npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
		npar->discard_tagged = esw_cfg.discard_tagged;
		npar->promisc_mode = esw_cfg.promisc_mode;
		npar->offload_flags = esw_cfg.offload_flags;
	}

	return 0;
}

S
Sony Chacko 已提交
1189

1190 1191 1192 1193 1194 1195 1196 1197
static int
qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
			struct qlcnic_npar_info *npar, int pci_func)
{
	struct qlcnic_esw_func_cfg esw_cfg;
	esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
	esw_cfg.pci_func = pci_func;
	esw_cfg.vlan_id = npar->pvid;
1198
	esw_cfg.mac_override = npar->mac_override;
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	esw_cfg.discard_tagged = npar->discard_tagged;
	esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
	esw_cfg.offload_flags = npar->offload_flags;
	esw_cfg.promisc_mode = npar->promisc_mode;
	if (qlcnic_config_switch_port(adapter, &esw_cfg))
		return -EIO;

	esw_cfg.op_mode = QLCNIC_ADD_VLAN;
	if (qlcnic_config_switch_port(adapter, &esw_cfg))
		return -EIO;

	return 0;
}

1213
int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
1214
{
1215
	int i, err;
1216 1217
	struct qlcnic_npar_info *npar;
	struct qlcnic_info nic_info;
1218
	u8 pci_func;
1219

1220 1221 1222
	if (qlcnic_82xx_check(adapter))
		if (!adapter->need_fw_reset)
			return 0;
1223

1224
	/* Set the NPAR config data after FW reset */
1225
	for (i = 0; i < adapter->ahw->act_pci_func; i++) {
1226
		npar = &adapter->npars[i];
1227 1228
		pci_func = npar->pci_func;
		memset(&nic_info, 0, sizeof(struct qlcnic_info));
S
Sony Chacko 已提交
1229
		err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
1230 1231 1232 1233 1234 1235 1236
		if (err)
			return err;
		nic_info.min_tx_bw = npar->min_bw;
		nic_info.max_tx_bw = npar->max_bw;
		err = qlcnic_set_nic_info(adapter, &nic_info);
		if (err)
			return err;
1237

1238 1239
		if (npar->enable_pm) {
			err = qlcnic_config_port_mirroring(adapter,
1240 1241
							   npar->dest_npar, 1,
							   pci_func);
1242 1243
			if (err)
				return err;
1244
		}
1245
		err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
1246 1247
		if (err)
			return err;
1248
	}
1249
	return 0;
1250 1251
}

A
Amit Kumar Salecha 已提交
1252 1253 1254 1255 1256
static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
{
	u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
	u32 npar_state;

1257
	if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
A
Amit Kumar Salecha 已提交
1258 1259
		return 0;

1260 1261
	npar_state = QLC_SHARED_REG_RD32(adapter,
					 QLCNIC_CRB_DEV_NPAR_STATE);
A
Amit Kumar Salecha 已提交
1262 1263
	while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
		msleep(1000);
1264 1265
		npar_state = QLC_SHARED_REG_RD32(adapter,
						 QLCNIC_CRB_DEV_NPAR_STATE);
A
Amit Kumar Salecha 已提交
1266 1267 1268
	}
	if (!npar_opt_timeo) {
		dev_err(&adapter->pdev->dev,
1269
			"Waiting for NPAR state to operational timeout\n");
A
Amit Kumar Salecha 已提交
1270 1271 1272 1273 1274
		return -EIO;
	}
	return 0;
}

1275 1276 1277 1278 1279 1280
static int
qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
{
	int err;

	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
1281
	    adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		return 0;

	err = qlcnic_set_default_offload_settings(adapter);
	if (err)
		return err;

	err = qlcnic_reset_npar_config(adapter);
	if (err)
		return err;

	qlcnic_dev_set_npar_ready(adapter);

	return err;
}

1297
int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
1298
{
1299
	int err;
1300

1301 1302 1303 1304
	err = qlcnic_can_start_firmware(adapter);
	if (err < 0)
		return err;
	else if (!err)
1305
		goto check_fw_status;
1306

1307
	if (qlcnic_load_fw_file)
1308
		qlcnic_request_firmware(adapter);
S
schacko 已提交
1309
	else {
S
Sony Chacko 已提交
1310 1311
		err = qlcnic_check_flash_fw_ver(adapter);
		if (err)
S
schacko 已提交
1312 1313
			goto err_out;

1314
		adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
S
schacko 已提交
1315
	}
1316 1317 1318

	err = qlcnic_need_fw_reset(adapter);
	if (err == 0)
1319
		goto check_fw_status;
1320

1321 1322 1323
	err = qlcnic_pinit_from_rom(adapter);
	if (err)
		goto err_out;
1324 1325 1326 1327 1328 1329

	err = qlcnic_load_firmware(adapter);
	if (err)
		goto err_out;

	qlcnic_release_firmware(adapter);
1330
	QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1331

1332 1333
check_fw_status:
	err = qlcnic_check_fw_status(adapter);
1334 1335 1336
	if (err)
		goto err_out;

1337
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1338
	qlcnic_idc_debug_info(adapter, 1);
1339 1340 1341 1342 1343 1344
	err = qlcnic_check_eswitch_mode(adapter);
	if (err) {
		dev_err(&adapter->pdev->dev,
			"Memory allocation failed for eswitch\n");
		goto err_out;
	}
1345 1346 1347 1348 1349
	err = qlcnic_set_mgmt_operations(adapter);
	if (err)
		goto err_out;

	qlcnic_check_options(adapter);
1350 1351
	adapter->need_fw_reset = 0;

1352 1353
	qlcnic_release_firmware(adapter);
	return 0;
1354 1355

err_out:
1356
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1357
	dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1358

1359 1360 1361 1362 1363 1364 1365 1366 1367
	qlcnic_release_firmware(adapter);
	return err;
}

static int
qlcnic_request_irq(struct qlcnic_adapter *adapter)
{
	irq_handler_t handler;
	struct qlcnic_host_sds_ring *sds_ring;
S
Sony Chacko 已提交
1368
	struct qlcnic_host_tx_ring *tx_ring;
1369
	int err, ring, num_sds_rings;
1370 1371 1372

	unsigned long flags = 0;
	struct net_device *netdev = adapter->netdev;
A
Anirban Chakraborty 已提交
1373
	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1374

1375
	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
S
Sony Chacko 已提交
1376 1377
		if (qlcnic_82xx_check(adapter))
			handler = qlcnic_tmp_intr;
1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
		if (!QLCNIC_IS_MSI_FAMILY(adapter))
			flags |= IRQF_SHARED;

	} else {
		if (adapter->flags & QLCNIC_MSIX_ENABLED)
			handler = qlcnic_msix_intr;
		else if (adapter->flags & QLCNIC_MSI_ENABLED)
			handler = qlcnic_msi_intr;
		else {
			flags |= IRQF_SHARED;
1388 1389 1390 1391
			if (qlcnic_82xx_check(adapter))
				handler = qlcnic_intr;
			else
				handler = qlcnic_83xx_intr;
1392
		}
1393 1394 1395
	}
	adapter->irq = netdev->irq;

S
Sony Chacko 已提交
1396
	if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1397 1398 1399
		if (qlcnic_82xx_check(adapter) ||
		    (qlcnic_83xx_check(adapter) &&
		     (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1400 1401
			num_sds_rings = adapter->max_sds_rings;
			for (ring = 0; ring < num_sds_rings; ring++) {
1402
				sds_ring = &recv_ctx->sds_rings[ring];
1403
				if (qlcnic_82xx_check(adapter) &&
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
				    (ring == (num_sds_rings - 1))) {
					if (!(adapter->flags &
					      QLCNIC_MSIX_ENABLED))
						snprintf(sds_ring->name,
							 sizeof(sds_ring->name),
							 "qlcnic");
					else
						snprintf(sds_ring->name,
							 sizeof(sds_ring->name),
							 "%s-tx-0-rx-%d",
							 netdev->name, ring);
				} else {
1416 1417
					snprintf(sds_ring->name,
						 sizeof(sds_ring->name),
1418
						 "%s-rx-%d",
1419
						 netdev->name, ring);
1420
				}
1421 1422 1423 1424 1425
				err = request_irq(sds_ring->irq, handler, flags,
						  sds_ring->name, sds_ring);
				if (err)
					return err;
			}
S
Sony Chacko 已提交
1426 1427
		}
		if (qlcnic_83xx_check(adapter) &&
1428 1429
		    (adapter->flags & QLCNIC_MSIX_ENABLED) &&
		    !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
S
Sony Chacko 已提交
1430 1431 1432 1433
			handler = qlcnic_msix_tx_intr;
			for (ring = 0; ring < adapter->max_drv_tx_rings;
			     ring++) {
				tx_ring = &adapter->tx_ring[ring];
1434
				snprintf(tx_ring->name, sizeof(tx_ring->name),
1435
					 "%s-tx-%d", netdev->name, ring);
S
Sony Chacko 已提交
1436 1437 1438 1439 1440 1441
				err = request_irq(tx_ring->irq, handler, flags,
						  tx_ring->name, tx_ring);
				if (err)
					return err;
			}
		}
1442 1443 1444 1445 1446 1447 1448 1449 1450
	}
	return 0;
}

static void
qlcnic_free_irq(struct qlcnic_adapter *adapter)
{
	int ring;
	struct qlcnic_host_sds_ring *sds_ring;
S
Sony Chacko 已提交
1451
	struct qlcnic_host_tx_ring *tx_ring;
1452

A
Anirban Chakraborty 已提交
1453
	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1454

S
Sony Chacko 已提交
1455
	if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1456 1457 1458 1459 1460 1461 1462
		if (qlcnic_82xx_check(adapter) ||
		    (qlcnic_83xx_check(adapter) &&
		     (adapter->flags & QLCNIC_MSIX_ENABLED))) {
			for (ring = 0; ring < adapter->max_sds_rings; ring++) {
				sds_ring = &recv_ctx->sds_rings[ring];
				free_irq(sds_ring->irq, sds_ring);
			}
S
Sony Chacko 已提交
1463
		}
1464 1465
		if (qlcnic_83xx_check(adapter) &&
		    !(adapter->flags & QLCNIC_TX_INTR_SHARED)) {
S
Sony Chacko 已提交
1466 1467 1468 1469 1470 1471 1472
			for (ring = 0; ring < adapter->max_drv_tx_rings;
			     ring++) {
				tx_ring = &adapter->tx_ring[ring];
				if (tx_ring->irq)
					free_irq(tx_ring->irq, tx_ring);
			}
		}
1473 1474 1475
	}
}

1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
static void qlcnic_get_lro_mss_capability(struct qlcnic_adapter *adapter)
{
	u32 capab = 0;

	if (qlcnic_82xx_check(adapter)) {
		if (adapter->ahw->capabilities2 &
		    QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
			adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
	} else {
		capab = adapter->ahw->capabilities;
		if (QLC_83XX_GET_FW_LRO_MSS_CAPABILITY(capab))
			adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
	}
}

S
Sony Chacko 已提交
1491
int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1492
{
1493 1494 1495
	int ring;
	struct qlcnic_host_rds_ring *rds_ring;

1496 1497 1498
	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
		return -EIO;

1499 1500
	if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
		return 0;
1501 1502
	if (qlcnic_set_eswitch_port_config(adapter))
		return -EIO;
1503
	qlcnic_get_lro_mss_capability(adapter);
1504

1505 1506 1507 1508
	if (qlcnic_fw_create_ctx(adapter))
		return -EIO;

	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
A
Anirban Chakraborty 已提交
1509
		rds_ring = &adapter->recv_ctx->rds_rings[ring];
S
Sony Chacko 已提交
1510
		qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1511 1512
	}

1513 1514 1515
	qlcnic_set_multi(netdev);
	qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);

A
Anirban Chakraborty 已提交
1516
	adapter->ahw->linkup = 0;
1517 1518 1519 1520 1521 1522

	if (adapter->max_sds_rings > 1)
		qlcnic_config_rss(adapter, 1);

	qlcnic_config_intr_coalesce(adapter);

1523
	if (netdev->features & NETIF_F_LRO)
1524 1525 1526 1527 1528 1529
		qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);

	qlcnic_napi_enable(adapter);

	qlcnic_linkevent_request(adapter, 1);

1530
	adapter->ahw->reset_context = 0;
1531 1532 1533 1534
	set_bit(__QLCNIC_DEV_UP, &adapter->state);
	return 0;
}

1535
int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
{
	int err = 0;

	rtnl_lock();
	if (netif_running(netdev))
		err = __qlcnic_up(adapter, netdev);
	rtnl_unlock();

	return err;
}

S
Sony Chacko 已提交
1547
void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1548 1549 1550 1551 1552 1553 1554
{
	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
		return;

	if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
		return;

1555 1556
	if (qlcnic_sriov_vf_check(adapter))
		qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc);
1557 1558 1559
	smp_mb();
	spin_lock(&adapter->tx_clean_lock);
	netif_carrier_off(netdev);
1560
	adapter->ahw->linkup = 0;
1561 1562 1563 1564
	netif_tx_disable(netdev);

	qlcnic_free_mac_list(adapter);

1565 1566 1567
	if (adapter->fhash.fnum)
		qlcnic_delete_lb_filters(adapter);

1568 1569 1570 1571
	qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);

	qlcnic_napi_disable(adapter);

1572
	qlcnic_fw_destroy_ctx(adapter);
1573
	adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
1574 1575

	qlcnic_reset_rx_buffers_list(adapter);
1576 1577 1578 1579 1580 1581
	qlcnic_release_tx_buffers(adapter);
	spin_unlock(&adapter->tx_clean_lock);
}

/* Usage: During suspend and firmware recovery module */

1582
void qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1583 1584 1585 1586 1587 1588 1589 1590
{
	rtnl_lock();
	if (netif_running(netdev))
		__qlcnic_down(adapter, netdev);
	rtnl_unlock();

}

S
Sony Chacko 已提交
1591
int
1592 1593 1594 1595
qlcnic_attach(struct qlcnic_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;
	struct pci_dev *pdev = adapter->pdev;
1596
	int err;
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607

	if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
		return 0;

	err = qlcnic_napi_add(adapter, netdev);
	if (err)
		return err;

	err = qlcnic_alloc_sw_resources(adapter);
	if (err) {
		dev_err(&pdev->dev, "Error in setting sw resources\n");
1608
		goto err_out_napi_del;
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
	}

	err = qlcnic_alloc_hw_resources(adapter);
	if (err) {
		dev_err(&pdev->dev, "Error in setting hw resources\n");
		goto err_out_free_sw;
	}

	err = qlcnic_request_irq(adapter);
	if (err) {
		dev_err(&pdev->dev, "failed to setup interrupt\n");
1620
		goto err_out_free_hw;
1621 1622 1623 1624 1625 1626 1627
	}

	qlcnic_create_sysfs_entries(adapter);

	adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
	return 0;

1628
err_out_free_hw:
1629 1630 1631
	qlcnic_free_hw_resources(adapter);
err_out_free_sw:
	qlcnic_free_sw_resources(adapter);
1632 1633
err_out_napi_del:
	qlcnic_napi_del(adapter);
1634 1635 1636
	return err;
}

S
Sony Chacko 已提交
1637
void qlcnic_detach(struct qlcnic_adapter *adapter)
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652
{
	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
		return;

	qlcnic_remove_sysfs_entries(adapter);

	qlcnic_free_hw_resources(adapter);
	qlcnic_release_rx_buffers(adapter);
	qlcnic_free_irq(adapter);
	qlcnic_napi_del(adapter);
	qlcnic_free_sw_resources(adapter);

	adapter->is_up = 0;
}

1653 1654 1655 1656 1657 1658
void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	struct qlcnic_host_sds_ring *sds_ring;
	int ring;

1659
	clear_bit(__QLCNIC_DEV_UP, &adapter->state);
1660
	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1661
		for (ring = 0; ring < adapter->max_sds_rings; ring++) {
A
Anirban Chakraborty 已提交
1662
			sds_ring = &adapter->recv_ctx->sds_rings[ring];
1663
			qlcnic_disable_int(sds_ring);
1664
		}
1665 1666
	}

1667 1668
	qlcnic_fw_destroy_ctx(adapter);

1669 1670
	qlcnic_detach(adapter);

1671
	adapter->ahw->diag_test = 0;
1672 1673 1674
	adapter->max_sds_rings = max_sds_rings;

	if (qlcnic_attach(adapter))
1675
		goto out;
1676 1677 1678

	if (netif_running(netdev))
		__qlcnic_up(adapter, netdev);
1679
out:
1680 1681 1682
	netif_device_attach(netdev);
}

A
Anirban Chakraborty 已提交
1683 1684
static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
{
1685
	struct qlcnic_hardware_context *ahw = adapter->ahw;
A
Anirban Chakraborty 已提交
1686
	int err = 0;
1687

A
Anirban Chakraborty 已提交
1688 1689 1690 1691
	adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
				GFP_KERNEL);
	if (!adapter->recv_ctx) {
		err = -ENOMEM;
A
Anirban Chakraborty 已提交
1692
		goto err_out;
A
Anirban Chakraborty 已提交
1693
	}
A
Anirban Chakraborty 已提交
1694
	/* Initialize interrupt coalesce parameters */
1695 1696 1697 1698 1699 1700 1701 1702
	ahw->coal.flag = QLCNIC_INTR_DEFAULT;
	ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX;
	ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
	ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
	if (qlcnic_83xx_check(adapter)) {
		ahw->coal.tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
		ahw->coal.tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
	}
S
Sony Chacko 已提交
1703 1704
	/* clear stats */
	memset(&adapter->stats, 0, sizeof(adapter->stats));
A
Anirban Chakraborty 已提交
1705 1706 1707 1708 1709 1710 1711 1712 1713
err_out:
	return err;
}

static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
{
	kfree(adapter->recv_ctx);
	adapter->recv_ctx = NULL;

A
Anirban Chakraborty 已提交
1714 1715 1716 1717
	if (adapter->ahw->fw_dump.tmpl_hdr) {
		vfree(adapter->ahw->fw_dump.tmpl_hdr);
		adapter->ahw->fw_dump.tmpl_hdr = NULL;
	}
S
Sony Chacko 已提交
1718

1719
	kfree(adapter->ahw->reset.buff);
S
Sony Chacko 已提交
1720
	adapter->ahw->fw_dump.tmpl_hdr = NULL;
A
Anirban Chakraborty 已提交
1721 1722
}

1723 1724 1725 1726
int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	struct qlcnic_host_sds_ring *sds_ring;
1727
	struct qlcnic_host_rds_ring *rds_ring;
1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738
	int ring;
	int ret;

	netif_device_detach(netdev);

	if (netif_running(netdev))
		__qlcnic_down(adapter, netdev);

	qlcnic_detach(adapter);

	adapter->max_sds_rings = 1;
1739
	adapter->ahw->diag_test = test;
S
Sony Chacko 已提交
1740
	adapter->ahw->linkup = 0;
1741 1742

	ret = qlcnic_attach(adapter);
1743 1744
	if (ret) {
		netif_device_attach(netdev);
1745
		return ret;
1746
	}
1747

1748 1749 1750
	ret = qlcnic_fw_create_ctx(adapter);
	if (ret) {
		qlcnic_detach(adapter);
1751
		netif_device_attach(netdev);
1752 1753 1754 1755
		return ret;
	}

	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
A
Anirban Chakraborty 已提交
1756
		rds_ring = &adapter->recv_ctx->rds_rings[ring];
S
Sony Chacko 已提交
1757
		qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1758 1759
	}

1760
	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1761
		for (ring = 0; ring < adapter->max_sds_rings; ring++) {
A
Anirban Chakraborty 已提交
1762
			sds_ring = &adapter->recv_ctx->sds_rings[ring];
1763
			qlcnic_enable_int(sds_ring);
1764
		}
1765
	}
1766

1767
	if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
1768 1769 1770 1771
		adapter->ahw->loopback_state = 0;
		qlcnic_linkevent_request(adapter, 1);
	}

1772
	set_bit(__QLCNIC_DEV_UP, &adapter->state);
1773 1774 1775 1776

	return 0;
}

1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
/* Reset context in hardware only */
static int
qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
{
	struct net_device *netdev = adapter->netdev;

	if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
		return -EBUSY;

	netif_device_detach(netdev);

	qlcnic_down(adapter, netdev);

	qlcnic_up(adapter, netdev);

	netif_device_attach(netdev);

	clear_bit(__QLCNIC_RESETTING, &adapter->state);
S
Sony Chacko 已提交
1795
	dev_err(&adapter->pdev->dev, "%s:\n", __func__);
1796 1797 1798
	return 0;
}

1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
int
qlcnic_reset_context(struct qlcnic_adapter *adapter)
{
	int err = 0;
	struct net_device *netdev = adapter->netdev;

	if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
		return -EBUSY;

	if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {

		netif_device_detach(netdev);

		if (netif_running(netdev))
			__qlcnic_down(adapter, netdev);

		qlcnic_detach(adapter);

		if (netif_running(netdev)) {
			err = qlcnic_attach(adapter);
A
Anirban Chakraborty 已提交
1819
			if (!err) {
1820
				__qlcnic_up(adapter, netdev);
A
Anirban Chakraborty 已提交
1821 1822
				qlcnic_restore_indev_addr(netdev, NETDEV_UP);
			}
1823 1824 1825 1826 1827 1828 1829 1830 1831
		}

		netif_device_attach(netdev);
	}

	clear_bit(__QLCNIC_RESETTING, &adapter->state);
	return err;
}

R
Rajesh Borundia 已提交
1832
int
S
Sony Chacko 已提交
1833 1834
qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev,
		    int pci_using_dac)
1835 1836 1837 1838
{
	int err;
	struct pci_dev *pdev = adapter->pdev;

S
Sony Chacko 已提交
1839
	adapter->rx_csum = 1;
1840
	adapter->ahw->mc_enabled = 0;
S
Sony Chacko 已提交
1841
	adapter->ahw->max_mc_count = QLCNIC_MAX_MC_COUNT;
1842 1843

	netdev->netdev_ops	   = &qlcnic_netdev_ops;
S
Sony Chacko 已提交
1844
	netdev->watchdog_timeo     = QLCNIC_WATCHDOG_TIMEOUTVALUE * HZ;
1845 1846 1847

	qlcnic_change_mtu(netdev, netdev->mtu);

1848 1849 1850 1851
	if (qlcnic_sriov_vf_check(adapter))
		SET_ETHTOOL_OPS(netdev, &qlcnic_sriov_vf_ethtool_ops);
	else
		SET_ETHTOOL_OPS(netdev, &qlcnic_ethtool_ops);
1852

1853
	netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
S
Sony Chacko 已提交
1854
			     NETIF_F_IPV6_CSUM | NETIF_F_GRO |
1855
			     NETIF_F_HW_VLAN_CTAG_RX);
S
Sony Chacko 已提交
1856 1857
	netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
				  NETIF_F_IPV6_CSUM);
1858

S
Sony Chacko 已提交
1859 1860 1861 1862
	if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
		netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
		netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
	}
1863

S
Sony Chacko 已提交
1864 1865 1866 1867
	if (pci_using_dac) {
		netdev->features |= NETIF_F_HIGHDMA;
		netdev->vlan_features |= NETIF_F_HIGHDMA;
	}
1868

S
Sony Chacko 已提交
1869
	if (qlcnic_vlan_tx_check(adapter))
1870
		netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX);
1871

1872 1873 1874
	if (qlcnic_sriov_vf_check(adapter))
		netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;

S
Sony Chacko 已提交
1875 1876
	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
		netdev->features |= NETIF_F_LRO;
1877

1878
	netdev->hw_features = netdev->features;
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
	netdev->irq = adapter->msix_entries[0].vector;

	err = register_netdev(netdev);
	if (err) {
		dev_err(&pdev->dev, "failed to register net device\n");
		return err;
	}

	return 0;
}

S
Sony Chacko 已提交
1890
static int qlcnic_set_dma_mask(struct pci_dev *pdev, int *pci_using_dac)
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905
{
	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
			!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
		*pci_using_dac = 1;
	else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
			!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
		*pci_using_dac = 0;
	else {
		dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
		return -EIO;
	}

	return 0;
}

S
Sony Chacko 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
{
	int ring;
	struct qlcnic_host_tx_ring *tx_ring;

	for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
		tx_ring = &adapter->tx_ring[ring];
		if (tx_ring && tx_ring->cmd_buf_arr != NULL) {
			vfree(tx_ring->cmd_buf_arr);
			tx_ring->cmd_buf_arr = NULL;
		}
	}
	if (adapter->tx_ring != NULL)
		kfree(adapter->tx_ring);
}

int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
			  struct net_device *netdev)
{
1925
	int ring, vector, index;
S
Sony Chacko 已提交
1926 1927 1928
	struct qlcnic_host_tx_ring *tx_ring;
	struct qlcnic_cmd_buffer *cmd_buf_arr;

1929 1930 1931
	tx_ring = kcalloc(adapter->max_drv_tx_rings,
			  sizeof(struct qlcnic_host_tx_ring), GFP_KERNEL);
	if (tx_ring == NULL)
S
Sony Chacko 已提交
1932
		return -ENOMEM;
1933

S
Sony Chacko 已提交
1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
	adapter->tx_ring = tx_ring;

	for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
		tx_ring = &adapter->tx_ring[ring];
		tx_ring->num_desc = adapter->num_txd;
		tx_ring->txq = netdev_get_tx_queue(netdev, ring);
		cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
		if (cmd_buf_arr == NULL) {
			qlcnic_free_tx_rings(adapter);
			return -ENOMEM;
		}
		memset(cmd_buf_arr, 0, TX_BUFF_RINGSIZE(tx_ring));
		tx_ring->cmd_buf_arr = cmd_buf_arr;
	}

	if (qlcnic_83xx_check(adapter)) {
		for (ring = 0; ring < adapter->max_drv_tx_rings; ring++) {
			tx_ring = &adapter->tx_ring[ring];
			tx_ring->adapter = adapter;
			if (adapter->flags & QLCNIC_MSIX_ENABLED) {
				index = adapter->max_sds_rings + ring;
				vector = adapter->msix_entries[index].vector;
				tx_ring->irq = vector;
			}
		}
	}
	return 0;
}

B
Bill Pemberton 已提交
1963
static int
1964 1965 1966 1967
qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
	struct net_device *netdev = NULL;
	struct qlcnic_adapter *adapter = NULL;
1968
	struct qlcnic_hardware_context *ahw;
S
Sony Chacko 已提交
1969
	int err, pci_using_dac = -1;
1970
	u32 capab2;
1971
	char board_name[QLCNIC_MAX_BOARD_NAME_LEN + 19]; /* MAC + ": " + name */
1972

R
Rajesh Borundia 已提交
1973 1974 1975
	if (pdev->is_virtfn)
		return -ENODEV;

1976 1977 1978 1979 1980 1981 1982 1983 1984
	err = pci_enable_device(pdev);
	if (err)
		return err;

	if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
		err = -ENODEV;
		goto err_out_disable_pdev;
	}

1985 1986 1987 1988
	err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
	if (err)
		goto err_out_disable_pdev;

1989 1990 1991 1992 1993
	err = pci_request_regions(pdev, qlcnic_driver_name);
	if (err)
		goto err_out_disable_pdev;

	pci_set_master(pdev);
S
Sucheta Chakraborty 已提交
1994
	pci_enable_pcie_error_reporting(pdev);
1995

1996
	ahw = kzalloc(sizeof(struct qlcnic_hardware_context), GFP_KERNEL);
1997 1998
	if (!ahw) {
		err = -ENOMEM;
1999
		goto err_out_free_res;
2000
	}
2001

R
Rajesh Borundia 已提交
2002 2003
	switch (ent->device) {
	case PCI_DEVICE_ID_QLOGIC_QLE824X:
2004
		ahw->hw_ops = &qlcnic_hw_ops;
R
Rajesh Borundia 已提交
2005 2006 2007
		ahw->reg_tbl = (u32 *) qlcnic_reg_tbl;
		break;
	case PCI_DEVICE_ID_QLOGIC_QLE834X:
S
Sony Chacko 已提交
2008
		qlcnic_83xx_register_map(ahw);
R
Rajesh Borundia 已提交
2009 2010 2011 2012 2013
		break;
	case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
		qlcnic_sriov_vf_register_map(ahw);
		break;
	default:
S
Sony Chacko 已提交
2014
		goto err_out_free_hw_res;
2015 2016 2017 2018 2019 2020
	}

	err = qlcnic_setup_pci_map(pdev, ahw);
	if (err)
		goto err_out_free_hw_res;

2021 2022 2023
	netdev = alloc_etherdev(sizeof(struct qlcnic_adapter));
	if (!netdev) {
		err = -ENOMEM;
2024
		goto err_out_iounmap;
2025 2026 2027 2028 2029 2030 2031
	}

	SET_NETDEV_DEV(netdev, &pdev->dev);

	adapter = netdev_priv(netdev);
	adapter->netdev  = netdev;
	adapter->pdev    = pdev;
S
Sony Chacko 已提交
2032 2033 2034 2035
	adapter->ahw = ahw;

	adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
	if (adapter->qlcnic_wq == NULL) {
2036
		err = -ENOMEM;
S
Sony Chacko 已提交
2037 2038 2039
		dev_err(&pdev->dev, "Failed to create workqueue\n");
		goto err_out_free_netdev;
	}
2040

2041 2042
	err = qlcnic_alloc_adapter_resources(adapter);
	if (err)
A
Anirban Chakraborty 已提交
2043 2044 2045
		goto err_out_free_netdev;

	adapter->dev_rst_time = jiffies;
2046
	adapter->ahw->revision_id = pdev->revision;
2047 2048 2049 2050
	if (qlcnic_mac_learn == FDB_MAC_LEARN)
		adapter->fdb_mac_learn = true;
	else if (qlcnic_mac_learn == DRV_MAC_LEARN)
		adapter->drv_mac_learn = true;
2051
	adapter->max_drv_tx_rings = 1;
2052

A
Anirban Chakraborty 已提交
2053 2054
	rwlock_init(&adapter->ahw->crb_lock);
	mutex_init(&adapter->ahw->mem_lock);
2055 2056 2057 2058

	spin_lock_init(&adapter->tx_clean_lock);
	INIT_LIST_HEAD(&adapter->mac_list);

2059
	if (qlcnic_82xx_check(adapter)) {
S
Sony Chacko 已提交
2060
		qlcnic_check_vf(adapter, ent);
2061 2062 2063 2064 2065 2066
		adapter->portnum = adapter->ahw->pci_func;
		err = qlcnic_start_firmware(adapter);
		if (err) {
			dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n");
			goto err_out_free_hw;
		}
2067

2068 2069 2070
		err = qlcnic_setup_idc_param(adapter);
		if (err)
			goto err_out_free_hw;
2071

2072
		adapter->flags |= QLCNIC_NEED_FLR;
S
Sony Chacko 已提交
2073 2074 2075
	} else if (qlcnic_83xx_check(adapter)) {
		qlcnic_83xx_check_vf(adapter, ent);
		adapter->portnum = adapter->ahw->pci_func;
R
Rajesh Borundia 已提交
2076
		err = qlcnic_83xx_init(adapter, pci_using_dac);
2077 2078 2079 2080
		if (err) {
			dev_err(&pdev->dev, "%s: failed\n", __func__);
			goto err_out_free_hw;
		}
R
Rajesh Borundia 已提交
2081 2082
		if (qlcnic_sriov_vf_check(adapter))
			return 0;
S
Sony Chacko 已提交
2083 2084 2085 2086
	} else {
		dev_err(&pdev->dev,
			"%s: failed. Please Reboot\n", __func__);
		goto err_out_free_hw;
2087
	}
2088

R
Rajesh Borundia 已提交
2089 2090 2091 2092
	if (qlcnic_read_mac_addr(adapter))
		dev_warn(&pdev->dev, "failed to read mac addr\n");

	if (adapter->portnum == 0) {
S
Sony Chacko 已提交
2093
		qlcnic_get_board_name(adapter, board_name);
S
Sony Chacko 已提交
2094

R
Rajesh Borundia 已提交
2095
		pr_info("%s: %s Board Chip rev 0x%x\n",
S
Sony Chacko 已提交
2096 2097
			module_name(THIS_MODULE),
			board_name, adapter->ahw->revision_id);
R
Rajesh Borundia 已提交
2098
	}
2099 2100 2101 2102 2103 2104

	if (qlcnic_83xx_check(adapter) && !qlcnic_use_msi_x &&
	    !!qlcnic_use_msi)
		dev_warn(&pdev->dev,
			 "83xx adapter do not support MSI interrupts\n");

2105
	err = qlcnic_setup_intr(adapter, 0);
2106 2107
	if (err) {
		dev_err(&pdev->dev, "Failed to setup interrupt\n");
2108
		goto err_out_disable_msi;
2109
	}
2110

S
Sony Chacko 已提交
2111 2112 2113 2114 2115
	if (qlcnic_83xx_check(adapter)) {
		err = qlcnic_83xx_setup_mbx_intr(adapter);
		if (err)
			goto err_out_disable_msi;
	}
2116

2117 2118 2119 2120
	err = qlcnic_get_act_pci_func(adapter);
	if (err)
		goto err_out_disable_mbx_intr;

2121
	err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
2122
	if (err)
2123
		goto err_out_disable_mbx_intr;
2124

2125 2126 2127 2128 2129 2130 2131 2132
	if (qlcnic_82xx_check(adapter)) {
		if (ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
			capab2 = QLCRD32(adapter, CRB_FW_CAPABILITIES_2);
			if (capab2 & QLCNIC_FW_CAPABILITY_2_OCBB)
				qlcnic_fw_cmd_set_drv_version(adapter);
		}
	}

2133 2134
	pci_set_drvdata(pdev, adapter);

2135 2136 2137
	if (qlcnic_82xx_check(adapter))
		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
				     FW_POLL_DELAY);
2138

A
Anirban Chakraborty 已提交
2139
	switch (adapter->ahw->port_type) {
2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
	case QLCNIC_GBE:
		dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
				adapter->netdev->name);
		break;
	case QLCNIC_XGBE:
		dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
				adapter->netdev->name);
		break;
	}

2150
	if (adapter->drv_mac_learn)
2151 2152
		qlcnic_alloc_lb_filters_mem(adapter);

2153
	qlcnic_add_sysfs(adapter);
2154 2155 2156

	return 0;

2157
err_out_disable_mbx_intr:
2158
	if (qlcnic_83xx_check(adapter))
S
Sony Chacko 已提交
2159
		qlcnic_83xx_free_mbx_intr(adapter);
2160

2161 2162
err_out_disable_msi:
	qlcnic_teardown_intr(adapter);
2163
	qlcnic_cancel_idc_work(adapter);
2164
	qlcnic_clr_all_drv_state(adapter, 0);
2165

A
Anirban Chakraborty 已提交
2166 2167 2168
err_out_free_hw:
	qlcnic_free_adapter_resources(adapter);

2169 2170 2171
err_out_free_netdev:
	free_netdev(netdev);

2172
err_out_iounmap:
2173
	qlcnic_cleanup_pci_map(ahw);
2174 2175 2176 2177

err_out_free_hw_res:
	kfree(ahw);

2178 2179 2180 2181 2182 2183 2184 2185 2186
err_out_free_res:
	pci_release_regions(pdev);

err_out_disable_pdev:
	pci_set_drvdata(pdev, NULL);
	pci_disable_device(pdev);
	return err;
}

B
Bill Pemberton 已提交
2187
static void qlcnic_remove(struct pci_dev *pdev)
2188 2189 2190
{
	struct qlcnic_adapter *adapter;
	struct net_device *netdev;
S
Sony Chacko 已提交
2191
	struct qlcnic_hardware_context *ahw;
2192 2193 2194 2195 2196 2197

	adapter = pci_get_drvdata(pdev);
	if (adapter == NULL)
		return;

	netdev = adapter->netdev;
2198
	qlcnic_sriov_pf_disable(adapter);
2199

S
Sony Chacko 已提交
2200 2201
	qlcnic_cancel_idc_work(adapter);
	ahw = adapter->ahw;
2202 2203

	unregister_netdev(netdev);
2204
	qlcnic_sriov_cleanup(adapter);
2205

S
Sony Chacko 已提交
2206 2207
	if (qlcnic_83xx_check(adapter)) {
		qlcnic_83xx_free_mbx_intr(adapter);
2208 2209
		qlcnic_83xx_register_nic_idc_func(adapter, 0);
		cancel_delayed_work_sync(&adapter->idc_aen_work);
S
Sony Chacko 已提交
2210 2211
	}

2212 2213
	qlcnic_detach(adapter);

2214 2215 2216 2217 2218
	if (adapter->npars != NULL)
		kfree(adapter->npars);
	if (adapter->eswitch != NULL)
		kfree(adapter->eswitch);

2219 2220
	if (qlcnic_82xx_check(adapter))
		qlcnic_clr_all_drv_state(adapter, 0);
2221 2222 2223

	clear_bit(__QLCNIC_RESETTING, &adapter->state);

2224 2225
	qlcnic_free_lb_filters_mem(adapter);

2226 2227
	qlcnic_teardown_intr(adapter);

S
Sony Chacko 已提交
2228
	qlcnic_remove_sysfs(adapter);
2229

2230
	qlcnic_cleanup_pci_map(adapter->ahw);
2231 2232 2233

	qlcnic_release_firmware(adapter);

S
Sucheta Chakraborty 已提交
2234
	pci_disable_pcie_error_reporting(pdev);
2235 2236 2237 2238
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

S
Sony Chacko 已提交
2239 2240 2241 2242
	if (adapter->qlcnic_wq) {
		destroy_workqueue(adapter->qlcnic_wq);
		adapter->qlcnic_wq = NULL;
	}
A
Anirban Chakraborty 已提交
2243
	qlcnic_free_adapter_resources(adapter);
S
Sony Chacko 已提交
2244
	kfree(ahw);
2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
	free_netdev(netdev);
}
static int __qlcnic_shutdown(struct pci_dev *pdev)
{
	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev = adapter->netdev;
	int retval;

	netif_device_detach(netdev);

S
Sony Chacko 已提交
2255
	qlcnic_cancel_idc_work(adapter);
2256 2257 2258 2259

	if (netif_running(netdev))
		qlcnic_down(adapter, netdev);

R
Rajesh Borundia 已提交
2260
	qlcnic_sriov_cleanup(adapter);
2261 2262
	if (qlcnic_82xx_check(adapter))
		qlcnic_clr_all_drv_state(adapter, 0);
2263 2264 2265 2266 2267 2268

	clear_bit(__QLCNIC_RESETTING, &adapter->state);

	retval = pci_save_state(pdev);
	if (retval)
		return retval;
2269 2270 2271 2272 2273
	if (qlcnic_82xx_check(adapter)) {
		if (qlcnic_wol_supported(adapter)) {
			pci_enable_wake(pdev, PCI_D3cold, 1);
			pci_enable_wake(pdev, PCI_D3hot, 1);
		}
2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315
	}

	return 0;
}

static void qlcnic_shutdown(struct pci_dev *pdev)
{
	if (__qlcnic_shutdown(pdev))
		return;

	pci_disable_device(pdev);
}

#ifdef CONFIG_PM
static int
qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
{
	int retval;

	retval = __qlcnic_shutdown(pdev);
	if (retval)
		return retval;

	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	return 0;
}

static int
qlcnic_resume(struct pci_dev *pdev)
{
	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev = adapter->netdev;
	int err;

	err = pci_enable_device(pdev);
	if (err)
		return err;

	pci_set_power_state(pdev, PCI_D0);
	pci_set_master(pdev);
	pci_restore_state(pdev);

S
Sony Chacko 已提交
2316
	err = qlcnic_start_firmware(adapter);
2317 2318 2319 2320 2321 2322 2323 2324
	if (err) {
		dev_err(&pdev->dev, "failed to start firmware\n");
		return err;
	}

	if (netif_running(netdev)) {
		err = qlcnic_up(adapter, netdev);
		if (err)
2325
			goto done;
2326

A
Amit Kumar Salecha 已提交
2327
		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2328
	}
2329
done:
2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
	netif_device_attach(netdev);
	qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
	return 0;
}
#endif

static int qlcnic_open(struct net_device *netdev)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	int err;

2341 2342
	netif_carrier_off(netdev);

2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367
	err = qlcnic_attach(adapter);
	if (err)
		return err;

	err = __qlcnic_up(adapter, netdev);
	if (err)
		goto err_out;

	netif_start_queue(netdev);

	return 0;

err_out:
	qlcnic_detach(adapter);
	return err;
}

/*
 * qlcnic_close - Disables a network interface entry point
 */
static int qlcnic_close(struct net_device *netdev)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);

	__qlcnic_down(adapter, netdev);
S
Sony Chacko 已提交
2368

2369 2370 2371
	return 0;
}

2372
void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
2373 2374 2375
{
	void *head;
	int i;
S
Sony Chacko 已提交
2376 2377 2378
	struct net_device *netdev = adapter->netdev;
	u32 filter_size = 0;
	u16 act_pci_func = 0;
2379

2380
	if (adapter->fhash.fmax && adapter->fhash.fhead)
2381 2382
		return;

S
Sony Chacko 已提交
2383
	act_pci_func = adapter->ahw->act_pci_func;
2384
	spin_lock_init(&adapter->mac_learn_lock);
2385
	spin_lock_init(&adapter->rx_mac_learn_lock);
2386

S
Sony Chacko 已提交
2387 2388 2389 2390 2391 2392 2393 2394 2395
	if (qlcnic_82xx_check(adapter)) {
		filter_size = QLCNIC_LB_MAX_FILTERS;
		adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
	} else {
		filter_size = QLC_83XX_LB_MAX_FILTERS;
		adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
	}

	head = kcalloc(adapter->fhash.fbucket_size,
2396
		       sizeof(struct hlist_head), GFP_ATOMIC);
S
Sony Chacko 已提交
2397

2398 2399 2400
	if (!head)
		return;

S
Sony Chacko 已提交
2401
	adapter->fhash.fmax = (filter_size / act_pci_func);
2402
	adapter->fhash.fhead = head;
2403

S
Sony Chacko 已提交
2404 2405 2406 2407
	netdev_info(netdev, "active nic func = %d, mac filter size=%d\n",
		    act_pci_func, adapter->fhash.fmax);

	for (i = 0; i < adapter->fhash.fbucket_size; i++)
2408
		INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422

	adapter->rx_fhash.fbucket_size = adapter->fhash.fbucket_size;

	head = kcalloc(adapter->rx_fhash.fbucket_size,
		       sizeof(struct hlist_head), GFP_ATOMIC);

	if (!head)
		return;

	adapter->rx_fhash.fmax = (filter_size / act_pci_func);
	adapter->rx_fhash.fhead = head;

	for (i = 0; i < adapter->rx_fhash.fbucket_size; i++)
		INIT_HLIST_HEAD(&adapter->rx_fhash.fhead[i]);
2423 2424 2425 2426 2427 2428 2429 2430 2431
}

static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
{
	if (adapter->fhash.fmax && adapter->fhash.fhead)
		kfree(adapter->fhash.fhead);

	adapter->fhash.fhead = NULL;
	adapter->fhash.fmax = 0;
2432 2433 2434 2435 2436 2437

	if (adapter->rx_fhash.fmax && adapter->rx_fhash.fhead)
		kfree(adapter->rx_fhash.fhead);

	adapter->rx_fhash.fmax = 0;
	adapter->rx_fhash.fhead = NULL;
2438 2439
}

2440
int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2441 2442
{
	struct net_device *netdev = adapter->netdev;
2443
	u32 temp_state, temp_val, temp = 0;
2444 2445
	int rv = 0;

S
Sony Chacko 已提交
2446 2447 2448
	if (qlcnic_83xx_check(adapter))
		temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);

2449
	if (qlcnic_82xx_check(adapter))
2450
		temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461

	temp_state = qlcnic_get_temp_state(temp);
	temp_val = qlcnic_get_temp_val(temp);

	if (temp_state == QLCNIC_TEMP_PANIC) {
		dev_err(&netdev->dev,
		       "Device temperature %d degrees C exceeds"
		       " maximum allowed. Hardware has been shut down.\n",
		       temp_val);
		rv = 1;
	} else if (temp_state == QLCNIC_TEMP_WARN) {
2462
		if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
2463 2464 2465 2466 2467 2468 2469
			dev_err(&netdev->dev,
			       "Device temperature %d degrees C "
			       "exceeds operating range."
			       " Immediate action needed.\n",
			       temp_val);
		}
	} else {
2470
		if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
2471 2472 2473 2474 2475
			dev_info(&netdev->dev,
			       "Device temperature is now %d degrees C"
			       " in normal range.\n", temp_val);
		}
	}
2476
	adapter->ahw->temp = temp_state;
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
	return rv;
}

static void qlcnic_tx_timeout(struct net_device *netdev)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);

	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
		return;

2487 2488 2489 2490 2491 2492 2493 2494 2495
	if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS) {
		netdev_info(netdev, "Tx timeout, reset the adapter.\n");
		if (qlcnic_82xx_check(adapter))
			adapter->need_fw_reset = 1;
		else if (qlcnic_83xx_check(adapter))
			qlcnic_83xx_idc_request_reset(adapter,
						      QLCNIC_FORCE_FW_DUMP_KEY);
	} else {
		netdev_info(netdev, "Tx timeout, reset adapter context.\n");
2496
		adapter->ahw->reset_context = 1;
2497
	}
2498 2499 2500 2501 2502 2503 2504 2505 2506
}

static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	struct net_device_stats *stats = &netdev->stats;

	stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
	stats->tx_packets = adapter->stats.xmitfinished;
2507
	stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
2508 2509 2510 2511 2512 2513 2514
	stats->tx_bytes = adapter->stats.txbytes;
	stats->rx_dropped = adapter->stats.rxdropped;
	stats->tx_dropped = adapter->stats.txdropped;

	return stats;
}

2515
irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
2516 2517 2518 2519 2520
{
	u32 status;

	status = readl(adapter->isr_int_vec);

2521
	if (!(status & adapter->ahw->int_vec_bit))
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
		return IRQ_NONE;

	/* check interrupt state machine, to be sure */
	status = readl(adapter->crb_int_state_reg);
	if (!ISR_LEGACY_INT_TRIGGERED(status))
		return IRQ_NONE;

	writel(0xffffffff, adapter->tgt_status_reg);
	/* read twice to ensure write is flushed */
	readl(adapter->isr_int_vec);
	readl(adapter->isr_int_vec);

2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552
	return IRQ_HANDLED;
}

static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
{
	struct qlcnic_host_sds_ring *sds_ring = data;
	struct qlcnic_adapter *adapter = sds_ring->adapter;

	if (adapter->flags & QLCNIC_MSIX_ENABLED)
		goto done;
	else if (adapter->flags & QLCNIC_MSI_ENABLED) {
		writel(0xffffffff, adapter->tgt_status_reg);
		goto done;
	}

	if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
		return IRQ_NONE;

done:
2553
	adapter->ahw->diag_cnt++;
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
	qlcnic_enable_int(sds_ring);
	return IRQ_HANDLED;
}

static irqreturn_t qlcnic_intr(int irq, void *data)
{
	struct qlcnic_host_sds_ring *sds_ring = data;
	struct qlcnic_adapter *adapter = sds_ring->adapter;

	if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
		return IRQ_NONE;

2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
	napi_schedule(&sds_ring->napi);

	return IRQ_HANDLED;
}

static irqreturn_t qlcnic_msi_intr(int irq, void *data)
{
	struct qlcnic_host_sds_ring *sds_ring = data;
	struct qlcnic_adapter *adapter = sds_ring->adapter;

	/* clear interrupt */
	writel(0xffffffff, adapter->tgt_status_reg);

	napi_schedule(&sds_ring->napi);
	return IRQ_HANDLED;
}

static irqreturn_t qlcnic_msix_intr(int irq, void *data)
{
	struct qlcnic_host_sds_ring *sds_ring = data;

	napi_schedule(&sds_ring->napi);
	return IRQ_HANDLED;
}

S
Sony Chacko 已提交
2591 2592 2593 2594 2595 2596 2597 2598
static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data)
{
	struct qlcnic_host_tx_ring *tx_ring = data;

	napi_schedule(&tx_ring->napi);
	return IRQ_HANDLED;
}

2599 2600 2601
#ifdef CONFIG_NET_POLL_CONTROLLER
static void qlcnic_poll_controller(struct net_device *netdev)
{
Y
Yinglin Luan 已提交
2602 2603
	int ring;
	struct qlcnic_host_sds_ring *sds_ring;
2604
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
A
Anirban Chakraborty 已提交
2605
	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
Y
Yinglin Luan 已提交
2606

2607
	disable_irq(adapter->irq);
Y
Yinglin Luan 已提交
2608 2609 2610 2611
	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
		sds_ring = &recv_ctx->sds_rings[ring];
		qlcnic_intr(adapter->irq, sds_ring);
	}
2612 2613 2614 2615
	enable_irq(adapter->irq);
}
#endif

2616 2617 2618 2619 2620 2621 2622 2623 2624
static void
qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
{
	u32 val;

	val = adapter->portnum & 0xf;
	val |= encoding << 7;
	val |= (jiffies - adapter->dev_rst_time) << 8;

2625
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
2626 2627 2628
	adapter->dev_rst_time = jiffies;
}

2629 2630
static int
qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
2631 2632 2633 2634 2635 2636 2637
{
	u32  val;

	WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
			state != QLCNIC_DEV_NEED_QUISCENT);

	if (qlcnic_api_lock(adapter))
2638
		return -EIO;
2639

2640
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2641 2642

	if (state == QLCNIC_DEV_NEED_RESET)
2643
		QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2644
	else if (state == QLCNIC_DEV_NEED_QUISCENT)
2645
		QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
2646

2647
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2648 2649

	qlcnic_api_unlock(adapter);
2650 2651

	return 0;
2652 2653
}

2654 2655 2656 2657 2658 2659 2660 2661
static int
qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
{
	u32  val;

	if (qlcnic_api_lock(adapter))
		return -EBUSY;

2662
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2663
	QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2664
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2665 2666 2667 2668 2669 2670

	qlcnic_api_unlock(adapter);

	return 0;
}

2671
static void
2672
qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
2673 2674 2675 2676 2677 2678
{
	u32  val;

	if (qlcnic_api_lock(adapter))
		goto err;

2679
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2680
	QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
2681
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2682

2683
	if (failed) {
2684 2685
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
				    QLCNIC_DEV_FAILED);
2686 2687 2688
		dev_info(&adapter->pdev->dev,
				"Device state set to Failed. Please Reboot\n");
	} else if (!(val & 0x11111111))
2689 2690
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
				    QLCNIC_DEV_COLD);
2691

2692
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2693
	QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
2694
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2695 2696 2697 2698

	qlcnic_api_unlock(adapter);
err:
	adapter->fw_fail_cnt = 0;
S
Sritej Velaga 已提交
2699
	adapter->flags &= ~QLCNIC_FW_HANG;
2700 2701 2702 2703
	clear_bit(__QLCNIC_START_FW, &adapter->state);
	clear_bit(__QLCNIC_RESETTING, &adapter->state);
}

2704
/* Grab api lock, before checking state */
2705 2706 2707
static int
qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
{
2708
	int act, state, active_mask;
2709
	struct qlcnic_hardware_context *ahw = adapter->ahw;
2710

2711 2712
	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
	act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2713

2714
	if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
2715
		active_mask = (~(1 << (ahw->pci_func * 4)));
2716 2717 2718
		act = act & active_mask;
	}

2719 2720 2721 2722 2723 2724 2725
	if (((state & 0x11111111) == (act & 0x11111111)) ||
			((act & 0x11111111) == ((state >> 1) & 0x11111111)))
		return 0;
	else
		return 1;
}

S
Sucheta Chakraborty 已提交
2726 2727
static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
{
2728
	u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
S
Sucheta Chakraborty 已提交
2729 2730 2731 2732 2733 2734 2735 2736 2737

	if (val != QLCNIC_DRV_IDC_VER) {
		dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
			" idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
	}

	return 0;
}

2738 2739 2740 2741
static int
qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
{
	u32 val, prev_state;
2742
	u8 dev_init_timeo = adapter->dev_init_timeo;
2743
	u8 portnum = adapter->portnum;
S
Sucheta Chakraborty 已提交
2744
	u8 ret;
2745

2746 2747 2748
	if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
		return 1;

2749 2750 2751
	if (qlcnic_api_lock(adapter))
		return -1;

2752
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
2753 2754
	if (!(val & (1 << (portnum * 4)))) {
		QLC_DEV_SET_REF_CNT(val, portnum);
2755
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
2756 2757
	}

2758
	prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2759
	QLCDB(adapter, HW, "Device state = %u\n", prev_state);
2760 2761 2762

	switch (prev_state) {
	case QLCNIC_DEV_COLD:
2763 2764 2765 2766
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
				    QLCNIC_DEV_INITIALIZING);
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
				    QLCNIC_DRV_IDC_VER);
2767
		qlcnic_idc_debug_info(adapter, 0);
2768 2769 2770 2771
		qlcnic_api_unlock(adapter);
		return 1;

	case QLCNIC_DEV_READY:
S
Sucheta Chakraborty 已提交
2772
		ret = qlcnic_check_idc_ver(adapter);
2773
		qlcnic_api_unlock(adapter);
S
Sucheta Chakraborty 已提交
2774
		return ret;
2775 2776

	case QLCNIC_DEV_NEED_RESET:
2777
		val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2778
		QLC_DEV_SET_RST_RDY(val, portnum);
2779
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2780 2781 2782
		break;

	case QLCNIC_DEV_NEED_QUISCENT:
2783
		val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2784
		QLC_DEV_SET_QSCNT_RDY(val, portnum);
2785
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2786 2787 2788
		break;

	case QLCNIC_DEV_FAILED:
2789
		dev_err(&adapter->pdev->dev, "Device in failed state.\n");
2790 2791
		qlcnic_api_unlock(adapter);
		return -1;
2792 2793 2794 2795

	case QLCNIC_DEV_INITIALIZING:
	case QLCNIC_DEV_QUISCENT:
		break;
2796 2797 2798
	}

	qlcnic_api_unlock(adapter);
2799 2800

	do {
2801
		msleep(1000);
2802
		prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2803 2804 2805 2806

		if (prev_state == QLCNIC_DEV_QUISCENT)
			continue;
	} while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
2807

2808 2809 2810
	if (!dev_init_timeo) {
		dev_err(&adapter->pdev->dev,
			"Waiting for device to initialize timeout\n");
2811
		return -1;
2812
	}
2813 2814 2815 2816

	if (qlcnic_api_lock(adapter))
		return -1;

2817
	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
2818
	QLC_DEV_CLR_RST_QSCNT(val, portnum);
2819
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
2820

S
Sucheta Chakraborty 已提交
2821
	ret = qlcnic_check_idc_ver(adapter);
2822 2823
	qlcnic_api_unlock(adapter);

S
Sucheta Chakraborty 已提交
2824
	return ret;
2825 2826 2827 2828 2829 2830 2831
}

static void
qlcnic_fwinit_work(struct work_struct *work)
{
	struct qlcnic_adapter *adapter = container_of(work,
			struct qlcnic_adapter, fw_work.work);
2832
	u32 dev_state = 0xf;
S
Sritej Velaga 已提交
2833
	u32 val;
2834

2835 2836
	if (qlcnic_api_lock(adapter))
		goto err_ret;
2837

2838
	dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2839 2840
	if (dev_state == QLCNIC_DEV_QUISCENT ||
	    dev_state == QLCNIC_DEV_NEED_QUISCENT) {
2841 2842 2843 2844 2845 2846
		qlcnic_api_unlock(adapter);
		qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
						FW_POLL_DELAY * 2);
		return;
	}

2847
	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
2848 2849
		qlcnic_api_unlock(adapter);
		goto wait_npar;
2850 2851
	}

2852 2853 2854 2855 2856 2857 2858
	if (dev_state == QLCNIC_DEV_INITIALIZING ||
	    dev_state == QLCNIC_DEV_READY) {
		dev_info(&adapter->pdev->dev, "Detected state change from "
				"DEV_NEED_RESET, skipping ack check\n");
		goto skip_ack_check;
	}

2859
	if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
2860
		dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
2861 2862 2863 2864 2865 2866
					adapter->reset_ack_timeo);
		goto skip_ack_check;
	}

	if (!qlcnic_check_drv_state(adapter)) {
skip_ack_check:
2867
		dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2868

2869
		if (dev_state == QLCNIC_DEV_NEED_RESET) {
2870 2871
			QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
					    QLCNIC_DEV_INITIALIZING);
2872 2873
			set_bit(__QLCNIC_START_FW, &adapter->state);
			QLCDB(adapter, DRV, "Restarting fw\n");
2874
			qlcnic_idc_debug_info(adapter, 0);
2875 2876
			val = QLC_SHARED_REG_RD32(adapter,
						  QLCNIC_CRB_DRV_STATE);
S
Sritej Velaga 已提交
2877
			QLC_DEV_SET_RST_RDY(val, adapter->portnum);
2878 2879
			QLC_SHARED_REG_WR32(adapter,
					    QLCNIC_CRB_DRV_STATE, val);
2880 2881
		}

2882 2883
		qlcnic_api_unlock(adapter);

2884
		rtnl_lock();
S
Sritej Velaga 已提交
2885 2886
		if (adapter->ahw->fw_dump.enable &&
		    (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
2887 2888
			QLCDB(adapter, DRV, "Take FW dump\n");
			qlcnic_dump_fw(adapter);
S
Sritej Velaga 已提交
2889
			adapter->flags |= QLCNIC_FW_HANG;
2890
		}
2891
		rtnl_unlock();
S
Sritej Velaga 已提交
2892 2893

		adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
2894
		if (!adapter->nic_ops->start_firmware(adapter)) {
2895
			qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2896
			adapter->fw_wait_cnt = 0;
2897 2898 2899 2900 2901
			return;
		}
		goto err_ret;
	}

2902
	qlcnic_api_unlock(adapter);
2903

2904
wait_npar:
2905
	dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
2906
	QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
2907

2908
	switch (dev_state) {
2909
	case QLCNIC_DEV_READY:
2910
		if (!qlcnic_start_firmware(adapter)) {
2911
			qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
2912
			adapter->fw_wait_cnt = 0;
2913 2914
			return;
		}
2915 2916 2917 2918 2919 2920
	case QLCNIC_DEV_FAILED:
		break;
	default:
		qlcnic_schedule_work(adapter,
			qlcnic_fwinit_work, FW_POLL_DELAY);
		return;
2921 2922 2923
	}

err_ret:
2924 2925
	dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
		"fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
2926
	netif_device_attach(adapter->netdev);
2927
	qlcnic_clr_all_drv_state(adapter, 0);
2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939
}

static void
qlcnic_detach_work(struct work_struct *work)
{
	struct qlcnic_adapter *adapter = container_of(work,
			struct qlcnic_adapter, fw_work.work);
	struct net_device *netdev = adapter->netdev;
	u32 status;

	netif_device_detach(netdev);

2940 2941 2942 2943 2944 2945
	/* Dont grab rtnl lock during Quiscent mode */
	if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
		if (netif_running(netdev))
			__qlcnic_down(adapter, netdev);
	} else
		qlcnic_down(adapter, netdev);
2946

2947
	status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
2948

S
Sony Chacko 已提交
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
	if (status & QLCNIC_RCODE_FATAL_ERROR) {
		dev_err(&adapter->pdev->dev,
			"Detaching the device: peg halt status1=0x%x\n",
					status);

		if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
			dev_err(&adapter->pdev->dev,
			"On board active cooling fan failed. "
				"Device has been halted.\n");
			dev_err(&adapter->pdev->dev,
				"Replace the adapter.\n");
		}

2962
		goto err_ret;
S
Sony Chacko 已提交
2963
	}
2964

2965
	if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
S
Sony Chacko 已提交
2966
		dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
2967
			adapter->ahw->temp);
2968
		goto err_ret;
S
Sony Chacko 已提交
2969 2970
	}

2971 2972
	/* Dont ack if this instance is the reset owner */
	if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
S
Sony Chacko 已提交
2973 2974 2975 2976
		if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
			dev_err(&adapter->pdev->dev,
				"Failed to set driver state,"
					"detaching the device.\n");
2977
			goto err_ret;
S
Sony Chacko 已提交
2978
		}
2979
	}
2980 2981 2982 2983 2984 2985 2986 2987

	adapter->fw_wait_cnt = 0;

	qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);

	return;

err_ret:
2988
	netif_device_attach(netdev);
2989
	qlcnic_clr_all_drv_state(adapter, 1);
2990 2991
}

2992 2993 2994 2995 2996 2997
/*Transit NPAR state to NON Operational */
static void
qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
{
	u32 state;

2998
	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
2999 3000 3001 3002 3003
	if (state == QLCNIC_DEV_NPAR_NON_OPER)
		return;

	if (qlcnic_api_lock(adapter))
		return;
3004 3005
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
			    QLCNIC_DEV_NPAR_NON_OPER);
3006 3007 3008
	qlcnic_api_unlock(adapter);
}

3009
void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter, u32 key)
3010
{
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022
	u32 state, xg_val = 0, gb_val = 0;

	qlcnic_xg_set_xg0_mask(xg_val);
	qlcnic_xg_set_xg1_mask(xg_val);
	QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
	qlcnic_gb_set_gb0_mask(gb_val);
	qlcnic_gb_set_gb1_mask(gb_val);
	qlcnic_gb_set_gb2_mask(gb_val);
	qlcnic_gb_set_gb3_mask(gb_val);
	QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
	dev_info(&adapter->pdev->dev, "Pause control frames disabled"
				" on all ports\n");
3023
	adapter->need_fw_reset = 1;
S
Sony Chacko 已提交
3024

3025 3026 3027
	if (qlcnic_api_lock(adapter))
		return;

S
Sony Chacko 已提交
3028
	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3029

3030
	if (state == QLCNIC_DEV_READY) {
S
Sony Chacko 已提交
3031 3032
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
				    QLCNIC_DEV_NEED_RESET);
3033
		adapter->flags |= QLCNIC_FW_RESET_OWNER;
3034
		QLCDB(adapter, DRV, "NEED_RESET state set\n");
3035
		qlcnic_idc_debug_info(adapter, 0);
3036 3037
	}

S
Sony Chacko 已提交
3038 3039
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
			    QLCNIC_DEV_NPAR_NON_OPER);
3040 3041 3042
	qlcnic_api_unlock(adapter);
}

3043 3044 3045 3046 3047 3048 3049
/* Transit to NPAR READY state from NPAR NOT READY state */
static void
qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
{
	if (qlcnic_api_lock(adapter))
		return;

3050 3051
	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
			    QLCNIC_DEV_NPAR_OPER);
3052
	QLCDB(adapter, DRV, "NPAR operational state set\n");
3053 3054 3055 3056

	qlcnic_api_unlock(adapter);
}

S
Sony Chacko 已提交
3057 3058
void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
			  work_func_t func, int delay)
3059
{
S
Sucheta Chakraborty 已提交
3060 3061 3062
	if (test_bit(__QLCNIC_AER, &adapter->state))
		return;

3063
	INIT_DELAYED_WORK(&adapter->fw_work, func);
S
Sony Chacko 已提交
3064 3065
	queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
			   round_jiffies_relative(delay));
3066 3067 3068 3069 3070 3071 3072 3073
}

static void
qlcnic_attach_work(struct work_struct *work)
{
	struct qlcnic_adapter *adapter = container_of(work,
				struct qlcnic_adapter, fw_work.work);
	struct net_device *netdev = adapter->netdev;
3074
	u32 npar_state;
3075

3076
	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
3077 3078
		npar_state = QLC_SHARED_REG_RD32(adapter,
						 QLCNIC_CRB_DEV_NPAR_STATE);
3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089
		if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
			qlcnic_clr_all_drv_state(adapter, 0);
		else if (npar_state != QLCNIC_DEV_NPAR_OPER)
			qlcnic_schedule_work(adapter, qlcnic_attach_work,
							FW_POLL_DELAY);
		else
			goto attach;
		QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
		return;
	}
attach:
3090
	if (netif_running(netdev)) {
3091
		if (qlcnic_up(adapter, netdev))
3092 3093
			goto done;

A
Amit Kumar Salecha 已提交
3094
		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3095 3096 3097
	}

done:
3098
	netif_device_attach(netdev);
3099
	adapter->fw_fail_cnt = 0;
S
Sritej Velaga 已提交
3100
	adapter->flags &= ~QLCNIC_FW_HANG;
3101
	clear_bit(__QLCNIC_RESETTING, &adapter->state);
3102 3103 3104 3105

	if (!qlcnic_clr_drv_state(adapter))
		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
							FW_POLL_DELAY);
3106 3107 3108 3109 3110
}

static int
qlcnic_check_health(struct qlcnic_adapter *adapter)
{
3111
	u32 state = 0, heartbeat;
3112
	u32 peg_status;
3113 3114 3115 3116

	if (qlcnic_check_temp(adapter))
		goto detach;

A
Amit Kumar Salecha 已提交
3117
	if (adapter->need_fw_reset)
3118
		qlcnic_dev_request_reset(adapter, 0);
3119

3120
	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3121
	if (state == QLCNIC_DEV_NEED_RESET) {
3122
		qlcnic_set_npar_non_operational(adapter);
3123
		adapter->need_fw_reset = 1;
3124 3125
	} else if (state == QLCNIC_DEV_NEED_QUISCENT)
		goto detach;
3126

3127
	heartbeat = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
3128 3129
	if (heartbeat != adapter->heartbeat) {
		adapter->heartbeat = heartbeat;
3130 3131 3132
		adapter->fw_fail_cnt = 0;
		if (adapter->need_fw_reset)
			goto detach;
3133

3134
		if (adapter->ahw->reset_context && qlcnic_auto_fw_reset)
3135 3136
			qlcnic_reset_hw_context(adapter);

3137 3138 3139 3140 3141 3142
		return 0;
	}

	if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
		return 0;

S
Sritej Velaga 已提交
3143 3144
	adapter->flags |= QLCNIC_FW_HANG;

3145
	qlcnic_dev_request_reset(adapter, 0);
3146

3147
	if (qlcnic_auto_fw_reset)
3148
		clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3149

3150
	dev_err(&adapter->pdev->dev, "firmware hang detected\n");
3151
	peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3152
	dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
S
Sritej Velaga 已提交
3153 3154 3155 3156
			"PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
			"PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
			"PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
			"PEG_NET_4_PC: 0x%x\n",
3157 3158
			peg_status,
			QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
S
Sritej Velaga 已提交
3159 3160 3161 3162 3163
			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c),
			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c),
			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c),
			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c),
			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c));
3164
	if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
3165 3166 3167
		dev_err(&adapter->pdev->dev,
			"Firmware aborted with error code 0x00006700. "
				"Device is being reset.\n");
3168 3169 3170 3171
detach:
	adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
		QLCNIC_DEV_NEED_RESET;

3172 3173
	if (qlcnic_auto_fw_reset && !test_and_set_bit(__QLCNIC_RESETTING,
						      &adapter->state)) {
3174

3175
		qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3176 3177
		QLCDB(adapter, DRV, "fw recovery scheduled.\n");
	}
3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194

	return 1;
}

static void
qlcnic_fw_poll_work(struct work_struct *work)
{
	struct qlcnic_adapter *adapter = container_of(work,
				struct qlcnic_adapter, fw_work.work);

	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
		goto reschedule;


	if (qlcnic_check_health(adapter))
		return;

3195 3196 3197
	if (adapter->fhash.fnum)
		qlcnic_prune_lb_filters(adapter);

3198 3199 3200 3201
reschedule:
	qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
}

S
Sucheta Chakraborty 已提交
3202 3203 3204 3205 3206 3207 3208 3209 3210
static int qlcnic_is_first_func(struct pci_dev *pdev)
{
	struct pci_dev *oth_pdev;
	int val = pdev->devfn;

	while (val-- > 0) {
		oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
			(pdev->bus), pdev->bus->number,
			PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
3211 3212
		if (!oth_pdev)
			continue;
S
Sucheta Chakraborty 已提交
3213

3214 3215
		if (oth_pdev->current_state != PCI_D3cold) {
			pci_dev_put(oth_pdev);
S
Sucheta Chakraborty 已提交
3216
			return 0;
3217 3218
		}
		pci_dev_put(oth_pdev);
S
Sucheta Chakraborty 已提交
3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
	}
	return 1;
}

static int qlcnic_attach_func(struct pci_dev *pdev)
{
	int err, first_func;
	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev = adapter->netdev;

	pdev->error_state = pci_channel_io_normal;

	err = pci_enable_device(pdev);
	if (err)
		return err;

	pci_set_power_state(pdev, PCI_D0);
	pci_set_master(pdev);
	pci_restore_state(pdev);

	first_func = qlcnic_is_first_func(pdev);

	if (qlcnic_api_lock(adapter))
		return -EINVAL;

3244
	if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
S
Sucheta Chakraborty 已提交
3245 3246
		adapter->need_fw_reset = 1;
		set_bit(__QLCNIC_START_FW, &adapter->state);
3247 3248
		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
				    QLCNIC_DEV_INITIALIZING);
S
Sucheta Chakraborty 已提交
3249 3250 3251 3252
		QLCDB(adapter, DRV, "Restarting fw\n");
	}
	qlcnic_api_unlock(adapter);

S
Sony Chacko 已提交
3253
	err = qlcnic_start_firmware(adapter);
S
Sucheta Chakraborty 已提交
3254 3255 3256 3257
	if (err)
		return err;

	qlcnic_clr_drv_state(adapter);
S
Sony Chacko 已提交
3258 3259 3260 3261
	kfree(adapter->msix_entries);
	adapter->msix_entries = NULL;
	err = qlcnic_setup_intr(adapter, 0);

3262 3263 3264 3265 3266 3267
	if (err) {
		kfree(adapter->msix_entries);
		netdev_err(netdev, "failed to setup interrupt\n");
		return err;
	}

S
Sony Chacko 已提交
3268
	if (qlcnic_83xx_check(adapter)) {
3269 3270
		/* register for NIC IDC AEN Events */
		qlcnic_83xx_register_nic_idc_func(adapter, 1);
S
Sony Chacko 已提交
3271 3272 3273 3274 3275 3276 3277 3278 3279
		err = qlcnic_83xx_setup_mbx_intr(adapter);
		if (err) {
			dev_err(&adapter->pdev->dev,
				"failed to setup mbx interrupt\n");
			qlcnic_clr_all_drv_state(adapter, 1);
			clear_bit(__QLCNIC_AER, &adapter->state);
			goto done;
		}
	}
S
Sucheta Chakraborty 已提交
3280 3281 3282 3283

	if (netif_running(netdev)) {
		err = qlcnic_attach(adapter);
		if (err) {
3284
			qlcnic_clr_all_drv_state(adapter, 1);
S
Sucheta Chakraborty 已提交
3285 3286 3287 3288 3289 3290 3291 3292 3293
			clear_bit(__QLCNIC_AER, &adapter->state);
			netif_device_attach(netdev);
			return err;
		}

		err = qlcnic_up(adapter, netdev);
		if (err)
			goto done;

A
Amit Kumar Salecha 已提交
3294
		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
S
Sucheta Chakraborty 已提交
3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
	}
 done:
	netif_device_attach(netdev);
	return err;
}

static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
						pci_channel_state_t state)
{
	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
	struct net_device *netdev = adapter->netdev;

	if (state == pci_channel_io_perm_failure)
		return PCI_ERS_RESULT_DISCONNECT;

	if (state == pci_channel_io_normal)
		return PCI_ERS_RESULT_RECOVERED;

	set_bit(__QLCNIC_AER, &adapter->state);
	netif_device_detach(netdev);

	cancel_delayed_work_sync(&adapter->fw_work);

	if (netif_running(netdev))
		qlcnic_down(adapter, netdev);

S
Sony Chacko 已提交
3321 3322
	if (qlcnic_83xx_check(adapter)) {
		qlcnic_83xx_free_mbx_intr(adapter);
3323 3324
		qlcnic_83xx_register_nic_idc_func(adapter, 0);
		cancel_delayed_work_sync(&adapter->idc_aen_work);
S
Sony Chacko 已提交
3325 3326
	}

S
Sucheta Chakraborty 已提交
3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
	qlcnic_detach(adapter);
	qlcnic_teardown_intr(adapter);

	clear_bit(__QLCNIC_RESETTING, &adapter->state);

	pci_save_state(pdev);
	pci_disable_device(pdev);

	return PCI_ERS_RESULT_NEED_RESET;
}

static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
{
	return qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
				PCI_ERS_RESULT_RECOVERED;
}

static void qlcnic_io_resume(struct pci_dev *pdev)
{
3346
	u32 state;
S
Sucheta Chakraborty 已提交
3347 3348 3349
	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);

	pci_cleanup_aer_uncorrect_error_status(pdev);
3350 3351 3352
	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
	if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
							    &adapter->state))
S
Sucheta Chakraborty 已提交
3353 3354 3355 3356
		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
						FW_POLL_DELAY);
}

3357 3358 3359 3360 3361 3362 3363 3364 3365
static int
qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
{
	int err;

	err = qlcnic_can_start_firmware(adapter);
	if (err)
		return err;

A
Amit Kumar Salecha 已提交
3366 3367 3368
	err = qlcnic_check_npar_opertional(adapter);
	if (err)
		return err;
3369

3370 3371 3372 3373
	err = qlcnic_initialize_nic(adapter);
	if (err)
		return err;

3374 3375
	qlcnic_check_options(adapter);

3376 3377 3378 3379
	err = qlcnic_set_eswitch_port_config(adapter);
	if (err)
		return err;

3380 3381 3382 3383 3384
	adapter->need_fw_reset = 0;

	return err;
}

3385 3386
int qlcnic_validate_max_rss(struct qlcnic_adapter *adapter,
			    __u32 val)
3387
{
3388 3389
	struct net_device *netdev = adapter->netdev;
	u8 max_hw = adapter->ahw->max_rx_ques;
S
Sony Chacko 已提交
3390 3391
	u32 max_allowed;

3392 3393 3394 3395
	if (val > QLC_MAX_SDS_RINGS) {
		netdev_err(netdev, "RSS value should not be higher than %u\n",
			   QLC_MAX_SDS_RINGS);
		return -EINVAL;
3396 3397
	}

S
Sony Chacko 已提交
3398 3399 3400
	max_allowed = rounddown_pow_of_two(min_t(int, max_hw,
						 num_online_cpus()));
	if ((val > max_allowed) || (val < 2) || !is_power_of_2(val)) {
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418
		if (!is_power_of_2(val))
			netdev_err(netdev, "RSS value should be a power of 2\n");

		if (val < 2)
			netdev_err(netdev, "RSS value should not be lower than 2\n");

		if (val > max_hw)
			netdev_err(netdev,
				   "RSS value should not be higher than[%u], the max RSS rings supported by the adapter\n",
				   max_hw);

		if (val > num_online_cpus())
			netdev_err(netdev,
				   "RSS value should not be higher than[%u], number of online CPUs in the system\n",
				   num_online_cpus());

		netdev_err(netdev, "Unable to configure %u RSS rings\n", val);

3419 3420 3421 3422 3423
		return -EINVAL;
	}
	return 0;
}

S
Sony Chacko 已提交
3424
int qlcnic_set_max_rss(struct qlcnic_adapter *adapter, u8 data, size_t len)
3425
{
S
Sony Chacko 已提交
3426
	int err;
3427 3428
	struct net_device *netdev = adapter->netdev;

S
Sony Chacko 已提交
3429 3430 3431
	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
		return -EBUSY;

3432 3433 3434
	netif_device_detach(netdev);
	if (netif_running(netdev))
		__qlcnic_down(adapter, netdev);
S
Sony Chacko 已提交
3435

3436 3437
	qlcnic_detach(adapter);

3438
	if (qlcnic_83xx_check(adapter)) {
S
Sony Chacko 已提交
3439
		qlcnic_83xx_free_mbx_intr(adapter);
3440 3441
		qlcnic_83xx_enable_mbx_poll(adapter);
	}
S
Sony Chacko 已提交
3442

3443
	qlcnic_teardown_intr(adapter);
S
Sony Chacko 已提交
3444
	err = qlcnic_setup_intr(adapter, data);
3445 3446 3447 3448 3449
	if (err) {
		kfree(adapter->msix_entries);
		netdev_err(netdev, "failed to setup interrupt\n");
		return err;
	}
3450

S
Sony Chacko 已提交
3451
	if (qlcnic_83xx_check(adapter)) {
3452 3453
		/* register for NIC IDC AEN Events */
		qlcnic_83xx_register_nic_idc_func(adapter, 1);
S
Sony Chacko 已提交
3454
		err = qlcnic_83xx_setup_mbx_intr(adapter);
3455
		qlcnic_83xx_disable_mbx_poll(adapter);
S
Sony Chacko 已提交
3456 3457 3458 3459 3460
		if (err) {
			dev_err(&adapter->pdev->dev,
				"failed to setup mbx interrupt\n");
			goto done;
		}
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471
	}

	if (netif_running(netdev)) {
		err = qlcnic_attach(adapter);
		if (err)
			goto done;
		err = __qlcnic_up(adapter, netdev);
		if (err)
			goto done;
		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
	}
S
Sony Chacko 已提交
3472
	err = len;
3473 3474 3475 3476 3477 3478
 done:
	netif_device_attach(netdev);
	clear_bit(__QLCNIC_RESETTING, &adapter->state);
	return err;
}

3479 3480 3481 3482 3483
#ifdef CONFIG_INET

#define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)

static void
A
Amit Kumar Salecha 已提交
3484 3485
qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
			struct net_device *dev, unsigned long event)
3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510
{
	struct in_device *indev;

	indev = in_dev_get(dev);
	if (!indev)
		return;

	for_ifa(indev) {
		switch (event) {
		case NETDEV_UP:
			qlcnic_config_ipaddr(adapter,
					ifa->ifa_address, QLCNIC_IP_UP);
			break;
		case NETDEV_DOWN:
			qlcnic_config_ipaddr(adapter,
					ifa->ifa_address, QLCNIC_IP_DOWN);
			break;
		default:
			break;
		}
	} endfor_ifa(indev);

	in_dev_put(indev);
}

S
Sony Chacko 已提交
3511
void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
A
Amit Kumar Salecha 已提交
3512 3513 3514 3515 3516 3517 3518
{
	struct qlcnic_adapter *adapter = netdev_priv(netdev);
	struct net_device *dev;
	u16 vid;

	qlcnic_config_indev_addr(adapter, netdev, event);

3519
	rcu_read_lock();
3520
	for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
3521
		dev = __vlan_find_dev_deep(netdev, htons(ETH_P_8021Q), vid);
A
Amit Kumar Salecha 已提交
3522 3523 3524 3525
		if (!dev)
			continue;
		qlcnic_config_indev_addr(adapter, dev, event);
	}
3526
	rcu_read_unlock();
A
Amit Kumar Salecha 已提交
3527 3528
}

3529 3530 3531 3532
static int qlcnic_netdev_event(struct notifier_block *this,
				 unsigned long event, void *ptr)
{
	struct qlcnic_adapter *adapter;
3533
	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551

recheck:
	if (dev == NULL)
		goto done;

	if (dev->priv_flags & IFF_802_1Q_VLAN) {
		dev = vlan_dev_real_dev(dev);
		goto recheck;
	}

	if (!is_qlcnic_netdev(dev))
		goto done;

	adapter = netdev_priv(dev);

	if (!adapter)
		goto done;

3552
	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3553 3554
		goto done;

A
Amit Kumar Salecha 已提交
3555
	qlcnic_config_indev_addr(adapter, dev, event);
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571
done:
	return NOTIFY_DONE;
}

static int
qlcnic_inetaddr_event(struct notifier_block *this,
		unsigned long event, void *ptr)
{
	struct qlcnic_adapter *adapter;
	struct net_device *dev;

	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;

	dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;

recheck:
A
Amit Kumar Salecha 已提交
3572
	if (dev == NULL)
3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584
		goto done;

	if (dev->priv_flags & IFF_802_1Q_VLAN) {
		dev = vlan_dev_real_dev(dev);
		goto recheck;
	}

	if (!is_qlcnic_netdev(dev))
		goto done;

	adapter = netdev_priv(dev);

A
Amit Kumar Salecha 已提交
3585
	if (!adapter)
3586 3587
		goto done;

3588
	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
3589 3590 3591 3592 3593
		goto done;

	switch (event) {
	case NETDEV_UP:
		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
S
Sony Chacko 已提交
3594

3595 3596 3597
		break;
	case NETDEV_DOWN:
		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
S
Sony Chacko 已提交
3598

3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615
		break;
	default:
		break;
	}

done:
	return NOTIFY_DONE;
}

static struct notifier_block	qlcnic_netdev_cb = {
	.notifier_call = qlcnic_netdev_event,
};

static struct notifier_block qlcnic_inetaddr_cb = {
	.notifier_call = qlcnic_inetaddr_event,
};
#else
S
Sony Chacko 已提交
3616
void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
3617 3618
{ }
#endif
3619
static const struct pci_error_handlers qlcnic_err_handler = {
S
Sucheta Chakraborty 已提交
3620 3621 3622 3623
	.error_detected = qlcnic_io_error_detected,
	.slot_reset = qlcnic_io_slot_reset,
	.resume = qlcnic_io_resume,
};
3624 3625 3626 3627 3628

static struct pci_driver qlcnic_driver = {
	.name = qlcnic_driver_name,
	.id_table = qlcnic_pci_tbl,
	.probe = qlcnic_probe,
B
Bill Pemberton 已提交
3629
	.remove = qlcnic_remove,
3630 3631 3632 3633
#ifdef CONFIG_PM
	.suspend = qlcnic_suspend,
	.resume = qlcnic_resume,
#endif
S
Sucheta Chakraborty 已提交
3634
	.shutdown = qlcnic_shutdown,
3635 3636 3637 3638
	.err_handler = &qlcnic_err_handler,
#ifdef CONFIG_QLCNIC_SRIOV
	.sriov_configure = qlcnic_pci_sriov_configure,
#endif
S
Sucheta Chakraborty 已提交
3639

3640 3641 3642 3643
};

static int __init qlcnic_init_module(void)
{
3644
	int ret;
3645 3646 3647 3648 3649 3650 3651 3652

	printk(KERN_INFO "%s\n", qlcnic_driver_string);

#ifdef CONFIG_INET
	register_netdevice_notifier(&qlcnic_netdev_cb);
	register_inetaddr_notifier(&qlcnic_inetaddr_cb);
#endif

3653 3654 3655 3656 3657 3658 3659
	ret = pci_register_driver(&qlcnic_driver);
	if (ret) {
#ifdef CONFIG_INET
		unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
		unregister_netdevice_notifier(&qlcnic_netdev_cb);
#endif
	}
3660

3661
	return ret;
3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676
}

module_init(qlcnic_init_module);

static void __exit qlcnic_exit_module(void)
{
	pci_unregister_driver(&qlcnic_driver);

#ifdef CONFIG_INET
	unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
	unregister_netdevice_notifier(&qlcnic_netdev_cb);
#endif
}

module_exit(qlcnic_exit_module);