1 /*
2  * QLogic qlcnic NIC Driver
3  * Copyright (c) 2009-2013 QLogic Corporation
4  *
5  * See LICENSE.qlcnic for copyright and licensing details.
6  */
7 
8 #include <linux/vmalloc.h>
9 #include <linux/interrupt.h>
10 #include <linux/swab.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/if_vlan.h>
13 #include <net/ip.h>
14 #include <linux/ipv6.h>
15 #include <linux/inetdevice.h>
16 #include <linux/aer.h>
17 #include <linux/log2.h>
18 #include <linux/pci.h>
19 #include <net/vxlan.h>
20 
21 #include "qlcnic.h"
22 #include "qlcnic_sriov.h"
23 #include "qlcnic_hw.h"
24 
25 MODULE_DESCRIPTION("QLogic 1/10 GbE Converged/Intelligent Ethernet Driver");
26 MODULE_LICENSE("GPL");
27 MODULE_VERSION(QLCNIC_LINUX_VERSIONID);
28 MODULE_FIRMWARE(QLCNIC_UNIFIED_ROMIMAGE_NAME);
29 
30 char qlcnic_driver_name[] = "qlcnic";
31 static const char qlcnic_driver_string[] = "QLogic 1/10 GbE "
32 	"Converged/Intelligent Ethernet Driver v" QLCNIC_LINUX_VERSIONID;
33 
34 static int qlcnic_mac_learn;
35 module_param(qlcnic_mac_learn, int, 0444);
36 MODULE_PARM_DESC(qlcnic_mac_learn,
37 		 "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, 2=POST in fast mode, 3= POST in medium mode, 4=POST in slow mode)");
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);
56 static void qlcnic_remove(struct pci_dev *pdev);
57 static int qlcnic_open(struct net_device *netdev);
58 static int qlcnic_close(struct net_device *netdev);
59 static void qlcnic_tx_timeout(struct net_device *netdev, unsigned int txqueue);
60 static void qlcnic_attach_work(struct work_struct *work);
61 static void qlcnic_fwinit_work(struct work_struct *work);
62 
63 static void qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding);
64 static int qlcnic_can_start_firmware(struct qlcnic_adapter *adapter);
65 
66 static irqreturn_t qlcnic_tmp_intr(int irq, void *data);
67 static irqreturn_t qlcnic_intr(int irq, void *data);
68 static irqreturn_t qlcnic_msi_intr(int irq, void *data);
69 static irqreturn_t qlcnic_msix_intr(int irq, void *data);
70 static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data);
71 
72 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev);
73 static int qlcnic_start_firmware(struct qlcnic_adapter *);
74 
75 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter);
76 static void qlcnic_dev_set_npar_ready(struct qlcnic_adapter *);
77 static int qlcnicvf_start_firmware(struct qlcnic_adapter *);
78 static int qlcnic_vlan_rx_add(struct net_device *, __be16, u16);
79 static int qlcnic_vlan_rx_del(struct net_device *, __be16, u16);
80 
81 static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *);
82 static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *, u32);
83 static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *);
84 static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *);
85 static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *);
86 static void qlcnic_82xx_io_resume(struct pci_dev *);
87 static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *);
88 static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *,
89 						      pci_channel_state_t);
90 static u32 qlcnic_vlan_tx_check(struct qlcnic_adapter *adapter)
91 {
92 	struct qlcnic_hardware_context *ahw = adapter->ahw;
93 
94 	if (adapter->pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X)
95 		return ahw->capabilities & QLCNIC_FW_CAPABILITY_FVLANTX;
96 	else
97 		return 1;
98 }
99 
100 /*  PCI Device ID Table  */
101 #define ENTRY(device) \
102 	{PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, (device)), \
103 	.class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
104 
105 static const struct pci_device_id qlcnic_pci_tbl[] = {
106 	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE824X),
107 	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE834X),
108 	ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE834X),
109 	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE8830),
110 	ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE8C30),
111 	ENTRY(PCI_DEVICE_ID_QLOGIC_QLE844X),
112 	ENTRY(PCI_DEVICE_ID_QLOGIC_VF_QLE844X),
113 	{0,}
114 };
115 
116 MODULE_DEVICE_TABLE(pci, qlcnic_pci_tbl);
117 
118 
119 inline void qlcnic_update_cmd_producer(struct qlcnic_host_tx_ring *tx_ring)
120 {
121 	writel(tx_ring->producer, tx_ring->crb_cmd_producer);
122 }
123 
124 static const u32 msi_tgt_status[8] = {
125 	ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
126 	ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
127 	ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
128 	ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
129 };
130 
131 static const u32 qlcnic_reg_tbl[] = {
132 	0x1B20A8,	/* PEG_HALT_STAT1 */
133 	0x1B20AC,	/* PEG_HALT_STAT2 */
134 	0x1B20B0,	/* FW_HEARTBEAT */
135 	0x1B2100,	/* LOCK ID */
136 	0x1B2128,	/* FW_CAPABILITIES */
137 	0x1B2138,	/* drv active */
138 	0x1B2140,	/* dev state */
139 	0x1B2144,	/* drv state */
140 	0x1B2148,	/* drv scratch */
141 	0x1B214C,	/* dev partition info */
142 	0x1B2174,	/* drv idc ver */
143 	0x1B2150,	/* fw version major */
144 	0x1B2154,	/* fw version minor */
145 	0x1B2158,	/* fw version sub */
146 	0x1B219C,	/* npar state */
147 	0x1B21FC,	/* FW_IMG_VALID */
148 	0x1B2250,	/* CMD_PEG_STATE */
149 	0x1B233C,	/* RCV_PEG_STATE */
150 	0x1B23B4,	/* ASIC TEMP */
151 	0x1B216C,	/* FW api */
152 	0x1B2170,	/* drv op mode */
153 	0x13C010,	/* flash lock */
154 	0x13C014,	/* flash unlock */
155 };
156 
157 static const struct qlcnic_board_info qlcnic_boards[] = {
158 	{ PCI_VENDOR_ID_QLOGIC,
159 	  PCI_DEVICE_ID_QLOGIC_QLE844X,
160 	  0x0,
161 	  0x0,
162 	  "8400 series 10GbE Converged Network Adapter (TCP/IP Networking)" },
163 	{ PCI_VENDOR_ID_QLOGIC,
164 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
165 	  PCI_VENDOR_ID_QLOGIC,
166 	  0x24e,
167 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
168 	  "(TCP/IP Networking)" },
169 	{ PCI_VENDOR_ID_QLOGIC,
170 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
171 	  PCI_VENDOR_ID_QLOGIC,
172 	  0x243,
173 	  "8300 Series Single Port 10GbE Converged Network Adapter "
174 	  "(TCP/IP Networking)" },
175 	{ PCI_VENDOR_ID_QLOGIC,
176 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
177 	  PCI_VENDOR_ID_QLOGIC,
178 	  0x24a,
179 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
180 	  "(TCP/IP Networking)" },
181 	{ PCI_VENDOR_ID_QLOGIC,
182 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
183 	  PCI_VENDOR_ID_QLOGIC,
184 	  0x246,
185 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
186 	  "(TCP/IP Networking)" },
187 	{ PCI_VENDOR_ID_QLOGIC,
188 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
189 	  PCI_VENDOR_ID_QLOGIC,
190 	  0x252,
191 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
192 	  "(TCP/IP Networking)" },
193 	{ PCI_VENDOR_ID_QLOGIC,
194 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
195 	  PCI_VENDOR_ID_QLOGIC,
196 	  0x26e,
197 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
198 	  "(TCP/IP Networking)" },
199 	{ PCI_VENDOR_ID_QLOGIC,
200 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
201 	  PCI_VENDOR_ID_QLOGIC,
202 	  0x260,
203 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
204 	  "(TCP/IP Networking)" },
205 	{ PCI_VENDOR_ID_QLOGIC,
206 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
207 	  PCI_VENDOR_ID_QLOGIC,
208 	  0x266,
209 	  "8300 Series Single Port 10GbE Converged Network Adapter "
210 	  "(TCP/IP Networking)" },
211 	{ PCI_VENDOR_ID_QLOGIC,
212 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
213 	  PCI_VENDOR_ID_QLOGIC,
214 	  0x269,
215 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
216 	  "(TCP/IP Networking)" },
217 	{ PCI_VENDOR_ID_QLOGIC,
218 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
219 	  PCI_VENDOR_ID_QLOGIC,
220 	  0x271,
221 	  "8300 Series Dual Port 10GbE Converged Network Adapter "
222 	  "(TCP/IP Networking)" },
223 	{ PCI_VENDOR_ID_QLOGIC,
224 	  PCI_DEVICE_ID_QLOGIC_QLE834X,
225 	  0x0, 0x0, "8300 Series 1/10GbE Controller" },
226 	{ PCI_VENDOR_ID_QLOGIC,
227 	  PCI_DEVICE_ID_QLOGIC_QLE8830,
228 	  0x0,
229 	  0x0,
230 	  "8830 Series 1/10GbE Controller" },
231 	{ PCI_VENDOR_ID_QLOGIC,
232 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
233 	  PCI_VENDOR_ID_QLOGIC,
234 	  0x203,
235 	  "8200 Series Single Port 10GbE Converged Network Adapter"
236 	  "(TCP/IP Networking)" },
237 	{ PCI_VENDOR_ID_QLOGIC,
238 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
239 	  PCI_VENDOR_ID_QLOGIC,
240 	  0x207,
241 	  "8200 Series Dual Port 10GbE Converged Network Adapter"
242 	  "(TCP/IP Networking)" },
243 	{ PCI_VENDOR_ID_QLOGIC,
244 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
245 	  PCI_VENDOR_ID_QLOGIC,
246 	  0x20b,
247 	  "3200 Series Dual Port 10Gb Intelligent Ethernet Adapter" },
248 	{ PCI_VENDOR_ID_QLOGIC,
249 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
250 	  PCI_VENDOR_ID_QLOGIC,
251 	  0x20c,
252 	  "3200 Series Quad Port 1Gb Intelligent Ethernet Adapter" },
253 	{ PCI_VENDOR_ID_QLOGIC,
254 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
255 	  PCI_VENDOR_ID_QLOGIC,
256 	  0x20f,
257 	  "3200 Series Single Port 10Gb Intelligent Ethernet Adapter" },
258 	{ PCI_VENDOR_ID_QLOGIC,
259 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
260 	  0x103c, 0x3733,
261 	  "NC523SFP 10Gb 2-port Server Adapter" },
262 	{ PCI_VENDOR_ID_QLOGIC,
263 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
264 	  0x103c, 0x3346,
265 	  "CN1000Q Dual Port Converged Network Adapter" },
266 	{ PCI_VENDOR_ID_QLOGIC,
267 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
268 	  PCI_VENDOR_ID_QLOGIC,
269 	  0x210,
270 	  "QME8242-k 10GbE Dual Port Mezzanine Card" },
271 	{ PCI_VENDOR_ID_QLOGIC,
272 	  PCI_DEVICE_ID_QLOGIC_QLE824X,
273 	  0x0, 0x0, "cLOM8214 1/10GbE Controller" },
274 };
275 
276 #define NUM_SUPPORTED_BOARDS ARRAY_SIZE(qlcnic_boards)
277 
278 static const
279 struct qlcnic_legacy_intr_set legacy_intr[] = QLCNIC_LEGACY_INTR_CONFIG;
280 
281 int qlcnic_alloc_sds_rings(struct qlcnic_recv_context *recv_ctx, int count)
282 {
283 	int size = sizeof(struct qlcnic_host_sds_ring) * count;
284 
285 	recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
286 
287 	return recv_ctx->sds_rings == NULL;
288 }
289 
290 void qlcnic_free_sds_rings(struct qlcnic_recv_context *recv_ctx)
291 {
292 	kfree(recv_ctx->sds_rings);
293 	recv_ctx->sds_rings = NULL;
294 }
295 
296 int qlcnic_read_mac_addr(struct qlcnic_adapter *adapter)
297 {
298 	struct net_device *netdev = adapter->netdev;
299 	struct pci_dev *pdev = adapter->pdev;
300 	u8 mac_addr[ETH_ALEN];
301 	int ret;
302 
303 	ret = qlcnic_get_mac_address(adapter, mac_addr,
304 				     adapter->ahw->pci_func);
305 	if (ret)
306 		return ret;
307 
308 	memcpy(netdev->dev_addr, mac_addr, ETH_ALEN);
309 	memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
310 
311 	/* set station address */
312 
313 	if (!is_valid_ether_addr(netdev->dev_addr))
314 		dev_warn(&pdev->dev, "Bad MAC address %pM.\n",
315 					netdev->dev_addr);
316 
317 	return 0;
318 }
319 
320 static void qlcnic_delete_adapter_mac(struct qlcnic_adapter *adapter)
321 {
322 	struct qlcnic_mac_vlan_list *cur;
323 	struct list_head *head;
324 
325 	list_for_each(head, &adapter->mac_list) {
326 		cur = list_entry(head, struct qlcnic_mac_vlan_list, list);
327 		if (ether_addr_equal_unaligned(adapter->mac_addr, cur->mac_addr)) {
328 			qlcnic_sre_macaddr_change(adapter, cur->mac_addr,
329 						  0, QLCNIC_MAC_DEL);
330 			list_del(&cur->list);
331 			kfree(cur);
332 			return;
333 		}
334 	}
335 }
336 
337 static int qlcnic_set_mac(struct net_device *netdev, void *p)
338 {
339 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
340 	struct sockaddr *addr = p;
341 
342 	if (qlcnic_sriov_vf_check(adapter))
343 		return -EINVAL;
344 
345 	if ((adapter->flags & QLCNIC_MAC_OVERRIDE_DISABLED))
346 		return -EOPNOTSUPP;
347 
348 	if (!is_valid_ether_addr(addr->sa_data))
349 		return -EINVAL;
350 
351 	if (ether_addr_equal_unaligned(adapter->mac_addr, addr->sa_data) &&
352 	    ether_addr_equal_unaligned(netdev->dev_addr, addr->sa_data))
353 		return 0;
354 
355 	if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
356 		netif_device_detach(netdev);
357 		qlcnic_napi_disable(adapter);
358 	}
359 
360 	qlcnic_delete_adapter_mac(adapter);
361 	memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
362 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
363 	qlcnic_set_multi(adapter->netdev);
364 
365 	if (test_bit(__QLCNIC_DEV_UP, &adapter->state)) {
366 		netif_device_attach(netdev);
367 		qlcnic_napi_enable(adapter);
368 	}
369 	return 0;
370 }
371 
372 static int qlcnic_fdb_del(struct ndmsg *ndm, struct nlattr *tb[],
373 			struct net_device *netdev,
374 			const unsigned char *addr, u16 vid)
375 {
376 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
377 	int err = -EOPNOTSUPP;
378 
379 	if (!adapter->fdb_mac_learn)
380 		return ndo_dflt_fdb_del(ndm, tb, netdev, addr, vid);
381 
382 	if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
383 	    qlcnic_sriov_check(adapter)) {
384 		if (is_unicast_ether_addr(addr)) {
385 			err = dev_uc_del(netdev, addr);
386 			if (!err)
387 				err = qlcnic_nic_del_mac(adapter, addr);
388 		} else if (is_multicast_ether_addr(addr)) {
389 			err = dev_mc_del(netdev, addr);
390 		} else {
391 			err =  -EINVAL;
392 		}
393 	}
394 	return err;
395 }
396 
397 static int qlcnic_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
398 			struct net_device *netdev,
399 			const unsigned char *addr, u16 vid, u16 flags,
400 			struct netlink_ext_ack *extack)
401 {
402 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
403 	int err = 0;
404 
405 	if (!adapter->fdb_mac_learn)
406 		return ndo_dflt_fdb_add(ndm, tb, netdev, addr, vid, flags);
407 
408 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) &&
409 	    !qlcnic_sriov_check(adapter)) {
410 		pr_info("%s: FDB e-switch is not enabled\n", __func__);
411 		return -EOPNOTSUPP;
412 	}
413 
414 	if (ether_addr_equal(addr, adapter->mac_addr))
415 		return err;
416 
417 	if (is_unicast_ether_addr(addr)) {
418 		if (netdev_uc_count(netdev) < adapter->ahw->max_uc_count)
419 			err = dev_uc_add_excl(netdev, addr);
420 		else
421 			err = -ENOMEM;
422 	} else if (is_multicast_ether_addr(addr)) {
423 		err = dev_mc_add_excl(netdev, addr);
424 	} else {
425 		err = -EINVAL;
426 	}
427 
428 	return err;
429 }
430 
431 static int qlcnic_fdb_dump(struct sk_buff *skb, struct netlink_callback *ncb,
432 			struct net_device *netdev,
433 			struct net_device *filter_dev, int *idx)
434 {
435 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
436 	int err = 0;
437 
438 	if (!adapter->fdb_mac_learn)
439 		return ndo_dflt_fdb_dump(skb, ncb, netdev, filter_dev, idx);
440 
441 	if ((adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
442 	    qlcnic_sriov_check(adapter))
443 		err = ndo_dflt_fdb_dump(skb, ncb, netdev, filter_dev, idx);
444 
445 	return err;
446 }
447 
448 static void qlcnic_82xx_cancel_idc_work(struct qlcnic_adapter *adapter)
449 {
450 	while (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
451 		usleep_range(10000, 11000);
452 
453 	if (!adapter->fw_work.work.func)
454 		return;
455 
456 	cancel_delayed_work_sync(&adapter->fw_work);
457 }
458 
459 static int qlcnic_get_phys_port_id(struct net_device *netdev,
460 				   struct netdev_phys_item_id *ppid)
461 {
462 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
463 	struct qlcnic_hardware_context *ahw = adapter->ahw;
464 
465 	if (!(adapter->flags & QLCNIC_HAS_PHYS_PORT_ID))
466 		return -EOPNOTSUPP;
467 
468 	ppid->id_len = sizeof(ahw->phys_port_id);
469 	memcpy(ppid->id, ahw->phys_port_id, ppid->id_len);
470 
471 	return 0;
472 }
473 
474 static void qlcnic_add_vxlan_port(struct net_device *netdev,
475 				  struct udp_tunnel_info *ti)
476 {
477 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
478 	struct qlcnic_hardware_context *ahw = adapter->ahw;
479 
480 	if (ti->type != UDP_TUNNEL_TYPE_VXLAN)
481 		return;
482 
483 	/* Adapter supports only one VXLAN port. Use very first port
484 	 * for enabling offload
485 	 */
486 	if (!qlcnic_encap_rx_offload(adapter))
487 		return;
488 	if (!ahw->vxlan_port_count) {
489 		ahw->vxlan_port_count = 1;
490 		ahw->vxlan_port = ntohs(ti->port);
491 		adapter->flags |= QLCNIC_ADD_VXLAN_PORT;
492 		return;
493 	}
494 	if (ahw->vxlan_port == ntohs(ti->port))
495 		ahw->vxlan_port_count++;
496 
497 }
498 
499 static void qlcnic_del_vxlan_port(struct net_device *netdev,
500 				  struct udp_tunnel_info *ti)
501 {
502 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
503 	struct qlcnic_hardware_context *ahw = adapter->ahw;
504 
505 	if (ti->type != UDP_TUNNEL_TYPE_VXLAN)
506 		return;
507 
508 	if (!qlcnic_encap_rx_offload(adapter) || !ahw->vxlan_port_count ||
509 	    (ahw->vxlan_port != ntohs(ti->port)))
510 		return;
511 
512 	ahw->vxlan_port_count--;
513 	if (!ahw->vxlan_port_count)
514 		adapter->flags |= QLCNIC_DEL_VXLAN_PORT;
515 }
516 
517 static netdev_features_t qlcnic_features_check(struct sk_buff *skb,
518 					       struct net_device *dev,
519 					       netdev_features_t features)
520 {
521 	features = vlan_features_check(skb, features);
522 	return vxlan_features_check(skb, features);
523 }
524 
525 static const struct net_device_ops qlcnic_netdev_ops = {
526 	.ndo_open	   = qlcnic_open,
527 	.ndo_stop	   = qlcnic_close,
528 	.ndo_start_xmit    = qlcnic_xmit_frame,
529 	.ndo_get_stats	   = qlcnic_get_stats,
530 	.ndo_validate_addr = eth_validate_addr,
531 	.ndo_set_rx_mode   = qlcnic_set_multi,
532 	.ndo_set_mac_address    = qlcnic_set_mac,
533 	.ndo_change_mtu	   = qlcnic_change_mtu,
534 	.ndo_fix_features  = qlcnic_fix_features,
535 	.ndo_set_features  = qlcnic_set_features,
536 	.ndo_tx_timeout	   = qlcnic_tx_timeout,
537 	.ndo_vlan_rx_add_vid	= qlcnic_vlan_rx_add,
538 	.ndo_vlan_rx_kill_vid	= qlcnic_vlan_rx_del,
539 	.ndo_fdb_add		= qlcnic_fdb_add,
540 	.ndo_fdb_del		= qlcnic_fdb_del,
541 	.ndo_fdb_dump		= qlcnic_fdb_dump,
542 	.ndo_get_phys_port_id	= qlcnic_get_phys_port_id,
543 	.ndo_udp_tunnel_add	= qlcnic_add_vxlan_port,
544 	.ndo_udp_tunnel_del	= qlcnic_del_vxlan_port,
545 	.ndo_features_check	= qlcnic_features_check,
546 #ifdef CONFIG_QLCNIC_SRIOV
547 	.ndo_set_vf_mac		= qlcnic_sriov_set_vf_mac,
548 	.ndo_set_vf_rate	= qlcnic_sriov_set_vf_tx_rate,
549 	.ndo_get_vf_config	= qlcnic_sriov_get_vf_config,
550 	.ndo_set_vf_vlan	= qlcnic_sriov_set_vf_vlan,
551 	.ndo_set_vf_spoofchk	= qlcnic_sriov_set_vf_spoofchk,
552 #endif
553 };
554 
555 static const struct net_device_ops qlcnic_netdev_failed_ops = {
556 	.ndo_open	   = qlcnic_open,
557 };
558 
559 static struct qlcnic_nic_template qlcnic_ops = {
560 	.config_bridged_mode	= qlcnic_config_bridged_mode,
561 	.config_led		= qlcnic_82xx_config_led,
562 	.start_firmware		= qlcnic_82xx_start_firmware,
563 	.request_reset		= qlcnic_82xx_dev_request_reset,
564 	.cancel_idc_work	= qlcnic_82xx_cancel_idc_work,
565 	.napi_add		= qlcnic_82xx_napi_add,
566 	.napi_del		= qlcnic_82xx_napi_del,
567 	.config_ipaddr		= qlcnic_82xx_config_ipaddr,
568 	.shutdown		= qlcnic_82xx_shutdown,
569 	.resume			= qlcnic_82xx_resume,
570 	.clear_legacy_intr	= qlcnic_82xx_clear_legacy_intr,
571 };
572 
573 struct qlcnic_nic_template qlcnic_vf_ops = {
574 	.config_bridged_mode	= qlcnicvf_config_bridged_mode,
575 	.config_led		= qlcnicvf_config_led,
576 	.start_firmware		= qlcnicvf_start_firmware
577 };
578 
579 static struct qlcnic_hardware_ops qlcnic_hw_ops = {
580 	.read_crb			= qlcnic_82xx_read_crb,
581 	.write_crb			= qlcnic_82xx_write_crb,
582 	.read_reg			= qlcnic_82xx_hw_read_wx_2M,
583 	.write_reg			= qlcnic_82xx_hw_write_wx_2M,
584 	.get_mac_address		= qlcnic_82xx_get_mac_address,
585 	.setup_intr			= qlcnic_82xx_setup_intr,
586 	.alloc_mbx_args			= qlcnic_82xx_alloc_mbx_args,
587 	.mbx_cmd			= qlcnic_82xx_issue_cmd,
588 	.get_func_no			= qlcnic_82xx_get_func_no,
589 	.api_lock			= qlcnic_82xx_api_lock,
590 	.api_unlock			= qlcnic_82xx_api_unlock,
591 	.add_sysfs			= qlcnic_82xx_add_sysfs,
592 	.remove_sysfs			= qlcnic_82xx_remove_sysfs,
593 	.process_lb_rcv_ring_diag	= qlcnic_82xx_process_rcv_ring_diag,
594 	.create_rx_ctx			= qlcnic_82xx_fw_cmd_create_rx_ctx,
595 	.create_tx_ctx			= qlcnic_82xx_fw_cmd_create_tx_ctx,
596 	.del_rx_ctx			= qlcnic_82xx_fw_cmd_del_rx_ctx,
597 	.del_tx_ctx			= qlcnic_82xx_fw_cmd_del_tx_ctx,
598 	.setup_link_event		= qlcnic_82xx_linkevent_request,
599 	.get_nic_info			= qlcnic_82xx_get_nic_info,
600 	.get_pci_info			= qlcnic_82xx_get_pci_info,
601 	.set_nic_info			= qlcnic_82xx_set_nic_info,
602 	.change_macvlan			= qlcnic_82xx_sre_macaddr_change,
603 	.napi_enable			= qlcnic_82xx_napi_enable,
604 	.napi_disable			= qlcnic_82xx_napi_disable,
605 	.config_intr_coal		= qlcnic_82xx_config_intr_coalesce,
606 	.config_rss			= qlcnic_82xx_config_rss,
607 	.config_hw_lro			= qlcnic_82xx_config_hw_lro,
608 	.config_loopback		= qlcnic_82xx_set_lb_mode,
609 	.clear_loopback			= qlcnic_82xx_clear_lb_mode,
610 	.config_promisc_mode		= qlcnic_82xx_nic_set_promisc,
611 	.change_l2_filter		= qlcnic_82xx_change_filter,
612 	.get_board_info			= qlcnic_82xx_get_board_info,
613 	.set_mac_filter_count		= qlcnic_82xx_set_mac_filter_count,
614 	.free_mac_list			= qlcnic_82xx_free_mac_list,
615 	.read_phys_port_id		= qlcnic_82xx_read_phys_port_id,
616 	.io_error_detected		= qlcnic_82xx_io_error_detected,
617 	.io_slot_reset			= qlcnic_82xx_io_slot_reset,
618 	.io_resume			= qlcnic_82xx_io_resume,
619 	.get_beacon_state		= qlcnic_82xx_get_beacon_state,
620 	.enable_sds_intr		= qlcnic_82xx_enable_sds_intr,
621 	.disable_sds_intr		= qlcnic_82xx_disable_sds_intr,
622 	.enable_tx_intr			= qlcnic_82xx_enable_tx_intr,
623 	.disable_tx_intr		= qlcnic_82xx_disable_tx_intr,
624 	.get_saved_state		= qlcnic_82xx_get_saved_state,
625 	.set_saved_state		= qlcnic_82xx_set_saved_state,
626 	.cache_tmpl_hdr_values		= qlcnic_82xx_cache_tmpl_hdr_values,
627 	.get_cap_size			= qlcnic_82xx_get_cap_size,
628 	.set_sys_info			= qlcnic_82xx_set_sys_info,
629 	.store_cap_mask			= qlcnic_82xx_store_cap_mask,
630 	.encap_rx_offload               = qlcnic_82xx_encap_rx_offload,
631 	.encap_tx_offload               = qlcnic_82xx_encap_tx_offload,
632 };
633 
634 static int qlcnic_check_multi_tx_capability(struct qlcnic_adapter *adapter)
635 {
636 	struct qlcnic_hardware_context *ahw = adapter->ahw;
637 
638 	if (qlcnic_82xx_check(adapter) &&
639 	    (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_2_MULTI_TX)) {
640 		test_and_set_bit(__QLCNIC_MULTI_TX_UNIQUE, &adapter->state);
641 		return 0;
642 	} else {
643 		return 1;
644 	}
645 }
646 
647 static int qlcnic_max_rings(struct qlcnic_adapter *adapter, u8 ring_cnt,
648 			    int queue_type)
649 {
650 	int num_rings, max_rings = QLCNIC_MAX_SDS_RINGS;
651 
652 	if (queue_type == QLCNIC_RX_QUEUE)
653 		max_rings = adapter->max_sds_rings;
654 	else if (queue_type == QLCNIC_TX_QUEUE)
655 		max_rings = adapter->max_tx_rings;
656 
657 	num_rings = rounddown_pow_of_two(min_t(int, num_online_cpus(),
658 					      max_rings));
659 
660 	if (ring_cnt > num_rings)
661 		return num_rings;
662 	else
663 		return ring_cnt;
664 }
665 
666 void qlcnic_set_tx_ring_count(struct qlcnic_adapter *adapter, u8 tx_cnt)
667 {
668 	/* 83xx adapter does not have max_tx_rings intialized in probe */
669 	if (adapter->max_tx_rings)
670 		adapter->drv_tx_rings = qlcnic_max_rings(adapter, tx_cnt,
671 							 QLCNIC_TX_QUEUE);
672 	else
673 		adapter->drv_tx_rings = tx_cnt;
674 }
675 
676 void qlcnic_set_sds_ring_count(struct qlcnic_adapter *adapter, u8 rx_cnt)
677 {
678 	/* 83xx adapter does not have max_sds_rings intialized in probe */
679 	if (adapter->max_sds_rings)
680 		adapter->drv_sds_rings = qlcnic_max_rings(adapter, rx_cnt,
681 							  QLCNIC_RX_QUEUE);
682 	else
683 		adapter->drv_sds_rings = rx_cnt;
684 }
685 
686 int qlcnic_setup_tss_rss_intr(struct qlcnic_adapter *adapter)
687 {
688 	struct pci_dev *pdev = adapter->pdev;
689 	int num_msix = 0, err = 0, vector;
690 
691 	adapter->flags &= ~QLCNIC_TSS_RSS;
692 
693 	if (adapter->drv_tss_rings > 0)
694 		num_msix += adapter->drv_tss_rings;
695 	else
696 		num_msix += adapter->drv_tx_rings;
697 
698 	if (adapter->drv_rss_rings > 0)
699 		num_msix += adapter->drv_rss_rings;
700 	else
701 		num_msix += adapter->drv_sds_rings;
702 
703 	if (qlcnic_83xx_check(adapter))
704 		num_msix += 1;
705 
706 	if (!adapter->msix_entries) {
707 		adapter->msix_entries = kcalloc(num_msix,
708 						sizeof(struct msix_entry),
709 						GFP_KERNEL);
710 		if (!adapter->msix_entries)
711 			return -ENOMEM;
712 	}
713 
714 	for (vector = 0; vector < num_msix; vector++)
715 		adapter->msix_entries[vector].entry = vector;
716 
717 restore:
718 	err = pci_enable_msix_exact(pdev, adapter->msix_entries, num_msix);
719 	if (err == -ENOSPC) {
720 		if (!adapter->drv_tss_rings && !adapter->drv_rss_rings)
721 			return err;
722 
723 		netdev_info(adapter->netdev,
724 			    "Unable to allocate %d MSI-X vectors, Available vectors %d\n",
725 			    num_msix, err);
726 
727 		num_msix = adapter->drv_tx_rings + adapter->drv_sds_rings;
728 
729 		/* Set rings to 0 so we can restore original TSS/RSS count */
730 		adapter->drv_tss_rings = 0;
731 		adapter->drv_rss_rings = 0;
732 
733 		if (qlcnic_83xx_check(adapter))
734 			num_msix += 1;
735 
736 		netdev_info(adapter->netdev,
737 			    "Restoring %d Tx, %d SDS rings for total %d vectors.\n",
738 			    adapter->drv_tx_rings, adapter->drv_sds_rings,
739 			    num_msix);
740 
741 		goto restore;
742 	} else if (err < 0) {
743 		return err;
744 	}
745 
746 	adapter->ahw->num_msix = num_msix;
747 	if (adapter->drv_tss_rings > 0)
748 		adapter->drv_tx_rings = adapter->drv_tss_rings;
749 
750 	if (adapter->drv_rss_rings > 0)
751 		adapter->drv_sds_rings = adapter->drv_rss_rings;
752 
753 	return 0;
754 }
755 
756 int qlcnic_enable_msix(struct qlcnic_adapter *adapter, u32 num_msix)
757 {
758 	struct pci_dev *pdev = adapter->pdev;
759 	int err, vector;
760 
761 	if (!adapter->msix_entries) {
762 		adapter->msix_entries = kcalloc(num_msix,
763 						sizeof(struct msix_entry),
764 						GFP_KERNEL);
765 		if (!adapter->msix_entries)
766 			return -ENOMEM;
767 	}
768 
769 	adapter->flags &= ~(QLCNIC_MSI_ENABLED | QLCNIC_MSIX_ENABLED);
770 
771 	if (adapter->ahw->msix_supported) {
772 enable_msix:
773 		for (vector = 0; vector < num_msix; vector++)
774 			adapter->msix_entries[vector].entry = vector;
775 
776 		err = pci_enable_msix_range(pdev,
777 					    adapter->msix_entries, 1, num_msix);
778 
779 		if (err == num_msix) {
780 			adapter->flags |= QLCNIC_MSIX_ENABLED;
781 			adapter->ahw->num_msix = num_msix;
782 			dev_info(&pdev->dev, "using msi-x interrupts\n");
783 			return 0;
784 		} else if (err > 0) {
785 			pci_disable_msix(pdev);
786 
787 			dev_info(&pdev->dev,
788 				 "Unable to allocate %d MSI-X vectors, Available vectors %d\n",
789 				 num_msix, err);
790 
791 			if (qlcnic_82xx_check(adapter)) {
792 				num_msix = rounddown_pow_of_two(err);
793 				if (err < QLCNIC_82XX_MINIMUM_VECTOR)
794 					return -ENOSPC;
795 			} else {
796 				num_msix = rounddown_pow_of_two(err - 1);
797 				num_msix += 1;
798 				if (err < QLCNIC_83XX_MINIMUM_VECTOR)
799 					return -ENOSPC;
800 			}
801 
802 			if (qlcnic_82xx_check(adapter) &&
803 			    !qlcnic_check_multi_tx(adapter)) {
804 				adapter->drv_sds_rings = num_msix;
805 				adapter->drv_tx_rings = QLCNIC_SINGLE_RING;
806 			} else {
807 				/* Distribute vectors equally */
808 				adapter->drv_tx_rings = num_msix / 2;
809 				adapter->drv_sds_rings = adapter->drv_tx_rings;
810 			}
811 
812 			if (num_msix) {
813 				dev_info(&pdev->dev,
814 					 "Trying to allocate %d MSI-X interrupt vectors\n",
815 					 num_msix);
816 				goto enable_msix;
817 			}
818 		} else {
819 			dev_info(&pdev->dev,
820 				 "Unable to allocate %d MSI-X vectors, err=%d\n",
821 				 num_msix, err);
822 			return err;
823 		}
824 	}
825 
826 	return -EIO;
827 }
828 
829 static int qlcnic_82xx_calculate_msix_vector(struct qlcnic_adapter *adapter)
830 {
831 	int num_msix;
832 
833 	num_msix = adapter->drv_sds_rings;
834 
835 	if (qlcnic_check_multi_tx(adapter))
836 		num_msix += adapter->drv_tx_rings;
837 	else
838 		num_msix += QLCNIC_SINGLE_RING;
839 
840 	return num_msix;
841 }
842 
843 static int qlcnic_enable_msi_legacy(struct qlcnic_adapter *adapter)
844 {
845 	int err = 0;
846 	u32 offset, mask_reg;
847 	const struct qlcnic_legacy_intr_set *legacy_intrp;
848 	struct qlcnic_hardware_context *ahw = adapter->ahw;
849 	struct pci_dev *pdev = adapter->pdev;
850 
851 	if (qlcnic_use_msi && !pci_enable_msi(pdev)) {
852 		adapter->flags |= QLCNIC_MSI_ENABLED;
853 		offset = msi_tgt_status[adapter->ahw->pci_func];
854 		adapter->tgt_status_reg = qlcnic_get_ioaddr(adapter->ahw,
855 							    offset);
856 		dev_info(&pdev->dev, "using msi interrupts\n");
857 		adapter->msix_entries[0].vector = pdev->irq;
858 		return err;
859 	}
860 
861 	if (qlcnic_use_msi || qlcnic_use_msi_x)
862 		return -EOPNOTSUPP;
863 
864 	legacy_intrp = &legacy_intr[adapter->ahw->pci_func];
865 	adapter->ahw->int_vec_bit = legacy_intrp->int_vec_bit;
866 	offset = legacy_intrp->tgt_status_reg;
867 	adapter->tgt_status_reg = qlcnic_get_ioaddr(ahw, offset);
868 	mask_reg = legacy_intrp->tgt_mask_reg;
869 	adapter->tgt_mask_reg = qlcnic_get_ioaddr(ahw, mask_reg);
870 	adapter->isr_int_vec = qlcnic_get_ioaddr(ahw, ISR_INT_VECTOR);
871 	adapter->crb_int_state_reg = qlcnic_get_ioaddr(ahw, ISR_INT_STATE_REG);
872 	dev_info(&pdev->dev, "using legacy interrupts\n");
873 	adapter->msix_entries[0].vector = pdev->irq;
874 	return err;
875 }
876 
877 static int qlcnic_82xx_setup_intr(struct qlcnic_adapter *adapter)
878 {
879 	int num_msix, err = 0;
880 
881 	if (adapter->flags & QLCNIC_TSS_RSS) {
882 		err = qlcnic_setup_tss_rss_intr(adapter);
883 		if (err < 0)
884 			return err;
885 		num_msix = adapter->ahw->num_msix;
886 	} else {
887 		num_msix = qlcnic_82xx_calculate_msix_vector(adapter);
888 
889 		err = qlcnic_enable_msix(adapter, num_msix);
890 		if (err == -ENOMEM)
891 			return err;
892 
893 		if (!(adapter->flags & QLCNIC_MSIX_ENABLED)) {
894 			qlcnic_disable_multi_tx(adapter);
895 			adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
896 
897 			err = qlcnic_enable_msi_legacy(adapter);
898 			if (err)
899 				return err;
900 		}
901 	}
902 
903 	return 0;
904 }
905 
906 int qlcnic_82xx_mq_intrpt(struct qlcnic_adapter *adapter, int op_type)
907 {
908 	struct qlcnic_hardware_context *ahw = adapter->ahw;
909 	int err, i;
910 
911 	if (qlcnic_check_multi_tx(adapter) &&
912 	    !ahw->diag_test &&
913 	    (adapter->flags & QLCNIC_MSIX_ENABLED)) {
914 		ahw->intr_tbl =
915 			vzalloc(array_size(sizeof(struct qlcnic_intrpt_config),
916 					   ahw->num_msix));
917 		if (!ahw->intr_tbl)
918 			return -ENOMEM;
919 
920 		for (i = 0; i < ahw->num_msix; i++) {
921 			ahw->intr_tbl[i].type = QLCNIC_INTRPT_MSIX;
922 			ahw->intr_tbl[i].id = i;
923 			ahw->intr_tbl[i].src = 0;
924 		}
925 
926 		err = qlcnic_82xx_config_intrpt(adapter, 1);
927 		if (err)
928 			dev_err(&adapter->pdev->dev,
929 				"Failed to configure Interrupt for %d vector\n",
930 				ahw->num_msix);
931 		return err;
932 	}
933 
934 	return 0;
935 }
936 
937 void qlcnic_teardown_intr(struct qlcnic_adapter *adapter)
938 {
939 	if (adapter->flags & QLCNIC_MSIX_ENABLED)
940 		pci_disable_msix(adapter->pdev);
941 	if (adapter->flags & QLCNIC_MSI_ENABLED)
942 		pci_disable_msi(adapter->pdev);
943 
944 	kfree(adapter->msix_entries);
945 	adapter->msix_entries = NULL;
946 
947 	if (adapter->ahw->intr_tbl) {
948 		vfree(adapter->ahw->intr_tbl);
949 		adapter->ahw->intr_tbl = NULL;
950 	}
951 }
952 
953 static void qlcnic_cleanup_pci_map(struct qlcnic_hardware_context *ahw)
954 {
955 	if (ahw->pci_base0 != NULL)
956 		iounmap(ahw->pci_base0);
957 }
958 
959 static int qlcnic_get_act_pci_func(struct qlcnic_adapter *adapter)
960 {
961 	struct qlcnic_hardware_context *ahw = adapter->ahw;
962 	struct qlcnic_pci_info *pci_info;
963 	int ret;
964 
965 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED)) {
966 		switch (ahw->port_type) {
967 		case QLCNIC_GBE:
968 			ahw->total_nic_func = QLCNIC_NIU_MAX_GBE_PORTS;
969 			break;
970 		case QLCNIC_XGBE:
971 			ahw->total_nic_func = QLCNIC_NIU_MAX_XG_PORTS;
972 			break;
973 		}
974 		return 0;
975 	}
976 
977 	if (ahw->op_mode == QLCNIC_MGMT_FUNC)
978 		return 0;
979 
980 	pci_info = kcalloc(ahw->max_vnic_func, sizeof(*pci_info), GFP_KERNEL);
981 	if (!pci_info)
982 		return -ENOMEM;
983 
984 	ret = qlcnic_get_pci_info(adapter, pci_info);
985 	kfree(pci_info);
986 	return ret;
987 }
988 
989 static bool qlcnic_port_eswitch_cfg_capability(struct qlcnic_adapter *adapter)
990 {
991 	bool ret = false;
992 
993 	if (qlcnic_84xx_check(adapter)) {
994 		ret = true;
995 	} else if (qlcnic_83xx_check(adapter)) {
996 		if (adapter->ahw->extra_capability[0] &
997 		    QLCNIC_FW_CAPABILITY_2_PER_PORT_ESWITCH_CFG)
998 			ret = true;
999 		else
1000 			ret = false;
1001 	}
1002 
1003 	return ret;
1004 }
1005 
1006 int qlcnic_init_pci_info(struct qlcnic_adapter *adapter)
1007 {
1008 	struct qlcnic_hardware_context *ahw = adapter->ahw;
1009 	struct qlcnic_pci_info *pci_info;
1010 	int i, id = 0, ret = 0, j = 0;
1011 	u16 act_pci_func;
1012 	u8 pfn;
1013 
1014 	pci_info = kcalloc(ahw->max_vnic_func, sizeof(*pci_info), GFP_KERNEL);
1015 	if (!pci_info)
1016 		return -ENOMEM;
1017 
1018 	ret = qlcnic_get_pci_info(adapter, pci_info);
1019 	if (ret)
1020 		goto err_pci_info;
1021 
1022 	act_pci_func = ahw->total_nic_func;
1023 
1024 	adapter->npars = kcalloc(act_pci_func,
1025 				 sizeof(struct qlcnic_npar_info),
1026 				 GFP_KERNEL);
1027 	if (!adapter->npars) {
1028 		ret = -ENOMEM;
1029 		goto err_pci_info;
1030 	}
1031 
1032 	adapter->eswitch = kcalloc(QLCNIC_NIU_MAX_XG_PORTS,
1033 				   sizeof(struct qlcnic_eswitch),
1034 				   GFP_KERNEL);
1035 	if (!adapter->eswitch) {
1036 		ret = -ENOMEM;
1037 		goto err_npars;
1038 	}
1039 
1040 	for (i = 0; i < ahw->max_vnic_func; i++) {
1041 		pfn = pci_info[i].id;
1042 
1043 		if (pfn >= ahw->max_vnic_func) {
1044 			ret = -EINVAL;
1045 			dev_err(&adapter->pdev->dev, "%s: Invalid function 0x%x, max 0x%x\n",
1046 				__func__, pfn, ahw->max_vnic_func);
1047 			goto err_eswitch;
1048 		}
1049 
1050 		if (!pci_info[i].active ||
1051 		    (pci_info[i].type != QLCNIC_TYPE_NIC))
1052 			continue;
1053 
1054 		if (qlcnic_port_eswitch_cfg_capability(adapter)) {
1055 			if (!qlcnic_83xx_set_port_eswitch_status(adapter, pfn,
1056 								 &id))
1057 				adapter->npars[j].eswitch_status = true;
1058 			else
1059 				continue;
1060 		} else {
1061 			adapter->npars[j].eswitch_status = true;
1062 		}
1063 
1064 		adapter->npars[j].pci_func = pfn;
1065 		adapter->npars[j].active = (u8)pci_info[i].active;
1066 		adapter->npars[j].type = (u8)pci_info[i].type;
1067 		adapter->npars[j].phy_port = (u8)pci_info[i].default_port;
1068 		adapter->npars[j].min_bw = pci_info[i].tx_min_bw;
1069 		adapter->npars[j].max_bw = pci_info[i].tx_max_bw;
1070 
1071 		memcpy(&adapter->npars[j].mac, &pci_info[i].mac, ETH_ALEN);
1072 		j++;
1073 	}
1074 
1075 	/* Update eSwitch status for adapters without per port eSwitch
1076 	 * configuration capability
1077 	 */
1078 	if (!qlcnic_port_eswitch_cfg_capability(adapter)) {
1079 		for (i = 0; i < QLCNIC_NIU_MAX_XG_PORTS; i++)
1080 			adapter->eswitch[i].flags |= QLCNIC_SWITCH_ENABLE;
1081 	}
1082 
1083 	kfree(pci_info);
1084 	return 0;
1085 
1086 err_eswitch:
1087 	kfree(adapter->eswitch);
1088 	adapter->eswitch = NULL;
1089 err_npars:
1090 	kfree(adapter->npars);
1091 	adapter->npars = NULL;
1092 err_pci_info:
1093 	kfree(pci_info);
1094 
1095 	return ret;
1096 }
1097 
1098 static int
1099 qlcnic_set_function_modes(struct qlcnic_adapter *adapter)
1100 {
1101 	u8 id;
1102 	int ret;
1103 	u32 data = QLCNIC_MGMT_FUNC;
1104 	struct qlcnic_hardware_context *ahw = adapter->ahw;
1105 
1106 	ret = qlcnic_api_lock(adapter);
1107 	if (ret)
1108 		goto err_lock;
1109 
1110 	id = ahw->pci_func;
1111 	data = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1112 	data = (data & ~QLC_DEV_SET_DRV(0xf, id)) |
1113 	       QLC_DEV_SET_DRV(QLCNIC_MGMT_FUNC, id);
1114 	QLC_SHARED_REG_WR32(adapter, QLCNIC_DRV_OP_MODE, data);
1115 	qlcnic_api_unlock(adapter);
1116 err_lock:
1117 	return ret;
1118 }
1119 
1120 static void qlcnic_check_vf(struct qlcnic_adapter *adapter,
1121 			    const struct pci_device_id *ent)
1122 {
1123 	u32 op_mode, priv_level;
1124 
1125 	/* Determine FW API version */
1126 	adapter->ahw->fw_hal_version = QLC_SHARED_REG_RD32(adapter,
1127 							   QLCNIC_FW_API);
1128 
1129 	/* Find PCI function number */
1130 	qlcnic_get_func_no(adapter);
1131 
1132 	/* Determine function privilege level */
1133 	op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1134 	if (op_mode == QLC_DEV_DRV_DEFAULT)
1135 		priv_level = QLCNIC_MGMT_FUNC;
1136 	else
1137 		priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1138 
1139 	if (priv_level == QLCNIC_NON_PRIV_FUNC) {
1140 		adapter->ahw->op_mode = QLCNIC_NON_PRIV_FUNC;
1141 		dev_info(&adapter->pdev->dev,
1142 			"HAL Version: %d Non Privileged function\n",
1143 			 adapter->ahw->fw_hal_version);
1144 		adapter->nic_ops = &qlcnic_vf_ops;
1145 	} else
1146 		adapter->nic_ops = &qlcnic_ops;
1147 }
1148 
1149 #define QLCNIC_82XX_BAR0_LENGTH 0x00200000UL
1150 #define QLCNIC_83XX_BAR0_LENGTH 0x4000
1151 static void qlcnic_get_bar_length(u32 dev_id, ulong *bar)
1152 {
1153 	switch (dev_id) {
1154 	case PCI_DEVICE_ID_QLOGIC_QLE824X:
1155 		*bar = QLCNIC_82XX_BAR0_LENGTH;
1156 		break;
1157 	case PCI_DEVICE_ID_QLOGIC_QLE834X:
1158 	case PCI_DEVICE_ID_QLOGIC_QLE8830:
1159 	case PCI_DEVICE_ID_QLOGIC_QLE844X:
1160 	case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
1161 	case PCI_DEVICE_ID_QLOGIC_VF_QLE844X:
1162 	case PCI_DEVICE_ID_QLOGIC_VF_QLE8C30:
1163 		*bar = QLCNIC_83XX_BAR0_LENGTH;
1164 		break;
1165 	default:
1166 		*bar = 0;
1167 	}
1168 }
1169 
1170 static int qlcnic_setup_pci_map(struct pci_dev *pdev,
1171 				struct qlcnic_hardware_context *ahw)
1172 {
1173 	u32 offset;
1174 	void __iomem *mem_ptr0 = NULL;
1175 	unsigned long mem_len, pci_len0 = 0, bar0_len;
1176 
1177 	/* remap phys address */
1178 	mem_len = pci_resource_len(pdev, 0);
1179 
1180 	qlcnic_get_bar_length(pdev->device, &bar0_len);
1181 	if (mem_len >= bar0_len) {
1182 
1183 		mem_ptr0 = pci_ioremap_bar(pdev, 0);
1184 		if (mem_ptr0 == NULL) {
1185 			dev_err(&pdev->dev, "failed to map PCI bar 0\n");
1186 			return -EIO;
1187 		}
1188 		pci_len0 = mem_len;
1189 	} else {
1190 		return -EIO;
1191 	}
1192 
1193 	dev_info(&pdev->dev, "%dKB memory map\n", (int)(mem_len >> 10));
1194 
1195 	ahw->pci_base0 = mem_ptr0;
1196 	ahw->pci_len0 = pci_len0;
1197 	offset = QLCNIC_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(ahw->pci_func));
1198 	qlcnic_get_ioaddr(ahw, offset);
1199 
1200 	return 0;
1201 }
1202 
1203 static bool qlcnic_validate_subsystem_id(struct qlcnic_adapter *adapter,
1204 					 int index)
1205 {
1206 	struct pci_dev *pdev = adapter->pdev;
1207 	unsigned short subsystem_vendor;
1208 	bool ret = true;
1209 
1210 	subsystem_vendor = pdev->subsystem_vendor;
1211 
1212 	if (pdev->device == PCI_DEVICE_ID_QLOGIC_QLE824X ||
1213 	    pdev->device == PCI_DEVICE_ID_QLOGIC_QLE834X) {
1214 		if (qlcnic_boards[index].sub_vendor == subsystem_vendor &&
1215 		    qlcnic_boards[index].sub_device == pdev->subsystem_device)
1216 			ret = true;
1217 		else
1218 			ret = false;
1219 	}
1220 
1221 	return ret;
1222 }
1223 
1224 static void qlcnic_get_board_name(struct qlcnic_adapter *adapter, char *name)
1225 {
1226 	struct pci_dev *pdev = adapter->pdev;
1227 	int i, found = 0;
1228 
1229 	for (i = 0; i < NUM_SUPPORTED_BOARDS; ++i) {
1230 		if (qlcnic_boards[i].vendor == pdev->vendor &&
1231 		    qlcnic_boards[i].device == pdev->device &&
1232 		    qlcnic_validate_subsystem_id(adapter, i)) {
1233 			found = 1;
1234 			break;
1235 		}
1236 	}
1237 
1238 	if (!found)
1239 		sprintf(name, "%pM Gigabit Ethernet", adapter->mac_addr);
1240 	else
1241 		sprintf(name, "%pM: %s" , adapter->mac_addr,
1242 			qlcnic_boards[i].short_name);
1243 }
1244 
1245 static void
1246 qlcnic_check_options(struct qlcnic_adapter *adapter)
1247 {
1248 	int err;
1249 	u32 fw_major, fw_minor, fw_build, prev_fw_version;
1250 	struct pci_dev *pdev = adapter->pdev;
1251 	struct qlcnic_hardware_context *ahw = adapter->ahw;
1252 	struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
1253 
1254 	prev_fw_version = adapter->fw_version;
1255 
1256 	fw_major = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MAJOR);
1257 	fw_minor = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_MINOR);
1258 	fw_build = QLC_SHARED_REG_RD32(adapter, QLCNIC_FW_VERSION_SUB);
1259 
1260 	adapter->fw_version = QLCNIC_VERSION_CODE(fw_major, fw_minor, fw_build);
1261 
1262 	err = qlcnic_get_board_info(adapter);
1263 	if (err) {
1264 		dev_err(&pdev->dev, "Error getting board config info.\n");
1265 		return;
1266 	}
1267 	if (ahw->op_mode != QLCNIC_NON_PRIV_FUNC) {
1268 		if (fw_dump->tmpl_hdr == NULL ||
1269 				adapter->fw_version > prev_fw_version) {
1270 			vfree(fw_dump->tmpl_hdr);
1271 			if (!qlcnic_fw_cmd_get_minidump_temp(adapter))
1272 				dev_info(&pdev->dev,
1273 					"Supports FW dump capability\n");
1274 		}
1275 	}
1276 
1277 	dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d\n",
1278 		 QLCNIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build);
1279 
1280 	if (adapter->ahw->port_type == QLCNIC_XGBE) {
1281 		if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1282 			adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_VF;
1283 			adapter->max_rxd = MAX_RCV_DESCRIPTORS_VF;
1284 		} else {
1285 			adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
1286 			adapter->max_rxd = MAX_RCV_DESCRIPTORS_10G;
1287 		}
1288 
1289 		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
1290 		adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
1291 
1292 	} else if (adapter->ahw->port_type == QLCNIC_GBE) {
1293 		adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
1294 		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
1295 		adapter->max_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
1296 		adapter->max_rxd = MAX_RCV_DESCRIPTORS_1G;
1297 	}
1298 
1299 	adapter->ahw->msix_supported = !!qlcnic_use_msi_x;
1300 
1301 	adapter->num_txd = MAX_CMD_DESCRIPTORS;
1302 
1303 	adapter->max_rds_rings = MAX_RDS_RINGS;
1304 }
1305 
1306 static int
1307 qlcnic_initialize_nic(struct qlcnic_adapter *adapter)
1308 {
1309 	struct qlcnic_info nic_info;
1310 	int err = 0;
1311 
1312 	memset(&nic_info, 0, sizeof(struct qlcnic_info));
1313 	err = qlcnic_get_nic_info(adapter, &nic_info, adapter->ahw->pci_func);
1314 	if (err)
1315 		return err;
1316 
1317 	adapter->ahw->physical_port = (u8)nic_info.phys_port;
1318 	adapter->ahw->switch_mode = nic_info.switch_mode;
1319 	adapter->ahw->max_tx_ques = nic_info.max_tx_ques;
1320 	adapter->ahw->max_rx_ques = nic_info.max_rx_ques;
1321 	adapter->ahw->capabilities = nic_info.capabilities;
1322 
1323 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_MORE_CAPS) {
1324 		u32 temp;
1325 		temp = QLCRD32(adapter, CRB_FW_CAPABILITIES_2, &err);
1326 		if (err == -EIO)
1327 			return err;
1328 		adapter->ahw->extra_capability[0] = temp;
1329 	} else {
1330 		adapter->ahw->extra_capability[0] = 0;
1331 	}
1332 
1333 	adapter->ahw->max_mac_filters = nic_info.max_mac_filters;
1334 	adapter->ahw->max_mtu = nic_info.max_mtu;
1335 
1336 	if (adapter->ahw->capabilities & BIT_6) {
1337 		adapter->flags |= QLCNIC_ESWITCH_ENABLED;
1338 		adapter->ahw->nic_mode = QLCNIC_VNIC_MODE;
1339 		adapter->max_tx_rings = QLCNIC_MAX_HW_VNIC_TX_RINGS;
1340 		adapter->max_sds_rings = QLCNIC_MAX_VNIC_SDS_RINGS;
1341 
1342 		dev_info(&adapter->pdev->dev, "vNIC mode enabled.\n");
1343 	} else {
1344 		adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
1345 		adapter->max_tx_rings = QLCNIC_MAX_HW_TX_RINGS;
1346 		adapter->max_sds_rings = QLCNIC_MAX_SDS_RINGS;
1347 		adapter->flags &= ~QLCNIC_ESWITCH_ENABLED;
1348 	}
1349 
1350 	return err;
1351 }
1352 
1353 void qlcnic_set_vlan_config(struct qlcnic_adapter *adapter,
1354 			    struct qlcnic_esw_func_cfg *esw_cfg)
1355 {
1356 	if (esw_cfg->discard_tagged)
1357 		adapter->flags &= ~QLCNIC_TAGGING_ENABLED;
1358 	else
1359 		adapter->flags |= QLCNIC_TAGGING_ENABLED;
1360 
1361 	if (esw_cfg->vlan_id) {
1362 		adapter->rx_pvid = esw_cfg->vlan_id;
1363 		adapter->tx_pvid = esw_cfg->vlan_id;
1364 	} else {
1365 		adapter->rx_pvid = 0;
1366 		adapter->tx_pvid = 0;
1367 	}
1368 }
1369 
1370 static int
1371 qlcnic_vlan_rx_add(struct net_device *netdev, __be16 proto, u16 vid)
1372 {
1373 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
1374 	int err;
1375 
1376 	if (qlcnic_sriov_vf_check(adapter)) {
1377 		err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 1);
1378 		if (err) {
1379 			netdev_err(netdev,
1380 				   "Cannot add VLAN filter for VLAN id %d, err=%d",
1381 				   vid, err);
1382 			return err;
1383 		}
1384 	}
1385 
1386 	set_bit(vid, adapter->vlans);
1387 	return 0;
1388 }
1389 
1390 static int
1391 qlcnic_vlan_rx_del(struct net_device *netdev, __be16 proto, u16 vid)
1392 {
1393 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
1394 	int err;
1395 
1396 	if (qlcnic_sriov_vf_check(adapter)) {
1397 		err = qlcnic_sriov_cfg_vf_guest_vlan(adapter, vid, 0);
1398 		if (err) {
1399 			netdev_err(netdev,
1400 				   "Cannot delete VLAN filter for VLAN id %d, err=%d",
1401 				   vid, err);
1402 			return err;
1403 		}
1404 	}
1405 
1406 	qlcnic_restore_indev_addr(netdev, NETDEV_DOWN);
1407 	clear_bit(vid, adapter->vlans);
1408 	return 0;
1409 }
1410 
1411 void qlcnic_set_eswitch_port_features(struct qlcnic_adapter *adapter,
1412 				      struct qlcnic_esw_func_cfg *esw_cfg)
1413 {
1414 	adapter->flags &= ~(QLCNIC_MACSPOOF | QLCNIC_MAC_OVERRIDE_DISABLED |
1415 				QLCNIC_PROMISC_DISABLED);
1416 
1417 	if (esw_cfg->mac_anti_spoof)
1418 		adapter->flags |= QLCNIC_MACSPOOF;
1419 
1420 	if (!esw_cfg->mac_override)
1421 		adapter->flags |= QLCNIC_MAC_OVERRIDE_DISABLED;
1422 
1423 	if (!esw_cfg->promisc_mode)
1424 		adapter->flags |= QLCNIC_PROMISC_DISABLED;
1425 }
1426 
1427 int qlcnic_set_eswitch_port_config(struct qlcnic_adapter *adapter)
1428 {
1429 	struct qlcnic_esw_func_cfg esw_cfg;
1430 
1431 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED))
1432 		return 0;
1433 
1434 	esw_cfg.pci_func = adapter->ahw->pci_func;
1435 	if (qlcnic_get_eswitch_port_config(adapter, &esw_cfg))
1436 			return -EIO;
1437 	qlcnic_set_vlan_config(adapter, &esw_cfg);
1438 	qlcnic_set_eswitch_port_features(adapter, &esw_cfg);
1439 	qlcnic_set_netdev_features(adapter, &esw_cfg);
1440 
1441 	return 0;
1442 }
1443 
1444 void qlcnic_set_netdev_features(struct qlcnic_adapter *adapter,
1445 				struct qlcnic_esw_func_cfg *esw_cfg)
1446 {
1447 	struct net_device *netdev = adapter->netdev;
1448 
1449 	if (qlcnic_83xx_check(adapter))
1450 		return;
1451 
1452 	adapter->offload_flags = esw_cfg->offload_flags;
1453 	adapter->flags |= QLCNIC_APP_CHANGED_FLAGS;
1454 	netdev_update_features(netdev);
1455 	adapter->flags &= ~QLCNIC_APP_CHANGED_FLAGS;
1456 }
1457 
1458 static int
1459 qlcnic_check_eswitch_mode(struct qlcnic_adapter *adapter)
1460 {
1461 	u32 op_mode, priv_level;
1462 	int err = 0;
1463 
1464 	err = qlcnic_initialize_nic(adapter);
1465 	if (err)
1466 		return err;
1467 
1468 	if (adapter->flags & QLCNIC_ADAPTER_INITIALIZED)
1469 		return 0;
1470 
1471 	op_mode = QLC_SHARED_REG_RD32(adapter, QLCNIC_DRV_OP_MODE);
1472 	priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1473 
1474 	if (op_mode == QLC_DEV_DRV_DEFAULT)
1475 		priv_level = QLCNIC_MGMT_FUNC;
1476 	else
1477 		priv_level = QLC_DEV_GET_DRV(op_mode, adapter->ahw->pci_func);
1478 
1479 	if (adapter->flags & QLCNIC_ESWITCH_ENABLED) {
1480 		if (priv_level == QLCNIC_MGMT_FUNC) {
1481 			adapter->ahw->op_mode = QLCNIC_MGMT_FUNC;
1482 			err = qlcnic_init_pci_info(adapter);
1483 			if (err)
1484 				return err;
1485 			/* Set privilege level for other functions */
1486 			qlcnic_set_function_modes(adapter);
1487 			dev_info(&adapter->pdev->dev,
1488 				"HAL Version: %d, Management function\n",
1489 				 adapter->ahw->fw_hal_version);
1490 		} else if (priv_level == QLCNIC_PRIV_FUNC) {
1491 			adapter->ahw->op_mode = QLCNIC_PRIV_FUNC;
1492 			dev_info(&adapter->pdev->dev,
1493 				"HAL Version: %d, Privileged function\n",
1494 				 adapter->ahw->fw_hal_version);
1495 		}
1496 	} else {
1497 		adapter->ahw->nic_mode = QLCNIC_DEFAULT_MODE;
1498 	}
1499 
1500 	adapter->flags |= QLCNIC_ADAPTER_INITIALIZED;
1501 
1502 	return err;
1503 }
1504 
1505 int qlcnic_set_default_offload_settings(struct qlcnic_adapter *adapter)
1506 {
1507 	struct qlcnic_esw_func_cfg esw_cfg;
1508 	struct qlcnic_npar_info *npar;
1509 	u8 i;
1510 
1511 	if (adapter->need_fw_reset)
1512 		return 0;
1513 
1514 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
1515 		if (!adapter->npars[i].eswitch_status)
1516 			continue;
1517 
1518 		memset(&esw_cfg, 0, sizeof(struct qlcnic_esw_func_cfg));
1519 		esw_cfg.pci_func = adapter->npars[i].pci_func;
1520 		esw_cfg.mac_override = BIT_0;
1521 		esw_cfg.promisc_mode = BIT_0;
1522 		if (qlcnic_82xx_check(adapter)) {
1523 			esw_cfg.offload_flags = BIT_0;
1524 			if (QLCNIC_IS_TSO_CAPABLE(adapter))
1525 				esw_cfg.offload_flags |= (BIT_1 | BIT_2);
1526 		}
1527 		if (qlcnic_config_switch_port(adapter, &esw_cfg))
1528 			return -EIO;
1529 		npar = &adapter->npars[i];
1530 		npar->pvid = esw_cfg.vlan_id;
1531 		npar->mac_override = esw_cfg.mac_override;
1532 		npar->mac_anti_spoof = esw_cfg.mac_anti_spoof;
1533 		npar->discard_tagged = esw_cfg.discard_tagged;
1534 		npar->promisc_mode = esw_cfg.promisc_mode;
1535 		npar->offload_flags = esw_cfg.offload_flags;
1536 	}
1537 
1538 	return 0;
1539 }
1540 
1541 
1542 static int
1543 qlcnic_reset_eswitch_config(struct qlcnic_adapter *adapter,
1544 			struct qlcnic_npar_info *npar, int pci_func)
1545 {
1546 	struct qlcnic_esw_func_cfg esw_cfg;
1547 	esw_cfg.op_mode = QLCNIC_PORT_DEFAULTS;
1548 	esw_cfg.pci_func = pci_func;
1549 	esw_cfg.vlan_id = npar->pvid;
1550 	esw_cfg.mac_override = npar->mac_override;
1551 	esw_cfg.discard_tagged = npar->discard_tagged;
1552 	esw_cfg.mac_anti_spoof = npar->mac_anti_spoof;
1553 	esw_cfg.offload_flags = npar->offload_flags;
1554 	esw_cfg.promisc_mode = npar->promisc_mode;
1555 	if (qlcnic_config_switch_port(adapter, &esw_cfg))
1556 		return -EIO;
1557 
1558 	esw_cfg.op_mode = QLCNIC_ADD_VLAN;
1559 	if (qlcnic_config_switch_port(adapter, &esw_cfg))
1560 		return -EIO;
1561 
1562 	return 0;
1563 }
1564 
1565 int qlcnic_reset_npar_config(struct qlcnic_adapter *adapter)
1566 {
1567 	int i, err;
1568 	struct qlcnic_npar_info *npar;
1569 	struct qlcnic_info nic_info;
1570 	u8 pci_func;
1571 
1572 	if (qlcnic_82xx_check(adapter))
1573 		if (!adapter->need_fw_reset)
1574 			return 0;
1575 
1576 	/* Set the NPAR config data after FW reset */
1577 	for (i = 0; i < adapter->ahw->total_nic_func; i++) {
1578 		npar = &adapter->npars[i];
1579 		pci_func = npar->pci_func;
1580 		if (!adapter->npars[i].eswitch_status)
1581 			continue;
1582 
1583 		memset(&nic_info, 0, sizeof(struct qlcnic_info));
1584 		err = qlcnic_get_nic_info(adapter, &nic_info, pci_func);
1585 		if (err)
1586 			return err;
1587 		nic_info.min_tx_bw = npar->min_bw;
1588 		nic_info.max_tx_bw = npar->max_bw;
1589 		err = qlcnic_set_nic_info(adapter, &nic_info);
1590 		if (err)
1591 			return err;
1592 
1593 		if (npar->enable_pm) {
1594 			err = qlcnic_config_port_mirroring(adapter,
1595 							   npar->dest_npar, 1,
1596 							   pci_func);
1597 			if (err)
1598 				return err;
1599 		}
1600 		err = qlcnic_reset_eswitch_config(adapter, npar, pci_func);
1601 		if (err)
1602 			return err;
1603 	}
1604 	return 0;
1605 }
1606 
1607 static int qlcnic_check_npar_opertional(struct qlcnic_adapter *adapter)
1608 {
1609 	u8 npar_opt_timeo = QLCNIC_DEV_NPAR_OPER_TIMEO;
1610 	u32 npar_state;
1611 
1612 	if (adapter->ahw->op_mode == QLCNIC_MGMT_FUNC)
1613 		return 0;
1614 
1615 	npar_state = QLC_SHARED_REG_RD32(adapter,
1616 					 QLCNIC_CRB_DEV_NPAR_STATE);
1617 	while (npar_state != QLCNIC_DEV_NPAR_OPER && --npar_opt_timeo) {
1618 		msleep(1000);
1619 		npar_state = QLC_SHARED_REG_RD32(adapter,
1620 						 QLCNIC_CRB_DEV_NPAR_STATE);
1621 	}
1622 	if (!npar_opt_timeo) {
1623 		dev_err(&adapter->pdev->dev,
1624 			"Waiting for NPAR state to operational timeout\n");
1625 		return -EIO;
1626 	}
1627 	return 0;
1628 }
1629 
1630 static int
1631 qlcnic_set_mgmt_operations(struct qlcnic_adapter *adapter)
1632 {
1633 	int err;
1634 
1635 	if (!(adapter->flags & QLCNIC_ESWITCH_ENABLED) ||
1636 	    adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
1637 		return 0;
1638 
1639 	err = qlcnic_set_default_offload_settings(adapter);
1640 	if (err)
1641 		return err;
1642 
1643 	err = qlcnic_reset_npar_config(adapter);
1644 	if (err)
1645 		return err;
1646 
1647 	qlcnic_dev_set_npar_ready(adapter);
1648 
1649 	return err;
1650 }
1651 
1652 static int qlcnic_82xx_start_firmware(struct qlcnic_adapter *adapter)
1653 {
1654 	int err;
1655 
1656 	err = qlcnic_can_start_firmware(adapter);
1657 	if (err < 0)
1658 		return err;
1659 	else if (!err)
1660 		goto check_fw_status;
1661 
1662 	if (qlcnic_load_fw_file)
1663 		qlcnic_request_firmware(adapter);
1664 	else {
1665 		err = qlcnic_check_flash_fw_ver(adapter);
1666 		if (err)
1667 			goto err_out;
1668 
1669 		adapter->ahw->fw_type = QLCNIC_FLASH_ROMIMAGE;
1670 	}
1671 
1672 	err = qlcnic_need_fw_reset(adapter);
1673 	if (err == 0)
1674 		goto check_fw_status;
1675 
1676 	err = qlcnic_pinit_from_rom(adapter);
1677 	if (err)
1678 		goto err_out;
1679 
1680 	err = qlcnic_load_firmware(adapter);
1681 	if (err)
1682 		goto err_out;
1683 
1684 	qlcnic_release_firmware(adapter);
1685 	QLCWR32(adapter, CRB_DRIVER_VERSION, QLCNIC_DRIVER_VERSION);
1686 
1687 check_fw_status:
1688 	err = qlcnic_check_fw_status(adapter);
1689 	if (err)
1690 		goto err_out;
1691 
1692 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_READY);
1693 	qlcnic_idc_debug_info(adapter, 1);
1694 	err = qlcnic_check_eswitch_mode(adapter);
1695 	if (err) {
1696 		dev_err(&adapter->pdev->dev,
1697 			"Memory allocation failed for eswitch\n");
1698 		goto err_out;
1699 	}
1700 	err = qlcnic_set_mgmt_operations(adapter);
1701 	if (err)
1702 		goto err_out;
1703 
1704 	qlcnic_check_options(adapter);
1705 	adapter->need_fw_reset = 0;
1706 
1707 	qlcnic_release_firmware(adapter);
1708 	return 0;
1709 
1710 err_out:
1711 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE, QLCNIC_DEV_FAILED);
1712 	dev_err(&adapter->pdev->dev, "Device state set to failed\n");
1713 
1714 	qlcnic_release_firmware(adapter);
1715 	return err;
1716 }
1717 
1718 static int
1719 qlcnic_request_irq(struct qlcnic_adapter *adapter)
1720 {
1721 	irq_handler_t handler;
1722 	struct qlcnic_host_sds_ring *sds_ring;
1723 	struct qlcnic_host_tx_ring *tx_ring;
1724 	int err, ring, num_sds_rings;
1725 
1726 	unsigned long flags = 0;
1727 	struct net_device *netdev = adapter->netdev;
1728 	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1729 
1730 	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
1731 		if (qlcnic_82xx_check(adapter))
1732 			handler = qlcnic_tmp_intr;
1733 		else
1734 			handler = qlcnic_83xx_tmp_intr;
1735 		if (!QLCNIC_IS_MSI_FAMILY(adapter))
1736 			flags |= IRQF_SHARED;
1737 
1738 	} else {
1739 		if (adapter->flags & QLCNIC_MSIX_ENABLED)
1740 			handler = qlcnic_msix_intr;
1741 		else if (adapter->flags & QLCNIC_MSI_ENABLED)
1742 			handler = qlcnic_msi_intr;
1743 		else {
1744 			flags |= IRQF_SHARED;
1745 			if (qlcnic_82xx_check(adapter))
1746 				handler = qlcnic_intr;
1747 			else
1748 				handler = qlcnic_83xx_intr;
1749 		}
1750 	}
1751 	adapter->irq = netdev->irq;
1752 
1753 	if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1754 		if (qlcnic_82xx_check(adapter) ||
1755 		    (qlcnic_83xx_check(adapter) &&
1756 		     (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1757 			num_sds_rings = adapter->drv_sds_rings;
1758 			for (ring = 0; ring < num_sds_rings; ring++) {
1759 				sds_ring = &recv_ctx->sds_rings[ring];
1760 				if (qlcnic_82xx_check(adapter) &&
1761 				    !qlcnic_check_multi_tx(adapter) &&
1762 				    (ring == (num_sds_rings - 1))) {
1763 					if (!(adapter->flags &
1764 					      QLCNIC_MSIX_ENABLED))
1765 						snprintf(sds_ring->name,
1766 							 sizeof(sds_ring->name),
1767 							 "qlcnic");
1768 					else
1769 						snprintf(sds_ring->name,
1770 							 sizeof(sds_ring->name),
1771 							 "%s-tx-0-rx-%d",
1772 							 netdev->name, ring);
1773 				} else {
1774 					snprintf(sds_ring->name,
1775 						 sizeof(sds_ring->name),
1776 						 "%s-rx-%d",
1777 						 netdev->name, ring);
1778 				}
1779 				err = request_irq(sds_ring->irq, handler, flags,
1780 						  sds_ring->name, sds_ring);
1781 				if (err)
1782 					return err;
1783 			}
1784 		}
1785 		if ((qlcnic_82xx_check(adapter) &&
1786 		     qlcnic_check_multi_tx(adapter)) ||
1787 		    (qlcnic_83xx_check(adapter) &&
1788 		     (adapter->flags & QLCNIC_MSIX_ENABLED) &&
1789 		     !(adapter->flags & QLCNIC_TX_INTR_SHARED))) {
1790 			handler = qlcnic_msix_tx_intr;
1791 			for (ring = 0; ring < adapter->drv_tx_rings;
1792 			     ring++) {
1793 				tx_ring = &adapter->tx_ring[ring];
1794 				snprintf(tx_ring->name, sizeof(tx_ring->name),
1795 					 "%s-tx-%d", netdev->name, ring);
1796 				err = request_irq(tx_ring->irq, handler, flags,
1797 						  tx_ring->name, tx_ring);
1798 				if (err)
1799 					return err;
1800 			}
1801 		}
1802 	}
1803 	return 0;
1804 }
1805 
1806 static void
1807 qlcnic_free_irq(struct qlcnic_adapter *adapter)
1808 {
1809 	int ring;
1810 	struct qlcnic_host_sds_ring *sds_ring;
1811 	struct qlcnic_host_tx_ring *tx_ring;
1812 
1813 	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
1814 
1815 	if (adapter->ahw->diag_test != QLCNIC_LOOPBACK_TEST) {
1816 		if (qlcnic_82xx_check(adapter) ||
1817 		    (qlcnic_83xx_check(adapter) &&
1818 		     (adapter->flags & QLCNIC_MSIX_ENABLED))) {
1819 			for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
1820 				sds_ring = &recv_ctx->sds_rings[ring];
1821 				free_irq(sds_ring->irq, sds_ring);
1822 			}
1823 		}
1824 		if ((qlcnic_83xx_check(adapter) &&
1825 		     !(adapter->flags & QLCNIC_TX_INTR_SHARED)) ||
1826 		    (qlcnic_82xx_check(adapter) &&
1827 		     qlcnic_check_multi_tx(adapter))) {
1828 			for (ring = 0; ring < adapter->drv_tx_rings;
1829 			     ring++) {
1830 				tx_ring = &adapter->tx_ring[ring];
1831 				if (tx_ring->irq)
1832 					free_irq(tx_ring->irq, tx_ring);
1833 			}
1834 		}
1835 	}
1836 }
1837 
1838 static void qlcnic_get_lro_mss_capability(struct qlcnic_adapter *adapter)
1839 {
1840 	u32 capab = 0;
1841 
1842 	if (qlcnic_82xx_check(adapter)) {
1843 		if (adapter->ahw->extra_capability[0] &
1844 		    QLCNIC_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1845 			adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1846 	} else {
1847 		capab = adapter->ahw->capabilities;
1848 		if (QLC_83XX_GET_FW_LRO_MSS_CAPABILITY(capab))
1849 			adapter->flags |= QLCNIC_FW_LRO_MSS_CAP;
1850 	}
1851 }
1852 
1853 static int qlcnic_config_def_intr_coalesce(struct qlcnic_adapter *adapter)
1854 {
1855 	struct qlcnic_hardware_context *ahw = adapter->ahw;
1856 	int err;
1857 
1858 	/* Initialize interrupt coalesce parameters */
1859 	ahw->coal.flag = QLCNIC_INTR_DEFAULT;
1860 
1861 	if (qlcnic_83xx_check(adapter)) {
1862 		ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX_TX;
1863 		ahw->coal.tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
1864 		ahw->coal.tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
1865 		ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1866 		ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1867 
1868 		err = qlcnic_83xx_set_rx_tx_intr_coal(adapter);
1869 	} else {
1870 		ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX;
1871 		ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
1872 		ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
1873 
1874 		err = qlcnic_82xx_set_rx_coalesce(adapter);
1875 	}
1876 
1877 	return err;
1878 }
1879 
1880 int __qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1881 {
1882 	int ring;
1883 	struct qlcnic_host_rds_ring *rds_ring;
1884 
1885 	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1886 		return -EIO;
1887 
1888 	if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
1889 		return 0;
1890 
1891 	if (qlcnic_set_eswitch_port_config(adapter))
1892 		return -EIO;
1893 
1894 	qlcnic_get_lro_mss_capability(adapter);
1895 
1896 	if (qlcnic_fw_create_ctx(adapter))
1897 		return -EIO;
1898 
1899 	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1900 		rds_ring = &adapter->recv_ctx->rds_rings[ring];
1901 		qlcnic_post_rx_buffers(adapter, rds_ring, ring);
1902 	}
1903 
1904 	qlcnic_set_multi(netdev);
1905 	qlcnic_fw_cmd_set_mtu(adapter, netdev->mtu);
1906 
1907 	adapter->ahw->linkup = 0;
1908 
1909 	if (adapter->drv_sds_rings > 1)
1910 		qlcnic_config_rss(adapter, 1);
1911 
1912 	qlcnic_config_def_intr_coalesce(adapter);
1913 
1914 	if (netdev->features & NETIF_F_LRO)
1915 		qlcnic_config_hw_lro(adapter, QLCNIC_LRO_ENABLED);
1916 
1917 	set_bit(__QLCNIC_DEV_UP, &adapter->state);
1918 	qlcnic_napi_enable(adapter);
1919 
1920 	qlcnic_linkevent_request(adapter, 1);
1921 
1922 	adapter->ahw->reset_context = 0;
1923 	netif_tx_start_all_queues(netdev);
1924 	return 0;
1925 }
1926 
1927 int qlcnic_up(struct qlcnic_adapter *adapter, struct net_device *netdev)
1928 {
1929 	int err = 0;
1930 
1931 	rtnl_lock();
1932 	if (netif_running(netdev))
1933 		err = __qlcnic_up(adapter, netdev);
1934 	rtnl_unlock();
1935 
1936 	return err;
1937 }
1938 
1939 void __qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1940 {
1941 	int ring;
1942 
1943 	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
1944 		return;
1945 
1946 	if (!test_and_clear_bit(__QLCNIC_DEV_UP, &adapter->state))
1947 		return;
1948 
1949 	smp_mb();
1950 	netif_carrier_off(netdev);
1951 	adapter->ahw->linkup = 0;
1952 	netif_tx_disable(netdev);
1953 
1954 	qlcnic_free_mac_list(adapter);
1955 
1956 	if (adapter->fhash.fnum)
1957 		qlcnic_delete_lb_filters(adapter);
1958 
1959 	qlcnic_nic_set_promisc(adapter, QLCNIC_NIU_NON_PROMISC_MODE);
1960 	if (qlcnic_sriov_vf_check(adapter))
1961 		qlcnic_sriov_cleanup_async_list(&adapter->ahw->sriov->bc);
1962 
1963 	qlcnic_napi_disable(adapter);
1964 
1965 	qlcnic_fw_destroy_ctx(adapter);
1966 	adapter->flags &= ~QLCNIC_FW_LRO_MSS_CAP;
1967 
1968 	qlcnic_reset_rx_buffers_list(adapter);
1969 
1970 	for (ring = 0; ring < adapter->drv_tx_rings; ring++)
1971 		qlcnic_release_tx_buffers(adapter, &adapter->tx_ring[ring]);
1972 }
1973 
1974 /* Usage: During suspend and firmware recovery module */
1975 
1976 void qlcnic_down(struct qlcnic_adapter *adapter, struct net_device *netdev)
1977 {
1978 	rtnl_lock();
1979 	if (netif_running(netdev))
1980 		__qlcnic_down(adapter, netdev);
1981 	rtnl_unlock();
1982 
1983 }
1984 
1985 int
1986 qlcnic_attach(struct qlcnic_adapter *adapter)
1987 {
1988 	struct net_device *netdev = adapter->netdev;
1989 	struct pci_dev *pdev = adapter->pdev;
1990 	int err;
1991 
1992 	if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC)
1993 		return 0;
1994 
1995 	err = qlcnic_napi_add(adapter, netdev);
1996 	if (err)
1997 		return err;
1998 
1999 	err = qlcnic_alloc_sw_resources(adapter);
2000 	if (err) {
2001 		dev_err(&pdev->dev, "Error in setting sw resources\n");
2002 		goto err_out_napi_del;
2003 	}
2004 
2005 	err = qlcnic_alloc_hw_resources(adapter);
2006 	if (err) {
2007 		dev_err(&pdev->dev, "Error in setting hw resources\n");
2008 		goto err_out_free_sw;
2009 	}
2010 
2011 	err = qlcnic_request_irq(adapter);
2012 	if (err) {
2013 		dev_err(&pdev->dev, "failed to setup interrupt\n");
2014 		goto err_out_free_hw;
2015 	}
2016 
2017 	qlcnic_create_sysfs_entries(adapter);
2018 
2019 	if (qlcnic_encap_rx_offload(adapter))
2020 		udp_tunnel_get_rx_info(netdev);
2021 
2022 	adapter->is_up = QLCNIC_ADAPTER_UP_MAGIC;
2023 	return 0;
2024 
2025 err_out_free_hw:
2026 	qlcnic_free_hw_resources(adapter);
2027 err_out_free_sw:
2028 	qlcnic_free_sw_resources(adapter);
2029 err_out_napi_del:
2030 	qlcnic_napi_del(adapter);
2031 	return err;
2032 }
2033 
2034 void qlcnic_detach(struct qlcnic_adapter *adapter)
2035 {
2036 	if (adapter->is_up != QLCNIC_ADAPTER_UP_MAGIC)
2037 		return;
2038 
2039 	qlcnic_remove_sysfs_entries(adapter);
2040 
2041 	qlcnic_free_hw_resources(adapter);
2042 	qlcnic_release_rx_buffers(adapter);
2043 	qlcnic_free_irq(adapter);
2044 	qlcnic_napi_del(adapter);
2045 	qlcnic_free_sw_resources(adapter);
2046 
2047 	adapter->is_up = 0;
2048 }
2049 
2050 void qlcnic_diag_free_res(struct net_device *netdev, int drv_sds_rings)
2051 {
2052 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
2053 	struct qlcnic_host_sds_ring *sds_ring;
2054 	int drv_tx_rings = adapter->drv_tx_rings;
2055 	int ring;
2056 
2057 	clear_bit(__QLCNIC_DEV_UP, &adapter->state);
2058 	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
2059 		for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
2060 			sds_ring = &adapter->recv_ctx->sds_rings[ring];
2061 			qlcnic_disable_sds_intr(adapter, sds_ring);
2062 		}
2063 	}
2064 
2065 	qlcnic_fw_destroy_ctx(adapter);
2066 
2067 	qlcnic_detach(adapter);
2068 
2069 	adapter->ahw->diag_test = 0;
2070 	adapter->drv_sds_rings = drv_sds_rings;
2071 	adapter->drv_tx_rings = drv_tx_rings;
2072 
2073 	if (qlcnic_attach(adapter))
2074 		goto out;
2075 
2076 	if (netif_running(netdev))
2077 		__qlcnic_up(adapter, netdev);
2078 out:
2079 	netif_device_attach(netdev);
2080 }
2081 
2082 static int qlcnic_alloc_adapter_resources(struct qlcnic_adapter *adapter)
2083 {
2084 	struct qlcnic_hardware_context *ahw = adapter->ahw;
2085 	int err = 0;
2086 
2087 	adapter->recv_ctx = kzalloc(sizeof(struct qlcnic_recv_context),
2088 				GFP_KERNEL);
2089 	if (!adapter->recv_ctx) {
2090 		err = -ENOMEM;
2091 		goto err_out;
2092 	}
2093 
2094 	if (qlcnic_83xx_check(adapter)) {
2095 		ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX_TX;
2096 		ahw->coal.tx_time_us = QLCNIC_DEF_INTR_COALESCE_TX_TIME_US;
2097 		ahw->coal.tx_packets = QLCNIC_DEF_INTR_COALESCE_TX_PACKETS;
2098 		ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
2099 		ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
2100 	} else {
2101 		ahw->coal.type = QLCNIC_INTR_COAL_TYPE_RX;
2102 		ahw->coal.rx_time_us = QLCNIC_DEF_INTR_COALESCE_RX_TIME_US;
2103 		ahw->coal.rx_packets = QLCNIC_DEF_INTR_COALESCE_RX_PACKETS;
2104 	}
2105 
2106 	/* clear stats */
2107 	memset(&adapter->stats, 0, sizeof(adapter->stats));
2108 err_out:
2109 	return err;
2110 }
2111 
2112 static void qlcnic_free_adapter_resources(struct qlcnic_adapter *adapter)
2113 {
2114 	struct qlcnic_fw_dump *fw_dump = &adapter->ahw->fw_dump;
2115 
2116 	kfree(adapter->recv_ctx);
2117 	adapter->recv_ctx = NULL;
2118 
2119 	if (fw_dump->tmpl_hdr) {
2120 		vfree(fw_dump->tmpl_hdr);
2121 		fw_dump->tmpl_hdr = NULL;
2122 	}
2123 
2124 	if (fw_dump->dma_buffer) {
2125 		dma_free_coherent(&adapter->pdev->dev, QLC_PEX_DMA_READ_SIZE,
2126 				  fw_dump->dma_buffer, fw_dump->phys_addr);
2127 		fw_dump->dma_buffer = NULL;
2128 	}
2129 
2130 	kfree(adapter->ahw->reset.buff);
2131 	adapter->ahw->fw_dump.tmpl_hdr = NULL;
2132 }
2133 
2134 int qlcnic_diag_alloc_res(struct net_device *netdev, int test)
2135 {
2136 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
2137 	struct qlcnic_host_sds_ring *sds_ring;
2138 	struct qlcnic_host_rds_ring *rds_ring;
2139 	int ring;
2140 	int ret;
2141 
2142 	netif_device_detach(netdev);
2143 
2144 	if (netif_running(netdev))
2145 		__qlcnic_down(adapter, netdev);
2146 
2147 	qlcnic_detach(adapter);
2148 
2149 	adapter->drv_sds_rings = QLCNIC_SINGLE_RING;
2150 	adapter->ahw->diag_test = test;
2151 	adapter->ahw->linkup = 0;
2152 
2153 	ret = qlcnic_attach(adapter);
2154 	if (ret) {
2155 		netif_device_attach(netdev);
2156 		return ret;
2157 	}
2158 
2159 	ret = qlcnic_fw_create_ctx(adapter);
2160 	if (ret) {
2161 		qlcnic_detach(adapter);
2162 		netif_device_attach(netdev);
2163 		return ret;
2164 	}
2165 
2166 	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
2167 		rds_ring = &adapter->recv_ctx->rds_rings[ring];
2168 		qlcnic_post_rx_buffers(adapter, rds_ring, ring);
2169 	}
2170 
2171 	if (adapter->ahw->diag_test == QLCNIC_INTERRUPT_TEST) {
2172 		for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
2173 			sds_ring = &adapter->recv_ctx->sds_rings[ring];
2174 			qlcnic_enable_sds_intr(adapter, sds_ring);
2175 		}
2176 	}
2177 
2178 	if (adapter->ahw->diag_test == QLCNIC_LOOPBACK_TEST) {
2179 		adapter->ahw->loopback_state = 0;
2180 		qlcnic_linkevent_request(adapter, 1);
2181 	}
2182 
2183 	set_bit(__QLCNIC_DEV_UP, &adapter->state);
2184 
2185 	return 0;
2186 }
2187 
2188 /* Reset context in hardware only */
2189 static int
2190 qlcnic_reset_hw_context(struct qlcnic_adapter *adapter)
2191 {
2192 	struct net_device *netdev = adapter->netdev;
2193 
2194 	if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2195 		return -EBUSY;
2196 
2197 	netif_device_detach(netdev);
2198 
2199 	qlcnic_down(adapter, netdev);
2200 
2201 	qlcnic_up(adapter, netdev);
2202 
2203 	netif_device_attach(netdev);
2204 
2205 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
2206 	netdev_info(adapter->netdev, "%s: soft reset complete\n", __func__);
2207 	return 0;
2208 }
2209 
2210 int
2211 qlcnic_reset_context(struct qlcnic_adapter *adapter)
2212 {
2213 	int err = 0;
2214 	struct net_device *netdev = adapter->netdev;
2215 
2216 	if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))
2217 		return -EBUSY;
2218 
2219 	if (adapter->is_up == QLCNIC_ADAPTER_UP_MAGIC) {
2220 
2221 		netif_device_detach(netdev);
2222 
2223 		if (netif_running(netdev))
2224 			__qlcnic_down(adapter, netdev);
2225 
2226 		qlcnic_detach(adapter);
2227 
2228 		if (netif_running(netdev)) {
2229 			err = qlcnic_attach(adapter);
2230 			if (!err) {
2231 				__qlcnic_up(adapter, netdev);
2232 				qlcnic_restore_indev_addr(netdev, NETDEV_UP);
2233 			}
2234 		}
2235 
2236 		netif_device_attach(netdev);
2237 	}
2238 
2239 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
2240 	return err;
2241 }
2242 
2243 static void qlcnic_82xx_set_mac_filter_count(struct qlcnic_adapter *adapter)
2244 {
2245 	struct qlcnic_hardware_context *ahw = adapter->ahw;
2246 	u16 act_pci_fn = ahw->total_nic_func;
2247 	u16 count;
2248 
2249 	ahw->max_mc_count = QLCNIC_MAX_MC_COUNT;
2250 	if (act_pci_fn <= 2)
2251 		count = (QLCNIC_MAX_UC_COUNT - QLCNIC_MAX_MC_COUNT) /
2252 			 act_pci_fn;
2253 	else
2254 		count = (QLCNIC_LB_MAX_FILTERS - QLCNIC_MAX_MC_COUNT) /
2255 			 act_pci_fn;
2256 	ahw->max_uc_count = count;
2257 }
2258 
2259 static int qlcnic_set_real_num_queues(struct qlcnic_adapter *adapter,
2260 				      u8 tx_queues, u8 rx_queues)
2261 {
2262 	struct net_device *netdev = adapter->netdev;
2263 	int err = 0;
2264 
2265 	if (tx_queues) {
2266 		err = netif_set_real_num_tx_queues(netdev, tx_queues);
2267 		if (err) {
2268 			netdev_err(netdev, "failed to set %d Tx queues\n",
2269 				   tx_queues);
2270 			return err;
2271 		}
2272 	}
2273 
2274 	if (rx_queues) {
2275 		err = netif_set_real_num_rx_queues(netdev, rx_queues);
2276 		if (err)
2277 			netdev_err(netdev, "failed to set %d Rx queues\n",
2278 				   rx_queues);
2279 	}
2280 
2281 	return err;
2282 }
2283 
2284 int
2285 qlcnic_setup_netdev(struct qlcnic_adapter *adapter, struct net_device *netdev,
2286 		    int pci_using_dac)
2287 {
2288 	int err;
2289 	struct pci_dev *pdev = adapter->pdev;
2290 
2291 	adapter->rx_csum = 1;
2292 	adapter->ahw->mc_enabled = 0;
2293 	qlcnic_set_mac_filter_count(adapter);
2294 
2295 	netdev->netdev_ops	   = &qlcnic_netdev_ops;
2296 	netdev->watchdog_timeo     = QLCNIC_WATCHDOG_TIMEOUTVALUE * HZ;
2297 
2298 	qlcnic_change_mtu(netdev, netdev->mtu);
2299 
2300 	netdev->ethtool_ops = (qlcnic_sriov_vf_check(adapter)) ?
2301 		&qlcnic_sriov_vf_ethtool_ops : &qlcnic_ethtool_ops;
2302 
2303 	netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM |
2304 			     NETIF_F_IPV6_CSUM | NETIF_F_GRO |
2305 			     NETIF_F_HW_VLAN_CTAG_RX);
2306 	netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM |
2307 				  NETIF_F_IPV6_CSUM);
2308 
2309 	if (QLCNIC_IS_TSO_CAPABLE(adapter)) {
2310 		netdev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
2311 		netdev->vlan_features |= (NETIF_F_TSO | NETIF_F_TSO6);
2312 	}
2313 
2314 	if (pci_using_dac) {
2315 		netdev->features |= NETIF_F_HIGHDMA;
2316 		netdev->vlan_features |= NETIF_F_HIGHDMA;
2317 	}
2318 
2319 	if (qlcnic_vlan_tx_check(adapter))
2320 		netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX);
2321 
2322 	if (qlcnic_sriov_vf_check(adapter))
2323 		netdev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
2324 
2325 	if (adapter->ahw->capabilities & QLCNIC_FW_CAPABILITY_HW_LRO)
2326 		netdev->features |= NETIF_F_LRO;
2327 
2328 	if (qlcnic_encap_tx_offload(adapter)) {
2329 		netdev->features |= NETIF_F_GSO_UDP_TUNNEL;
2330 
2331 		/* encapsulation Tx offload supported by Adapter */
2332 		netdev->hw_enc_features = NETIF_F_IP_CSUM        |
2333 					  NETIF_F_GSO_UDP_TUNNEL |
2334 					  NETIF_F_TSO            |
2335 					  NETIF_F_TSO6;
2336 	}
2337 
2338 	if (qlcnic_encap_rx_offload(adapter))
2339 		netdev->hw_enc_features |= NETIF_F_RXCSUM;
2340 
2341 	netdev->hw_features = netdev->features;
2342 	netdev->priv_flags |= IFF_UNICAST_FLT;
2343 	netdev->irq = adapter->msix_entries[0].vector;
2344 
2345 	/* MTU range: 68 - 9600 */
2346 	netdev->min_mtu = P3P_MIN_MTU;
2347 	netdev->max_mtu = P3P_MAX_MTU;
2348 
2349 	err = qlcnic_set_real_num_queues(adapter, adapter->drv_tx_rings,
2350 					 adapter->drv_sds_rings);
2351 	if (err)
2352 		return err;
2353 
2354 	qlcnic_dcb_init_dcbnl_ops(adapter->dcb);
2355 
2356 	err = register_netdev(netdev);
2357 	if (err) {
2358 		dev_err(&pdev->dev, "failed to register net device\n");
2359 		return err;
2360 	}
2361 
2362 	return 0;
2363 }
2364 
2365 static int qlcnic_set_dma_mask(struct pci_dev *pdev, int *pci_using_dac)
2366 {
2367 	if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) &&
2368 			!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2369 		*pci_using_dac = 1;
2370 	else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) &&
2371 			!pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))
2372 		*pci_using_dac = 0;
2373 	else {
2374 		dev_err(&pdev->dev, "Unable to set DMA mask, aborting\n");
2375 		return -EIO;
2376 	}
2377 
2378 	return 0;
2379 }
2380 
2381 void qlcnic_free_tx_rings(struct qlcnic_adapter *adapter)
2382 {
2383 	int ring;
2384 	struct qlcnic_host_tx_ring *tx_ring;
2385 
2386 	for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2387 		tx_ring = &adapter->tx_ring[ring];
2388 		if (tx_ring) {
2389 			vfree(tx_ring->cmd_buf_arr);
2390 			tx_ring->cmd_buf_arr = NULL;
2391 		}
2392 	}
2393 	kfree(adapter->tx_ring);
2394 }
2395 
2396 int qlcnic_alloc_tx_rings(struct qlcnic_adapter *adapter,
2397 			  struct net_device *netdev)
2398 {
2399 	int ring, vector, index;
2400 	struct qlcnic_host_tx_ring *tx_ring;
2401 	struct qlcnic_cmd_buffer *cmd_buf_arr;
2402 
2403 	tx_ring = kcalloc(adapter->drv_tx_rings,
2404 			  sizeof(struct qlcnic_host_tx_ring), GFP_KERNEL);
2405 	if (tx_ring == NULL)
2406 		return -ENOMEM;
2407 
2408 	adapter->tx_ring = tx_ring;
2409 
2410 	for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2411 		tx_ring = &adapter->tx_ring[ring];
2412 		tx_ring->num_desc = adapter->num_txd;
2413 		tx_ring->txq = netdev_get_tx_queue(netdev, ring);
2414 		cmd_buf_arr = vzalloc(TX_BUFF_RINGSIZE(tx_ring));
2415 		if (cmd_buf_arr == NULL) {
2416 			qlcnic_free_tx_rings(adapter);
2417 			return -ENOMEM;
2418 		}
2419 		tx_ring->cmd_buf_arr = cmd_buf_arr;
2420 		spin_lock_init(&tx_ring->tx_clean_lock);
2421 	}
2422 
2423 	if (qlcnic_83xx_check(adapter) ||
2424 	    (qlcnic_82xx_check(adapter) && qlcnic_check_multi_tx(adapter))) {
2425 		for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
2426 			tx_ring = &adapter->tx_ring[ring];
2427 			tx_ring->adapter = adapter;
2428 			if (adapter->flags & QLCNIC_MSIX_ENABLED) {
2429 				index = adapter->drv_sds_rings + ring;
2430 				vector = adapter->msix_entries[index].vector;
2431 				tx_ring->irq = vector;
2432 			}
2433 		}
2434 	}
2435 
2436 	return 0;
2437 }
2438 
2439 void qlcnic_set_drv_version(struct qlcnic_adapter *adapter)
2440 {
2441 	struct qlcnic_hardware_context *ahw = adapter->ahw;
2442 	u32 fw_cmd = 0;
2443 
2444 	if (qlcnic_82xx_check(adapter))
2445 		fw_cmd = QLCNIC_CMD_82XX_SET_DRV_VER;
2446 	else if (qlcnic_83xx_check(adapter))
2447 		fw_cmd = QLCNIC_CMD_83XX_SET_DRV_VER;
2448 
2449 	if (ahw->extra_capability[0] & QLCNIC_FW_CAPABILITY_SET_DRV_VER)
2450 		qlcnic_fw_cmd_set_drv_version(adapter, fw_cmd);
2451 }
2452 
2453 /* Reset firmware API lock */
2454 static void qlcnic_reset_api_lock(struct qlcnic_adapter *adapter)
2455 {
2456 	qlcnic_api_lock(adapter);
2457 	qlcnic_api_unlock(adapter);
2458 }
2459 
2460 
2461 static int
2462 qlcnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
2463 {
2464 	struct net_device *netdev = NULL;
2465 	struct qlcnic_adapter *adapter = NULL;
2466 	struct qlcnic_hardware_context *ahw;
2467 	int err, pci_using_dac = -1;
2468 	char board_name[QLCNIC_MAX_BOARD_NAME_LEN + 19]; /* MAC + ": " + name */
2469 
2470 	err = pci_enable_device(pdev);
2471 	if (err)
2472 		return err;
2473 
2474 	if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
2475 		err = -ENODEV;
2476 		goto err_out_disable_pdev;
2477 	}
2478 
2479 	err = qlcnic_set_dma_mask(pdev, &pci_using_dac);
2480 	if (err)
2481 		goto err_out_disable_pdev;
2482 
2483 	err = pci_request_regions(pdev, qlcnic_driver_name);
2484 	if (err)
2485 		goto err_out_disable_pdev;
2486 
2487 	pci_set_master(pdev);
2488 	pci_enable_pcie_error_reporting(pdev);
2489 
2490 	ahw = kzalloc(sizeof(struct qlcnic_hardware_context), GFP_KERNEL);
2491 	if (!ahw) {
2492 		err = -ENOMEM;
2493 		goto err_out_free_res;
2494 	}
2495 
2496 	switch (ent->device) {
2497 	case PCI_DEVICE_ID_QLOGIC_QLE824X:
2498 		ahw->hw_ops = &qlcnic_hw_ops;
2499 		ahw->reg_tbl = (u32 *) qlcnic_reg_tbl;
2500 		break;
2501 	case PCI_DEVICE_ID_QLOGIC_QLE834X:
2502 	case PCI_DEVICE_ID_QLOGIC_QLE8830:
2503 	case PCI_DEVICE_ID_QLOGIC_QLE844X:
2504 		qlcnic_83xx_register_map(ahw);
2505 		break;
2506 	case PCI_DEVICE_ID_QLOGIC_VF_QLE834X:
2507 	case PCI_DEVICE_ID_QLOGIC_VF_QLE8C30:
2508 	case PCI_DEVICE_ID_QLOGIC_VF_QLE844X:
2509 		qlcnic_sriov_vf_register_map(ahw);
2510 		break;
2511 	default:
2512 		goto err_out_free_hw_res;
2513 	}
2514 
2515 	err = qlcnic_setup_pci_map(pdev, ahw);
2516 	if (err)
2517 		goto err_out_free_hw_res;
2518 
2519 	netdev = alloc_etherdev_mq(sizeof(struct qlcnic_adapter),
2520 				   QLCNIC_MAX_TX_RINGS);
2521 	if (!netdev) {
2522 		err = -ENOMEM;
2523 		goto err_out_iounmap;
2524 	}
2525 
2526 	SET_NETDEV_DEV(netdev, &pdev->dev);
2527 
2528 	adapter = netdev_priv(netdev);
2529 	adapter->netdev  = netdev;
2530 	adapter->pdev    = pdev;
2531 	adapter->ahw = ahw;
2532 
2533 	adapter->qlcnic_wq = create_singlethread_workqueue("qlcnic");
2534 	if (adapter->qlcnic_wq == NULL) {
2535 		err = -ENOMEM;
2536 		dev_err(&pdev->dev, "Failed to create workqueue\n");
2537 		goto err_out_free_netdev;
2538 	}
2539 
2540 	err = qlcnic_alloc_adapter_resources(adapter);
2541 	if (err)
2542 		goto err_out_free_wq;
2543 
2544 	adapter->dev_rst_time = jiffies;
2545 	ahw->revision_id = pdev->revision;
2546 	ahw->max_vnic_func = qlcnic_get_vnic_func_count(adapter);
2547 	if (qlcnic_mac_learn == FDB_MAC_LEARN)
2548 		adapter->fdb_mac_learn = true;
2549 	else if (qlcnic_mac_learn == DRV_MAC_LEARN)
2550 		adapter->drv_mac_learn = true;
2551 
2552 	rwlock_init(&adapter->ahw->crb_lock);
2553 	mutex_init(&adapter->ahw->mem_lock);
2554 
2555 	INIT_LIST_HEAD(&adapter->mac_list);
2556 
2557 	qlcnic_register_dcb(adapter);
2558 
2559 	if (qlcnic_82xx_check(adapter)) {
2560 		qlcnic_check_vf(adapter, ent);
2561 		adapter->portnum = adapter->ahw->pci_func;
2562 		qlcnic_reset_api_lock(adapter);
2563 		err = qlcnic_start_firmware(adapter);
2564 		if (err) {
2565 			dev_err(&pdev->dev, "Loading fw failed.Please Reboot\n"
2566 				"\t\tIf reboot doesn't help, try flashing the card\n");
2567 			goto err_out_maintenance_mode;
2568 		}
2569 
2570 		/* compute and set default and max tx/sds rings */
2571 		if (adapter->ahw->msix_supported) {
2572 			if (qlcnic_check_multi_tx_capability(adapter) == 1)
2573 				qlcnic_set_tx_ring_count(adapter,
2574 							 QLCNIC_SINGLE_RING);
2575 			else
2576 				qlcnic_set_tx_ring_count(adapter,
2577 							 QLCNIC_DEF_TX_RINGS);
2578 			qlcnic_set_sds_ring_count(adapter,
2579 						  QLCNIC_DEF_SDS_RINGS);
2580 		} else {
2581 			qlcnic_set_tx_ring_count(adapter, QLCNIC_SINGLE_RING);
2582 			qlcnic_set_sds_ring_count(adapter, QLCNIC_SINGLE_RING);
2583 		}
2584 
2585 		err = qlcnic_setup_idc_param(adapter);
2586 		if (err)
2587 			goto err_out_free_hw;
2588 
2589 		adapter->flags |= QLCNIC_NEED_FLR;
2590 
2591 	} else if (qlcnic_83xx_check(adapter)) {
2592 		qlcnic_83xx_check_vf(adapter, ent);
2593 		adapter->portnum = adapter->ahw->pci_func;
2594 		err = qlcnic_83xx_init(adapter, pci_using_dac);
2595 		if (err) {
2596 			switch (err) {
2597 			case -ENOTRECOVERABLE:
2598 				dev_err(&pdev->dev, "Adapter initialization failed due to a faulty hardware\n");
2599 				dev_err(&pdev->dev, "Please replace the adapter with new one and return the faulty adapter for repair\n");
2600 				goto err_out_free_hw;
2601 			case -ENOMEM:
2602 				dev_err(&pdev->dev, "Adapter initialization failed. Please reboot\n");
2603 				goto err_out_free_hw;
2604 			case -EOPNOTSUPP:
2605 				dev_err(&pdev->dev, "Adapter initialization failed\n");
2606 				goto err_out_free_hw;
2607 			default:
2608 				dev_err(&pdev->dev, "Adapter initialization failed. Driver will load in maintenance mode to recover the adapter using the application\n");
2609 				goto err_out_maintenance_mode;
2610 			}
2611 		}
2612 
2613 		if (qlcnic_sriov_vf_check(adapter))
2614 			return 0;
2615 	} else {
2616 		dev_err(&pdev->dev,
2617 			"%s: failed. Please Reboot\n", __func__);
2618 		err = -ENODEV;
2619 		goto err_out_free_hw;
2620 	}
2621 
2622 	if (qlcnic_read_mac_addr(adapter))
2623 		dev_warn(&pdev->dev, "failed to read mac addr\n");
2624 
2625 	qlcnic_read_phys_port_id(adapter);
2626 
2627 	if (adapter->portnum == 0) {
2628 		qlcnic_get_board_name(adapter, board_name);
2629 
2630 		pr_info("%s: %s Board Chip rev 0x%x\n",
2631 			module_name(THIS_MODULE),
2632 			board_name, adapter->ahw->revision_id);
2633 	}
2634 
2635 	if (qlcnic_83xx_check(adapter) && !qlcnic_use_msi_x &&
2636 	    !!qlcnic_use_msi)
2637 		dev_warn(&pdev->dev,
2638 			 "Device does not support MSI interrupts\n");
2639 
2640 	if (qlcnic_82xx_check(adapter)) {
2641 		qlcnic_dcb_enable(adapter->dcb);
2642 		qlcnic_dcb_get_info(adapter->dcb);
2643 		err = qlcnic_setup_intr(adapter);
2644 
2645 		if (err) {
2646 			dev_err(&pdev->dev, "Failed to setup interrupt\n");
2647 			goto err_out_disable_msi;
2648 		}
2649 	}
2650 
2651 	err = qlcnic_get_act_pci_func(adapter);
2652 	if (err)
2653 		goto err_out_disable_mbx_intr;
2654 
2655 	if (adapter->portnum == 0)
2656 		qlcnic_set_drv_version(adapter);
2657 
2658 	err = qlcnic_setup_netdev(adapter, netdev, pci_using_dac);
2659 	if (err)
2660 		goto err_out_disable_mbx_intr;
2661 
2662 	pci_set_drvdata(pdev, adapter);
2663 
2664 	if (qlcnic_82xx_check(adapter))
2665 		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
2666 				     FW_POLL_DELAY);
2667 
2668 	switch (adapter->ahw->port_type) {
2669 	case QLCNIC_GBE:
2670 		dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
2671 				adapter->netdev->name);
2672 		break;
2673 	case QLCNIC_XGBE:
2674 		dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
2675 				adapter->netdev->name);
2676 		break;
2677 	}
2678 
2679 	if (adapter->drv_mac_learn)
2680 		qlcnic_alloc_lb_filters_mem(adapter);
2681 
2682 	qlcnic_add_sysfs(adapter);
2683 	qlcnic_register_hwmon_dev(adapter);
2684 	return 0;
2685 
2686 err_out_disable_mbx_intr:
2687 	if (qlcnic_83xx_check(adapter))
2688 		qlcnic_83xx_free_mbx_intr(adapter);
2689 
2690 err_out_disable_msi:
2691 	qlcnic_teardown_intr(adapter);
2692 	qlcnic_cancel_idc_work(adapter);
2693 	qlcnic_clr_all_drv_state(adapter, 0);
2694 
2695 err_out_free_hw:
2696 	qlcnic_free_adapter_resources(adapter);
2697 
2698 err_out_free_wq:
2699 	destroy_workqueue(adapter->qlcnic_wq);
2700 
2701 err_out_free_netdev:
2702 	free_netdev(netdev);
2703 
2704 err_out_iounmap:
2705 	qlcnic_cleanup_pci_map(ahw);
2706 
2707 err_out_free_hw_res:
2708 	kfree(ahw);
2709 
2710 err_out_free_res:
2711 	pci_release_regions(pdev);
2712 
2713 err_out_disable_pdev:
2714 	pci_disable_device(pdev);
2715 	return err;
2716 
2717 err_out_maintenance_mode:
2718 	set_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state);
2719 	netdev->netdev_ops = &qlcnic_netdev_failed_ops;
2720 	netdev->ethtool_ops = &qlcnic_ethtool_failed_ops;
2721 	ahw->port_type = QLCNIC_XGBE;
2722 
2723 	if (qlcnic_83xx_check(adapter))
2724 		adapter->tgt_status_reg = NULL;
2725 	else
2726 		ahw->board_type = QLCNIC_BRDTYPE_P3P_10G_SFP_PLUS;
2727 
2728 	err = register_netdev(netdev);
2729 
2730 	if (err) {
2731 		dev_err(&pdev->dev, "Failed to register net device\n");
2732 		qlcnic_clr_all_drv_state(adapter, 0);
2733 		goto err_out_free_hw;
2734 	}
2735 
2736 	pci_set_drvdata(pdev, adapter);
2737 	qlcnic_add_sysfs(adapter);
2738 
2739 	return 0;
2740 }
2741 
2742 static void qlcnic_remove(struct pci_dev *pdev)
2743 {
2744 	struct qlcnic_adapter *adapter;
2745 	struct net_device *netdev;
2746 	struct qlcnic_hardware_context *ahw;
2747 
2748 	adapter = pci_get_drvdata(pdev);
2749 	if (adapter == NULL)
2750 		return;
2751 
2752 	netdev = adapter->netdev;
2753 
2754 	qlcnic_cancel_idc_work(adapter);
2755 	qlcnic_sriov_pf_disable(adapter);
2756 	ahw = adapter->ahw;
2757 
2758 	unregister_netdev(netdev);
2759 	qlcnic_sriov_cleanup(adapter);
2760 
2761 	if (qlcnic_83xx_check(adapter)) {
2762 		qlcnic_83xx_initialize_nic(adapter, 0);
2763 		cancel_delayed_work_sync(&adapter->idc_aen_work);
2764 		qlcnic_83xx_free_mbx_intr(adapter);
2765 		qlcnic_83xx_detach_mailbox_work(adapter);
2766 		qlcnic_83xx_free_mailbox(ahw->mailbox);
2767 		kfree(ahw->fw_info);
2768 	}
2769 
2770 	qlcnic_dcb_free(adapter->dcb);
2771 	qlcnic_detach(adapter);
2772 	kfree(adapter->npars);
2773 	kfree(adapter->eswitch);
2774 
2775 	if (qlcnic_82xx_check(adapter))
2776 		qlcnic_clr_all_drv_state(adapter, 0);
2777 
2778 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
2779 
2780 	qlcnic_free_lb_filters_mem(adapter);
2781 
2782 	qlcnic_teardown_intr(adapter);
2783 
2784 	qlcnic_remove_sysfs(adapter);
2785 
2786 	qlcnic_unregister_hwmon_dev(adapter);
2787 
2788 	qlcnic_cleanup_pci_map(adapter->ahw);
2789 
2790 	qlcnic_release_firmware(adapter);
2791 
2792 	pci_disable_pcie_error_reporting(pdev);
2793 	pci_release_regions(pdev);
2794 	pci_disable_device(pdev);
2795 
2796 	if (adapter->qlcnic_wq) {
2797 		destroy_workqueue(adapter->qlcnic_wq);
2798 		adapter->qlcnic_wq = NULL;
2799 	}
2800 
2801 	qlcnic_free_adapter_resources(adapter);
2802 	kfree(ahw);
2803 	free_netdev(netdev);
2804 }
2805 
2806 static void qlcnic_shutdown(struct pci_dev *pdev)
2807 {
2808 	if (__qlcnic_shutdown(pdev))
2809 		return;
2810 
2811 	pci_disable_device(pdev);
2812 }
2813 
2814 #ifdef CONFIG_PM
2815 static int qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
2816 {
2817 	int retval;
2818 
2819 	retval = __qlcnic_shutdown(pdev);
2820 	if (retval)
2821 		return retval;
2822 
2823 	pci_set_power_state(pdev, pci_choose_state(pdev, state));
2824 	return 0;
2825 }
2826 
2827 static int qlcnic_resume(struct pci_dev *pdev)
2828 {
2829 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
2830 	int err;
2831 
2832 	err = pci_enable_device(pdev);
2833 	if (err)
2834 		return err;
2835 
2836 	pci_set_power_state(pdev, PCI_D0);
2837 	pci_set_master(pdev);
2838 	pci_restore_state(pdev);
2839 
2840 	return  __qlcnic_resume(adapter);
2841 }
2842 #endif
2843 
2844 static int qlcnic_open(struct net_device *netdev)
2845 {
2846 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
2847 	int err;
2848 
2849 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
2850 		netdev_err(netdev, "%s: Device is in non-operational state\n",
2851 			   __func__);
2852 
2853 		return -EIO;
2854 	}
2855 
2856 	netif_carrier_off(netdev);
2857 
2858 	err = qlcnic_attach(adapter);
2859 	if (err)
2860 		return err;
2861 
2862 	err = __qlcnic_up(adapter, netdev);
2863 	if (err)
2864 		qlcnic_detach(adapter);
2865 
2866 	return err;
2867 }
2868 
2869 /*
2870  * qlcnic_close - Disables a network interface entry point
2871  */
2872 static int qlcnic_close(struct net_device *netdev)
2873 {
2874 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
2875 
2876 	__qlcnic_down(adapter, netdev);
2877 
2878 	return 0;
2879 }
2880 
2881 #define QLCNIC_VF_LB_BUCKET_SIZE 1
2882 
2883 void qlcnic_alloc_lb_filters_mem(struct qlcnic_adapter *adapter)
2884 {
2885 	void *head;
2886 	int i;
2887 	struct net_device *netdev = adapter->netdev;
2888 	u32 filter_size = 0;
2889 	u16 act_pci_func = 0;
2890 
2891 	if (adapter->fhash.fmax && adapter->fhash.fhead)
2892 		return;
2893 
2894 	act_pci_func = adapter->ahw->total_nic_func;
2895 	spin_lock_init(&adapter->mac_learn_lock);
2896 	spin_lock_init(&adapter->rx_mac_learn_lock);
2897 
2898 	if (qlcnic_sriov_vf_check(adapter)) {
2899 		filter_size = QLCNIC_83XX_SRIOV_VF_MAX_MAC - 1;
2900 		adapter->fhash.fbucket_size = QLCNIC_VF_LB_BUCKET_SIZE;
2901 	} else if (qlcnic_82xx_check(adapter)) {
2902 		filter_size = QLCNIC_LB_MAX_FILTERS;
2903 		adapter->fhash.fbucket_size = QLCNIC_LB_BUCKET_SIZE;
2904 	} else {
2905 		filter_size = QLC_83XX_LB_MAX_FILTERS;
2906 		adapter->fhash.fbucket_size = QLC_83XX_LB_BUCKET_SIZE;
2907 	}
2908 
2909 	head = kcalloc(adapter->fhash.fbucket_size,
2910 		       sizeof(struct hlist_head), GFP_ATOMIC);
2911 
2912 	if (!head)
2913 		return;
2914 
2915 	adapter->fhash.fmax = (filter_size / act_pci_func);
2916 	adapter->fhash.fhead = head;
2917 
2918 	netdev_info(netdev, "active nic func = %d, mac filter size=%d\n",
2919 		    act_pci_func, adapter->fhash.fmax);
2920 
2921 	for (i = 0; i < adapter->fhash.fbucket_size; i++)
2922 		INIT_HLIST_HEAD(&adapter->fhash.fhead[i]);
2923 
2924 	adapter->rx_fhash.fbucket_size = adapter->fhash.fbucket_size;
2925 
2926 	head = kcalloc(adapter->rx_fhash.fbucket_size,
2927 		       sizeof(struct hlist_head), GFP_ATOMIC);
2928 
2929 	if (!head)
2930 		return;
2931 
2932 	adapter->rx_fhash.fmax = (filter_size / act_pci_func);
2933 	adapter->rx_fhash.fhead = head;
2934 
2935 	for (i = 0; i < adapter->rx_fhash.fbucket_size; i++)
2936 		INIT_HLIST_HEAD(&adapter->rx_fhash.fhead[i]);
2937 }
2938 
2939 static void qlcnic_free_lb_filters_mem(struct qlcnic_adapter *adapter)
2940 {
2941 	if (adapter->fhash.fmax)
2942 		kfree(adapter->fhash.fhead);
2943 
2944 	adapter->fhash.fhead = NULL;
2945 	adapter->fhash.fmax = 0;
2946 
2947 	if (adapter->rx_fhash.fmax)
2948 		kfree(adapter->rx_fhash.fhead);
2949 
2950 	adapter->rx_fhash.fmax = 0;
2951 	adapter->rx_fhash.fhead = NULL;
2952 }
2953 
2954 int qlcnic_check_temp(struct qlcnic_adapter *adapter)
2955 {
2956 	struct net_device *netdev = adapter->netdev;
2957 	u32 temp_state, temp_val, temp = 0;
2958 	int rv = 0;
2959 
2960 	if (qlcnic_83xx_check(adapter))
2961 		temp = QLCRDX(adapter->ahw, QLC_83XX_ASIC_TEMP);
2962 
2963 	if (qlcnic_82xx_check(adapter))
2964 		temp = QLC_SHARED_REG_RD32(adapter, QLCNIC_ASIC_TEMP);
2965 
2966 	temp_state = qlcnic_get_temp_state(temp);
2967 	temp_val = qlcnic_get_temp_val(temp);
2968 
2969 	if (temp_state == QLCNIC_TEMP_PANIC) {
2970 		dev_err(&netdev->dev,
2971 		       "Device temperature %d degrees C exceeds"
2972 		       " maximum allowed. Hardware has been shut down.\n",
2973 		       temp_val);
2974 		rv = 1;
2975 	} else if (temp_state == QLCNIC_TEMP_WARN) {
2976 		if (adapter->ahw->temp == QLCNIC_TEMP_NORMAL) {
2977 			dev_err(&netdev->dev,
2978 			       "Device temperature %d degrees C "
2979 			       "exceeds operating range."
2980 			       " Immediate action needed.\n",
2981 			       temp_val);
2982 		}
2983 	} else {
2984 		if (adapter->ahw->temp == QLCNIC_TEMP_WARN) {
2985 			dev_info(&netdev->dev,
2986 			       "Device temperature is now %d degrees C"
2987 			       " in normal range.\n", temp_val);
2988 		}
2989 	}
2990 	adapter->ahw->temp = temp_state;
2991 	return rv;
2992 }
2993 
2994 static inline void dump_tx_ring_desc(struct qlcnic_host_tx_ring *tx_ring)
2995 {
2996 	int i;
2997 
2998 	for (i = 0; i < tx_ring->num_desc; i++) {
2999 		pr_info("TX Desc: %d\n", i);
3000 		print_hex_dump(KERN_INFO, "TX: ", DUMP_PREFIX_OFFSET, 16, 1,
3001 			       &tx_ring->desc_head[i],
3002 			       sizeof(struct cmd_desc_type0), true);
3003 	}
3004 }
3005 
3006 static void qlcnic_dump_rings(struct qlcnic_adapter *adapter)
3007 {
3008 	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
3009 	struct net_device *netdev = adapter->netdev;
3010 	struct qlcnic_host_rds_ring *rds_ring;
3011 	struct qlcnic_host_sds_ring *sds_ring;
3012 	struct qlcnic_host_tx_ring *tx_ring;
3013 	int ring;
3014 
3015 	if (!netdev || !netif_running(netdev))
3016 		return;
3017 
3018 	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
3019 		rds_ring = &recv_ctx->rds_rings[ring];
3020 		if (!rds_ring)
3021 			continue;
3022 		netdev_info(netdev,
3023 			    "rds_ring=%d crb_rcv_producer=%d producer=%u num_desc=%u\n",
3024 			     ring, readl(rds_ring->crb_rcv_producer),
3025 			     rds_ring->producer, rds_ring->num_desc);
3026 	}
3027 
3028 	for (ring = 0; ring < adapter->drv_sds_rings; ring++) {
3029 		sds_ring = &(recv_ctx->sds_rings[ring]);
3030 		if (!sds_ring)
3031 			continue;
3032 		netdev_info(netdev,
3033 			    "sds_ring=%d crb_sts_consumer=%d consumer=%u crb_intr_mask=%d num_desc=%u\n",
3034 			    ring, readl(sds_ring->crb_sts_consumer),
3035 			    sds_ring->consumer, readl(sds_ring->crb_intr_mask),
3036 			    sds_ring->num_desc);
3037 	}
3038 
3039 	for (ring = 0; ring < adapter->drv_tx_rings; ring++) {
3040 		tx_ring = &adapter->tx_ring[ring];
3041 		if (!tx_ring)
3042 			continue;
3043 		netdev_info(netdev, "Tx ring=%d Context Id=0x%x\n",
3044 			    ring, tx_ring->ctx_id);
3045 		netdev_info(netdev,
3046 			    "xmit_finished=%llu, xmit_called=%llu, xmit_on=%llu, xmit_off=%llu\n",
3047 			    tx_ring->tx_stats.xmit_finished,
3048 			    tx_ring->tx_stats.xmit_called,
3049 			    tx_ring->tx_stats.xmit_on,
3050 			    tx_ring->tx_stats.xmit_off);
3051 
3052 		if (tx_ring->crb_intr_mask)
3053 			netdev_info(netdev, "crb_intr_mask=%d\n",
3054 				    readl(tx_ring->crb_intr_mask));
3055 
3056 		netdev_info(netdev,
3057 			    "hw_producer=%d, sw_producer=%d sw_consumer=%d, hw_consumer=%d\n",
3058 			    readl(tx_ring->crb_cmd_producer),
3059 			    tx_ring->producer, tx_ring->sw_consumer,
3060 			    le32_to_cpu(*(tx_ring->hw_consumer)));
3061 
3062 		netdev_info(netdev, "Total desc=%d, Available desc=%d\n",
3063 			    tx_ring->num_desc, qlcnic_tx_avail(tx_ring));
3064 
3065 		if (netif_msg_tx_err(adapter->ahw))
3066 			dump_tx_ring_desc(tx_ring);
3067 	}
3068 
3069 }
3070 
3071 static void qlcnic_tx_timeout(struct net_device *netdev, unsigned int txqueue)
3072 {
3073 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
3074 
3075 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3076 		return;
3077 
3078 	qlcnic_dump_rings(adapter);
3079 
3080 	if (++adapter->tx_timeo_cnt >= QLCNIC_MAX_TX_TIMEOUTS ||
3081 	    netif_msg_tx_err(adapter->ahw)) {
3082 		netdev_err(netdev, "Tx timeout, reset the adapter.\n");
3083 		if (qlcnic_82xx_check(adapter))
3084 			adapter->need_fw_reset = 1;
3085 		else if (qlcnic_83xx_check(adapter))
3086 			qlcnic_83xx_idc_request_reset(adapter,
3087 						      QLCNIC_FORCE_FW_DUMP_KEY);
3088 	} else {
3089 		netdev_err(netdev, "Tx timeout, reset adapter context.\n");
3090 		adapter->ahw->reset_context = 1;
3091 	}
3092 }
3093 
3094 static struct net_device_stats *qlcnic_get_stats(struct net_device *netdev)
3095 {
3096 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
3097 	struct net_device_stats *stats = &netdev->stats;
3098 
3099 	if (test_bit(__QLCNIC_DEV_UP, &adapter->state))
3100 		qlcnic_update_stats(adapter);
3101 
3102 	stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
3103 	stats->tx_packets = adapter->stats.xmitfinished;
3104 	stats->rx_bytes = adapter->stats.rxbytes + adapter->stats.lrobytes;
3105 	stats->tx_bytes = adapter->stats.txbytes;
3106 	stats->rx_dropped = adapter->stats.rxdropped;
3107 	stats->tx_dropped = adapter->stats.txdropped;
3108 
3109 	return stats;
3110 }
3111 
3112 static irqreturn_t qlcnic_82xx_clear_legacy_intr(struct qlcnic_adapter *adapter)
3113 {
3114 	u32 status;
3115 
3116 	status = readl(adapter->isr_int_vec);
3117 
3118 	if (!(status & adapter->ahw->int_vec_bit))
3119 		return IRQ_NONE;
3120 
3121 	/* check interrupt state machine, to be sure */
3122 	status = readl(adapter->crb_int_state_reg);
3123 	if (!ISR_LEGACY_INT_TRIGGERED(status))
3124 		return IRQ_NONE;
3125 
3126 	writel(0xffffffff, adapter->tgt_status_reg);
3127 	/* read twice to ensure write is flushed */
3128 	readl(adapter->isr_int_vec);
3129 	readl(adapter->isr_int_vec);
3130 
3131 	return IRQ_HANDLED;
3132 }
3133 
3134 static irqreturn_t qlcnic_tmp_intr(int irq, void *data)
3135 {
3136 	struct qlcnic_host_sds_ring *sds_ring = data;
3137 	struct qlcnic_adapter *adapter = sds_ring->adapter;
3138 
3139 	if (adapter->flags & QLCNIC_MSIX_ENABLED)
3140 		goto done;
3141 	else if (adapter->flags & QLCNIC_MSI_ENABLED) {
3142 		writel(0xffffffff, adapter->tgt_status_reg);
3143 		goto done;
3144 	}
3145 
3146 	if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3147 		return IRQ_NONE;
3148 
3149 done:
3150 	adapter->ahw->diag_cnt++;
3151 	qlcnic_enable_sds_intr(adapter, sds_ring);
3152 	return IRQ_HANDLED;
3153 }
3154 
3155 static irqreturn_t qlcnic_intr(int irq, void *data)
3156 {
3157 	struct qlcnic_host_sds_ring *sds_ring = data;
3158 	struct qlcnic_adapter *adapter = sds_ring->adapter;
3159 
3160 	if (qlcnic_clear_legacy_intr(adapter) == IRQ_NONE)
3161 		return IRQ_NONE;
3162 
3163 	napi_schedule(&sds_ring->napi);
3164 
3165 	return IRQ_HANDLED;
3166 }
3167 
3168 static irqreturn_t qlcnic_msi_intr(int irq, void *data)
3169 {
3170 	struct qlcnic_host_sds_ring *sds_ring = data;
3171 	struct qlcnic_adapter *adapter = sds_ring->adapter;
3172 
3173 	/* clear interrupt */
3174 	writel(0xffffffff, adapter->tgt_status_reg);
3175 
3176 	napi_schedule(&sds_ring->napi);
3177 	return IRQ_HANDLED;
3178 }
3179 
3180 static irqreturn_t qlcnic_msix_intr(int irq, void *data)
3181 {
3182 	struct qlcnic_host_sds_ring *sds_ring = data;
3183 
3184 	napi_schedule(&sds_ring->napi);
3185 	return IRQ_HANDLED;
3186 }
3187 
3188 static irqreturn_t qlcnic_msix_tx_intr(int irq, void *data)
3189 {
3190 	struct qlcnic_host_tx_ring *tx_ring = data;
3191 
3192 	napi_schedule(&tx_ring->napi);
3193 	return IRQ_HANDLED;
3194 }
3195 
3196 static void
3197 qlcnic_idc_debug_info(struct qlcnic_adapter *adapter, u8 encoding)
3198 {
3199 	u32 val;
3200 
3201 	val = adapter->portnum & 0xf;
3202 	val |= encoding << 7;
3203 	val |= (jiffies - adapter->dev_rst_time) << 8;
3204 
3205 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_SCRATCH, val);
3206 	adapter->dev_rst_time = jiffies;
3207 }
3208 
3209 static int
3210 qlcnic_set_drv_state(struct qlcnic_adapter *adapter, u8 state)
3211 {
3212 	u32  val;
3213 
3214 	WARN_ON(state != QLCNIC_DEV_NEED_RESET &&
3215 			state != QLCNIC_DEV_NEED_QUISCENT);
3216 
3217 	if (qlcnic_api_lock(adapter))
3218 		return -EIO;
3219 
3220 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3221 
3222 	if (state == QLCNIC_DEV_NEED_RESET)
3223 		QLC_DEV_SET_RST_RDY(val, adapter->portnum);
3224 	else if (state == QLCNIC_DEV_NEED_QUISCENT)
3225 		QLC_DEV_SET_QSCNT_RDY(val, adapter->portnum);
3226 
3227 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3228 
3229 	qlcnic_api_unlock(adapter);
3230 
3231 	return 0;
3232 }
3233 
3234 static int
3235 qlcnic_clr_drv_state(struct qlcnic_adapter *adapter)
3236 {
3237 	u32  val;
3238 
3239 	if (qlcnic_api_lock(adapter))
3240 		return -EBUSY;
3241 
3242 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3243 	QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
3244 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3245 
3246 	qlcnic_api_unlock(adapter);
3247 
3248 	return 0;
3249 }
3250 
3251 void qlcnic_clr_all_drv_state(struct qlcnic_adapter *adapter, u8 failed)
3252 {
3253 	u32  val;
3254 
3255 	if (qlcnic_api_lock(adapter))
3256 		goto err;
3257 
3258 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3259 	QLC_DEV_CLR_REF_CNT(val, adapter->portnum);
3260 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
3261 
3262 	if (failed) {
3263 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3264 				    QLCNIC_DEV_FAILED);
3265 		dev_info(&adapter->pdev->dev,
3266 				"Device state set to Failed. Please Reboot\n");
3267 	} else if (!(val & 0x11111111))
3268 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3269 				    QLCNIC_DEV_COLD);
3270 
3271 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3272 	QLC_DEV_CLR_RST_QSCNT(val, adapter->portnum);
3273 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3274 
3275 	qlcnic_api_unlock(adapter);
3276 err:
3277 	adapter->fw_fail_cnt = 0;
3278 	adapter->flags &= ~QLCNIC_FW_HANG;
3279 	clear_bit(__QLCNIC_START_FW, &adapter->state);
3280 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
3281 }
3282 
3283 /* Grab api lock, before checking state */
3284 static int
3285 qlcnic_check_drv_state(struct qlcnic_adapter *adapter)
3286 {
3287 	int act, state, active_mask;
3288 	struct qlcnic_hardware_context *ahw = adapter->ahw;
3289 
3290 	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3291 	act = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3292 
3293 	if (adapter->flags & QLCNIC_FW_RESET_OWNER) {
3294 		active_mask = (~(1 << (ahw->pci_func * 4)));
3295 		act = act & active_mask;
3296 	}
3297 
3298 	if (((state & 0x11111111) == (act & 0x11111111)) ||
3299 			((act & 0x11111111) == ((state >> 1) & 0x11111111)))
3300 		return 0;
3301 	else
3302 		return 1;
3303 }
3304 
3305 static int qlcnic_check_idc_ver(struct qlcnic_adapter *adapter)
3306 {
3307 	u32 val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_IDC_VER);
3308 
3309 	if (val != QLCNIC_DRV_IDC_VER) {
3310 		dev_warn(&adapter->pdev->dev, "IDC Version mismatch, driver's"
3311 			" idc ver = %x; reqd = %x\n", QLCNIC_DRV_IDC_VER, val);
3312 	}
3313 
3314 	return 0;
3315 }
3316 
3317 static int
3318 qlcnic_can_start_firmware(struct qlcnic_adapter *adapter)
3319 {
3320 	u32 val, prev_state;
3321 	u8 dev_init_timeo = adapter->dev_init_timeo;
3322 	u8 portnum = adapter->portnum;
3323 	u8 ret;
3324 
3325 	if (test_and_clear_bit(__QLCNIC_START_FW, &adapter->state))
3326 		return 1;
3327 
3328 	if (qlcnic_api_lock(adapter))
3329 		return -1;
3330 
3331 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_ACTIVE);
3332 	if (!(val & (1 << (portnum * 4)))) {
3333 		QLC_DEV_SET_REF_CNT(val, portnum);
3334 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_ACTIVE, val);
3335 	}
3336 
3337 	prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3338 	QLCDB(adapter, HW, "Device state = %u\n", prev_state);
3339 
3340 	switch (prev_state) {
3341 	case QLCNIC_DEV_COLD:
3342 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3343 				    QLCNIC_DEV_INITIALIZING);
3344 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_IDC_VER,
3345 				    QLCNIC_DRV_IDC_VER);
3346 		qlcnic_idc_debug_info(adapter, 0);
3347 		qlcnic_api_unlock(adapter);
3348 		return 1;
3349 
3350 	case QLCNIC_DEV_READY:
3351 		ret = qlcnic_check_idc_ver(adapter);
3352 		qlcnic_api_unlock(adapter);
3353 		return ret;
3354 
3355 	case QLCNIC_DEV_NEED_RESET:
3356 		val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3357 		QLC_DEV_SET_RST_RDY(val, portnum);
3358 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3359 		break;
3360 
3361 	case QLCNIC_DEV_NEED_QUISCENT:
3362 		val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3363 		QLC_DEV_SET_QSCNT_RDY(val, portnum);
3364 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3365 		break;
3366 
3367 	case QLCNIC_DEV_FAILED:
3368 		dev_err(&adapter->pdev->dev, "Device in failed state.\n");
3369 		qlcnic_api_unlock(adapter);
3370 		return -1;
3371 
3372 	case QLCNIC_DEV_INITIALIZING:
3373 	case QLCNIC_DEV_QUISCENT:
3374 		break;
3375 	}
3376 
3377 	qlcnic_api_unlock(adapter);
3378 
3379 	do {
3380 		msleep(1000);
3381 		prev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3382 
3383 		if (prev_state == QLCNIC_DEV_QUISCENT)
3384 			continue;
3385 	} while ((prev_state != QLCNIC_DEV_READY) && --dev_init_timeo);
3386 
3387 	if (!dev_init_timeo) {
3388 		dev_err(&adapter->pdev->dev,
3389 			"Waiting for device to initialize timeout\n");
3390 		return -1;
3391 	}
3392 
3393 	if (qlcnic_api_lock(adapter))
3394 		return -1;
3395 
3396 	val = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DRV_STATE);
3397 	QLC_DEV_CLR_RST_QSCNT(val, portnum);
3398 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DRV_STATE, val);
3399 
3400 	ret = qlcnic_check_idc_ver(adapter);
3401 	qlcnic_api_unlock(adapter);
3402 
3403 	return ret;
3404 }
3405 
3406 static void
3407 qlcnic_fwinit_work(struct work_struct *work)
3408 {
3409 	struct qlcnic_adapter *adapter = container_of(work,
3410 			struct qlcnic_adapter, fw_work.work);
3411 	u32 dev_state = 0xf;
3412 	u32 val;
3413 
3414 	if (qlcnic_api_lock(adapter))
3415 		goto err_ret;
3416 
3417 	dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3418 	if (dev_state == QLCNIC_DEV_QUISCENT ||
3419 	    dev_state == QLCNIC_DEV_NEED_QUISCENT) {
3420 		qlcnic_api_unlock(adapter);
3421 		qlcnic_schedule_work(adapter, qlcnic_fwinit_work,
3422 						FW_POLL_DELAY * 2);
3423 		return;
3424 	}
3425 
3426 	if (adapter->ahw->op_mode == QLCNIC_NON_PRIV_FUNC) {
3427 		qlcnic_api_unlock(adapter);
3428 		goto wait_npar;
3429 	}
3430 
3431 	if (dev_state == QLCNIC_DEV_INITIALIZING ||
3432 	    dev_state == QLCNIC_DEV_READY) {
3433 		dev_info(&adapter->pdev->dev, "Detected state change from "
3434 				"DEV_NEED_RESET, skipping ack check\n");
3435 		goto skip_ack_check;
3436 	}
3437 
3438 	if (adapter->fw_wait_cnt++ > adapter->reset_ack_timeo) {
3439 		dev_info(&adapter->pdev->dev, "Reset:Failed to get ack %d sec\n",
3440 					adapter->reset_ack_timeo);
3441 		goto skip_ack_check;
3442 	}
3443 
3444 	if (!qlcnic_check_drv_state(adapter)) {
3445 skip_ack_check:
3446 		dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3447 
3448 		if (dev_state == QLCNIC_DEV_NEED_RESET) {
3449 			QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3450 					    QLCNIC_DEV_INITIALIZING);
3451 			set_bit(__QLCNIC_START_FW, &adapter->state);
3452 			QLCDB(adapter, DRV, "Restarting fw\n");
3453 			qlcnic_idc_debug_info(adapter, 0);
3454 			val = QLC_SHARED_REG_RD32(adapter,
3455 						  QLCNIC_CRB_DRV_STATE);
3456 			QLC_DEV_SET_RST_RDY(val, adapter->portnum);
3457 			QLC_SHARED_REG_WR32(adapter,
3458 					    QLCNIC_CRB_DRV_STATE, val);
3459 		}
3460 
3461 		qlcnic_api_unlock(adapter);
3462 
3463 		rtnl_lock();
3464 		if (qlcnic_check_fw_dump_state(adapter) &&
3465 		    (adapter->flags & QLCNIC_FW_RESET_OWNER)) {
3466 			QLCDB(adapter, DRV, "Take FW dump\n");
3467 			qlcnic_dump_fw(adapter);
3468 			adapter->flags |= QLCNIC_FW_HANG;
3469 		}
3470 		rtnl_unlock();
3471 
3472 		adapter->flags &= ~QLCNIC_FW_RESET_OWNER;
3473 		if (!adapter->nic_ops->start_firmware(adapter)) {
3474 			qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
3475 			adapter->fw_wait_cnt = 0;
3476 			return;
3477 		}
3478 		goto err_ret;
3479 	}
3480 
3481 	qlcnic_api_unlock(adapter);
3482 
3483 wait_npar:
3484 	dev_state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3485 	QLCDB(adapter, HW, "Func waiting: Device state=%u\n", dev_state);
3486 
3487 	switch (dev_state) {
3488 	case QLCNIC_DEV_READY:
3489 		if (!qlcnic_start_firmware(adapter)) {
3490 			qlcnic_schedule_work(adapter, qlcnic_attach_work, 0);
3491 			adapter->fw_wait_cnt = 0;
3492 			return;
3493 		}
3494 	case QLCNIC_DEV_FAILED:
3495 		break;
3496 	default:
3497 		qlcnic_schedule_work(adapter,
3498 			qlcnic_fwinit_work, FW_POLL_DELAY);
3499 		return;
3500 	}
3501 
3502 err_ret:
3503 	dev_err(&adapter->pdev->dev, "Fwinit work failed state=%u "
3504 		"fw_wait_cnt=%u\n", dev_state, adapter->fw_wait_cnt);
3505 	netif_device_attach(adapter->netdev);
3506 	qlcnic_clr_all_drv_state(adapter, 0);
3507 }
3508 
3509 static void
3510 qlcnic_detach_work(struct work_struct *work)
3511 {
3512 	struct qlcnic_adapter *adapter = container_of(work,
3513 			struct qlcnic_adapter, fw_work.work);
3514 	struct net_device *netdev = adapter->netdev;
3515 	u32 status;
3516 
3517 	netif_device_detach(netdev);
3518 
3519 	/* Dont grab rtnl lock during Quiscent mode */
3520 	if (adapter->dev_state == QLCNIC_DEV_NEED_QUISCENT) {
3521 		if (netif_running(netdev))
3522 			__qlcnic_down(adapter, netdev);
3523 	} else
3524 		qlcnic_down(adapter, netdev);
3525 
3526 	status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3527 
3528 	if (status & QLCNIC_RCODE_FATAL_ERROR) {
3529 		dev_err(&adapter->pdev->dev,
3530 			"Detaching the device: peg halt status1=0x%x\n",
3531 					status);
3532 
3533 		if (QLCNIC_FWERROR_CODE(status) == QLCNIC_FWERROR_FAN_FAILURE) {
3534 			dev_err(&adapter->pdev->dev,
3535 			"On board active cooling fan failed. "
3536 				"Device has been halted.\n");
3537 			dev_err(&adapter->pdev->dev,
3538 				"Replace the adapter.\n");
3539 		}
3540 
3541 		goto err_ret;
3542 	}
3543 
3544 	if (adapter->ahw->temp == QLCNIC_TEMP_PANIC) {
3545 		dev_err(&adapter->pdev->dev, "Detaching the device: temp=%d\n",
3546 			adapter->ahw->temp);
3547 		goto err_ret;
3548 	}
3549 
3550 	/* Dont ack if this instance is the reset owner */
3551 	if (!(adapter->flags & QLCNIC_FW_RESET_OWNER)) {
3552 		if (qlcnic_set_drv_state(adapter, adapter->dev_state)) {
3553 			dev_err(&adapter->pdev->dev,
3554 				"Failed to set driver state,"
3555 					"detaching the device.\n");
3556 			goto err_ret;
3557 		}
3558 	}
3559 
3560 	adapter->fw_wait_cnt = 0;
3561 
3562 	qlcnic_schedule_work(adapter, qlcnic_fwinit_work, FW_POLL_DELAY);
3563 
3564 	return;
3565 
3566 err_ret:
3567 	netif_device_attach(netdev);
3568 	qlcnic_clr_all_drv_state(adapter, 1);
3569 }
3570 
3571 /*Transit NPAR state to NON Operational */
3572 static void
3573 qlcnic_set_npar_non_operational(struct qlcnic_adapter *adapter)
3574 {
3575 	u32 state;
3576 
3577 	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_NPAR_STATE);
3578 	if (state == QLCNIC_DEV_NPAR_NON_OPER)
3579 		return;
3580 
3581 	if (qlcnic_api_lock(adapter))
3582 		return;
3583 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3584 			    QLCNIC_DEV_NPAR_NON_OPER);
3585 	qlcnic_api_unlock(adapter);
3586 }
3587 
3588 static void qlcnic_82xx_dev_request_reset(struct qlcnic_adapter *adapter,
3589 					  u32 key)
3590 {
3591 	u32 state, xg_val = 0, gb_val = 0;
3592 
3593 	qlcnic_xg_set_xg0_mask(xg_val);
3594 	qlcnic_xg_set_xg1_mask(xg_val);
3595 	QLCWR32(adapter, QLCNIC_NIU_XG_PAUSE_CTL, xg_val);
3596 	qlcnic_gb_set_gb0_mask(gb_val);
3597 	qlcnic_gb_set_gb1_mask(gb_val);
3598 	qlcnic_gb_set_gb2_mask(gb_val);
3599 	qlcnic_gb_set_gb3_mask(gb_val);
3600 	QLCWR32(adapter, QLCNIC_NIU_GB_PAUSE_CTL, gb_val);
3601 	dev_info(&adapter->pdev->dev, "Pause control frames disabled"
3602 				" on all ports\n");
3603 	adapter->need_fw_reset = 1;
3604 
3605 	if (qlcnic_api_lock(adapter))
3606 		return;
3607 
3608 	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3609 
3610 	if (test_bit(__QLCNIC_MAINTENANCE_MODE, &adapter->state)) {
3611 		netdev_err(adapter->netdev, "%s: Device is in non-operational state\n",
3612 			   __func__);
3613 		qlcnic_api_unlock(adapter);
3614 
3615 		return;
3616 	}
3617 
3618 	if (state == QLCNIC_DEV_READY) {
3619 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3620 				    QLCNIC_DEV_NEED_RESET);
3621 		adapter->flags |= QLCNIC_FW_RESET_OWNER;
3622 		QLCDB(adapter, DRV, "NEED_RESET state set\n");
3623 		qlcnic_idc_debug_info(adapter, 0);
3624 	}
3625 
3626 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3627 			    QLCNIC_DEV_NPAR_NON_OPER);
3628 	qlcnic_api_unlock(adapter);
3629 }
3630 
3631 /* Transit to NPAR READY state from NPAR NOT READY state */
3632 static void
3633 qlcnic_dev_set_npar_ready(struct qlcnic_adapter *adapter)
3634 {
3635 	if (qlcnic_api_lock(adapter))
3636 		return;
3637 
3638 	QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_NPAR_STATE,
3639 			    QLCNIC_DEV_NPAR_OPER);
3640 	QLCDB(adapter, DRV, "NPAR operational state set\n");
3641 
3642 	qlcnic_api_unlock(adapter);
3643 }
3644 
3645 void qlcnic_schedule_work(struct qlcnic_adapter *adapter,
3646 			  work_func_t func, int delay)
3647 {
3648 	if (test_bit(__QLCNIC_AER, &adapter->state))
3649 		return;
3650 
3651 	INIT_DELAYED_WORK(&adapter->fw_work, func);
3652 	queue_delayed_work(adapter->qlcnic_wq, &adapter->fw_work,
3653 			   round_jiffies_relative(delay));
3654 }
3655 
3656 static void
3657 qlcnic_attach_work(struct work_struct *work)
3658 {
3659 	struct qlcnic_adapter *adapter = container_of(work,
3660 				struct qlcnic_adapter, fw_work.work);
3661 	struct net_device *netdev = adapter->netdev;
3662 	u32 npar_state;
3663 
3664 	if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC) {
3665 		npar_state = QLC_SHARED_REG_RD32(adapter,
3666 						 QLCNIC_CRB_DEV_NPAR_STATE);
3667 		if (adapter->fw_wait_cnt++ > QLCNIC_DEV_NPAR_OPER_TIMEO)
3668 			qlcnic_clr_all_drv_state(adapter, 0);
3669 		else if (npar_state != QLCNIC_DEV_NPAR_OPER)
3670 			qlcnic_schedule_work(adapter, qlcnic_attach_work,
3671 							FW_POLL_DELAY);
3672 		else
3673 			goto attach;
3674 		QLCDB(adapter, DRV, "Waiting for NPAR state to operational\n");
3675 		return;
3676 	}
3677 attach:
3678 	qlcnic_dcb_get_info(adapter->dcb);
3679 
3680 	if (netif_running(netdev)) {
3681 		if (qlcnic_up(adapter, netdev))
3682 			goto done;
3683 
3684 		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3685 	}
3686 
3687 done:
3688 	netif_device_attach(netdev);
3689 	adapter->fw_fail_cnt = 0;
3690 	adapter->flags &= ~QLCNIC_FW_HANG;
3691 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
3692 	if (adapter->portnum == 0)
3693 		qlcnic_set_drv_version(adapter);
3694 
3695 	if (!qlcnic_clr_drv_state(adapter))
3696 		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3697 							FW_POLL_DELAY);
3698 }
3699 
3700 static int
3701 qlcnic_check_health(struct qlcnic_adapter *adapter)
3702 {
3703 	struct qlcnic_hardware_context *ahw = adapter->ahw;
3704 	struct qlcnic_fw_dump *fw_dump = &ahw->fw_dump;
3705 	u32 state = 0, heartbeat;
3706 	u32 peg_status;
3707 	int err = 0;
3708 
3709 	if (qlcnic_check_temp(adapter))
3710 		goto detach;
3711 
3712 	if (adapter->need_fw_reset)
3713 		qlcnic_dev_request_reset(adapter, 0);
3714 
3715 	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3716 	if (state == QLCNIC_DEV_NEED_RESET) {
3717 		qlcnic_set_npar_non_operational(adapter);
3718 		adapter->need_fw_reset = 1;
3719 	} else if (state == QLCNIC_DEV_NEED_QUISCENT)
3720 		goto detach;
3721 
3722 	heartbeat = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_ALIVE_COUNTER);
3723 	if (heartbeat != adapter->heartbeat) {
3724 		adapter->heartbeat = heartbeat;
3725 		adapter->fw_fail_cnt = 0;
3726 		if (adapter->need_fw_reset)
3727 			goto detach;
3728 
3729 		if (ahw->reset_context && qlcnic_auto_fw_reset)
3730 			qlcnic_reset_hw_context(adapter);
3731 
3732 		return 0;
3733 	}
3734 
3735 	if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
3736 		return 0;
3737 
3738 	adapter->flags |= QLCNIC_FW_HANG;
3739 
3740 	qlcnic_dev_request_reset(adapter, 0);
3741 
3742 	if (qlcnic_auto_fw_reset)
3743 		clear_bit(__QLCNIC_FW_ATTACHED, &adapter->state);
3744 
3745 	dev_err(&adapter->pdev->dev, "firmware hang detected\n");
3746 	peg_status = QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS1);
3747 	dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
3748 			"PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
3749 			"PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
3750 			"PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
3751 			"PEG_NET_4_PC: 0x%x\n",
3752 			peg_status,
3753 			QLC_SHARED_REG_RD32(adapter, QLCNIC_PEG_HALT_STATUS2),
3754 			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_0 + 0x3c, &err),
3755 			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_1 + 0x3c, &err),
3756 			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_2 + 0x3c, &err),
3757 			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_3 + 0x3c, &err),
3758 			QLCRD32(adapter, QLCNIC_CRB_PEG_NET_4 + 0x3c, &err));
3759 	if (QLCNIC_FWERROR_CODE(peg_status) == 0x67)
3760 		dev_err(&adapter->pdev->dev,
3761 			"Firmware aborted with error code 0x00006700. "
3762 				"Device is being reset.\n");
3763 detach:
3764 	adapter->dev_state = (state == QLCNIC_DEV_NEED_QUISCENT) ? state :
3765 		QLCNIC_DEV_NEED_RESET;
3766 
3767 	if (qlcnic_auto_fw_reset && !test_and_set_bit(__QLCNIC_RESETTING,
3768 						      &adapter->state)) {
3769 
3770 		qlcnic_schedule_work(adapter, qlcnic_detach_work, 0);
3771 		QLCDB(adapter, DRV, "fw recovery scheduled.\n");
3772 	} else if (!qlcnic_auto_fw_reset && fw_dump->enable &&
3773 		   adapter->flags & QLCNIC_FW_RESET_OWNER) {
3774 		qlcnic_dump_fw(adapter);
3775 	}
3776 
3777 	return 1;
3778 }
3779 
3780 void qlcnic_fw_poll_work(struct work_struct *work)
3781 {
3782 	struct qlcnic_adapter *adapter = container_of(work,
3783 				struct qlcnic_adapter, fw_work.work);
3784 
3785 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
3786 		goto reschedule;
3787 
3788 
3789 	if (qlcnic_check_health(adapter))
3790 		return;
3791 
3792 	if (adapter->fhash.fnum)
3793 		qlcnic_prune_lb_filters(adapter);
3794 
3795 reschedule:
3796 	qlcnic_schedule_work(adapter, qlcnic_fw_poll_work, FW_POLL_DELAY);
3797 }
3798 
3799 static int qlcnic_is_first_func(struct pci_dev *pdev)
3800 {
3801 	struct pci_dev *oth_pdev;
3802 	int val = pdev->devfn;
3803 
3804 	while (val-- > 0) {
3805 		oth_pdev = pci_get_domain_bus_and_slot(pci_domain_nr
3806 			(pdev->bus), pdev->bus->number,
3807 			PCI_DEVFN(PCI_SLOT(pdev->devfn), val));
3808 		if (!oth_pdev)
3809 			continue;
3810 
3811 		if (oth_pdev->current_state != PCI_D3cold) {
3812 			pci_dev_put(oth_pdev);
3813 			return 0;
3814 		}
3815 		pci_dev_put(oth_pdev);
3816 	}
3817 	return 1;
3818 }
3819 
3820 static int qlcnic_attach_func(struct pci_dev *pdev)
3821 {
3822 	int err, first_func;
3823 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3824 	struct net_device *netdev = adapter->netdev;
3825 
3826 	pdev->error_state = pci_channel_io_normal;
3827 
3828 	err = pci_enable_device(pdev);
3829 	if (err)
3830 		return err;
3831 
3832 	pci_set_master(pdev);
3833 	pci_restore_state(pdev);
3834 
3835 	first_func = qlcnic_is_first_func(pdev);
3836 
3837 	if (qlcnic_api_lock(adapter))
3838 		return -EINVAL;
3839 
3840 	if (adapter->ahw->op_mode != QLCNIC_NON_PRIV_FUNC && first_func) {
3841 		adapter->need_fw_reset = 1;
3842 		set_bit(__QLCNIC_START_FW, &adapter->state);
3843 		QLC_SHARED_REG_WR32(adapter, QLCNIC_CRB_DEV_STATE,
3844 				    QLCNIC_DEV_INITIALIZING);
3845 		QLCDB(adapter, DRV, "Restarting fw\n");
3846 	}
3847 	qlcnic_api_unlock(adapter);
3848 
3849 	err = qlcnic_start_firmware(adapter);
3850 	if (err)
3851 		return err;
3852 
3853 	qlcnic_clr_drv_state(adapter);
3854 	kfree(adapter->msix_entries);
3855 	adapter->msix_entries = NULL;
3856 	err = qlcnic_setup_intr(adapter);
3857 
3858 	if (err) {
3859 		kfree(adapter->msix_entries);
3860 		netdev_err(netdev, "failed to setup interrupt\n");
3861 		return err;
3862 	}
3863 
3864 	if (netif_running(netdev)) {
3865 		err = qlcnic_attach(adapter);
3866 		if (err) {
3867 			qlcnic_clr_all_drv_state(adapter, 1);
3868 			clear_bit(__QLCNIC_AER, &adapter->state);
3869 			netif_device_attach(netdev);
3870 			return err;
3871 		}
3872 
3873 		err = qlcnic_up(adapter, netdev);
3874 		if (err)
3875 			goto done;
3876 
3877 		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
3878 	}
3879  done:
3880 	netif_device_attach(netdev);
3881 	return err;
3882 }
3883 
3884 static pci_ers_result_t qlcnic_82xx_io_error_detected(struct pci_dev *pdev,
3885 						      pci_channel_state_t state)
3886 {
3887 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3888 	struct net_device *netdev = adapter->netdev;
3889 
3890 	if (state == pci_channel_io_perm_failure)
3891 		return PCI_ERS_RESULT_DISCONNECT;
3892 
3893 	if (state == pci_channel_io_normal)
3894 		return PCI_ERS_RESULT_RECOVERED;
3895 
3896 	set_bit(__QLCNIC_AER, &adapter->state);
3897 	netif_device_detach(netdev);
3898 
3899 	cancel_delayed_work_sync(&adapter->fw_work);
3900 
3901 	if (netif_running(netdev))
3902 		qlcnic_down(adapter, netdev);
3903 
3904 	qlcnic_detach(adapter);
3905 	qlcnic_teardown_intr(adapter);
3906 
3907 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
3908 
3909 	pci_save_state(pdev);
3910 	pci_disable_device(pdev);
3911 
3912 	return PCI_ERS_RESULT_NEED_RESET;
3913 }
3914 
3915 static pci_ers_result_t qlcnic_82xx_io_slot_reset(struct pci_dev *pdev)
3916 {
3917 	pci_ers_result_t res;
3918 
3919 	rtnl_lock();
3920 	res = qlcnic_attach_func(pdev) ? PCI_ERS_RESULT_DISCONNECT :
3921 					 PCI_ERS_RESULT_RECOVERED;
3922 	rtnl_unlock();
3923 
3924 	return res;
3925 }
3926 
3927 static void qlcnic_82xx_io_resume(struct pci_dev *pdev)
3928 {
3929 	u32 state;
3930 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3931 
3932 	state = QLC_SHARED_REG_RD32(adapter, QLCNIC_CRB_DEV_STATE);
3933 	if (state == QLCNIC_DEV_READY && test_and_clear_bit(__QLCNIC_AER,
3934 							    &adapter->state))
3935 		qlcnic_schedule_work(adapter, qlcnic_fw_poll_work,
3936 				     FW_POLL_DELAY);
3937 }
3938 
3939 static pci_ers_result_t qlcnic_io_error_detected(struct pci_dev *pdev,
3940 						 pci_channel_state_t state)
3941 {
3942 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3943 	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3944 
3945 	if (hw_ops->io_error_detected) {
3946 		return hw_ops->io_error_detected(pdev, state);
3947 	} else {
3948 		dev_err(&pdev->dev, "AER error_detected handler not registered.\n");
3949 		return PCI_ERS_RESULT_DISCONNECT;
3950 	}
3951 }
3952 
3953 static pci_ers_result_t qlcnic_io_slot_reset(struct pci_dev *pdev)
3954 {
3955 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3956 	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3957 
3958 	if (hw_ops->io_slot_reset) {
3959 		return hw_ops->io_slot_reset(pdev);
3960 	} else {
3961 		dev_err(&pdev->dev, "AER slot_reset handler not registered.\n");
3962 		return PCI_ERS_RESULT_DISCONNECT;
3963 	}
3964 }
3965 
3966 static void qlcnic_io_resume(struct pci_dev *pdev)
3967 {
3968 	struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
3969 	struct qlcnic_hardware_ops *hw_ops = adapter->ahw->hw_ops;
3970 
3971 	if (hw_ops->io_resume)
3972 		hw_ops->io_resume(pdev);
3973 	else
3974 		dev_err(&pdev->dev, "AER resume handler not registered.\n");
3975 }
3976 
3977 
3978 static int
3979 qlcnicvf_start_firmware(struct qlcnic_adapter *adapter)
3980 {
3981 	int err;
3982 
3983 	err = qlcnic_can_start_firmware(adapter);
3984 	if (err)
3985 		return err;
3986 
3987 	err = qlcnic_check_npar_opertional(adapter);
3988 	if (err)
3989 		return err;
3990 
3991 	err = qlcnic_initialize_nic(adapter);
3992 	if (err)
3993 		return err;
3994 
3995 	qlcnic_check_options(adapter);
3996 
3997 	err = qlcnic_set_eswitch_port_config(adapter);
3998 	if (err)
3999 		return err;
4000 
4001 	adapter->need_fw_reset = 0;
4002 
4003 	return err;
4004 }
4005 
4006 int qlcnic_validate_rings(struct qlcnic_adapter *adapter, __u32 ring_cnt,
4007 			  int queue_type)
4008 {
4009 	struct net_device *netdev = adapter->netdev;
4010 	char buf[8];
4011 
4012 	if (queue_type == QLCNIC_RX_QUEUE)
4013 		strcpy(buf, "SDS");
4014 	else
4015 		strcpy(buf, "Tx");
4016 
4017 	if (!is_power_of_2(ring_cnt)) {
4018 		netdev_err(netdev, "%s rings value should be a power of 2\n",
4019 			   buf);
4020 		return -EINVAL;
4021 	}
4022 
4023 	if (qlcnic_82xx_check(adapter) && (queue_type == QLCNIC_TX_QUEUE) &&
4024 	    !qlcnic_check_multi_tx(adapter)) {
4025 			netdev_err(netdev, "No Multi Tx queue support\n");
4026 			return -EINVAL;
4027 	}
4028 
4029 	if (ring_cnt > num_online_cpus()) {
4030 		netdev_err(netdev,
4031 			   "%s value[%u] should not be higher than, number of online CPUs\n",
4032 			   buf, num_online_cpus());
4033 		return -EINVAL;
4034 	}
4035 
4036 	return 0;
4037 }
4038 
4039 int qlcnic_setup_rings(struct qlcnic_adapter *adapter)
4040 {
4041 	struct net_device *netdev = adapter->netdev;
4042 	u8 tx_rings, rx_rings;
4043 	int err;
4044 
4045 	if (test_bit(__QLCNIC_RESETTING, &adapter->state))
4046 		return -EBUSY;
4047 
4048 	tx_rings = adapter->drv_tss_rings;
4049 	rx_rings = adapter->drv_rss_rings;
4050 
4051 	netif_device_detach(netdev);
4052 
4053 	err = qlcnic_set_real_num_queues(adapter, tx_rings, rx_rings);
4054 	if (err)
4055 		goto done;
4056 
4057 	if (netif_running(netdev))
4058 		__qlcnic_down(adapter, netdev);
4059 
4060 	qlcnic_detach(adapter);
4061 
4062 	if (qlcnic_83xx_check(adapter)) {
4063 		qlcnic_83xx_free_mbx_intr(adapter);
4064 		qlcnic_83xx_enable_mbx_poll(adapter);
4065 	}
4066 
4067 	qlcnic_teardown_intr(adapter);
4068 
4069 	err = qlcnic_setup_intr(adapter);
4070 	if (err) {
4071 		kfree(adapter->msix_entries);
4072 		netdev_err(netdev, "failed to setup interrupt\n");
4073 		return err;
4074 	}
4075 
4076 	/* Check if we need to update real_num_{tx|rx}_queues because
4077 	 * qlcnic_setup_intr() may change Tx/Rx rings size
4078 	 */
4079 	if ((tx_rings != adapter->drv_tx_rings) ||
4080 	    (rx_rings != adapter->drv_sds_rings)) {
4081 		err = qlcnic_set_real_num_queues(adapter,
4082 						 adapter->drv_tx_rings,
4083 						 adapter->drv_sds_rings);
4084 		if (err)
4085 			goto done;
4086 	}
4087 
4088 	if (qlcnic_83xx_check(adapter)) {
4089 		qlcnic_83xx_initialize_nic(adapter, 1);
4090 		err = qlcnic_83xx_setup_mbx_intr(adapter);
4091 		qlcnic_83xx_disable_mbx_poll(adapter);
4092 		if (err) {
4093 			dev_err(&adapter->pdev->dev,
4094 				"failed to setup mbx interrupt\n");
4095 			goto done;
4096 		}
4097 	}
4098 
4099 	if (netif_running(netdev)) {
4100 		err = qlcnic_attach(adapter);
4101 		if (err)
4102 			goto done;
4103 		err = __qlcnic_up(adapter, netdev);
4104 		if (err)
4105 			goto done;
4106 		qlcnic_restore_indev_addr(netdev, NETDEV_UP);
4107 	}
4108 done:
4109 	netif_device_attach(netdev);
4110 	clear_bit(__QLCNIC_RESETTING, &adapter->state);
4111 	return err;
4112 }
4113 
4114 #ifdef CONFIG_INET
4115 
4116 #define is_qlcnic_netdev(dev) (dev->netdev_ops == &qlcnic_netdev_ops)
4117 
4118 static void
4119 qlcnic_config_indev_addr(struct qlcnic_adapter *adapter,
4120 			struct net_device *dev, unsigned long event)
4121 {
4122 	const struct in_ifaddr *ifa;
4123 	struct in_device *indev;
4124 
4125 	indev = in_dev_get(dev);
4126 	if (!indev)
4127 		return;
4128 
4129 	in_dev_for_each_ifa_rtnl(ifa, indev) {
4130 		switch (event) {
4131 		case NETDEV_UP:
4132 			qlcnic_config_ipaddr(adapter,
4133 					ifa->ifa_address, QLCNIC_IP_UP);
4134 			break;
4135 		case NETDEV_DOWN:
4136 			qlcnic_config_ipaddr(adapter,
4137 					ifa->ifa_address, QLCNIC_IP_DOWN);
4138 			break;
4139 		default:
4140 			break;
4141 		}
4142 	}
4143 
4144 	in_dev_put(indev);
4145 }
4146 
4147 void qlcnic_restore_indev_addr(struct net_device *netdev, unsigned long event)
4148 {
4149 	struct qlcnic_adapter *adapter = netdev_priv(netdev);
4150 	struct net_device *dev;
4151 	u16 vid;
4152 
4153 	qlcnic_config_indev_addr(adapter, netdev, event);
4154 
4155 	rcu_read_lock();
4156 	for_each_set_bit(vid, adapter->vlans, VLAN_N_VID) {
4157 		dev = __vlan_find_dev_deep_rcu(netdev, htons(ETH_P_8021Q), vid);
4158 		if (!dev)
4159 			continue;
4160 		qlcnic_config_indev_addr(adapter, dev, event);
4161 	}
4162 	rcu_read_unlock();
4163 }
4164 
4165 static int qlcnic_netdev_event(struct notifier_block *this,
4166 				 unsigned long event, void *ptr)
4167 {
4168 	struct qlcnic_adapter *adapter;
4169 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
4170 
4171 recheck:
4172 	if (dev == NULL)
4173 		goto done;
4174 
4175 	if (is_vlan_dev(dev)) {
4176 		dev = vlan_dev_real_dev(dev);
4177 		goto recheck;
4178 	}
4179 
4180 	if (!is_qlcnic_netdev(dev))
4181 		goto done;
4182 
4183 	adapter = netdev_priv(dev);
4184 
4185 	if (!adapter)
4186 		goto done;
4187 
4188 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4189 		goto done;
4190 
4191 	qlcnic_config_indev_addr(adapter, dev, event);
4192 done:
4193 	return NOTIFY_DONE;
4194 }
4195 
4196 static int
4197 qlcnic_inetaddr_event(struct notifier_block *this,
4198 		unsigned long event, void *ptr)
4199 {
4200 	struct qlcnic_adapter *adapter;
4201 	struct net_device *dev;
4202 
4203 	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
4204 
4205 	dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
4206 
4207 recheck:
4208 	if (dev == NULL)
4209 		goto done;
4210 
4211 	if (is_vlan_dev(dev)) {
4212 		dev = vlan_dev_real_dev(dev);
4213 		goto recheck;
4214 	}
4215 
4216 	if (!is_qlcnic_netdev(dev))
4217 		goto done;
4218 
4219 	adapter = netdev_priv(dev);
4220 
4221 	if (!adapter)
4222 		goto done;
4223 
4224 	if (!test_bit(__QLCNIC_DEV_UP, &adapter->state))
4225 		goto done;
4226 
4227 	switch (event) {
4228 	case NETDEV_UP:
4229 		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_UP);
4230 
4231 		break;
4232 	case NETDEV_DOWN:
4233 		qlcnic_config_ipaddr(adapter, ifa->ifa_address, QLCNIC_IP_DOWN);
4234 
4235 		break;
4236 	default:
4237 		break;
4238 	}
4239 
4240 done:
4241 	return NOTIFY_DONE;
4242 }
4243 
4244 static struct notifier_block	qlcnic_netdev_cb = {
4245 	.notifier_call = qlcnic_netdev_event,
4246 };
4247 
4248 static struct notifier_block qlcnic_inetaddr_cb = {
4249 	.notifier_call = qlcnic_inetaddr_event,
4250 };
4251 #else
4252 void qlcnic_restore_indev_addr(struct net_device *dev, unsigned long event)
4253 { }
4254 #endif
4255 static const struct pci_error_handlers qlcnic_err_handler = {
4256 	.error_detected = qlcnic_io_error_detected,
4257 	.slot_reset = qlcnic_io_slot_reset,
4258 	.resume = qlcnic_io_resume,
4259 };
4260 
4261 static struct pci_driver qlcnic_driver = {
4262 	.name = qlcnic_driver_name,
4263 	.id_table = qlcnic_pci_tbl,
4264 	.probe = qlcnic_probe,
4265 	.remove = qlcnic_remove,
4266 #ifdef CONFIG_PM
4267 	.suspend = qlcnic_suspend,
4268 	.resume = qlcnic_resume,
4269 #endif
4270 	.shutdown = qlcnic_shutdown,
4271 	.err_handler = &qlcnic_err_handler,
4272 #ifdef CONFIG_QLCNIC_SRIOV
4273 	.sriov_configure = qlcnic_pci_sriov_configure,
4274 #endif
4275 
4276 };
4277 
4278 static int __init qlcnic_init_module(void)
4279 {
4280 	int ret;
4281 
4282 	printk(KERN_INFO "%s\n", qlcnic_driver_string);
4283 
4284 #ifdef CONFIG_INET
4285 	register_netdevice_notifier(&qlcnic_netdev_cb);
4286 	register_inetaddr_notifier(&qlcnic_inetaddr_cb);
4287 #endif
4288 
4289 	ret = pci_register_driver(&qlcnic_driver);
4290 	if (ret) {
4291 #ifdef CONFIG_INET
4292 		unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4293 		unregister_netdevice_notifier(&qlcnic_netdev_cb);
4294 #endif
4295 	}
4296 
4297 	return ret;
4298 }
4299 
4300 module_init(qlcnic_init_module);
4301 
4302 static void __exit qlcnic_exit_module(void)
4303 {
4304 	pci_unregister_driver(&qlcnic_driver);
4305 
4306 #ifdef CONFIG_INET
4307 	unregister_inetaddr_notifier(&qlcnic_inetaddr_cb);
4308 	unregister_netdevice_notifier(&qlcnic_netdev_cb);
4309 #endif
4310 }
4311 
4312 module_exit(qlcnic_exit_module);
4313