2 * Copyright (C) 2003 - 2006 NetXen, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 * The full GNU General Public License is included in this distribution
21 * in the file called LICENSE.
23 * Contact Information:
26 * 3965 Freedom Circle, Fourth floor,
27 * Santa Clara, CA 95054
30 * Main source file for NetXen NIC Driver on Linux
34 #include <linux/vmalloc.h>
35 #include <linux/highmem.h>
36 #include "netxen_nic_hw.h"
38 #include "netxen_nic.h"
39 #include "netxen_nic_phan_reg.h"
41 #include <linux/dma-mapping.h>
44 MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
45 MODULE_LICENSE("GPL");
46 MODULE_VERSION(NETXEN_NIC_LINUX_VERSIONID
);
48 char netxen_nic_driver_name
[] = "netxen_nic";
49 static char netxen_nic_driver_string
[] = "NetXen Network Driver version "
50 NETXEN_NIC_LINUX_VERSIONID
;
52 #define NETXEN_NETDEV_WEIGHT 120
53 #define NETXEN_ADAPTER_UP_MAGIC 777
54 #define NETXEN_NIC_PEG_TUNE 0
56 #define DMA_32BIT_MASK 0x00000000ffffffffULL
57 #define DMA_35BIT_MASK 0x00000007ffffffffULL
59 /* Local functions to NetXen NIC driver */
60 static int __devinit
netxen_nic_probe(struct pci_dev
*pdev
,
61 const struct pci_device_id
*ent
);
62 static void __devexit
netxen_nic_remove(struct pci_dev
*pdev
);
63 static int netxen_nic_open(struct net_device
*netdev
);
64 static int netxen_nic_close(struct net_device
*netdev
);
65 static int netxen_nic_xmit_frame(struct sk_buff
*, struct net_device
*);
66 static void netxen_tx_timeout(struct net_device
*netdev
);
67 static void netxen_tx_timeout_task(struct work_struct
*work
);
68 static void netxen_watchdog(unsigned long);
69 static int netxen_handle_int(struct netxen_adapter
*, struct net_device
*);
70 static int netxen_nic_poll(struct napi_struct
*napi
, int budget
);
71 #ifdef CONFIG_NET_POLL_CONTROLLER
72 static void netxen_nic_poll_controller(struct net_device
*netdev
);
74 static irqreturn_t
netxen_intr(int irq
, void *data
);
76 int physical_port
[] = {0, 1, 2, 3};
78 /* PCI Device ID Table */
79 static struct pci_device_id netxen_pci_tbl
[] __devinitdata
= {
80 {PCI_DEVICE(0x4040, 0x0001)},
81 {PCI_DEVICE(0x4040, 0x0002)},
82 {PCI_DEVICE(0x4040, 0x0003)},
83 {PCI_DEVICE(0x4040, 0x0004)},
84 {PCI_DEVICE(0x4040, 0x0005)},
85 {PCI_DEVICE(0x4040, 0x0024)},
86 {PCI_DEVICE(0x4040, 0x0025)},
90 MODULE_DEVICE_TABLE(pci
, netxen_pci_tbl
);
92 struct workqueue_struct
*netxen_workq
;
93 static void netxen_watchdog(unsigned long);
95 static inline void netxen_nic_update_cmd_producer(struct netxen_adapter
*adapter
,
96 uint32_t crb_producer
)
98 switch (adapter
->portnum
) {
100 writel(crb_producer
, NETXEN_CRB_NORMALIZE
101 (adapter
, CRB_CMD_PRODUCER_OFFSET
));
104 writel(crb_producer
, NETXEN_CRB_NORMALIZE
105 (adapter
, CRB_CMD_PRODUCER_OFFSET_1
));
108 writel(crb_producer
, NETXEN_CRB_NORMALIZE
109 (adapter
, CRB_CMD_PRODUCER_OFFSET_2
));
112 writel(crb_producer
, NETXEN_CRB_NORMALIZE
113 (adapter
, CRB_CMD_PRODUCER_OFFSET_3
));
116 printk(KERN_WARNING
"We tried to update "
117 "CRB_CMD_PRODUCER_OFFSET for invalid "
118 "PCI function id %d\n",
124 static inline void netxen_nic_update_cmd_consumer(struct netxen_adapter
*adapter
,
127 switch (adapter
->portnum
) {
129 writel(crb_consumer
, NETXEN_CRB_NORMALIZE
130 (adapter
, CRB_CMD_CONSUMER_OFFSET
));
133 writel(crb_consumer
, NETXEN_CRB_NORMALIZE
134 (adapter
, CRB_CMD_CONSUMER_OFFSET_1
));
137 writel(crb_consumer
, NETXEN_CRB_NORMALIZE
138 (adapter
, CRB_CMD_CONSUMER_OFFSET_2
));
141 writel(crb_consumer
, NETXEN_CRB_NORMALIZE
142 (adapter
, CRB_CMD_CONSUMER_OFFSET_3
));
145 printk(KERN_WARNING
"We tried to update "
146 "CRB_CMD_PRODUCER_OFFSET for invalid "
147 "PCI function id %d\n",
153 #define ADAPTER_LIST_SIZE 12
154 int netxen_cards_found
;
156 static void netxen_nic_disable_int(struct netxen_adapter
*adapter
)
158 uint32_t mask
= 0x7ff;
161 DPRINTK(1, INFO
, "Entered ISR Disable \n");
163 switch (adapter
->portnum
) {
165 writel(0x0, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_0
));
168 writel(0x0, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_1
));
171 writel(0x0, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_2
));
174 writel(0x0, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_3
));
178 if (adapter
->intr_scheme
!= -1 &&
179 adapter
->intr_scheme
!= INTR_SCHEME_PERPORT
)
180 writel(mask
,PCI_OFFSET_SECOND_RANGE(adapter
, ISR_INT_MASK
));
182 /* Window = 0 or 1 */
183 if (!(adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)) {
186 PCI_OFFSET_SECOND_RANGE(adapter
, ISR_INT_TARGET_STATUS
));
187 mask
= readl(pci_base_offset(adapter
, ISR_INT_VECTOR
));
194 printk(KERN_NOTICE
"%s: Failed to disable interrupt completely\n",
195 netxen_nic_driver_name
);
199 DPRINTK(1, INFO
, "Done with Disable Int\n");
202 static void netxen_nic_enable_int(struct netxen_adapter
*adapter
)
206 DPRINTK(1, INFO
, "Entered ISR Enable \n");
208 if (adapter
->intr_scheme
!= -1 &&
209 adapter
->intr_scheme
!= INTR_SCHEME_PERPORT
) {
210 switch (adapter
->ahw
.board_type
) {
214 case NETXEN_NIC_XGBE
:
222 writel(mask
, PCI_OFFSET_SECOND_RANGE(adapter
, ISR_INT_MASK
));
225 switch (adapter
->portnum
) {
227 writel(0x1, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_0
));
230 writel(0x1, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_1
));
233 writel(0x1, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_2
));
236 writel(0x1, NETXEN_CRB_NORMALIZE(adapter
, CRB_SW_INT_MASK_3
));
240 if (!(adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)) {
242 if (adapter
->intr_scheme
!= -1 &&
243 adapter
->intr_scheme
!= INTR_SCHEME_PERPORT
) {
244 writel(0X0, NETXEN_CRB_NORMALIZE(adapter
, CRB_INT_VECTOR
));
247 PCI_OFFSET_SECOND_RANGE(adapter
, ISR_INT_TARGET_MASK
));
250 DPRINTK(1, INFO
, "Done with enable Int\n");
256 * The Linux system will invoke this after identifying the vendor ID and
257 * device Id in the pci_tbl supported by this module.
259 * A quad port card has one operational PCI config space, (function 0),
260 * which is used to access all four ports.
262 * This routine will initialize the adapter, and setup the global parameters
263 * along with the port's specific structure.
266 netxen_nic_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
268 struct net_device
*netdev
= NULL
;
269 struct netxen_adapter
*adapter
= NULL
;
270 void __iomem
*mem_ptr0
= NULL
;
271 void __iomem
*mem_ptr1
= NULL
;
272 void __iomem
*mem_ptr2
= NULL
;
273 unsigned long first_page_group_end
;
274 unsigned long first_page_group_start
;
277 u8 __iomem
*db_ptr
= NULL
;
278 unsigned long mem_base
, mem_len
, db_base
, db_len
;
279 int pci_using_dac
, i
= 0, err
;
281 struct netxen_recv_context
*recv_ctx
= NULL
;
282 struct netxen_rcv_desc_ctx
*rcv_desc
= NULL
;
283 struct netxen_cmd_buffer
*cmd_buf_arr
= NULL
;
284 u64 mac_addr
[FLASH_NUM_PORTS
+ 1];
287 int pci_func_id
= PCI_FUNC(pdev
->devfn
);
289 printk(KERN_INFO
"%s \n", netxen_nic_driver_string
);
291 if (pdev
->class != 0x020000) {
292 printk(KERN_ERR
"NetXen function %d, class %x will not"
293 "be enabled.\n",pci_func_id
, pdev
->class);
296 if ((err
= pci_enable_device(pdev
)))
298 if (!(pci_resource_flags(pdev
, 0) & IORESOURCE_MEM
)) {
300 goto err_out_disable_pdev
;
303 if ((err
= pci_request_regions(pdev
, netxen_nic_driver_name
)))
304 goto err_out_disable_pdev
;
306 pci_set_master(pdev
);
307 if (pdev
->revision
== NX_P2_C1
&&
308 (pci_set_dma_mask(pdev
, DMA_35BIT_MASK
) == 0) &&
309 (pci_set_consistent_dma_mask(pdev
, DMA_35BIT_MASK
) == 0)) {
312 if ((err
= pci_set_dma_mask(pdev
, DMA_32BIT_MASK
)) ||
313 (err
= pci_set_consistent_dma_mask(pdev
, DMA_32BIT_MASK
)))
314 goto err_out_free_res
;
320 netdev
= alloc_etherdev(sizeof(struct netxen_adapter
));
322 printk(KERN_ERR
"%s: Failed to allocate memory for the "
323 "device block.Check system memory resource"
324 " usage.\n", netxen_nic_driver_name
);
325 goto err_out_free_res
;
328 SET_MODULE_OWNER(netdev
);
329 SET_NETDEV_DEV(netdev
, &pdev
->dev
);
331 adapter
= netdev
->priv
;
333 adapter
->ahw
.pdev
= pdev
;
334 adapter
->ahw
.pci_func
= pci_func_id
;
335 spin_lock_init(&adapter
->tx_lock
);
337 /* remap phys address */
338 mem_base
= pci_resource_start(pdev
, 0); /* 0 is for BAR 0 */
339 mem_len
= pci_resource_len(pdev
, 0);
341 /* 128 Meg of memory */
342 if (mem_len
== NETXEN_PCI_128MB_SIZE
) {
343 mem_ptr0
= ioremap(mem_base
, FIRST_PAGE_GROUP_SIZE
);
344 mem_ptr1
= ioremap(mem_base
+ SECOND_PAGE_GROUP_START
,
345 SECOND_PAGE_GROUP_SIZE
);
346 mem_ptr2
= ioremap(mem_base
+ THIRD_PAGE_GROUP_START
,
347 THIRD_PAGE_GROUP_SIZE
);
348 first_page_group_start
= FIRST_PAGE_GROUP_START
;
349 first_page_group_end
= FIRST_PAGE_GROUP_END
;
350 } else if (mem_len
== NETXEN_PCI_32MB_SIZE
) {
351 mem_ptr1
= ioremap(mem_base
, SECOND_PAGE_GROUP_SIZE
);
352 mem_ptr2
= ioremap(mem_base
+ THIRD_PAGE_GROUP_START
-
353 SECOND_PAGE_GROUP_START
, THIRD_PAGE_GROUP_SIZE
);
354 first_page_group_start
= 0;
355 first_page_group_end
= 0;
358 goto err_out_free_netdev
;
361 if (((mem_ptr0
== 0UL) && (mem_len
== NETXEN_PCI_128MB_SIZE
)) ||
362 (mem_ptr1
== 0UL) || (mem_ptr2
== 0UL)) {
364 "Cannot remap adapter memory aborting.:"
365 "0 -> %p, 1 -> %p, 2 -> %p\n",
366 mem_ptr0
, mem_ptr1
, mem_ptr2
);
369 goto err_out_iounmap
;
371 db_base
= pci_resource_start(pdev
, 4); /* doorbell is on bar 4 */
372 db_len
= pci_resource_len(pdev
, 4);
375 printk(KERN_ERR
"%s: doorbell is disabled\n",
376 netxen_nic_driver_name
);
378 goto err_out_iounmap
;
380 DPRINTK(INFO
, "doorbell ioremap from %lx a size of %lx\n", db_base
,
383 db_ptr
= ioremap(db_base
, NETXEN_DB_MAPSIZE_BYTES
);
385 printk(KERN_ERR
"%s: Failed to allocate doorbell map.",
386 netxen_nic_driver_name
);
388 goto err_out_iounmap
;
390 DPRINTK(INFO
, "doorbell ioremaped at %p\n", db_ptr
);
392 adapter
->ahw
.pci_base0
= mem_ptr0
;
393 adapter
->ahw
.first_page_group_start
= first_page_group_start
;
394 adapter
->ahw
.first_page_group_end
= first_page_group_end
;
395 adapter
->ahw
.pci_base1
= mem_ptr1
;
396 adapter
->ahw
.pci_base2
= mem_ptr2
;
397 adapter
->ahw
.db_base
= db_ptr
;
398 adapter
->ahw
.db_len
= db_len
;
400 adapter
->netdev
= netdev
;
401 adapter
->pdev
= pdev
;
403 netif_napi_add(netdev
, &adapter
->napi
,
404 netxen_nic_poll
, NETXEN_NETDEV_WEIGHT
);
406 /* this will be read from FW later */
407 adapter
->intr_scheme
= -1;
409 /* This will be reset for mezz cards */
410 adapter
->portnum
= pci_func_id
;
411 adapter
->status
&= ~NETXEN_NETDEV_STATUS
;
413 netdev
->open
= netxen_nic_open
;
414 netdev
->stop
= netxen_nic_close
;
415 netdev
->hard_start_xmit
= netxen_nic_xmit_frame
;
416 netdev
->get_stats
= netxen_nic_get_stats
;
417 netdev
->set_multicast_list
= netxen_nic_set_multi
;
418 netdev
->set_mac_address
= netxen_nic_set_mac
;
419 netdev
->change_mtu
= netxen_nic_change_mtu
;
420 netdev
->tx_timeout
= netxen_tx_timeout
;
421 netdev
->watchdog_timeo
= HZ
;
423 netxen_nic_change_mtu(netdev
, netdev
->mtu
);
425 SET_ETHTOOL_OPS(netdev
, &netxen_nic_ethtool_ops
);
426 #ifdef CONFIG_NET_POLL_CONTROLLER
427 netdev
->poll_controller
= netxen_nic_poll_controller
;
429 /* ScatterGather support */
430 netdev
->features
= NETIF_F_SG
;
431 netdev
->features
|= NETIF_F_IP_CSUM
;
432 netdev
->features
|= NETIF_F_TSO
;
435 netdev
->features
|= NETIF_F_HIGHDMA
;
437 if (pci_enable_msi(pdev
))
438 adapter
->flags
&= ~NETXEN_NIC_MSI_ENABLED
;
440 adapter
->flags
|= NETXEN_NIC_MSI_ENABLED
;
442 netdev
->irq
= pdev
->irq
;
443 INIT_WORK(&adapter
->tx_timeout_task
, netxen_tx_timeout_task
);
446 * Set the CRB window to invalid. If any register in window 0 is
447 * accessed it should set the window to 0 and then reset it to 1.
449 adapter
->curr_window
= 255;
451 /* initialize the adapter */
452 netxen_initialize_adapter_hw(adapter
);
455 * Adapter in our case is quad port so initialize it before
456 * initializing the ports
459 netxen_initialize_adapter_ops(adapter
);
461 adapter
->max_tx_desc_count
= MAX_CMD_DESCRIPTORS_HOST
;
462 if ((adapter
->ahw
.boardcfg
.board_type
== NETXEN_BRDTYPE_P2_SB35_4G
) ||
463 (adapter
->ahw
.boardcfg
.board_type
==
464 NETXEN_BRDTYPE_P2_SB31_2G
))
465 adapter
->max_rx_desc_count
= MAX_RCV_DESCRIPTORS_1G
;
467 adapter
->max_rx_desc_count
= MAX_RCV_DESCRIPTORS
;
468 adapter
->max_jumbo_rx_desc_count
= MAX_JUMBO_RCV_DESCRIPTORS
;
469 adapter
->max_lro_rx_desc_count
= MAX_LRO_RCV_DESCRIPTORS
;
471 cmd_buf_arr
= (struct netxen_cmd_buffer
*)vmalloc(TX_RINGSIZE
);
472 if (cmd_buf_arr
== NULL
) {
474 "%s: Could not allocate cmd_buf_arr memory:%d\n",
475 netxen_nic_driver_name
, (int)TX_RINGSIZE
);
477 goto err_out_free_adapter
;
479 memset(cmd_buf_arr
, 0, TX_RINGSIZE
);
480 adapter
->cmd_buf_arr
= cmd_buf_arr
;
482 for (i
= 0; i
< MAX_RCV_CTX
; ++i
) {
483 recv_ctx
= &adapter
->recv_ctx
[i
];
484 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
485 rcv_desc
= &recv_ctx
->rcv_desc
[ring
];
486 switch (RCV_DESC_TYPE(ring
)) {
487 case RCV_DESC_NORMAL
:
488 rcv_desc
->max_rx_desc_count
=
489 adapter
->max_rx_desc_count
;
490 rcv_desc
->flags
= RCV_DESC_NORMAL
;
491 rcv_desc
->dma_size
= RX_DMA_MAP_LEN
;
492 rcv_desc
->skb_size
= MAX_RX_BUFFER_LENGTH
;
496 rcv_desc
->max_rx_desc_count
=
497 adapter
->max_jumbo_rx_desc_count
;
498 rcv_desc
->flags
= RCV_DESC_JUMBO
;
499 rcv_desc
->dma_size
= RX_JUMBO_DMA_MAP_LEN
;
500 rcv_desc
->skb_size
= MAX_RX_JUMBO_BUFFER_LENGTH
;
504 rcv_desc
->max_rx_desc_count
=
505 adapter
->max_lro_rx_desc_count
;
506 rcv_desc
->flags
= RCV_DESC_LRO
;
507 rcv_desc
->dma_size
= RX_LRO_DMA_MAP_LEN
;
508 rcv_desc
->skb_size
= MAX_RX_LRO_BUFFER_LENGTH
;
512 rcv_desc
->rx_buf_arr
= (struct netxen_rx_buffer
*)
513 vmalloc(RCV_BUFFSIZE
);
515 if (rcv_desc
->rx_buf_arr
== NULL
) {
516 printk(KERN_ERR
"%s: Could not allocate"
517 "rcv_desc->rx_buf_arr memory:%d\n",
518 netxen_nic_driver_name
,
521 goto err_out_free_rx_buffer
;
523 memset(rcv_desc
->rx_buf_arr
, 0, RCV_BUFFSIZE
);
528 netxen_initialize_adapter_sw(adapter
); /* initialize the buffers in adapter */
530 /* Mezz cards have PCI function 0,2,3 enabled */
531 if ((adapter
->ahw
.boardcfg
.board_type
== NETXEN_BRDTYPE_P2_SB31_10G_IMEZ
)
532 && (pci_func_id
>= 2))
533 adapter
->portnum
= pci_func_id
- 2;
536 if(adapter
->portnum
== 0) {
537 netxen_pinit_from_rom(adapter
, 0);
539 netxen_load_firmware(adapter
);
543 init_timer(&adapter
->watchdog_timer
);
544 adapter
->ahw
.xg_linkup
= 0;
545 adapter
->watchdog_timer
.function
= &netxen_watchdog
;
546 adapter
->watchdog_timer
.data
= (unsigned long)adapter
;
547 INIT_WORK(&adapter
->watchdog_task
, netxen_watchdog_task
);
548 adapter
->ahw
.pdev
= pdev
;
549 adapter
->proc_cmd_buf_counter
= 0;
550 adapter
->ahw
.revision_id
= pdev
->revision
;
552 /* make sure Window == 1 */
553 netxen_nic_pci_change_crbwindow(adapter
, 1);
555 netxen_nic_update_cmd_producer(adapter
, 0);
556 netxen_nic_update_cmd_consumer(adapter
, 0);
557 writel(0, NETXEN_CRB_NORMALIZE(adapter
, CRB_HOST_CMD_ADDR_LO
));
559 if (netxen_is_flash_supported(adapter
) == 0 &&
560 netxen_get_flash_mac_addr(adapter
, mac_addr
) == 0)
566 unsigned char *p
= (unsigned char *)&mac_addr
[adapter
->portnum
];
567 netdev
->dev_addr
[0] = *(p
+ 5);
568 netdev
->dev_addr
[1] = *(p
+ 4);
569 netdev
->dev_addr
[2] = *(p
+ 3);
570 netdev
->dev_addr
[3] = *(p
+ 2);
571 netdev
->dev_addr
[4] = *(p
+ 1);
572 netdev
->dev_addr
[5] = *(p
+ 0);
574 memcpy(netdev
->perm_addr
, netdev
->dev_addr
,
576 if (!is_valid_ether_addr(netdev
->perm_addr
)) {
577 printk(KERN_ERR
"%s: Bad MAC address "
578 "%02x:%02x:%02x:%02x:%02x:%02x.\n",
579 netxen_nic_driver_name
,
585 netdev
->dev_addr
[5]);
587 if (adapter
->macaddr_set
)
588 adapter
->macaddr_set(adapter
,
593 if (adapter
->portnum
== 0) {
594 err
= netxen_initialize_adapter_offload(adapter
);
596 goto err_out_free_rx_buffer
;
597 val
= readl(NETXEN_CRB_NORMALIZE(adapter
,
598 NETXEN_CAM_RAM(0x1fc)));
599 if (val
== 0x55555555) {
600 /* This is the first boot after power up */
601 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(0x4), &val
);
604 netxen_nic_write_w0(adapter
, NETXEN_PCIE_REG(0x4), val
);
605 netxen_nic_read_w0(adapter
, NETXEN_PCIE_REG(0x4), &val
);
607 printk(KERN_ERR
"%s: failed to set MSI bit in PCI-e reg\n",
608 netxen_nic_driver_name
);
610 val
= readl(NETXEN_CRB_NORMALIZE(adapter
,
611 NETXEN_ROMUSB_GLB_SW_RESET
));
612 printk(KERN_INFO
"NetXen: read 0x%08x for reset reg.\n",val
);
613 if (val
!= 0x80000f) {
614 /* clear the register for future unloads/loads */
615 writel(0, NETXEN_CRB_NORMALIZE(adapter
,
616 NETXEN_CAM_RAM(0x1fc)));
617 printk(KERN_ERR
"ERROR in NetXen HW init sequence.\n");
619 goto err_out_free_dev
;
623 /* clear the register for future unloads/loads */
624 writel(0, NETXEN_CRB_NORMALIZE(adapter
, NETXEN_CAM_RAM(0x1fc)));
625 printk(KERN_INFO
"State: 0x%0x\n",
626 readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
)));
629 * Tell the hardware our version number.
631 i
= (_NETXEN_NIC_LINUX_MAJOR
<< 16)
632 | ((_NETXEN_NIC_LINUX_MINOR
<< 8))
633 | (_NETXEN_NIC_LINUX_SUBVERSION
);
634 writel(i
, NETXEN_CRB_NORMALIZE(adapter
, CRB_DRIVER_VERSION
));
636 /* Unlock the HW, prompting the boot sequence */
638 NETXEN_CRB_NORMALIZE(adapter
,
639 NETXEN_ROMUSB_GLB_PEGTUNE_DONE
));
640 /* Handshake with the card before we register the devices. */
641 netxen_phantom_init(adapter
, NETXEN_NIC_PEG_TUNE
);
645 * See if the firmware gave us a virtual-physical port mapping.
647 i
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_V2P(adapter
->portnum
)));
649 physical_port
[adapter
->portnum
] = i
;
651 netif_carrier_off(netdev
);
652 netif_stop_queue(netdev
);
654 if ((err
= register_netdev(netdev
))) {
655 printk(KERN_ERR
"%s: register_netdev failed port #%d"
656 " aborting\n", netxen_nic_driver_name
,
659 goto err_out_free_dev
;
662 pci_set_drvdata(pdev
, adapter
);
664 switch (adapter
->ahw
.board_type
) {
666 printk(KERN_INFO
"%s: QUAD GbE board initialized\n",
667 netxen_nic_driver_name
);
670 case NETXEN_NIC_XGBE
:
671 printk(KERN_INFO
"%s: XGbE board initialized\n",
672 netxen_nic_driver_name
);
676 adapter
->driver_mismatch
= 0;
681 if (adapter
->portnum
== 0)
682 netxen_free_adapter_offload(adapter
);
684 err_out_free_rx_buffer
:
685 for (i
= 0; i
< MAX_RCV_CTX
; ++i
) {
686 recv_ctx
= &adapter
->recv_ctx
[i
];
687 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
688 rcv_desc
= &recv_ctx
->rcv_desc
[ring
];
689 if (rcv_desc
->rx_buf_arr
!= NULL
) {
690 vfree(rcv_desc
->rx_buf_arr
);
691 rcv_desc
->rx_buf_arr
= NULL
;
697 err_out_free_adapter
:
698 if (adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)
699 pci_disable_msi(pdev
);
701 pci_set_drvdata(pdev
, NULL
);
718 pci_release_regions(pdev
);
720 err_out_disable_pdev
:
721 pci_disable_device(pdev
);
725 static void __devexit
netxen_nic_remove(struct pci_dev
*pdev
)
727 struct netxen_adapter
*adapter
;
728 struct net_device
*netdev
;
729 struct netxen_rx_buffer
*buffer
;
730 struct netxen_recv_context
*recv_ctx
;
731 struct netxen_rcv_desc_ctx
*rcv_desc
;
733 static int init_firmware_done
= 0;
735 adapter
= pci_get_drvdata(pdev
);
739 netdev
= adapter
->netdev
;
741 unregister_netdev(netdev
);
743 if (adapter
->stop_port
)
744 adapter
->stop_port(adapter
);
746 netxen_nic_disable_int(adapter
);
748 if (adapter
->is_up
== NETXEN_ADAPTER_UP_MAGIC
) {
749 init_firmware_done
++;
750 netxen_free_hw_resources(adapter
);
753 for (ctxid
= 0; ctxid
< MAX_RCV_CTX
; ++ctxid
) {
754 recv_ctx
= &adapter
->recv_ctx
[ctxid
];
755 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++) {
756 rcv_desc
= &recv_ctx
->rcv_desc
[ring
];
757 for (i
= 0; i
< rcv_desc
->max_rx_desc_count
; ++i
) {
758 buffer
= &(rcv_desc
->rx_buf_arr
[i
]);
759 if (buffer
->state
== NETXEN_BUFFER_FREE
)
761 pci_unmap_single(pdev
, buffer
->dma
,
764 if (buffer
->skb
!= NULL
)
765 dev_kfree_skb_any(buffer
->skb
);
767 vfree(rcv_desc
->rx_buf_arr
);
771 vfree(adapter
->cmd_buf_arr
);
773 if (adapter
->portnum
== 0) {
774 if (init_firmware_done
) {
777 if (dma_watchdog_shutdown_request(adapter
) == 1)
780 if (dma_watchdog_shutdown_poll_result(adapter
) == 1)
785 printk(KERN_ERR
"%s: dma_watchdog_shutdown failed\n",
788 /* clear the register for future unloads/loads */
789 writel(0, NETXEN_CRB_NORMALIZE(adapter
, NETXEN_CAM_RAM(0x1fc)));
790 printk(KERN_INFO
"State: 0x%0x\n",
791 readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
)));
793 /* leave the hw in the same state as reboot */
794 writel(0, NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
));
795 netxen_pinit_from_rom(adapter
, 0);
797 netxen_load_firmware(adapter
);
798 netxen_phantom_init(adapter
, NETXEN_NIC_PEG_TUNE
);
801 /* clear the register for future unloads/loads */
802 writel(0, NETXEN_CRB_NORMALIZE(adapter
, NETXEN_CAM_RAM(0x1fc)));
803 printk(KERN_INFO
"State: 0x%0x\n",
804 readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_CMDPEG_STATE
)));
808 if (dma_watchdog_shutdown_request(adapter
) == 1)
811 if (dma_watchdog_shutdown_poll_result(adapter
) == 1)
816 netxen_free_adapter_offload(adapter
);
818 printk(KERN_ERR
"%s: dma_watchdog_shutdown failed\n",
824 free_irq(adapter
->irq
, adapter
);
826 if (adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)
827 pci_disable_msi(pdev
);
829 iounmap(adapter
->ahw
.db_base
);
830 iounmap(adapter
->ahw
.pci_base0
);
831 iounmap(adapter
->ahw
.pci_base1
);
832 iounmap(adapter
->ahw
.pci_base2
);
834 pci_release_regions(pdev
);
835 pci_disable_device(pdev
);
836 pci_set_drvdata(pdev
, NULL
);
842 * Called when a network interface is made active
843 * @returns 0 on success, negative value on failure
845 static int netxen_nic_open(struct net_device
*netdev
)
847 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)netdev
->priv
;
851 if (adapter
->is_up
!= NETXEN_ADAPTER_UP_MAGIC
) {
852 err
= netxen_init_firmware(adapter
);
854 printk(KERN_ERR
"Failed to init firmware\n");
857 netxen_nic_flash_print(adapter
);
859 /* setup all the resources for the Phantom... */
860 /* this include the descriptors for rcv, tx, and status */
861 netxen_nic_clear_stats(adapter
);
862 err
= netxen_nic_hw_resources(adapter
);
864 printk(KERN_ERR
"Error in setting hw resources:%d\n",
868 for (ctx
= 0; ctx
< MAX_RCV_CTX
; ++ctx
) {
869 for (ring
= 0; ring
< NUM_RCV_DESC_RINGS
; ring
++)
870 netxen_post_rx_buffers(adapter
, ctx
, ring
);
872 adapter
->irq
= adapter
->ahw
.pdev
->irq
;
873 err
= request_irq(adapter
->ahw
.pdev
->irq
, netxen_intr
,
874 IRQF_SHARED
|IRQF_SAMPLE_RANDOM
, netdev
->name
,
877 printk(KERN_ERR
"request_irq failed with: %d\n", err
);
878 netxen_free_hw_resources(adapter
);
882 adapter
->is_up
= NETXEN_ADAPTER_UP_MAGIC
;
884 if (!adapter
->driver_mismatch
)
885 mod_timer(&adapter
->watchdog_timer
, jiffies
);
887 napi_enable(&adapter
->napi
);
889 netxen_nic_enable_int(adapter
);
891 /* Done here again so that even if phantom sw overwrote it,
893 if (adapter
->init_port
894 && adapter
->init_port(adapter
, adapter
->portnum
) != 0) {
895 del_timer_sync(&adapter
->watchdog_timer
);
896 printk(KERN_ERR
"%s: Failed to initialize port %d\n",
897 netxen_nic_driver_name
, adapter
->portnum
);
898 napi_disable(&adapter
->napi
);
901 if (adapter
->macaddr_set
)
902 adapter
->macaddr_set(adapter
, netdev
->dev_addr
);
904 netxen_nic_set_link_parameters(adapter
);
906 netxen_nic_set_multi(netdev
);
907 if (adapter
->set_mtu
)
908 adapter
->set_mtu(adapter
, netdev
->mtu
);
910 if (!adapter
->driver_mismatch
)
911 netif_start_queue(netdev
);
917 * netxen_nic_close - Disables a network interface entry point
919 static int netxen_nic_close(struct net_device
*netdev
)
921 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
923 struct netxen_cmd_buffer
*cmd_buff
;
924 struct netxen_skb_frag
*buffrag
;
926 netif_carrier_off(netdev
);
927 netif_stop_queue(netdev
);
928 napi_disable(&adapter
->napi
);
930 netxen_nic_disable_int(adapter
);
932 cmd_buff
= adapter
->cmd_buf_arr
;
933 for (i
= 0; i
< adapter
->max_tx_desc_count
; i
++) {
934 buffrag
= cmd_buff
->frag_array
;
936 pci_unmap_single(adapter
->pdev
, buffrag
->dma
,
937 buffrag
->length
, PCI_DMA_TODEVICE
);
940 for (j
= 0; j
< cmd_buff
->frag_count
; j
++) {
943 pci_unmap_page(adapter
->pdev
, buffrag
->dma
,
949 /* Free the skb we received in netxen_nic_xmit_frame */
951 dev_kfree_skb_any(cmd_buff
->skb
);
952 cmd_buff
->skb
= NULL
;
956 if (adapter
->is_up
== NETXEN_ADAPTER_UP_MAGIC
) {
957 FLUSH_SCHEDULED_WORK();
958 del_timer_sync(&adapter
->watchdog_timer
);
964 static int netxen_nic_xmit_frame(struct sk_buff
*skb
, struct net_device
*netdev
)
966 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
967 struct netxen_hardware_context
*hw
= &adapter
->ahw
;
968 unsigned int first_seg_len
= skb
->len
- skb
->data_len
;
969 struct netxen_skb_frag
*buffrag
;
973 u32 saved_producer
= 0;
974 struct cmd_desc_type0
*hwdesc
;
976 struct netxen_cmd_buffer
*pbuf
= NULL
;
977 static int dropped_packet
= 0;
979 u32 local_producer
= 0;
980 u32 max_tx_desc_count
= 0;
981 u32 last_cmd_consumer
= 0;
984 adapter
->stats
.xmitcalled
++;
985 frag_count
= skb_shinfo(skb
)->nr_frags
+ 1;
987 if (unlikely(skb
->len
<= 0)) {
988 dev_kfree_skb_any(skb
);
989 adapter
->stats
.badskblen
++;
993 if (frag_count
> MAX_BUFFERS_PER_CMD
) {
994 printk("%s: %s netxen_nic_xmit_frame: frag_count (%d)"
995 "too large, can handle only %d frags\n",
996 netxen_nic_driver_name
, netdev
->name
,
997 frag_count
, MAX_BUFFERS_PER_CMD
);
998 adapter
->stats
.txdropped
++;
999 if ((++dropped_packet
& 0xff) == 0xff)
1000 printk("%s: %s droppped packets = %d\n",
1001 netxen_nic_driver_name
, netdev
->name
,
1004 return NETDEV_TX_OK
;
1008 * Everything is set up. Now, we just need to transmit it out.
1009 * Note that we have to copy the contents of buffer over to
1010 * right place. Later on, this can be optimized out by de-coupling the
1011 * producer index from the buffer index.
1013 retry_getting_window
:
1014 spin_lock_bh(&adapter
->tx_lock
);
1015 if (adapter
->total_threads
>= MAX_XMIT_PRODUCERS
) {
1016 spin_unlock_bh(&adapter
->tx_lock
);
1023 for (i
= 0; i
< 20; i
++)
1024 cpu_relax(); /*This a nop instr on i386 */
1026 goto retry_getting_window
;
1028 local_producer
= adapter
->cmd_producer
;
1029 /* There 4 fragments per descriptor */
1030 no_of_desc
= (frag_count
+ 3) >> 2;
1031 if (netdev
->features
& NETIF_F_TSO
) {
1032 if (skb_shinfo(skb
)->gso_size
> 0) {
1035 if ((ip_hdrlen(skb
) + tcp_hdrlen(skb
) +
1036 sizeof(struct ethhdr
)) >
1037 (sizeof(struct cmd_desc_type0
) - 2)) {
1042 k
= adapter
->cmd_producer
;
1043 max_tx_desc_count
= adapter
->max_tx_desc_count
;
1044 last_cmd_consumer
= adapter
->last_cmd_consumer
;
1045 if ((k
+ no_of_desc
) >=
1046 ((last_cmd_consumer
<= k
) ? last_cmd_consumer
+ max_tx_desc_count
:
1047 last_cmd_consumer
)) {
1048 netif_stop_queue(netdev
);
1049 adapter
->flags
|= NETXEN_NETDEV_STATUS
;
1050 spin_unlock_bh(&adapter
->tx_lock
);
1051 return NETDEV_TX_BUSY
;
1053 k
= get_index_range(k
, max_tx_desc_count
, no_of_desc
);
1054 adapter
->cmd_producer
= k
;
1055 adapter
->total_threads
++;
1056 adapter
->num_threads
++;
1058 spin_unlock_bh(&adapter
->tx_lock
);
1059 /* Copy the descriptors into the hardware */
1060 producer
= local_producer
;
1061 saved_producer
= producer
;
1062 hwdesc
= &hw
->cmd_desc_head
[producer
];
1063 memset(hwdesc
, 0, sizeof(struct cmd_desc_type0
));
1064 /* Take skb->data itself */
1065 pbuf
= &adapter
->cmd_buf_arr
[producer
];
1066 if ((netdev
->features
& NETIF_F_TSO
) && skb_shinfo(skb
)->gso_size
> 0) {
1067 pbuf
->mss
= skb_shinfo(skb
)->gso_size
;
1068 hwdesc
->mss
= cpu_to_le16(skb_shinfo(skb
)->gso_size
);
1073 pbuf
->total_length
= skb
->len
;
1075 pbuf
->cmd
= TX_ETHER_PKT
;
1076 pbuf
->frag_count
= frag_count
;
1077 pbuf
->port
= adapter
->portnum
;
1078 buffrag
= &pbuf
->frag_array
[0];
1079 buffrag
->dma
= pci_map_single(adapter
->pdev
, skb
->data
, first_seg_len
,
1081 buffrag
->length
= first_seg_len
;
1082 netxen_set_cmd_desc_totallength(hwdesc
, skb
->len
);
1083 netxen_set_cmd_desc_num_of_buff(hwdesc
, frag_count
);
1084 netxen_set_cmd_desc_opcode(hwdesc
, TX_ETHER_PKT
);
1086 netxen_set_cmd_desc_port(hwdesc
, adapter
->portnum
);
1087 netxen_set_cmd_desc_ctxid(hwdesc
, adapter
->portnum
);
1088 hwdesc
->buffer1_length
= cpu_to_le16(first_seg_len
);
1089 hwdesc
->addr_buffer1
= cpu_to_le64(buffrag
->dma
);
1091 for (i
= 1, k
= 1; i
< frag_count
; i
++, k
++) {
1092 struct skb_frag_struct
*frag
;
1094 unsigned long offset
;
1095 dma_addr_t temp_dma
;
1097 /* move to next desc. if there is a need */
1098 if ((i
& 0x3) == 0) {
1100 producer
= get_next_index(producer
,
1101 adapter
->max_tx_desc_count
);
1102 hwdesc
= &hw
->cmd_desc_head
[producer
];
1103 memset(hwdesc
, 0, sizeof(struct cmd_desc_type0
));
1105 frag
= &skb_shinfo(skb
)->frags
[i
- 1];
1107 offset
= frag
->page_offset
;
1110 temp_dma
= pci_map_page(adapter
->pdev
, frag
->page
, offset
,
1111 len
, PCI_DMA_TODEVICE
);
1114 buffrag
->dma
= temp_dma
;
1115 buffrag
->length
= temp_len
;
1117 DPRINTK(INFO
, "for loop. i=%d k=%d\n", i
, k
);
1120 hwdesc
->buffer1_length
= cpu_to_le16(temp_len
);
1121 hwdesc
->addr_buffer1
= cpu_to_le64(temp_dma
);
1124 hwdesc
->buffer2_length
= cpu_to_le16(temp_len
);
1125 hwdesc
->addr_buffer2
= cpu_to_le64(temp_dma
);
1128 hwdesc
->buffer3_length
= cpu_to_le16(temp_len
);
1129 hwdesc
->addr_buffer3
= cpu_to_le64(temp_dma
);
1132 hwdesc
->buffer4_length
= cpu_to_le16(temp_len
);
1133 hwdesc
->addr_buffer4
= cpu_to_le64(temp_dma
);
1138 producer
= get_next_index(producer
, adapter
->max_tx_desc_count
);
1140 /* might change opcode to TX_TCP_LSO */
1141 netxen_tso_check(adapter
, &hw
->cmd_desc_head
[saved_producer
], skb
);
1143 /* For LSO, we need to copy the MAC/IP/TCP headers into
1144 * the descriptor ring
1146 if (netxen_get_cmd_desc_opcode(&hw
->cmd_desc_head
[saved_producer
])
1148 int hdr_len
, first_hdr_len
, more_hdr
;
1149 hdr_len
= hw
->cmd_desc_head
[saved_producer
].total_hdr_length
;
1150 if (hdr_len
> (sizeof(struct cmd_desc_type0
) - 2)) {
1151 first_hdr_len
= sizeof(struct cmd_desc_type0
) - 2;
1154 first_hdr_len
= hdr_len
;
1157 /* copy the MAC/IP/TCP headers to the cmd descriptor list */
1158 hwdesc
= &hw
->cmd_desc_head
[producer
];
1160 /* copy the first 64 bytes */
1161 memcpy(((void *)hwdesc
) + 2,
1162 (void *)(skb
->data
), first_hdr_len
);
1163 producer
= get_next_index(producer
, max_tx_desc_count
);
1166 hwdesc
= &hw
->cmd_desc_head
[producer
];
1167 /* copy the next 64 bytes - should be enough except
1168 * for pathological case
1170 skb_copy_from_linear_data_offset(skb
, first_hdr_len
,
1174 producer
= get_next_index(producer
, max_tx_desc_count
);
1178 i
= netxen_get_cmd_desc_totallength(&hw
->cmd_desc_head
[saved_producer
]);
1180 hw
->cmd_desc_head
[saved_producer
].flags_opcode
=
1181 cpu_to_le16(hw
->cmd_desc_head
[saved_producer
].flags_opcode
);
1182 hw
->cmd_desc_head
[saved_producer
].num_of_buffers_total_length
=
1183 cpu_to_le32(hw
->cmd_desc_head
[saved_producer
].
1184 num_of_buffers_total_length
);
1186 spin_lock_bh(&adapter
->tx_lock
);
1187 adapter
->stats
.txbytes
+= i
;
1189 /* Code to update the adapter considering how many producer threads
1190 are currently working */
1191 if ((--adapter
->num_threads
) == 0) {
1192 /* This is the last thread */
1193 u32 crb_producer
= adapter
->cmd_producer
;
1194 netxen_nic_update_cmd_producer(adapter
, crb_producer
);
1196 adapter
->total_threads
= 0;
1199 adapter
->stats
.xmitfinished
++;
1200 spin_unlock_bh(&adapter
->tx_lock
);
1202 netdev
->trans_start
= jiffies
;
1204 DPRINTK(INFO
, "wrote CMD producer %x to phantom\n", producer
);
1206 DPRINTK(INFO
, "Done. Send\n");
1207 return NETDEV_TX_OK
;
1210 static void netxen_watchdog(unsigned long v
)
1212 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)v
;
1214 SCHEDULE_WORK(&adapter
->watchdog_task
);
1217 static void netxen_tx_timeout(struct net_device
*netdev
)
1219 struct netxen_adapter
*adapter
= (struct netxen_adapter
*)
1220 netdev_priv(netdev
);
1221 SCHEDULE_WORK(&adapter
->tx_timeout_task
);
1224 static void netxen_tx_timeout_task(struct work_struct
*work
)
1226 struct netxen_adapter
*adapter
=
1227 container_of(work
, struct netxen_adapter
, tx_timeout_task
);
1229 printk(KERN_ERR
"%s %s: transmit timeout, resetting.\n",
1230 netxen_nic_driver_name
, adapter
->netdev
->name
);
1232 netxen_nic_close(adapter
->netdev
);
1233 netxen_nic_open(adapter
->netdev
);
1234 adapter
->netdev
->trans_start
= jiffies
;
1235 netif_wake_queue(adapter
->netdev
);
1239 netxen_handle_int(struct netxen_adapter
*adapter
, struct net_device
*netdev
)
1243 DPRINTK(INFO
, "Entered handle ISR\n");
1244 adapter
->stats
.ints
++;
1246 netxen_nic_disable_int(adapter
);
1248 if (netxen_nic_rx_has_work(adapter
) || netxen_nic_tx_has_work(adapter
)) {
1249 if (netif_rx_schedule_prep(netdev
, &adapter
->napi
)) {
1251 * Interrupts are already disabled.
1253 __netif_rx_schedule(netdev
, &adapter
->napi
);
1255 static unsigned int intcount
= 0;
1256 if ((++intcount
& 0xfff) == 0xfff)
1258 "%s: %s interrupt %d while in poll\n",
1259 netxen_nic_driver_name
, netdev
->name
,
1266 netxen_nic_enable_int(adapter
);
1273 * netxen_intr - Interrupt Handler
1274 * @irq: interrupt number
1275 * data points to adapter stucture (which may be handling more than 1 port
1277 irqreturn_t
netxen_intr(int irq
, void *data
)
1279 struct netxen_adapter
*adapter
;
1280 struct net_device
*netdev
;
1283 if (unlikely(!irq
)) {
1284 return IRQ_NONE
; /* Not our interrupt */
1287 adapter
= (struct netxen_adapter
*)data
;
1288 netdev
= adapter
->netdev
;
1290 if (!(adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)) {
1291 our_int
= readl(NETXEN_CRB_NORMALIZE(adapter
, CRB_INT_VECTOR
));
1292 /* not our interrupt */
1293 if ((our_int
& (0x80 << adapter
->portnum
)) == 0)
1297 if (adapter
->intr_scheme
== INTR_SCHEME_PERPORT
) {
1298 /* claim interrupt */
1299 if (!(adapter
->flags
& NETXEN_NIC_MSI_ENABLED
)) {
1300 writel(our_int
& ~((u32
)(0x80 << adapter
->portnum
)),
1301 NETXEN_CRB_NORMALIZE(adapter
, CRB_INT_VECTOR
));
1305 if (netif_running(netdev
))
1306 netxen_handle_int(adapter
, netdev
);
1311 static int netxen_nic_poll(struct napi_struct
*napi
, int budget
)
1313 struct netxen_adapter
*adapter
= container_of(napi
, struct netxen_adapter
, napi
);
1314 struct net_device
*netdev
= adapter
->netdev
;
1319 DPRINTK(INFO
, "polling for %d descriptors\n", *budget
);
1322 for (ctx
= 0; ctx
< MAX_RCV_CTX
; ++ctx
) {
1324 * Fairness issue. This will give undue weight to the
1325 * receive context 0.
1329 * To avoid starvation, we give each of our receivers,
1330 * a fraction of the quota. Sometimes, it might happen that we
1331 * have enough quota to process every packet, but since all the
1332 * packets are on one context, it gets only half of the quota,
1333 * and ends up not processing it.
1335 work_done
+= netxen_process_rcv_ring(adapter
, ctx
,
1336 budget
/ MAX_RCV_CTX
);
1339 if (work_done
>= budget
&& netxen_nic_rx_has_work(adapter
) != 0)
1342 if (netxen_process_cmd_ring((unsigned long)adapter
) == 0)
1345 DPRINTK(INFO
, "new work_done: %d work_to_do: %d\n",
1346 work_done
, work_to_do
);
1348 netif_rx_complete(netdev
, napi
);
1349 netxen_nic_enable_int(adapter
);
1355 #ifdef CONFIG_NET_POLL_CONTROLLER
1356 static void netxen_nic_poll_controller(struct net_device
*netdev
)
1358 struct netxen_adapter
*adapter
= netdev_priv(netdev
);
1359 disable_irq(adapter
->irq
);
1360 netxen_intr(adapter
->irq
, adapter
);
1361 enable_irq(adapter
->irq
);
1365 static struct pci_driver netxen_driver
= {
1366 .name
= netxen_nic_driver_name
,
1367 .id_table
= netxen_pci_tbl
,
1368 .probe
= netxen_nic_probe
,
1369 .remove
= __devexit_p(netxen_nic_remove
)
1372 /* Driver Registration on NetXen card */
1374 static int __init
netxen_init_module(void)
1376 if ((netxen_workq
= create_singlethread_workqueue("netxen")) == 0)
1379 return pci_register_driver(&netxen_driver
);
1382 module_init(netxen_init_module
);
1384 static void __exit
netxen_exit_module(void)
1387 * Wait for some time to allow the dma to drain, if any.
1390 pci_unregister_driver(&netxen_driver
);
1391 destroy_workqueue(netxen_workq
);
1394 module_exit(netxen_exit_module
);