2 * QLogic qlge NIC HBA Driver
3 * Copyright (c) 2003-2008 QLogic Corporation
4 * See LICENSE.qlge for copyright and licensing details.
5 * Author: Linux qlge network device driver by
6 * Ron Mercer <ron.mercer@qlogic.com>
8 #include <linux/kernel.h>
9 #include <linux/init.h>
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/list.h>
13 #include <linux/pci.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/pagemap.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/dmapool.h>
19 #include <linux/mempool.h>
20 #include <linux/spinlock.h>
21 #include <linux/kthread.h>
22 #include <linux/interrupt.h>
23 #include <linux/errno.h>
24 #include <linux/ioport.h>
27 #include <linux/ipv6.h>
29 #include <linux/tcp.h>
30 #include <linux/udp.h>
31 #include <linux/if_arp.h>
32 #include <linux/if_ether.h>
33 #include <linux/netdevice.h>
34 #include <linux/etherdevice.h>
35 #include <linux/ethtool.h>
36 #include <linux/skbuff.h>
37 #include <linux/if_vlan.h>
38 #include <linux/delay.h>
40 #include <linux/vmalloc.h>
41 #include <net/ip6_checksum.h>
45 char qlge_driver_name
[] = DRV_NAME
;
46 const char qlge_driver_version
[] = DRV_VERSION
;
48 MODULE_AUTHOR("Ron Mercer <ron.mercer@qlogic.com>");
49 MODULE_DESCRIPTION(DRV_STRING
" ");
50 MODULE_LICENSE("GPL");
51 MODULE_VERSION(DRV_VERSION
);
53 static const u32 default_msg
=
54 NETIF_MSG_DRV
| NETIF_MSG_PROBE
| NETIF_MSG_LINK
|
55 /* NETIF_MSG_TIMER | */
60 /* NETIF_MSG_TX_QUEUED | */
61 /* NETIF_MSG_INTR | NETIF_MSG_TX_DONE | NETIF_MSG_RX_STATUS | */
62 /* NETIF_MSG_PKTDATA | */
63 NETIF_MSG_HW
| NETIF_MSG_WOL
| 0;
65 static int debug
= 0x00007fff; /* defaults above */
66 module_param(debug
, int, 0);
67 MODULE_PARM_DESC(debug
, "Debug level (0=none,...,16=all)");
72 static int qlge_irq_type
= MSIX_IRQ
;
73 module_param(qlge_irq_type
, int, MSIX_IRQ
);
74 MODULE_PARM_DESC(qlge_irq_type
, "0 = MSI-X, 1 = MSI, 2 = Legacy.");
76 static int qlge_mpi_coredump
;
77 module_param(qlge_mpi_coredump
, int, 0);
78 MODULE_PARM_DESC(qlge_mpi_coredump
,
79 "Option to enable MPI firmware dump. "
80 "Default is OFF - Do Not allocate memory. ");
82 static int qlge_force_coredump
;
83 module_param(qlge_force_coredump
, int, 0);
84 MODULE_PARM_DESC(qlge_force_coredump
,
85 "Option to allow force of firmware core dump. "
86 "Default is OFF - Do not allow.");
88 static DEFINE_PCI_DEVICE_TABLE(qlge_pci_tbl
) = {
89 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, QLGE_DEVICE_ID_8012
)},
90 {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC
, QLGE_DEVICE_ID_8000
)},
91 /* required last entry */
95 MODULE_DEVICE_TABLE(pci
, qlge_pci_tbl
);
97 /* This hardware semaphore causes exclusive access to
98 * resources shared between the NIC driver, MPI firmware,
99 * FCOE firmware and the FC driver.
101 static int ql_sem_trylock(struct ql_adapter
*qdev
, u32 sem_mask
)
106 case SEM_XGMAC0_MASK
:
107 sem_bits
= SEM_SET
<< SEM_XGMAC0_SHIFT
;
109 case SEM_XGMAC1_MASK
:
110 sem_bits
= SEM_SET
<< SEM_XGMAC1_SHIFT
;
113 sem_bits
= SEM_SET
<< SEM_ICB_SHIFT
;
115 case SEM_MAC_ADDR_MASK
:
116 sem_bits
= SEM_SET
<< SEM_MAC_ADDR_SHIFT
;
119 sem_bits
= SEM_SET
<< SEM_FLASH_SHIFT
;
122 sem_bits
= SEM_SET
<< SEM_PROBE_SHIFT
;
124 case SEM_RT_IDX_MASK
:
125 sem_bits
= SEM_SET
<< SEM_RT_IDX_SHIFT
;
127 case SEM_PROC_REG_MASK
:
128 sem_bits
= SEM_SET
<< SEM_PROC_REG_SHIFT
;
131 netif_alert(qdev
, probe
, qdev
->ndev
, "bad Semaphore mask!.\n");
135 ql_write32(qdev
, SEM
, sem_bits
| sem_mask
);
136 return !(ql_read32(qdev
, SEM
) & sem_bits
);
139 int ql_sem_spinlock(struct ql_adapter
*qdev
, u32 sem_mask
)
141 unsigned int wait_count
= 30;
143 if (!ql_sem_trylock(qdev
, sem_mask
))
146 } while (--wait_count
);
150 void ql_sem_unlock(struct ql_adapter
*qdev
, u32 sem_mask
)
152 ql_write32(qdev
, SEM
, sem_mask
);
153 ql_read32(qdev
, SEM
); /* flush */
156 /* This function waits for a specific bit to come ready
157 * in a given register. It is used mostly by the initialize
158 * process, but is also used in kernel thread API such as
159 * netdev->set_multi, netdev->set_mac_address, netdev->vlan_rx_add_vid.
161 int ql_wait_reg_rdy(struct ql_adapter
*qdev
, u32 reg
, u32 bit
, u32 err_bit
)
164 int count
= UDELAY_COUNT
;
167 temp
= ql_read32(qdev
, reg
);
169 /* check for errors */
170 if (temp
& err_bit
) {
171 netif_alert(qdev
, probe
, qdev
->ndev
,
172 "register 0x%.08x access error, value = 0x%.08x!.\n",
175 } else if (temp
& bit
)
177 udelay(UDELAY_DELAY
);
180 netif_alert(qdev
, probe
, qdev
->ndev
,
181 "Timed out waiting for reg %x to come ready.\n", reg
);
185 /* The CFG register is used to download TX and RX control blocks
186 * to the chip. This function waits for an operation to complete.
188 static int ql_wait_cfg(struct ql_adapter
*qdev
, u32 bit
)
190 int count
= UDELAY_COUNT
;
194 temp
= ql_read32(qdev
, CFG
);
199 udelay(UDELAY_DELAY
);
206 /* Used to issue init control blocks to hw. Maps control block,
207 * sets address, triggers download, waits for completion.
209 int ql_write_cfg(struct ql_adapter
*qdev
, void *ptr
, int size
, u32 bit
,
219 (bit
& (CFG_LRQ
| CFG_LR
| CFG_LCQ
)) ? PCI_DMA_TODEVICE
:
222 map
= pci_map_single(qdev
->pdev
, ptr
, size
, direction
);
223 if (pci_dma_mapping_error(qdev
->pdev
, map
)) {
224 netif_err(qdev
, ifup
, qdev
->ndev
, "Couldn't map DMA area.\n");
228 status
= ql_sem_spinlock(qdev
, SEM_ICB_MASK
);
232 status
= ql_wait_cfg(qdev
, bit
);
234 netif_err(qdev
, ifup
, qdev
->ndev
,
235 "Timed out waiting for CFG to come ready.\n");
239 ql_write32(qdev
, ICB_L
, (u32
) map
);
240 ql_write32(qdev
, ICB_H
, (u32
) (map
>> 32));
242 mask
= CFG_Q_MASK
| (bit
<< 16);
243 value
= bit
| (q_id
<< CFG_Q_SHIFT
);
244 ql_write32(qdev
, CFG
, (mask
| value
));
247 * Wait for the bit to clear after signaling hw.
249 status
= ql_wait_cfg(qdev
, bit
);
251 ql_sem_unlock(qdev
, SEM_ICB_MASK
); /* does flush too */
252 pci_unmap_single(qdev
->pdev
, map
, size
, direction
);
256 /* Get a specific MAC address from the CAM. Used for debug and reg dump. */
257 int ql_get_mac_addr_reg(struct ql_adapter
*qdev
, u32 type
, u16 index
,
264 case MAC_ADDR_TYPE_MULTI_MAC
:
265 case MAC_ADDR_TYPE_CAM_MAC
:
268 ql_wait_reg_rdy(qdev
,
269 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
272 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) | /* offset */
273 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
274 MAC_ADDR_ADR
| MAC_ADDR_RS
| type
); /* type */
276 ql_wait_reg_rdy(qdev
,
277 MAC_ADDR_IDX
, MAC_ADDR_MR
, 0);
280 *value
++ = ql_read32(qdev
, MAC_ADDR_DATA
);
282 ql_wait_reg_rdy(qdev
,
283 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
286 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) | /* offset */
287 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
288 MAC_ADDR_ADR
| MAC_ADDR_RS
| type
); /* type */
290 ql_wait_reg_rdy(qdev
,
291 MAC_ADDR_IDX
, MAC_ADDR_MR
, 0);
294 *value
++ = ql_read32(qdev
, MAC_ADDR_DATA
);
295 if (type
== MAC_ADDR_TYPE_CAM_MAC
) {
297 ql_wait_reg_rdy(qdev
,
298 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
301 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) | /* offset */
302 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
303 MAC_ADDR_ADR
| MAC_ADDR_RS
| type
); /* type */
305 ql_wait_reg_rdy(qdev
, MAC_ADDR_IDX
,
309 *value
++ = ql_read32(qdev
, MAC_ADDR_DATA
);
313 case MAC_ADDR_TYPE_VLAN
:
314 case MAC_ADDR_TYPE_MULTI_FLTR
:
316 netif_crit(qdev
, ifup
, qdev
->ndev
,
317 "Address type %d not yet supported.\n", type
);
324 /* Set up a MAC, multicast or VLAN address for the
325 * inbound frame matching.
327 static int ql_set_mac_addr_reg(struct ql_adapter
*qdev
, u8
*addr
, u32 type
,
334 case MAC_ADDR_TYPE_MULTI_MAC
:
336 u32 upper
= (addr
[0] << 8) | addr
[1];
337 u32 lower
= (addr
[2] << 24) | (addr
[3] << 16) |
338 (addr
[4] << 8) | (addr
[5]);
341 ql_wait_reg_rdy(qdev
,
342 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
345 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) |
346 (index
<< MAC_ADDR_IDX_SHIFT
) |
348 ql_write32(qdev
, MAC_ADDR_DATA
, lower
);
350 ql_wait_reg_rdy(qdev
,
351 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
354 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) |
355 (index
<< MAC_ADDR_IDX_SHIFT
) |
358 ql_write32(qdev
, MAC_ADDR_DATA
, upper
);
360 ql_wait_reg_rdy(qdev
,
361 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
366 case MAC_ADDR_TYPE_CAM_MAC
:
369 u32 upper
= (addr
[0] << 8) | addr
[1];
371 (addr
[2] << 24) | (addr
[3] << 16) | (addr
[4] << 8) |
374 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
375 "Adding %s address %pM at index %d in the CAM.\n",
376 type
== MAC_ADDR_TYPE_MULTI_MAC
?
377 "MULTICAST" : "UNICAST",
381 ql_wait_reg_rdy(qdev
,
382 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
385 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) | /* offset */
386 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
388 ql_write32(qdev
, MAC_ADDR_DATA
, lower
);
390 ql_wait_reg_rdy(qdev
,
391 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
394 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
++) | /* offset */
395 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
397 ql_write32(qdev
, MAC_ADDR_DATA
, upper
);
399 ql_wait_reg_rdy(qdev
,
400 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
403 ql_write32(qdev
, MAC_ADDR_IDX
, (offset
) | /* offset */
404 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
406 /* This field should also include the queue id
407 and possibly the function id. Right now we hardcode
408 the route field to NIC core.
410 cam_output
= (CAM_OUT_ROUTE_NIC
|
412 func
<< CAM_OUT_FUNC_SHIFT
) |
413 (0 << CAM_OUT_CQ_ID_SHIFT
));
415 cam_output
|= CAM_OUT_RV
;
416 /* route to NIC core */
417 ql_write32(qdev
, MAC_ADDR_DATA
, cam_output
);
420 case MAC_ADDR_TYPE_VLAN
:
422 u32 enable_bit
= *((u32
*) &addr
[0]);
423 /* For VLAN, the addr actually holds a bit that
424 * either enables or disables the vlan id we are
425 * addressing. It's either MAC_ADDR_E on or off.
426 * That's bit-27 we're talking about.
428 netif_info(qdev
, ifup
, qdev
->ndev
,
429 "%s VLAN ID %d %s the CAM.\n",
430 enable_bit
? "Adding" : "Removing",
432 enable_bit
? "to" : "from");
435 ql_wait_reg_rdy(qdev
,
436 MAC_ADDR_IDX
, MAC_ADDR_MW
, 0);
439 ql_write32(qdev
, MAC_ADDR_IDX
, offset
| /* offset */
440 (index
<< MAC_ADDR_IDX_SHIFT
) | /* index */
442 enable_bit
); /* enable/disable */
445 case MAC_ADDR_TYPE_MULTI_FLTR
:
447 netif_crit(qdev
, ifup
, qdev
->ndev
,
448 "Address type %d not yet supported.\n", type
);
455 /* Set or clear MAC address in hardware. We sometimes
456 * have to clear it to prevent wrong frame routing
457 * especially in a bonding environment.
459 static int ql_set_mac_addr(struct ql_adapter
*qdev
, int set
)
462 char zero_mac_addr
[ETH_ALEN
];
466 addr
= &qdev
->current_mac_addr
[0];
467 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
468 "Set Mac addr %pM\n", addr
);
470 memset(zero_mac_addr
, 0, ETH_ALEN
);
471 addr
= &zero_mac_addr
[0];
472 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
473 "Clearing MAC address\n");
475 status
= ql_sem_spinlock(qdev
, SEM_MAC_ADDR_MASK
);
478 status
= ql_set_mac_addr_reg(qdev
, (u8
*) addr
,
479 MAC_ADDR_TYPE_CAM_MAC
, qdev
->func
* MAX_CQ
);
480 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
482 netif_err(qdev
, ifup
, qdev
->ndev
,
483 "Failed to init mac address.\n");
487 void ql_link_on(struct ql_adapter
*qdev
)
489 netif_err(qdev
, link
, qdev
->ndev
, "Link is up.\n");
490 netif_carrier_on(qdev
->ndev
);
491 ql_set_mac_addr(qdev
, 1);
494 void ql_link_off(struct ql_adapter
*qdev
)
496 netif_err(qdev
, link
, qdev
->ndev
, "Link is down.\n");
497 netif_carrier_off(qdev
->ndev
);
498 ql_set_mac_addr(qdev
, 0);
501 /* Get a specific frame routing value from the CAM.
502 * Used for debug and reg dump.
504 int ql_get_routing_reg(struct ql_adapter
*qdev
, u32 index
, u32
*value
)
508 status
= ql_wait_reg_rdy(qdev
, RT_IDX
, RT_IDX_MW
, 0);
512 ql_write32(qdev
, RT_IDX
,
513 RT_IDX_TYPE_NICQ
| RT_IDX_RS
| (index
<< RT_IDX_IDX_SHIFT
));
514 status
= ql_wait_reg_rdy(qdev
, RT_IDX
, RT_IDX_MR
, 0);
517 *value
= ql_read32(qdev
, RT_DATA
);
522 /* The NIC function for this chip has 16 routing indexes. Each one can be used
523 * to route different frame types to various inbound queues. We send broadcast/
524 * multicast/error frames to the default queue for slow handling,
525 * and CAM hit/RSS frames to the fast handling queues.
527 static int ql_set_routing_reg(struct ql_adapter
*qdev
, u32 index
, u32 mask
,
530 int status
= -EINVAL
; /* Return error if no mask match. */
533 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
534 "%s %s mask %s the routing reg.\n",
535 enable
? "Adding" : "Removing",
536 index
== RT_IDX_ALL_ERR_SLOT
? "MAC ERROR/ALL ERROR" :
537 index
== RT_IDX_IP_CSUM_ERR_SLOT
? "IP CSUM ERROR" :
538 index
== RT_IDX_TCP_UDP_CSUM_ERR_SLOT
? "TCP/UDP CSUM ERROR" :
539 index
== RT_IDX_BCAST_SLOT
? "BROADCAST" :
540 index
== RT_IDX_MCAST_MATCH_SLOT
? "MULTICAST MATCH" :
541 index
== RT_IDX_ALLMULTI_SLOT
? "ALL MULTICAST MATCH" :
542 index
== RT_IDX_UNUSED6_SLOT
? "UNUSED6" :
543 index
== RT_IDX_UNUSED7_SLOT
? "UNUSED7" :
544 index
== RT_IDX_RSS_MATCH_SLOT
? "RSS ALL/IPV4 MATCH" :
545 index
== RT_IDX_RSS_IPV6_SLOT
? "RSS IPV6" :
546 index
== RT_IDX_RSS_TCP4_SLOT
? "RSS TCP4" :
547 index
== RT_IDX_RSS_TCP6_SLOT
? "RSS TCP6" :
548 index
== RT_IDX_CAM_HIT_SLOT
? "CAM HIT" :
549 index
== RT_IDX_UNUSED013
? "UNUSED13" :
550 index
== RT_IDX_UNUSED014
? "UNUSED14" :
551 index
== RT_IDX_PROMISCUOUS_SLOT
? "PROMISCUOUS" :
552 "(Bad index != RT_IDX)",
553 enable
? "to" : "from");
558 value
= RT_IDX_DST_CAM_Q
| /* dest */
559 RT_IDX_TYPE_NICQ
| /* type */
560 (RT_IDX_CAM_HIT_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
563 case RT_IDX_VALID
: /* Promiscuous Mode frames. */
565 value
= RT_IDX_DST_DFLT_Q
| /* dest */
566 RT_IDX_TYPE_NICQ
| /* type */
567 (RT_IDX_PROMISCUOUS_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
570 case RT_IDX_ERR
: /* Pass up MAC,IP,TCP/UDP error frames. */
572 value
= RT_IDX_DST_DFLT_Q
| /* dest */
573 RT_IDX_TYPE_NICQ
| /* type */
574 (RT_IDX_ALL_ERR_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
577 case RT_IDX_IP_CSUM_ERR
: /* Pass up IP CSUM error frames. */
579 value
= RT_IDX_DST_DFLT_Q
| /* dest */
580 RT_IDX_TYPE_NICQ
| /* type */
581 (RT_IDX_IP_CSUM_ERR_SLOT
<<
582 RT_IDX_IDX_SHIFT
); /* index */
585 case RT_IDX_TU_CSUM_ERR
: /* Pass up TCP/UDP CSUM error frames. */
587 value
= RT_IDX_DST_DFLT_Q
| /* dest */
588 RT_IDX_TYPE_NICQ
| /* type */
589 (RT_IDX_TCP_UDP_CSUM_ERR_SLOT
<<
590 RT_IDX_IDX_SHIFT
); /* index */
593 case RT_IDX_BCAST
: /* Pass up Broadcast frames to default Q. */
595 value
= RT_IDX_DST_DFLT_Q
| /* dest */
596 RT_IDX_TYPE_NICQ
| /* type */
597 (RT_IDX_BCAST_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
600 case RT_IDX_MCAST
: /* Pass up All Multicast frames. */
602 value
= RT_IDX_DST_DFLT_Q
| /* dest */
603 RT_IDX_TYPE_NICQ
| /* type */
604 (RT_IDX_ALLMULTI_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
607 case RT_IDX_MCAST_MATCH
: /* Pass up matched Multicast frames. */
609 value
= RT_IDX_DST_DFLT_Q
| /* dest */
610 RT_IDX_TYPE_NICQ
| /* type */
611 (RT_IDX_MCAST_MATCH_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
614 case RT_IDX_RSS_MATCH
: /* Pass up matched RSS frames. */
616 value
= RT_IDX_DST_RSS
| /* dest */
617 RT_IDX_TYPE_NICQ
| /* type */
618 (RT_IDX_RSS_MATCH_SLOT
<< RT_IDX_IDX_SHIFT
);/* index */
621 case 0: /* Clear the E-bit on an entry. */
623 value
= RT_IDX_DST_DFLT_Q
| /* dest */
624 RT_IDX_TYPE_NICQ
| /* type */
625 (index
<< RT_IDX_IDX_SHIFT
);/* index */
629 netif_err(qdev
, ifup
, qdev
->ndev
,
630 "Mask type %d not yet supported.\n", mask
);
636 status
= ql_wait_reg_rdy(qdev
, RT_IDX
, RT_IDX_MW
, 0);
639 value
|= (enable
? RT_IDX_E
: 0);
640 ql_write32(qdev
, RT_IDX
, value
);
641 ql_write32(qdev
, RT_DATA
, enable
? mask
: 0);
647 static void ql_enable_interrupts(struct ql_adapter
*qdev
)
649 ql_write32(qdev
, INTR_EN
, (INTR_EN_EI
<< 16) | INTR_EN_EI
);
652 static void ql_disable_interrupts(struct ql_adapter
*qdev
)
654 ql_write32(qdev
, INTR_EN
, (INTR_EN_EI
<< 16));
657 /* If we're running with multiple MSI-X vectors then we enable on the fly.
658 * Otherwise, we may have multiple outstanding workers and don't want to
659 * enable until the last one finishes. In this case, the irq_cnt gets
660 * incremented everytime we queue a worker and decremented everytime
661 * a worker finishes. Once it hits zero we enable the interrupt.
663 u32
ql_enable_completion_interrupt(struct ql_adapter
*qdev
, u32 intr
)
666 unsigned long hw_flags
= 0;
667 struct intr_context
*ctx
= qdev
->intr_context
+ intr
;
669 if (likely(test_bit(QL_MSIX_ENABLED
, &qdev
->flags
) && intr
)) {
670 /* Always enable if we're MSIX multi interrupts and
671 * it's not the default (zeroeth) interrupt.
673 ql_write32(qdev
, INTR_EN
,
675 var
= ql_read32(qdev
, STS
);
679 spin_lock_irqsave(&qdev
->hw_lock
, hw_flags
);
680 if (atomic_dec_and_test(&ctx
->irq_cnt
)) {
681 ql_write32(qdev
, INTR_EN
,
683 var
= ql_read32(qdev
, STS
);
685 spin_unlock_irqrestore(&qdev
->hw_lock
, hw_flags
);
689 static u32
ql_disable_completion_interrupt(struct ql_adapter
*qdev
, u32 intr
)
692 struct intr_context
*ctx
;
694 /* HW disables for us if we're MSIX multi interrupts and
695 * it's not the default (zeroeth) interrupt.
697 if (likely(test_bit(QL_MSIX_ENABLED
, &qdev
->flags
) && intr
))
700 ctx
= qdev
->intr_context
+ intr
;
701 spin_lock(&qdev
->hw_lock
);
702 if (!atomic_read(&ctx
->irq_cnt
)) {
703 ql_write32(qdev
, INTR_EN
,
705 var
= ql_read32(qdev
, STS
);
707 atomic_inc(&ctx
->irq_cnt
);
708 spin_unlock(&qdev
->hw_lock
);
712 static void ql_enable_all_completion_interrupts(struct ql_adapter
*qdev
)
715 for (i
= 0; i
< qdev
->intr_count
; i
++) {
716 /* The enable call does a atomic_dec_and_test
717 * and enables only if the result is zero.
718 * So we precharge it here.
720 if (unlikely(!test_bit(QL_MSIX_ENABLED
, &qdev
->flags
) ||
722 atomic_set(&qdev
->intr_context
[i
].irq_cnt
, 1);
723 ql_enable_completion_interrupt(qdev
, i
);
728 static int ql_validate_flash(struct ql_adapter
*qdev
, u32 size
, const char *str
)
732 __le16
*flash
= (__le16
*)&qdev
->flash
;
734 status
= strncmp((char *)&qdev
->flash
, str
, 4);
736 netif_err(qdev
, ifup
, qdev
->ndev
, "Invalid flash signature.\n");
740 for (i
= 0; i
< size
; i
++)
741 csum
+= le16_to_cpu(*flash
++);
744 netif_err(qdev
, ifup
, qdev
->ndev
,
745 "Invalid flash checksum, csum = 0x%.04x.\n", csum
);
750 static int ql_read_flash_word(struct ql_adapter
*qdev
, int offset
, __le32
*data
)
753 /* wait for reg to come ready */
754 status
= ql_wait_reg_rdy(qdev
,
755 FLASH_ADDR
, FLASH_ADDR_RDY
, FLASH_ADDR_ERR
);
758 /* set up for reg read */
759 ql_write32(qdev
, FLASH_ADDR
, FLASH_ADDR_R
| offset
);
760 /* wait for reg to come ready */
761 status
= ql_wait_reg_rdy(qdev
,
762 FLASH_ADDR
, FLASH_ADDR_RDY
, FLASH_ADDR_ERR
);
765 /* This data is stored on flash as an array of
766 * __le32. Since ql_read32() returns cpu endian
767 * we need to swap it back.
769 *data
= cpu_to_le32(ql_read32(qdev
, FLASH_DATA
));
774 static int ql_get_8000_flash_params(struct ql_adapter
*qdev
)
778 __le32
*p
= (__le32
*)&qdev
->flash
;
782 /* Get flash offset for function and adjust
786 offset
= FUNC0_FLASH_OFFSET
/ sizeof(u32
);
788 offset
= FUNC1_FLASH_OFFSET
/ sizeof(u32
);
790 if (ql_sem_spinlock(qdev
, SEM_FLASH_MASK
))
793 size
= sizeof(struct flash_params_8000
) / sizeof(u32
);
794 for (i
= 0; i
< size
; i
++, p
++) {
795 status
= ql_read_flash_word(qdev
, i
+offset
, p
);
797 netif_err(qdev
, ifup
, qdev
->ndev
,
798 "Error reading flash.\n");
803 status
= ql_validate_flash(qdev
,
804 sizeof(struct flash_params_8000
) / sizeof(u16
),
807 netif_err(qdev
, ifup
, qdev
->ndev
, "Invalid flash.\n");
812 /* Extract either manufacturer or BOFM modified
815 if (qdev
->flash
.flash_params_8000
.data_type1
== 2)
817 qdev
->flash
.flash_params_8000
.mac_addr1
,
818 qdev
->ndev
->addr_len
);
821 qdev
->flash
.flash_params_8000
.mac_addr
,
822 qdev
->ndev
->addr_len
);
824 if (!is_valid_ether_addr(mac_addr
)) {
825 netif_err(qdev
, ifup
, qdev
->ndev
, "Invalid MAC address.\n");
830 memcpy(qdev
->ndev
->dev_addr
,
832 qdev
->ndev
->addr_len
);
835 ql_sem_unlock(qdev
, SEM_FLASH_MASK
);
839 static int ql_get_8012_flash_params(struct ql_adapter
*qdev
)
843 __le32
*p
= (__le32
*)&qdev
->flash
;
845 u32 size
= sizeof(struct flash_params_8012
) / sizeof(u32
);
847 /* Second function's parameters follow the first
853 if (ql_sem_spinlock(qdev
, SEM_FLASH_MASK
))
856 for (i
= 0; i
< size
; i
++, p
++) {
857 status
= ql_read_flash_word(qdev
, i
+offset
, p
);
859 netif_err(qdev
, ifup
, qdev
->ndev
,
860 "Error reading flash.\n");
866 status
= ql_validate_flash(qdev
,
867 sizeof(struct flash_params_8012
) / sizeof(u16
),
870 netif_err(qdev
, ifup
, qdev
->ndev
, "Invalid flash.\n");
875 if (!is_valid_ether_addr(qdev
->flash
.flash_params_8012
.mac_addr
)) {
880 memcpy(qdev
->ndev
->dev_addr
,
881 qdev
->flash
.flash_params_8012
.mac_addr
,
882 qdev
->ndev
->addr_len
);
885 ql_sem_unlock(qdev
, SEM_FLASH_MASK
);
889 /* xgmac register are located behind the xgmac_addr and xgmac_data
890 * register pair. Each read/write requires us to wait for the ready
891 * bit before reading/writing the data.
893 static int ql_write_xgmac_reg(struct ql_adapter
*qdev
, u32 reg
, u32 data
)
896 /* wait for reg to come ready */
897 status
= ql_wait_reg_rdy(qdev
,
898 XGMAC_ADDR
, XGMAC_ADDR_RDY
, XGMAC_ADDR_XME
);
901 /* write the data to the data reg */
902 ql_write32(qdev
, XGMAC_DATA
, data
);
903 /* trigger the write */
904 ql_write32(qdev
, XGMAC_ADDR
, reg
);
908 /* xgmac register are located behind the xgmac_addr and xgmac_data
909 * register pair. Each read/write requires us to wait for the ready
910 * bit before reading/writing the data.
912 int ql_read_xgmac_reg(struct ql_adapter
*qdev
, u32 reg
, u32
*data
)
915 /* wait for reg to come ready */
916 status
= ql_wait_reg_rdy(qdev
,
917 XGMAC_ADDR
, XGMAC_ADDR_RDY
, XGMAC_ADDR_XME
);
920 /* set up for reg read */
921 ql_write32(qdev
, XGMAC_ADDR
, reg
| XGMAC_ADDR_R
);
922 /* wait for reg to come ready */
923 status
= ql_wait_reg_rdy(qdev
,
924 XGMAC_ADDR
, XGMAC_ADDR_RDY
, XGMAC_ADDR_XME
);
928 *data
= ql_read32(qdev
, XGMAC_DATA
);
933 /* This is used for reading the 64-bit statistics regs. */
934 int ql_read_xgmac_reg64(struct ql_adapter
*qdev
, u32 reg
, u64
*data
)
940 status
= ql_read_xgmac_reg(qdev
, reg
, &lo
);
944 status
= ql_read_xgmac_reg(qdev
, reg
+ 4, &hi
);
948 *data
= (u64
) lo
| ((u64
) hi
<< 32);
954 static int ql_8000_port_initialize(struct ql_adapter
*qdev
)
958 * Get MPI firmware version for driver banner
961 status
= ql_mb_about_fw(qdev
);
964 status
= ql_mb_get_fw_state(qdev
);
967 /* Wake up a worker to get/set the TX/RX frame sizes. */
968 queue_delayed_work(qdev
->workqueue
, &qdev
->mpi_port_cfg_work
, 0);
973 /* Take the MAC Core out of reset.
974 * Enable statistics counting.
975 * Take the transmitter/receiver out of reset.
976 * This functionality may be done in the MPI firmware at a
979 static int ql_8012_port_initialize(struct ql_adapter
*qdev
)
984 if (ql_sem_trylock(qdev
, qdev
->xg_sem_mask
)) {
985 /* Another function has the semaphore, so
986 * wait for the port init bit to come ready.
988 netif_info(qdev
, link
, qdev
->ndev
,
989 "Another function has the semaphore, so wait for the port init bit to come ready.\n");
990 status
= ql_wait_reg_rdy(qdev
, STS
, qdev
->port_init
, 0);
992 netif_crit(qdev
, link
, qdev
->ndev
,
993 "Port initialize timed out.\n");
998 netif_info(qdev
, link
, qdev
->ndev
, "Got xgmac semaphore!.\n");
999 /* Set the core reset. */
1000 status
= ql_read_xgmac_reg(qdev
, GLOBAL_CFG
, &data
);
1003 data
|= GLOBAL_CFG_RESET
;
1004 status
= ql_write_xgmac_reg(qdev
, GLOBAL_CFG
, data
);
1008 /* Clear the core reset and turn on jumbo for receiver. */
1009 data
&= ~GLOBAL_CFG_RESET
; /* Clear core reset. */
1010 data
|= GLOBAL_CFG_JUMBO
; /* Turn on jumbo. */
1011 data
|= GLOBAL_CFG_TX_STAT_EN
;
1012 data
|= GLOBAL_CFG_RX_STAT_EN
;
1013 status
= ql_write_xgmac_reg(qdev
, GLOBAL_CFG
, data
);
1017 /* Enable transmitter, and clear it's reset. */
1018 status
= ql_read_xgmac_reg(qdev
, TX_CFG
, &data
);
1021 data
&= ~TX_CFG_RESET
; /* Clear the TX MAC reset. */
1022 data
|= TX_CFG_EN
; /* Enable the transmitter. */
1023 status
= ql_write_xgmac_reg(qdev
, TX_CFG
, data
);
1027 /* Enable receiver and clear it's reset. */
1028 status
= ql_read_xgmac_reg(qdev
, RX_CFG
, &data
);
1031 data
&= ~RX_CFG_RESET
; /* Clear the RX MAC reset. */
1032 data
|= RX_CFG_EN
; /* Enable the receiver. */
1033 status
= ql_write_xgmac_reg(qdev
, RX_CFG
, data
);
1037 /* Turn on jumbo. */
1039 ql_write_xgmac_reg(qdev
, MAC_TX_PARAMS
, MAC_TX_PARAMS_JUMBO
| (0x2580 << 16));
1043 ql_write_xgmac_reg(qdev
, MAC_RX_PARAMS
, 0x2580);
1047 /* Signal to the world that the port is enabled. */
1048 ql_write32(qdev
, STS
, ((qdev
->port_init
<< 16) | qdev
->port_init
));
1050 ql_sem_unlock(qdev
, qdev
->xg_sem_mask
);
1054 static inline unsigned int ql_lbq_block_size(struct ql_adapter
*qdev
)
1056 return PAGE_SIZE
<< qdev
->lbq_buf_order
;
1059 /* Get the next large buffer. */
1060 static struct bq_desc
*ql_get_curr_lbuf(struct rx_ring
*rx_ring
)
1062 struct bq_desc
*lbq_desc
= &rx_ring
->lbq
[rx_ring
->lbq_curr_idx
];
1063 rx_ring
->lbq_curr_idx
++;
1064 if (rx_ring
->lbq_curr_idx
== rx_ring
->lbq_len
)
1065 rx_ring
->lbq_curr_idx
= 0;
1066 rx_ring
->lbq_free_cnt
++;
1070 static struct bq_desc
*ql_get_curr_lchunk(struct ql_adapter
*qdev
,
1071 struct rx_ring
*rx_ring
)
1073 struct bq_desc
*lbq_desc
= ql_get_curr_lbuf(rx_ring
);
1075 pci_dma_sync_single_for_cpu(qdev
->pdev
,
1076 dma_unmap_addr(lbq_desc
, mapaddr
),
1077 rx_ring
->lbq_buf_size
,
1078 PCI_DMA_FROMDEVICE
);
1080 /* If it's the last chunk of our master page then
1083 if ((lbq_desc
->p
.pg_chunk
.offset
+ rx_ring
->lbq_buf_size
)
1084 == ql_lbq_block_size(qdev
))
1085 pci_unmap_page(qdev
->pdev
,
1086 lbq_desc
->p
.pg_chunk
.map
,
1087 ql_lbq_block_size(qdev
),
1088 PCI_DMA_FROMDEVICE
);
1092 /* Get the next small buffer. */
1093 static struct bq_desc
*ql_get_curr_sbuf(struct rx_ring
*rx_ring
)
1095 struct bq_desc
*sbq_desc
= &rx_ring
->sbq
[rx_ring
->sbq_curr_idx
];
1096 rx_ring
->sbq_curr_idx
++;
1097 if (rx_ring
->sbq_curr_idx
== rx_ring
->sbq_len
)
1098 rx_ring
->sbq_curr_idx
= 0;
1099 rx_ring
->sbq_free_cnt
++;
1103 /* Update an rx ring index. */
1104 static void ql_update_cq(struct rx_ring
*rx_ring
)
1106 rx_ring
->cnsmr_idx
++;
1107 rx_ring
->curr_entry
++;
1108 if (unlikely(rx_ring
->cnsmr_idx
== rx_ring
->cq_len
)) {
1109 rx_ring
->cnsmr_idx
= 0;
1110 rx_ring
->curr_entry
= rx_ring
->cq_base
;
1114 static void ql_write_cq_idx(struct rx_ring
*rx_ring
)
1116 ql_write_db_reg(rx_ring
->cnsmr_idx
, rx_ring
->cnsmr_idx_db_reg
);
1119 static int ql_get_next_chunk(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
,
1120 struct bq_desc
*lbq_desc
)
1122 if (!rx_ring
->pg_chunk
.page
) {
1124 rx_ring
->pg_chunk
.page
= alloc_pages(__GFP_COLD
| __GFP_COMP
|
1126 qdev
->lbq_buf_order
);
1127 if (unlikely(!rx_ring
->pg_chunk
.page
)) {
1128 netif_err(qdev
, drv
, qdev
->ndev
,
1129 "page allocation failed.\n");
1132 rx_ring
->pg_chunk
.offset
= 0;
1133 map
= pci_map_page(qdev
->pdev
, rx_ring
->pg_chunk
.page
,
1134 0, ql_lbq_block_size(qdev
),
1135 PCI_DMA_FROMDEVICE
);
1136 if (pci_dma_mapping_error(qdev
->pdev
, map
)) {
1137 __free_pages(rx_ring
->pg_chunk
.page
,
1138 qdev
->lbq_buf_order
);
1139 netif_err(qdev
, drv
, qdev
->ndev
,
1140 "PCI mapping failed.\n");
1143 rx_ring
->pg_chunk
.map
= map
;
1144 rx_ring
->pg_chunk
.va
= page_address(rx_ring
->pg_chunk
.page
);
1147 /* Copy the current master pg_chunk info
1148 * to the current descriptor.
1150 lbq_desc
->p
.pg_chunk
= rx_ring
->pg_chunk
;
1152 /* Adjust the master page chunk for next
1155 rx_ring
->pg_chunk
.offset
+= rx_ring
->lbq_buf_size
;
1156 if (rx_ring
->pg_chunk
.offset
== ql_lbq_block_size(qdev
)) {
1157 rx_ring
->pg_chunk
.page
= NULL
;
1158 lbq_desc
->p
.pg_chunk
.last_flag
= 1;
1160 rx_ring
->pg_chunk
.va
+= rx_ring
->lbq_buf_size
;
1161 get_page(rx_ring
->pg_chunk
.page
);
1162 lbq_desc
->p
.pg_chunk
.last_flag
= 0;
1166 /* Process (refill) a large buffer queue. */
1167 static void ql_update_lbq(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
)
1169 u32 clean_idx
= rx_ring
->lbq_clean_idx
;
1170 u32 start_idx
= clean_idx
;
1171 struct bq_desc
*lbq_desc
;
1175 while (rx_ring
->lbq_free_cnt
> 32) {
1176 for (i
= 0; i
< 16; i
++) {
1177 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1178 "lbq: try cleaning clean_idx = %d.\n",
1180 lbq_desc
= &rx_ring
->lbq
[clean_idx
];
1181 if (ql_get_next_chunk(qdev
, rx_ring
, lbq_desc
)) {
1182 netif_err(qdev
, ifup
, qdev
->ndev
,
1183 "Could not get a page chunk.\n");
1187 map
= lbq_desc
->p
.pg_chunk
.map
+
1188 lbq_desc
->p
.pg_chunk
.offset
;
1189 dma_unmap_addr_set(lbq_desc
, mapaddr
, map
);
1190 dma_unmap_len_set(lbq_desc
, maplen
,
1191 rx_ring
->lbq_buf_size
);
1192 *lbq_desc
->addr
= cpu_to_le64(map
);
1194 pci_dma_sync_single_for_device(qdev
->pdev
, map
,
1195 rx_ring
->lbq_buf_size
,
1196 PCI_DMA_FROMDEVICE
);
1198 if (clean_idx
== rx_ring
->lbq_len
)
1202 rx_ring
->lbq_clean_idx
= clean_idx
;
1203 rx_ring
->lbq_prod_idx
+= 16;
1204 if (rx_ring
->lbq_prod_idx
== rx_ring
->lbq_len
)
1205 rx_ring
->lbq_prod_idx
= 0;
1206 rx_ring
->lbq_free_cnt
-= 16;
1209 if (start_idx
!= clean_idx
) {
1210 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1211 "lbq: updating prod idx = %d.\n",
1212 rx_ring
->lbq_prod_idx
);
1213 ql_write_db_reg(rx_ring
->lbq_prod_idx
,
1214 rx_ring
->lbq_prod_idx_db_reg
);
1218 /* Process (refill) a small buffer queue. */
1219 static void ql_update_sbq(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
)
1221 u32 clean_idx
= rx_ring
->sbq_clean_idx
;
1222 u32 start_idx
= clean_idx
;
1223 struct bq_desc
*sbq_desc
;
1227 while (rx_ring
->sbq_free_cnt
> 16) {
1228 for (i
= 0; i
< 16; i
++) {
1229 sbq_desc
= &rx_ring
->sbq
[clean_idx
];
1230 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1231 "sbq: try cleaning clean_idx = %d.\n",
1233 if (sbq_desc
->p
.skb
== NULL
) {
1234 netif_printk(qdev
, rx_status
, KERN_DEBUG
,
1236 "sbq: getting new skb for index %d.\n",
1239 netdev_alloc_skb(qdev
->ndev
,
1241 if (sbq_desc
->p
.skb
== NULL
) {
1242 netif_err(qdev
, probe
, qdev
->ndev
,
1243 "Couldn't get an skb.\n");
1244 rx_ring
->sbq_clean_idx
= clean_idx
;
1247 skb_reserve(sbq_desc
->p
.skb
, QLGE_SB_PAD
);
1248 map
= pci_map_single(qdev
->pdev
,
1249 sbq_desc
->p
.skb
->data
,
1250 rx_ring
->sbq_buf_size
,
1251 PCI_DMA_FROMDEVICE
);
1252 if (pci_dma_mapping_error(qdev
->pdev
, map
)) {
1253 netif_err(qdev
, ifup
, qdev
->ndev
,
1254 "PCI mapping failed.\n");
1255 rx_ring
->sbq_clean_idx
= clean_idx
;
1256 dev_kfree_skb_any(sbq_desc
->p
.skb
);
1257 sbq_desc
->p
.skb
= NULL
;
1260 dma_unmap_addr_set(sbq_desc
, mapaddr
, map
);
1261 dma_unmap_len_set(sbq_desc
, maplen
,
1262 rx_ring
->sbq_buf_size
);
1263 *sbq_desc
->addr
= cpu_to_le64(map
);
1267 if (clean_idx
== rx_ring
->sbq_len
)
1270 rx_ring
->sbq_clean_idx
= clean_idx
;
1271 rx_ring
->sbq_prod_idx
+= 16;
1272 if (rx_ring
->sbq_prod_idx
== rx_ring
->sbq_len
)
1273 rx_ring
->sbq_prod_idx
= 0;
1274 rx_ring
->sbq_free_cnt
-= 16;
1277 if (start_idx
!= clean_idx
) {
1278 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1279 "sbq: updating prod idx = %d.\n",
1280 rx_ring
->sbq_prod_idx
);
1281 ql_write_db_reg(rx_ring
->sbq_prod_idx
,
1282 rx_ring
->sbq_prod_idx_db_reg
);
1286 static void ql_update_buffer_queues(struct ql_adapter
*qdev
,
1287 struct rx_ring
*rx_ring
)
1289 ql_update_sbq(qdev
, rx_ring
);
1290 ql_update_lbq(qdev
, rx_ring
);
1293 /* Unmaps tx buffers. Can be called from send() if a pci mapping
1294 * fails at some stage, or from the interrupt when a tx completes.
1296 static void ql_unmap_send(struct ql_adapter
*qdev
,
1297 struct tx_ring_desc
*tx_ring_desc
, int mapped
)
1300 for (i
= 0; i
< mapped
; i
++) {
1301 if (i
== 0 || (i
== 7 && mapped
> 7)) {
1303 * Unmap the skb->data area, or the
1304 * external sglist (AKA the Outbound
1305 * Address List (OAL)).
1306 * If its the zeroeth element, then it's
1307 * the skb->data area. If it's the 7th
1308 * element and there is more than 6 frags,
1312 netif_printk(qdev
, tx_done
, KERN_DEBUG
,
1314 "unmapping OAL area.\n");
1316 pci_unmap_single(qdev
->pdev
,
1317 dma_unmap_addr(&tx_ring_desc
->map
[i
],
1319 dma_unmap_len(&tx_ring_desc
->map
[i
],
1323 netif_printk(qdev
, tx_done
, KERN_DEBUG
, qdev
->ndev
,
1324 "unmapping frag %d.\n", i
);
1325 pci_unmap_page(qdev
->pdev
,
1326 dma_unmap_addr(&tx_ring_desc
->map
[i
],
1328 dma_unmap_len(&tx_ring_desc
->map
[i
],
1329 maplen
), PCI_DMA_TODEVICE
);
1335 /* Map the buffers for this transmit. This will return
1336 * NETDEV_TX_BUSY or NETDEV_TX_OK based on success.
1338 static int ql_map_send(struct ql_adapter
*qdev
,
1339 struct ob_mac_iocb_req
*mac_iocb_ptr
,
1340 struct sk_buff
*skb
, struct tx_ring_desc
*tx_ring_desc
)
1342 int len
= skb_headlen(skb
);
1344 int frag_idx
, err
, map_idx
= 0;
1345 struct tx_buf_desc
*tbd
= mac_iocb_ptr
->tbd
;
1346 int frag_cnt
= skb_shinfo(skb
)->nr_frags
;
1349 netif_printk(qdev
, tx_queued
, KERN_DEBUG
, qdev
->ndev
,
1350 "frag_cnt = %d.\n", frag_cnt
);
1353 * Map the skb buffer first.
1355 map
= pci_map_single(qdev
->pdev
, skb
->data
, len
, PCI_DMA_TODEVICE
);
1357 err
= pci_dma_mapping_error(qdev
->pdev
, map
);
1359 netif_err(qdev
, tx_queued
, qdev
->ndev
,
1360 "PCI mapping failed with error: %d\n", err
);
1362 return NETDEV_TX_BUSY
;
1365 tbd
->len
= cpu_to_le32(len
);
1366 tbd
->addr
= cpu_to_le64(map
);
1367 dma_unmap_addr_set(&tx_ring_desc
->map
[map_idx
], mapaddr
, map
);
1368 dma_unmap_len_set(&tx_ring_desc
->map
[map_idx
], maplen
, len
);
1372 * This loop fills the remainder of the 8 address descriptors
1373 * in the IOCB. If there are more than 7 fragments, then the
1374 * eighth address desc will point to an external list (OAL).
1375 * When this happens, the remainder of the frags will be stored
1378 for (frag_idx
= 0; frag_idx
< frag_cnt
; frag_idx
++, map_idx
++) {
1379 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[frag_idx
];
1381 if (frag_idx
== 6 && frag_cnt
> 7) {
1382 /* Let's tack on an sglist.
1383 * Our control block will now
1385 * iocb->seg[0] = skb->data
1386 * iocb->seg[1] = frag[0]
1387 * iocb->seg[2] = frag[1]
1388 * iocb->seg[3] = frag[2]
1389 * iocb->seg[4] = frag[3]
1390 * iocb->seg[5] = frag[4]
1391 * iocb->seg[6] = frag[5]
1392 * iocb->seg[7] = ptr to OAL (external sglist)
1393 * oal->seg[0] = frag[6]
1394 * oal->seg[1] = frag[7]
1395 * oal->seg[2] = frag[8]
1396 * oal->seg[3] = frag[9]
1397 * oal->seg[4] = frag[10]
1400 /* Tack on the OAL in the eighth segment of IOCB. */
1401 map
= pci_map_single(qdev
->pdev
, &tx_ring_desc
->oal
,
1404 err
= pci_dma_mapping_error(qdev
->pdev
, map
);
1406 netif_err(qdev
, tx_queued
, qdev
->ndev
,
1407 "PCI mapping outbound address list with error: %d\n",
1412 tbd
->addr
= cpu_to_le64(map
);
1414 * The length is the number of fragments
1415 * that remain to be mapped times the length
1416 * of our sglist (OAL).
1419 cpu_to_le32((sizeof(struct tx_buf_desc
) *
1420 (frag_cnt
- frag_idx
)) | TX_DESC_C
);
1421 dma_unmap_addr_set(&tx_ring_desc
->map
[map_idx
], mapaddr
,
1423 dma_unmap_len_set(&tx_ring_desc
->map
[map_idx
], maplen
,
1424 sizeof(struct oal
));
1425 tbd
= (struct tx_buf_desc
*)&tx_ring_desc
->oal
;
1430 pci_map_page(qdev
->pdev
, frag
->page
,
1431 frag
->page_offset
, frag
->size
,
1434 err
= pci_dma_mapping_error(qdev
->pdev
, map
);
1436 netif_err(qdev
, tx_queued
, qdev
->ndev
,
1437 "PCI mapping frags failed with error: %d.\n",
1442 tbd
->addr
= cpu_to_le64(map
);
1443 tbd
->len
= cpu_to_le32(frag
->size
);
1444 dma_unmap_addr_set(&tx_ring_desc
->map
[map_idx
], mapaddr
, map
);
1445 dma_unmap_len_set(&tx_ring_desc
->map
[map_idx
], maplen
,
1449 /* Save the number of segments we've mapped. */
1450 tx_ring_desc
->map_cnt
= map_idx
;
1451 /* Terminate the last segment. */
1452 tbd
->len
= cpu_to_le32(le32_to_cpu(tbd
->len
) | TX_DESC_E
);
1453 return NETDEV_TX_OK
;
1457 * If the first frag mapping failed, then i will be zero.
1458 * This causes the unmap of the skb->data area. Otherwise
1459 * we pass in the number of frags that mapped successfully
1460 * so they can be umapped.
1462 ql_unmap_send(qdev
, tx_ring_desc
, map_idx
);
1463 return NETDEV_TX_BUSY
;
1466 /* Process an inbound completion from an rx ring. */
1467 static void ql_process_mac_rx_gro_page(struct ql_adapter
*qdev
,
1468 struct rx_ring
*rx_ring
,
1469 struct ib_mac_iocb_rsp
*ib_mac_rsp
,
1473 struct sk_buff
*skb
;
1474 struct bq_desc
*lbq_desc
= ql_get_curr_lchunk(qdev
, rx_ring
);
1475 struct skb_frag_struct
*rx_frag
;
1477 struct napi_struct
*napi
= &rx_ring
->napi
;
1479 napi
->dev
= qdev
->ndev
;
1481 skb
= napi_get_frags(napi
);
1483 netif_err(qdev
, drv
, qdev
->ndev
,
1484 "Couldn't get an skb, exiting.\n");
1485 rx_ring
->rx_dropped
++;
1486 put_page(lbq_desc
->p
.pg_chunk
.page
);
1489 prefetch(lbq_desc
->p
.pg_chunk
.va
);
1490 rx_frag
= skb_shinfo(skb
)->frags
;
1491 nr_frags
= skb_shinfo(skb
)->nr_frags
;
1492 rx_frag
+= nr_frags
;
1493 rx_frag
->page
= lbq_desc
->p
.pg_chunk
.page
;
1494 rx_frag
->page_offset
= lbq_desc
->p
.pg_chunk
.offset
;
1495 rx_frag
->size
= length
;
1498 skb
->data_len
+= length
;
1499 skb
->truesize
+= length
;
1500 skb_shinfo(skb
)->nr_frags
++;
1502 rx_ring
->rx_packets
++;
1503 rx_ring
->rx_bytes
+= length
;
1504 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1505 skb_record_rx_queue(skb
, rx_ring
->cq_id
);
1506 if (qdev
->vlgrp
&& (vlan_id
!= 0xffff))
1507 vlan_gro_frags(&rx_ring
->napi
, qdev
->vlgrp
, vlan_id
);
1509 napi_gro_frags(napi
);
1512 /* Process an inbound completion from an rx ring. */
1513 static void ql_process_mac_rx_page(struct ql_adapter
*qdev
,
1514 struct rx_ring
*rx_ring
,
1515 struct ib_mac_iocb_rsp
*ib_mac_rsp
,
1519 struct net_device
*ndev
= qdev
->ndev
;
1520 struct sk_buff
*skb
= NULL
;
1522 struct bq_desc
*lbq_desc
= ql_get_curr_lchunk(qdev
, rx_ring
);
1523 struct napi_struct
*napi
= &rx_ring
->napi
;
1525 skb
= netdev_alloc_skb(ndev
, length
);
1527 netif_err(qdev
, drv
, qdev
->ndev
,
1528 "Couldn't get an skb, need to unwind!.\n");
1529 rx_ring
->rx_dropped
++;
1530 put_page(lbq_desc
->p
.pg_chunk
.page
);
1534 addr
= lbq_desc
->p
.pg_chunk
.va
;
1538 /* Frame error, so drop the packet. */
1539 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_ERR_MASK
) {
1540 netif_info(qdev
, drv
, qdev
->ndev
,
1541 "Receive error, flags2 = 0x%x\n", ib_mac_rsp
->flags2
);
1542 rx_ring
->rx_errors
++;
1546 /* The max framesize filter on this chip is set higher than
1547 * MTU since FCoE uses 2k frames.
1549 if (skb
->len
> ndev
->mtu
+ ETH_HLEN
) {
1550 netif_err(qdev
, drv
, qdev
->ndev
,
1551 "Segment too small, dropping.\n");
1552 rx_ring
->rx_dropped
++;
1555 memcpy(skb_put(skb
, ETH_HLEN
), addr
, ETH_HLEN
);
1556 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1557 "%d bytes of headers and data in large. Chain page to new skb and pull tail.\n",
1559 skb_fill_page_desc(skb
, 0, lbq_desc
->p
.pg_chunk
.page
,
1560 lbq_desc
->p
.pg_chunk
.offset
+ETH_HLEN
,
1562 skb
->len
+= length
-ETH_HLEN
;
1563 skb
->data_len
+= length
-ETH_HLEN
;
1564 skb
->truesize
+= length
-ETH_HLEN
;
1566 rx_ring
->rx_packets
++;
1567 rx_ring
->rx_bytes
+= skb
->len
;
1568 skb
->protocol
= eth_type_trans(skb
, ndev
);
1569 skb
->ip_summed
= CHECKSUM_NONE
;
1571 if (qdev
->rx_csum
&&
1572 !(ib_mac_rsp
->flags1
& IB_MAC_CSUM_ERR_MASK
)) {
1574 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_T
) {
1575 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1576 "TCP checksum done!\n");
1577 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1578 } else if ((ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_U
) &&
1579 (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_V4
)) {
1580 /* Unfragmented ipv4 UDP frame. */
1581 struct iphdr
*iph
= (struct iphdr
*) skb
->data
;
1582 if (!(iph
->frag_off
&
1583 cpu_to_be16(IP_MF
|IP_OFFSET
))) {
1584 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1585 netif_printk(qdev
, rx_status
, KERN_DEBUG
,
1587 "TCP checksum done!\n");
1592 skb_record_rx_queue(skb
, rx_ring
->cq_id
);
1593 if (skb
->ip_summed
== CHECKSUM_UNNECESSARY
) {
1594 if (qdev
->vlgrp
&& (vlan_id
!= 0xffff))
1595 vlan_gro_receive(napi
, qdev
->vlgrp
, vlan_id
, skb
);
1597 napi_gro_receive(napi
, skb
);
1599 if (qdev
->vlgrp
&& (vlan_id
!= 0xffff))
1600 vlan_hwaccel_receive_skb(skb
, qdev
->vlgrp
, vlan_id
);
1602 netif_receive_skb(skb
);
1606 dev_kfree_skb_any(skb
);
1607 put_page(lbq_desc
->p
.pg_chunk
.page
);
1610 /* Process an inbound completion from an rx ring. */
1611 static void ql_process_mac_rx_skb(struct ql_adapter
*qdev
,
1612 struct rx_ring
*rx_ring
,
1613 struct ib_mac_iocb_rsp
*ib_mac_rsp
,
1617 struct net_device
*ndev
= qdev
->ndev
;
1618 struct sk_buff
*skb
= NULL
;
1619 struct sk_buff
*new_skb
= NULL
;
1620 struct bq_desc
*sbq_desc
= ql_get_curr_sbuf(rx_ring
);
1622 skb
= sbq_desc
->p
.skb
;
1623 /* Allocate new_skb and copy */
1624 new_skb
= netdev_alloc_skb(qdev
->ndev
, length
+ NET_IP_ALIGN
);
1625 if (new_skb
== NULL
) {
1626 netif_err(qdev
, probe
, qdev
->ndev
,
1627 "No skb available, drop the packet.\n");
1628 rx_ring
->rx_dropped
++;
1631 skb_reserve(new_skb
, NET_IP_ALIGN
);
1632 memcpy(skb_put(new_skb
, length
), skb
->data
, length
);
1635 /* Frame error, so drop the packet. */
1636 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_ERR_MASK
) {
1637 netif_info(qdev
, drv
, qdev
->ndev
,
1638 "Receive error, flags2 = 0x%x\n", ib_mac_rsp
->flags2
);
1639 dev_kfree_skb_any(skb
);
1640 rx_ring
->rx_errors
++;
1644 /* loopback self test for ethtool */
1645 if (test_bit(QL_SELFTEST
, &qdev
->flags
)) {
1646 ql_check_lb_frame(qdev
, skb
);
1647 dev_kfree_skb_any(skb
);
1651 /* The max framesize filter on this chip is set higher than
1652 * MTU since FCoE uses 2k frames.
1654 if (skb
->len
> ndev
->mtu
+ ETH_HLEN
) {
1655 dev_kfree_skb_any(skb
);
1656 rx_ring
->rx_dropped
++;
1660 prefetch(skb
->data
);
1662 if (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) {
1663 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1665 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1666 IB_MAC_IOCB_RSP_M_HASH
? "Hash" :
1667 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1668 IB_MAC_IOCB_RSP_M_REG
? "Registered" :
1669 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1670 IB_MAC_IOCB_RSP_M_PROM
? "Promiscuous" : "");
1672 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_P
)
1673 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1674 "Promiscuous Packet.\n");
1676 rx_ring
->rx_packets
++;
1677 rx_ring
->rx_bytes
+= skb
->len
;
1678 skb
->protocol
= eth_type_trans(skb
, ndev
);
1679 skb
->ip_summed
= CHECKSUM_NONE
;
1681 /* If rx checksum is on, and there are no
1682 * csum or frame errors.
1684 if (qdev
->rx_csum
&&
1685 !(ib_mac_rsp
->flags1
& IB_MAC_CSUM_ERR_MASK
)) {
1687 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_T
) {
1688 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1689 "TCP checksum done!\n");
1690 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1691 } else if ((ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_U
) &&
1692 (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_V4
)) {
1693 /* Unfragmented ipv4 UDP frame. */
1694 struct iphdr
*iph
= (struct iphdr
*) skb
->data
;
1695 if (!(iph
->frag_off
&
1696 ntohs(IP_MF
|IP_OFFSET
))) {
1697 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1698 netif_printk(qdev
, rx_status
, KERN_DEBUG
,
1700 "TCP checksum done!\n");
1705 skb_record_rx_queue(skb
, rx_ring
->cq_id
);
1706 if (skb
->ip_summed
== CHECKSUM_UNNECESSARY
) {
1707 if (qdev
->vlgrp
&& (vlan_id
!= 0xffff))
1708 vlan_gro_receive(&rx_ring
->napi
, qdev
->vlgrp
,
1711 napi_gro_receive(&rx_ring
->napi
, skb
);
1713 if (qdev
->vlgrp
&& (vlan_id
!= 0xffff))
1714 vlan_hwaccel_receive_skb(skb
, qdev
->vlgrp
, vlan_id
);
1716 netif_receive_skb(skb
);
1720 static void ql_realign_skb(struct sk_buff
*skb
, int len
)
1722 void *temp_addr
= skb
->data
;
1724 /* Undo the skb_reserve(skb,32) we did before
1725 * giving to hardware, and realign data on
1726 * a 2-byte boundary.
1728 skb
->data
-= QLGE_SB_PAD
- NET_IP_ALIGN
;
1729 skb
->tail
-= QLGE_SB_PAD
- NET_IP_ALIGN
;
1730 skb_copy_to_linear_data(skb
, temp_addr
,
1735 * This function builds an skb for the given inbound
1736 * completion. It will be rewritten for readability in the near
1737 * future, but for not it works well.
1739 static struct sk_buff
*ql_build_rx_skb(struct ql_adapter
*qdev
,
1740 struct rx_ring
*rx_ring
,
1741 struct ib_mac_iocb_rsp
*ib_mac_rsp
)
1743 struct bq_desc
*lbq_desc
;
1744 struct bq_desc
*sbq_desc
;
1745 struct sk_buff
*skb
= NULL
;
1746 u32 length
= le32_to_cpu(ib_mac_rsp
->data_len
);
1747 u32 hdr_len
= le32_to_cpu(ib_mac_rsp
->hdr_len
);
1750 * Handle the header buffer if present.
1752 if (ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HV
&&
1753 ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HS
) {
1754 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1755 "Header of %d bytes in small buffer.\n", hdr_len
);
1757 * Headers fit nicely into a small buffer.
1759 sbq_desc
= ql_get_curr_sbuf(rx_ring
);
1760 pci_unmap_single(qdev
->pdev
,
1761 dma_unmap_addr(sbq_desc
, mapaddr
),
1762 dma_unmap_len(sbq_desc
, maplen
),
1763 PCI_DMA_FROMDEVICE
);
1764 skb
= sbq_desc
->p
.skb
;
1765 ql_realign_skb(skb
, hdr_len
);
1766 skb_put(skb
, hdr_len
);
1767 sbq_desc
->p
.skb
= NULL
;
1771 * Handle the data buffer(s).
1773 if (unlikely(!length
)) { /* Is there data too? */
1774 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1775 "No Data buffer in this packet.\n");
1779 if (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_DS
) {
1780 if (ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HS
) {
1781 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1782 "Headers in small, data of %d bytes in small, combine them.\n",
1785 * Data is less than small buffer size so it's
1786 * stuffed in a small buffer.
1787 * For this case we append the data
1788 * from the "data" small buffer to the "header" small
1791 sbq_desc
= ql_get_curr_sbuf(rx_ring
);
1792 pci_dma_sync_single_for_cpu(qdev
->pdev
,
1794 (sbq_desc
, mapaddr
),
1797 PCI_DMA_FROMDEVICE
);
1798 memcpy(skb_put(skb
, length
),
1799 sbq_desc
->p
.skb
->data
, length
);
1800 pci_dma_sync_single_for_device(qdev
->pdev
,
1807 PCI_DMA_FROMDEVICE
);
1809 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1810 "%d bytes in a single small buffer.\n",
1812 sbq_desc
= ql_get_curr_sbuf(rx_ring
);
1813 skb
= sbq_desc
->p
.skb
;
1814 ql_realign_skb(skb
, length
);
1815 skb_put(skb
, length
);
1816 pci_unmap_single(qdev
->pdev
,
1817 dma_unmap_addr(sbq_desc
,
1819 dma_unmap_len(sbq_desc
,
1821 PCI_DMA_FROMDEVICE
);
1822 sbq_desc
->p
.skb
= NULL
;
1824 } else if (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_DL
) {
1825 if (ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HS
) {
1826 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1827 "Header in small, %d bytes in large. Chain large to small!\n",
1830 * The data is in a single large buffer. We
1831 * chain it to the header buffer's skb and let
1834 lbq_desc
= ql_get_curr_lchunk(qdev
, rx_ring
);
1835 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1836 "Chaining page at offset = %d, for %d bytes to skb.\n",
1837 lbq_desc
->p
.pg_chunk
.offset
, length
);
1838 skb_fill_page_desc(skb
, 0, lbq_desc
->p
.pg_chunk
.page
,
1839 lbq_desc
->p
.pg_chunk
.offset
,
1842 skb
->data_len
+= length
;
1843 skb
->truesize
+= length
;
1846 * The headers and data are in a single large buffer. We
1847 * copy it to a new skb and let it go. This can happen with
1848 * jumbo mtu on a non-TCP/UDP frame.
1850 lbq_desc
= ql_get_curr_lchunk(qdev
, rx_ring
);
1851 skb
= netdev_alloc_skb(qdev
->ndev
, length
);
1853 netif_printk(qdev
, probe
, KERN_DEBUG
, qdev
->ndev
,
1854 "No skb available, drop the packet.\n");
1857 pci_unmap_page(qdev
->pdev
,
1858 dma_unmap_addr(lbq_desc
,
1860 dma_unmap_len(lbq_desc
, maplen
),
1861 PCI_DMA_FROMDEVICE
);
1862 skb_reserve(skb
, NET_IP_ALIGN
);
1863 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1864 "%d bytes of headers and data in large. Chain page to new skb and pull tail.\n",
1866 skb_fill_page_desc(skb
, 0,
1867 lbq_desc
->p
.pg_chunk
.page
,
1868 lbq_desc
->p
.pg_chunk
.offset
,
1871 skb
->data_len
+= length
;
1872 skb
->truesize
+= length
;
1874 __pskb_pull_tail(skb
,
1875 (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_V
) ?
1876 VLAN_ETH_HLEN
: ETH_HLEN
);
1880 * The data is in a chain of large buffers
1881 * pointed to by a small buffer. We loop
1882 * thru and chain them to the our small header
1884 * frags: There are 18 max frags and our small
1885 * buffer will hold 32 of them. The thing is,
1886 * we'll use 3 max for our 9000 byte jumbo
1887 * frames. If the MTU goes up we could
1888 * eventually be in trouble.
1891 sbq_desc
= ql_get_curr_sbuf(rx_ring
);
1892 pci_unmap_single(qdev
->pdev
,
1893 dma_unmap_addr(sbq_desc
, mapaddr
),
1894 dma_unmap_len(sbq_desc
, maplen
),
1895 PCI_DMA_FROMDEVICE
);
1896 if (!(ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HS
)) {
1898 * This is an non TCP/UDP IP frame, so
1899 * the headers aren't split into a small
1900 * buffer. We have to use the small buffer
1901 * that contains our sg list as our skb to
1902 * send upstairs. Copy the sg list here to
1903 * a local buffer and use it to find the
1906 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1907 "%d bytes of headers & data in chain of large.\n",
1909 skb
= sbq_desc
->p
.skb
;
1910 sbq_desc
->p
.skb
= NULL
;
1911 skb_reserve(skb
, NET_IP_ALIGN
);
1913 while (length
> 0) {
1914 lbq_desc
= ql_get_curr_lchunk(qdev
, rx_ring
);
1915 size
= (length
< rx_ring
->lbq_buf_size
) ? length
:
1916 rx_ring
->lbq_buf_size
;
1918 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1919 "Adding page %d to skb for %d bytes.\n",
1921 skb_fill_page_desc(skb
, i
,
1922 lbq_desc
->p
.pg_chunk
.page
,
1923 lbq_desc
->p
.pg_chunk
.offset
,
1926 skb
->data_len
+= size
;
1927 skb
->truesize
+= size
;
1931 __pskb_pull_tail(skb
, (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_V
) ?
1932 VLAN_ETH_HLEN
: ETH_HLEN
);
1937 /* Process an inbound completion from an rx ring. */
1938 static void ql_process_mac_split_rx_intr(struct ql_adapter
*qdev
,
1939 struct rx_ring
*rx_ring
,
1940 struct ib_mac_iocb_rsp
*ib_mac_rsp
,
1943 struct net_device
*ndev
= qdev
->ndev
;
1944 struct sk_buff
*skb
= NULL
;
1946 QL_DUMP_IB_MAC_RSP(ib_mac_rsp
);
1948 skb
= ql_build_rx_skb(qdev
, rx_ring
, ib_mac_rsp
);
1949 if (unlikely(!skb
)) {
1950 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1951 "No skb available, drop packet.\n");
1952 rx_ring
->rx_dropped
++;
1956 /* Frame error, so drop the packet. */
1957 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_ERR_MASK
) {
1958 netif_info(qdev
, drv
, qdev
->ndev
,
1959 "Receive error, flags2 = 0x%x\n", ib_mac_rsp
->flags2
);
1960 dev_kfree_skb_any(skb
);
1961 rx_ring
->rx_errors
++;
1965 /* The max framesize filter on this chip is set higher than
1966 * MTU since FCoE uses 2k frames.
1968 if (skb
->len
> ndev
->mtu
+ ETH_HLEN
) {
1969 dev_kfree_skb_any(skb
);
1970 rx_ring
->rx_dropped
++;
1974 /* loopback self test for ethtool */
1975 if (test_bit(QL_SELFTEST
, &qdev
->flags
)) {
1976 ql_check_lb_frame(qdev
, skb
);
1977 dev_kfree_skb_any(skb
);
1981 prefetch(skb
->data
);
1983 if (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) {
1984 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
, "%s Multicast.\n",
1985 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1986 IB_MAC_IOCB_RSP_M_HASH
? "Hash" :
1987 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1988 IB_MAC_IOCB_RSP_M_REG
? "Registered" :
1989 (ib_mac_rsp
->flags1
& IB_MAC_IOCB_RSP_M_MASK
) ==
1990 IB_MAC_IOCB_RSP_M_PROM
? "Promiscuous" : "");
1991 rx_ring
->rx_multicast
++;
1993 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_P
) {
1994 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
1995 "Promiscuous Packet.\n");
1998 skb
->protocol
= eth_type_trans(skb
, ndev
);
1999 skb
->ip_summed
= CHECKSUM_NONE
;
2001 /* If rx checksum is on, and there are no
2002 * csum or frame errors.
2004 if (qdev
->rx_csum
&&
2005 !(ib_mac_rsp
->flags1
& IB_MAC_CSUM_ERR_MASK
)) {
2007 if (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_T
) {
2008 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2009 "TCP checksum done!\n");
2010 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2011 } else if ((ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_U
) &&
2012 (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_V4
)) {
2013 /* Unfragmented ipv4 UDP frame. */
2014 struct iphdr
*iph
= (struct iphdr
*) skb
->data
;
2015 if (!(iph
->frag_off
&
2016 ntohs(IP_MF
|IP_OFFSET
))) {
2017 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
2018 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2019 "TCP checksum done!\n");
2024 rx_ring
->rx_packets
++;
2025 rx_ring
->rx_bytes
+= skb
->len
;
2026 skb_record_rx_queue(skb
, rx_ring
->cq_id
);
2027 if (skb
->ip_summed
== CHECKSUM_UNNECESSARY
) {
2029 (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_V
) &&
2031 vlan_gro_receive(&rx_ring
->napi
, qdev
->vlgrp
,
2034 napi_gro_receive(&rx_ring
->napi
, skb
);
2037 (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_V
) &&
2039 vlan_hwaccel_receive_skb(skb
, qdev
->vlgrp
, vlan_id
);
2041 netif_receive_skb(skb
);
2045 /* Process an inbound completion from an rx ring. */
2046 static unsigned long ql_process_mac_rx_intr(struct ql_adapter
*qdev
,
2047 struct rx_ring
*rx_ring
,
2048 struct ib_mac_iocb_rsp
*ib_mac_rsp
)
2050 u32 length
= le32_to_cpu(ib_mac_rsp
->data_len
);
2051 u16 vlan_id
= (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_V
) ?
2052 ((le16_to_cpu(ib_mac_rsp
->vlan_id
) &
2053 IB_MAC_IOCB_RSP_VLAN_MASK
)) : 0xffff;
2055 QL_DUMP_IB_MAC_RSP(ib_mac_rsp
);
2057 if (ib_mac_rsp
->flags4
& IB_MAC_IOCB_RSP_HV
) {
2058 /* The data and headers are split into
2061 ql_process_mac_split_rx_intr(qdev
, rx_ring
, ib_mac_rsp
,
2063 } else if (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_DS
) {
2064 /* The data fit in a single small buffer.
2065 * Allocate a new skb, copy the data and
2066 * return the buffer to the free pool.
2068 ql_process_mac_rx_skb(qdev
, rx_ring
, ib_mac_rsp
,
2070 } else if ((ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_DL
) &&
2071 !(ib_mac_rsp
->flags1
& IB_MAC_CSUM_ERR_MASK
) &&
2072 (ib_mac_rsp
->flags2
& IB_MAC_IOCB_RSP_T
)) {
2073 /* TCP packet in a page chunk that's been checksummed.
2074 * Tack it on to our GRO skb and let it go.
2076 ql_process_mac_rx_gro_page(qdev
, rx_ring
, ib_mac_rsp
,
2078 } else if (ib_mac_rsp
->flags3
& IB_MAC_IOCB_RSP_DL
) {
2079 /* Non-TCP packet in a page chunk. Allocate an
2080 * skb, tack it on frags, and send it up.
2082 ql_process_mac_rx_page(qdev
, rx_ring
, ib_mac_rsp
,
2085 /* Non-TCP/UDP large frames that span multiple buffers
2086 * can be processed corrrectly by the split frame logic.
2088 ql_process_mac_split_rx_intr(qdev
, rx_ring
, ib_mac_rsp
,
2092 return (unsigned long)length
;
2095 /* Process an outbound completion from an rx ring. */
2096 static void ql_process_mac_tx_intr(struct ql_adapter
*qdev
,
2097 struct ob_mac_iocb_rsp
*mac_rsp
)
2099 struct tx_ring
*tx_ring
;
2100 struct tx_ring_desc
*tx_ring_desc
;
2102 QL_DUMP_OB_MAC_RSP(mac_rsp
);
2103 tx_ring
= &qdev
->tx_ring
[mac_rsp
->txq_idx
];
2104 tx_ring_desc
= &tx_ring
->q
[mac_rsp
->tid
];
2105 ql_unmap_send(qdev
, tx_ring_desc
, tx_ring_desc
->map_cnt
);
2106 tx_ring
->tx_bytes
+= (tx_ring_desc
->skb
)->len
;
2107 tx_ring
->tx_packets
++;
2108 dev_kfree_skb(tx_ring_desc
->skb
);
2109 tx_ring_desc
->skb
= NULL
;
2111 if (unlikely(mac_rsp
->flags1
& (OB_MAC_IOCB_RSP_E
|
2114 OB_MAC_IOCB_RSP_P
| OB_MAC_IOCB_RSP_B
))) {
2115 if (mac_rsp
->flags1
& OB_MAC_IOCB_RSP_E
) {
2116 netif_warn(qdev
, tx_done
, qdev
->ndev
,
2117 "Total descriptor length did not match transfer length.\n");
2119 if (mac_rsp
->flags1
& OB_MAC_IOCB_RSP_S
) {
2120 netif_warn(qdev
, tx_done
, qdev
->ndev
,
2121 "Frame too short to be valid, not sent.\n");
2123 if (mac_rsp
->flags1
& OB_MAC_IOCB_RSP_L
) {
2124 netif_warn(qdev
, tx_done
, qdev
->ndev
,
2125 "Frame too long, but sent anyway.\n");
2127 if (mac_rsp
->flags1
& OB_MAC_IOCB_RSP_B
) {
2128 netif_warn(qdev
, tx_done
, qdev
->ndev
,
2129 "PCI backplane error. Frame not sent.\n");
2132 atomic_inc(&tx_ring
->tx_count
);
2135 /* Fire up a handler to reset the MPI processor. */
2136 void ql_queue_fw_error(struct ql_adapter
*qdev
)
2139 queue_delayed_work(qdev
->workqueue
, &qdev
->mpi_reset_work
, 0);
2142 void ql_queue_asic_error(struct ql_adapter
*qdev
)
2145 ql_disable_interrupts(qdev
);
2146 /* Clear adapter up bit to signal the recovery
2147 * process that it shouldn't kill the reset worker
2150 clear_bit(QL_ADAPTER_UP
, &qdev
->flags
);
2151 queue_delayed_work(qdev
->workqueue
, &qdev
->asic_reset_work
, 0);
2154 static void ql_process_chip_ae_intr(struct ql_adapter
*qdev
,
2155 struct ib_ae_iocb_rsp
*ib_ae_rsp
)
2157 switch (ib_ae_rsp
->event
) {
2158 case MGMT_ERR_EVENT
:
2159 netif_err(qdev
, rx_err
, qdev
->ndev
,
2160 "Management Processor Fatal Error.\n");
2161 ql_queue_fw_error(qdev
);
2164 case CAM_LOOKUP_ERR_EVENT
:
2165 netif_err(qdev
, link
, qdev
->ndev
,
2166 "Multiple CAM hits lookup occurred.\n");
2167 netif_err(qdev
, drv
, qdev
->ndev
,
2168 "This event shouldn't occur.\n");
2169 ql_queue_asic_error(qdev
);
2172 case SOFT_ECC_ERROR_EVENT
:
2173 netif_err(qdev
, rx_err
, qdev
->ndev
,
2174 "Soft ECC error detected.\n");
2175 ql_queue_asic_error(qdev
);
2178 case PCI_ERR_ANON_BUF_RD
:
2179 netif_err(qdev
, rx_err
, qdev
->ndev
,
2180 "PCI error occurred when reading anonymous buffers from rx_ring %d.\n",
2182 ql_queue_asic_error(qdev
);
2186 netif_err(qdev
, drv
, qdev
->ndev
, "Unexpected event %d.\n",
2188 ql_queue_asic_error(qdev
);
2193 static int ql_clean_outbound_rx_ring(struct rx_ring
*rx_ring
)
2195 struct ql_adapter
*qdev
= rx_ring
->qdev
;
2196 u32 prod
= ql_read_sh_reg(rx_ring
->prod_idx_sh_reg
);
2197 struct ob_mac_iocb_rsp
*net_rsp
= NULL
;
2200 struct tx_ring
*tx_ring
;
2201 /* While there are entries in the completion queue. */
2202 while (prod
!= rx_ring
->cnsmr_idx
) {
2204 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2205 "cq_id = %d, prod = %d, cnsmr = %d.\n.",
2206 rx_ring
->cq_id
, prod
, rx_ring
->cnsmr_idx
);
2208 net_rsp
= (struct ob_mac_iocb_rsp
*)rx_ring
->curr_entry
;
2210 switch (net_rsp
->opcode
) {
2212 case OPCODE_OB_MAC_TSO_IOCB
:
2213 case OPCODE_OB_MAC_IOCB
:
2214 ql_process_mac_tx_intr(qdev
, net_rsp
);
2217 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2218 "Hit default case, not handled! dropping the packet, opcode = %x.\n",
2222 ql_update_cq(rx_ring
);
2223 prod
= ql_read_sh_reg(rx_ring
->prod_idx_sh_reg
);
2225 ql_write_cq_idx(rx_ring
);
2226 tx_ring
= &qdev
->tx_ring
[net_rsp
->txq_idx
];
2227 if (__netif_subqueue_stopped(qdev
->ndev
, tx_ring
->wq_id
) &&
2229 if (atomic_read(&tx_ring
->queue_stopped
) &&
2230 (atomic_read(&tx_ring
->tx_count
) > (tx_ring
->wq_len
/ 4)))
2232 * The queue got stopped because the tx_ring was full.
2233 * Wake it up, because it's now at least 25% empty.
2235 netif_wake_subqueue(qdev
->ndev
, tx_ring
->wq_id
);
2241 static int ql_clean_inbound_rx_ring(struct rx_ring
*rx_ring
, int budget
)
2243 struct ql_adapter
*qdev
= rx_ring
->qdev
;
2244 u32 prod
= ql_read_sh_reg(rx_ring
->prod_idx_sh_reg
);
2245 struct ql_net_rsp_iocb
*net_rsp
;
2248 /* While there are entries in the completion queue. */
2249 while (prod
!= rx_ring
->cnsmr_idx
) {
2251 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2252 "cq_id = %d, prod = %d, cnsmr = %d.\n.",
2253 rx_ring
->cq_id
, prod
, rx_ring
->cnsmr_idx
);
2255 net_rsp
= rx_ring
->curr_entry
;
2257 switch (net_rsp
->opcode
) {
2258 case OPCODE_IB_MAC_IOCB
:
2259 ql_process_mac_rx_intr(qdev
, rx_ring
,
2260 (struct ib_mac_iocb_rsp
*)
2264 case OPCODE_IB_AE_IOCB
:
2265 ql_process_chip_ae_intr(qdev
, (struct ib_ae_iocb_rsp
*)
2269 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2270 "Hit default case, not handled! dropping the packet, opcode = %x.\n",
2275 ql_update_cq(rx_ring
);
2276 prod
= ql_read_sh_reg(rx_ring
->prod_idx_sh_reg
);
2277 if (count
== budget
)
2280 ql_update_buffer_queues(qdev
, rx_ring
);
2281 ql_write_cq_idx(rx_ring
);
2285 static int ql_napi_poll_msix(struct napi_struct
*napi
, int budget
)
2287 struct rx_ring
*rx_ring
= container_of(napi
, struct rx_ring
, napi
);
2288 struct ql_adapter
*qdev
= rx_ring
->qdev
;
2289 struct rx_ring
*trx_ring
;
2290 int i
, work_done
= 0;
2291 struct intr_context
*ctx
= &qdev
->intr_context
[rx_ring
->cq_id
];
2293 netif_printk(qdev
, rx_status
, KERN_DEBUG
, qdev
->ndev
,
2294 "Enter, NAPI POLL cq_id = %d.\n", rx_ring
->cq_id
);
2296 /* Service the TX rings first. They start
2297 * right after the RSS rings. */
2298 for (i
= qdev
->rss_ring_count
; i
< qdev
->rx_ring_count
; i
++) {
2299 trx_ring
= &qdev
->rx_ring
[i
];
2300 /* If this TX completion ring belongs to this vector and
2301 * it's not empty then service it.
2303 if ((ctx
->irq_mask
& (1 << trx_ring
->cq_id
)) &&
2304 (ql_read_sh_reg(trx_ring
->prod_idx_sh_reg
) !=
2305 trx_ring
->cnsmr_idx
)) {
2306 netif_printk(qdev
, intr
, KERN_DEBUG
, qdev
->ndev
,
2307 "%s: Servicing TX completion ring %d.\n",
2308 __func__
, trx_ring
->cq_id
);
2309 ql_clean_outbound_rx_ring(trx_ring
);
2314 * Now service the RSS ring if it's active.
2316 if (ql_read_sh_reg(rx_ring
->prod_idx_sh_reg
) !=
2317 rx_ring
->cnsmr_idx
) {
2318 netif_printk(qdev
, intr
, KERN_DEBUG
, qdev
->ndev
,
2319 "%s: Servicing RX completion ring %d.\n",
2320 __func__
, rx_ring
->cq_id
);
2321 work_done
= ql_clean_inbound_rx_ring(rx_ring
, budget
);
2324 if (work_done
< budget
) {
2325 napi_complete(napi
);
2326 ql_enable_completion_interrupt(qdev
, rx_ring
->irq
);
2331 static void qlge_vlan_rx_register(struct net_device
*ndev
, struct vlan_group
*grp
)
2333 struct ql_adapter
*qdev
= netdev_priv(ndev
);
2337 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
2338 "Turning on VLAN in NIC_RCV_CFG.\n");
2339 ql_write32(qdev
, NIC_RCV_CFG
, NIC_RCV_CFG_VLAN_MASK
|
2340 NIC_RCV_CFG_VLAN_MATCH_AND_NON
);
2342 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
2343 "Turning off VLAN in NIC_RCV_CFG.\n");
2344 ql_write32(qdev
, NIC_RCV_CFG
, NIC_RCV_CFG_VLAN_MASK
);
2348 static void qlge_vlan_rx_add_vid(struct net_device
*ndev
, u16 vid
)
2350 struct ql_adapter
*qdev
= netdev_priv(ndev
);
2351 u32 enable_bit
= MAC_ADDR_E
;
2354 status
= ql_sem_spinlock(qdev
, SEM_MAC_ADDR_MASK
);
2357 if (ql_set_mac_addr_reg
2358 (qdev
, (u8
*) &enable_bit
, MAC_ADDR_TYPE_VLAN
, vid
)) {
2359 netif_err(qdev
, ifup
, qdev
->ndev
,
2360 "Failed to init vlan address.\n");
2362 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
2365 static void qlge_vlan_rx_kill_vid(struct net_device
*ndev
, u16 vid
)
2367 struct ql_adapter
*qdev
= netdev_priv(ndev
);
2371 status
= ql_sem_spinlock(qdev
, SEM_MAC_ADDR_MASK
);
2375 if (ql_set_mac_addr_reg
2376 (qdev
, (u8
*) &enable_bit
, MAC_ADDR_TYPE_VLAN
, vid
)) {
2377 netif_err(qdev
, ifup
, qdev
->ndev
,
2378 "Failed to clear vlan address.\n");
2380 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
2384 /* MSI-X Multiple Vector Interrupt Handler for inbound completions. */
2385 static irqreturn_t
qlge_msix_rx_isr(int irq
, void *dev_id
)
2387 struct rx_ring
*rx_ring
= dev_id
;
2388 napi_schedule(&rx_ring
->napi
);
2392 /* This handles a fatal error, MPI activity, and the default
2393 * rx_ring in an MSI-X multiple vector environment.
2394 * In MSI/Legacy environment it also process the rest of
2397 static irqreturn_t
qlge_isr(int irq
, void *dev_id
)
2399 struct rx_ring
*rx_ring
= dev_id
;
2400 struct ql_adapter
*qdev
= rx_ring
->qdev
;
2401 struct intr_context
*intr_context
= &qdev
->intr_context
[0];
2405 spin_lock(&qdev
->hw_lock
);
2406 if (atomic_read(&qdev
->intr_context
[0].irq_cnt
)) {
2407 netif_printk(qdev
, intr
, KERN_DEBUG
, qdev
->ndev
,
2408 "Shared Interrupt, Not ours!\n");
2409 spin_unlock(&qdev
->hw_lock
);
2412 spin_unlock(&qdev
->hw_lock
);
2414 var
= ql_disable_completion_interrupt(qdev
, intr_context
->intr
);
2417 * Check for fatal error.
2420 ql_queue_asic_error(qdev
);
2421 netif_err(qdev
, intr
, qdev
->ndev
,
2422 "Got fatal error, STS = %x.\n", var
);
2423 var
= ql_read32(qdev
, ERR_STS
);
2424 netif_err(qdev
, intr
, qdev
->ndev
,
2425 "Resetting chip. Error Status Register = 0x%x\n", var
);
2430 * Check MPI processor activity.
2432 if ((var
& STS_PI
) &&
2433 (ql_read32(qdev
, INTR_MASK
) & INTR_MASK_PI
)) {
2435 * We've got an async event or mailbox completion.
2436 * Handle it and clear the source of the interrupt.
2438 netif_err(qdev
, intr
, qdev
->ndev
,
2439 "Got MPI processor interrupt.\n");
2440 ql_disable_completion_interrupt(qdev
, intr_context
->intr
);
2441 ql_write32(qdev
, INTR_MASK
, (INTR_MASK_PI
<< 16));
2442 queue_delayed_work_on(smp_processor_id(),
2443 qdev
->workqueue
, &qdev
->mpi_work
, 0);
2448 * Get the bit-mask that shows the active queues for this
2449 * pass. Compare it to the queues that this irq services
2450 * and call napi if there's a match.
2452 var
= ql_read32(qdev
, ISR1
);
2453 if (var
& intr_context
->irq_mask
) {
2454 netif_info(qdev
, intr
, qdev
->ndev
,
2455 "Waking handler for rx_ring[0].\n");
2456 ql_disable_completion_interrupt(qdev
, intr_context
->intr
);
2457 napi_schedule(&rx_ring
->napi
);
2460 ql_enable_completion_interrupt(qdev
, intr_context
->intr
);
2461 return work_done
? IRQ_HANDLED
: IRQ_NONE
;
2464 static int ql_tso(struct sk_buff
*skb
, struct ob_mac_tso_iocb_req
*mac_iocb_ptr
)
2467 if (skb_is_gso(skb
)) {
2469 if (skb_header_cloned(skb
)) {
2470 err
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
);
2475 mac_iocb_ptr
->opcode
= OPCODE_OB_MAC_TSO_IOCB
;
2476 mac_iocb_ptr
->flags3
|= OB_MAC_TSO_IOCB_IC
;
2477 mac_iocb_ptr
->frame_len
= cpu_to_le32((u32
) skb
->len
);
2478 mac_iocb_ptr
->total_hdrs_len
=
2479 cpu_to_le16(skb_transport_offset(skb
) + tcp_hdrlen(skb
));
2480 mac_iocb_ptr
->net_trans_offset
=
2481 cpu_to_le16(skb_network_offset(skb
) |
2482 skb_transport_offset(skb
)
2483 << OB_MAC_TRANSPORT_HDR_SHIFT
);
2484 mac_iocb_ptr
->mss
= cpu_to_le16(skb_shinfo(skb
)->gso_size
);
2485 mac_iocb_ptr
->flags2
|= OB_MAC_TSO_IOCB_LSO
;
2486 if (likely(skb
->protocol
== htons(ETH_P_IP
))) {
2487 struct iphdr
*iph
= ip_hdr(skb
);
2489 mac_iocb_ptr
->flags1
|= OB_MAC_TSO_IOCB_IP4
;
2490 tcp_hdr(skb
)->check
= ~csum_tcpudp_magic(iph
->saddr
,
2494 } else if (skb
->protocol
== htons(ETH_P_IPV6
)) {
2495 mac_iocb_ptr
->flags1
|= OB_MAC_TSO_IOCB_IP6
;
2496 tcp_hdr(skb
)->check
=
2497 ~csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
2498 &ipv6_hdr(skb
)->daddr
,
2506 static void ql_hw_csum_setup(struct sk_buff
*skb
,
2507 struct ob_mac_tso_iocb_req
*mac_iocb_ptr
)
2510 struct iphdr
*iph
= ip_hdr(skb
);
2512 mac_iocb_ptr
->opcode
= OPCODE_OB_MAC_TSO_IOCB
;
2513 mac_iocb_ptr
->frame_len
= cpu_to_le32((u32
) skb
->len
);
2514 mac_iocb_ptr
->net_trans_offset
=
2515 cpu_to_le16(skb_network_offset(skb
) |
2516 skb_transport_offset(skb
) << OB_MAC_TRANSPORT_HDR_SHIFT
);
2518 mac_iocb_ptr
->flags1
|= OB_MAC_TSO_IOCB_IP4
;
2519 len
= (ntohs(iph
->tot_len
) - (iph
->ihl
<< 2));
2520 if (likely(iph
->protocol
== IPPROTO_TCP
)) {
2521 check
= &(tcp_hdr(skb
)->check
);
2522 mac_iocb_ptr
->flags2
|= OB_MAC_TSO_IOCB_TC
;
2523 mac_iocb_ptr
->total_hdrs_len
=
2524 cpu_to_le16(skb_transport_offset(skb
) +
2525 (tcp_hdr(skb
)->doff
<< 2));
2527 check
= &(udp_hdr(skb
)->check
);
2528 mac_iocb_ptr
->flags2
|= OB_MAC_TSO_IOCB_UC
;
2529 mac_iocb_ptr
->total_hdrs_len
=
2530 cpu_to_le16(skb_transport_offset(skb
) +
2531 sizeof(struct udphdr
));
2533 *check
= ~csum_tcpudp_magic(iph
->saddr
,
2534 iph
->daddr
, len
, iph
->protocol
, 0);
2537 static netdev_tx_t
qlge_send(struct sk_buff
*skb
, struct net_device
*ndev
)
2539 struct tx_ring_desc
*tx_ring_desc
;
2540 struct ob_mac_iocb_req
*mac_iocb_ptr
;
2541 struct ql_adapter
*qdev
= netdev_priv(ndev
);
2543 struct tx_ring
*tx_ring
;
2544 u32 tx_ring_idx
= (u32
) skb
->queue_mapping
;
2546 tx_ring
= &qdev
->tx_ring
[tx_ring_idx
];
2548 if (skb_padto(skb
, ETH_ZLEN
))
2549 return NETDEV_TX_OK
;
2551 if (unlikely(atomic_read(&tx_ring
->tx_count
) < 2)) {
2552 netif_info(qdev
, tx_queued
, qdev
->ndev
,
2553 "%s: shutting down tx queue %d du to lack of resources.\n",
2554 __func__
, tx_ring_idx
);
2555 netif_stop_subqueue(ndev
, tx_ring
->wq_id
);
2556 atomic_inc(&tx_ring
->queue_stopped
);
2557 tx_ring
->tx_errors
++;
2558 return NETDEV_TX_BUSY
;
2560 tx_ring_desc
= &tx_ring
->q
[tx_ring
->prod_idx
];
2561 mac_iocb_ptr
= tx_ring_desc
->queue_entry
;
2562 memset((void *)mac_iocb_ptr
, 0, sizeof(*mac_iocb_ptr
));
2564 mac_iocb_ptr
->opcode
= OPCODE_OB_MAC_IOCB
;
2565 mac_iocb_ptr
->tid
= tx_ring_desc
->index
;
2566 /* We use the upper 32-bits to store the tx queue for this IO.
2567 * When we get the completion we can use it to establish the context.
2569 mac_iocb_ptr
->txq_idx
= tx_ring_idx
;
2570 tx_ring_desc
->skb
= skb
;
2572 mac_iocb_ptr
->frame_len
= cpu_to_le16((u16
) skb
->len
);
2574 if (qdev
->vlgrp
&& vlan_tx_tag_present(skb
)) {
2575 netif_printk(qdev
, tx_queued
, KERN_DEBUG
, qdev
->ndev
,
2576 "Adding a vlan tag %d.\n", vlan_tx_tag_get(skb
));
2577 mac_iocb_ptr
->flags3
|= OB_MAC_IOCB_V
;
2578 mac_iocb_ptr
->vlan_tci
= cpu_to_le16(vlan_tx_tag_get(skb
));
2580 tso
= ql_tso(skb
, (struct ob_mac_tso_iocb_req
*)mac_iocb_ptr
);
2582 dev_kfree_skb_any(skb
);
2583 return NETDEV_TX_OK
;
2584 } else if (unlikely(!tso
) && (skb
->ip_summed
== CHECKSUM_PARTIAL
)) {
2585 ql_hw_csum_setup(skb
,
2586 (struct ob_mac_tso_iocb_req
*)mac_iocb_ptr
);
2588 if (ql_map_send(qdev
, mac_iocb_ptr
, skb
, tx_ring_desc
) !=
2590 netif_err(qdev
, tx_queued
, qdev
->ndev
,
2591 "Could not map the segments.\n");
2592 tx_ring
->tx_errors
++;
2593 return NETDEV_TX_BUSY
;
2595 QL_DUMP_OB_MAC_IOCB(mac_iocb_ptr
);
2596 tx_ring
->prod_idx
++;
2597 if (tx_ring
->prod_idx
== tx_ring
->wq_len
)
2598 tx_ring
->prod_idx
= 0;
2601 ql_write_db_reg(tx_ring
->prod_idx
, tx_ring
->prod_idx_db_reg
);
2602 netif_printk(qdev
, tx_queued
, KERN_DEBUG
, qdev
->ndev
,
2603 "tx queued, slot %d, len %d\n",
2604 tx_ring
->prod_idx
, skb
->len
);
2606 atomic_dec(&tx_ring
->tx_count
);
2607 return NETDEV_TX_OK
;
2611 static void ql_free_shadow_space(struct ql_adapter
*qdev
)
2613 if (qdev
->rx_ring_shadow_reg_area
) {
2614 pci_free_consistent(qdev
->pdev
,
2616 qdev
->rx_ring_shadow_reg_area
,
2617 qdev
->rx_ring_shadow_reg_dma
);
2618 qdev
->rx_ring_shadow_reg_area
= NULL
;
2620 if (qdev
->tx_ring_shadow_reg_area
) {
2621 pci_free_consistent(qdev
->pdev
,
2623 qdev
->tx_ring_shadow_reg_area
,
2624 qdev
->tx_ring_shadow_reg_dma
);
2625 qdev
->tx_ring_shadow_reg_area
= NULL
;
2629 static int ql_alloc_shadow_space(struct ql_adapter
*qdev
)
2631 qdev
->rx_ring_shadow_reg_area
=
2632 pci_alloc_consistent(qdev
->pdev
,
2633 PAGE_SIZE
, &qdev
->rx_ring_shadow_reg_dma
);
2634 if (qdev
->rx_ring_shadow_reg_area
== NULL
) {
2635 netif_err(qdev
, ifup
, qdev
->ndev
,
2636 "Allocation of RX shadow space failed.\n");
2639 memset(qdev
->rx_ring_shadow_reg_area
, 0, PAGE_SIZE
);
2640 qdev
->tx_ring_shadow_reg_area
=
2641 pci_alloc_consistent(qdev
->pdev
, PAGE_SIZE
,
2642 &qdev
->tx_ring_shadow_reg_dma
);
2643 if (qdev
->tx_ring_shadow_reg_area
== NULL
) {
2644 netif_err(qdev
, ifup
, qdev
->ndev
,
2645 "Allocation of TX shadow space failed.\n");
2646 goto err_wqp_sh_area
;
2648 memset(qdev
->tx_ring_shadow_reg_area
, 0, PAGE_SIZE
);
2652 pci_free_consistent(qdev
->pdev
,
2654 qdev
->rx_ring_shadow_reg_area
,
2655 qdev
->rx_ring_shadow_reg_dma
);
2659 static void ql_init_tx_ring(struct ql_adapter
*qdev
, struct tx_ring
*tx_ring
)
2661 struct tx_ring_desc
*tx_ring_desc
;
2663 struct ob_mac_iocb_req
*mac_iocb_ptr
;
2665 mac_iocb_ptr
= tx_ring
->wq_base
;
2666 tx_ring_desc
= tx_ring
->q
;
2667 for (i
= 0; i
< tx_ring
->wq_len
; i
++) {
2668 tx_ring_desc
->index
= i
;
2669 tx_ring_desc
->skb
= NULL
;
2670 tx_ring_desc
->queue_entry
= mac_iocb_ptr
;
2674 atomic_set(&tx_ring
->tx_count
, tx_ring
->wq_len
);
2675 atomic_set(&tx_ring
->queue_stopped
, 0);
2678 static void ql_free_tx_resources(struct ql_adapter
*qdev
,
2679 struct tx_ring
*tx_ring
)
2681 if (tx_ring
->wq_base
) {
2682 pci_free_consistent(qdev
->pdev
, tx_ring
->wq_size
,
2683 tx_ring
->wq_base
, tx_ring
->wq_base_dma
);
2684 tx_ring
->wq_base
= NULL
;
2690 static int ql_alloc_tx_resources(struct ql_adapter
*qdev
,
2691 struct tx_ring
*tx_ring
)
2694 pci_alloc_consistent(qdev
->pdev
, tx_ring
->wq_size
,
2695 &tx_ring
->wq_base_dma
);
2697 if ((tx_ring
->wq_base
== NULL
) ||
2698 tx_ring
->wq_base_dma
& WQ_ADDR_ALIGN
) {
2699 netif_err(qdev
, ifup
, qdev
->ndev
, "tx_ring alloc failed.\n");
2703 kmalloc(tx_ring
->wq_len
* sizeof(struct tx_ring_desc
), GFP_KERNEL
);
2704 if (tx_ring
->q
== NULL
)
2709 pci_free_consistent(qdev
->pdev
, tx_ring
->wq_size
,
2710 tx_ring
->wq_base
, tx_ring
->wq_base_dma
);
2714 static void ql_free_lbq_buffers(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
)
2716 struct bq_desc
*lbq_desc
;
2718 uint32_t curr_idx
, clean_idx
;
2720 curr_idx
= rx_ring
->lbq_curr_idx
;
2721 clean_idx
= rx_ring
->lbq_clean_idx
;
2722 while (curr_idx
!= clean_idx
) {
2723 lbq_desc
= &rx_ring
->lbq
[curr_idx
];
2725 if (lbq_desc
->p
.pg_chunk
.last_flag
) {
2726 pci_unmap_page(qdev
->pdev
,
2727 lbq_desc
->p
.pg_chunk
.map
,
2728 ql_lbq_block_size(qdev
),
2729 PCI_DMA_FROMDEVICE
);
2730 lbq_desc
->p
.pg_chunk
.last_flag
= 0;
2733 put_page(lbq_desc
->p
.pg_chunk
.page
);
2734 lbq_desc
->p
.pg_chunk
.page
= NULL
;
2736 if (++curr_idx
== rx_ring
->lbq_len
)
2742 static void ql_free_sbq_buffers(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
)
2745 struct bq_desc
*sbq_desc
;
2747 for (i
= 0; i
< rx_ring
->sbq_len
; i
++) {
2748 sbq_desc
= &rx_ring
->sbq
[i
];
2749 if (sbq_desc
== NULL
) {
2750 netif_err(qdev
, ifup
, qdev
->ndev
,
2751 "sbq_desc %d is NULL.\n", i
);
2754 if (sbq_desc
->p
.skb
) {
2755 pci_unmap_single(qdev
->pdev
,
2756 dma_unmap_addr(sbq_desc
, mapaddr
),
2757 dma_unmap_len(sbq_desc
, maplen
),
2758 PCI_DMA_FROMDEVICE
);
2759 dev_kfree_skb(sbq_desc
->p
.skb
);
2760 sbq_desc
->p
.skb
= NULL
;
2765 /* Free all large and small rx buffers associated
2766 * with the completion queues for this device.
2768 static void ql_free_rx_buffers(struct ql_adapter
*qdev
)
2771 struct rx_ring
*rx_ring
;
2773 for (i
= 0; i
< qdev
->rx_ring_count
; i
++) {
2774 rx_ring
= &qdev
->rx_ring
[i
];
2776 ql_free_lbq_buffers(qdev
, rx_ring
);
2778 ql_free_sbq_buffers(qdev
, rx_ring
);
2782 static void ql_alloc_rx_buffers(struct ql_adapter
*qdev
)
2784 struct rx_ring
*rx_ring
;
2787 for (i
= 0; i
< qdev
->rx_ring_count
; i
++) {
2788 rx_ring
= &qdev
->rx_ring
[i
];
2789 if (rx_ring
->type
!= TX_Q
)
2790 ql_update_buffer_queues(qdev
, rx_ring
);
2794 static void ql_init_lbq_ring(struct ql_adapter
*qdev
,
2795 struct rx_ring
*rx_ring
)
2798 struct bq_desc
*lbq_desc
;
2799 __le64
*bq
= rx_ring
->lbq_base
;
2801 memset(rx_ring
->lbq
, 0, rx_ring
->lbq_len
* sizeof(struct bq_desc
));
2802 for (i
= 0; i
< rx_ring
->lbq_len
; i
++) {
2803 lbq_desc
= &rx_ring
->lbq
[i
];
2804 memset(lbq_desc
, 0, sizeof(*lbq_desc
));
2805 lbq_desc
->index
= i
;
2806 lbq_desc
->addr
= bq
;
2811 static void ql_init_sbq_ring(struct ql_adapter
*qdev
,
2812 struct rx_ring
*rx_ring
)
2815 struct bq_desc
*sbq_desc
;
2816 __le64
*bq
= rx_ring
->sbq_base
;
2818 memset(rx_ring
->sbq
, 0, rx_ring
->sbq_len
* sizeof(struct bq_desc
));
2819 for (i
= 0; i
< rx_ring
->sbq_len
; i
++) {
2820 sbq_desc
= &rx_ring
->sbq
[i
];
2821 memset(sbq_desc
, 0, sizeof(*sbq_desc
));
2822 sbq_desc
->index
= i
;
2823 sbq_desc
->addr
= bq
;
2828 static void ql_free_rx_resources(struct ql_adapter
*qdev
,
2829 struct rx_ring
*rx_ring
)
2831 /* Free the small buffer queue. */
2832 if (rx_ring
->sbq_base
) {
2833 pci_free_consistent(qdev
->pdev
,
2835 rx_ring
->sbq_base
, rx_ring
->sbq_base_dma
);
2836 rx_ring
->sbq_base
= NULL
;
2839 /* Free the small buffer queue control blocks. */
2840 kfree(rx_ring
->sbq
);
2841 rx_ring
->sbq
= NULL
;
2843 /* Free the large buffer queue. */
2844 if (rx_ring
->lbq_base
) {
2845 pci_free_consistent(qdev
->pdev
,
2847 rx_ring
->lbq_base
, rx_ring
->lbq_base_dma
);
2848 rx_ring
->lbq_base
= NULL
;
2851 /* Free the large buffer queue control blocks. */
2852 kfree(rx_ring
->lbq
);
2853 rx_ring
->lbq
= NULL
;
2855 /* Free the rx queue. */
2856 if (rx_ring
->cq_base
) {
2857 pci_free_consistent(qdev
->pdev
,
2859 rx_ring
->cq_base
, rx_ring
->cq_base_dma
);
2860 rx_ring
->cq_base
= NULL
;
2864 /* Allocate queues and buffers for this completions queue based
2865 * on the values in the parameter structure. */
2866 static int ql_alloc_rx_resources(struct ql_adapter
*qdev
,
2867 struct rx_ring
*rx_ring
)
2871 * Allocate the completion queue for this rx_ring.
2874 pci_alloc_consistent(qdev
->pdev
, rx_ring
->cq_size
,
2875 &rx_ring
->cq_base_dma
);
2877 if (rx_ring
->cq_base
== NULL
) {
2878 netif_err(qdev
, ifup
, qdev
->ndev
, "rx_ring alloc failed.\n");
2882 if (rx_ring
->sbq_len
) {
2884 * Allocate small buffer queue.
2887 pci_alloc_consistent(qdev
->pdev
, rx_ring
->sbq_size
,
2888 &rx_ring
->sbq_base_dma
);
2890 if (rx_ring
->sbq_base
== NULL
) {
2891 netif_err(qdev
, ifup
, qdev
->ndev
,
2892 "Small buffer queue allocation failed.\n");
2897 * Allocate small buffer queue control blocks.
2900 kmalloc(rx_ring
->sbq_len
* sizeof(struct bq_desc
),
2902 if (rx_ring
->sbq
== NULL
) {
2903 netif_err(qdev
, ifup
, qdev
->ndev
,
2904 "Small buffer queue control block allocation failed.\n");
2908 ql_init_sbq_ring(qdev
, rx_ring
);
2911 if (rx_ring
->lbq_len
) {
2913 * Allocate large buffer queue.
2916 pci_alloc_consistent(qdev
->pdev
, rx_ring
->lbq_size
,
2917 &rx_ring
->lbq_base_dma
);
2919 if (rx_ring
->lbq_base
== NULL
) {
2920 netif_err(qdev
, ifup
, qdev
->ndev
,
2921 "Large buffer queue allocation failed.\n");
2925 * Allocate large buffer queue control blocks.
2928 kmalloc(rx_ring
->lbq_len
* sizeof(struct bq_desc
),
2930 if (rx_ring
->lbq
== NULL
) {
2931 netif_err(qdev
, ifup
, qdev
->ndev
,
2932 "Large buffer queue control block allocation failed.\n");
2936 ql_init_lbq_ring(qdev
, rx_ring
);
2942 ql_free_rx_resources(qdev
, rx_ring
);
2946 static void ql_tx_ring_clean(struct ql_adapter
*qdev
)
2948 struct tx_ring
*tx_ring
;
2949 struct tx_ring_desc
*tx_ring_desc
;
2953 * Loop through all queues and free
2956 for (j
= 0; j
< qdev
->tx_ring_count
; j
++) {
2957 tx_ring
= &qdev
->tx_ring
[j
];
2958 for (i
= 0; i
< tx_ring
->wq_len
; i
++) {
2959 tx_ring_desc
= &tx_ring
->q
[i
];
2960 if (tx_ring_desc
&& tx_ring_desc
->skb
) {
2961 netif_err(qdev
, ifdown
, qdev
->ndev
,
2962 "Freeing lost SKB %p, from queue %d, index %d.\n",
2963 tx_ring_desc
->skb
, j
,
2964 tx_ring_desc
->index
);
2965 ql_unmap_send(qdev
, tx_ring_desc
,
2966 tx_ring_desc
->map_cnt
);
2967 dev_kfree_skb(tx_ring_desc
->skb
);
2968 tx_ring_desc
->skb
= NULL
;
2974 static void ql_free_mem_resources(struct ql_adapter
*qdev
)
2978 for (i
= 0; i
< qdev
->tx_ring_count
; i
++)
2979 ql_free_tx_resources(qdev
, &qdev
->tx_ring
[i
]);
2980 for (i
= 0; i
< qdev
->rx_ring_count
; i
++)
2981 ql_free_rx_resources(qdev
, &qdev
->rx_ring
[i
]);
2982 ql_free_shadow_space(qdev
);
2985 static int ql_alloc_mem_resources(struct ql_adapter
*qdev
)
2989 /* Allocate space for our shadow registers and such. */
2990 if (ql_alloc_shadow_space(qdev
))
2993 for (i
= 0; i
< qdev
->rx_ring_count
; i
++) {
2994 if (ql_alloc_rx_resources(qdev
, &qdev
->rx_ring
[i
]) != 0) {
2995 netif_err(qdev
, ifup
, qdev
->ndev
,
2996 "RX resource allocation failed.\n");
3000 /* Allocate tx queue resources */
3001 for (i
= 0; i
< qdev
->tx_ring_count
; i
++) {
3002 if (ql_alloc_tx_resources(qdev
, &qdev
->tx_ring
[i
]) != 0) {
3003 netif_err(qdev
, ifup
, qdev
->ndev
,
3004 "TX resource allocation failed.\n");
3011 ql_free_mem_resources(qdev
);
3015 /* Set up the rx ring control block and pass it to the chip.
3016 * The control block is defined as
3017 * "Completion Queue Initialization Control Block", or cqicb.
3019 static int ql_start_rx_ring(struct ql_adapter
*qdev
, struct rx_ring
*rx_ring
)
3021 struct cqicb
*cqicb
= &rx_ring
->cqicb
;
3022 void *shadow_reg
= qdev
->rx_ring_shadow_reg_area
+
3023 (rx_ring
->cq_id
* RX_RING_SHADOW_SPACE
);
3024 u64 shadow_reg_dma
= qdev
->rx_ring_shadow_reg_dma
+
3025 (rx_ring
->cq_id
* RX_RING_SHADOW_SPACE
);
3026 void __iomem
*doorbell_area
=
3027 qdev
->doorbell_area
+ (DB_PAGE_SIZE
* (128 + rx_ring
->cq_id
));
3031 __le64
*base_indirect_ptr
;
3034 /* Set up the shadow registers for this ring. */
3035 rx_ring
->prod_idx_sh_reg
= shadow_reg
;
3036 rx_ring
->prod_idx_sh_reg_dma
= shadow_reg_dma
;
3037 *rx_ring
->prod_idx_sh_reg
= 0;
3038 shadow_reg
+= sizeof(u64
);
3039 shadow_reg_dma
+= sizeof(u64
);
3040 rx_ring
->lbq_base_indirect
= shadow_reg
;
3041 rx_ring
->lbq_base_indirect_dma
= shadow_reg_dma
;
3042 shadow_reg
+= (sizeof(u64
) * MAX_DB_PAGES_PER_BQ(rx_ring
->lbq_len
));
3043 shadow_reg_dma
+= (sizeof(u64
) * MAX_DB_PAGES_PER_BQ(rx_ring
->lbq_len
));
3044 rx_ring
->sbq_base_indirect
= shadow_reg
;
3045 rx_ring
->sbq_base_indirect_dma
= shadow_reg_dma
;
3047 /* PCI doorbell mem area + 0x00 for consumer index register */
3048 rx_ring
->cnsmr_idx_db_reg
= (u32 __iomem
*) doorbell_area
;
3049 rx_ring
->cnsmr_idx
= 0;
3050 rx_ring
->curr_entry
= rx_ring
->cq_base
;
3052 /* PCI doorbell mem area + 0x04 for valid register */
3053 rx_ring
->valid_db_reg
= doorbell_area
+ 0x04;
3055 /* PCI doorbell mem area + 0x18 for large buffer consumer */
3056 rx_ring
->lbq_prod_idx_db_reg
= (u32 __iomem
*) (doorbell_area
+ 0x18);
3058 /* PCI doorbell mem area + 0x1c */
3059 rx_ring
->sbq_prod_idx_db_reg
= (u32 __iomem
*) (doorbell_area
+ 0x1c);
3061 memset((void *)cqicb
, 0, sizeof(struct cqicb
));
3062 cqicb
->msix_vect
= rx_ring
->irq
;
3064 bq_len
= (rx_ring
->cq_len
== 65536) ? 0 : (u16
) rx_ring
->cq_len
;
3065 cqicb
->len
= cpu_to_le16(bq_len
| LEN_V
| LEN_CPP_CONT
);
3067 cqicb
->addr
= cpu_to_le64(rx_ring
->cq_base_dma
);
3069 cqicb
->prod_idx_addr
= cpu_to_le64(rx_ring
->prod_idx_sh_reg_dma
);
3072 * Set up the control block load flags.
3074 cqicb
->flags
= FLAGS_LC
| /* Load queue base address */
3075 FLAGS_LV
| /* Load MSI-X vector */
3076 FLAGS_LI
; /* Load irq delay values */
3077 if (rx_ring
->lbq_len
) {
3078 cqicb
->flags
|= FLAGS_LL
; /* Load lbq values */
3079 tmp
= (u64
)rx_ring
->lbq_base_dma
;
3080 base_indirect_ptr
= (__le64
*) rx_ring
->lbq_base_indirect
;
3083 *base_indirect_ptr
= cpu_to_le64(tmp
);
3084 tmp
+= DB_PAGE_SIZE
;
3085 base_indirect_ptr
++;
3087 } while (page_entries
< MAX_DB_PAGES_PER_BQ(rx_ring
->lbq_len
));
3089 cpu_to_le64(rx_ring
->lbq_base_indirect_dma
);
3090 bq_len
= (rx_ring
->lbq_buf_size
== 65536) ? 0 :
3091 (u16
) rx_ring
->lbq_buf_size
;
3092 cqicb
->lbq_buf_size
= cpu_to_le16(bq_len
);
3093 bq_len
= (rx_ring
->lbq_len
== 65536) ? 0 :
3094 (u16
) rx_ring
->lbq_len
;
3095 cqicb
->lbq_len
= cpu_to_le16(bq_len
);
3096 rx_ring
->lbq_prod_idx
= 0;
3097 rx_ring
->lbq_curr_idx
= 0;
3098 rx_ring
->lbq_clean_idx
= 0;
3099 rx_ring
->lbq_free_cnt
= rx_ring
->lbq_len
;
3101 if (rx_ring
->sbq_len
) {
3102 cqicb
->flags
|= FLAGS_LS
; /* Load sbq values */
3103 tmp
= (u64
)rx_ring
->sbq_base_dma
;
3104 base_indirect_ptr
= (__le64
*) rx_ring
->sbq_base_indirect
;
3107 *base_indirect_ptr
= cpu_to_le64(tmp
);
3108 tmp
+= DB_PAGE_SIZE
;
3109 base_indirect_ptr
++;
3111 } while (page_entries
< MAX_DB_PAGES_PER_BQ(rx_ring
->sbq_len
));
3113 cpu_to_le64(rx_ring
->sbq_base_indirect_dma
);
3114 cqicb
->sbq_buf_size
=
3115 cpu_to_le16((u16
)(rx_ring
->sbq_buf_size
));
3116 bq_len
= (rx_ring
->sbq_len
== 65536) ? 0 :
3117 (u16
) rx_ring
->sbq_len
;
3118 cqicb
->sbq_len
= cpu_to_le16(bq_len
);
3119 rx_ring
->sbq_prod_idx
= 0;
3120 rx_ring
->sbq_curr_idx
= 0;
3121 rx_ring
->sbq_clean_idx
= 0;
3122 rx_ring
->sbq_free_cnt
= rx_ring
->sbq_len
;
3124 switch (rx_ring
->type
) {
3126 cqicb
->irq_delay
= cpu_to_le16(qdev
->tx_coalesce_usecs
);
3127 cqicb
->pkt_delay
= cpu_to_le16(qdev
->tx_max_coalesced_frames
);
3130 /* Inbound completion handling rx_rings run in
3131 * separate NAPI contexts.
3133 netif_napi_add(qdev
->ndev
, &rx_ring
->napi
, ql_napi_poll_msix
,
3135 cqicb
->irq_delay
= cpu_to_le16(qdev
->rx_coalesce_usecs
);
3136 cqicb
->pkt_delay
= cpu_to_le16(qdev
->rx_max_coalesced_frames
);
3139 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3140 "Invalid rx_ring->type = %d.\n", rx_ring
->type
);
3142 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3143 "Initializing rx work queue.\n");
3144 err
= ql_write_cfg(qdev
, cqicb
, sizeof(struct cqicb
),
3145 CFG_LCQ
, rx_ring
->cq_id
);
3147 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to load CQICB.\n");
3153 static int ql_start_tx_ring(struct ql_adapter
*qdev
, struct tx_ring
*tx_ring
)
3155 struct wqicb
*wqicb
= (struct wqicb
*)tx_ring
;
3156 void __iomem
*doorbell_area
=
3157 qdev
->doorbell_area
+ (DB_PAGE_SIZE
* tx_ring
->wq_id
);
3158 void *shadow_reg
= qdev
->tx_ring_shadow_reg_area
+
3159 (tx_ring
->wq_id
* sizeof(u64
));
3160 u64 shadow_reg_dma
= qdev
->tx_ring_shadow_reg_dma
+
3161 (tx_ring
->wq_id
* sizeof(u64
));
3165 * Assign doorbell registers for this tx_ring.
3167 /* TX PCI doorbell mem area for tx producer index */
3168 tx_ring
->prod_idx_db_reg
= (u32 __iomem
*) doorbell_area
;
3169 tx_ring
->prod_idx
= 0;
3170 /* TX PCI doorbell mem area + 0x04 */
3171 tx_ring
->valid_db_reg
= doorbell_area
+ 0x04;
3174 * Assign shadow registers for this tx_ring.
3176 tx_ring
->cnsmr_idx_sh_reg
= shadow_reg
;
3177 tx_ring
->cnsmr_idx_sh_reg_dma
= shadow_reg_dma
;
3179 wqicb
->len
= cpu_to_le16(tx_ring
->wq_len
| Q_LEN_V
| Q_LEN_CPP_CONT
);
3180 wqicb
->flags
= cpu_to_le16(Q_FLAGS_LC
|
3181 Q_FLAGS_LB
| Q_FLAGS_LI
| Q_FLAGS_LO
);
3182 wqicb
->cq_id_rss
= cpu_to_le16(tx_ring
->cq_id
);
3184 wqicb
->addr
= cpu_to_le64(tx_ring
->wq_base_dma
);
3186 wqicb
->cnsmr_idx_addr
= cpu_to_le64(tx_ring
->cnsmr_idx_sh_reg_dma
);
3188 ql_init_tx_ring(qdev
, tx_ring
);
3190 err
= ql_write_cfg(qdev
, wqicb
, sizeof(*wqicb
), CFG_LRQ
,
3191 (u16
) tx_ring
->wq_id
);
3193 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to load tx_ring.\n");
3196 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3197 "Successfully loaded WQICB.\n");
3201 static void ql_disable_msix(struct ql_adapter
*qdev
)
3203 if (test_bit(QL_MSIX_ENABLED
, &qdev
->flags
)) {
3204 pci_disable_msix(qdev
->pdev
);
3205 clear_bit(QL_MSIX_ENABLED
, &qdev
->flags
);
3206 kfree(qdev
->msi_x_entry
);
3207 qdev
->msi_x_entry
= NULL
;
3208 } else if (test_bit(QL_MSI_ENABLED
, &qdev
->flags
)) {
3209 pci_disable_msi(qdev
->pdev
);
3210 clear_bit(QL_MSI_ENABLED
, &qdev
->flags
);
3214 /* We start by trying to get the number of vectors
3215 * stored in qdev->intr_count. If we don't get that
3216 * many then we reduce the count and try again.
3218 static void ql_enable_msix(struct ql_adapter
*qdev
)
3222 /* Get the MSIX vectors. */
3223 if (qlge_irq_type
== MSIX_IRQ
) {
3224 /* Try to alloc space for the msix struct,
3225 * if it fails then go to MSI/legacy.
3227 qdev
->msi_x_entry
= kcalloc(qdev
->intr_count
,
3228 sizeof(struct msix_entry
),
3230 if (!qdev
->msi_x_entry
) {
3231 qlge_irq_type
= MSI_IRQ
;
3235 for (i
= 0; i
< qdev
->intr_count
; i
++)
3236 qdev
->msi_x_entry
[i
].entry
= i
;
3238 /* Loop to get our vectors. We start with
3239 * what we want and settle for what we get.
3242 err
= pci_enable_msix(qdev
->pdev
,
3243 qdev
->msi_x_entry
, qdev
->intr_count
);
3245 qdev
->intr_count
= err
;
3249 kfree(qdev
->msi_x_entry
);
3250 qdev
->msi_x_entry
= NULL
;
3251 netif_warn(qdev
, ifup
, qdev
->ndev
,
3252 "MSI-X Enable failed, trying MSI.\n");
3253 qdev
->intr_count
= 1;
3254 qlge_irq_type
= MSI_IRQ
;
3255 } else if (err
== 0) {
3256 set_bit(QL_MSIX_ENABLED
, &qdev
->flags
);
3257 netif_info(qdev
, ifup
, qdev
->ndev
,
3258 "MSI-X Enabled, got %d vectors.\n",
3264 qdev
->intr_count
= 1;
3265 if (qlge_irq_type
== MSI_IRQ
) {
3266 if (!pci_enable_msi(qdev
->pdev
)) {
3267 set_bit(QL_MSI_ENABLED
, &qdev
->flags
);
3268 netif_info(qdev
, ifup
, qdev
->ndev
,
3269 "Running with MSI interrupts.\n");
3273 qlge_irq_type
= LEG_IRQ
;
3274 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3275 "Running with legacy interrupts.\n");
3278 /* Each vector services 1 RSS ring and and 1 or more
3279 * TX completion rings. This function loops through
3280 * the TX completion rings and assigns the vector that
3281 * will service it. An example would be if there are
3282 * 2 vectors (so 2 RSS rings) and 8 TX completion rings.
3283 * This would mean that vector 0 would service RSS ring 0
3284 * and TX competion rings 0,1,2 and 3. Vector 1 would
3285 * service RSS ring 1 and TX completion rings 4,5,6 and 7.
3287 static void ql_set_tx_vect(struct ql_adapter
*qdev
)
3290 u32 tx_rings_per_vector
= qdev
->tx_ring_count
/ qdev
->intr_count
;
3292 if (likely(test_bit(QL_MSIX_ENABLED
, &qdev
->flags
))) {
3293 /* Assign irq vectors to TX rx_rings.*/
3294 for (vect
= 0, j
= 0, i
= qdev
->rss_ring_count
;
3295 i
< qdev
->rx_ring_count
; i
++) {
3296 if (j
== tx_rings_per_vector
) {
3300 qdev
->rx_ring
[i
].irq
= vect
;
3304 /* For single vector all rings have an irq
3307 for (i
= 0; i
< qdev
->rx_ring_count
; i
++)
3308 qdev
->rx_ring
[i
].irq
= 0;
3312 /* Set the interrupt mask for this vector. Each vector
3313 * will service 1 RSS ring and 1 or more TX completion
3314 * rings. This function sets up a bit mask per vector
3315 * that indicates which rings it services.
3317 static void ql_set_irq_mask(struct ql_adapter
*qdev
, struct intr_context
*ctx
)
3319 int j
, vect
= ctx
->intr
;
3320 u32 tx_rings_per_vector
= qdev
->tx_ring_count
/ qdev
->intr_count
;
3322 if (likely(test_bit(QL_MSIX_ENABLED
, &qdev
->flags
))) {
3323 /* Add the RSS ring serviced by this vector
3326 ctx
->irq_mask
= (1 << qdev
->rx_ring
[vect
].cq_id
);
3327 /* Add the TX ring(s) serviced by this vector
3329 for (j
= 0; j
< tx_rings_per_vector
; j
++) {
3331 (1 << qdev
->rx_ring
[qdev
->rss_ring_count
+
3332 (vect
* tx_rings_per_vector
) + j
].cq_id
);
3335 /* For single vector we just shift each queue's
3338 for (j
= 0; j
< qdev
->rx_ring_count
; j
++)
3339 ctx
->irq_mask
|= (1 << qdev
->rx_ring
[j
].cq_id
);
3344 * Here we build the intr_context structures based on
3345 * our rx_ring count and intr vector count.
3346 * The intr_context structure is used to hook each vector
3347 * to possibly different handlers.
3349 static void ql_resolve_queues_to_irqs(struct ql_adapter
*qdev
)
3352 struct intr_context
*intr_context
= &qdev
->intr_context
[0];
3354 if (likely(test_bit(QL_MSIX_ENABLED
, &qdev
->flags
))) {
3355 /* Each rx_ring has it's
3356 * own intr_context since we have separate
3357 * vectors for each queue.
3359 for (i
= 0; i
< qdev
->intr_count
; i
++, intr_context
++) {
3360 qdev
->rx_ring
[i
].irq
= i
;
3361 intr_context
->intr
= i
;
3362 intr_context
->qdev
= qdev
;
3363 /* Set up this vector's bit-mask that indicates
3364 * which queues it services.
3366 ql_set_irq_mask(qdev
, intr_context
);
3368 * We set up each vectors enable/disable/read bits so
3369 * there's no bit/mask calculations in the critical path.
3371 intr_context
->intr_en_mask
=
3372 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
|
3373 INTR_EN_TYPE_ENABLE
| INTR_EN_IHD_MASK
| INTR_EN_IHD
3375 intr_context
->intr_dis_mask
=
3376 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
|
3377 INTR_EN_TYPE_DISABLE
| INTR_EN_IHD_MASK
|
3379 intr_context
->intr_read_mask
=
3380 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
|
3381 INTR_EN_TYPE_READ
| INTR_EN_IHD_MASK
| INTR_EN_IHD
|
3384 /* The first vector/queue handles
3385 * broadcast/multicast, fatal errors,
3386 * and firmware events. This in addition
3387 * to normal inbound NAPI processing.
3389 intr_context
->handler
= qlge_isr
;
3390 sprintf(intr_context
->name
, "%s-rx-%d",
3391 qdev
->ndev
->name
, i
);
3394 * Inbound queues handle unicast frames only.
3396 intr_context
->handler
= qlge_msix_rx_isr
;
3397 sprintf(intr_context
->name
, "%s-rx-%d",
3398 qdev
->ndev
->name
, i
);
3403 * All rx_rings use the same intr_context since
3404 * there is only one vector.
3406 intr_context
->intr
= 0;
3407 intr_context
->qdev
= qdev
;
3409 * We set up each vectors enable/disable/read bits so
3410 * there's no bit/mask calculations in the critical path.
3412 intr_context
->intr_en_mask
=
3413 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
| INTR_EN_TYPE_ENABLE
;
3414 intr_context
->intr_dis_mask
=
3415 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
|
3416 INTR_EN_TYPE_DISABLE
;
3417 intr_context
->intr_read_mask
=
3418 INTR_EN_TYPE_MASK
| INTR_EN_INTR_MASK
| INTR_EN_TYPE_READ
;
3420 * Single interrupt means one handler for all rings.
3422 intr_context
->handler
= qlge_isr
;
3423 sprintf(intr_context
->name
, "%s-single_irq", qdev
->ndev
->name
);
3424 /* Set up this vector's bit-mask that indicates
3425 * which queues it services. In this case there is
3426 * a single vector so it will service all RSS and
3427 * TX completion rings.
3429 ql_set_irq_mask(qdev
, intr_context
);
3431 /* Tell the TX completion rings which MSIx vector
3432 * they will be using.
3434 ql_set_tx_vect(qdev
);
3437 static void ql_free_irq(struct ql_adapter
*qdev
)
3440 struct intr_context
*intr_context
= &qdev
->intr_context
[0];
3442 for (i
= 0; i
< qdev
->intr_count
; i
++, intr_context
++) {
3443 if (intr_context
->hooked
) {
3444 if (test_bit(QL_MSIX_ENABLED
, &qdev
->flags
)) {
3445 free_irq(qdev
->msi_x_entry
[i
].vector
,
3447 netif_printk(qdev
, ifdown
, KERN_DEBUG
, qdev
->ndev
,
3448 "freeing msix interrupt %d.\n", i
);
3450 free_irq(qdev
->pdev
->irq
, &qdev
->rx_ring
[0]);
3451 netif_printk(qdev
, ifdown
, KERN_DEBUG
, qdev
->ndev
,
3452 "freeing msi interrupt %d.\n", i
);
3456 ql_disable_msix(qdev
);
3459 static int ql_request_irq(struct ql_adapter
*qdev
)
3463 struct pci_dev
*pdev
= qdev
->pdev
;
3464 struct intr_context
*intr_context
= &qdev
->intr_context
[0];
3466 ql_resolve_queues_to_irqs(qdev
);
3468 for (i
= 0; i
< qdev
->intr_count
; i
++, intr_context
++) {
3469 atomic_set(&intr_context
->irq_cnt
, 0);
3470 if (test_bit(QL_MSIX_ENABLED
, &qdev
->flags
)) {
3471 status
= request_irq(qdev
->msi_x_entry
[i
].vector
,
3472 intr_context
->handler
,
3477 netif_err(qdev
, ifup
, qdev
->ndev
,
3478 "Failed request for MSIX interrupt %d.\n",
3482 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3483 "Hooked intr %d, queue type %s, with name %s.\n",
3485 qdev
->rx_ring
[i
].type
== DEFAULT_Q
?
3487 qdev
->rx_ring
[i
].type
== TX_Q
?
3489 qdev
->rx_ring
[i
].type
== RX_Q
?
3491 intr_context
->name
);
3494 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3495 "trying msi or legacy interrupts.\n");
3496 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3497 "%s: irq = %d.\n", __func__
, pdev
->irq
);
3498 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3499 "%s: context->name = %s.\n", __func__
,
3500 intr_context
->name
);
3501 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3502 "%s: dev_id = 0x%p.\n", __func__
,
3505 request_irq(pdev
->irq
, qlge_isr
,
3506 test_bit(QL_MSI_ENABLED
,
3508 flags
) ? 0 : IRQF_SHARED
,
3509 intr_context
->name
, &qdev
->rx_ring
[0]);
3513 netif_err(qdev
, ifup
, qdev
->ndev
,
3514 "Hooked intr %d, queue type %s, with name %s.\n",
3516 qdev
->rx_ring
[0].type
== DEFAULT_Q
?
3518 qdev
->rx_ring
[0].type
== TX_Q
? "TX_Q" :
3519 qdev
->rx_ring
[0].type
== RX_Q
? "RX_Q" : "",
3520 intr_context
->name
);
3522 intr_context
->hooked
= 1;
3526 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to get the interrupts!!!/n");
3531 static int ql_start_rss(struct ql_adapter
*qdev
)
3533 u8 init_hash_seed
[] = {0x6d, 0x5a, 0x56, 0xda, 0x25, 0x5b, 0x0e, 0xc2,
3534 0x41, 0x67, 0x25, 0x3d, 0x43, 0xa3, 0x8f,
3535 0xb0, 0xd0, 0xca, 0x2b, 0xcb, 0xae, 0x7b,
3536 0x30, 0xb4, 0x77, 0xcb, 0x2d, 0xa3, 0x80,
3537 0x30, 0xf2, 0x0c, 0x6a, 0x42, 0xb7, 0x3b,
3538 0xbe, 0xac, 0x01, 0xfa};
3539 struct ricb
*ricb
= &qdev
->ricb
;
3542 u8
*hash_id
= (u8
*) ricb
->hash_cq_id
;
3544 memset((void *)ricb
, 0, sizeof(*ricb
));
3546 ricb
->base_cq
= RSS_L4K
;
3548 (RSS_L6K
| RSS_LI
| RSS_LB
| RSS_LM
| RSS_RT4
| RSS_RT6
);
3549 ricb
->mask
= cpu_to_le16((u16
)(0x3ff));
3552 * Fill out the Indirection Table.
3554 for (i
= 0; i
< 1024; i
++)
3555 hash_id
[i
] = (i
& (qdev
->rss_ring_count
- 1));
3557 memcpy((void *)&ricb
->ipv6_hash_key
[0], init_hash_seed
, 40);
3558 memcpy((void *)&ricb
->ipv4_hash_key
[0], init_hash_seed
, 16);
3560 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
, "Initializing RSS.\n");
3562 status
= ql_write_cfg(qdev
, ricb
, sizeof(*ricb
), CFG_LR
, 0);
3564 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to load RICB.\n");
3567 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3568 "Successfully loaded RICB.\n");
3572 static int ql_clear_routing_entries(struct ql_adapter
*qdev
)
3576 status
= ql_sem_spinlock(qdev
, SEM_RT_IDX_MASK
);
3579 /* Clear all the entries in the routing table. */
3580 for (i
= 0; i
< 16; i
++) {
3581 status
= ql_set_routing_reg(qdev
, i
, 0, 0);
3583 netif_err(qdev
, ifup
, qdev
->ndev
,
3584 "Failed to init routing register for CAM packets.\n");
3588 ql_sem_unlock(qdev
, SEM_RT_IDX_MASK
);
3592 /* Initialize the frame-to-queue routing. */
3593 static int ql_route_initialize(struct ql_adapter
*qdev
)
3597 /* Clear all the entries in the routing table. */
3598 status
= ql_clear_routing_entries(qdev
);
3602 status
= ql_sem_spinlock(qdev
, SEM_RT_IDX_MASK
);
3606 status
= ql_set_routing_reg(qdev
, RT_IDX_IP_CSUM_ERR_SLOT
,
3607 RT_IDX_IP_CSUM_ERR
, 1);
3609 netif_err(qdev
, ifup
, qdev
->ndev
,
3610 "Failed to init routing register "
3611 "for IP CSUM error packets.\n");
3614 status
= ql_set_routing_reg(qdev
, RT_IDX_TCP_UDP_CSUM_ERR_SLOT
,
3615 RT_IDX_TU_CSUM_ERR
, 1);
3617 netif_err(qdev
, ifup
, qdev
->ndev
,
3618 "Failed to init routing register "
3619 "for TCP/UDP CSUM error packets.\n");
3622 status
= ql_set_routing_reg(qdev
, RT_IDX_BCAST_SLOT
, RT_IDX_BCAST
, 1);
3624 netif_err(qdev
, ifup
, qdev
->ndev
,
3625 "Failed to init routing register for broadcast packets.\n");
3628 /* If we have more than one inbound queue, then turn on RSS in the
3631 if (qdev
->rss_ring_count
> 1) {
3632 status
= ql_set_routing_reg(qdev
, RT_IDX_RSS_MATCH_SLOT
,
3633 RT_IDX_RSS_MATCH
, 1);
3635 netif_err(qdev
, ifup
, qdev
->ndev
,
3636 "Failed to init routing register for MATCH RSS packets.\n");
3641 status
= ql_set_routing_reg(qdev
, RT_IDX_CAM_HIT_SLOT
,
3644 netif_err(qdev
, ifup
, qdev
->ndev
,
3645 "Failed to init routing register for CAM packets.\n");
3647 ql_sem_unlock(qdev
, SEM_RT_IDX_MASK
);
3651 int ql_cam_route_initialize(struct ql_adapter
*qdev
)
3655 /* If check if the link is up and use to
3656 * determine if we are setting or clearing
3657 * the MAC address in the CAM.
3659 set
= ql_read32(qdev
, STS
);
3660 set
&= qdev
->port_link_up
;
3661 status
= ql_set_mac_addr(qdev
, set
);
3663 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to init mac address.\n");
3667 status
= ql_route_initialize(qdev
);
3669 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to init routing table.\n");
3674 static int ql_adapter_initialize(struct ql_adapter
*qdev
)
3681 * Set up the System register to halt on errors.
3683 value
= SYS_EFE
| SYS_FAE
;
3685 ql_write32(qdev
, SYS
, mask
| value
);
3687 /* Set the default queue, and VLAN behavior. */
3688 value
= NIC_RCV_CFG_DFQ
| NIC_RCV_CFG_RV
;
3689 mask
= NIC_RCV_CFG_DFQ_MASK
| (NIC_RCV_CFG_RV
<< 16);
3690 ql_write32(qdev
, NIC_RCV_CFG
, (mask
| value
));
3692 /* Set the MPI interrupt to enabled. */
3693 ql_write32(qdev
, INTR_MASK
, (INTR_MASK_PI
<< 16) | INTR_MASK_PI
);
3695 /* Enable the function, set pagesize, enable error checking. */
3696 value
= FSC_FE
| FSC_EPC_INBOUND
| FSC_EPC_OUTBOUND
|
3697 FSC_EC
| FSC_VM_PAGE_4K
;
3698 value
|= SPLT_SETTING
;
3700 /* Set/clear header splitting. */
3701 mask
= FSC_VM_PAGESIZE_MASK
|
3702 FSC_DBL_MASK
| FSC_DBRST_MASK
| (value
<< 16);
3703 ql_write32(qdev
, FSC
, mask
| value
);
3705 ql_write32(qdev
, SPLT_HDR
, SPLT_LEN
);
3707 /* Set RX packet routing to use port/pci function on which the
3708 * packet arrived on in addition to usual frame routing.
3709 * This is helpful on bonding where both interfaces can have
3710 * the same MAC address.
3712 ql_write32(qdev
, RST_FO
, RST_FO_RR_MASK
| RST_FO_RR_RCV_FUNC_CQ
);
3713 /* Reroute all packets to our Interface.
3714 * They may have been routed to MPI firmware
3717 value
= ql_read32(qdev
, MGMT_RCV_CFG
);
3718 value
&= ~MGMT_RCV_CFG_RM
;
3721 /* Sticky reg needs clearing due to WOL. */
3722 ql_write32(qdev
, MGMT_RCV_CFG
, mask
);
3723 ql_write32(qdev
, MGMT_RCV_CFG
, mask
| value
);
3725 /* Default WOL is enable on Mezz cards */
3726 if (qdev
->pdev
->subsystem_device
== 0x0068 ||
3727 qdev
->pdev
->subsystem_device
== 0x0180)
3728 qdev
->wol
= WAKE_MAGIC
;
3730 /* Start up the rx queues. */
3731 for (i
= 0; i
< qdev
->rx_ring_count
; i
++) {
3732 status
= ql_start_rx_ring(qdev
, &qdev
->rx_ring
[i
]);
3734 netif_err(qdev
, ifup
, qdev
->ndev
,
3735 "Failed to start rx ring[%d].\n", i
);
3740 /* If there is more than one inbound completion queue
3741 * then download a RICB to configure RSS.
3743 if (qdev
->rss_ring_count
> 1) {
3744 status
= ql_start_rss(qdev
);
3746 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to start RSS.\n");
3751 /* Start up the tx queues. */
3752 for (i
= 0; i
< qdev
->tx_ring_count
; i
++) {
3753 status
= ql_start_tx_ring(qdev
, &qdev
->tx_ring
[i
]);
3755 netif_err(qdev
, ifup
, qdev
->ndev
,
3756 "Failed to start tx ring[%d].\n", i
);
3761 /* Initialize the port and set the max framesize. */
3762 status
= qdev
->nic_ops
->port_initialize(qdev
);
3764 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to start port.\n");
3766 /* Set up the MAC address and frame routing filter. */
3767 status
= ql_cam_route_initialize(qdev
);
3769 netif_err(qdev
, ifup
, qdev
->ndev
,
3770 "Failed to init CAM/Routing tables.\n");
3774 /* Start NAPI for the RSS queues. */
3775 for (i
= 0; i
< qdev
->rss_ring_count
; i
++) {
3776 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
3777 "Enabling NAPI for rx_ring[%d].\n", i
);
3778 napi_enable(&qdev
->rx_ring
[i
].napi
);
3784 /* Issue soft reset to chip. */
3785 static int ql_adapter_reset(struct ql_adapter
*qdev
)
3789 unsigned long end_jiffies
;
3791 /* Clear all the entries in the routing table. */
3792 status
= ql_clear_routing_entries(qdev
);
3794 netif_err(qdev
, ifup
, qdev
->ndev
, "Failed to clear routing bits.\n");
3798 end_jiffies
= jiffies
+
3799 max((unsigned long)1, usecs_to_jiffies(30));
3801 /* Stop management traffic. */
3802 ql_mb_set_mgmnt_traffic_ctl(qdev
, MB_SET_MPI_TFK_STOP
);
3804 /* Wait for the NIC and MGMNT FIFOs to empty. */
3805 ql_wait_fifo_empty(qdev
);
3807 ql_write32(qdev
, RST_FO
, (RST_FO_FR
<< 16) | RST_FO_FR
);
3810 value
= ql_read32(qdev
, RST_FO
);
3811 if ((value
& RST_FO_FR
) == 0)
3814 } while (time_before(jiffies
, end_jiffies
));
3816 if (value
& RST_FO_FR
) {
3817 netif_err(qdev
, ifdown
, qdev
->ndev
,
3818 "ETIMEDOUT!!! errored out of resetting the chip!\n");
3819 status
= -ETIMEDOUT
;
3822 /* Resume management traffic. */
3823 ql_mb_set_mgmnt_traffic_ctl(qdev
, MB_SET_MPI_TFK_RESUME
);
3827 static void ql_display_dev_info(struct net_device
*ndev
)
3829 struct ql_adapter
*qdev
= (struct ql_adapter
*)netdev_priv(ndev
);
3831 netif_info(qdev
, probe
, qdev
->ndev
,
3832 "Function #%d, Port %d, NIC Roll %d, NIC Rev = %d, "
3833 "XG Roll = %d, XG Rev = %d.\n",
3836 qdev
->chip_rev_id
& 0x0000000f,
3837 qdev
->chip_rev_id
>> 4 & 0x0000000f,
3838 qdev
->chip_rev_id
>> 8 & 0x0000000f,
3839 qdev
->chip_rev_id
>> 12 & 0x0000000f);
3840 netif_info(qdev
, probe
, qdev
->ndev
,
3841 "MAC address %pM\n", ndev
->dev_addr
);
3844 int ql_wol(struct ql_adapter
*qdev
)
3847 u32 wol
= MB_WOL_DISABLE
;
3849 /* The CAM is still intact after a reset, but if we
3850 * are doing WOL, then we may need to program the
3851 * routing regs. We would also need to issue the mailbox
3852 * commands to instruct the MPI what to do per the ethtool
3856 if (qdev
->wol
& (WAKE_ARP
| WAKE_MAGICSECURE
| WAKE_PHY
| WAKE_UCAST
|
3857 WAKE_MCAST
| WAKE_BCAST
)) {
3858 netif_err(qdev
, ifdown
, qdev
->ndev
,
3859 "Unsupported WOL paramter. qdev->wol = 0x%x.\n",
3864 if (qdev
->wol
& WAKE_MAGIC
) {
3865 status
= ql_mb_wol_set_magic(qdev
, 1);
3867 netif_err(qdev
, ifdown
, qdev
->ndev
,
3868 "Failed to set magic packet on %s.\n",
3872 netif_info(qdev
, drv
, qdev
->ndev
,
3873 "Enabled magic packet successfully on %s.\n",
3876 wol
|= MB_WOL_MAGIC_PKT
;
3880 wol
|= MB_WOL_MODE_ON
;
3881 status
= ql_mb_wol_mode(qdev
, wol
);
3882 netif_err(qdev
, drv
, qdev
->ndev
,
3883 "WOL %s (wol code 0x%x) on %s\n",
3884 (status
== 0) ? "Successfully set" : "Failed",
3885 wol
, qdev
->ndev
->name
);
3891 static int ql_adapter_down(struct ql_adapter
*qdev
)
3897 /* Don't kill the reset worker thread if we
3898 * are in the process of recovery.
3900 if (test_bit(QL_ADAPTER_UP
, &qdev
->flags
))
3901 cancel_delayed_work_sync(&qdev
->asic_reset_work
);
3902 cancel_delayed_work_sync(&qdev
->mpi_reset_work
);
3903 cancel_delayed_work_sync(&qdev
->mpi_work
);
3904 cancel_delayed_work_sync(&qdev
->mpi_idc_work
);
3905 cancel_delayed_work_sync(&qdev
->mpi_core_to_log
);
3906 cancel_delayed_work_sync(&qdev
->mpi_port_cfg_work
);
3908 for (i
= 0; i
< qdev
->rss_ring_count
; i
++)
3909 napi_disable(&qdev
->rx_ring
[i
].napi
);
3911 clear_bit(QL_ADAPTER_UP
, &qdev
->flags
);
3913 ql_disable_interrupts(qdev
);
3915 ql_tx_ring_clean(qdev
);
3917 /* Call netif_napi_del() from common point.
3919 for (i
= 0; i
< qdev
->rss_ring_count
; i
++)
3920 netif_napi_del(&qdev
->rx_ring
[i
].napi
);
3922 status
= ql_adapter_reset(qdev
);
3924 netif_err(qdev
, ifdown
, qdev
->ndev
, "reset(func #%d) FAILED!\n",
3926 ql_free_rx_buffers(qdev
);
3931 static int ql_adapter_up(struct ql_adapter
*qdev
)
3935 err
= ql_adapter_initialize(qdev
);
3937 netif_info(qdev
, ifup
, qdev
->ndev
, "Unable to initialize adapter.\n");
3940 set_bit(QL_ADAPTER_UP
, &qdev
->flags
);
3941 ql_alloc_rx_buffers(qdev
);
3942 /* If the port is initialized and the
3943 * link is up the turn on the carrier.
3945 if ((ql_read32(qdev
, STS
) & qdev
->port_init
) &&
3946 (ql_read32(qdev
, STS
) & qdev
->port_link_up
))
3948 /* Restore rx mode. */
3949 clear_bit(QL_ALLMULTI
, &qdev
->flags
);
3950 clear_bit(QL_PROMISCUOUS
, &qdev
->flags
);
3951 qlge_set_multicast_list(qdev
->ndev
);
3953 ql_enable_interrupts(qdev
);
3954 ql_enable_all_completion_interrupts(qdev
);
3955 netif_tx_start_all_queues(qdev
->ndev
);
3959 ql_adapter_reset(qdev
);
3963 static void ql_release_adapter_resources(struct ql_adapter
*qdev
)
3965 ql_free_mem_resources(qdev
);
3969 static int ql_get_adapter_resources(struct ql_adapter
*qdev
)
3973 if (ql_alloc_mem_resources(qdev
)) {
3974 netif_err(qdev
, ifup
, qdev
->ndev
, "Unable to allocate memory.\n");
3977 status
= ql_request_irq(qdev
);
3981 static int qlge_close(struct net_device
*ndev
)
3983 struct ql_adapter
*qdev
= netdev_priv(ndev
);
3985 /* If we hit pci_channel_io_perm_failure
3986 * failure condition, then we already
3987 * brought the adapter down.
3989 if (test_bit(QL_EEH_FATAL
, &qdev
->flags
)) {
3990 netif_err(qdev
, drv
, qdev
->ndev
, "EEH fatal did unload.\n");
3991 clear_bit(QL_EEH_FATAL
, &qdev
->flags
);
3996 * Wait for device to recover from a reset.
3997 * (Rarely happens, but possible.)
3999 while (!test_bit(QL_ADAPTER_UP
, &qdev
->flags
))
4001 ql_adapter_down(qdev
);
4002 ql_release_adapter_resources(qdev
);
4006 static int ql_configure_rings(struct ql_adapter
*qdev
)
4009 struct rx_ring
*rx_ring
;
4010 struct tx_ring
*tx_ring
;
4011 int cpu_cnt
= min(MAX_CPUS
, (int)num_online_cpus());
4012 unsigned int lbq_buf_len
= (qdev
->ndev
->mtu
> 1500) ?
4013 LARGE_BUFFER_MAX_SIZE
: LARGE_BUFFER_MIN_SIZE
;
4015 qdev
->lbq_buf_order
= get_order(lbq_buf_len
);
4017 /* In a perfect world we have one RSS ring for each CPU
4018 * and each has it's own vector. To do that we ask for
4019 * cpu_cnt vectors. ql_enable_msix() will adjust the
4020 * vector count to what we actually get. We then
4021 * allocate an RSS ring for each.
4022 * Essentially, we are doing min(cpu_count, msix_vector_count).
4024 qdev
->intr_count
= cpu_cnt
;
4025 ql_enable_msix(qdev
);
4026 /* Adjust the RSS ring count to the actual vector count. */
4027 qdev
->rss_ring_count
= qdev
->intr_count
;
4028 qdev
->tx_ring_count
= cpu_cnt
;
4029 qdev
->rx_ring_count
= qdev
->tx_ring_count
+ qdev
->rss_ring_count
;
4031 for (i
= 0; i
< qdev
->tx_ring_count
; i
++) {
4032 tx_ring
= &qdev
->tx_ring
[i
];
4033 memset((void *)tx_ring
, 0, sizeof(*tx_ring
));
4034 tx_ring
->qdev
= qdev
;
4036 tx_ring
->wq_len
= qdev
->tx_ring_size
;
4038 tx_ring
->wq_len
* sizeof(struct ob_mac_iocb_req
);
4041 * The completion queue ID for the tx rings start
4042 * immediately after the rss rings.
4044 tx_ring
->cq_id
= qdev
->rss_ring_count
+ i
;
4047 for (i
= 0; i
< qdev
->rx_ring_count
; i
++) {
4048 rx_ring
= &qdev
->rx_ring
[i
];
4049 memset((void *)rx_ring
, 0, sizeof(*rx_ring
));
4050 rx_ring
->qdev
= qdev
;
4052 rx_ring
->cpu
= i
% cpu_cnt
; /* CPU to run handler on. */
4053 if (i
< qdev
->rss_ring_count
) {
4055 * Inbound (RSS) queues.
4057 rx_ring
->cq_len
= qdev
->rx_ring_size
;
4059 rx_ring
->cq_len
* sizeof(struct ql_net_rsp_iocb
);
4060 rx_ring
->lbq_len
= NUM_LARGE_BUFFERS
;
4062 rx_ring
->lbq_len
* sizeof(__le64
);
4063 rx_ring
->lbq_buf_size
= (u16
)lbq_buf_len
;
4064 netif_printk(qdev
, ifup
, KERN_DEBUG
, qdev
->ndev
,
4065 "lbq_buf_size %d, order = %d\n",
4066 rx_ring
->lbq_buf_size
,
4067 qdev
->lbq_buf_order
);
4068 rx_ring
->sbq_len
= NUM_SMALL_BUFFERS
;
4070 rx_ring
->sbq_len
* sizeof(__le64
);
4071 rx_ring
->sbq_buf_size
= SMALL_BUF_MAP_SIZE
;
4072 rx_ring
->type
= RX_Q
;
4075 * Outbound queue handles outbound completions only.
4077 /* outbound cq is same size as tx_ring it services. */
4078 rx_ring
->cq_len
= qdev
->tx_ring_size
;
4080 rx_ring
->cq_len
* sizeof(struct ql_net_rsp_iocb
);
4081 rx_ring
->lbq_len
= 0;
4082 rx_ring
->lbq_size
= 0;
4083 rx_ring
->lbq_buf_size
= 0;
4084 rx_ring
->sbq_len
= 0;
4085 rx_ring
->sbq_size
= 0;
4086 rx_ring
->sbq_buf_size
= 0;
4087 rx_ring
->type
= TX_Q
;
4093 static int qlge_open(struct net_device
*ndev
)
4096 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4098 err
= ql_adapter_reset(qdev
);
4102 err
= ql_configure_rings(qdev
);
4106 err
= ql_get_adapter_resources(qdev
);
4110 err
= ql_adapter_up(qdev
);
4117 ql_release_adapter_resources(qdev
);
4121 static int ql_change_rx_buffers(struct ql_adapter
*qdev
)
4123 struct rx_ring
*rx_ring
;
4127 /* Wait for an oustanding reset to complete. */
4128 if (!test_bit(QL_ADAPTER_UP
, &qdev
->flags
)) {
4130 while (i
-- && !test_bit(QL_ADAPTER_UP
, &qdev
->flags
)) {
4131 netif_err(qdev
, ifup
, qdev
->ndev
,
4132 "Waiting for adapter UP...\n");
4137 netif_err(qdev
, ifup
, qdev
->ndev
,
4138 "Timed out waiting for adapter UP\n");
4143 status
= ql_adapter_down(qdev
);
4147 /* Get the new rx buffer size. */
4148 lbq_buf_len
= (qdev
->ndev
->mtu
> 1500) ?
4149 LARGE_BUFFER_MAX_SIZE
: LARGE_BUFFER_MIN_SIZE
;
4150 qdev
->lbq_buf_order
= get_order(lbq_buf_len
);
4152 for (i
= 0; i
< qdev
->rss_ring_count
; i
++) {
4153 rx_ring
= &qdev
->rx_ring
[i
];
4154 /* Set the new size. */
4155 rx_ring
->lbq_buf_size
= lbq_buf_len
;
4158 status
= ql_adapter_up(qdev
);
4164 netif_alert(qdev
, ifup
, qdev
->ndev
,
4165 "Driver up/down cycle failed, closing device.\n");
4166 set_bit(QL_ADAPTER_UP
, &qdev
->flags
);
4167 dev_close(qdev
->ndev
);
4171 static int qlge_change_mtu(struct net_device
*ndev
, int new_mtu
)
4173 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4176 if (ndev
->mtu
== 1500 && new_mtu
== 9000) {
4177 netif_err(qdev
, ifup
, qdev
->ndev
, "Changing to jumbo MTU.\n");
4178 } else if (ndev
->mtu
== 9000 && new_mtu
== 1500) {
4179 netif_err(qdev
, ifup
, qdev
->ndev
, "Changing to normal MTU.\n");
4183 queue_delayed_work(qdev
->workqueue
,
4184 &qdev
->mpi_port_cfg_work
, 3*HZ
);
4186 ndev
->mtu
= new_mtu
;
4188 if (!netif_running(qdev
->ndev
)) {
4192 status
= ql_change_rx_buffers(qdev
);
4194 netif_err(qdev
, ifup
, qdev
->ndev
,
4195 "Changing MTU failed.\n");
4201 static struct net_device_stats
*qlge_get_stats(struct net_device
4204 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4205 struct rx_ring
*rx_ring
= &qdev
->rx_ring
[0];
4206 struct tx_ring
*tx_ring
= &qdev
->tx_ring
[0];
4207 unsigned long pkts
, mcast
, dropped
, errors
, bytes
;
4211 pkts
= mcast
= dropped
= errors
= bytes
= 0;
4212 for (i
= 0; i
< qdev
->rss_ring_count
; i
++, rx_ring
++) {
4213 pkts
+= rx_ring
->rx_packets
;
4214 bytes
+= rx_ring
->rx_bytes
;
4215 dropped
+= rx_ring
->rx_dropped
;
4216 errors
+= rx_ring
->rx_errors
;
4217 mcast
+= rx_ring
->rx_multicast
;
4219 ndev
->stats
.rx_packets
= pkts
;
4220 ndev
->stats
.rx_bytes
= bytes
;
4221 ndev
->stats
.rx_dropped
= dropped
;
4222 ndev
->stats
.rx_errors
= errors
;
4223 ndev
->stats
.multicast
= mcast
;
4226 pkts
= errors
= bytes
= 0;
4227 for (i
= 0; i
< qdev
->tx_ring_count
; i
++, tx_ring
++) {
4228 pkts
+= tx_ring
->tx_packets
;
4229 bytes
+= tx_ring
->tx_bytes
;
4230 errors
+= tx_ring
->tx_errors
;
4232 ndev
->stats
.tx_packets
= pkts
;
4233 ndev
->stats
.tx_bytes
= bytes
;
4234 ndev
->stats
.tx_errors
= errors
;
4235 return &ndev
->stats
;
4238 void qlge_set_multicast_list(struct net_device
*ndev
)
4240 struct ql_adapter
*qdev
= (struct ql_adapter
*)netdev_priv(ndev
);
4241 struct netdev_hw_addr
*ha
;
4244 status
= ql_sem_spinlock(qdev
, SEM_RT_IDX_MASK
);
4248 * Set or clear promiscuous mode if a
4249 * transition is taking place.
4251 if (ndev
->flags
& IFF_PROMISC
) {
4252 if (!test_bit(QL_PROMISCUOUS
, &qdev
->flags
)) {
4253 if (ql_set_routing_reg
4254 (qdev
, RT_IDX_PROMISCUOUS_SLOT
, RT_IDX_VALID
, 1)) {
4255 netif_err(qdev
, hw
, qdev
->ndev
,
4256 "Failed to set promiscous mode.\n");
4258 set_bit(QL_PROMISCUOUS
, &qdev
->flags
);
4262 if (test_bit(QL_PROMISCUOUS
, &qdev
->flags
)) {
4263 if (ql_set_routing_reg
4264 (qdev
, RT_IDX_PROMISCUOUS_SLOT
, RT_IDX_VALID
, 0)) {
4265 netif_err(qdev
, hw
, qdev
->ndev
,
4266 "Failed to clear promiscous mode.\n");
4268 clear_bit(QL_PROMISCUOUS
, &qdev
->flags
);
4274 * Set or clear all multicast mode if a
4275 * transition is taking place.
4277 if ((ndev
->flags
& IFF_ALLMULTI
) ||
4278 (netdev_mc_count(ndev
) > MAX_MULTICAST_ENTRIES
)) {
4279 if (!test_bit(QL_ALLMULTI
, &qdev
->flags
)) {
4280 if (ql_set_routing_reg
4281 (qdev
, RT_IDX_ALLMULTI_SLOT
, RT_IDX_MCAST
, 1)) {
4282 netif_err(qdev
, hw
, qdev
->ndev
,
4283 "Failed to set all-multi mode.\n");
4285 set_bit(QL_ALLMULTI
, &qdev
->flags
);
4289 if (test_bit(QL_ALLMULTI
, &qdev
->flags
)) {
4290 if (ql_set_routing_reg
4291 (qdev
, RT_IDX_ALLMULTI_SLOT
, RT_IDX_MCAST
, 0)) {
4292 netif_err(qdev
, hw
, qdev
->ndev
,
4293 "Failed to clear all-multi mode.\n");
4295 clear_bit(QL_ALLMULTI
, &qdev
->flags
);
4300 if (!netdev_mc_empty(ndev
)) {
4301 status
= ql_sem_spinlock(qdev
, SEM_MAC_ADDR_MASK
);
4305 netdev_for_each_mc_addr(ha
, ndev
) {
4306 if (ql_set_mac_addr_reg(qdev
, (u8
*) ha
->addr
,
4307 MAC_ADDR_TYPE_MULTI_MAC
, i
)) {
4308 netif_err(qdev
, hw
, qdev
->ndev
,
4309 "Failed to loadmulticast address.\n");
4310 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
4315 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
4316 if (ql_set_routing_reg
4317 (qdev
, RT_IDX_MCAST_MATCH_SLOT
, RT_IDX_MCAST_MATCH
, 1)) {
4318 netif_err(qdev
, hw
, qdev
->ndev
,
4319 "Failed to set multicast match mode.\n");
4321 set_bit(QL_ALLMULTI
, &qdev
->flags
);
4325 ql_sem_unlock(qdev
, SEM_RT_IDX_MASK
);
4328 static int qlge_set_mac_address(struct net_device
*ndev
, void *p
)
4330 struct ql_adapter
*qdev
= (struct ql_adapter
*)netdev_priv(ndev
);
4331 struct sockaddr
*addr
= p
;
4334 if (!is_valid_ether_addr(addr
->sa_data
))
4335 return -EADDRNOTAVAIL
;
4336 memcpy(ndev
->dev_addr
, addr
->sa_data
, ndev
->addr_len
);
4337 /* Update local copy of current mac address. */
4338 memcpy(qdev
->current_mac_addr
, ndev
->dev_addr
, ndev
->addr_len
);
4340 status
= ql_sem_spinlock(qdev
, SEM_MAC_ADDR_MASK
);
4343 status
= ql_set_mac_addr_reg(qdev
, (u8
*) ndev
->dev_addr
,
4344 MAC_ADDR_TYPE_CAM_MAC
, qdev
->func
* MAX_CQ
);
4346 netif_err(qdev
, hw
, qdev
->ndev
, "Failed to load MAC address.\n");
4347 ql_sem_unlock(qdev
, SEM_MAC_ADDR_MASK
);
4351 static void qlge_tx_timeout(struct net_device
*ndev
)
4353 struct ql_adapter
*qdev
= (struct ql_adapter
*)netdev_priv(ndev
);
4354 ql_queue_asic_error(qdev
);
4357 static void ql_asic_reset_work(struct work_struct
*work
)
4359 struct ql_adapter
*qdev
=
4360 container_of(work
, struct ql_adapter
, asic_reset_work
.work
);
4363 status
= ql_adapter_down(qdev
);
4367 status
= ql_adapter_up(qdev
);
4371 /* Restore rx mode. */
4372 clear_bit(QL_ALLMULTI
, &qdev
->flags
);
4373 clear_bit(QL_PROMISCUOUS
, &qdev
->flags
);
4374 qlge_set_multicast_list(qdev
->ndev
);
4379 netif_alert(qdev
, ifup
, qdev
->ndev
,
4380 "Driver up/down cycle failed, closing device\n");
4382 set_bit(QL_ADAPTER_UP
, &qdev
->flags
);
4383 dev_close(qdev
->ndev
);
4387 static struct nic_operations qla8012_nic_ops
= {
4388 .get_flash
= ql_get_8012_flash_params
,
4389 .port_initialize
= ql_8012_port_initialize
,
4392 static struct nic_operations qla8000_nic_ops
= {
4393 .get_flash
= ql_get_8000_flash_params
,
4394 .port_initialize
= ql_8000_port_initialize
,
4397 /* Find the pcie function number for the other NIC
4398 * on this chip. Since both NIC functions share a
4399 * common firmware we have the lowest enabled function
4400 * do any common work. Examples would be resetting
4401 * after a fatal firmware error, or doing a firmware
4404 static int ql_get_alt_pcie_func(struct ql_adapter
*qdev
)
4408 u32 nic_func1
, nic_func2
;
4410 status
= ql_read_mpi_reg(qdev
, MPI_TEST_FUNC_PORT_CFG
,
4415 nic_func1
= ((temp
>> MPI_TEST_NIC1_FUNC_SHIFT
) &
4416 MPI_TEST_NIC_FUNC_MASK
);
4417 nic_func2
= ((temp
>> MPI_TEST_NIC2_FUNC_SHIFT
) &
4418 MPI_TEST_NIC_FUNC_MASK
);
4420 if (qdev
->func
== nic_func1
)
4421 qdev
->alt_func
= nic_func2
;
4422 else if (qdev
->func
== nic_func2
)
4423 qdev
->alt_func
= nic_func1
;
4430 static int ql_get_board_info(struct ql_adapter
*qdev
)
4434 (ql_read32(qdev
, STS
) & STS_FUNC_ID_MASK
) >> STS_FUNC_ID_SHIFT
;
4438 status
= ql_get_alt_pcie_func(qdev
);
4442 qdev
->port
= (qdev
->func
< qdev
->alt_func
) ? 0 : 1;
4444 qdev
->xg_sem_mask
= SEM_XGMAC1_MASK
;
4445 qdev
->port_link_up
= STS_PL1
;
4446 qdev
->port_init
= STS_PI1
;
4447 qdev
->mailbox_in
= PROC_ADDR_MPI_RISC
| PROC_ADDR_FUNC2_MBI
;
4448 qdev
->mailbox_out
= PROC_ADDR_MPI_RISC
| PROC_ADDR_FUNC2_MBO
;
4450 qdev
->xg_sem_mask
= SEM_XGMAC0_MASK
;
4451 qdev
->port_link_up
= STS_PL0
;
4452 qdev
->port_init
= STS_PI0
;
4453 qdev
->mailbox_in
= PROC_ADDR_MPI_RISC
| PROC_ADDR_FUNC0_MBI
;
4454 qdev
->mailbox_out
= PROC_ADDR_MPI_RISC
| PROC_ADDR_FUNC0_MBO
;
4456 qdev
->chip_rev_id
= ql_read32(qdev
, REV_ID
);
4457 qdev
->device_id
= qdev
->pdev
->device
;
4458 if (qdev
->device_id
== QLGE_DEVICE_ID_8012
)
4459 qdev
->nic_ops
= &qla8012_nic_ops
;
4460 else if (qdev
->device_id
== QLGE_DEVICE_ID_8000
)
4461 qdev
->nic_ops
= &qla8000_nic_ops
;
4465 static void ql_release_all(struct pci_dev
*pdev
)
4467 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4468 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4470 if (qdev
->workqueue
) {
4471 destroy_workqueue(qdev
->workqueue
);
4472 qdev
->workqueue
= NULL
;
4476 iounmap(qdev
->reg_base
);
4477 if (qdev
->doorbell_area
)
4478 iounmap(qdev
->doorbell_area
);
4479 vfree(qdev
->mpi_coredump
);
4480 pci_release_regions(pdev
);
4481 pci_set_drvdata(pdev
, NULL
);
4484 static int __devinit
ql_init_device(struct pci_dev
*pdev
,
4485 struct net_device
*ndev
, int cards_found
)
4487 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4490 memset((void *)qdev
, 0, sizeof(*qdev
));
4491 err
= pci_enable_device(pdev
);
4493 dev_err(&pdev
->dev
, "PCI device enable failed.\n");
4499 pci_set_drvdata(pdev
, ndev
);
4501 /* Set PCIe read request size */
4502 err
= pcie_set_readrq(pdev
, 4096);
4504 dev_err(&pdev
->dev
, "Set readrq failed.\n");
4508 err
= pci_request_regions(pdev
, DRV_NAME
);
4510 dev_err(&pdev
->dev
, "PCI region request failed.\n");
4514 pci_set_master(pdev
);
4515 if (!pci_set_dma_mask(pdev
, DMA_BIT_MASK(64))) {
4516 set_bit(QL_DMA64
, &qdev
->flags
);
4517 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64));
4519 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
4521 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
4525 dev_err(&pdev
->dev
, "No usable DMA configuration.\n");
4529 /* Set PCIe reset type for EEH to fundamental. */
4530 pdev
->needs_freset
= 1;
4531 pci_save_state(pdev
);
4533 ioremap_nocache(pci_resource_start(pdev
, 1),
4534 pci_resource_len(pdev
, 1));
4535 if (!qdev
->reg_base
) {
4536 dev_err(&pdev
->dev
, "Register mapping failed.\n");
4541 qdev
->doorbell_area_size
= pci_resource_len(pdev
, 3);
4542 qdev
->doorbell_area
=
4543 ioremap_nocache(pci_resource_start(pdev
, 3),
4544 pci_resource_len(pdev
, 3));
4545 if (!qdev
->doorbell_area
) {
4546 dev_err(&pdev
->dev
, "Doorbell register mapping failed.\n");
4551 err
= ql_get_board_info(qdev
);
4553 dev_err(&pdev
->dev
, "Register access failed.\n");
4557 qdev
->msg_enable
= netif_msg_init(debug
, default_msg
);
4558 spin_lock_init(&qdev
->hw_lock
);
4559 spin_lock_init(&qdev
->stats_lock
);
4561 if (qlge_mpi_coredump
) {
4562 qdev
->mpi_coredump
=
4563 vmalloc(sizeof(struct ql_mpi_coredump
));
4564 if (qdev
->mpi_coredump
== NULL
) {
4565 dev_err(&pdev
->dev
, "Coredump alloc failed.\n");
4569 if (qlge_force_coredump
)
4570 set_bit(QL_FRC_COREDUMP
, &qdev
->flags
);
4572 /* make sure the EEPROM is good */
4573 err
= qdev
->nic_ops
->get_flash(qdev
);
4575 dev_err(&pdev
->dev
, "Invalid FLASH.\n");
4579 memcpy(ndev
->perm_addr
, ndev
->dev_addr
, ndev
->addr_len
);
4580 /* Keep local copy of current mac address. */
4581 memcpy(qdev
->current_mac_addr
, ndev
->dev_addr
, ndev
->addr_len
);
4583 /* Set up the default ring sizes. */
4584 qdev
->tx_ring_size
= NUM_TX_RING_ENTRIES
;
4585 qdev
->rx_ring_size
= NUM_RX_RING_ENTRIES
;
4587 /* Set up the coalescing parameters. */
4588 qdev
->rx_coalesce_usecs
= DFLT_COALESCE_WAIT
;
4589 qdev
->tx_coalesce_usecs
= DFLT_COALESCE_WAIT
;
4590 qdev
->rx_max_coalesced_frames
= DFLT_INTER_FRAME_WAIT
;
4591 qdev
->tx_max_coalesced_frames
= DFLT_INTER_FRAME_WAIT
;
4594 * Set up the operating parameters.
4597 qdev
->workqueue
= create_singlethread_workqueue(ndev
->name
);
4598 INIT_DELAYED_WORK(&qdev
->asic_reset_work
, ql_asic_reset_work
);
4599 INIT_DELAYED_WORK(&qdev
->mpi_reset_work
, ql_mpi_reset_work
);
4600 INIT_DELAYED_WORK(&qdev
->mpi_work
, ql_mpi_work
);
4601 INIT_DELAYED_WORK(&qdev
->mpi_port_cfg_work
, ql_mpi_port_cfg_work
);
4602 INIT_DELAYED_WORK(&qdev
->mpi_idc_work
, ql_mpi_idc_work
);
4603 INIT_DELAYED_WORK(&qdev
->mpi_core_to_log
, ql_mpi_core_to_log
);
4604 init_completion(&qdev
->ide_completion
);
4607 dev_info(&pdev
->dev
, "%s\n", DRV_STRING
);
4608 dev_info(&pdev
->dev
, "Driver name: %s, Version: %s.\n",
4609 DRV_NAME
, DRV_VERSION
);
4613 ql_release_all(pdev
);
4615 pci_disable_device(pdev
);
4619 static const struct net_device_ops qlge_netdev_ops
= {
4620 .ndo_open
= qlge_open
,
4621 .ndo_stop
= qlge_close
,
4622 .ndo_start_xmit
= qlge_send
,
4623 .ndo_change_mtu
= qlge_change_mtu
,
4624 .ndo_get_stats
= qlge_get_stats
,
4625 .ndo_set_multicast_list
= qlge_set_multicast_list
,
4626 .ndo_set_mac_address
= qlge_set_mac_address
,
4627 .ndo_validate_addr
= eth_validate_addr
,
4628 .ndo_tx_timeout
= qlge_tx_timeout
,
4629 .ndo_vlan_rx_register
= qlge_vlan_rx_register
,
4630 .ndo_vlan_rx_add_vid
= qlge_vlan_rx_add_vid
,
4631 .ndo_vlan_rx_kill_vid
= qlge_vlan_rx_kill_vid
,
4634 static void ql_timer(unsigned long data
)
4636 struct ql_adapter
*qdev
= (struct ql_adapter
*)data
;
4639 var
= ql_read32(qdev
, STS
);
4640 if (pci_channel_offline(qdev
->pdev
)) {
4641 netif_err(qdev
, ifup
, qdev
->ndev
, "EEH STS = 0x%.08x.\n", var
);
4645 mod_timer(&qdev
->timer
, jiffies
+ (5*HZ
));
4648 static int __devinit
qlge_probe(struct pci_dev
*pdev
,
4649 const struct pci_device_id
*pci_entry
)
4651 struct net_device
*ndev
= NULL
;
4652 struct ql_adapter
*qdev
= NULL
;
4653 static int cards_found
= 0;
4656 ndev
= alloc_etherdev_mq(sizeof(struct ql_adapter
),
4657 min(MAX_CPUS
, (int)num_online_cpus()));
4661 err
= ql_init_device(pdev
, ndev
, cards_found
);
4667 qdev
= netdev_priv(ndev
);
4668 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
4675 | NETIF_F_HW_VLAN_TX
4676 | NETIF_F_HW_VLAN_RX
| NETIF_F_HW_VLAN_FILTER
);
4677 ndev
->features
|= NETIF_F_GRO
;
4679 if (test_bit(QL_DMA64
, &qdev
->flags
))
4680 ndev
->features
|= NETIF_F_HIGHDMA
;
4683 * Set up net_device structure.
4685 ndev
->tx_queue_len
= qdev
->tx_ring_size
;
4686 ndev
->irq
= pdev
->irq
;
4688 ndev
->netdev_ops
= &qlge_netdev_ops
;
4689 SET_ETHTOOL_OPS(ndev
, &qlge_ethtool_ops
);
4690 ndev
->watchdog_timeo
= 10 * HZ
;
4692 err
= register_netdev(ndev
);
4694 dev_err(&pdev
->dev
, "net device registration failed.\n");
4695 ql_release_all(pdev
);
4696 pci_disable_device(pdev
);
4699 /* Start up the timer to trigger EEH if
4702 init_timer_deferrable(&qdev
->timer
);
4703 qdev
->timer
.data
= (unsigned long)qdev
;
4704 qdev
->timer
.function
= ql_timer
;
4705 qdev
->timer
.expires
= jiffies
+ (5*HZ
);
4706 add_timer(&qdev
->timer
);
4708 ql_display_dev_info(ndev
);
4709 atomic_set(&qdev
->lb_count
, 0);
4714 netdev_tx_t
ql_lb_send(struct sk_buff
*skb
, struct net_device
*ndev
)
4716 return qlge_send(skb
, ndev
);
4719 int ql_clean_lb_rx_ring(struct rx_ring
*rx_ring
, int budget
)
4721 return ql_clean_inbound_rx_ring(rx_ring
, budget
);
4724 static void __devexit
qlge_remove(struct pci_dev
*pdev
)
4726 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4727 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4728 del_timer_sync(&qdev
->timer
);
4729 unregister_netdev(ndev
);
4730 ql_release_all(pdev
);
4731 pci_disable_device(pdev
);
4735 /* Clean up resources without touching hardware. */
4736 static void ql_eeh_close(struct net_device
*ndev
)
4739 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4741 if (netif_carrier_ok(ndev
)) {
4742 netif_carrier_off(ndev
);
4743 netif_stop_queue(ndev
);
4746 /* Disabling the timer */
4747 del_timer_sync(&qdev
->timer
);
4748 if (test_bit(QL_ADAPTER_UP
, &qdev
->flags
))
4749 cancel_delayed_work_sync(&qdev
->asic_reset_work
);
4750 cancel_delayed_work_sync(&qdev
->mpi_reset_work
);
4751 cancel_delayed_work_sync(&qdev
->mpi_work
);
4752 cancel_delayed_work_sync(&qdev
->mpi_idc_work
);
4753 cancel_delayed_work_sync(&qdev
->mpi_core_to_log
);
4754 cancel_delayed_work_sync(&qdev
->mpi_port_cfg_work
);
4756 for (i
= 0; i
< qdev
->rss_ring_count
; i
++)
4757 netif_napi_del(&qdev
->rx_ring
[i
].napi
);
4759 clear_bit(QL_ADAPTER_UP
, &qdev
->flags
);
4760 ql_tx_ring_clean(qdev
);
4761 ql_free_rx_buffers(qdev
);
4762 ql_release_adapter_resources(qdev
);
4766 * This callback is called by the PCI subsystem whenever
4767 * a PCI bus error is detected.
4769 static pci_ers_result_t
qlge_io_error_detected(struct pci_dev
*pdev
,
4770 enum pci_channel_state state
)
4772 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4773 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4776 case pci_channel_io_normal
:
4777 return PCI_ERS_RESULT_CAN_RECOVER
;
4778 case pci_channel_io_frozen
:
4779 netif_device_detach(ndev
);
4780 if (netif_running(ndev
))
4782 pci_disable_device(pdev
);
4783 return PCI_ERS_RESULT_NEED_RESET
;
4784 case pci_channel_io_perm_failure
:
4786 "%s: pci_channel_io_perm_failure.\n", __func__
);
4788 set_bit(QL_EEH_FATAL
, &qdev
->flags
);
4789 return PCI_ERS_RESULT_DISCONNECT
;
4792 /* Request a slot reset. */
4793 return PCI_ERS_RESULT_NEED_RESET
;
4797 * This callback is called after the PCI buss has been reset.
4798 * Basically, this tries to restart the card from scratch.
4799 * This is a shortened version of the device probe/discovery code,
4800 * it resembles the first-half of the () routine.
4802 static pci_ers_result_t
qlge_io_slot_reset(struct pci_dev
*pdev
)
4804 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4805 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4807 pdev
->error_state
= pci_channel_io_normal
;
4809 pci_restore_state(pdev
);
4810 if (pci_enable_device(pdev
)) {
4811 netif_err(qdev
, ifup
, qdev
->ndev
,
4812 "Cannot re-enable PCI device after reset.\n");
4813 return PCI_ERS_RESULT_DISCONNECT
;
4815 pci_set_master(pdev
);
4817 if (ql_adapter_reset(qdev
)) {
4818 netif_err(qdev
, drv
, qdev
->ndev
, "reset FAILED!\n");
4819 set_bit(QL_EEH_FATAL
, &qdev
->flags
);
4820 return PCI_ERS_RESULT_DISCONNECT
;
4823 return PCI_ERS_RESULT_RECOVERED
;
4826 static void qlge_io_resume(struct pci_dev
*pdev
)
4828 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4829 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4832 if (netif_running(ndev
)) {
4833 err
= qlge_open(ndev
);
4835 netif_err(qdev
, ifup
, qdev
->ndev
,
4836 "Device initialization failed after reset.\n");
4840 netif_err(qdev
, ifup
, qdev
->ndev
,
4841 "Device was not running prior to EEH.\n");
4843 mod_timer(&qdev
->timer
, jiffies
+ (5*HZ
));
4844 netif_device_attach(ndev
);
4847 static struct pci_error_handlers qlge_err_handler
= {
4848 .error_detected
= qlge_io_error_detected
,
4849 .slot_reset
= qlge_io_slot_reset
,
4850 .resume
= qlge_io_resume
,
4853 static int qlge_suspend(struct pci_dev
*pdev
, pm_message_t state
)
4855 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4856 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4859 netif_device_detach(ndev
);
4860 del_timer_sync(&qdev
->timer
);
4862 if (netif_running(ndev
)) {
4863 err
= ql_adapter_down(qdev
);
4869 err
= pci_save_state(pdev
);
4873 pci_disable_device(pdev
);
4875 pci_set_power_state(pdev
, pci_choose_state(pdev
, state
));
4881 static int qlge_resume(struct pci_dev
*pdev
)
4883 struct net_device
*ndev
= pci_get_drvdata(pdev
);
4884 struct ql_adapter
*qdev
= netdev_priv(ndev
);
4887 pci_set_power_state(pdev
, PCI_D0
);
4888 pci_restore_state(pdev
);
4889 err
= pci_enable_device(pdev
);
4891 netif_err(qdev
, ifup
, qdev
->ndev
, "Cannot enable PCI device from suspend\n");
4894 pci_set_master(pdev
);
4896 pci_enable_wake(pdev
, PCI_D3hot
, 0);
4897 pci_enable_wake(pdev
, PCI_D3cold
, 0);
4899 if (netif_running(ndev
)) {
4900 err
= ql_adapter_up(qdev
);
4905 mod_timer(&qdev
->timer
, jiffies
+ (5*HZ
));
4906 netif_device_attach(ndev
);
4910 #endif /* CONFIG_PM */
4912 static void qlge_shutdown(struct pci_dev
*pdev
)
4914 qlge_suspend(pdev
, PMSG_SUSPEND
);
4917 static struct pci_driver qlge_driver
= {
4919 .id_table
= qlge_pci_tbl
,
4920 .probe
= qlge_probe
,
4921 .remove
= __devexit_p(qlge_remove
),
4923 .suspend
= qlge_suspend
,
4924 .resume
= qlge_resume
,
4926 .shutdown
= qlge_shutdown
,
4927 .err_handler
= &qlge_err_handler
4930 static int __init
qlge_init_module(void)
4932 return pci_register_driver(&qlge_driver
);
4935 static void __exit
qlge_exit(void)
4937 pci_unregister_driver(&qlge_driver
);
4940 module_init(qlge_init_module
);
4941 module_exit(qlge_exit
);