1 /*
2  * Copyright (C) 2003 - 2009 NetXen, Inc.
3  * Copyright (C) 2009 - QLogic Corporation.
4  * All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  *
19  * The full GNU General Public License is included in this distribution
20  * in the file called "COPYING".
21  *
22  */
23 
24 #include <linux/slab.h>
25 #include <linux/vmalloc.h>
26 #include <linux/interrupt.h>
27 #include "netxen_nic_hw.h"
28 
29 #include "netxen_nic.h"
30 
31 #include <linux/dma-mapping.h>
32 #include <linux/if_vlan.h>
33 #include <net/ip.h>
34 #include <linux/ipv6.h>
35 #include <linux/inetdevice.h>
36 #include <linux/sysfs.h>
37 #include <linux/aer.h>
38 
39 MODULE_DESCRIPTION("QLogic/NetXen (1/10) GbE Intelligent Ethernet Driver");
40 MODULE_LICENSE("GPL");
41 MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID);
42 MODULE_FIRMWARE(NX_UNIFIED_ROMIMAGE_NAME);
43 
44 char netxen_nic_driver_name[] = "netxen_nic";
45 static char netxen_nic_driver_string[] = "QLogic/NetXen Network Driver v"
46     NETXEN_NIC_LINUX_VERSIONID;
47 
48 static int port_mode = NETXEN_PORT_MODE_AUTO_NEG;
49 
50 /* Default to restricted 1G auto-neg mode */
51 static int wol_port_mode = 5;
52 
53 static int use_msi = 1;
54 
55 static int use_msi_x = 1;
56 
57 static int auto_fw_reset = AUTO_FW_RESET_ENABLED;
58 module_param(auto_fw_reset, int, 0644);
59 MODULE_PARM_DESC(auto_fw_reset,"Auto firmware reset (0=disabled, 1=enabled");
60 
61 static int netxen_nic_probe(struct pci_dev *pdev,
62 		const struct pci_device_id *ent);
63 static void netxen_nic_remove(struct pci_dev *pdev);
64 static int netxen_nic_open(struct net_device *netdev);
65 static int netxen_nic_close(struct net_device *netdev);
66 static netdev_tx_t netxen_nic_xmit_frame(struct sk_buff *,
67 					       struct net_device *);
68 static void netxen_tx_timeout(struct net_device *netdev);
69 static void netxen_tx_timeout_task(struct work_struct *work);
70 static void netxen_fw_poll_work(struct work_struct *work);
71 static void netxen_schedule_work(struct netxen_adapter *adapter,
72 		work_func_t func, int delay);
73 static void netxen_cancel_fw_work(struct netxen_adapter *adapter);
74 static int netxen_nic_poll(struct napi_struct *napi, int budget);
75 #ifdef CONFIG_NET_POLL_CONTROLLER
76 static void netxen_nic_poll_controller(struct net_device *netdev);
77 #endif
78 
79 static void netxen_create_sysfs_entries(struct netxen_adapter *adapter);
80 static void netxen_remove_sysfs_entries(struct netxen_adapter *adapter);
81 static void netxen_create_diag_entries(struct netxen_adapter *adapter);
82 static void netxen_remove_diag_entries(struct netxen_adapter *adapter);
83 static int nx_dev_request_aer(struct netxen_adapter *adapter);
84 static int nx_decr_dev_ref_cnt(struct netxen_adapter *adapter);
85 static int netxen_can_start_firmware(struct netxen_adapter *adapter);
86 
87 static irqreturn_t netxen_intr(int irq, void *data);
88 static irqreturn_t netxen_msi_intr(int irq, void *data);
89 static irqreturn_t netxen_msix_intr(int irq, void *data);
90 
91 static void netxen_free_ip_list(struct netxen_adapter *, bool);
92 static void netxen_restore_indev_addr(struct net_device *dev, unsigned long);
93 static void netxen_nic_get_stats(struct net_device *dev,
94 				 struct rtnl_link_stats64 *stats);
95 static int netxen_nic_set_mac(struct net_device *netdev, void *p);
96 
97 /*  PCI Device ID Table  */
98 #define ENTRY(device) \
99 	{PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
100 	.class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
101 
102 static const struct pci_device_id netxen_pci_tbl[] = {
103 	ENTRY(PCI_DEVICE_ID_NX2031_10GXSR),
104 	ENTRY(PCI_DEVICE_ID_NX2031_10GCX4),
105 	ENTRY(PCI_DEVICE_ID_NX2031_4GCU),
106 	ENTRY(PCI_DEVICE_ID_NX2031_IMEZ),
107 	ENTRY(PCI_DEVICE_ID_NX2031_HMEZ),
108 	ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT),
109 	ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2),
110 	ENTRY(PCI_DEVICE_ID_NX3031),
111 	{0,}
112 };
113 
114 MODULE_DEVICE_TABLE(pci, netxen_pci_tbl);
115 
116 static uint32_t crb_cmd_producer[4] = {
117 	CRB_CMD_PRODUCER_OFFSET, CRB_CMD_PRODUCER_OFFSET_1,
118 	CRB_CMD_PRODUCER_OFFSET_2, CRB_CMD_PRODUCER_OFFSET_3
119 };
120 
121 void
122 netxen_nic_update_cmd_producer(struct netxen_adapter *adapter,
123 		struct nx_host_tx_ring *tx_ring)
124 {
125 	NXWRIO(adapter, tx_ring->crb_cmd_producer, tx_ring->producer);
126 }
127 
128 static uint32_t crb_cmd_consumer[4] = {
129 	CRB_CMD_CONSUMER_OFFSET, CRB_CMD_CONSUMER_OFFSET_1,
130 	CRB_CMD_CONSUMER_OFFSET_2, CRB_CMD_CONSUMER_OFFSET_3
131 };
132 
133 static inline void
134 netxen_nic_update_cmd_consumer(struct netxen_adapter *adapter,
135 		struct nx_host_tx_ring *tx_ring)
136 {
137 	NXWRIO(adapter, tx_ring->crb_cmd_consumer, tx_ring->sw_consumer);
138 }
139 
140 static uint32_t msi_tgt_status[8] = {
141 	ISR_INT_TARGET_STATUS, ISR_INT_TARGET_STATUS_F1,
142 	ISR_INT_TARGET_STATUS_F2, ISR_INT_TARGET_STATUS_F3,
143 	ISR_INT_TARGET_STATUS_F4, ISR_INT_TARGET_STATUS_F5,
144 	ISR_INT_TARGET_STATUS_F6, ISR_INT_TARGET_STATUS_F7
145 };
146 
147 static struct netxen_legacy_intr_set legacy_intr[] = NX_LEGACY_INTR_CONFIG;
148 
149 static inline void netxen_nic_disable_int(struct nx_host_sds_ring *sds_ring)
150 {
151 	struct netxen_adapter *adapter = sds_ring->adapter;
152 
153 	NXWRIO(adapter, sds_ring->crb_intr_mask, 0);
154 }
155 
156 static inline void netxen_nic_enable_int(struct nx_host_sds_ring *sds_ring)
157 {
158 	struct netxen_adapter *adapter = sds_ring->adapter;
159 
160 	NXWRIO(adapter, sds_ring->crb_intr_mask, 0x1);
161 
162 	if (!NETXEN_IS_MSI_FAMILY(adapter))
163 		NXWRIO(adapter, adapter->tgt_mask_reg, 0xfbff);
164 }
165 
166 static int
167 netxen_alloc_sds_rings(struct netxen_recv_context *recv_ctx, int count)
168 {
169 	int size = sizeof(struct nx_host_sds_ring) * count;
170 
171 	recv_ctx->sds_rings = kzalloc(size, GFP_KERNEL);
172 
173 	return recv_ctx->sds_rings == NULL;
174 }
175 
176 static void
177 netxen_free_sds_rings(struct netxen_recv_context *recv_ctx)
178 {
179 	kfree(recv_ctx->sds_rings);
180 	recv_ctx->sds_rings = NULL;
181 }
182 
183 static int
184 netxen_napi_add(struct netxen_adapter *adapter, struct net_device *netdev)
185 {
186 	int ring;
187 	struct nx_host_sds_ring *sds_ring;
188 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
189 
190 	if (netxen_alloc_sds_rings(recv_ctx, adapter->max_sds_rings))
191 		return -ENOMEM;
192 
193 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
194 		sds_ring = &recv_ctx->sds_rings[ring];
195 		netif_napi_add(netdev, &sds_ring->napi,
196 				netxen_nic_poll, NAPI_POLL_WEIGHT);
197 	}
198 
199 	return 0;
200 }
201 
202 static void
203 netxen_napi_del(struct netxen_adapter *adapter)
204 {
205 	int ring;
206 	struct nx_host_sds_ring *sds_ring;
207 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
208 
209 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
210 		sds_ring = &recv_ctx->sds_rings[ring];
211 		netif_napi_del(&sds_ring->napi);
212 	}
213 
214 	netxen_free_sds_rings(&adapter->recv_ctx);
215 }
216 
217 static void
218 netxen_napi_enable(struct netxen_adapter *adapter)
219 {
220 	int ring;
221 	struct nx_host_sds_ring *sds_ring;
222 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
223 
224 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
225 		sds_ring = &recv_ctx->sds_rings[ring];
226 		napi_enable(&sds_ring->napi);
227 		netxen_nic_enable_int(sds_ring);
228 	}
229 }
230 
231 static void
232 netxen_napi_disable(struct netxen_adapter *adapter)
233 {
234 	int ring;
235 	struct nx_host_sds_ring *sds_ring;
236 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
237 
238 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
239 		sds_ring = &recv_ctx->sds_rings[ring];
240 		netxen_nic_disable_int(sds_ring);
241 		napi_synchronize(&sds_ring->napi);
242 		napi_disable(&sds_ring->napi);
243 	}
244 }
245 
246 static int nx_set_dma_mask(struct netxen_adapter *adapter)
247 {
248 	struct pci_dev *pdev = adapter->pdev;
249 	uint64_t mask, cmask;
250 
251 	adapter->pci_using_dac = 0;
252 
253 	mask = DMA_BIT_MASK(32);
254 	cmask = DMA_BIT_MASK(32);
255 
256 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
257 #ifndef CONFIG_IA64
258 		mask = DMA_BIT_MASK(35);
259 #endif
260 	} else {
261 		mask = DMA_BIT_MASK(39);
262 		cmask = mask;
263 	}
264 
265 	if (pci_set_dma_mask(pdev, mask) == 0 &&
266 		pci_set_consistent_dma_mask(pdev, cmask) == 0) {
267 		adapter->pci_using_dac = 1;
268 		return 0;
269 	}
270 
271 	return -EIO;
272 }
273 
274 /* Update addressable range if firmware supports it */
275 static int
276 nx_update_dma_mask(struct netxen_adapter *adapter)
277 {
278 	int change, shift, err;
279 	uint64_t mask, old_mask, old_cmask;
280 	struct pci_dev *pdev = adapter->pdev;
281 
282 	change = 0;
283 
284 	shift = NXRD32(adapter, CRB_DMA_SHIFT);
285 	if (shift > 32)
286 		return 0;
287 
288 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id) && (shift > 9))
289 		change = 1;
290 	else if ((adapter->ahw.revision_id == NX_P2_C1) && (shift <= 4))
291 		change = 1;
292 
293 	if (change) {
294 		old_mask = pdev->dma_mask;
295 		old_cmask = pdev->dev.coherent_dma_mask;
296 
297 		mask = DMA_BIT_MASK(32+shift);
298 
299 		err = pci_set_dma_mask(pdev, mask);
300 		if (err)
301 			goto err_out;
302 
303 		if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
304 
305 			err = pci_set_consistent_dma_mask(pdev, mask);
306 			if (err)
307 				goto err_out;
308 		}
309 		dev_info(&pdev->dev, "using %d-bit dma mask\n", 32+shift);
310 	}
311 
312 	return 0;
313 
314 err_out:
315 	pci_set_dma_mask(pdev, old_mask);
316 	pci_set_consistent_dma_mask(pdev, old_cmask);
317 	return err;
318 }
319 
320 static int
321 netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
322 {
323 	u32 val, timeout;
324 
325 	if (first_boot == 0x55555555) {
326 		/* This is the first boot after power up */
327 		NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
328 
329 		if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
330 			return 0;
331 
332 		/* PCI bus master workaround */
333 		first_boot = NXRD32(adapter, NETXEN_PCIE_REG(0x4));
334 		if (!(first_boot & 0x4)) {
335 			first_boot |= 0x4;
336 			NXWR32(adapter, NETXEN_PCIE_REG(0x4), first_boot);
337 			NXRD32(adapter, NETXEN_PCIE_REG(0x4));
338 		}
339 
340 		/* This is the first boot after power up */
341 		first_boot = NXRD32(adapter, NETXEN_ROMUSB_GLB_SW_RESET);
342 		if (first_boot != 0x80000f) {
343 			/* clear the register for future unloads/loads */
344 			NXWR32(adapter, NETXEN_CAM_RAM(0x1fc), 0);
345 			return -EIO;
346 		}
347 
348 		/* Start P2 boot loader */
349 		val = NXRD32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
350 		NXWR32(adapter, NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
351 		timeout = 0;
352 		do {
353 			msleep(1);
354 			val = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
355 
356 			if (++timeout > 5000)
357 				return -EIO;
358 
359 		} while (val == NETXEN_BDINFO_MAGIC);
360 	}
361 	return 0;
362 }
363 
364 static void netxen_set_port_mode(struct netxen_adapter *adapter)
365 {
366 	u32 val, data;
367 
368 	val = adapter->ahw.board_type;
369 	if ((val == NETXEN_BRDTYPE_P3_HMEZ) ||
370 		(val == NETXEN_BRDTYPE_P3_XG_LOM)) {
371 		if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
372 			data = NETXEN_PORT_MODE_802_3_AP;
373 			NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
374 		} else if (port_mode == NETXEN_PORT_MODE_XG) {
375 			data = NETXEN_PORT_MODE_XG;
376 			NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
377 		} else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_1G) {
378 			data = NETXEN_PORT_MODE_AUTO_NEG_1G;
379 			NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
380 		} else if (port_mode == NETXEN_PORT_MODE_AUTO_NEG_XG) {
381 			data = NETXEN_PORT_MODE_AUTO_NEG_XG;
382 			NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
383 		} else {
384 			data = NETXEN_PORT_MODE_AUTO_NEG;
385 			NXWR32(adapter, NETXEN_PORT_MODE_ADDR, data);
386 		}
387 
388 		if ((wol_port_mode != NETXEN_PORT_MODE_802_3_AP) &&
389 			(wol_port_mode != NETXEN_PORT_MODE_XG) &&
390 			(wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_1G) &&
391 			(wol_port_mode != NETXEN_PORT_MODE_AUTO_NEG_XG)) {
392 			wol_port_mode = NETXEN_PORT_MODE_AUTO_NEG;
393 		}
394 		NXWR32(adapter, NETXEN_WOL_PORT_MODE, wol_port_mode);
395 	}
396 }
397 
398 #define PCI_CAP_ID_GEN  0x10
399 
400 static void netxen_pcie_strap_init(struct netxen_adapter *adapter)
401 {
402 	u32 pdevfuncsave;
403 	u32 c8c9value = 0;
404 	u32 chicken = 0;
405 	u32 control = 0;
406 	int i, pos;
407 	struct pci_dev *pdev;
408 
409 	pdev = adapter->pdev;
410 
411 	chicken = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3));
412 	/* clear chicken3.25:24 */
413 	chicken &= 0xFCFFFFFF;
414 	/*
415 	 * if gen1 and B0, set F1020 - if gen 2, do nothing
416 	 * if gen2 set to F1000
417 	 */
418 	pos = pci_find_capability(pdev, PCI_CAP_ID_GEN);
419 	if (pos == 0xC0) {
420 		pci_read_config_dword(pdev, pos + 0x10, &control);
421 		if ((control & 0x000F0000) != 0x00020000) {
422 			/*  set chicken3.24 if gen1 */
423 			chicken |= 0x01000000;
424 		}
425 		dev_info(&adapter->pdev->dev, "Gen2 strapping detected\n");
426 		c8c9value = 0xF1000;
427 	} else {
428 		/* set chicken3.24 if gen1 */
429 		chicken |= 0x01000000;
430 		dev_info(&adapter->pdev->dev, "Gen1 strapping detected\n");
431 		if (adapter->ahw.revision_id == NX_P3_B0)
432 			c8c9value = 0xF1020;
433 		else
434 			c8c9value = 0;
435 	}
436 
437 	NXWR32(adapter, NETXEN_PCIE_REG(PCIE_CHICKEN3), chicken);
438 
439 	if (!c8c9value)
440 		return;
441 
442 	pdevfuncsave = pdev->devfn;
443 	if (pdevfuncsave & 0x07)
444 		return;
445 
446 	for (i = 0; i < 8; i++) {
447 		pci_read_config_dword(pdev, pos + 8, &control);
448 		pci_read_config_dword(pdev, pos + 8, &control);
449 		pci_write_config_dword(pdev, pos + 8, c8c9value);
450 		pdev->devfn++;
451 	}
452 	pdev->devfn = pdevfuncsave;
453 }
454 
455 static void netxen_set_msix_bit(struct pci_dev *pdev, int enable)
456 {
457 	u32 control;
458 
459 	if (pdev->msix_cap) {
460 		pci_read_config_dword(pdev, pdev->msix_cap, &control);
461 		if (enable)
462 			control |= PCI_MSIX_FLAGS_ENABLE;
463 		else
464 			control = 0;
465 		pci_write_config_dword(pdev, pdev->msix_cap, control);
466 	}
467 }
468 
469 static void netxen_init_msix_entries(struct netxen_adapter *adapter, int count)
470 {
471 	int i;
472 
473 	for (i = 0; i < count; i++)
474 		adapter->msix_entries[i].entry = i;
475 }
476 
477 static int
478 netxen_read_mac_addr(struct netxen_adapter *adapter)
479 {
480 	int i;
481 	unsigned char *p;
482 	u64 mac_addr;
483 	struct net_device *netdev = adapter->netdev;
484 	struct pci_dev *pdev = adapter->pdev;
485 
486 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
487 		if (netxen_p3_get_mac_addr(adapter, &mac_addr) != 0)
488 			return -EIO;
489 	} else {
490 		if (netxen_get_flash_mac_addr(adapter, &mac_addr) != 0)
491 			return -EIO;
492 	}
493 
494 	p = (unsigned char *)&mac_addr;
495 	for (i = 0; i < 6; i++)
496 		netdev->dev_addr[i] = *(p + 5 - i);
497 
498 	memcpy(adapter->mac_addr, netdev->dev_addr, netdev->addr_len);
499 
500 	/* set station address */
501 
502 	if (!is_valid_ether_addr(netdev->dev_addr))
503 		dev_warn(&pdev->dev, "Bad MAC address %pM.\n", netdev->dev_addr);
504 
505 	return 0;
506 }
507 
508 static int netxen_nic_set_mac(struct net_device *netdev, void *p)
509 {
510 	struct netxen_adapter *adapter = netdev_priv(netdev);
511 	struct sockaddr *addr = p;
512 
513 	if (!is_valid_ether_addr(addr->sa_data))
514 		return -EADDRNOTAVAIL;
515 
516 	if (netif_running(netdev)) {
517 		netif_device_detach(netdev);
518 		netxen_napi_disable(adapter);
519 	}
520 
521 	memcpy(adapter->mac_addr, addr->sa_data, netdev->addr_len);
522 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
523 	adapter->macaddr_set(adapter, addr->sa_data);
524 
525 	if (netif_running(netdev)) {
526 		netif_device_attach(netdev);
527 		netxen_napi_enable(adapter);
528 	}
529 	return 0;
530 }
531 
532 static void netxen_set_multicast_list(struct net_device *dev)
533 {
534 	struct netxen_adapter *adapter = netdev_priv(dev);
535 
536 	adapter->set_multi(dev);
537 }
538 
539 static netdev_features_t netxen_fix_features(struct net_device *dev,
540 	netdev_features_t features)
541 {
542 	if (!(features & NETIF_F_RXCSUM)) {
543 		netdev_info(dev, "disabling LRO as RXCSUM is off\n");
544 
545 		features &= ~NETIF_F_LRO;
546 	}
547 
548 	return features;
549 }
550 
551 static int netxen_set_features(struct net_device *dev,
552 	netdev_features_t features)
553 {
554 	struct netxen_adapter *adapter = netdev_priv(dev);
555 	int hw_lro;
556 
557 	if (!((dev->features ^ features) & NETIF_F_LRO))
558 		return 0;
559 
560 	hw_lro = (features & NETIF_F_LRO) ? NETXEN_NIC_LRO_ENABLED
561 	         : NETXEN_NIC_LRO_DISABLED;
562 
563 	if (netxen_config_hw_lro(adapter, hw_lro))
564 		return -EIO;
565 
566 	if (!(features & NETIF_F_LRO) && netxen_send_lro_cleanup(adapter))
567 		return -EIO;
568 
569 	return 0;
570 }
571 
572 static const struct net_device_ops netxen_netdev_ops = {
573 	.ndo_open	   = netxen_nic_open,
574 	.ndo_stop	   = netxen_nic_close,
575 	.ndo_start_xmit    = netxen_nic_xmit_frame,
576 	.ndo_get_stats64   = netxen_nic_get_stats,
577 	.ndo_validate_addr = eth_validate_addr,
578 	.ndo_set_rx_mode   = netxen_set_multicast_list,
579 	.ndo_set_mac_address    = netxen_nic_set_mac,
580 	.ndo_change_mtu	   = netxen_nic_change_mtu,
581 	.ndo_tx_timeout	   = netxen_tx_timeout,
582 	.ndo_fix_features = netxen_fix_features,
583 	.ndo_set_features = netxen_set_features,
584 #ifdef CONFIG_NET_POLL_CONTROLLER
585 	.ndo_poll_controller = netxen_nic_poll_controller,
586 #endif
587 };
588 
589 static inline bool netxen_function_zero(struct pci_dev *pdev)
590 {
591 	return (PCI_FUNC(pdev->devfn) == 0) ? true : false;
592 }
593 
594 static inline void netxen_set_interrupt_mode(struct netxen_adapter *adapter,
595 					     u32 mode)
596 {
597 	NXWR32(adapter, NETXEN_INTR_MODE_REG, mode);
598 }
599 
600 static inline u32 netxen_get_interrupt_mode(struct netxen_adapter *adapter)
601 {
602 	return NXRD32(adapter, NETXEN_INTR_MODE_REG);
603 }
604 
605 static void
606 netxen_initialize_interrupt_registers(struct netxen_adapter *adapter)
607 {
608 	struct netxen_legacy_intr_set *legacy_intrp;
609 	u32 tgt_status_reg, int_state_reg;
610 
611 	if (adapter->ahw.revision_id >= NX_P3_B0)
612 		legacy_intrp = &legacy_intr[adapter->ahw.pci_func];
613 	else
614 		legacy_intrp = &legacy_intr[0];
615 
616 	tgt_status_reg = legacy_intrp->tgt_status_reg;
617 	int_state_reg = ISR_INT_STATE_REG;
618 
619 	adapter->int_vec_bit = legacy_intrp->int_vec_bit;
620 	adapter->tgt_status_reg = netxen_get_ioaddr(adapter, tgt_status_reg);
621 	adapter->tgt_mask_reg = netxen_get_ioaddr(adapter,
622 						  legacy_intrp->tgt_mask_reg);
623 	adapter->pci_int_reg = netxen_get_ioaddr(adapter,
624 						 legacy_intrp->pci_int_reg);
625 	adapter->isr_int_vec = netxen_get_ioaddr(adapter, ISR_INT_VECTOR);
626 
627 	if (adapter->ahw.revision_id >= NX_P3_B1)
628 		adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
629 							       int_state_reg);
630 	else
631 		adapter->crb_int_state_reg = netxen_get_ioaddr(adapter,
632 							       CRB_INT_VECTOR);
633 }
634 
635 static int netxen_setup_msi_interrupts(struct netxen_adapter *adapter,
636 				       int num_msix)
637 {
638 	struct pci_dev *pdev = adapter->pdev;
639 	u32 value;
640 	int err;
641 
642 	if (adapter->msix_supported) {
643 		netxen_init_msix_entries(adapter, num_msix);
644 		err = pci_enable_msix_range(pdev, adapter->msix_entries,
645 					    num_msix, num_msix);
646 		if (err > 0) {
647 			adapter->flags |= NETXEN_NIC_MSIX_ENABLED;
648 			netxen_set_msix_bit(pdev, 1);
649 
650 			if (adapter->rss_supported)
651 				adapter->max_sds_rings = num_msix;
652 
653 			dev_info(&pdev->dev, "using msi-x interrupts\n");
654 			return 0;
655 		}
656 		/* fall through for msi */
657 	}
658 
659 	if (use_msi && !pci_enable_msi(pdev)) {
660 		value = msi_tgt_status[adapter->ahw.pci_func];
661 		adapter->flags |= NETXEN_NIC_MSI_ENABLED;
662 		adapter->tgt_status_reg = netxen_get_ioaddr(adapter, value);
663 		adapter->msix_entries[0].vector = pdev->irq;
664 		dev_info(&pdev->dev, "using msi interrupts\n");
665 		return 0;
666 	}
667 
668 	dev_err(&pdev->dev, "Failed to acquire MSI-X/MSI interrupt vector\n");
669 	return -EIO;
670 }
671 
672 static int netxen_setup_intr(struct netxen_adapter *adapter)
673 {
674 	struct pci_dev *pdev = adapter->pdev;
675 	int num_msix;
676 
677 	if (adapter->rss_supported)
678 		num_msix = (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER) ?
679 			    MSIX_ENTRIES_PER_ADAPTER : 2;
680 	else
681 		num_msix = 1;
682 
683 	adapter->max_sds_rings = 1;
684 	adapter->flags &= ~(NETXEN_NIC_MSI_ENABLED | NETXEN_NIC_MSIX_ENABLED);
685 
686 	netxen_initialize_interrupt_registers(adapter);
687 	netxen_set_msix_bit(pdev, 0);
688 
689 	if (netxen_function_zero(pdev)) {
690 		if (!netxen_setup_msi_interrupts(adapter, num_msix))
691 			netxen_set_interrupt_mode(adapter, NETXEN_MSI_MODE);
692 		else
693 			netxen_set_interrupt_mode(adapter, NETXEN_INTX_MODE);
694 	} else {
695 		if (netxen_get_interrupt_mode(adapter) == NETXEN_MSI_MODE &&
696 		    netxen_setup_msi_interrupts(adapter, num_msix)) {
697 			dev_err(&pdev->dev, "Co-existence of MSI-X/MSI and INTx interrupts is not supported\n");
698 			return -EIO;
699 		}
700 	}
701 
702 	if (!NETXEN_IS_MSI_FAMILY(adapter)) {
703 		adapter->msix_entries[0].vector = pdev->irq;
704 		dev_info(&pdev->dev, "using legacy interrupts\n");
705 	}
706 	return 0;
707 }
708 
709 static void
710 netxen_teardown_intr(struct netxen_adapter *adapter)
711 {
712 	if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
713 		pci_disable_msix(adapter->pdev);
714 	if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
715 		pci_disable_msi(adapter->pdev);
716 }
717 
718 static void
719 netxen_cleanup_pci_map(struct netxen_adapter *adapter)
720 {
721 	if (adapter->ahw.db_base != NULL)
722 		iounmap(adapter->ahw.db_base);
723 	if (adapter->ahw.pci_base0 != NULL)
724 		iounmap(adapter->ahw.pci_base0);
725 	if (adapter->ahw.pci_base1 != NULL)
726 		iounmap(adapter->ahw.pci_base1);
727 	if (adapter->ahw.pci_base2 != NULL)
728 		iounmap(adapter->ahw.pci_base2);
729 }
730 
731 static int
732 netxen_setup_pci_map(struct netxen_adapter *adapter)
733 {
734 	void __iomem *db_ptr = NULL;
735 
736 	resource_size_t mem_base, db_base;
737 	unsigned long mem_len, db_len = 0;
738 
739 	struct pci_dev *pdev = adapter->pdev;
740 	int pci_func = adapter->ahw.pci_func;
741 	struct netxen_hardware_context *ahw = &adapter->ahw;
742 
743 	int err = 0;
744 
745 	/*
746 	 * Set the CRB window to invalid. If any register in window 0 is
747 	 * accessed it should set the window to 0 and then reset it to 1.
748 	 */
749 	adapter->ahw.crb_win = -1;
750 	adapter->ahw.ocm_win = -1;
751 
752 	/* remap phys address */
753 	mem_base = pci_resource_start(pdev, 0);	/* 0 is for BAR 0 */
754 	mem_len = pci_resource_len(pdev, 0);
755 
756 	/* 128 Meg of memory */
757 	if (mem_len == NETXEN_PCI_128MB_SIZE) {
758 
759 		ahw->pci_base0 = ioremap(mem_base, FIRST_PAGE_GROUP_SIZE);
760 		ahw->pci_base1 = ioremap(mem_base + SECOND_PAGE_GROUP_START,
761 				SECOND_PAGE_GROUP_SIZE);
762 		ahw->pci_base2 = ioremap(mem_base + THIRD_PAGE_GROUP_START,
763 				THIRD_PAGE_GROUP_SIZE);
764 		if (ahw->pci_base0 == NULL || ahw->pci_base1 == NULL ||
765 						ahw->pci_base2 == NULL) {
766 			dev_err(&pdev->dev, "failed to map PCI bar 0\n");
767 			err = -EIO;
768 			goto err_out;
769 		}
770 
771 		ahw->pci_len0 = FIRST_PAGE_GROUP_SIZE;
772 
773 	} else if (mem_len == NETXEN_PCI_32MB_SIZE) {
774 
775 		ahw->pci_base1 = ioremap(mem_base, SECOND_PAGE_GROUP_SIZE);
776 		ahw->pci_base2 = ioremap(mem_base + THIRD_PAGE_GROUP_START -
777 			SECOND_PAGE_GROUP_START, THIRD_PAGE_GROUP_SIZE);
778 		if (ahw->pci_base1 == NULL || ahw->pci_base2 == NULL) {
779 			dev_err(&pdev->dev, "failed to map PCI bar 0\n");
780 			err = -EIO;
781 			goto err_out;
782 		}
783 
784 	} else if (mem_len == NETXEN_PCI_2MB_SIZE) {
785 
786 		ahw->pci_base0 = pci_ioremap_bar(pdev, 0);
787 		if (ahw->pci_base0 == NULL) {
788 			dev_err(&pdev->dev, "failed to map PCI bar 0\n");
789 			return -EIO;
790 		}
791 		ahw->pci_len0 = mem_len;
792 	} else {
793 		return -EIO;
794 	}
795 
796 	netxen_setup_hwops(adapter);
797 
798 	dev_info(&pdev->dev, "%dMB memory map\n", (int)(mem_len>>20));
799 
800 	if (NX_IS_REVISION_P3P(adapter->ahw.revision_id)) {
801 		adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
802 			NETXEN_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(pci_func)));
803 
804 	} else if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
805 		adapter->ahw.ocm_win_crb = netxen_get_ioaddr(adapter,
806 			NETXEN_PCIX_PS_REG(PCIE_MN_WINDOW_REG(pci_func)));
807 	}
808 
809 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
810 		goto skip_doorbell;
811 
812 	db_base = pci_resource_start(pdev, 4);	/* doorbell is on bar 4 */
813 	db_len = pci_resource_len(pdev, 4);
814 
815 	if (db_len == 0) {
816 		printk(KERN_ERR "%s: doorbell is disabled\n",
817 				netxen_nic_driver_name);
818 		err = -EIO;
819 		goto err_out;
820 	}
821 
822 	db_ptr = ioremap(db_base, NETXEN_DB_MAPSIZE_BYTES);
823 	if (!db_ptr) {
824 		printk(KERN_ERR "%s: Failed to allocate doorbell map.",
825 				netxen_nic_driver_name);
826 		err = -EIO;
827 		goto err_out;
828 	}
829 
830 skip_doorbell:
831 	adapter->ahw.db_base = db_ptr;
832 	adapter->ahw.db_len = db_len;
833 	return 0;
834 
835 err_out:
836 	netxen_cleanup_pci_map(adapter);
837 	return err;
838 }
839 
840 static void
841 netxen_check_options(struct netxen_adapter *adapter)
842 {
843 	u32 fw_major, fw_minor, fw_build, prev_fw_version;
844 	char brd_name[NETXEN_MAX_SHORT_NAME];
845 	char serial_num[32];
846 	int i, offset, val, err;
847 	__le32 *ptr32;
848 	struct pci_dev *pdev = adapter->pdev;
849 
850 	adapter->driver_mismatch = 0;
851 
852 	ptr32 = (__le32 *)&serial_num;
853 	offset = NX_FW_SERIAL_NUM_OFFSET;
854 	for (i = 0; i < 8; i++) {
855 		err = netxen_rom_fast_read(adapter, offset, &val);
856 		if (err) {
857 			dev_err(&pdev->dev, "error reading board info\n");
858 			adapter->driver_mismatch = 1;
859 			return;
860 		}
861 		ptr32[i] = cpu_to_le32(val);
862 		offset += sizeof(u32);
863 	}
864 
865 	fw_major = NXRD32(adapter, NETXEN_FW_VERSION_MAJOR);
866 	fw_minor = NXRD32(adapter, NETXEN_FW_VERSION_MINOR);
867 	fw_build = NXRD32(adapter, NETXEN_FW_VERSION_SUB);
868 	prev_fw_version = adapter->fw_version;
869 	adapter->fw_version = NETXEN_VERSION_CODE(fw_major, fw_minor, fw_build);
870 
871 	/* Get FW Mini Coredump template and store it */
872 	 if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
873 		if (adapter->mdump.md_template == NULL ||
874 				adapter->fw_version > prev_fw_version) {
875 			kfree(adapter->mdump.md_template);
876 			adapter->mdump.md_template = NULL;
877 			err = netxen_setup_minidump(adapter);
878 			if (err)
879 				dev_err(&adapter->pdev->dev,
880 				"Failed to setup minidump rcode = %d\n", err);
881 		}
882 	}
883 
884 	if (adapter->portnum == 0) {
885 		if (netxen_nic_get_brd_name_by_type(adapter->ahw.board_type,
886 						    brd_name))
887 			strcpy(serial_num, "Unknown");
888 
889 		pr_info("%s: %s Board S/N %s  Chip rev 0x%x\n",
890 				module_name(THIS_MODULE),
891 				brd_name, serial_num, adapter->ahw.revision_id);
892 	}
893 
894 	if (adapter->fw_version < NETXEN_VERSION_CODE(3, 4, 216)) {
895 		adapter->driver_mismatch = 1;
896 		dev_warn(&pdev->dev, "firmware version %d.%d.%d unsupported\n",
897 				fw_major, fw_minor, fw_build);
898 		return;
899 	}
900 
901 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
902 		i = NXRD32(adapter, NETXEN_SRE_MISC);
903 		adapter->ahw.cut_through = (i & 0x8000) ? 1 : 0;
904 	}
905 
906 	dev_info(&pdev->dev, "Driver v%s, firmware v%d.%d.%d [%s]\n",
907 		 NETXEN_NIC_LINUX_VERSIONID, fw_major, fw_minor, fw_build,
908 		 adapter->ahw.cut_through ? "cut-through" : "legacy");
909 
910 	if (adapter->fw_version >= NETXEN_VERSION_CODE(4, 0, 222))
911 		adapter->capabilities = NXRD32(adapter, CRB_FW_CAPABILITIES_1);
912 
913 	if (adapter->ahw.port_type == NETXEN_NIC_XGBE) {
914 		adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_10G;
915 		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_10G;
916 	} else if (adapter->ahw.port_type == NETXEN_NIC_GBE) {
917 		adapter->num_rxd = DEFAULT_RCV_DESCRIPTORS_1G;
918 		adapter->num_jumbo_rxd = MAX_JUMBO_RCV_DESCRIPTORS_1G;
919 	}
920 
921 	adapter->msix_supported = 0;
922 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
923 		adapter->msix_supported = !!use_msi_x;
924 		adapter->rss_supported = !!use_msi_x;
925 	} else {
926 		u32 flashed_ver = 0;
927 		netxen_rom_fast_read(adapter,
928 				NX_FW_VERSION_OFFSET, (int *)&flashed_ver);
929 		flashed_ver = NETXEN_DECODE_VERSION(flashed_ver);
930 
931 		if (flashed_ver >= NETXEN_VERSION_CODE(3, 4, 336)) {
932 			switch (adapter->ahw.board_type) {
933 			case NETXEN_BRDTYPE_P2_SB31_10G:
934 			case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
935 				adapter->msix_supported = !!use_msi_x;
936 				adapter->rss_supported = !!use_msi_x;
937 				break;
938 			default:
939 				break;
940 			}
941 		}
942 	}
943 
944 	adapter->num_txd = MAX_CMD_DESCRIPTORS;
945 
946 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
947 		adapter->num_lro_rxd = MAX_LRO_RCV_DESCRIPTORS;
948 		adapter->max_rds_rings = 3;
949 	} else {
950 		adapter->num_lro_rxd = 0;
951 		adapter->max_rds_rings = 2;
952 	}
953 }
954 
955 static int
956 netxen_start_firmware(struct netxen_adapter *adapter)
957 {
958 	int val, err, first_boot;
959 	struct pci_dev *pdev = adapter->pdev;
960 
961 	/* required for NX2031 dummy dma */
962 	err = nx_set_dma_mask(adapter);
963 	if (err)
964 		return err;
965 
966 	err = netxen_can_start_firmware(adapter);
967 
968 	if (err < 0)
969 		return err;
970 
971 	if (!err)
972 		goto wait_init;
973 
974 	first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
975 
976 	err = netxen_check_hw_init(adapter, first_boot);
977 	if (err) {
978 		dev_err(&pdev->dev, "error in init HW init sequence\n");
979 		return err;
980 	}
981 
982 	netxen_request_firmware(adapter);
983 
984 	err = netxen_need_fw_reset(adapter);
985 	if (err < 0)
986 		goto err_out;
987 	if (err == 0)
988 		goto pcie_strap_init;
989 
990 	if (first_boot != 0x55555555) {
991 		NXWR32(adapter, CRB_CMDPEG_STATE, 0);
992 		netxen_pinit_from_rom(adapter);
993 		msleep(1);
994 	}
995 
996 	NXWR32(adapter, CRB_DMA_SHIFT, 0x55555555);
997 	NXWR32(adapter, NETXEN_PEG_HALT_STATUS1, 0);
998 	NXWR32(adapter, NETXEN_PEG_HALT_STATUS2, 0);
999 
1000 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1001 		netxen_set_port_mode(adapter);
1002 
1003 	err = netxen_load_firmware(adapter);
1004 	if (err)
1005 		goto err_out;
1006 
1007 	netxen_release_firmware(adapter);
1008 
1009 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1010 
1011 		/* Initialize multicast addr pool owners */
1012 		val = 0x7654;
1013 		if (adapter->ahw.port_type == NETXEN_NIC_XGBE)
1014 			val |= 0x0f000000;
1015 		NXWR32(adapter, NETXEN_MAC_ADDR_CNTL_REG, val);
1016 
1017 	}
1018 
1019 	err = netxen_init_dummy_dma(adapter);
1020 	if (err)
1021 		goto err_out;
1022 
1023 	/*
1024 	 * Tell the hardware our version number.
1025 	 */
1026 	val = (_NETXEN_NIC_LINUX_MAJOR << 16)
1027 		| ((_NETXEN_NIC_LINUX_MINOR << 8))
1028 		| (_NETXEN_NIC_LINUX_SUBVERSION);
1029 	NXWR32(adapter, CRB_DRIVER_VERSION, val);
1030 
1031 pcie_strap_init:
1032 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1033 		netxen_pcie_strap_init(adapter);
1034 
1035 wait_init:
1036 	/* Handshake with the card before we register the devices. */
1037 	err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
1038 	if (err) {
1039 		netxen_free_dummy_dma(adapter);
1040 		goto err_out;
1041 	}
1042 
1043 	NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_READY);
1044 
1045 	nx_update_dma_mask(adapter);
1046 
1047 	netxen_check_options(adapter);
1048 
1049 	adapter->need_fw_reset = 0;
1050 
1051 	/* fall through and release firmware */
1052 
1053 err_out:
1054 	netxen_release_firmware(adapter);
1055 	return err;
1056 }
1057 
1058 static int
1059 netxen_nic_request_irq(struct netxen_adapter *adapter)
1060 {
1061 	irq_handler_t handler;
1062 	struct nx_host_sds_ring *sds_ring;
1063 	int err, ring;
1064 
1065 	unsigned long flags = 0;
1066 	struct net_device *netdev = adapter->netdev;
1067 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1068 
1069 	if (adapter->flags & NETXEN_NIC_MSIX_ENABLED)
1070 		handler = netxen_msix_intr;
1071 	else if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
1072 		handler = netxen_msi_intr;
1073 	else {
1074 		flags |= IRQF_SHARED;
1075 		handler = netxen_intr;
1076 	}
1077 	adapter->irq = netdev->irq;
1078 
1079 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1080 		sds_ring = &recv_ctx->sds_rings[ring];
1081 		sprintf(sds_ring->name, "%s[%d]", netdev->name, ring);
1082 		err = request_irq(sds_ring->irq, handler,
1083 				  flags, sds_ring->name, sds_ring);
1084 		if (err)
1085 			return err;
1086 	}
1087 
1088 	return 0;
1089 }
1090 
1091 static void
1092 netxen_nic_free_irq(struct netxen_adapter *adapter)
1093 {
1094 	int ring;
1095 	struct nx_host_sds_ring *sds_ring;
1096 
1097 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
1098 
1099 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
1100 		sds_ring = &recv_ctx->sds_rings[ring];
1101 		free_irq(sds_ring->irq, sds_ring);
1102 	}
1103 }
1104 
1105 static void
1106 netxen_nic_init_coalesce_defaults(struct netxen_adapter *adapter)
1107 {
1108 	adapter->coal.flags = NETXEN_NIC_INTR_DEFAULT;
1109 	adapter->coal.normal.data.rx_time_us =
1110 		NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US;
1111 	adapter->coal.normal.data.rx_packets =
1112 		NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS;
1113 	adapter->coal.normal.data.tx_time_us =
1114 		NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US;
1115 	adapter->coal.normal.data.tx_packets =
1116 		NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS;
1117 }
1118 
1119 /* with rtnl_lock */
1120 static int
1121 __netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
1122 {
1123 	int err;
1124 
1125 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1126 		return -EIO;
1127 
1128 	err = adapter->init_port(adapter, adapter->physical_port);
1129 	if (err) {
1130 		printk(KERN_ERR "%s: Failed to initialize port %d\n",
1131 				netxen_nic_driver_name, adapter->portnum);
1132 		return err;
1133 	}
1134 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
1135 		adapter->macaddr_set(adapter, adapter->mac_addr);
1136 
1137 	adapter->set_multi(netdev);
1138 	adapter->set_mtu(adapter, netdev->mtu);
1139 
1140 	adapter->ahw.linkup = 0;
1141 
1142 	if (adapter->max_sds_rings > 1)
1143 		netxen_config_rss(adapter, 1);
1144 
1145 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1146 		netxen_config_intr_coalesce(adapter);
1147 
1148 	if (netdev->features & NETIF_F_LRO)
1149 		netxen_config_hw_lro(adapter, NETXEN_NIC_LRO_ENABLED);
1150 
1151 	netxen_napi_enable(adapter);
1152 
1153 	if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
1154 		netxen_linkevent_request(adapter, 1);
1155 	else
1156 		netxen_nic_set_link_parameters(adapter);
1157 
1158 	set_bit(__NX_DEV_UP, &adapter->state);
1159 	return 0;
1160 }
1161 
1162 /* Usage: During resume and firmware recovery module.*/
1163 
1164 static inline int
1165 netxen_nic_up(struct netxen_adapter *adapter, struct net_device *netdev)
1166 {
1167 	int err = 0;
1168 
1169 	rtnl_lock();
1170 	if (netif_running(netdev))
1171 		err = __netxen_nic_up(adapter, netdev);
1172 	rtnl_unlock();
1173 
1174 	return err;
1175 }
1176 
1177 /* with rtnl_lock */
1178 static void
1179 __netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
1180 {
1181 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1182 		return;
1183 
1184 	if (!test_and_clear_bit(__NX_DEV_UP, &adapter->state))
1185 		return;
1186 
1187 	smp_mb();
1188 	netif_carrier_off(netdev);
1189 	netif_tx_disable(netdev);
1190 
1191 	if (adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)
1192 		netxen_linkevent_request(adapter, 0);
1193 
1194 	if (adapter->stop_port)
1195 		adapter->stop_port(adapter);
1196 
1197 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1198 		netxen_p3_free_mac_list(adapter);
1199 
1200 	adapter->set_promisc(adapter, NETXEN_NIU_NON_PROMISC_MODE);
1201 
1202 	netxen_napi_disable(adapter);
1203 
1204 	netxen_release_tx_buffers(adapter);
1205 }
1206 
1207 /* Usage: During suspend and firmware recovery module */
1208 
1209 static inline void
1210 netxen_nic_down(struct netxen_adapter *adapter, struct net_device *netdev)
1211 {
1212 	rtnl_lock();
1213 	if (netif_running(netdev))
1214 		__netxen_nic_down(adapter, netdev);
1215 	rtnl_unlock();
1216 
1217 }
1218 
1219 static int
1220 netxen_nic_attach(struct netxen_adapter *adapter)
1221 {
1222 	struct net_device *netdev = adapter->netdev;
1223 	struct pci_dev *pdev = adapter->pdev;
1224 	int err, ring;
1225 	struct nx_host_rds_ring *rds_ring;
1226 	struct nx_host_tx_ring *tx_ring;
1227 	u32 capab2;
1228 
1229 	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC)
1230 		return 0;
1231 
1232 	err = netxen_init_firmware(adapter);
1233 	if (err)
1234 		return err;
1235 
1236 	adapter->flags &= ~NETXEN_FW_MSS_CAP;
1237 	if (adapter->capabilities & NX_FW_CAPABILITY_MORE_CAPS) {
1238 		capab2 = NXRD32(adapter, CRB_FW_CAPABILITIES_2);
1239 		if (capab2 & NX_FW_CAPABILITY_2_LRO_MAX_TCP_SEG)
1240 			adapter->flags |= NETXEN_FW_MSS_CAP;
1241 	}
1242 
1243 	err = netxen_napi_add(adapter, netdev);
1244 	if (err)
1245 		return err;
1246 
1247 	err = netxen_alloc_sw_resources(adapter);
1248 	if (err) {
1249 		printk(KERN_ERR "%s: Error in setting sw resources\n",
1250 				netdev->name);
1251 		return err;
1252 	}
1253 
1254 	err = netxen_alloc_hw_resources(adapter);
1255 	if (err) {
1256 		printk(KERN_ERR "%s: Error in setting hw resources\n",
1257 				netdev->name);
1258 		goto err_out_free_sw;
1259 	}
1260 
1261 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1262 		tx_ring = adapter->tx_ring;
1263 		tx_ring->crb_cmd_producer = netxen_get_ioaddr(adapter,
1264 				crb_cmd_producer[adapter->portnum]);
1265 		tx_ring->crb_cmd_consumer = netxen_get_ioaddr(adapter,
1266 				crb_cmd_consumer[adapter->portnum]);
1267 
1268 		tx_ring->producer = 0;
1269 		tx_ring->sw_consumer = 0;
1270 
1271 		netxen_nic_update_cmd_producer(adapter, tx_ring);
1272 		netxen_nic_update_cmd_consumer(adapter, tx_ring);
1273 	}
1274 
1275 	for (ring = 0; ring < adapter->max_rds_rings; ring++) {
1276 		rds_ring = &adapter->recv_ctx.rds_rings[ring];
1277 		netxen_post_rx_buffers(adapter, ring, rds_ring);
1278 	}
1279 
1280 	err = netxen_nic_request_irq(adapter);
1281 	if (err) {
1282 		dev_err(&pdev->dev, "%s: failed to setup interrupt\n",
1283 				netdev->name);
1284 		goto err_out_free_rxbuf;
1285 	}
1286 
1287 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1288 		netxen_nic_init_coalesce_defaults(adapter);
1289 
1290 	netxen_create_sysfs_entries(adapter);
1291 
1292 	adapter->is_up = NETXEN_ADAPTER_UP_MAGIC;
1293 	return 0;
1294 
1295 err_out_free_rxbuf:
1296 	netxen_release_rx_buffers(adapter);
1297 	netxen_free_hw_resources(adapter);
1298 err_out_free_sw:
1299 	netxen_free_sw_resources(adapter);
1300 	return err;
1301 }
1302 
1303 static void
1304 netxen_nic_detach(struct netxen_adapter *adapter)
1305 {
1306 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
1307 		return;
1308 
1309 	netxen_remove_sysfs_entries(adapter);
1310 
1311 	netxen_free_hw_resources(adapter);
1312 	netxen_release_rx_buffers(adapter);
1313 	netxen_nic_free_irq(adapter);
1314 	netxen_napi_del(adapter);
1315 	netxen_free_sw_resources(adapter);
1316 
1317 	adapter->is_up = 0;
1318 }
1319 
1320 int
1321 netxen_nic_reset_context(struct netxen_adapter *adapter)
1322 {
1323 	int err = 0;
1324 	struct net_device *netdev = adapter->netdev;
1325 
1326 	if (test_and_set_bit(__NX_RESETTING, &adapter->state))
1327 		return -EBUSY;
1328 
1329 	if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
1330 
1331 		netif_device_detach(netdev);
1332 
1333 		if (netif_running(netdev))
1334 			__netxen_nic_down(adapter, netdev);
1335 
1336 		netxen_nic_detach(adapter);
1337 
1338 		if (netif_running(netdev)) {
1339 			err = netxen_nic_attach(adapter);
1340 			if (!err)
1341 				err = __netxen_nic_up(adapter, netdev);
1342 
1343 			if (err)
1344 				goto done;
1345 		}
1346 
1347 		netif_device_attach(netdev);
1348 	}
1349 
1350 done:
1351 	clear_bit(__NX_RESETTING, &adapter->state);
1352 	return err;
1353 }
1354 
1355 static int
1356 netxen_setup_netdev(struct netxen_adapter *adapter,
1357 		struct net_device *netdev)
1358 {
1359 	int err = 0;
1360 	struct pci_dev *pdev = adapter->pdev;
1361 
1362 	adapter->mc_enabled = 0;
1363 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1364 		adapter->max_mc_count = 38;
1365 	else
1366 		adapter->max_mc_count = 16;
1367 
1368 	netdev->netdev_ops	   = &netxen_netdev_ops;
1369 	netdev->watchdog_timeo     = 5*HZ;
1370 
1371 	netxen_nic_change_mtu(netdev, netdev->mtu);
1372 
1373 	netdev->ethtool_ops = &netxen_nic_ethtool_ops;
1374 
1375 	netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO |
1376 	                      NETIF_F_RXCSUM;
1377 
1378 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1379 		netdev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6;
1380 
1381 	netdev->vlan_features |= netdev->hw_features;
1382 
1383 	if (adapter->pci_using_dac) {
1384 		netdev->features |= NETIF_F_HIGHDMA;
1385 		netdev->vlan_features |= NETIF_F_HIGHDMA;
1386 	}
1387 
1388 	if (adapter->capabilities & NX_FW_CAPABILITY_FVLANTX)
1389 		netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX;
1390 
1391 	if (adapter->capabilities & NX_FW_CAPABILITY_HW_LRO)
1392 		netdev->hw_features |= NETIF_F_LRO;
1393 
1394 	netdev->features |= netdev->hw_features;
1395 
1396 	netdev->irq = adapter->msix_entries[0].vector;
1397 
1398 	INIT_WORK(&adapter->tx_timeout_task, netxen_tx_timeout_task);
1399 
1400 	if (netxen_read_mac_addr(adapter))
1401 		dev_warn(&pdev->dev, "failed to read mac addr\n");
1402 
1403 	netif_carrier_off(netdev);
1404 
1405 	err = register_netdev(netdev);
1406 	if (err) {
1407 		dev_err(&pdev->dev, "failed to register net device\n");
1408 		return err;
1409 	}
1410 
1411 	return 0;
1412 }
1413 
1414 #define NETXEN_ULA_ADAPTER_KEY		(0xdaddad01)
1415 #define NETXEN_NON_ULA_ADAPTER_KEY	(0xdaddad00)
1416 
1417 static void netxen_read_ula_info(struct netxen_adapter *adapter)
1418 {
1419 	u32 temp;
1420 
1421 	/* Print ULA info only once for an adapter */
1422 	if (adapter->portnum != 0)
1423 		return;
1424 
1425 	temp = NXRD32(adapter, NETXEN_ULA_KEY);
1426 	switch (temp) {
1427 	case NETXEN_ULA_ADAPTER_KEY:
1428 		dev_info(&adapter->pdev->dev, "ULA adapter");
1429 		break;
1430 	case NETXEN_NON_ULA_ADAPTER_KEY:
1431 		dev_info(&adapter->pdev->dev, "non ULA adapter");
1432 		break;
1433 	default:
1434 		break;
1435 	}
1436 
1437 	return;
1438 }
1439 
1440 #ifdef CONFIG_PCIEAER
1441 static void netxen_mask_aer_correctable(struct netxen_adapter *adapter)
1442 {
1443 	struct pci_dev *pdev = adapter->pdev;
1444 	struct pci_dev *root = pdev->bus->self;
1445 	u32 aer_pos;
1446 
1447 	/* root bus? */
1448 	if (!root)
1449 		return;
1450 
1451 	if (adapter->ahw.board_type != NETXEN_BRDTYPE_P3_4_GB_MM &&
1452 		adapter->ahw.board_type != NETXEN_BRDTYPE_P3_10G_TP)
1453 		return;
1454 
1455 	if (pci_pcie_type(root) != PCI_EXP_TYPE_ROOT_PORT)
1456 		return;
1457 
1458 	aer_pos = pci_find_ext_capability(root, PCI_EXT_CAP_ID_ERR);
1459 	if (!aer_pos)
1460 		return;
1461 
1462 	pci_write_config_dword(root, aer_pos + PCI_ERR_COR_MASK, 0xffff);
1463 }
1464 #endif
1465 
1466 static int
1467 netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1468 {
1469 	struct net_device *netdev = NULL;
1470 	struct netxen_adapter *adapter = NULL;
1471 	int i = 0, err;
1472 	int pci_func_id = PCI_FUNC(pdev->devfn);
1473 	uint8_t revision_id;
1474 	u32 val;
1475 
1476 	if (pdev->revision >= NX_P3_A0 && pdev->revision <= NX_P3_B1) {
1477 		pr_warn("%s: chip revisions between 0x%x-0x%x will not be enabled\n",
1478 			module_name(THIS_MODULE), NX_P3_A0, NX_P3_B1);
1479 		return -ENODEV;
1480 	}
1481 
1482 	if ((err = pci_enable_device(pdev)))
1483 		return err;
1484 
1485 	if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1486 		err = -ENODEV;
1487 		goto err_out_disable_pdev;
1488 	}
1489 
1490 	if ((err = pci_request_regions(pdev, netxen_nic_driver_name)))
1491 		goto err_out_disable_pdev;
1492 
1493 	if (NX_IS_REVISION_P3(pdev->revision))
1494 		pci_enable_pcie_error_reporting(pdev);
1495 
1496 	pci_set_master(pdev);
1497 
1498 	netdev = alloc_etherdev(sizeof(struct netxen_adapter));
1499 	if(!netdev) {
1500 		err = -ENOMEM;
1501 		goto err_out_free_res;
1502 	}
1503 
1504 	SET_NETDEV_DEV(netdev, &pdev->dev);
1505 
1506 	adapter = netdev_priv(netdev);
1507 	adapter->netdev  = netdev;
1508 	adapter->pdev    = pdev;
1509 	adapter->ahw.pci_func  = pci_func_id;
1510 
1511 	revision_id = pdev->revision;
1512 	adapter->ahw.revision_id = revision_id;
1513 
1514 	rwlock_init(&adapter->ahw.crb_lock);
1515 	spin_lock_init(&adapter->ahw.mem_lock);
1516 
1517 	spin_lock_init(&adapter->tx_clean_lock);
1518 	INIT_LIST_HEAD(&adapter->mac_list);
1519 	INIT_LIST_HEAD(&adapter->ip_list);
1520 
1521 	err = netxen_setup_pci_map(adapter);
1522 	if (err)
1523 		goto err_out_free_netdev;
1524 
1525 	/* This will be reset for mezz cards  */
1526 	adapter->portnum = pci_func_id;
1527 
1528 	err = netxen_nic_get_board_info(adapter);
1529 	if (err) {
1530 		dev_err(&pdev->dev, "Error getting board config info.\n");
1531 		goto err_out_iounmap;
1532 	}
1533 
1534 #ifdef CONFIG_PCIEAER
1535 	netxen_mask_aer_correctable(adapter);
1536 #endif
1537 
1538 	/* Mezz cards have PCI function 0,2,3 enabled */
1539 	switch (adapter->ahw.board_type) {
1540 	case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ:
1541 	case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ:
1542 		if (pci_func_id >= 2)
1543 			adapter->portnum = pci_func_id - 2;
1544 		break;
1545 	default:
1546 		break;
1547 	}
1548 
1549 	err = netxen_check_flash_fw_compatibility(adapter);
1550 	if (err)
1551 		goto err_out_iounmap;
1552 
1553 	if (adapter->portnum == 0) {
1554 		val = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
1555 		if (val != 0xffffffff && val != 0) {
1556 			NXWR32(adapter, NX_CRB_DEV_REF_COUNT, 0);
1557 			adapter->need_fw_reset = 1;
1558 		}
1559 	}
1560 
1561 	err = netxen_start_firmware(adapter);
1562 	if (err)
1563 		goto err_out_decr_ref;
1564 
1565 	/*
1566 	 * See if the firmware gave us a virtual-physical port mapping.
1567 	 */
1568 	adapter->physical_port = adapter->portnum;
1569 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
1570 		i = NXRD32(adapter, CRB_V2P(adapter->portnum));
1571 		if (i != 0x55555555)
1572 			adapter->physical_port = i;
1573 	}
1574 
1575 	/* MTU range: 0 - 8000 (P2) or 9600 (P3) */
1576 	netdev->min_mtu = 0;
1577 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
1578 		netdev->max_mtu = P3_MAX_MTU;
1579 	else
1580 		netdev->max_mtu = P2_MAX_MTU;
1581 
1582 	netxen_nic_clear_stats(adapter);
1583 
1584 	err = netxen_setup_intr(adapter);
1585 
1586 	if (err) {
1587 		dev_err(&adapter->pdev->dev,
1588 			"Failed to setup interrupts, error = %d\n", err);
1589 		goto err_out_disable_msi;
1590 	}
1591 
1592 	netxen_read_ula_info(adapter);
1593 
1594 	err = netxen_setup_netdev(adapter, netdev);
1595 	if (err)
1596 		goto err_out_disable_msi;
1597 
1598 	pci_set_drvdata(pdev, adapter);
1599 
1600 	netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1601 
1602 	switch (adapter->ahw.port_type) {
1603 	case NETXEN_NIC_GBE:
1604 		dev_info(&adapter->pdev->dev, "%s: GbE port initialized\n",
1605 				adapter->netdev->name);
1606 		break;
1607 	case NETXEN_NIC_XGBE:
1608 		dev_info(&adapter->pdev->dev, "%s: XGbE port initialized\n",
1609 				adapter->netdev->name);
1610 		break;
1611 	}
1612 
1613 	netxen_create_diag_entries(adapter);
1614 
1615 	return 0;
1616 
1617 err_out_disable_msi:
1618 	netxen_teardown_intr(adapter);
1619 
1620 	netxen_free_dummy_dma(adapter);
1621 
1622 err_out_decr_ref:
1623 	nx_decr_dev_ref_cnt(adapter);
1624 
1625 err_out_iounmap:
1626 	netxen_cleanup_pci_map(adapter);
1627 
1628 err_out_free_netdev:
1629 	free_netdev(netdev);
1630 
1631 err_out_free_res:
1632 	pci_release_regions(pdev);
1633 
1634 err_out_disable_pdev:
1635 	pci_disable_device(pdev);
1636 	return err;
1637 }
1638 
1639 static
1640 void netxen_cleanup_minidump(struct netxen_adapter *adapter)
1641 {
1642 	kfree(adapter->mdump.md_template);
1643 	adapter->mdump.md_template = NULL;
1644 
1645 	if (adapter->mdump.md_capture_buff) {
1646 		vfree(adapter->mdump.md_capture_buff);
1647 		adapter->mdump.md_capture_buff = NULL;
1648 	}
1649 }
1650 
1651 static void netxen_nic_remove(struct pci_dev *pdev)
1652 {
1653 	struct netxen_adapter *adapter;
1654 	struct net_device *netdev;
1655 
1656 	adapter = pci_get_drvdata(pdev);
1657 	if (adapter == NULL)
1658 		return;
1659 
1660 	netdev = adapter->netdev;
1661 
1662 	netxen_cancel_fw_work(adapter);
1663 
1664 	unregister_netdev(netdev);
1665 
1666 	cancel_work_sync(&adapter->tx_timeout_task);
1667 
1668 	netxen_free_ip_list(adapter, false);
1669 	netxen_nic_detach(adapter);
1670 
1671 	nx_decr_dev_ref_cnt(adapter);
1672 
1673 	if (adapter->portnum == 0)
1674 		netxen_free_dummy_dma(adapter);
1675 
1676 	clear_bit(__NX_RESETTING, &adapter->state);
1677 
1678 	netxen_teardown_intr(adapter);
1679 	netxen_set_interrupt_mode(adapter, 0);
1680 	netxen_remove_diag_entries(adapter);
1681 
1682 	netxen_cleanup_pci_map(adapter);
1683 
1684 	netxen_release_firmware(adapter);
1685 
1686 	if (NX_IS_REVISION_P3(pdev->revision)) {
1687 		netxen_cleanup_minidump(adapter);
1688 		pci_disable_pcie_error_reporting(pdev);
1689 	}
1690 
1691 	pci_release_regions(pdev);
1692 	pci_disable_device(pdev);
1693 
1694 	free_netdev(netdev);
1695 }
1696 
1697 static void netxen_nic_detach_func(struct netxen_adapter *adapter)
1698 {
1699 	struct net_device *netdev = adapter->netdev;
1700 
1701 	netif_device_detach(netdev);
1702 
1703 	netxen_cancel_fw_work(adapter);
1704 
1705 	if (netif_running(netdev))
1706 		netxen_nic_down(adapter, netdev);
1707 
1708 	cancel_work_sync(&adapter->tx_timeout_task);
1709 
1710 	netxen_nic_detach(adapter);
1711 
1712 	if (adapter->portnum == 0)
1713 		netxen_free_dummy_dma(adapter);
1714 
1715 	nx_decr_dev_ref_cnt(adapter);
1716 
1717 	clear_bit(__NX_RESETTING, &adapter->state);
1718 }
1719 
1720 static int netxen_nic_attach_func(struct pci_dev *pdev)
1721 {
1722 	struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1723 	struct net_device *netdev = adapter->netdev;
1724 	int err;
1725 
1726 	err = pci_enable_device(pdev);
1727 	if (err)
1728 		return err;
1729 
1730 	pci_set_power_state(pdev, PCI_D0);
1731 	pci_set_master(pdev);
1732 	pci_restore_state(pdev);
1733 
1734 	adapter->ahw.crb_win = -1;
1735 	adapter->ahw.ocm_win = -1;
1736 
1737 	err = netxen_start_firmware(adapter);
1738 	if (err) {
1739 		dev_err(&pdev->dev, "failed to start firmware\n");
1740 		return err;
1741 	}
1742 
1743 	if (netif_running(netdev)) {
1744 		err = netxen_nic_attach(adapter);
1745 		if (err)
1746 			goto err_out;
1747 
1748 		err = netxen_nic_up(adapter, netdev);
1749 		if (err)
1750 			goto err_out_detach;
1751 
1752 		netxen_restore_indev_addr(netdev, NETDEV_UP);
1753 	}
1754 
1755 	netif_device_attach(netdev);
1756 	netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
1757 	return 0;
1758 
1759 err_out_detach:
1760 	netxen_nic_detach(adapter);
1761 err_out:
1762 	nx_decr_dev_ref_cnt(adapter);
1763 	return err;
1764 }
1765 
1766 static pci_ers_result_t netxen_io_error_detected(struct pci_dev *pdev,
1767 						pci_channel_state_t state)
1768 {
1769 	struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1770 
1771 	if (state == pci_channel_io_perm_failure)
1772 		return PCI_ERS_RESULT_DISCONNECT;
1773 
1774 	if (nx_dev_request_aer(adapter))
1775 		return PCI_ERS_RESULT_RECOVERED;
1776 
1777 	netxen_nic_detach_func(adapter);
1778 
1779 	pci_disable_device(pdev);
1780 
1781 	return PCI_ERS_RESULT_NEED_RESET;
1782 }
1783 
1784 static pci_ers_result_t netxen_io_slot_reset(struct pci_dev *pdev)
1785 {
1786 	int err = 0;
1787 
1788 	err = netxen_nic_attach_func(pdev);
1789 
1790 	return err ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
1791 }
1792 
1793 static void netxen_io_resume(struct pci_dev *pdev)
1794 {
1795 	pci_cleanup_aer_uncorrect_error_status(pdev);
1796 }
1797 
1798 static void netxen_nic_shutdown(struct pci_dev *pdev)
1799 {
1800 	struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1801 
1802 	netxen_nic_detach_func(adapter);
1803 
1804 	if (pci_save_state(pdev))
1805 		return;
1806 
1807 	if (netxen_nic_wol_supported(adapter)) {
1808 		pci_enable_wake(pdev, PCI_D3cold, 1);
1809 		pci_enable_wake(pdev, PCI_D3hot, 1);
1810 	}
1811 
1812 	pci_disable_device(pdev);
1813 }
1814 
1815 #ifdef CONFIG_PM
1816 static int
1817 netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
1818 {
1819 	struct netxen_adapter *adapter = pci_get_drvdata(pdev);
1820 	int retval;
1821 
1822 	netxen_nic_detach_func(adapter);
1823 
1824 	retval = pci_save_state(pdev);
1825 	if (retval)
1826 		return retval;
1827 
1828 	if (netxen_nic_wol_supported(adapter)) {
1829 		pci_enable_wake(pdev, PCI_D3cold, 1);
1830 		pci_enable_wake(pdev, PCI_D3hot, 1);
1831 	}
1832 
1833 	pci_disable_device(pdev);
1834 	pci_set_power_state(pdev, pci_choose_state(pdev, state));
1835 
1836 	return 0;
1837 }
1838 
1839 static int
1840 netxen_nic_resume(struct pci_dev *pdev)
1841 {
1842 	return netxen_nic_attach_func(pdev);
1843 }
1844 #endif
1845 
1846 static int netxen_nic_open(struct net_device *netdev)
1847 {
1848 	struct netxen_adapter *adapter = netdev_priv(netdev);
1849 	int err = 0;
1850 
1851 	if (adapter->driver_mismatch)
1852 		return -EIO;
1853 
1854 	err = netxen_nic_attach(adapter);
1855 	if (err)
1856 		return err;
1857 
1858 	err = __netxen_nic_up(adapter, netdev);
1859 	if (err)
1860 		goto err_out;
1861 
1862 	netif_start_queue(netdev);
1863 
1864 	return 0;
1865 
1866 err_out:
1867 	netxen_nic_detach(adapter);
1868 	return err;
1869 }
1870 
1871 /*
1872  * netxen_nic_close - Disables a network interface entry point
1873  */
1874 static int netxen_nic_close(struct net_device *netdev)
1875 {
1876 	struct netxen_adapter *adapter = netdev_priv(netdev);
1877 
1878 	__netxen_nic_down(adapter, netdev);
1879 	return 0;
1880 }
1881 
1882 static void
1883 netxen_tso_check(struct net_device *netdev,
1884 		struct nx_host_tx_ring *tx_ring,
1885 		struct cmd_desc_type0 *first_desc,
1886 		struct sk_buff *skb)
1887 {
1888 	u8 opcode = TX_ETHER_PKT;
1889 	__be16 protocol = skb->protocol;
1890 	u16 flags = 0, vid = 0;
1891 	u32 producer;
1892 	int copied, offset, copy_len, hdr_len = 0, tso = 0, vlan_oob = 0;
1893 	struct cmd_desc_type0 *hwdesc;
1894 	struct vlan_ethhdr *vh;
1895 
1896 	if (protocol == cpu_to_be16(ETH_P_8021Q)) {
1897 
1898 		vh = (struct vlan_ethhdr *)skb->data;
1899 		protocol = vh->h_vlan_encapsulated_proto;
1900 		flags = FLAGS_VLAN_TAGGED;
1901 
1902 	} else if (skb_vlan_tag_present(skb)) {
1903 		flags = FLAGS_VLAN_OOB;
1904 		vid = skb_vlan_tag_get(skb);
1905 		netxen_set_tx_vlan_tci(first_desc, vid);
1906 		vlan_oob = 1;
1907 	}
1908 
1909 	if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
1910 			skb_shinfo(skb)->gso_size > 0) {
1911 
1912 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
1913 
1914 		first_desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
1915 		first_desc->total_hdr_length = hdr_len;
1916 		if (vlan_oob) {
1917 			first_desc->total_hdr_length += VLAN_HLEN;
1918 			first_desc->tcp_hdr_offset = VLAN_HLEN;
1919 			first_desc->ip_hdr_offset = VLAN_HLEN;
1920 			/* Only in case of TSO on vlan device */
1921 			flags |= FLAGS_VLAN_TAGGED;
1922 		}
1923 
1924 		opcode = (protocol == cpu_to_be16(ETH_P_IPV6)) ?
1925 				TX_TCP_LSO6 : TX_TCP_LSO;
1926 		tso = 1;
1927 
1928 	} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
1929 		u8 l4proto;
1930 
1931 		if (protocol == cpu_to_be16(ETH_P_IP)) {
1932 			l4proto = ip_hdr(skb)->protocol;
1933 
1934 			if (l4proto == IPPROTO_TCP)
1935 				opcode = TX_TCP_PKT;
1936 			else if(l4proto == IPPROTO_UDP)
1937 				opcode = TX_UDP_PKT;
1938 		} else if (protocol == cpu_to_be16(ETH_P_IPV6)) {
1939 			l4proto = ipv6_hdr(skb)->nexthdr;
1940 
1941 			if (l4proto == IPPROTO_TCP)
1942 				opcode = TX_TCPV6_PKT;
1943 			else if(l4proto == IPPROTO_UDP)
1944 				opcode = TX_UDPV6_PKT;
1945 		}
1946 	}
1947 
1948 	first_desc->tcp_hdr_offset += skb_transport_offset(skb);
1949 	first_desc->ip_hdr_offset += skb_network_offset(skb);
1950 	netxen_set_tx_flags_opcode(first_desc, flags, opcode);
1951 
1952 	if (!tso)
1953 		return;
1954 
1955 	/* For LSO, we need to copy the MAC/IP/TCP headers into
1956 	 * the descriptor ring
1957 	 */
1958 	producer = tx_ring->producer;
1959 	copied = 0;
1960 	offset = 2;
1961 
1962 	if (vlan_oob) {
1963 		/* Create a TSO vlan header template for firmware */
1964 
1965 		hwdesc = &tx_ring->desc_head[producer];
1966 		tx_ring->cmd_buf_arr[producer].skb = NULL;
1967 
1968 		copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1969 				hdr_len + VLAN_HLEN);
1970 
1971 		vh = (struct vlan_ethhdr *)((char *)hwdesc + 2);
1972 		skb_copy_from_linear_data(skb, vh, 12);
1973 		vh->h_vlan_proto = htons(ETH_P_8021Q);
1974 		vh->h_vlan_TCI = htons(vid);
1975 		skb_copy_from_linear_data_offset(skb, 12,
1976 				(char *)vh + 16, copy_len - 16);
1977 
1978 		copied = copy_len - VLAN_HLEN;
1979 		offset = 0;
1980 
1981 		producer = get_next_index(producer, tx_ring->num_desc);
1982 	}
1983 
1984 	while (copied < hdr_len) {
1985 
1986 		copy_len = min((int)sizeof(struct cmd_desc_type0) - offset,
1987 				(hdr_len - copied));
1988 
1989 		hwdesc = &tx_ring->desc_head[producer];
1990 		tx_ring->cmd_buf_arr[producer].skb = NULL;
1991 
1992 		skb_copy_from_linear_data_offset(skb, copied,
1993 				 (char *)hwdesc + offset, copy_len);
1994 
1995 		copied += copy_len;
1996 		offset = 0;
1997 
1998 		producer = get_next_index(producer, tx_ring->num_desc);
1999 	}
2000 
2001 	tx_ring->producer = producer;
2002 	barrier();
2003 }
2004 
2005 static int
2006 netxen_map_tx_skb(struct pci_dev *pdev,
2007 		struct sk_buff *skb, struct netxen_cmd_buffer *pbuf)
2008 {
2009 	struct netxen_skb_frag *nf;
2010 	struct skb_frag_struct *frag;
2011 	int i, nr_frags;
2012 	dma_addr_t map;
2013 
2014 	nr_frags = skb_shinfo(skb)->nr_frags;
2015 	nf = &pbuf->frag_array[0];
2016 
2017 	map = pci_map_single(pdev, skb->data,
2018 			skb_headlen(skb), PCI_DMA_TODEVICE);
2019 	if (pci_dma_mapping_error(pdev, map))
2020 		goto out_err;
2021 
2022 	nf->dma = map;
2023 	nf->length = skb_headlen(skb);
2024 
2025 	for (i = 0; i < nr_frags; i++) {
2026 		frag = &skb_shinfo(skb)->frags[i];
2027 		nf = &pbuf->frag_array[i+1];
2028 
2029 		map = skb_frag_dma_map(&pdev->dev, frag, 0, skb_frag_size(frag),
2030 				       DMA_TO_DEVICE);
2031 		if (dma_mapping_error(&pdev->dev, map))
2032 			goto unwind;
2033 
2034 		nf->dma = map;
2035 		nf->length = skb_frag_size(frag);
2036 	}
2037 
2038 	return 0;
2039 
2040 unwind:
2041 	while (--i >= 0) {
2042 		nf = &pbuf->frag_array[i+1];
2043 		pci_unmap_page(pdev, nf->dma, nf->length, PCI_DMA_TODEVICE);
2044 		nf->dma = 0ULL;
2045 	}
2046 
2047 	nf = &pbuf->frag_array[0];
2048 	pci_unmap_single(pdev, nf->dma, skb_headlen(skb), PCI_DMA_TODEVICE);
2049 	nf->dma = 0ULL;
2050 
2051 out_err:
2052 	return -ENOMEM;
2053 }
2054 
2055 static inline void
2056 netxen_clear_cmddesc(u64 *desc)
2057 {
2058 	desc[0] = 0ULL;
2059 	desc[2] = 0ULL;
2060 }
2061 
2062 static netdev_tx_t
2063 netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
2064 {
2065 	struct netxen_adapter *adapter = netdev_priv(netdev);
2066 	struct nx_host_tx_ring *tx_ring = adapter->tx_ring;
2067 	struct netxen_cmd_buffer *pbuf;
2068 	struct netxen_skb_frag *buffrag;
2069 	struct cmd_desc_type0 *hwdesc, *first_desc;
2070 	struct pci_dev *pdev;
2071 	int i, k;
2072 	int delta = 0;
2073 	struct skb_frag_struct *frag;
2074 
2075 	u32 producer;
2076 	int frag_count, no_of_desc;
2077 	u32 num_txd = tx_ring->num_desc;
2078 
2079 	frag_count = skb_shinfo(skb)->nr_frags + 1;
2080 
2081 	/* 14 frags supported for normal packet and
2082 	 * 32 frags supported for TSO packet
2083 	 */
2084 	if (!skb_is_gso(skb) && frag_count > NETXEN_MAX_FRAGS_PER_TX) {
2085 
2086 		for (i = 0; i < (frag_count - NETXEN_MAX_FRAGS_PER_TX); i++) {
2087 			frag = &skb_shinfo(skb)->frags[i];
2088 			delta += skb_frag_size(frag);
2089 		}
2090 
2091 		if (!__pskb_pull_tail(skb, delta))
2092 			goto drop_packet;
2093 
2094 		frag_count = 1 + skb_shinfo(skb)->nr_frags;
2095 	}
2096 	/* 4 fragments per cmd des */
2097 	no_of_desc = (frag_count + 3) >> 2;
2098 
2099 	if (unlikely(netxen_tx_avail(tx_ring) <= TX_STOP_THRESH)) {
2100 		netif_stop_queue(netdev);
2101 		smp_mb();
2102 		if (netxen_tx_avail(tx_ring) > TX_STOP_THRESH)
2103 			netif_start_queue(netdev);
2104 		else
2105 			return NETDEV_TX_BUSY;
2106 	}
2107 
2108 	producer = tx_ring->producer;
2109 	pbuf = &tx_ring->cmd_buf_arr[producer];
2110 
2111 	pdev = adapter->pdev;
2112 
2113 	if (netxen_map_tx_skb(pdev, skb, pbuf))
2114 		goto drop_packet;
2115 
2116 	pbuf->skb = skb;
2117 	pbuf->frag_count = frag_count;
2118 
2119 	first_desc = hwdesc = &tx_ring->desc_head[producer];
2120 	netxen_clear_cmddesc((u64 *)hwdesc);
2121 
2122 	netxen_set_tx_frags_len(first_desc, frag_count, skb->len);
2123 	netxen_set_tx_port(first_desc, adapter->portnum);
2124 
2125 	for (i = 0; i < frag_count; i++) {
2126 
2127 		k = i % 4;
2128 
2129 		if ((k == 0) && (i > 0)) {
2130 			/* move to next desc.*/
2131 			producer = get_next_index(producer, num_txd);
2132 			hwdesc = &tx_ring->desc_head[producer];
2133 			netxen_clear_cmddesc((u64 *)hwdesc);
2134 			tx_ring->cmd_buf_arr[producer].skb = NULL;
2135 		}
2136 
2137 		buffrag = &pbuf->frag_array[i];
2138 
2139 		hwdesc->buffer_length[k] = cpu_to_le16(buffrag->length);
2140 		switch (k) {
2141 		case 0:
2142 			hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
2143 			break;
2144 		case 1:
2145 			hwdesc->addr_buffer2 = cpu_to_le64(buffrag->dma);
2146 			break;
2147 		case 2:
2148 			hwdesc->addr_buffer3 = cpu_to_le64(buffrag->dma);
2149 			break;
2150 		case 3:
2151 			hwdesc->addr_buffer4 = cpu_to_le64(buffrag->dma);
2152 			break;
2153 		}
2154 	}
2155 
2156 	tx_ring->producer = get_next_index(producer, num_txd);
2157 
2158 	netxen_tso_check(netdev, tx_ring, first_desc, skb);
2159 
2160 	adapter->stats.txbytes += skb->len;
2161 	adapter->stats.xmitcalled++;
2162 
2163 	netxen_nic_update_cmd_producer(adapter, tx_ring);
2164 
2165 	return NETDEV_TX_OK;
2166 
2167 drop_packet:
2168 	adapter->stats.txdropped++;
2169 	dev_kfree_skb_any(skb);
2170 	return NETDEV_TX_OK;
2171 }
2172 
2173 static int netxen_nic_check_temp(struct netxen_adapter *adapter)
2174 {
2175 	struct net_device *netdev = adapter->netdev;
2176 	uint32_t temp, temp_state, temp_val;
2177 	int rv = 0;
2178 
2179 	temp = NXRD32(adapter, CRB_TEMP_STATE);
2180 
2181 	temp_state = nx_get_temp_state(temp);
2182 	temp_val = nx_get_temp_val(temp);
2183 
2184 	if (temp_state == NX_TEMP_PANIC) {
2185 		printk(KERN_ALERT
2186 		       "%s: Device temperature %d degrees C exceeds"
2187 		       " maximum allowed. Hardware has been shut down.\n",
2188 		       netdev->name, temp_val);
2189 		rv = 1;
2190 	} else if (temp_state == NX_TEMP_WARN) {
2191 		if (adapter->temp == NX_TEMP_NORMAL) {
2192 			printk(KERN_ALERT
2193 			       "%s: Device temperature %d degrees C "
2194 			       "exceeds operating range."
2195 			       " Immediate action needed.\n",
2196 			       netdev->name, temp_val);
2197 		}
2198 	} else {
2199 		if (adapter->temp == NX_TEMP_WARN) {
2200 			printk(KERN_INFO
2201 			       "%s: Device temperature is now %d degrees C"
2202 			       " in normal range.\n", netdev->name,
2203 			       temp_val);
2204 		}
2205 	}
2206 	adapter->temp = temp_state;
2207 	return rv;
2208 }
2209 
2210 void netxen_advert_link_change(struct netxen_adapter *adapter, int linkup)
2211 {
2212 	struct net_device *netdev = adapter->netdev;
2213 
2214 	if (adapter->ahw.linkup && !linkup) {
2215 		printk(KERN_INFO "%s: %s NIC Link is down\n",
2216 		       netxen_nic_driver_name, netdev->name);
2217 		adapter->ahw.linkup = 0;
2218 		if (netif_running(netdev)) {
2219 			netif_carrier_off(netdev);
2220 			netif_stop_queue(netdev);
2221 		}
2222 		adapter->link_changed = !adapter->has_link_events;
2223 	} else if (!adapter->ahw.linkup && linkup) {
2224 		printk(KERN_INFO "%s: %s NIC Link is up\n",
2225 		       netxen_nic_driver_name, netdev->name);
2226 		adapter->ahw.linkup = 1;
2227 		if (netif_running(netdev)) {
2228 			netif_carrier_on(netdev);
2229 			netif_wake_queue(netdev);
2230 		}
2231 		adapter->link_changed = !adapter->has_link_events;
2232 	}
2233 }
2234 
2235 static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
2236 {
2237 	u32 val, port, linkup;
2238 
2239 	port = adapter->physical_port;
2240 
2241 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
2242 		val = NXRD32(adapter, CRB_XG_STATE_P3);
2243 		val = XG_LINK_STATE_P3(adapter->ahw.pci_func, val);
2244 		linkup = (val == XG_LINK_UP_P3);
2245 	} else {
2246 		val = NXRD32(adapter, CRB_XG_STATE);
2247 		val = (val >> port*8) & 0xff;
2248 		linkup = (val == XG_LINK_UP);
2249 	}
2250 
2251 	netxen_advert_link_change(adapter, linkup);
2252 }
2253 
2254 static void netxen_tx_timeout(struct net_device *netdev)
2255 {
2256 	struct netxen_adapter *adapter = netdev_priv(netdev);
2257 
2258 	if (test_bit(__NX_RESETTING, &adapter->state))
2259 		return;
2260 
2261 	dev_err(&netdev->dev, "transmit timeout, resetting.\n");
2262 	schedule_work(&adapter->tx_timeout_task);
2263 }
2264 
2265 static void netxen_tx_timeout_task(struct work_struct *work)
2266 {
2267 	struct netxen_adapter *adapter =
2268 		container_of(work, struct netxen_adapter, tx_timeout_task);
2269 
2270 	if (!netif_running(adapter->netdev))
2271 		return;
2272 
2273 	if (test_and_set_bit(__NX_RESETTING, &adapter->state))
2274 		return;
2275 
2276 	if (++adapter->tx_timeo_cnt >= NX_MAX_TX_TIMEOUTS)
2277 		goto request_reset;
2278 
2279 	rtnl_lock();
2280 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
2281 		/* try to scrub interrupt */
2282 		netxen_napi_disable(adapter);
2283 
2284 		netxen_napi_enable(adapter);
2285 
2286 		netif_wake_queue(adapter->netdev);
2287 
2288 		clear_bit(__NX_RESETTING, &adapter->state);
2289 	} else {
2290 		clear_bit(__NX_RESETTING, &adapter->state);
2291 		if (netxen_nic_reset_context(adapter)) {
2292 			rtnl_unlock();
2293 			goto request_reset;
2294 		}
2295 	}
2296 	netif_trans_update(adapter->netdev);
2297 	rtnl_unlock();
2298 	return;
2299 
2300 request_reset:
2301 	adapter->need_fw_reset = 1;
2302 	clear_bit(__NX_RESETTING, &adapter->state);
2303 }
2304 
2305 static void netxen_nic_get_stats(struct net_device *netdev,
2306 				 struct rtnl_link_stats64 *stats)
2307 {
2308 	struct netxen_adapter *adapter = netdev_priv(netdev);
2309 
2310 	stats->rx_packets = adapter->stats.rx_pkts + adapter->stats.lro_pkts;
2311 	stats->tx_packets = adapter->stats.xmitfinished;
2312 	stats->rx_bytes = adapter->stats.rxbytes;
2313 	stats->tx_bytes = adapter->stats.txbytes;
2314 	stats->rx_dropped = adapter->stats.rxdropped;
2315 	stats->tx_dropped = adapter->stats.txdropped;
2316 }
2317 
2318 static irqreturn_t netxen_intr(int irq, void *data)
2319 {
2320 	struct nx_host_sds_ring *sds_ring = data;
2321 	struct netxen_adapter *adapter = sds_ring->adapter;
2322 	u32 status = 0;
2323 
2324 	status = readl(adapter->isr_int_vec);
2325 
2326 	if (!(status & adapter->int_vec_bit))
2327 		return IRQ_NONE;
2328 
2329 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
2330 		/* check interrupt state machine, to be sure */
2331 		status = readl(adapter->crb_int_state_reg);
2332 		if (!ISR_LEGACY_INT_TRIGGERED(status))
2333 			return IRQ_NONE;
2334 
2335 	} else {
2336 		unsigned long our_int = 0;
2337 
2338 		our_int = readl(adapter->crb_int_state_reg);
2339 
2340 		/* not our interrupt */
2341 		if (!test_and_clear_bit((7 + adapter->portnum), &our_int))
2342 			return IRQ_NONE;
2343 
2344 		/* claim interrupt */
2345 		writel((our_int & 0xffffffff), adapter->crb_int_state_reg);
2346 
2347 		/* clear interrupt */
2348 		netxen_nic_disable_int(sds_ring);
2349 	}
2350 
2351 	writel(0xffffffff, adapter->tgt_status_reg);
2352 	/* read twice to ensure write is flushed */
2353 	readl(adapter->isr_int_vec);
2354 	readl(adapter->isr_int_vec);
2355 
2356 	napi_schedule(&sds_ring->napi);
2357 
2358 	return IRQ_HANDLED;
2359 }
2360 
2361 static irqreturn_t netxen_msi_intr(int irq, void *data)
2362 {
2363 	struct nx_host_sds_ring *sds_ring = data;
2364 	struct netxen_adapter *adapter = sds_ring->adapter;
2365 
2366 	/* clear interrupt */
2367 	writel(0xffffffff, adapter->tgt_status_reg);
2368 
2369 	napi_schedule(&sds_ring->napi);
2370 	return IRQ_HANDLED;
2371 }
2372 
2373 static irqreturn_t netxen_msix_intr(int irq, void *data)
2374 {
2375 	struct nx_host_sds_ring *sds_ring = data;
2376 
2377 	napi_schedule(&sds_ring->napi);
2378 	return IRQ_HANDLED;
2379 }
2380 
2381 static int netxen_nic_poll(struct napi_struct *napi, int budget)
2382 {
2383 	struct nx_host_sds_ring *sds_ring =
2384 		container_of(napi, struct nx_host_sds_ring, napi);
2385 
2386 	struct netxen_adapter *adapter = sds_ring->adapter;
2387 
2388 	int tx_complete;
2389 	int work_done;
2390 
2391 	tx_complete = netxen_process_cmd_ring(adapter);
2392 
2393 	work_done = netxen_process_rcv_ring(sds_ring, budget);
2394 
2395 	if (!tx_complete)
2396 		work_done = budget;
2397 
2398 	if (work_done < budget) {
2399 		napi_complete_done(&sds_ring->napi, work_done);
2400 		if (test_bit(__NX_DEV_UP, &adapter->state))
2401 			netxen_nic_enable_int(sds_ring);
2402 	}
2403 
2404 	return work_done;
2405 }
2406 
2407 #ifdef CONFIG_NET_POLL_CONTROLLER
2408 static void netxen_nic_poll_controller(struct net_device *netdev)
2409 {
2410 	int ring;
2411 	struct nx_host_sds_ring *sds_ring;
2412 	struct netxen_adapter *adapter = netdev_priv(netdev);
2413 	struct netxen_recv_context *recv_ctx = &adapter->recv_ctx;
2414 
2415 	disable_irq(adapter->irq);
2416 	for (ring = 0; ring < adapter->max_sds_rings; ring++) {
2417 		sds_ring = &recv_ctx->sds_rings[ring];
2418 		netxen_intr(adapter->irq, sds_ring);
2419 	}
2420 	enable_irq(adapter->irq);
2421 }
2422 #endif
2423 
2424 static int
2425 nx_incr_dev_ref_cnt(struct netxen_adapter *adapter)
2426 {
2427 	int count;
2428 	if (netxen_api_lock(adapter))
2429 		return -EIO;
2430 
2431 	count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2432 
2433 	NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2434 
2435 	netxen_api_unlock(adapter);
2436 	return count;
2437 }
2438 
2439 static int
2440 nx_decr_dev_ref_cnt(struct netxen_adapter *adapter)
2441 {
2442 	int count, state;
2443 	if (netxen_api_lock(adapter))
2444 		return -EIO;
2445 
2446 	count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2447 	WARN_ON(count == 0);
2448 
2449 	NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2450 	state = NXRD32(adapter, NX_CRB_DEV_STATE);
2451 
2452 	if (count == 0 && state != NX_DEV_FAILED)
2453 		NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2454 
2455 	netxen_api_unlock(adapter);
2456 	return count;
2457 }
2458 
2459 static int
2460 nx_dev_request_aer(struct netxen_adapter *adapter)
2461 {
2462 	u32 state;
2463 	int ret = -EINVAL;
2464 
2465 	if (netxen_api_lock(adapter))
2466 		return ret;
2467 
2468 	state = NXRD32(adapter, NX_CRB_DEV_STATE);
2469 
2470 	if (state == NX_DEV_NEED_AER)
2471 		ret = 0;
2472 	else if (state == NX_DEV_READY) {
2473 		NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_AER);
2474 		ret = 0;
2475 	}
2476 
2477 	netxen_api_unlock(adapter);
2478 	return ret;
2479 }
2480 
2481 int
2482 nx_dev_request_reset(struct netxen_adapter *adapter)
2483 {
2484 	u32 state;
2485 	int ret = -EINVAL;
2486 
2487 	if (netxen_api_lock(adapter))
2488 		return ret;
2489 
2490 	state = NXRD32(adapter, NX_CRB_DEV_STATE);
2491 
2492 	if (state == NX_DEV_NEED_RESET || state == NX_DEV_FAILED)
2493 		ret = 0;
2494 	else if (state != NX_DEV_INITALIZING && state != NX_DEV_NEED_AER) {
2495 		NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_NEED_RESET);
2496 		adapter->flags |= NETXEN_FW_RESET_OWNER;
2497 		ret = 0;
2498 	}
2499 
2500 	netxen_api_unlock(adapter);
2501 
2502 	return ret;
2503 }
2504 
2505 static int
2506 netxen_can_start_firmware(struct netxen_adapter *adapter)
2507 {
2508 	int count;
2509 	int can_start = 0;
2510 
2511 	if (netxen_api_lock(adapter)) {
2512 		nx_incr_dev_ref_cnt(adapter);
2513 		return -1;
2514 	}
2515 
2516 	count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2517 
2518 	if ((count < 0) || (count >= NX_MAX_PCI_FUNC))
2519 		count = 0;
2520 
2521 	if (count == 0) {
2522 		can_start = 1;
2523 		NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_INITALIZING);
2524 	}
2525 
2526 	NXWR32(adapter, NX_CRB_DEV_REF_COUNT, ++count);
2527 
2528 	netxen_api_unlock(adapter);
2529 
2530 	return can_start;
2531 }
2532 
2533 static void
2534 netxen_schedule_work(struct netxen_adapter *adapter,
2535 		work_func_t func, int delay)
2536 {
2537 	INIT_DELAYED_WORK(&adapter->fw_work, func);
2538 	schedule_delayed_work(&adapter->fw_work, delay);
2539 }
2540 
2541 static void
2542 netxen_cancel_fw_work(struct netxen_adapter *adapter)
2543 {
2544 	while (test_and_set_bit(__NX_RESETTING, &adapter->state))
2545 		msleep(10);
2546 
2547 	cancel_delayed_work_sync(&adapter->fw_work);
2548 }
2549 
2550 static void
2551 netxen_attach_work(struct work_struct *work)
2552 {
2553 	struct netxen_adapter *adapter = container_of(work,
2554 				struct netxen_adapter, fw_work.work);
2555 	struct net_device *netdev = adapter->netdev;
2556 	int err = 0;
2557 
2558 	if (netif_running(netdev)) {
2559 		err = netxen_nic_attach(adapter);
2560 		if (err)
2561 			goto done;
2562 
2563 		err = netxen_nic_up(adapter, netdev);
2564 		if (err) {
2565 			netxen_nic_detach(adapter);
2566 			goto done;
2567 		}
2568 
2569 		netxen_restore_indev_addr(netdev, NETDEV_UP);
2570 	}
2571 
2572 	netif_device_attach(netdev);
2573 
2574 done:
2575 	adapter->fw_fail_cnt = 0;
2576 	clear_bit(__NX_RESETTING, &adapter->state);
2577 	netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2578 }
2579 
2580 static void
2581 netxen_fwinit_work(struct work_struct *work)
2582 {
2583 	struct netxen_adapter *adapter = container_of(work,
2584 				struct netxen_adapter, fw_work.work);
2585 	int dev_state;
2586 	int count;
2587 	dev_state = NXRD32(adapter, NX_CRB_DEV_STATE);
2588 	if (adapter->flags & NETXEN_FW_RESET_OWNER) {
2589 		count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2590 		WARN_ON(count == 0);
2591 		if (count == 1) {
2592 			if (adapter->mdump.md_enabled) {
2593 				rtnl_lock();
2594 				netxen_dump_fw(adapter);
2595 				rtnl_unlock();
2596 			}
2597 			adapter->flags &= ~NETXEN_FW_RESET_OWNER;
2598 			if (netxen_api_lock(adapter)) {
2599 				clear_bit(__NX_RESETTING, &adapter->state);
2600 				NXWR32(adapter, NX_CRB_DEV_STATE,
2601 						NX_DEV_FAILED);
2602 				return;
2603 			}
2604 			count = NXRD32(adapter, NX_CRB_DEV_REF_COUNT);
2605 			NXWR32(adapter, NX_CRB_DEV_REF_COUNT, --count);
2606 			NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_COLD);
2607 			dev_state = NX_DEV_COLD;
2608 			netxen_api_unlock(adapter);
2609 		}
2610 	}
2611 
2612 	switch (dev_state) {
2613 	case NX_DEV_COLD:
2614 	case NX_DEV_READY:
2615 		if (!netxen_start_firmware(adapter)) {
2616 			netxen_schedule_work(adapter, netxen_attach_work, 0);
2617 			return;
2618 		}
2619 		break;
2620 
2621 	case NX_DEV_NEED_RESET:
2622 	case NX_DEV_INITALIZING:
2623 			netxen_schedule_work(adapter,
2624 					netxen_fwinit_work, 2 * FW_POLL_DELAY);
2625 			return;
2626 
2627 	case NX_DEV_FAILED:
2628 	default:
2629 		nx_incr_dev_ref_cnt(adapter);
2630 		break;
2631 	}
2632 
2633 	if (netxen_api_lock(adapter)) {
2634 		clear_bit(__NX_RESETTING, &adapter->state);
2635 		return;
2636 	}
2637 	NXWR32(adapter, NX_CRB_DEV_STATE, NX_DEV_FAILED);
2638 	netxen_api_unlock(adapter);
2639 	dev_err(&adapter->pdev->dev, "%s: Device initialization Failed\n",
2640 				adapter->netdev->name);
2641 
2642 	clear_bit(__NX_RESETTING, &adapter->state);
2643 }
2644 
2645 static void
2646 netxen_detach_work(struct work_struct *work)
2647 {
2648 	struct netxen_adapter *adapter = container_of(work,
2649 				struct netxen_adapter, fw_work.work);
2650 	struct net_device *netdev = adapter->netdev;
2651 	int ref_cnt = 0, delay;
2652 	u32 status;
2653 
2654 	netif_device_detach(netdev);
2655 
2656 	netxen_nic_down(adapter, netdev);
2657 
2658 	rtnl_lock();
2659 	netxen_nic_detach(adapter);
2660 	rtnl_unlock();
2661 
2662 	status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2663 
2664 	if (status & NX_RCODE_FATAL_ERROR)
2665 		goto err_ret;
2666 
2667 	if (adapter->temp == NX_TEMP_PANIC)
2668 		goto err_ret;
2669 
2670 	if (!(adapter->flags & NETXEN_FW_RESET_OWNER))
2671 		ref_cnt = nx_decr_dev_ref_cnt(adapter);
2672 
2673 	if (ref_cnt == -EIO)
2674 		goto err_ret;
2675 
2676 	delay = (ref_cnt == 0) ? 0 : (2 * FW_POLL_DELAY);
2677 
2678 	adapter->fw_wait_cnt = 0;
2679 	netxen_schedule_work(adapter, netxen_fwinit_work, delay);
2680 
2681 	return;
2682 
2683 err_ret:
2684 	clear_bit(__NX_RESETTING, &adapter->state);
2685 }
2686 
2687 static int
2688 netxen_check_health(struct netxen_adapter *adapter)
2689 {
2690 	u32 state, heartbit;
2691 	u32 peg_status;
2692 	struct net_device *netdev = adapter->netdev;
2693 
2694 	state = NXRD32(adapter, NX_CRB_DEV_STATE);
2695 	if (state == NX_DEV_NEED_AER)
2696 		return 0;
2697 
2698 	if (netxen_nic_check_temp(adapter))
2699 		goto detach;
2700 
2701 	if (adapter->need_fw_reset) {
2702 		if (nx_dev_request_reset(adapter))
2703 			return 0;
2704 		goto detach;
2705 	}
2706 
2707 	/* NX_DEV_NEED_RESET, this state can be marked in two cases
2708 	 * 1. Tx timeout 2. Fw hang
2709 	 * Send request to destroy context in case of tx timeout only
2710 	 * and doesn't required in case of Fw hang
2711 	 */
2712 	if (state == NX_DEV_NEED_RESET || state == NX_DEV_FAILED) {
2713 		adapter->need_fw_reset = 1;
2714 		if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2715 			goto detach;
2716 	}
2717 
2718 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2719 		return 0;
2720 
2721 	heartbit = NXRD32(adapter, NETXEN_PEG_ALIVE_COUNTER);
2722 	if (heartbit != adapter->heartbit) {
2723 		adapter->heartbit = heartbit;
2724 		adapter->fw_fail_cnt = 0;
2725 		if (adapter->need_fw_reset)
2726 			goto detach;
2727 		return 0;
2728 	}
2729 
2730 	if (++adapter->fw_fail_cnt < FW_FAIL_THRESH)
2731 		return 0;
2732 
2733 	if (nx_dev_request_reset(adapter))
2734 		return 0;
2735 
2736 	clear_bit(__NX_FW_ATTACHED, &adapter->state);
2737 
2738 	dev_err(&netdev->dev, "firmware hang detected\n");
2739 	peg_status = NXRD32(adapter, NETXEN_PEG_HALT_STATUS1);
2740 	dev_err(&adapter->pdev->dev, "Dumping hw/fw registers\n"
2741 			"PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
2742 			"PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
2743 			"PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
2744 			"PEG_NET_4_PC: 0x%x\n",
2745 			peg_status,
2746 			NXRD32(adapter, NETXEN_PEG_HALT_STATUS2),
2747 			NXRD32(adapter, NETXEN_CRB_PEG_NET_0 + 0x3c),
2748 			NXRD32(adapter, NETXEN_CRB_PEG_NET_1 + 0x3c),
2749 			NXRD32(adapter, NETXEN_CRB_PEG_NET_2 + 0x3c),
2750 			NXRD32(adapter, NETXEN_CRB_PEG_NET_3 + 0x3c),
2751 			NXRD32(adapter, NETXEN_CRB_PEG_NET_4 + 0x3c));
2752 	if (NX_FWERROR_PEGSTAT1(peg_status) == 0x67)
2753 		dev_err(&adapter->pdev->dev,
2754 			"Firmware aborted with error code 0x00006700. "
2755 				"Device is being reset.\n");
2756 detach:
2757 	if ((auto_fw_reset == AUTO_FW_RESET_ENABLED) &&
2758 			!test_and_set_bit(__NX_RESETTING, &adapter->state))
2759 		netxen_schedule_work(adapter, netxen_detach_work, 0);
2760 	return 1;
2761 }
2762 
2763 static void
2764 netxen_fw_poll_work(struct work_struct *work)
2765 {
2766 	struct netxen_adapter *adapter = container_of(work,
2767 				struct netxen_adapter, fw_work.work);
2768 
2769 	if (test_bit(__NX_RESETTING, &adapter->state))
2770 		goto reschedule;
2771 
2772 	if (test_bit(__NX_DEV_UP, &adapter->state) &&
2773 	    !(adapter->capabilities & NX_FW_CAPABILITY_LINK_NOTIFICATION)) {
2774 		if (!adapter->has_link_events) {
2775 
2776 			netxen_nic_handle_phy_intr(adapter);
2777 
2778 			if (adapter->link_changed)
2779 				netxen_nic_set_link_parameters(adapter);
2780 		}
2781 	}
2782 
2783 	if (netxen_check_health(adapter))
2784 		return;
2785 
2786 reschedule:
2787 	netxen_schedule_work(adapter, netxen_fw_poll_work, FW_POLL_DELAY);
2788 }
2789 
2790 static ssize_t
2791 netxen_store_bridged_mode(struct device *dev,
2792 		struct device_attribute *attr, const char *buf, size_t len)
2793 {
2794 	struct net_device *net = to_net_dev(dev);
2795 	struct netxen_adapter *adapter = netdev_priv(net);
2796 	unsigned long new;
2797 	int ret = -EINVAL;
2798 
2799 	if (!(adapter->capabilities & NX_FW_CAPABILITY_BDG))
2800 		goto err_out;
2801 
2802 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
2803 		goto err_out;
2804 
2805 	if (kstrtoul(buf, 2, &new))
2806 		goto err_out;
2807 
2808 	if (!netxen_config_bridged_mode(adapter, !!new))
2809 		ret = len;
2810 
2811 err_out:
2812 	return ret;
2813 }
2814 
2815 static ssize_t
2816 netxen_show_bridged_mode(struct device *dev,
2817 		struct device_attribute *attr, char *buf)
2818 {
2819 	struct net_device *net = to_net_dev(dev);
2820 	struct netxen_adapter *adapter;
2821 	int bridged_mode = 0;
2822 
2823 	adapter = netdev_priv(net);
2824 
2825 	if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
2826 		bridged_mode = !!(adapter->flags & NETXEN_NIC_BRIDGE_ENABLED);
2827 
2828 	return sprintf(buf, "%d\n", bridged_mode);
2829 }
2830 
2831 static const struct device_attribute dev_attr_bridged_mode = {
2832        .attr = {.name = "bridged_mode", .mode = (S_IRUGO | S_IWUSR)},
2833        .show = netxen_show_bridged_mode,
2834        .store = netxen_store_bridged_mode,
2835 };
2836 
2837 static ssize_t
2838 netxen_store_diag_mode(struct device *dev,
2839 		struct device_attribute *attr, const char *buf, size_t len)
2840 {
2841 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2842 	unsigned long new;
2843 
2844 	if (kstrtoul(buf, 2, &new))
2845 		return -EINVAL;
2846 
2847 	if (!!new != !!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2848 		adapter->flags ^= NETXEN_NIC_DIAG_ENABLED;
2849 
2850 	return len;
2851 }
2852 
2853 static ssize_t
2854 netxen_show_diag_mode(struct device *dev,
2855 		struct device_attribute *attr, char *buf)
2856 {
2857 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2858 
2859 	return sprintf(buf, "%d\n",
2860 			!!(adapter->flags & NETXEN_NIC_DIAG_ENABLED));
2861 }
2862 
2863 static const struct device_attribute dev_attr_diag_mode = {
2864 	.attr = {.name = "diag_mode", .mode = (S_IRUGO | S_IWUSR)},
2865 	.show = netxen_show_diag_mode,
2866 	.store = netxen_store_diag_mode,
2867 };
2868 
2869 static int
2870 netxen_sysfs_validate_crb(struct netxen_adapter *adapter,
2871 		loff_t offset, size_t size)
2872 {
2873 	size_t crb_size = 4;
2874 
2875 	if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2876 		return -EIO;
2877 
2878 	if (offset < NETXEN_PCI_CRBSPACE) {
2879 		if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
2880 			return -EINVAL;
2881 
2882 		if (ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
2883 						NETXEN_PCI_CAMQM_2M_END))
2884 			crb_size = 8;
2885 		else
2886 			return -EINVAL;
2887 	}
2888 
2889 	if ((size != crb_size) || (offset & (crb_size-1)))
2890 		return  -EINVAL;
2891 
2892 	return 0;
2893 }
2894 
2895 static ssize_t
2896 netxen_sysfs_read_crb(struct file *filp, struct kobject *kobj,
2897 		struct bin_attribute *attr,
2898 		char *buf, loff_t offset, size_t size)
2899 {
2900 	struct device *dev = kobj_to_dev(kobj);
2901 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2902 	u32 data;
2903 	u64 qmdata;
2904 	int ret;
2905 
2906 	ret = netxen_sysfs_validate_crb(adapter, offset, size);
2907 	if (ret != 0)
2908 		return ret;
2909 
2910 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
2911 		ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
2912 					NETXEN_PCI_CAMQM_2M_END)) {
2913 		netxen_pci_camqm_read_2M(adapter, offset, &qmdata);
2914 		memcpy(buf, &qmdata, size);
2915 	} else {
2916 		data = NXRD32(adapter, offset);
2917 		memcpy(buf, &data, size);
2918 	}
2919 
2920 	return size;
2921 }
2922 
2923 static ssize_t
2924 netxen_sysfs_write_crb(struct file *filp, struct kobject *kobj,
2925 		struct bin_attribute *attr,
2926 		char *buf, loff_t offset, size_t size)
2927 {
2928 	struct device *dev = kobj_to_dev(kobj);
2929 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2930 	u32 data;
2931 	u64 qmdata;
2932 	int ret;
2933 
2934 	ret = netxen_sysfs_validate_crb(adapter, offset, size);
2935 	if (ret != 0)
2936 		return ret;
2937 
2938 	if (NX_IS_REVISION_P3(adapter->ahw.revision_id) &&
2939 		ADDR_IN_RANGE(offset, NETXEN_PCI_CAMQM,
2940 					NETXEN_PCI_CAMQM_2M_END)) {
2941 		memcpy(&qmdata, buf, size);
2942 		netxen_pci_camqm_write_2M(adapter, offset, qmdata);
2943 	} else {
2944 		memcpy(&data, buf, size);
2945 		NXWR32(adapter, offset, data);
2946 	}
2947 
2948 	return size;
2949 }
2950 
2951 static int
2952 netxen_sysfs_validate_mem(struct netxen_adapter *adapter,
2953 		loff_t offset, size_t size)
2954 {
2955 	if (!(adapter->flags & NETXEN_NIC_DIAG_ENABLED))
2956 		return -EIO;
2957 
2958 	if ((size != 8) || (offset & 0x7))
2959 		return  -EIO;
2960 
2961 	return 0;
2962 }
2963 
2964 static ssize_t
2965 netxen_sysfs_read_mem(struct file *filp, struct kobject *kobj,
2966 		struct bin_attribute *attr,
2967 		char *buf, loff_t offset, size_t size)
2968 {
2969 	struct device *dev = kobj_to_dev(kobj);
2970 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2971 	u64 data;
2972 	int ret;
2973 
2974 	ret = netxen_sysfs_validate_mem(adapter, offset, size);
2975 	if (ret != 0)
2976 		return ret;
2977 
2978 	if (adapter->pci_mem_read(adapter, offset, &data))
2979 		return -EIO;
2980 
2981 	memcpy(buf, &data, size);
2982 
2983 	return size;
2984 }
2985 
2986 static ssize_t netxen_sysfs_write_mem(struct file *filp, struct kobject *kobj,
2987 		struct bin_attribute *attr, char *buf,
2988 		loff_t offset, size_t size)
2989 {
2990 	struct device *dev = kobj_to_dev(kobj);
2991 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
2992 	u64 data;
2993 	int ret;
2994 
2995 	ret = netxen_sysfs_validate_mem(adapter, offset, size);
2996 	if (ret != 0)
2997 		return ret;
2998 
2999 	memcpy(&data, buf, size);
3000 
3001 	if (adapter->pci_mem_write(adapter, offset, data))
3002 		return -EIO;
3003 
3004 	return size;
3005 }
3006 
3007 
3008 static const struct bin_attribute bin_attr_crb = {
3009 	.attr = {.name = "crb", .mode = (S_IRUGO | S_IWUSR)},
3010 	.size = 0,
3011 	.read = netxen_sysfs_read_crb,
3012 	.write = netxen_sysfs_write_crb,
3013 };
3014 
3015 static const struct bin_attribute bin_attr_mem = {
3016 	.attr = {.name = "mem", .mode = (S_IRUGO | S_IWUSR)},
3017 	.size = 0,
3018 	.read = netxen_sysfs_read_mem,
3019 	.write = netxen_sysfs_write_mem,
3020 };
3021 
3022 static ssize_t
3023 netxen_sysfs_read_dimm(struct file *filp, struct kobject *kobj,
3024 		struct bin_attribute *attr,
3025 		char *buf, loff_t offset, size_t size)
3026 {
3027 	struct device *dev = kobj_to_dev(kobj);
3028 	struct netxen_adapter *adapter = dev_get_drvdata(dev);
3029 	struct net_device *netdev = adapter->netdev;
3030 	struct netxen_dimm_cfg dimm;
3031 	u8 dw, rows, cols, banks, ranks;
3032 	u32 val;
3033 
3034 	if (size < attr->size) {
3035 		netdev_err(netdev, "Invalid size\n");
3036 		return -EINVAL;
3037 	}
3038 
3039 	memset(&dimm, 0, sizeof(struct netxen_dimm_cfg));
3040 	val = NXRD32(adapter, NETXEN_DIMM_CAPABILITY);
3041 
3042 	/* Checks if DIMM info is valid. */
3043 	if (val & NETXEN_DIMM_VALID_FLAG) {
3044 		netdev_err(netdev, "Invalid DIMM flag\n");
3045 		dimm.presence = 0xff;
3046 		goto out;
3047 	}
3048 
3049 	rows = NETXEN_DIMM_NUMROWS(val);
3050 	cols = NETXEN_DIMM_NUMCOLS(val);
3051 	ranks = NETXEN_DIMM_NUMRANKS(val);
3052 	banks = NETXEN_DIMM_NUMBANKS(val);
3053 	dw = NETXEN_DIMM_DATAWIDTH(val);
3054 
3055 	dimm.presence = (val & NETXEN_DIMM_PRESENT);
3056 
3057 	/* Checks if DIMM info is present. */
3058 	if (!dimm.presence) {
3059 		netdev_err(netdev, "DIMM not present\n");
3060 		goto out;
3061 	}
3062 
3063 	dimm.dimm_type = NETXEN_DIMM_TYPE(val);
3064 
3065 	switch (dimm.dimm_type) {
3066 	case NETXEN_DIMM_TYPE_RDIMM:
3067 	case NETXEN_DIMM_TYPE_UDIMM:
3068 	case NETXEN_DIMM_TYPE_SO_DIMM:
3069 	case NETXEN_DIMM_TYPE_Micro_DIMM:
3070 	case NETXEN_DIMM_TYPE_Mini_RDIMM:
3071 	case NETXEN_DIMM_TYPE_Mini_UDIMM:
3072 		break;
3073 	default:
3074 		netdev_err(netdev, "Invalid DIMM type %x\n", dimm.dimm_type);
3075 		goto out;
3076 	}
3077 
3078 	if (val & NETXEN_DIMM_MEMTYPE_DDR2_SDRAM)
3079 		dimm.mem_type = NETXEN_DIMM_MEM_DDR2_SDRAM;
3080 	else
3081 		dimm.mem_type = NETXEN_DIMM_MEMTYPE(val);
3082 
3083 	if (val & NETXEN_DIMM_SIZE) {
3084 		dimm.size = NETXEN_DIMM_STD_MEM_SIZE;
3085 		goto out;
3086 	}
3087 
3088 	if (!rows) {
3089 		netdev_err(netdev, "Invalid no of rows %x\n", rows);
3090 		goto out;
3091 	}
3092 
3093 	if (!cols) {
3094 		netdev_err(netdev, "Invalid no of columns %x\n", cols);
3095 		goto out;
3096 	}
3097 
3098 	if (!banks) {
3099 		netdev_err(netdev, "Invalid no of banks %x\n", banks);
3100 		goto out;
3101 	}
3102 
3103 	ranks += 1;
3104 
3105 	switch (dw) {
3106 	case 0x0:
3107 		dw = 32;
3108 		break;
3109 	case 0x1:
3110 		dw = 33;
3111 		break;
3112 	case 0x2:
3113 		dw = 36;
3114 		break;
3115 	case 0x3:
3116 		dw = 64;
3117 		break;
3118 	case 0x4:
3119 		dw = 72;
3120 		break;
3121 	case 0x5:
3122 		dw = 80;
3123 		break;
3124 	case 0x6:
3125 		dw = 128;
3126 		break;
3127 	case 0x7:
3128 		dw = 144;
3129 		break;
3130 	default:
3131 		netdev_err(netdev, "Invalid data-width %x\n", dw);
3132 		goto out;
3133 	}
3134 
3135 	dimm.size = ((1 << rows) * (1 << cols) * dw * banks * ranks) / 8;
3136 	/* Size returned in MB. */
3137 	dimm.size = (dimm.size) / 0x100000;
3138 out:
3139 	memcpy(buf, &dimm, sizeof(struct netxen_dimm_cfg));
3140 	return sizeof(struct netxen_dimm_cfg);
3141 
3142 }
3143 
3144 static const struct bin_attribute bin_attr_dimm = {
3145 	.attr = { .name = "dimm", .mode = (S_IRUGO | S_IWUSR) },
3146 	.size = sizeof(struct netxen_dimm_cfg),
3147 	.read = netxen_sysfs_read_dimm,
3148 };
3149 
3150 
3151 static void
3152 netxen_create_sysfs_entries(struct netxen_adapter *adapter)
3153 {
3154 	struct device *dev = &adapter->pdev->dev;
3155 
3156 	if (adapter->capabilities & NX_FW_CAPABILITY_BDG) {
3157 		/* bridged_mode control */
3158 		if (device_create_file(dev, &dev_attr_bridged_mode)) {
3159 			dev_warn(dev,
3160 				"failed to create bridged_mode sysfs entry\n");
3161 		}
3162 	}
3163 }
3164 
3165 static void
3166 netxen_remove_sysfs_entries(struct netxen_adapter *adapter)
3167 {
3168 	struct device *dev = &adapter->pdev->dev;
3169 
3170 	if (adapter->capabilities & NX_FW_CAPABILITY_BDG)
3171 		device_remove_file(dev, &dev_attr_bridged_mode);
3172 }
3173 
3174 static void
3175 netxen_create_diag_entries(struct netxen_adapter *adapter)
3176 {
3177 	struct pci_dev *pdev = adapter->pdev;
3178 	struct device *dev;
3179 
3180 	dev = &pdev->dev;
3181 	if (device_create_file(dev, &dev_attr_diag_mode))
3182 		dev_info(dev, "failed to create diag_mode sysfs entry\n");
3183 	if (device_create_bin_file(dev, &bin_attr_crb))
3184 		dev_info(dev, "failed to create crb sysfs entry\n");
3185 	if (device_create_bin_file(dev, &bin_attr_mem))
3186 		dev_info(dev, "failed to create mem sysfs entry\n");
3187 	if (device_create_bin_file(dev, &bin_attr_dimm))
3188 		dev_info(dev, "failed to create dimm sysfs entry\n");
3189 }
3190 
3191 
3192 static void
3193 netxen_remove_diag_entries(struct netxen_adapter *adapter)
3194 {
3195 	struct pci_dev *pdev = adapter->pdev;
3196 	struct device *dev = &pdev->dev;
3197 
3198 	device_remove_file(dev, &dev_attr_diag_mode);
3199 	device_remove_bin_file(dev, &bin_attr_crb);
3200 	device_remove_bin_file(dev, &bin_attr_mem);
3201 	device_remove_bin_file(dev, &bin_attr_dimm);
3202 }
3203 
3204 #ifdef CONFIG_INET
3205 
3206 #define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
3207 
3208 static int
3209 netxen_destip_supported(struct netxen_adapter *adapter)
3210 {
3211 	if (NX_IS_REVISION_P2(adapter->ahw.revision_id))
3212 		return 0;
3213 
3214 	if (adapter->ahw.cut_through)
3215 		return 0;
3216 
3217 	return 1;
3218 }
3219 
3220 static void
3221 netxen_free_ip_list(struct netxen_adapter *adapter, bool master)
3222 {
3223 	struct nx_ip_list  *cur, *tmp_cur;
3224 
3225 	list_for_each_entry_safe(cur, tmp_cur, &adapter->ip_list, list) {
3226 		if (master) {
3227 			if (cur->master) {
3228 				netxen_config_ipaddr(adapter, cur->ip_addr,
3229 						     NX_IP_DOWN);
3230 				list_del(&cur->list);
3231 				kfree(cur);
3232 			}
3233 		} else {
3234 			netxen_config_ipaddr(adapter, cur->ip_addr, NX_IP_DOWN);
3235 			list_del(&cur->list);
3236 			kfree(cur);
3237 		}
3238 	}
3239 }
3240 
3241 static bool
3242 netxen_list_config_ip(struct netxen_adapter *adapter,
3243 		struct in_ifaddr *ifa, unsigned long event)
3244 {
3245 	struct net_device *dev;
3246 	struct nx_ip_list *cur, *tmp_cur;
3247 	struct list_head *head;
3248 	bool ret = false;
3249 
3250 	dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
3251 
3252 	if (dev == NULL)
3253 		goto out;
3254 
3255 	switch (event) {
3256 	case NX_IP_UP:
3257 		list_for_each(head, &adapter->ip_list) {
3258 			cur = list_entry(head, struct nx_ip_list, list);
3259 
3260 			if (cur->ip_addr == ifa->ifa_address)
3261 				goto out;
3262 		}
3263 
3264 		cur = kzalloc(sizeof(struct nx_ip_list), GFP_ATOMIC);
3265 		if (cur == NULL)
3266 			goto out;
3267 		if (is_vlan_dev(dev))
3268 			dev = vlan_dev_real_dev(dev);
3269 		cur->master = !!netif_is_bond_master(dev);
3270 		cur->ip_addr = ifa->ifa_address;
3271 		list_add_tail(&cur->list, &adapter->ip_list);
3272 		netxen_config_ipaddr(adapter, ifa->ifa_address, NX_IP_UP);
3273 		ret = true;
3274 		break;
3275 	case NX_IP_DOWN:
3276 		list_for_each_entry_safe(cur, tmp_cur,
3277 					&adapter->ip_list, list) {
3278 			if (cur->ip_addr == ifa->ifa_address) {
3279 				list_del(&cur->list);
3280 				kfree(cur);
3281 				netxen_config_ipaddr(adapter, ifa->ifa_address,
3282 						     NX_IP_DOWN);
3283 				ret = true;
3284 				break;
3285 			}
3286 		}
3287 	}
3288 out:
3289 	return ret;
3290 }
3291 
3292 static void
3293 netxen_config_indev_addr(struct netxen_adapter *adapter,
3294 		struct net_device *dev, unsigned long event)
3295 {
3296 	struct in_device *indev;
3297 
3298 	if (!netxen_destip_supported(adapter))
3299 		return;
3300 
3301 	indev = in_dev_get(dev);
3302 	if (!indev)
3303 		return;
3304 
3305 	for_ifa(indev) {
3306 		switch (event) {
3307 		case NETDEV_UP:
3308 			netxen_list_config_ip(adapter, ifa, NX_IP_UP);
3309 			break;
3310 		case NETDEV_DOWN:
3311 			netxen_list_config_ip(adapter, ifa, NX_IP_DOWN);
3312 			break;
3313 		default:
3314 			break;
3315 		}
3316 	} endfor_ifa(indev);
3317 
3318 	in_dev_put(indev);
3319 }
3320 
3321 static void
3322 netxen_restore_indev_addr(struct net_device *netdev, unsigned long event)
3323 
3324 {
3325 	struct netxen_adapter *adapter = netdev_priv(netdev);
3326 	struct nx_ip_list *pos, *tmp_pos;
3327 	unsigned long ip_event;
3328 
3329 	ip_event = (event == NETDEV_UP) ? NX_IP_UP : NX_IP_DOWN;
3330 	netxen_config_indev_addr(adapter, netdev, event);
3331 
3332 	list_for_each_entry_safe(pos, tmp_pos, &adapter->ip_list, list) {
3333 		netxen_config_ipaddr(adapter, pos->ip_addr, ip_event);
3334 	}
3335 }
3336 
3337 static inline bool
3338 netxen_config_checkdev(struct net_device *dev)
3339 {
3340 	struct netxen_adapter *adapter;
3341 
3342 	if (!is_netxen_netdev(dev))
3343 		return false;
3344 	adapter = netdev_priv(dev);
3345 	if (!adapter)
3346 		return false;
3347 	if (!netxen_destip_supported(adapter))
3348 		return false;
3349 	if (adapter->is_up != NETXEN_ADAPTER_UP_MAGIC)
3350 		return false;
3351 
3352 	return true;
3353 }
3354 
3355 /**
3356  * netxen_config_master - configure addresses based on master
3357  * @dev: netxen device
3358  * @event: netdev event
3359  */
3360 static void netxen_config_master(struct net_device *dev, unsigned long event)
3361 {
3362 	struct net_device *master, *slave;
3363 	struct netxen_adapter *adapter = netdev_priv(dev);
3364 
3365 	rcu_read_lock();
3366 	master = netdev_master_upper_dev_get_rcu(dev);
3367 	/*
3368 	 * This is the case where the netxen nic is being
3369 	 * enslaved and is dev_open()ed in bond_enslave()
3370 	 * Now we should program the bond's (and its vlans')
3371 	 * addresses in the netxen NIC.
3372 	 */
3373 	if (master && netif_is_bond_master(master) &&
3374 	    !netif_is_bond_slave(dev)) {
3375 		netxen_config_indev_addr(adapter, master, event);
3376 		for_each_netdev_rcu(&init_net, slave)
3377 			if (is_vlan_dev(slave) &&
3378 			    vlan_dev_real_dev(slave) == master)
3379 				netxen_config_indev_addr(adapter, slave, event);
3380 	}
3381 	rcu_read_unlock();
3382 	/*
3383 	 * This is the case where the netxen nic is being
3384 	 * released and is dev_close()ed in bond_release()
3385 	 * just before IFF_BONDING is stripped.
3386 	 */
3387 	if (!master && dev->priv_flags & IFF_BONDING)
3388 		netxen_free_ip_list(adapter, true);
3389 }
3390 
3391 static int netxen_netdev_event(struct notifier_block *this,
3392 				 unsigned long event, void *ptr)
3393 {
3394 	struct netxen_adapter *adapter;
3395 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3396 	struct net_device *orig_dev = dev;
3397 	struct net_device *slave;
3398 
3399 recheck:
3400 	if (dev == NULL)
3401 		goto done;
3402 
3403 	if (is_vlan_dev(dev)) {
3404 		dev = vlan_dev_real_dev(dev);
3405 		goto recheck;
3406 	}
3407 	if (event == NETDEV_UP || event == NETDEV_DOWN) {
3408 		/* If this is a bonding device, look for netxen-based slaves*/
3409 		if (netif_is_bond_master(dev)) {
3410 			rcu_read_lock();
3411 			for_each_netdev_in_bond_rcu(dev, slave) {
3412 				if (!netxen_config_checkdev(slave))
3413 					continue;
3414 				adapter = netdev_priv(slave);
3415 				netxen_config_indev_addr(adapter,
3416 							 orig_dev, event);
3417 			}
3418 			rcu_read_unlock();
3419 		} else {
3420 			if (!netxen_config_checkdev(dev))
3421 				goto done;
3422 			adapter = netdev_priv(dev);
3423 			/* Act only if the actual netxen is the target */
3424 			if (orig_dev == dev)
3425 				netxen_config_master(dev, event);
3426 			netxen_config_indev_addr(adapter, orig_dev, event);
3427 		}
3428 	}
3429 done:
3430 	return NOTIFY_DONE;
3431 }
3432 
3433 static int
3434 netxen_inetaddr_event(struct notifier_block *this,
3435 		unsigned long event, void *ptr)
3436 {
3437 	struct netxen_adapter *adapter;
3438 	struct net_device *dev, *slave;
3439 	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3440 	unsigned long ip_event;
3441 
3442 	dev = ifa->ifa_dev ? ifa->ifa_dev->dev : NULL;
3443 	ip_event = (event == NETDEV_UP) ? NX_IP_UP : NX_IP_DOWN;
3444 recheck:
3445 	if (dev == NULL)
3446 		goto done;
3447 
3448 	if (is_vlan_dev(dev)) {
3449 		dev = vlan_dev_real_dev(dev);
3450 		goto recheck;
3451 	}
3452 	if (event == NETDEV_UP || event == NETDEV_DOWN) {
3453 		/* If this is a bonding device, look for netxen-based slaves*/
3454 		if (netif_is_bond_master(dev)) {
3455 			rcu_read_lock();
3456 			for_each_netdev_in_bond_rcu(dev, slave) {
3457 				if (!netxen_config_checkdev(slave))
3458 					continue;
3459 				adapter = netdev_priv(slave);
3460 				netxen_list_config_ip(adapter, ifa, ip_event);
3461 			}
3462 			rcu_read_unlock();
3463 		} else {
3464 			if (!netxen_config_checkdev(dev))
3465 				goto done;
3466 			adapter = netdev_priv(dev);
3467 			netxen_list_config_ip(adapter, ifa, ip_event);
3468 		}
3469 	}
3470 done:
3471 	return NOTIFY_DONE;
3472 }
3473 
3474 static struct notifier_block	netxen_netdev_cb = {
3475 	.notifier_call = netxen_netdev_event,
3476 };
3477 
3478 static struct notifier_block netxen_inetaddr_cb = {
3479 	.notifier_call = netxen_inetaddr_event,
3480 };
3481 #else
3482 static void
3483 netxen_restore_indev_addr(struct net_device *dev, unsigned long event)
3484 { }
3485 static void
3486 netxen_free_ip_list(struct netxen_adapter *adapter, bool master)
3487 { }
3488 #endif
3489 
3490 static const struct pci_error_handlers netxen_err_handler = {
3491 	.error_detected = netxen_io_error_detected,
3492 	.slot_reset = netxen_io_slot_reset,
3493 	.resume = netxen_io_resume,
3494 };
3495 
3496 static struct pci_driver netxen_driver = {
3497 	.name = netxen_nic_driver_name,
3498 	.id_table = netxen_pci_tbl,
3499 	.probe = netxen_nic_probe,
3500 	.remove = netxen_nic_remove,
3501 #ifdef CONFIG_PM
3502 	.suspend = netxen_nic_suspend,
3503 	.resume = netxen_nic_resume,
3504 #endif
3505 	.shutdown = netxen_nic_shutdown,
3506 	.err_handler = &netxen_err_handler
3507 };
3508 
3509 static int __init netxen_init_module(void)
3510 {
3511 	printk(KERN_INFO "%s\n", netxen_nic_driver_string);
3512 
3513 #ifdef CONFIG_INET
3514 	register_netdevice_notifier(&netxen_netdev_cb);
3515 	register_inetaddr_notifier(&netxen_inetaddr_cb);
3516 #endif
3517 	return pci_register_driver(&netxen_driver);
3518 }
3519 
3520 module_init(netxen_init_module);
3521 
3522 static void __exit netxen_exit_module(void)
3523 {
3524 	pci_unregister_driver(&netxen_driver);
3525 
3526 #ifdef CONFIG_INET
3527 	unregister_inetaddr_notifier(&netxen_inetaddr_cb);
3528 	unregister_netdevice_notifier(&netxen_netdev_cb);
3529 #endif
3530 }
3531 
3532 module_exit(netxen_exit_module);
3533