2 * Copyright (C) 2003 - 2009 NetXen, Inc.
3 * Copyright (C) 2009 - QLogic Corporation.
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.
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.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
21 * The full GNU General Public License is included in this distribution
22 * in the file called "COPYING".
26 #include <linux/slab.h>
27 #include <linux/vmalloc.h>
28 #include <linux/interrupt.h>
29 #include "netxen_nic_hw.h"
31 #include "netxen_nic.h"
33 #include <linux/dma-mapping.h>
34 #include <linux/if_vlan.h>
36 #include <linux/ipv6.h>
37 #include <linux/inetdevice.h>
38 #include <linux/sysfs.h>
39 #include <linux/aer.h>
41 MODULE_DESCRIPTION("QLogic/NetXen (1/10) GbE Intelligent Ethernet Driver");
42 MODULE_LICENSE("GPL");
43 MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID
);
44 MODULE_FIRMWARE(NX_UNIFIED_ROMIMAGE_NAME
);
46 char netxen_nic_driver_name
[] = "netxen_nic";
47 static char netxen_nic_driver_string
[] = "QLogic/NetXen Network Driver v"
48 NETXEN_NIC_LINUX_VERSIONID
;
50 static int port_mode
= NETXEN_PORT_MODE_AUTO_NEG
;
52 /* Default to restricted 1G auto-neg mode */
53 static int wol_port_mode
= 5;
55 static int use_msi
= 1;
57 static int use_msi_x
= 1;
59 static int auto_fw_reset
= AUTO_FW_RESET_ENABLED
;
60 module_param(auto_fw_reset
, int, 0644);
61 MODULE_PARM_DESC(auto_fw_reset
,"Auto firmware reset (0=disabled, 1=enabled");
63 static int netxen_nic_probe(struct pci_dev
*pdev
,
64 const struct pci_device_id
*ent
);
65 static void netxen_nic_remove(struct pci_dev
*pdev
);
66 static int netxen_nic_open(struct net_device
*netdev
);
67 static int netxen_nic_close(struct net_device
*netdev
);
68 static netdev_tx_t
netxen_nic_xmit_frame(struct sk_buff
*,
70 static void netxen_tx_timeout(struct net_device
*netdev
);
71 static void netxen_tx_timeout_task(struct work_struct
*work
);
72 static void netxen_fw_poll_work(struct work_struct
*work
);
73 static void netxen_schedule_work(struct netxen_adapter
*adapter
,
74 work_func_t func
, int delay
);
75 static void netxen_cancel_fw_work(struct netxen_adapter
*adapter
);
76 static int netxen_nic_poll(struct napi_struct
*napi
, int budget
);
77 #ifdef CONFIG_NET_POLL_CONTROLLER
78 static void netxen_nic_poll_controller(struct net_device
*netdev
);
81 static void netxen_create_sysfs_entries(struct netxen_adapter
*adapter
);
82 static void netxen_remove_sysfs_entries(struct netxen_adapter
*adapter
);
83 static void netxen_create_diag_entries(struct netxen_adapter
*adapter
);
84 static void netxen_remove_diag_entries(struct netxen_adapter
*adapter
);
85 static int nx_dev_request_aer(struct netxen_adapter
*adapter
);
86 static int nx_decr_dev_ref_cnt(struct netxen_adapter
*adapter
);
87 static int netxen_can_start_firmware(struct netxen_adapter
*adapter
);
89 static irqreturn_t
netxen_intr(int irq
, void *data
);
90 static irqreturn_t
netxen_msi_intr(int irq
, void *data
);
91 static irqreturn_t
netxen_msix_intr(int irq
, void *data
);
93 static void netxen_free_ip_list(struct netxen_adapter
*, bool);
94 static void netxen_restore_indev_addr(struct net_device
*dev
, unsigned long);
95 static struct rtnl_link_stats64
*netxen_nic_get_stats(struct net_device
*dev
,
96 struct rtnl_link_stats64
*stats
);
97 static int netxen_nic_set_mac(struct net_device
*netdev
, void *p
);
99 /* PCI Device ID Table */
100 #define ENTRY(device) \
101 {PCI_DEVICE(PCI_VENDOR_ID_NETXEN, (device)), \
102 .class = PCI_CLASS_NETWORK_ETHERNET << 8, .class_mask = ~0}
104 static DEFINE_PCI_DEVICE_TABLE(netxen_pci_tbl
) = {
105 ENTRY(PCI_DEVICE_ID_NX2031_10GXSR
),
106 ENTRY(PCI_DEVICE_ID_NX2031_10GCX4
),
107 ENTRY(PCI_DEVICE_ID_NX2031_4GCU
),
108 ENTRY(PCI_DEVICE_ID_NX2031_IMEZ
),
109 ENTRY(PCI_DEVICE_ID_NX2031_HMEZ
),
110 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT
),
111 ENTRY(PCI_DEVICE_ID_NX2031_XG_MGMT2
),
112 ENTRY(PCI_DEVICE_ID_NX3031
),
116 MODULE_DEVICE_TABLE(pci
, netxen_pci_tbl
);
118 static uint32_t crb_cmd_producer
[4] = {
119 CRB_CMD_PRODUCER_OFFSET
, CRB_CMD_PRODUCER_OFFSET_1
,
120 CRB_CMD_PRODUCER_OFFSET_2
, CRB_CMD_PRODUCER_OFFSET_3
124 netxen_nic_update_cmd_producer(struct netxen_adapter
*adapter
,
125 struct nx_host_tx_ring
*tx_ring
)
127 NXWRIO(adapter
, tx_ring
->crb_cmd_producer
, tx_ring
->producer
);
130 static uint32_t crb_cmd_consumer
[4] = {
131 CRB_CMD_CONSUMER_OFFSET
, CRB_CMD_CONSUMER_OFFSET_1
,
132 CRB_CMD_CONSUMER_OFFSET_2
, CRB_CMD_CONSUMER_OFFSET_3
136 netxen_nic_update_cmd_consumer(struct netxen_adapter
*adapter
,
137 struct nx_host_tx_ring
*tx_ring
)
139 NXWRIO(adapter
, tx_ring
->crb_cmd_consumer
, tx_ring
->sw_consumer
);
142 static uint32_t msi_tgt_status
[8] = {
143 ISR_INT_TARGET_STATUS
, ISR_INT_TARGET_STATUS_F1
,
144 ISR_INT_TARGET_STATUS_F2
, ISR_INT_TARGET_STATUS_F3
,
145 ISR_INT_TARGET_STATUS_F4
, ISR_INT_TARGET_STATUS_F5
,
146 ISR_INT_TARGET_STATUS_F6
, ISR_INT_TARGET_STATUS_F7
149 static struct netxen_legacy_intr_set legacy_intr
[] = NX_LEGACY_INTR_CONFIG
;
151 static inline void netxen_nic_disable_int(struct nx_host_sds_ring
*sds_ring
)
153 struct netxen_adapter
*adapter
= sds_ring
->adapter
;
155 NXWRIO(adapter
, sds_ring
->crb_intr_mask
, 0);
158 static inline void netxen_nic_enable_int(struct nx_host_sds_ring
*sds_ring
)
160 struct netxen_adapter
*adapter
= sds_ring
->adapter
;
162 NXWRIO(adapter
, sds_ring
->crb_intr_mask
, 0x1);
164 if (!NETXEN_IS_MSI_FAMILY(adapter
))
165 NXWRIO(adapter
, adapter
->tgt_mask_reg
, 0xfbff);
169 netxen_alloc_sds_rings(struct netxen_recv_context
*recv_ctx
, int count
)
171 int size
= sizeof(struct nx_host_sds_ring
) * count
;
173 recv_ctx
->sds_rings
= kzalloc(size
, GFP_KERNEL
);
175 return recv_ctx
->sds_rings
== NULL
;
179 netxen_free_sds_rings(struct netxen_recv_context
*recv_ctx
)
181 if (recv_ctx
->sds_rings
!= NULL
)
182 kfree(recv_ctx
->sds_rings
);
184 recv_ctx
->sds_rings
= NULL
;
188 netxen_napi_add(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
191 struct nx_host_sds_ring
*sds_ring
;
192 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
194 if (netxen_alloc_sds_rings(recv_ctx
, adapter
->max_sds_rings
))
197 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
198 sds_ring
= &recv_ctx
->sds_rings
[ring
];
199 netif_napi_add(netdev
, &sds_ring
->napi
,
200 netxen_nic_poll
, NETXEN_NETDEV_WEIGHT
);
207 netxen_napi_del(struct netxen_adapter
*adapter
)
210 struct nx_host_sds_ring
*sds_ring
;
211 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
213 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
214 sds_ring
= &recv_ctx
->sds_rings
[ring
];
215 netif_napi_del(&sds_ring
->napi
);
218 netxen_free_sds_rings(&adapter
->recv_ctx
);
222 netxen_napi_enable(struct netxen_adapter
*adapter
)
225 struct nx_host_sds_ring
*sds_ring
;
226 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
228 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
229 sds_ring
= &recv_ctx
->sds_rings
[ring
];
230 napi_enable(&sds_ring
->napi
);
231 netxen_nic_enable_int(sds_ring
);
236 netxen_napi_disable(struct netxen_adapter
*adapter
)
239 struct nx_host_sds_ring
*sds_ring
;
240 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
242 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
243 sds_ring
= &recv_ctx
->sds_rings
[ring
];
244 netxen_nic_disable_int(sds_ring
);
245 napi_synchronize(&sds_ring
->napi
);
246 napi_disable(&sds_ring
->napi
);
250 static int nx_set_dma_mask(struct netxen_adapter
*adapter
)
252 struct pci_dev
*pdev
= adapter
->pdev
;
253 uint64_t mask
, cmask
;
255 adapter
->pci_using_dac
= 0;
257 mask
= DMA_BIT_MASK(32);
258 cmask
= DMA_BIT_MASK(32);
260 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
262 mask
= DMA_BIT_MASK(35);
265 mask
= DMA_BIT_MASK(39);
269 if (pci_set_dma_mask(pdev
, mask
) == 0 &&
270 pci_set_consistent_dma_mask(pdev
, cmask
) == 0) {
271 adapter
->pci_using_dac
= 1;
278 /* Update addressable range if firmware supports it */
280 nx_update_dma_mask(struct netxen_adapter
*adapter
)
282 int change
, shift
, err
;
283 uint64_t mask
, old_mask
, old_cmask
;
284 struct pci_dev
*pdev
= adapter
->pdev
;
288 shift
= NXRD32(adapter
, CRB_DMA_SHIFT
);
292 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
) && (shift
> 9))
294 else if ((adapter
->ahw
.revision_id
== NX_P2_C1
) && (shift
<= 4))
298 old_mask
= pdev
->dma_mask
;
299 old_cmask
= pdev
->dev
.coherent_dma_mask
;
301 mask
= DMA_BIT_MASK(32+shift
);
303 err
= pci_set_dma_mask(pdev
, mask
);
307 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
309 err
= pci_set_consistent_dma_mask(pdev
, mask
);
313 dev_info(&pdev
->dev
, "using %d-bit dma mask\n", 32+shift
);
319 pci_set_dma_mask(pdev
, old_mask
);
320 pci_set_consistent_dma_mask(pdev
, old_cmask
);
325 netxen_check_hw_init(struct netxen_adapter
*adapter
, int first_boot
)
329 if (first_boot
== 0x55555555) {
330 /* This is the first boot after power up */
331 NXWR32(adapter
, NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC
);
333 if (!NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
336 /* PCI bus master workaround */
337 first_boot
= NXRD32(adapter
, NETXEN_PCIE_REG(0x4));
338 if (!(first_boot
& 0x4)) {
340 NXWR32(adapter
, NETXEN_PCIE_REG(0x4), first_boot
);
341 NXRD32(adapter
, NETXEN_PCIE_REG(0x4));
344 /* This is the first boot after power up */
345 first_boot
= NXRD32(adapter
, NETXEN_ROMUSB_GLB_SW_RESET
);
346 if (first_boot
!= 0x80000f) {
347 /* clear the register for future unloads/loads */
348 NXWR32(adapter
, NETXEN_CAM_RAM(0x1fc), 0);
352 /* Start P2 boot loader */
353 val
= NXRD32(adapter
, NETXEN_ROMUSB_GLB_PEGTUNE_DONE
);
354 NXWR32(adapter
, NETXEN_ROMUSB_GLB_PEGTUNE_DONE
, val
| 0x1);
358 val
= NXRD32(adapter
, NETXEN_CAM_RAM(0x1fc));
360 if (++timeout
> 5000)
363 } while (val
== NETXEN_BDINFO_MAGIC
);
368 static void netxen_set_port_mode(struct netxen_adapter
*adapter
)
372 val
= adapter
->ahw
.board_type
;
373 if ((val
== NETXEN_BRDTYPE_P3_HMEZ
) ||
374 (val
== NETXEN_BRDTYPE_P3_XG_LOM
)) {
375 if (port_mode
== NETXEN_PORT_MODE_802_3_AP
) {
376 data
= NETXEN_PORT_MODE_802_3_AP
;
377 NXWR32(adapter
, NETXEN_PORT_MODE_ADDR
, data
);
378 } else if (port_mode
== NETXEN_PORT_MODE_XG
) {
379 data
= NETXEN_PORT_MODE_XG
;
380 NXWR32(adapter
, NETXEN_PORT_MODE_ADDR
, data
);
381 } else if (port_mode
== NETXEN_PORT_MODE_AUTO_NEG_1G
) {
382 data
= NETXEN_PORT_MODE_AUTO_NEG_1G
;
383 NXWR32(adapter
, NETXEN_PORT_MODE_ADDR
, data
);
384 } else if (port_mode
== NETXEN_PORT_MODE_AUTO_NEG_XG
) {
385 data
= NETXEN_PORT_MODE_AUTO_NEG_XG
;
386 NXWR32(adapter
, NETXEN_PORT_MODE_ADDR
, data
);
388 data
= NETXEN_PORT_MODE_AUTO_NEG
;
389 NXWR32(adapter
, NETXEN_PORT_MODE_ADDR
, data
);
392 if ((wol_port_mode
!= NETXEN_PORT_MODE_802_3_AP
) &&
393 (wol_port_mode
!= NETXEN_PORT_MODE_XG
) &&
394 (wol_port_mode
!= NETXEN_PORT_MODE_AUTO_NEG_1G
) &&
395 (wol_port_mode
!= NETXEN_PORT_MODE_AUTO_NEG_XG
)) {
396 wol_port_mode
= NETXEN_PORT_MODE_AUTO_NEG
;
398 NXWR32(adapter
, NETXEN_WOL_PORT_MODE
, wol_port_mode
);
402 #define PCI_CAP_ID_GEN 0x10
404 static void netxen_pcie_strap_init(struct netxen_adapter
*adapter
)
411 struct pci_dev
*pdev
;
413 pdev
= adapter
->pdev
;
415 chicken
= NXRD32(adapter
, NETXEN_PCIE_REG(PCIE_CHICKEN3
));
416 /* clear chicken3.25:24 */
417 chicken
&= 0xFCFFFFFF;
419 * if gen1 and B0, set F1020 - if gen 2, do nothing
420 * if gen2 set to F1000
422 pos
= pci_find_capability(pdev
, PCI_CAP_ID_GEN
);
424 pci_read_config_dword(pdev
, pos
+ 0x10, &control
);
425 if ((control
& 0x000F0000) != 0x00020000) {
426 /* set chicken3.24 if gen1 */
427 chicken
|= 0x01000000;
429 dev_info(&adapter
->pdev
->dev
, "Gen2 strapping detected\n");
432 /* set chicken3.24 if gen1 */
433 chicken
|= 0x01000000;
434 dev_info(&adapter
->pdev
->dev
, "Gen1 strapping detected\n");
435 if (adapter
->ahw
.revision_id
== NX_P3_B0
)
441 NXWR32(adapter
, NETXEN_PCIE_REG(PCIE_CHICKEN3
), chicken
);
446 pdevfuncsave
= pdev
->devfn
;
447 if (pdevfuncsave
& 0x07)
450 for (i
= 0; i
< 8; i
++) {
451 pci_read_config_dword(pdev
, pos
+ 8, &control
);
452 pci_read_config_dword(pdev
, pos
+ 8, &control
);
453 pci_write_config_dword(pdev
, pos
+ 8, c8c9value
);
456 pdev
->devfn
= pdevfuncsave
;
459 static void netxen_set_msix_bit(struct pci_dev
*pdev
, int enable
)
464 pos
= pci_find_capability(pdev
, PCI_CAP_ID_MSIX
);
466 pci_read_config_dword(pdev
, pos
, &control
);
468 control
|= PCI_MSIX_FLAGS_ENABLE
;
471 pci_write_config_dword(pdev
, pos
, control
);
475 static void netxen_init_msix_entries(struct netxen_adapter
*adapter
, int count
)
479 for (i
= 0; i
< count
; i
++)
480 adapter
->msix_entries
[i
].entry
= i
;
484 netxen_read_mac_addr(struct netxen_adapter
*adapter
)
489 struct net_device
*netdev
= adapter
->netdev
;
490 struct pci_dev
*pdev
= adapter
->pdev
;
492 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
493 if (netxen_p3_get_mac_addr(adapter
, &mac_addr
) != 0)
496 if (netxen_get_flash_mac_addr(adapter
, &mac_addr
) != 0)
500 p
= (unsigned char *)&mac_addr
;
501 for (i
= 0; i
< 6; i
++)
502 netdev
->dev_addr
[i
] = *(p
+ 5 - i
);
504 memcpy(adapter
->mac_addr
, netdev
->dev_addr
, netdev
->addr_len
);
506 /* set station address */
508 if (!is_valid_ether_addr(netdev
->dev_addr
))
509 dev_warn(&pdev
->dev
, "Bad MAC address %pM.\n", netdev
->dev_addr
);
514 static int netxen_nic_set_mac(struct net_device
*netdev
, void *p
)
516 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
517 struct sockaddr
*addr
= p
;
519 if (!is_valid_ether_addr(addr
->sa_data
))
520 return -EADDRNOTAVAIL
;
522 if (netif_running(netdev
)) {
523 netif_device_detach(netdev
);
524 netxen_napi_disable(adapter
);
527 memcpy(adapter
->mac_addr
, addr
->sa_data
, netdev
->addr_len
);
528 memcpy(netdev
->dev_addr
, addr
->sa_data
, netdev
->addr_len
);
529 adapter
->macaddr_set(adapter
, addr
->sa_data
);
531 if (netif_running(netdev
)) {
532 netif_device_attach(netdev
);
533 netxen_napi_enable(adapter
);
538 static void netxen_set_multicast_list(struct net_device
*dev
)
540 struct netxen_adapter
*adapter
= netdev_priv(dev
);
542 adapter
->set_multi(dev
);
545 static netdev_features_t
netxen_fix_features(struct net_device
*dev
,
546 netdev_features_t features
)
548 if (!(features
& NETIF_F_RXCSUM
)) {
549 netdev_info(dev
, "disabling LRO as RXCSUM is off\n");
551 features
&= ~NETIF_F_LRO
;
557 static int netxen_set_features(struct net_device
*dev
,
558 netdev_features_t features
)
560 struct netxen_adapter
*adapter
= netdev_priv(dev
);
563 if (!((dev
->features
^ features
) & NETIF_F_LRO
))
566 hw_lro
= (features
& NETIF_F_LRO
) ? NETXEN_NIC_LRO_ENABLED
567 : NETXEN_NIC_LRO_DISABLED
;
569 if (netxen_config_hw_lro(adapter
, hw_lro
))
572 if (!(features
& NETIF_F_LRO
) && netxen_send_lro_cleanup(adapter
))
578 static const struct net_device_ops netxen_netdev_ops
= {
579 .ndo_open
= netxen_nic_open
,
580 .ndo_stop
= netxen_nic_close
,
581 .ndo_start_xmit
= netxen_nic_xmit_frame
,
582 .ndo_get_stats64
= netxen_nic_get_stats
,
583 .ndo_validate_addr
= eth_validate_addr
,
584 .ndo_set_rx_mode
= netxen_set_multicast_list
,
585 .ndo_set_mac_address
= netxen_nic_set_mac
,
586 .ndo_change_mtu
= netxen_nic_change_mtu
,
587 .ndo_tx_timeout
= netxen_tx_timeout
,
588 .ndo_fix_features
= netxen_fix_features
,
589 .ndo_set_features
= netxen_set_features
,
590 #ifdef CONFIG_NET_POLL_CONTROLLER
591 .ndo_poll_controller
= netxen_nic_poll_controller
,
596 netxen_setup_intr(struct netxen_adapter
*adapter
)
598 struct netxen_legacy_intr_set
*legacy_intrp
;
599 struct pci_dev
*pdev
= adapter
->pdev
;
602 if (adapter
->rss_supported
) {
603 num_msix
= (num_online_cpus() >= MSIX_ENTRIES_PER_ADAPTER
) ?
604 MSIX_ENTRIES_PER_ADAPTER
: 2;
608 adapter
->max_sds_rings
= 1;
610 adapter
->flags
&= ~(NETXEN_NIC_MSI_ENABLED
| NETXEN_NIC_MSIX_ENABLED
);
612 if (adapter
->ahw
.revision_id
>= NX_P3_B0
)
613 legacy_intrp
= &legacy_intr
[adapter
->ahw
.pci_func
];
615 legacy_intrp
= &legacy_intr
[0];
617 adapter
->int_vec_bit
= legacy_intrp
->int_vec_bit
;
618 adapter
->tgt_status_reg
= netxen_get_ioaddr(adapter
,
619 legacy_intrp
->tgt_status_reg
);
620 adapter
->tgt_mask_reg
= netxen_get_ioaddr(adapter
,
621 legacy_intrp
->tgt_mask_reg
);
622 adapter
->pci_int_reg
= netxen_get_ioaddr(adapter
,
623 legacy_intrp
->pci_int_reg
);
624 adapter
->isr_int_vec
= netxen_get_ioaddr(adapter
, ISR_INT_VECTOR
);
626 if (adapter
->ahw
.revision_id
>= NX_P3_B1
)
627 adapter
->crb_int_state_reg
= netxen_get_ioaddr(adapter
,
630 adapter
->crb_int_state_reg
= netxen_get_ioaddr(adapter
,
633 netxen_set_msix_bit(pdev
, 0);
635 if (adapter
->msix_supported
) {
637 netxen_init_msix_entries(adapter
, num_msix
);
638 err
= pci_enable_msix(pdev
, adapter
->msix_entries
, num_msix
);
640 adapter
->flags
|= NETXEN_NIC_MSIX_ENABLED
;
641 netxen_set_msix_bit(pdev
, 1);
643 if (adapter
->rss_supported
)
644 adapter
->max_sds_rings
= num_msix
;
646 dev_info(&pdev
->dev
, "using msi-x interrupts\n");
651 pci_disable_msix(pdev
);
653 /* fall through for msi */
656 if (use_msi
&& !pci_enable_msi(pdev
)) {
657 adapter
->flags
|= NETXEN_NIC_MSI_ENABLED
;
658 adapter
->tgt_status_reg
= netxen_get_ioaddr(adapter
,
659 msi_tgt_status
[adapter
->ahw
.pci_func
]);
660 dev_info(&pdev
->dev
, "using msi interrupts\n");
661 adapter
->msix_entries
[0].vector
= pdev
->irq
;
665 dev_info(&pdev
->dev
, "using legacy interrupts\n");
666 adapter
->msix_entries
[0].vector
= pdev
->irq
;
670 netxen_teardown_intr(struct netxen_adapter
*adapter
)
672 if (adapter
->flags
& NETXEN_NIC_MSIX_ENABLED
)
673 pci_disable_msix(adapter
->pdev
);
674 if (adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)
675 pci_disable_msi(adapter
->pdev
);
679 netxen_cleanup_pci_map(struct netxen_adapter
*adapter
)
681 if (adapter
->ahw
.db_base
!= NULL
)
682 iounmap(adapter
->ahw
.db_base
);
683 if (adapter
->ahw
.pci_base0
!= NULL
)
684 iounmap(adapter
->ahw
.pci_base0
);
685 if (adapter
->ahw
.pci_base1
!= NULL
)
686 iounmap(adapter
->ahw
.pci_base1
);
687 if (adapter
->ahw
.pci_base2
!= NULL
)
688 iounmap(adapter
->ahw
.pci_base2
);
692 netxen_setup_pci_map(struct netxen_adapter
*adapter
)
694 void __iomem
*db_ptr
= NULL
;
696 resource_size_t mem_base
, db_base
;
697 unsigned long mem_len
, db_len
= 0;
699 struct pci_dev
*pdev
= adapter
->pdev
;
700 int pci_func
= adapter
->ahw
.pci_func
;
701 struct netxen_hardware_context
*ahw
= &adapter
->ahw
;
706 * Set the CRB window to invalid. If any register in window 0 is
707 * accessed it should set the window to 0 and then reset it to 1.
709 adapter
->ahw
.crb_win
= -1;
710 adapter
->ahw
.ocm_win
= -1;
712 /* remap phys address */
713 mem_base
= pci_resource_start(pdev
, 0); /* 0 is for BAR 0 */
714 mem_len
= pci_resource_len(pdev
, 0);
716 /* 128 Meg of memory */
717 if (mem_len
== NETXEN_PCI_128MB_SIZE
) {
719 ahw
->pci_base0
= ioremap(mem_base
, FIRST_PAGE_GROUP_SIZE
);
720 ahw
->pci_base1
= ioremap(mem_base
+ SECOND_PAGE_GROUP_START
,
721 SECOND_PAGE_GROUP_SIZE
);
722 ahw
->pci_base2
= ioremap(mem_base
+ THIRD_PAGE_GROUP_START
,
723 THIRD_PAGE_GROUP_SIZE
);
724 if (ahw
->pci_base0
== NULL
|| ahw
->pci_base1
== NULL
||
725 ahw
->pci_base2
== NULL
) {
726 dev_err(&pdev
->dev
, "failed to map PCI bar 0\n");
731 ahw
->pci_len0
= FIRST_PAGE_GROUP_SIZE
;
733 } else if (mem_len
== NETXEN_PCI_32MB_SIZE
) {
735 ahw
->pci_base1
= ioremap(mem_base
, SECOND_PAGE_GROUP_SIZE
);
736 ahw
->pci_base2
= ioremap(mem_base
+ THIRD_PAGE_GROUP_START
-
737 SECOND_PAGE_GROUP_START
, THIRD_PAGE_GROUP_SIZE
);
738 if (ahw
->pci_base1
== NULL
|| ahw
->pci_base2
== NULL
) {
739 dev_err(&pdev
->dev
, "failed to map PCI bar 0\n");
744 } else if (mem_len
== NETXEN_PCI_2MB_SIZE
) {
746 ahw
->pci_base0
= pci_ioremap_bar(pdev
, 0);
747 if (ahw
->pci_base0
== NULL
) {
748 dev_err(&pdev
->dev
, "failed to map PCI bar 0\n");
751 ahw
->pci_len0
= mem_len
;
756 netxen_setup_hwops(adapter
);
758 dev_info(&pdev
->dev
, "%dMB memory map\n", (int)(mem_len
>>20));
760 if (NX_IS_REVISION_P3P(adapter
->ahw
.revision_id
)) {
761 adapter
->ahw
.ocm_win_crb
= netxen_get_ioaddr(adapter
,
762 NETXEN_PCIX_PS_REG(PCIX_OCM_WINDOW_REG(pci_func
)));
764 } else if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
765 adapter
->ahw
.ocm_win_crb
= netxen_get_ioaddr(adapter
,
766 NETXEN_PCIX_PS_REG(PCIE_MN_WINDOW_REG(pci_func
)));
769 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
772 db_base
= pci_resource_start(pdev
, 4); /* doorbell is on bar 4 */
773 db_len
= pci_resource_len(pdev
, 4);
776 printk(KERN_ERR
"%s: doorbell is disabled\n",
777 netxen_nic_driver_name
);
782 db_ptr
= ioremap(db_base
, NETXEN_DB_MAPSIZE_BYTES
);
784 printk(KERN_ERR
"%s: Failed to allocate doorbell map.",
785 netxen_nic_driver_name
);
791 adapter
->ahw
.db_base
= db_ptr
;
792 adapter
->ahw
.db_len
= db_len
;
796 netxen_cleanup_pci_map(adapter
);
801 netxen_check_options(struct netxen_adapter
*adapter
)
803 u32 fw_major
, fw_minor
, fw_build
, prev_fw_version
;
804 char brd_name
[NETXEN_MAX_SHORT_NAME
];
806 int i
, offset
, val
, err
;
808 struct pci_dev
*pdev
= adapter
->pdev
;
810 adapter
->driver_mismatch
= 0;
812 ptr32
= (__le32
*)&serial_num
;
813 offset
= NX_FW_SERIAL_NUM_OFFSET
;
814 for (i
= 0; i
< 8; i
++) {
815 if (netxen_rom_fast_read(adapter
, offset
, &val
) == -1) {
816 dev_err(&pdev
->dev
, "error reading board info\n");
817 adapter
->driver_mismatch
= 1;
820 ptr32
[i
] = cpu_to_le32(val
);
821 offset
+= sizeof(u32
);
824 fw_major
= NXRD32(adapter
, NETXEN_FW_VERSION_MAJOR
);
825 fw_minor
= NXRD32(adapter
, NETXEN_FW_VERSION_MINOR
);
826 fw_build
= NXRD32(adapter
, NETXEN_FW_VERSION_SUB
);
827 prev_fw_version
= adapter
->fw_version
;
828 adapter
->fw_version
= NETXEN_VERSION_CODE(fw_major
, fw_minor
, fw_build
);
830 /* Get FW Mini Coredump template and store it */
831 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
832 if (adapter
->mdump
.md_template
== NULL
||
833 adapter
->fw_version
> prev_fw_version
) {
834 kfree(adapter
->mdump
.md_template
);
835 adapter
->mdump
.md_template
= NULL
;
836 err
= netxen_setup_minidump(adapter
);
838 dev_err(&adapter
->pdev
->dev
,
839 "Failed to setup minidump rcode = %d\n", err
);
843 if (adapter
->portnum
== 0) {
844 get_brd_name_by_type(adapter
->ahw
.board_type
, brd_name
);
846 pr_info("%s: %s Board S/N %s Chip rev 0x%x\n",
847 module_name(THIS_MODULE
),
848 brd_name
, serial_num
, adapter
->ahw
.revision_id
);
851 if (adapter
->fw_version
< NETXEN_VERSION_CODE(3, 4, 216)) {
852 adapter
->driver_mismatch
= 1;
853 dev_warn(&pdev
->dev
, "firmware version %d.%d.%d unsupported\n",
854 fw_major
, fw_minor
, fw_build
);
858 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
859 i
= NXRD32(adapter
, NETXEN_SRE_MISC
);
860 adapter
->ahw
.cut_through
= (i
& 0x8000) ? 1 : 0;
863 dev_info(&pdev
->dev
, "firmware v%d.%d.%d [%s]\n",
864 fw_major
, fw_minor
, fw_build
,
865 adapter
->ahw
.cut_through
? "cut-through" : "legacy");
867 if (adapter
->fw_version
>= NETXEN_VERSION_CODE(4, 0, 222))
868 adapter
->capabilities
= NXRD32(adapter
, CRB_FW_CAPABILITIES_1
);
870 if (adapter
->ahw
.port_type
== NETXEN_NIC_XGBE
) {
871 adapter
->num_rxd
= DEFAULT_RCV_DESCRIPTORS_10G
;
872 adapter
->num_jumbo_rxd
= MAX_JUMBO_RCV_DESCRIPTORS_10G
;
873 } else if (adapter
->ahw
.port_type
== NETXEN_NIC_GBE
) {
874 adapter
->num_rxd
= DEFAULT_RCV_DESCRIPTORS_1G
;
875 adapter
->num_jumbo_rxd
= MAX_JUMBO_RCV_DESCRIPTORS_1G
;
878 adapter
->msix_supported
= 0;
879 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
880 adapter
->msix_supported
= !!use_msi_x
;
881 adapter
->rss_supported
= !!use_msi_x
;
884 netxen_rom_fast_read(adapter
,
885 NX_FW_VERSION_OFFSET
, (int *)&flashed_ver
);
886 flashed_ver
= NETXEN_DECODE_VERSION(flashed_ver
);
888 if (flashed_ver
>= NETXEN_VERSION_CODE(3, 4, 336)) {
889 switch (adapter
->ahw
.board_type
) {
890 case NETXEN_BRDTYPE_P2_SB31_10G
:
891 case NETXEN_BRDTYPE_P2_SB31_10G_CX4
:
892 adapter
->msix_supported
= !!use_msi_x
;
893 adapter
->rss_supported
= !!use_msi_x
;
901 adapter
->num_txd
= MAX_CMD_DESCRIPTORS
;
903 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
904 adapter
->num_lro_rxd
= MAX_LRO_RCV_DESCRIPTORS
;
905 adapter
->max_rds_rings
= 3;
907 adapter
->num_lro_rxd
= 0;
908 adapter
->max_rds_rings
= 2;
913 netxen_start_firmware(struct netxen_adapter
*adapter
)
915 int val
, err
, first_boot
;
916 struct pci_dev
*pdev
= adapter
->pdev
;
918 /* required for NX2031 dummy dma */
919 err
= nx_set_dma_mask(adapter
);
923 err
= netxen_can_start_firmware(adapter
);
931 first_boot
= NXRD32(adapter
, NETXEN_CAM_RAM(0x1fc));
933 err
= netxen_check_hw_init(adapter
, first_boot
);
935 dev_err(&pdev
->dev
, "error in init HW init sequence\n");
939 netxen_request_firmware(adapter
);
941 err
= netxen_need_fw_reset(adapter
);
945 goto pcie_strap_init
;
947 if (first_boot
!= 0x55555555) {
948 NXWR32(adapter
, CRB_CMDPEG_STATE
, 0);
949 netxen_pinit_from_rom(adapter
);
953 NXWR32(adapter
, CRB_DMA_SHIFT
, 0x55555555);
954 NXWR32(adapter
, NETXEN_PEG_HALT_STATUS1
, 0);
955 NXWR32(adapter
, NETXEN_PEG_HALT_STATUS2
, 0);
957 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
958 netxen_set_port_mode(adapter
);
960 err
= netxen_load_firmware(adapter
);
964 netxen_release_firmware(adapter
);
966 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
968 /* Initialize multicast addr pool owners */
970 if (adapter
->ahw
.port_type
== NETXEN_NIC_XGBE
)
972 NXWR32(adapter
, NETXEN_MAC_ADDR_CNTL_REG
, val
);
976 err
= netxen_init_dummy_dma(adapter
);
981 * Tell the hardware our version number.
983 val
= (_NETXEN_NIC_LINUX_MAJOR
<< 16)
984 | ((_NETXEN_NIC_LINUX_MINOR
<< 8))
985 | (_NETXEN_NIC_LINUX_SUBVERSION
);
986 NXWR32(adapter
, CRB_DRIVER_VERSION
, val
);
989 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
990 netxen_pcie_strap_init(adapter
);
993 /* Handshake with the card before we register the devices. */
994 err
= netxen_phantom_init(adapter
, NETXEN_NIC_PEG_TUNE
);
996 netxen_free_dummy_dma(adapter
);
1000 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_READY
);
1002 nx_update_dma_mask(adapter
);
1004 netxen_check_options(adapter
);
1006 adapter
->need_fw_reset
= 0;
1008 /* fall through and release firmware */
1011 netxen_release_firmware(adapter
);
1016 netxen_nic_request_irq(struct netxen_adapter
*adapter
)
1018 irq_handler_t handler
;
1019 struct nx_host_sds_ring
*sds_ring
;
1022 unsigned long flags
= 0;
1023 struct net_device
*netdev
= adapter
->netdev
;
1024 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
1026 if (adapter
->flags
& NETXEN_NIC_MSIX_ENABLED
)
1027 handler
= netxen_msix_intr
;
1028 else if (adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)
1029 handler
= netxen_msi_intr
;
1031 flags
|= IRQF_SHARED
;
1032 handler
= netxen_intr
;
1034 adapter
->irq
= netdev
->irq
;
1036 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
1037 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1038 sprintf(sds_ring
->name
, "%s[%d]", netdev
->name
, ring
);
1039 err
= request_irq(sds_ring
->irq
, handler
,
1040 flags
, sds_ring
->name
, sds_ring
);
1049 netxen_nic_free_irq(struct netxen_adapter
*adapter
)
1052 struct nx_host_sds_ring
*sds_ring
;
1054 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
1056 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
1057 sds_ring
= &recv_ctx
->sds_rings
[ring
];
1058 free_irq(sds_ring
->irq
, sds_ring
);
1063 netxen_nic_init_coalesce_defaults(struct netxen_adapter
*adapter
)
1065 adapter
->coal
.flags
= NETXEN_NIC_INTR_DEFAULT
;
1066 adapter
->coal
.normal
.data
.rx_time_us
=
1067 NETXEN_DEFAULT_INTR_COALESCE_RX_TIME_US
;
1068 adapter
->coal
.normal
.data
.rx_packets
=
1069 NETXEN_DEFAULT_INTR_COALESCE_RX_PACKETS
;
1070 adapter
->coal
.normal
.data
.tx_time_us
=
1071 NETXEN_DEFAULT_INTR_COALESCE_TX_TIME_US
;
1072 adapter
->coal
.normal
.data
.tx_packets
=
1073 NETXEN_DEFAULT_INTR_COALESCE_TX_PACKETS
;
1076 /* with rtnl_lock */
1078 __netxen_nic_up(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
1082 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
)
1085 err
= adapter
->init_port(adapter
, adapter
->physical_port
);
1087 printk(KERN_ERR
"%s: Failed to initialize port %d\n",
1088 netxen_nic_driver_name
, adapter
->portnum
);
1091 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
1092 adapter
->macaddr_set(adapter
, adapter
->mac_addr
);
1094 adapter
->set_multi(netdev
);
1095 adapter
->set_mtu(adapter
, netdev
->mtu
);
1097 adapter
->ahw
.linkup
= 0;
1099 if (adapter
->max_sds_rings
> 1)
1100 netxen_config_rss(adapter
, 1);
1102 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1103 netxen_config_intr_coalesce(adapter
);
1105 if (netdev
->features
& NETIF_F_LRO
)
1106 netxen_config_hw_lro(adapter
, NETXEN_NIC_LRO_ENABLED
);
1108 netxen_napi_enable(adapter
);
1110 if (adapter
->capabilities
& NX_FW_CAPABILITY_LINK_NOTIFICATION
)
1111 netxen_linkevent_request(adapter
, 1);
1113 netxen_nic_set_link_parameters(adapter
);
1115 set_bit(__NX_DEV_UP
, &adapter
->state
);
1119 /* Usage: During resume and firmware recovery module.*/
1122 netxen_nic_up(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
1127 if (netif_running(netdev
))
1128 err
= __netxen_nic_up(adapter
, netdev
);
1134 /* with rtnl_lock */
1136 __netxen_nic_down(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
1138 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
)
1141 if (!test_and_clear_bit(__NX_DEV_UP
, &adapter
->state
))
1145 spin_lock(&adapter
->tx_clean_lock
);
1146 netif_carrier_off(netdev
);
1147 netif_tx_disable(netdev
);
1149 if (adapter
->capabilities
& NX_FW_CAPABILITY_LINK_NOTIFICATION
)
1150 netxen_linkevent_request(adapter
, 0);
1152 if (adapter
->stop_port
)
1153 adapter
->stop_port(adapter
);
1155 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1156 netxen_p3_free_mac_list(adapter
);
1158 adapter
->set_promisc(adapter
, NETXEN_NIU_NON_PROMISC_MODE
);
1160 netxen_napi_disable(adapter
);
1162 netxen_release_tx_buffers(adapter
);
1163 spin_unlock(&adapter
->tx_clean_lock
);
1166 /* Usage: During suspend and firmware recovery module */
1169 netxen_nic_down(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
1172 if (netif_running(netdev
))
1173 __netxen_nic_down(adapter
, netdev
);
1179 netxen_nic_attach(struct netxen_adapter
*adapter
)
1181 struct net_device
*netdev
= adapter
->netdev
;
1182 struct pci_dev
*pdev
= adapter
->pdev
;
1184 struct nx_host_rds_ring
*rds_ring
;
1185 struct nx_host_tx_ring
*tx_ring
;
1188 if (adapter
->is_up
== NETXEN_ADAPTER_UP_MAGIC
)
1191 err
= netxen_init_firmware(adapter
);
1195 adapter
->flags
&= ~NETXEN_FW_MSS_CAP
;
1196 if (adapter
->capabilities
& NX_FW_CAPABILITY_MORE_CAPS
) {
1197 capab2
= NXRD32(adapter
, CRB_FW_CAPABILITIES_2
);
1198 if (capab2
& NX_FW_CAPABILITY_2_LRO_MAX_TCP_SEG
)
1199 adapter
->flags
|= NETXEN_FW_MSS_CAP
;
1202 err
= netxen_napi_add(adapter
, netdev
);
1206 err
= netxen_alloc_sw_resources(adapter
);
1208 printk(KERN_ERR
"%s: Error in setting sw resources\n",
1213 err
= netxen_alloc_hw_resources(adapter
);
1215 printk(KERN_ERR
"%s: Error in setting hw resources\n",
1217 goto err_out_free_sw
;
1220 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
1221 tx_ring
= adapter
->tx_ring
;
1222 tx_ring
->crb_cmd_producer
= netxen_get_ioaddr(adapter
,
1223 crb_cmd_producer
[adapter
->portnum
]);
1224 tx_ring
->crb_cmd_consumer
= netxen_get_ioaddr(adapter
,
1225 crb_cmd_consumer
[adapter
->portnum
]);
1227 tx_ring
->producer
= 0;
1228 tx_ring
->sw_consumer
= 0;
1230 netxen_nic_update_cmd_producer(adapter
, tx_ring
);
1231 netxen_nic_update_cmd_consumer(adapter
, tx_ring
);
1234 for (ring
= 0; ring
< adapter
->max_rds_rings
; ring
++) {
1235 rds_ring
= &adapter
->recv_ctx
.rds_rings
[ring
];
1236 netxen_post_rx_buffers(adapter
, ring
, rds_ring
);
1239 err
= netxen_nic_request_irq(adapter
);
1241 dev_err(&pdev
->dev
, "%s: failed to setup interrupt\n",
1243 goto err_out_free_rxbuf
;
1246 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1247 netxen_nic_init_coalesce_defaults(adapter
);
1249 netxen_create_sysfs_entries(adapter
);
1251 adapter
->is_up
= NETXEN_ADAPTER_UP_MAGIC
;
1255 netxen_release_rx_buffers(adapter
);
1256 netxen_free_hw_resources(adapter
);
1258 netxen_free_sw_resources(adapter
);
1263 netxen_nic_detach(struct netxen_adapter
*adapter
)
1265 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
)
1268 netxen_remove_sysfs_entries(adapter
);
1270 netxen_free_hw_resources(adapter
);
1271 netxen_release_rx_buffers(adapter
);
1272 netxen_nic_free_irq(adapter
);
1273 netxen_napi_del(adapter
);
1274 netxen_free_sw_resources(adapter
);
1280 netxen_nic_reset_context(struct netxen_adapter
*adapter
)
1283 struct net_device
*netdev
= adapter
->netdev
;
1285 if (test_and_set_bit(__NX_RESETTING
, &adapter
->state
))
1288 if (adapter
->is_up
== NETXEN_ADAPTER_UP_MAGIC
) {
1290 netif_device_detach(netdev
);
1292 if (netif_running(netdev
))
1293 __netxen_nic_down(adapter
, netdev
);
1295 netxen_nic_detach(adapter
);
1297 if (netif_running(netdev
)) {
1298 err
= netxen_nic_attach(adapter
);
1300 err
= __netxen_nic_up(adapter
, netdev
);
1306 netif_device_attach(netdev
);
1310 clear_bit(__NX_RESETTING
, &adapter
->state
);
1315 netxen_setup_netdev(struct netxen_adapter
*adapter
,
1316 struct net_device
*netdev
)
1319 struct pci_dev
*pdev
= adapter
->pdev
;
1321 adapter
->mc_enabled
= 0;
1322 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1323 adapter
->max_mc_count
= 38;
1325 adapter
->max_mc_count
= 16;
1327 netdev
->netdev_ops
= &netxen_netdev_ops
;
1328 netdev
->watchdog_timeo
= 5*HZ
;
1330 netxen_nic_change_mtu(netdev
, netdev
->mtu
);
1332 SET_ETHTOOL_OPS(netdev
, &netxen_nic_ethtool_ops
);
1334 netdev
->hw_features
= NETIF_F_SG
| NETIF_F_IP_CSUM
| NETIF_F_TSO
|
1337 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
))
1338 netdev
->hw_features
|= NETIF_F_IPV6_CSUM
| NETIF_F_TSO6
;
1340 netdev
->vlan_features
|= netdev
->hw_features
;
1342 if (adapter
->pci_using_dac
) {
1343 netdev
->features
|= NETIF_F_HIGHDMA
;
1344 netdev
->vlan_features
|= NETIF_F_HIGHDMA
;
1347 if (adapter
->capabilities
& NX_FW_CAPABILITY_FVLANTX
)
1348 netdev
->hw_features
|= NETIF_F_HW_VLAN_CTAG_TX
;
1350 if (adapter
->capabilities
& NX_FW_CAPABILITY_HW_LRO
)
1351 netdev
->hw_features
|= NETIF_F_LRO
;
1353 netdev
->features
|= netdev
->hw_features
;
1355 netdev
->irq
= adapter
->msix_entries
[0].vector
;
1357 INIT_WORK(&adapter
->tx_timeout_task
, netxen_tx_timeout_task
);
1359 if (netxen_read_mac_addr(adapter
))
1360 dev_warn(&pdev
->dev
, "failed to read mac addr\n");
1362 netif_carrier_off(netdev
);
1364 err
= register_netdev(netdev
);
1366 dev_err(&pdev
->dev
, "failed to register net device\n");
1373 #ifdef CONFIG_PCIEAER
1374 static void netxen_mask_aer_correctable(struct netxen_adapter
*adapter
)
1376 struct pci_dev
*pdev
= adapter
->pdev
;
1377 struct pci_dev
*root
= pdev
->bus
->self
;
1384 if (adapter
->ahw
.board_type
!= NETXEN_BRDTYPE_P3_4_GB_MM
&&
1385 adapter
->ahw
.board_type
!= NETXEN_BRDTYPE_P3_10G_TP
)
1388 if (pci_pcie_type(root
) != PCI_EXP_TYPE_ROOT_PORT
)
1391 aer_pos
= pci_find_ext_capability(root
, PCI_EXT_CAP_ID_ERR
);
1395 pci_write_config_dword(root
, aer_pos
+ PCI_ERR_COR_MASK
, 0xffff);
1400 netxen_nic_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
1402 struct net_device
*netdev
= NULL
;
1403 struct netxen_adapter
*adapter
= NULL
;
1405 int pci_func_id
= PCI_FUNC(pdev
->devfn
);
1406 uint8_t revision_id
;
1409 if (pdev
->revision
>= NX_P3_A0
&& pdev
->revision
<= NX_P3_B1
) {
1410 pr_warning("%s: chip revisions between 0x%x-0x%x "
1411 "will not be enabled.\n",
1412 module_name(THIS_MODULE
), NX_P3_A0
, NX_P3_B1
);
1416 if ((err
= pci_enable_device(pdev
)))
1419 if (!(pci_resource_flags(pdev
, 0) & IORESOURCE_MEM
)) {
1421 goto err_out_disable_pdev
;
1424 if ((err
= pci_request_regions(pdev
, netxen_nic_driver_name
)))
1425 goto err_out_disable_pdev
;
1427 if (NX_IS_REVISION_P3(pdev
->revision
))
1428 pci_enable_pcie_error_reporting(pdev
);
1430 pci_set_master(pdev
);
1432 netdev
= alloc_etherdev(sizeof(struct netxen_adapter
));
1435 goto err_out_free_res
;
1438 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
1440 adapter
= netdev_priv(netdev
);
1441 adapter
->netdev
= netdev
;
1442 adapter
->pdev
= pdev
;
1443 adapter
->ahw
.pci_func
= pci_func_id
;
1445 revision_id
= pdev
->revision
;
1446 adapter
->ahw
.revision_id
= revision_id
;
1448 rwlock_init(&adapter
->ahw
.crb_lock
);
1449 spin_lock_init(&adapter
->ahw
.mem_lock
);
1451 spin_lock_init(&adapter
->tx_clean_lock
);
1452 INIT_LIST_HEAD(&adapter
->mac_list
);
1453 INIT_LIST_HEAD(&adapter
->ip_list
);
1455 err
= netxen_setup_pci_map(adapter
);
1457 goto err_out_free_netdev
;
1459 /* This will be reset for mezz cards */
1460 adapter
->portnum
= pci_func_id
;
1462 err
= netxen_nic_get_board_info(adapter
);
1464 dev_err(&pdev
->dev
, "Error getting board config info.\n");
1465 goto err_out_iounmap
;
1468 #ifdef CONFIG_PCIEAER
1469 netxen_mask_aer_correctable(adapter
);
1472 /* Mezz cards have PCI function 0,2,3 enabled */
1473 switch (adapter
->ahw
.board_type
) {
1474 case NETXEN_BRDTYPE_P2_SB31_10G_IMEZ
:
1475 case NETXEN_BRDTYPE_P2_SB31_10G_HMEZ
:
1476 if (pci_func_id
>= 2)
1477 adapter
->portnum
= pci_func_id
- 2;
1483 err
= netxen_check_flash_fw_compatibility(adapter
);
1485 goto err_out_iounmap
;
1487 if (adapter
->portnum
== 0) {
1488 val
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
1489 if (val
!= 0xffffffff && val
!= 0) {
1490 NXWR32(adapter
, NX_CRB_DEV_REF_COUNT
, 0);
1491 adapter
->need_fw_reset
= 1;
1495 err
= netxen_start_firmware(adapter
);
1497 goto err_out_decr_ref
;
1500 * See if the firmware gave us a virtual-physical port mapping.
1502 adapter
->physical_port
= adapter
->portnum
;
1503 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
1504 i
= NXRD32(adapter
, CRB_V2P(adapter
->portnum
));
1505 if (i
!= 0x55555555)
1506 adapter
->physical_port
= i
;
1509 netxen_nic_clear_stats(adapter
);
1511 netxen_setup_intr(adapter
);
1513 err
= netxen_setup_netdev(adapter
, netdev
);
1515 goto err_out_disable_msi
;
1517 pci_set_drvdata(pdev
, adapter
);
1519 netxen_schedule_work(adapter
, netxen_fw_poll_work
, FW_POLL_DELAY
);
1521 switch (adapter
->ahw
.port_type
) {
1522 case NETXEN_NIC_GBE
:
1523 dev_info(&adapter
->pdev
->dev
, "%s: GbE port initialized\n",
1524 adapter
->netdev
->name
);
1526 case NETXEN_NIC_XGBE
:
1527 dev_info(&adapter
->pdev
->dev
, "%s: XGbE port initialized\n",
1528 adapter
->netdev
->name
);
1532 netxen_create_diag_entries(adapter
);
1536 err_out_disable_msi
:
1537 netxen_teardown_intr(adapter
);
1539 netxen_free_dummy_dma(adapter
);
1542 nx_decr_dev_ref_cnt(adapter
);
1545 netxen_cleanup_pci_map(adapter
);
1547 err_out_free_netdev
:
1548 free_netdev(netdev
);
1551 pci_release_regions(pdev
);
1553 err_out_disable_pdev
:
1554 pci_set_drvdata(pdev
, NULL
);
1555 pci_disable_device(pdev
);
1560 void netxen_cleanup_minidump(struct netxen_adapter
*adapter
)
1562 kfree(adapter
->mdump
.md_template
);
1563 adapter
->mdump
.md_template
= NULL
;
1565 if (adapter
->mdump
.md_capture_buff
) {
1566 vfree(adapter
->mdump
.md_capture_buff
);
1567 adapter
->mdump
.md_capture_buff
= NULL
;
1571 static void netxen_nic_remove(struct pci_dev
*pdev
)
1573 struct netxen_adapter
*adapter
;
1574 struct net_device
*netdev
;
1576 adapter
= pci_get_drvdata(pdev
);
1577 if (adapter
== NULL
)
1580 netdev
= adapter
->netdev
;
1582 netxen_cancel_fw_work(adapter
);
1584 unregister_netdev(netdev
);
1586 cancel_work_sync(&adapter
->tx_timeout_task
);
1588 netxen_free_ip_list(adapter
, false);
1589 netxen_nic_detach(adapter
);
1591 nx_decr_dev_ref_cnt(adapter
);
1593 if (adapter
->portnum
== 0)
1594 netxen_free_dummy_dma(adapter
);
1596 clear_bit(__NX_RESETTING
, &adapter
->state
);
1598 netxen_teardown_intr(adapter
);
1600 netxen_remove_diag_entries(adapter
);
1602 netxen_cleanup_pci_map(adapter
);
1604 netxen_release_firmware(adapter
);
1606 if (NX_IS_REVISION_P3(pdev
->revision
)) {
1607 netxen_cleanup_minidump(adapter
);
1608 pci_disable_pcie_error_reporting(pdev
);
1611 pci_release_regions(pdev
);
1612 pci_disable_device(pdev
);
1613 pci_set_drvdata(pdev
, NULL
);
1615 free_netdev(netdev
);
1618 static void netxen_nic_detach_func(struct netxen_adapter
*adapter
)
1620 struct net_device
*netdev
= adapter
->netdev
;
1622 netif_device_detach(netdev
);
1624 netxen_cancel_fw_work(adapter
);
1626 if (netif_running(netdev
))
1627 netxen_nic_down(adapter
, netdev
);
1629 cancel_work_sync(&adapter
->tx_timeout_task
);
1631 netxen_nic_detach(adapter
);
1633 if (adapter
->portnum
== 0)
1634 netxen_free_dummy_dma(adapter
);
1636 nx_decr_dev_ref_cnt(adapter
);
1638 clear_bit(__NX_RESETTING
, &adapter
->state
);
1641 static int netxen_nic_attach_func(struct pci_dev
*pdev
)
1643 struct netxen_adapter
*adapter
= pci_get_drvdata(pdev
);
1644 struct net_device
*netdev
= adapter
->netdev
;
1647 err
= pci_enable_device(pdev
);
1651 pci_set_power_state(pdev
, PCI_D0
);
1652 pci_set_master(pdev
);
1653 pci_restore_state(pdev
);
1655 adapter
->ahw
.crb_win
= -1;
1656 adapter
->ahw
.ocm_win
= -1;
1658 err
= netxen_start_firmware(adapter
);
1660 dev_err(&pdev
->dev
, "failed to start firmware\n");
1664 if (netif_running(netdev
)) {
1665 err
= netxen_nic_attach(adapter
);
1669 err
= netxen_nic_up(adapter
, netdev
);
1671 goto err_out_detach
;
1673 netxen_restore_indev_addr(netdev
, NETDEV_UP
);
1676 netif_device_attach(netdev
);
1677 netxen_schedule_work(adapter
, netxen_fw_poll_work
, FW_POLL_DELAY
);
1681 netxen_nic_detach(adapter
);
1683 nx_decr_dev_ref_cnt(adapter
);
1687 static pci_ers_result_t
netxen_io_error_detected(struct pci_dev
*pdev
,
1688 pci_channel_state_t state
)
1690 struct netxen_adapter
*adapter
= pci_get_drvdata(pdev
);
1692 if (state
== pci_channel_io_perm_failure
)
1693 return PCI_ERS_RESULT_DISCONNECT
;
1695 if (nx_dev_request_aer(adapter
))
1696 return PCI_ERS_RESULT_RECOVERED
;
1698 netxen_nic_detach_func(adapter
);
1700 pci_disable_device(pdev
);
1702 return PCI_ERS_RESULT_NEED_RESET
;
1705 static pci_ers_result_t
netxen_io_slot_reset(struct pci_dev
*pdev
)
1709 err
= netxen_nic_attach_func(pdev
);
1711 return err
? PCI_ERS_RESULT_DISCONNECT
: PCI_ERS_RESULT_RECOVERED
;
1714 static void netxen_io_resume(struct pci_dev
*pdev
)
1716 pci_cleanup_aer_uncorrect_error_status(pdev
);
1719 static void netxen_nic_shutdown(struct pci_dev
*pdev
)
1721 struct netxen_adapter
*adapter
= pci_get_drvdata(pdev
);
1723 netxen_nic_detach_func(adapter
);
1725 if (pci_save_state(pdev
))
1728 if (netxen_nic_wol_supported(adapter
)) {
1729 pci_enable_wake(pdev
, PCI_D3cold
, 1);
1730 pci_enable_wake(pdev
, PCI_D3hot
, 1);
1733 pci_disable_device(pdev
);
1738 netxen_nic_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1740 struct netxen_adapter
*adapter
= pci_get_drvdata(pdev
);
1743 netxen_nic_detach_func(adapter
);
1745 retval
= pci_save_state(pdev
);
1749 if (netxen_nic_wol_supported(adapter
)) {
1750 pci_enable_wake(pdev
, PCI_D3cold
, 1);
1751 pci_enable_wake(pdev
, PCI_D3hot
, 1);
1754 pci_disable_device(pdev
);
1755 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
1761 netxen_nic_resume(struct pci_dev
*pdev
)
1763 return netxen_nic_attach_func(pdev
);
1767 static int netxen_nic_open(struct net_device
*netdev
)
1769 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
1772 if (adapter
->driver_mismatch
)
1775 err
= netxen_nic_attach(adapter
);
1779 err
= __netxen_nic_up(adapter
, netdev
);
1783 netif_start_queue(netdev
);
1788 netxen_nic_detach(adapter
);
1793 * netxen_nic_close - Disables a network interface entry point
1795 static int netxen_nic_close(struct net_device
*netdev
)
1797 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
1799 __netxen_nic_down(adapter
, netdev
);
1804 netxen_tso_check(struct net_device
*netdev
,
1805 struct nx_host_tx_ring
*tx_ring
,
1806 struct cmd_desc_type0
*first_desc
,
1807 struct sk_buff
*skb
)
1809 u8 opcode
= TX_ETHER_PKT
;
1810 __be16 protocol
= skb
->protocol
;
1811 u16 flags
= 0, vid
= 0;
1813 int copied
, offset
, copy_len
, hdr_len
= 0, tso
= 0, vlan_oob
= 0;
1814 struct cmd_desc_type0
*hwdesc
;
1815 struct vlan_ethhdr
*vh
;
1817 if (protocol
== cpu_to_be16(ETH_P_8021Q
)) {
1819 vh
= (struct vlan_ethhdr
*)skb
->data
;
1820 protocol
= vh
->h_vlan_encapsulated_proto
;
1821 flags
= FLAGS_VLAN_TAGGED
;
1823 } else if (vlan_tx_tag_present(skb
)) {
1824 flags
= FLAGS_VLAN_OOB
;
1825 vid
= vlan_tx_tag_get(skb
);
1826 netxen_set_tx_vlan_tci(first_desc
, vid
);
1830 if ((netdev
->features
& (NETIF_F_TSO
| NETIF_F_TSO6
)) &&
1831 skb_shinfo(skb
)->gso_size
> 0) {
1833 hdr_len
= skb_transport_offset(skb
) + tcp_hdrlen(skb
);
1835 first_desc
->mss
= cpu_to_le16(skb_shinfo(skb
)->gso_size
);
1836 first_desc
->total_hdr_length
= hdr_len
;
1838 first_desc
->total_hdr_length
+= VLAN_HLEN
;
1839 first_desc
->tcp_hdr_offset
= VLAN_HLEN
;
1840 first_desc
->ip_hdr_offset
= VLAN_HLEN
;
1841 /* Only in case of TSO on vlan device */
1842 flags
|= FLAGS_VLAN_TAGGED
;
1845 opcode
= (protocol
== cpu_to_be16(ETH_P_IPV6
)) ?
1846 TX_TCP_LSO6
: TX_TCP_LSO
;
1849 } else if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
1852 if (protocol
== cpu_to_be16(ETH_P_IP
)) {
1853 l4proto
= ip_hdr(skb
)->protocol
;
1855 if (l4proto
== IPPROTO_TCP
)
1856 opcode
= TX_TCP_PKT
;
1857 else if(l4proto
== IPPROTO_UDP
)
1858 opcode
= TX_UDP_PKT
;
1859 } else if (protocol
== cpu_to_be16(ETH_P_IPV6
)) {
1860 l4proto
= ipv6_hdr(skb
)->nexthdr
;
1862 if (l4proto
== IPPROTO_TCP
)
1863 opcode
= TX_TCPV6_PKT
;
1864 else if(l4proto
== IPPROTO_UDP
)
1865 opcode
= TX_UDPV6_PKT
;
1869 first_desc
->tcp_hdr_offset
+= skb_transport_offset(skb
);
1870 first_desc
->ip_hdr_offset
+= skb_network_offset(skb
);
1871 netxen_set_tx_flags_opcode(first_desc
, flags
, opcode
);
1876 /* For LSO, we need to copy the MAC/IP/TCP headers into
1877 * the descriptor ring
1879 producer
= tx_ring
->producer
;
1884 /* Create a TSO vlan header template for firmware */
1886 hwdesc
= &tx_ring
->desc_head
[producer
];
1887 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
1889 copy_len
= min((int)sizeof(struct cmd_desc_type0
) - offset
,
1890 hdr_len
+ VLAN_HLEN
);
1892 vh
= (struct vlan_ethhdr
*)((char *)hwdesc
+ 2);
1893 skb_copy_from_linear_data(skb
, vh
, 12);
1894 vh
->h_vlan_proto
= htons(ETH_P_8021Q
);
1895 vh
->h_vlan_TCI
= htons(vid
);
1896 skb_copy_from_linear_data_offset(skb
, 12,
1897 (char *)vh
+ 16, copy_len
- 16);
1899 copied
= copy_len
- VLAN_HLEN
;
1902 producer
= get_next_index(producer
, tx_ring
->num_desc
);
1905 while (copied
< hdr_len
) {
1907 copy_len
= min((int)sizeof(struct cmd_desc_type0
) - offset
,
1908 (hdr_len
- copied
));
1910 hwdesc
= &tx_ring
->desc_head
[producer
];
1911 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
1913 skb_copy_from_linear_data_offset(skb
, copied
,
1914 (char *)hwdesc
+ offset
, copy_len
);
1919 producer
= get_next_index(producer
, tx_ring
->num_desc
);
1922 tx_ring
->producer
= producer
;
1927 netxen_map_tx_skb(struct pci_dev
*pdev
,
1928 struct sk_buff
*skb
, struct netxen_cmd_buffer
*pbuf
)
1930 struct netxen_skb_frag
*nf
;
1931 struct skb_frag_struct
*frag
;
1935 nr_frags
= skb_shinfo(skb
)->nr_frags
;
1936 nf
= &pbuf
->frag_array
[0];
1938 map
= pci_map_single(pdev
, skb
->data
,
1939 skb_headlen(skb
), PCI_DMA_TODEVICE
);
1940 if (pci_dma_mapping_error(pdev
, map
))
1944 nf
->length
= skb_headlen(skb
);
1946 for (i
= 0; i
< nr_frags
; i
++) {
1947 frag
= &skb_shinfo(skb
)->frags
[i
];
1948 nf
= &pbuf
->frag_array
[i
+1];
1950 map
= skb_frag_dma_map(&pdev
->dev
, frag
, 0, skb_frag_size(frag
),
1952 if (dma_mapping_error(&pdev
->dev
, map
))
1956 nf
->length
= skb_frag_size(frag
);
1963 nf
= &pbuf
->frag_array
[i
+1];
1964 pci_unmap_page(pdev
, nf
->dma
, nf
->length
, PCI_DMA_TODEVICE
);
1968 nf
= &pbuf
->frag_array
[0];
1969 pci_unmap_single(pdev
, nf
->dma
, skb_headlen(skb
), PCI_DMA_TODEVICE
);
1977 netxen_clear_cmddesc(u64
*desc
)
1984 netxen_nic_xmit_frame(struct sk_buff
*skb
, struct net_device
*netdev
)
1986 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
1987 struct nx_host_tx_ring
*tx_ring
= adapter
->tx_ring
;
1988 struct netxen_cmd_buffer
*pbuf
;
1989 struct netxen_skb_frag
*buffrag
;
1990 struct cmd_desc_type0
*hwdesc
, *first_desc
;
1991 struct pci_dev
*pdev
;
1994 struct skb_frag_struct
*frag
;
1997 int frag_count
, no_of_desc
;
1998 u32 num_txd
= tx_ring
->num_desc
;
2000 frag_count
= skb_shinfo(skb
)->nr_frags
+ 1;
2002 /* 14 frags supported for normal packet and
2003 * 32 frags supported for TSO packet
2005 if (!skb_is_gso(skb
) && frag_count
> NETXEN_MAX_FRAGS_PER_TX
) {
2007 for (i
= 0; i
< (frag_count
- NETXEN_MAX_FRAGS_PER_TX
); i
++) {
2008 frag
= &skb_shinfo(skb
)->frags
[i
];
2009 delta
+= skb_frag_size(frag
);
2012 if (!__pskb_pull_tail(skb
, delta
))
2015 frag_count
= 1 + skb_shinfo(skb
)->nr_frags
;
2017 /* 4 fragments per cmd des */
2018 no_of_desc
= (frag_count
+ 3) >> 2;
2020 if (unlikely(netxen_tx_avail(tx_ring
) <= TX_STOP_THRESH
)) {
2021 netif_stop_queue(netdev
);
2023 if (netxen_tx_avail(tx_ring
) > TX_STOP_THRESH
)
2024 netif_start_queue(netdev
);
2026 return NETDEV_TX_BUSY
;
2029 producer
= tx_ring
->producer
;
2030 pbuf
= &tx_ring
->cmd_buf_arr
[producer
];
2032 pdev
= adapter
->pdev
;
2034 if (netxen_map_tx_skb(pdev
, skb
, pbuf
))
2038 pbuf
->frag_count
= frag_count
;
2040 first_desc
= hwdesc
= &tx_ring
->desc_head
[producer
];
2041 netxen_clear_cmddesc((u64
*)hwdesc
);
2043 netxen_set_tx_frags_len(first_desc
, frag_count
, skb
->len
);
2044 netxen_set_tx_port(first_desc
, adapter
->portnum
);
2046 for (i
= 0; i
< frag_count
; i
++) {
2050 if ((k
== 0) && (i
> 0)) {
2051 /* move to next desc.*/
2052 producer
= get_next_index(producer
, num_txd
);
2053 hwdesc
= &tx_ring
->desc_head
[producer
];
2054 netxen_clear_cmddesc((u64
*)hwdesc
);
2055 tx_ring
->cmd_buf_arr
[producer
].skb
= NULL
;
2058 buffrag
= &pbuf
->frag_array
[i
];
2060 hwdesc
->buffer_length
[k
] = cpu_to_le16(buffrag
->length
);
2063 hwdesc
->addr_buffer1
= cpu_to_le64(buffrag
->dma
);
2066 hwdesc
->addr_buffer2
= cpu_to_le64(buffrag
->dma
);
2069 hwdesc
->addr_buffer3
= cpu_to_le64(buffrag
->dma
);
2072 hwdesc
->addr_buffer4
= cpu_to_le64(buffrag
->dma
);
2077 tx_ring
->producer
= get_next_index(producer
, num_txd
);
2079 netxen_tso_check(netdev
, tx_ring
, first_desc
, skb
);
2081 adapter
->stats
.txbytes
+= skb
->len
;
2082 adapter
->stats
.xmitcalled
++;
2084 netxen_nic_update_cmd_producer(adapter
, tx_ring
);
2086 return NETDEV_TX_OK
;
2089 adapter
->stats
.txdropped
++;
2090 dev_kfree_skb_any(skb
);
2091 return NETDEV_TX_OK
;
2094 static int netxen_nic_check_temp(struct netxen_adapter
*adapter
)
2096 struct net_device
*netdev
= adapter
->netdev
;
2097 uint32_t temp
, temp_state
, temp_val
;
2100 temp
= NXRD32(adapter
, CRB_TEMP_STATE
);
2102 temp_state
= nx_get_temp_state(temp
);
2103 temp_val
= nx_get_temp_val(temp
);
2105 if (temp_state
== NX_TEMP_PANIC
) {
2107 "%s: Device temperature %d degrees C exceeds"
2108 " maximum allowed. Hardware has been shut down.\n",
2109 netdev
->name
, temp_val
);
2111 } else if (temp_state
== NX_TEMP_WARN
) {
2112 if (adapter
->temp
== NX_TEMP_NORMAL
) {
2114 "%s: Device temperature %d degrees C "
2115 "exceeds operating range."
2116 " Immediate action needed.\n",
2117 netdev
->name
, temp_val
);
2120 if (adapter
->temp
== NX_TEMP_WARN
) {
2122 "%s: Device temperature is now %d degrees C"
2123 " in normal range.\n", netdev
->name
,
2127 adapter
->temp
= temp_state
;
2131 void netxen_advert_link_change(struct netxen_adapter
*adapter
, int linkup
)
2133 struct net_device
*netdev
= adapter
->netdev
;
2135 if (adapter
->ahw
.linkup
&& !linkup
) {
2136 printk(KERN_INFO
"%s: %s NIC Link is down\n",
2137 netxen_nic_driver_name
, netdev
->name
);
2138 adapter
->ahw
.linkup
= 0;
2139 if (netif_running(netdev
)) {
2140 netif_carrier_off(netdev
);
2141 netif_stop_queue(netdev
);
2143 adapter
->link_changed
= !adapter
->has_link_events
;
2144 } else if (!adapter
->ahw
.linkup
&& linkup
) {
2145 printk(KERN_INFO
"%s: %s NIC Link is up\n",
2146 netxen_nic_driver_name
, netdev
->name
);
2147 adapter
->ahw
.linkup
= 1;
2148 if (netif_running(netdev
)) {
2149 netif_carrier_on(netdev
);
2150 netif_wake_queue(netdev
);
2152 adapter
->link_changed
= !adapter
->has_link_events
;
2156 static void netxen_nic_handle_phy_intr(struct netxen_adapter
*adapter
)
2158 u32 val
, port
, linkup
;
2160 port
= adapter
->physical_port
;
2162 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
2163 val
= NXRD32(adapter
, CRB_XG_STATE_P3
);
2164 val
= XG_LINK_STATE_P3(adapter
->ahw
.pci_func
, val
);
2165 linkup
= (val
== XG_LINK_UP_P3
);
2167 val
= NXRD32(adapter
, CRB_XG_STATE
);
2168 val
= (val
>> port
*8) & 0xff;
2169 linkup
= (val
== XG_LINK_UP
);
2172 netxen_advert_link_change(adapter
, linkup
);
2175 static void netxen_tx_timeout(struct net_device
*netdev
)
2177 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
2179 if (test_bit(__NX_RESETTING
, &adapter
->state
))
2182 dev_err(&netdev
->dev
, "transmit timeout, resetting.\n");
2183 schedule_work(&adapter
->tx_timeout_task
);
2186 static void netxen_tx_timeout_task(struct work_struct
*work
)
2188 struct netxen_adapter
*adapter
=
2189 container_of(work
, struct netxen_adapter
, tx_timeout_task
);
2191 if (!netif_running(adapter
->netdev
))
2194 if (test_and_set_bit(__NX_RESETTING
, &adapter
->state
))
2197 if (++adapter
->tx_timeo_cnt
>= NX_MAX_TX_TIMEOUTS
)
2201 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
)) {
2202 /* try to scrub interrupt */
2203 netxen_napi_disable(adapter
);
2205 netxen_napi_enable(adapter
);
2207 netif_wake_queue(adapter
->netdev
);
2209 clear_bit(__NX_RESETTING
, &adapter
->state
);
2211 clear_bit(__NX_RESETTING
, &adapter
->state
);
2212 if (netxen_nic_reset_context(adapter
)) {
2217 adapter
->netdev
->trans_start
= jiffies
;
2222 adapter
->need_fw_reset
= 1;
2223 clear_bit(__NX_RESETTING
, &adapter
->state
);
2226 static struct rtnl_link_stats64
*netxen_nic_get_stats(struct net_device
*netdev
,
2227 struct rtnl_link_stats64
*stats
)
2229 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
2231 stats
->rx_packets
= adapter
->stats
.rx_pkts
+ adapter
->stats
.lro_pkts
;
2232 stats
->tx_packets
= adapter
->stats
.xmitfinished
;
2233 stats
->rx_bytes
= adapter
->stats
.rxbytes
;
2234 stats
->tx_bytes
= adapter
->stats
.txbytes
;
2235 stats
->rx_dropped
= adapter
->stats
.rxdropped
;
2236 stats
->tx_dropped
= adapter
->stats
.txdropped
;
2241 static irqreturn_t
netxen_intr(int irq
, void *data
)
2243 struct nx_host_sds_ring
*sds_ring
= data
;
2244 struct netxen_adapter
*adapter
= sds_ring
->adapter
;
2247 status
= readl(adapter
->isr_int_vec
);
2249 if (!(status
& adapter
->int_vec_bit
))
2252 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
)) {
2253 /* check interrupt state machine, to be sure */
2254 status
= readl(adapter
->crb_int_state_reg
);
2255 if (!ISR_LEGACY_INT_TRIGGERED(status
))
2259 unsigned long our_int
= 0;
2261 our_int
= readl(adapter
->crb_int_state_reg
);
2263 /* not our interrupt */
2264 if (!test_and_clear_bit((7 + adapter
->portnum
), &our_int
))
2267 /* claim interrupt */
2268 writel((our_int
& 0xffffffff), adapter
->crb_int_state_reg
);
2270 /* clear interrupt */
2271 netxen_nic_disable_int(sds_ring
);
2274 writel(0xffffffff, adapter
->tgt_status_reg
);
2275 /* read twice to ensure write is flushed */
2276 readl(adapter
->isr_int_vec
);
2277 readl(adapter
->isr_int_vec
);
2279 napi_schedule(&sds_ring
->napi
);
2284 static irqreturn_t
netxen_msi_intr(int irq
, void *data
)
2286 struct nx_host_sds_ring
*sds_ring
= data
;
2287 struct netxen_adapter
*adapter
= sds_ring
->adapter
;
2289 /* clear interrupt */
2290 writel(0xffffffff, adapter
->tgt_status_reg
);
2292 napi_schedule(&sds_ring
->napi
);
2296 static irqreturn_t
netxen_msix_intr(int irq
, void *data
)
2298 struct nx_host_sds_ring
*sds_ring
= data
;
2300 napi_schedule(&sds_ring
->napi
);
2304 static int netxen_nic_poll(struct napi_struct
*napi
, int budget
)
2306 struct nx_host_sds_ring
*sds_ring
=
2307 container_of(napi
, struct nx_host_sds_ring
, napi
);
2309 struct netxen_adapter
*adapter
= sds_ring
->adapter
;
2314 tx_complete
= netxen_process_cmd_ring(adapter
);
2316 work_done
= netxen_process_rcv_ring(sds_ring
, budget
);
2318 if ((work_done
< budget
) && tx_complete
) {
2319 napi_complete(&sds_ring
->napi
);
2320 if (test_bit(__NX_DEV_UP
, &adapter
->state
))
2321 netxen_nic_enable_int(sds_ring
);
2327 #ifdef CONFIG_NET_POLL_CONTROLLER
2328 static void netxen_nic_poll_controller(struct net_device
*netdev
)
2331 struct nx_host_sds_ring
*sds_ring
;
2332 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
2333 struct netxen_recv_context
*recv_ctx
= &adapter
->recv_ctx
;
2335 disable_irq(adapter
->irq
);
2336 for (ring
= 0; ring
< adapter
->max_sds_rings
; ring
++) {
2337 sds_ring
= &recv_ctx
->sds_rings
[ring
];
2338 netxen_intr(adapter
->irq
, sds_ring
);
2340 enable_irq(adapter
->irq
);
2345 nx_incr_dev_ref_cnt(struct netxen_adapter
*adapter
)
2348 if (netxen_api_lock(adapter
))
2351 count
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
2353 NXWR32(adapter
, NX_CRB_DEV_REF_COUNT
, ++count
);
2355 netxen_api_unlock(adapter
);
2360 nx_decr_dev_ref_cnt(struct netxen_adapter
*adapter
)
2363 if (netxen_api_lock(adapter
))
2366 count
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
2367 WARN_ON(count
== 0);
2369 NXWR32(adapter
, NX_CRB_DEV_REF_COUNT
, --count
);
2370 state
= NXRD32(adapter
, NX_CRB_DEV_STATE
);
2372 if (count
== 0 && state
!= NX_DEV_FAILED
)
2373 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_COLD
);
2375 netxen_api_unlock(adapter
);
2380 nx_dev_request_aer(struct netxen_adapter
*adapter
)
2385 if (netxen_api_lock(adapter
))
2388 state
= NXRD32(adapter
, NX_CRB_DEV_STATE
);
2390 if (state
== NX_DEV_NEED_AER
)
2392 else if (state
== NX_DEV_READY
) {
2393 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_NEED_AER
);
2397 netxen_api_unlock(adapter
);
2402 nx_dev_request_reset(struct netxen_adapter
*adapter
)
2407 if (netxen_api_lock(adapter
))
2410 state
= NXRD32(adapter
, NX_CRB_DEV_STATE
);
2412 if (state
== NX_DEV_NEED_RESET
|| state
== NX_DEV_FAILED
)
2414 else if (state
!= NX_DEV_INITALIZING
&& state
!= NX_DEV_NEED_AER
) {
2415 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_NEED_RESET
);
2416 adapter
->flags
|= NETXEN_FW_RESET_OWNER
;
2420 netxen_api_unlock(adapter
);
2426 netxen_can_start_firmware(struct netxen_adapter
*adapter
)
2431 if (netxen_api_lock(adapter
)) {
2432 nx_incr_dev_ref_cnt(adapter
);
2436 count
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
2438 if ((count
< 0) || (count
>= NX_MAX_PCI_FUNC
))
2443 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_INITALIZING
);
2446 NXWR32(adapter
, NX_CRB_DEV_REF_COUNT
, ++count
);
2448 netxen_api_unlock(adapter
);
2454 netxen_schedule_work(struct netxen_adapter
*adapter
,
2455 work_func_t func
, int delay
)
2457 INIT_DELAYED_WORK(&adapter
->fw_work
, func
);
2458 schedule_delayed_work(&adapter
->fw_work
, delay
);
2462 netxen_cancel_fw_work(struct netxen_adapter
*adapter
)
2464 while (test_and_set_bit(__NX_RESETTING
, &adapter
->state
))
2467 cancel_delayed_work_sync(&adapter
->fw_work
);
2471 netxen_attach_work(struct work_struct
*work
)
2473 struct netxen_adapter
*adapter
= container_of(work
,
2474 struct netxen_adapter
, fw_work
.work
);
2475 struct net_device
*netdev
= adapter
->netdev
;
2478 if (netif_running(netdev
)) {
2479 err
= netxen_nic_attach(adapter
);
2483 err
= netxen_nic_up(adapter
, netdev
);
2485 netxen_nic_detach(adapter
);
2489 netxen_restore_indev_addr(netdev
, NETDEV_UP
);
2492 netif_device_attach(netdev
);
2495 adapter
->fw_fail_cnt
= 0;
2496 clear_bit(__NX_RESETTING
, &adapter
->state
);
2497 netxen_schedule_work(adapter
, netxen_fw_poll_work
, FW_POLL_DELAY
);
2501 netxen_fwinit_work(struct work_struct
*work
)
2503 struct netxen_adapter
*adapter
= container_of(work
,
2504 struct netxen_adapter
, fw_work
.work
);
2507 dev_state
= NXRD32(adapter
, NX_CRB_DEV_STATE
);
2508 if (adapter
->flags
& NETXEN_FW_RESET_OWNER
) {
2509 count
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
2510 WARN_ON(count
== 0);
2512 if (adapter
->mdump
.md_enabled
) {
2514 netxen_dump_fw(adapter
);
2517 adapter
->flags
&= ~NETXEN_FW_RESET_OWNER
;
2518 if (netxen_api_lock(adapter
)) {
2519 clear_bit(__NX_RESETTING
, &adapter
->state
);
2520 NXWR32(adapter
, NX_CRB_DEV_STATE
,
2524 count
= NXRD32(adapter
, NX_CRB_DEV_REF_COUNT
);
2525 NXWR32(adapter
, NX_CRB_DEV_REF_COUNT
, --count
);
2526 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_COLD
);
2527 dev_state
= NX_DEV_COLD
;
2528 netxen_api_unlock(adapter
);
2532 switch (dev_state
) {
2535 if (!netxen_start_firmware(adapter
)) {
2536 netxen_schedule_work(adapter
, netxen_attach_work
, 0);
2541 case NX_DEV_NEED_RESET
:
2542 case NX_DEV_INITALIZING
:
2543 netxen_schedule_work(adapter
,
2544 netxen_fwinit_work
, 2 * FW_POLL_DELAY
);
2549 nx_incr_dev_ref_cnt(adapter
);
2553 if (netxen_api_lock(adapter
)) {
2554 clear_bit(__NX_RESETTING
, &adapter
->state
);
2557 NXWR32(adapter
, NX_CRB_DEV_STATE
, NX_DEV_FAILED
);
2558 netxen_api_unlock(adapter
);
2559 dev_err(&adapter
->pdev
->dev
, "%s: Device initialization Failed\n",
2560 adapter
->netdev
->name
);
2562 clear_bit(__NX_RESETTING
, &adapter
->state
);
2566 netxen_detach_work(struct work_struct
*work
)
2568 struct netxen_adapter
*adapter
= container_of(work
,
2569 struct netxen_adapter
, fw_work
.work
);
2570 struct net_device
*netdev
= adapter
->netdev
;
2571 int ref_cnt
= 0, delay
;
2574 netif_device_detach(netdev
);
2576 netxen_nic_down(adapter
, netdev
);
2579 netxen_nic_detach(adapter
);
2582 status
= NXRD32(adapter
, NETXEN_PEG_HALT_STATUS1
);
2584 if (status
& NX_RCODE_FATAL_ERROR
)
2587 if (adapter
->temp
== NX_TEMP_PANIC
)
2590 if (!(adapter
->flags
& NETXEN_FW_RESET_OWNER
))
2591 ref_cnt
= nx_decr_dev_ref_cnt(adapter
);
2593 if (ref_cnt
== -EIO
)
2596 delay
= (ref_cnt
== 0) ? 0 : (2 * FW_POLL_DELAY
);
2598 adapter
->fw_wait_cnt
= 0;
2599 netxen_schedule_work(adapter
, netxen_fwinit_work
, delay
);
2604 clear_bit(__NX_RESETTING
, &adapter
->state
);
2608 netxen_check_health(struct netxen_adapter
*adapter
)
2610 u32 state
, heartbit
;
2612 struct net_device
*netdev
= adapter
->netdev
;
2614 state
= NXRD32(adapter
, NX_CRB_DEV_STATE
);
2615 if (state
== NX_DEV_NEED_AER
)
2618 if (netxen_nic_check_temp(adapter
))
2621 if (adapter
->need_fw_reset
) {
2622 if (nx_dev_request_reset(adapter
))
2627 /* NX_DEV_NEED_RESET, this state can be marked in two cases
2628 * 1. Tx timeout 2. Fw hang
2629 * Send request to destroy context in case of tx timeout only
2630 * and doesn't required in case of Fw hang
2632 if (state
== NX_DEV_NEED_RESET
|| state
== NX_DEV_FAILED
) {
2633 adapter
->need_fw_reset
= 1;
2634 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
2638 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
2641 heartbit
= NXRD32(adapter
, NETXEN_PEG_ALIVE_COUNTER
);
2642 if (heartbit
!= adapter
->heartbit
) {
2643 adapter
->heartbit
= heartbit
;
2644 adapter
->fw_fail_cnt
= 0;
2645 if (adapter
->need_fw_reset
)
2650 if (++adapter
->fw_fail_cnt
< FW_FAIL_THRESH
)
2653 if (nx_dev_request_reset(adapter
))
2656 clear_bit(__NX_FW_ATTACHED
, &adapter
->state
);
2658 dev_err(&netdev
->dev
, "firmware hang detected\n");
2659 peg_status
= NXRD32(adapter
, NETXEN_PEG_HALT_STATUS1
);
2660 dev_err(&adapter
->pdev
->dev
, "Dumping hw/fw registers\n"
2661 "PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n"
2662 "PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n"
2663 "PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n"
2664 "PEG_NET_4_PC: 0x%x\n",
2666 NXRD32(adapter
, NETXEN_PEG_HALT_STATUS2
),
2667 NXRD32(adapter
, NETXEN_CRB_PEG_NET_0
+ 0x3c),
2668 NXRD32(adapter
, NETXEN_CRB_PEG_NET_1
+ 0x3c),
2669 NXRD32(adapter
, NETXEN_CRB_PEG_NET_2
+ 0x3c),
2670 NXRD32(adapter
, NETXEN_CRB_PEG_NET_3
+ 0x3c),
2671 NXRD32(adapter
, NETXEN_CRB_PEG_NET_4
+ 0x3c));
2672 if (NX_FWERROR_PEGSTAT1(peg_status
) == 0x67)
2673 dev_err(&adapter
->pdev
->dev
,
2674 "Firmware aborted with error code 0x00006700. "
2675 "Device is being reset.\n");
2677 if ((auto_fw_reset
== AUTO_FW_RESET_ENABLED
) &&
2678 !test_and_set_bit(__NX_RESETTING
, &adapter
->state
))
2679 netxen_schedule_work(adapter
, netxen_detach_work
, 0);
2684 netxen_fw_poll_work(struct work_struct
*work
)
2686 struct netxen_adapter
*adapter
= container_of(work
,
2687 struct netxen_adapter
, fw_work
.work
);
2689 if (test_bit(__NX_RESETTING
, &adapter
->state
))
2692 if (test_bit(__NX_DEV_UP
, &adapter
->state
)) {
2693 if (!adapter
->has_link_events
) {
2695 netxen_nic_handle_phy_intr(adapter
);
2697 if (adapter
->link_changed
)
2698 netxen_nic_set_link_parameters(adapter
);
2702 if (netxen_check_health(adapter
))
2706 netxen_schedule_work(adapter
, netxen_fw_poll_work
, FW_POLL_DELAY
);
2710 netxen_store_bridged_mode(struct device
*dev
,
2711 struct device_attribute
*attr
, const char *buf
, size_t len
)
2713 struct net_device
*net
= to_net_dev(dev
);
2714 struct netxen_adapter
*adapter
= netdev_priv(net
);
2718 if (!(adapter
->capabilities
& NX_FW_CAPABILITY_BDG
))
2721 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
)
2724 if (strict_strtoul(buf
, 2, &new))
2727 if (!netxen_config_bridged_mode(adapter
, !!new))
2735 netxen_show_bridged_mode(struct device
*dev
,
2736 struct device_attribute
*attr
, char *buf
)
2738 struct net_device
*net
= to_net_dev(dev
);
2739 struct netxen_adapter
*adapter
;
2740 int bridged_mode
= 0;
2742 adapter
= netdev_priv(net
);
2744 if (adapter
->capabilities
& NX_FW_CAPABILITY_BDG
)
2745 bridged_mode
= !!(adapter
->flags
& NETXEN_NIC_BRIDGE_ENABLED
);
2747 return sprintf(buf
, "%d\n", bridged_mode
);
2750 static struct device_attribute dev_attr_bridged_mode
= {
2751 .attr
= {.name
= "bridged_mode", .mode
= (S_IRUGO
| S_IWUSR
)},
2752 .show
= netxen_show_bridged_mode
,
2753 .store
= netxen_store_bridged_mode
,
2757 netxen_store_diag_mode(struct device
*dev
,
2758 struct device_attribute
*attr
, const char *buf
, size_t len
)
2760 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2763 if (strict_strtoul(buf
, 2, &new))
2766 if (!!new != !!(adapter
->flags
& NETXEN_NIC_DIAG_ENABLED
))
2767 adapter
->flags
^= NETXEN_NIC_DIAG_ENABLED
;
2773 netxen_show_diag_mode(struct device
*dev
,
2774 struct device_attribute
*attr
, char *buf
)
2776 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2778 return sprintf(buf
, "%d\n",
2779 !!(adapter
->flags
& NETXEN_NIC_DIAG_ENABLED
));
2782 static struct device_attribute dev_attr_diag_mode
= {
2783 .attr
= {.name
= "diag_mode", .mode
= (S_IRUGO
| S_IWUSR
)},
2784 .show
= netxen_show_diag_mode
,
2785 .store
= netxen_store_diag_mode
,
2789 netxen_sysfs_validate_crb(struct netxen_adapter
*adapter
,
2790 loff_t offset
, size_t size
)
2792 size_t crb_size
= 4;
2794 if (!(adapter
->flags
& NETXEN_NIC_DIAG_ENABLED
))
2797 if (offset
< NETXEN_PCI_CRBSPACE
) {
2798 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
2801 if (ADDR_IN_RANGE(offset
, NETXEN_PCI_CAMQM
,
2802 NETXEN_PCI_CAMQM_2M_END
))
2808 if ((size
!= crb_size
) || (offset
& (crb_size
-1)))
2815 netxen_sysfs_read_crb(struct file
*filp
, struct kobject
*kobj
,
2816 struct bin_attribute
*attr
,
2817 char *buf
, loff_t offset
, size_t size
)
2819 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
2820 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2825 ret
= netxen_sysfs_validate_crb(adapter
, offset
, size
);
2829 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
) &&
2830 ADDR_IN_RANGE(offset
, NETXEN_PCI_CAMQM
,
2831 NETXEN_PCI_CAMQM_2M_END
)) {
2832 netxen_pci_camqm_read_2M(adapter
, offset
, &qmdata
);
2833 memcpy(buf
, &qmdata
, size
);
2835 data
= NXRD32(adapter
, offset
);
2836 memcpy(buf
, &data
, size
);
2843 netxen_sysfs_write_crb(struct file
*filp
, struct kobject
*kobj
,
2844 struct bin_attribute
*attr
,
2845 char *buf
, loff_t offset
, size_t size
)
2847 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
2848 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2853 ret
= netxen_sysfs_validate_crb(adapter
, offset
, size
);
2857 if (NX_IS_REVISION_P3(adapter
->ahw
.revision_id
) &&
2858 ADDR_IN_RANGE(offset
, NETXEN_PCI_CAMQM
,
2859 NETXEN_PCI_CAMQM_2M_END
)) {
2860 memcpy(&qmdata
, buf
, size
);
2861 netxen_pci_camqm_write_2M(adapter
, offset
, qmdata
);
2863 memcpy(&data
, buf
, size
);
2864 NXWR32(adapter
, offset
, data
);
2871 netxen_sysfs_validate_mem(struct netxen_adapter
*adapter
,
2872 loff_t offset
, size_t size
)
2874 if (!(adapter
->flags
& NETXEN_NIC_DIAG_ENABLED
))
2877 if ((size
!= 8) || (offset
& 0x7))
2884 netxen_sysfs_read_mem(struct file
*filp
, struct kobject
*kobj
,
2885 struct bin_attribute
*attr
,
2886 char *buf
, loff_t offset
, size_t size
)
2888 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
2889 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2893 ret
= netxen_sysfs_validate_mem(adapter
, offset
, size
);
2897 if (adapter
->pci_mem_read(adapter
, offset
, &data
))
2900 memcpy(buf
, &data
, size
);
2905 static ssize_t
netxen_sysfs_write_mem(struct file
*filp
, struct kobject
*kobj
,
2906 struct bin_attribute
*attr
, char *buf
,
2907 loff_t offset
, size_t size
)
2909 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
2910 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2914 ret
= netxen_sysfs_validate_mem(adapter
, offset
, size
);
2918 memcpy(&data
, buf
, size
);
2920 if (adapter
->pci_mem_write(adapter
, offset
, data
))
2927 static struct bin_attribute bin_attr_crb
= {
2928 .attr
= {.name
= "crb", .mode
= (S_IRUGO
| S_IWUSR
)},
2930 .read
= netxen_sysfs_read_crb
,
2931 .write
= netxen_sysfs_write_crb
,
2934 static struct bin_attribute bin_attr_mem
= {
2935 .attr
= {.name
= "mem", .mode
= (S_IRUGO
| S_IWUSR
)},
2937 .read
= netxen_sysfs_read_mem
,
2938 .write
= netxen_sysfs_write_mem
,
2942 netxen_sysfs_read_dimm(struct file
*filp
, struct kobject
*kobj
,
2943 struct bin_attribute
*attr
,
2944 char *buf
, loff_t offset
, size_t size
)
2946 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
2947 struct netxen_adapter
*adapter
= dev_get_drvdata(dev
);
2948 struct net_device
*netdev
= adapter
->netdev
;
2949 struct netxen_dimm_cfg dimm
;
2950 u8 dw
, rows
, cols
, banks
, ranks
;
2953 if (size
!= sizeof(struct netxen_dimm_cfg
)) {
2954 netdev_err(netdev
, "Invalid size\n");
2958 memset(&dimm
, 0, sizeof(struct netxen_dimm_cfg
));
2959 val
= NXRD32(adapter
, NETXEN_DIMM_CAPABILITY
);
2961 /* Checks if DIMM info is valid. */
2962 if (val
& NETXEN_DIMM_VALID_FLAG
) {
2963 netdev_err(netdev
, "Invalid DIMM flag\n");
2964 dimm
.presence
= 0xff;
2968 rows
= NETXEN_DIMM_NUMROWS(val
);
2969 cols
= NETXEN_DIMM_NUMCOLS(val
);
2970 ranks
= NETXEN_DIMM_NUMRANKS(val
);
2971 banks
= NETXEN_DIMM_NUMBANKS(val
);
2972 dw
= NETXEN_DIMM_DATAWIDTH(val
);
2974 dimm
.presence
= (val
& NETXEN_DIMM_PRESENT
);
2976 /* Checks if DIMM info is present. */
2977 if (!dimm
.presence
) {
2978 netdev_err(netdev
, "DIMM not present\n");
2982 dimm
.dimm_type
= NETXEN_DIMM_TYPE(val
);
2984 switch (dimm
.dimm_type
) {
2985 case NETXEN_DIMM_TYPE_RDIMM
:
2986 case NETXEN_DIMM_TYPE_UDIMM
:
2987 case NETXEN_DIMM_TYPE_SO_DIMM
:
2988 case NETXEN_DIMM_TYPE_Micro_DIMM
:
2989 case NETXEN_DIMM_TYPE_Mini_RDIMM
:
2990 case NETXEN_DIMM_TYPE_Mini_UDIMM
:
2993 netdev_err(netdev
, "Invalid DIMM type %x\n", dimm
.dimm_type
);
2997 if (val
& NETXEN_DIMM_MEMTYPE_DDR2_SDRAM
)
2998 dimm
.mem_type
= NETXEN_DIMM_MEM_DDR2_SDRAM
;
3000 dimm
.mem_type
= NETXEN_DIMM_MEMTYPE(val
);
3002 if (val
& NETXEN_DIMM_SIZE
) {
3003 dimm
.size
= NETXEN_DIMM_STD_MEM_SIZE
;
3008 netdev_err(netdev
, "Invalid no of rows %x\n", rows
);
3013 netdev_err(netdev
, "Invalid no of columns %x\n", cols
);
3018 netdev_err(netdev
, "Invalid no of banks %x\n", banks
);
3050 netdev_err(netdev
, "Invalid data-width %x\n", dw
);
3054 dimm
.size
= ((1 << rows
) * (1 << cols
) * dw
* banks
* ranks
) / 8;
3055 /* Size returned in MB. */
3056 dimm
.size
= (dimm
.size
) / 0x100000;
3058 memcpy(buf
, &dimm
, sizeof(struct netxen_dimm_cfg
));
3059 return sizeof(struct netxen_dimm_cfg
);
3063 static struct bin_attribute bin_attr_dimm
= {
3064 .attr
= { .name
= "dimm", .mode
= (S_IRUGO
| S_IWUSR
) },
3066 .read
= netxen_sysfs_read_dimm
,
3071 netxen_create_sysfs_entries(struct netxen_adapter
*adapter
)
3073 struct device
*dev
= &adapter
->pdev
->dev
;
3075 if (adapter
->capabilities
& NX_FW_CAPABILITY_BDG
) {
3076 /* bridged_mode control */
3077 if (device_create_file(dev
, &dev_attr_bridged_mode
)) {
3079 "failed to create bridged_mode sysfs entry\n");
3085 netxen_remove_sysfs_entries(struct netxen_adapter
*adapter
)
3087 struct device
*dev
= &adapter
->pdev
->dev
;
3089 if (adapter
->capabilities
& NX_FW_CAPABILITY_BDG
)
3090 device_remove_file(dev
, &dev_attr_bridged_mode
);
3094 netxen_create_diag_entries(struct netxen_adapter
*adapter
)
3096 struct pci_dev
*pdev
= adapter
->pdev
;
3100 if (device_create_file(dev
, &dev_attr_diag_mode
))
3101 dev_info(dev
, "failed to create diag_mode sysfs entry\n");
3102 if (device_create_bin_file(dev
, &bin_attr_crb
))
3103 dev_info(dev
, "failed to create crb sysfs entry\n");
3104 if (device_create_bin_file(dev
, &bin_attr_mem
))
3105 dev_info(dev
, "failed to create mem sysfs entry\n");
3106 if (device_create_bin_file(dev
, &bin_attr_dimm
))
3107 dev_info(dev
, "failed to create dimm sysfs entry\n");
3112 netxen_remove_diag_entries(struct netxen_adapter
*adapter
)
3114 struct pci_dev
*pdev
= adapter
->pdev
;
3115 struct device
*dev
= &pdev
->dev
;
3117 device_remove_file(dev
, &dev_attr_diag_mode
);
3118 device_remove_bin_file(dev
, &bin_attr_crb
);
3119 device_remove_bin_file(dev
, &bin_attr_mem
);
3120 device_remove_bin_file(dev
, &bin_attr_dimm
);
3125 #define is_netxen_netdev(dev) (dev->netdev_ops == &netxen_netdev_ops)
3128 netxen_destip_supported(struct netxen_adapter
*adapter
)
3130 if (NX_IS_REVISION_P2(adapter
->ahw
.revision_id
))
3133 if (adapter
->ahw
.cut_through
)
3140 netxen_free_ip_list(struct netxen_adapter
*adapter
, bool master
)
3142 struct nx_ip_list
*cur
, *tmp_cur
;
3144 list_for_each_entry_safe(cur
, tmp_cur
, &adapter
->ip_list
, list
) {
3147 netxen_config_ipaddr(adapter
, cur
->ip_addr
,
3149 list_del(&cur
->list
);
3153 netxen_config_ipaddr(adapter
, cur
->ip_addr
, NX_IP_DOWN
);
3154 list_del(&cur
->list
);
3161 netxen_list_config_ip(struct netxen_adapter
*adapter
,
3162 struct in_ifaddr
*ifa
, unsigned long event
)
3164 struct net_device
*dev
;
3165 struct nx_ip_list
*cur
, *tmp_cur
;
3166 struct list_head
*head
;
3169 dev
= ifa
->ifa_dev
? ifa
->ifa_dev
->dev
: NULL
;
3176 list_for_each(head
, &adapter
->ip_list
) {
3177 cur
= list_entry(head
, struct nx_ip_list
, list
);
3179 if (cur
->ip_addr
== ifa
->ifa_address
)
3183 cur
= kzalloc(sizeof(struct nx_ip_list
), GFP_ATOMIC
);
3186 if (dev
->priv_flags
& IFF_802_1Q_VLAN
)
3187 dev
= vlan_dev_real_dev(dev
);
3188 cur
->master
= !!netif_is_bond_master(dev
);
3189 cur
->ip_addr
= ifa
->ifa_address
;
3190 list_add_tail(&cur
->list
, &adapter
->ip_list
);
3191 netxen_config_ipaddr(adapter
, ifa
->ifa_address
, NX_IP_UP
);
3195 list_for_each_entry_safe(cur
, tmp_cur
,
3196 &adapter
->ip_list
, list
) {
3197 if (cur
->ip_addr
== ifa
->ifa_address
) {
3198 list_del(&cur
->list
);
3200 netxen_config_ipaddr(adapter
, ifa
->ifa_address
,
3212 netxen_config_indev_addr(struct netxen_adapter
*adapter
,
3213 struct net_device
*dev
, unsigned long event
)
3215 struct in_device
*indev
;
3217 if (!netxen_destip_supported(adapter
))
3220 indev
= in_dev_get(dev
);
3227 netxen_list_config_ip(adapter
, ifa
, NX_IP_UP
);
3230 netxen_list_config_ip(adapter
, ifa
, NX_IP_DOWN
);
3235 } endfor_ifa(indev
);
3241 netxen_restore_indev_addr(struct net_device
*netdev
, unsigned long event
)
3244 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
3245 struct nx_ip_list
*pos
, *tmp_pos
;
3246 unsigned long ip_event
;
3248 ip_event
= (event
== NETDEV_UP
) ? NX_IP_UP
: NX_IP_DOWN
;
3249 netxen_config_indev_addr(adapter
, netdev
, event
);
3251 list_for_each_entry_safe(pos
, tmp_pos
, &adapter
->ip_list
, list
) {
3252 netxen_config_ipaddr(adapter
, pos
->ip_addr
, ip_event
);
3257 netxen_config_checkdev(struct net_device
*dev
)
3259 struct netxen_adapter
*adapter
;
3261 if (!is_netxen_netdev(dev
))
3263 adapter
= netdev_priv(dev
);
3266 if (!netxen_destip_supported(adapter
))
3268 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
)
3275 * netxen_config_master - configure addresses based on master
3276 * @dev: netxen device
3277 * @event: netdev event
3279 static void netxen_config_master(struct net_device
*dev
, unsigned long event
)
3281 struct net_device
*master
, *slave
;
3282 struct netxen_adapter
*adapter
= netdev_priv(dev
);
3285 master
= netdev_master_upper_dev_get_rcu(dev
);
3287 * This is the case where the netxen nic is being
3288 * enslaved and is dev_open()ed in bond_enslave()
3289 * Now we should program the bond's (and its vlans')
3290 * addresses in the netxen NIC.
3292 if (master
&& netif_is_bond_master(master
) &&
3293 !netif_is_bond_slave(dev
)) {
3294 netxen_config_indev_addr(adapter
, master
, event
);
3295 for_each_netdev_rcu(&init_net
, slave
)
3296 if (slave
->priv_flags
& IFF_802_1Q_VLAN
&&
3297 vlan_dev_real_dev(slave
) == master
)
3298 netxen_config_indev_addr(adapter
, slave
, event
);
3302 * This is the case where the netxen nic is being
3303 * released and is dev_close()ed in bond_release()
3304 * just before IFF_BONDING is stripped.
3306 if (!master
&& dev
->priv_flags
& IFF_BONDING
)
3307 netxen_free_ip_list(adapter
, true);
3310 static int netxen_netdev_event(struct notifier_block
*this,
3311 unsigned long event
, void *ptr
)
3313 struct netxen_adapter
*adapter
;
3314 struct net_device
*dev
= (struct net_device
*)ptr
;
3315 struct net_device
*orig_dev
= dev
;
3316 struct net_device
*slave
;
3322 if (dev
->priv_flags
& IFF_802_1Q_VLAN
) {
3323 dev
= vlan_dev_real_dev(dev
);
3326 if (event
== NETDEV_UP
|| event
== NETDEV_DOWN
) {
3327 /* If this is a bonding device, look for netxen-based slaves*/
3328 if (netif_is_bond_master(dev
)) {
3330 for_each_netdev_in_bond_rcu(dev
, slave
) {
3331 if (!netxen_config_checkdev(slave
))
3333 adapter
= netdev_priv(slave
);
3334 netxen_config_indev_addr(adapter
,
3339 if (!netxen_config_checkdev(dev
))
3341 adapter
= netdev_priv(dev
);
3342 /* Act only if the actual netxen is the target */
3343 if (orig_dev
== dev
)
3344 netxen_config_master(dev
, event
);
3345 netxen_config_indev_addr(adapter
, orig_dev
, event
);
3353 netxen_inetaddr_event(struct notifier_block
*this,
3354 unsigned long event
, void *ptr
)
3356 struct netxen_adapter
*adapter
;
3357 struct net_device
*dev
, *slave
;
3358 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
3359 unsigned long ip_event
;
3361 dev
= ifa
->ifa_dev
? ifa
->ifa_dev
->dev
: NULL
;
3362 ip_event
= (event
== NETDEV_UP
) ? NX_IP_UP
: NX_IP_DOWN
;
3367 if (dev
->priv_flags
& IFF_802_1Q_VLAN
) {
3368 dev
= vlan_dev_real_dev(dev
);
3371 if (event
== NETDEV_UP
|| event
== NETDEV_DOWN
) {
3372 /* If this is a bonding device, look for netxen-based slaves*/
3373 if (netif_is_bond_master(dev
)) {
3375 for_each_netdev_in_bond_rcu(dev
, slave
) {
3376 if (!netxen_config_checkdev(slave
))
3378 adapter
= netdev_priv(slave
);
3379 netxen_list_config_ip(adapter
, ifa
, ip_event
);
3383 if (!netxen_config_checkdev(dev
))
3385 adapter
= netdev_priv(dev
);
3386 netxen_list_config_ip(adapter
, ifa
, ip_event
);
3393 static struct notifier_block netxen_netdev_cb
= {
3394 .notifier_call
= netxen_netdev_event
,
3397 static struct notifier_block netxen_inetaddr_cb
= {
3398 .notifier_call
= netxen_inetaddr_event
,
3402 netxen_restore_indev_addr(struct net_device
*dev
, unsigned long event
)
3405 netxen_free_ip_list(struct netxen_adapter
*adapter
, bool master
)
3409 static const struct pci_error_handlers netxen_err_handler
= {
3410 .error_detected
= netxen_io_error_detected
,
3411 .slot_reset
= netxen_io_slot_reset
,
3412 .resume
= netxen_io_resume
,
3415 static struct pci_driver netxen_driver
= {
3416 .name
= netxen_nic_driver_name
,
3417 .id_table
= netxen_pci_tbl
,
3418 .probe
= netxen_nic_probe
,
3419 .remove
= netxen_nic_remove
,
3421 .suspend
= netxen_nic_suspend
,
3422 .resume
= netxen_nic_resume
,
3424 .shutdown
= netxen_nic_shutdown
,
3425 .err_handler
= &netxen_err_handler
3428 static int __init
netxen_init_module(void)
3430 printk(KERN_INFO
"%s\n", netxen_nic_driver_string
);
3433 register_netdevice_notifier(&netxen_netdev_cb
);
3434 register_inetaddr_notifier(&netxen_inetaddr_cb
);
3436 return pci_register_driver(&netxen_driver
);
3439 module_init(netxen_init_module
);
3441 static void __exit
netxen_exit_module(void)
3443 pci_unregister_driver(&netxen_driver
);
3446 unregister_inetaddr_notifier(&netxen_inetaddr_cb
);
3447 unregister_netdevice_notifier(&netxen_netdev_cb
);
3451 module_exit(netxen_exit_module
);