1 /*******************************************************************************
3 Copyright (c) 2001-2004, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
32 ***************************************************************************/
36 #ifdef HAVE_KERNEL_OPTION_HEADERS
37 #include "opt_device_polling.h"
40 #include <dev/ixgb/if_ixgb.h>
42 /*********************************************************************
43 * Set this to one to display debug statistics
44 *********************************************************************/
45 int ixgb_display_debug_stats = 0;
47 /*********************************************************************
48 * Linked list of board private structures for all NICs found
49 *********************************************************************/
51 struct adapter *ixgb_adapter_list = NULL;
55 /*********************************************************************
57 *********************************************************************/
59 char ixgb_driver_version[] = "1.0.6";
60 char ixgb_copyright[] = "Copyright (c) 2001-2004 Intel Corporation.";
62 /*********************************************************************
65 * Used by probe to select devices to load on
66 * Last field stores an index into ixgb_strings
67 * Last entry must be all 0s
69 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index }
70 *********************************************************************/
72 static ixgb_vendor_info_t ixgb_vendor_info_array[] =
74 /* Intel(R) PRO/10000 Network Connection */
75 {IXGB_VENDOR_ID, IXGB_DEVICE_ID_82597EX, PCI_ANY_ID, PCI_ANY_ID, 0},
76 {IXGB_VENDOR_ID, IXGB_DEVICE_ID_82597EX_SR, PCI_ANY_ID, PCI_ANY_ID, 0},
77 /* required last entry */
81 /*********************************************************************
82 * Table of branding strings for all supported NICs.
83 *********************************************************************/
85 static char *ixgb_strings[] = {
86 "Intel(R) PRO/10GbE Network Driver"
89 /*********************************************************************
91 *********************************************************************/
92 static int ixgb_probe(device_t);
93 static int ixgb_attach(device_t);
94 static int ixgb_detach(device_t);
95 static int ixgb_shutdown(device_t);
96 static void ixgb_intr(void *);
97 static void ixgb_start(struct ifnet *);
98 static void ixgb_start_locked(struct ifnet *);
99 static int ixgb_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t);
100 static uint64_t ixgb_get_counter(struct ifnet *, ift_counter);
101 static void ixgb_watchdog(struct adapter *);
102 static void ixgb_init(void *);
103 static void ixgb_init_locked(struct adapter *);
104 static void ixgb_stop(void *);
105 static void ixgb_media_status(struct ifnet *, struct ifmediareq *);
106 static int ixgb_media_change(struct ifnet *);
107 static void ixgb_identify_hardware(struct adapter *);
108 static int ixgb_allocate_pci_resources(struct adapter *);
109 static void ixgb_free_pci_resources(struct adapter *);
110 static void ixgb_local_timer(void *);
111 static int ixgb_hardware_init(struct adapter *);
112 static int ixgb_setup_interface(device_t, struct adapter *);
113 static int ixgb_setup_transmit_structures(struct adapter *);
114 static void ixgb_initialize_transmit_unit(struct adapter *);
115 static int ixgb_setup_receive_structures(struct adapter *);
116 static void ixgb_initialize_receive_unit(struct adapter *);
117 static void ixgb_enable_intr(struct adapter *);
118 static void ixgb_disable_intr(struct adapter *);
119 static void ixgb_free_transmit_structures(struct adapter *);
120 static void ixgb_free_receive_structures(struct adapter *);
121 static void ixgb_update_stats_counters(struct adapter *);
122 static void ixgb_clean_transmit_interrupts(struct adapter *);
123 static int ixgb_allocate_receive_structures(struct adapter *);
124 static int ixgb_allocate_transmit_structures(struct adapter *);
125 static int ixgb_process_receive_interrupts(struct adapter *, int);
127 ixgb_receive_checksum(struct adapter *,
128 struct ixgb_rx_desc * rx_desc,
131 ixgb_transmit_checksum_setup(struct adapter *,
134 static void ixgb_set_promisc(struct adapter *);
135 static void ixgb_disable_promisc(struct adapter *);
136 static void ixgb_set_multi(struct adapter *);
137 static void ixgb_print_hw_stats(struct adapter *);
138 static void ixgb_print_link_status(struct adapter *);
140 ixgb_get_buf(int i, struct adapter *,
142 static void ixgb_enable_vlans(struct adapter * adapter);
143 static int ixgb_encap(struct adapter * adapter, struct mbuf * m_head);
144 static int ixgb_sysctl_stats(SYSCTL_HANDLER_ARGS);
146 ixgb_dma_malloc(struct adapter *, bus_size_t,
147 struct ixgb_dma_alloc *, int);
148 static void ixgb_dma_free(struct adapter *, struct ixgb_dma_alloc *);
149 #ifdef DEVICE_POLLING
150 static poll_handler_t ixgb_poll;
153 /*********************************************************************
154 * FreeBSD Device Interface Entry Points
155 *********************************************************************/
157 static device_method_t ixgb_methods[] = {
158 /* Device interface */
159 DEVMETHOD(device_probe, ixgb_probe),
160 DEVMETHOD(device_attach, ixgb_attach),
161 DEVMETHOD(device_detach, ixgb_detach),
162 DEVMETHOD(device_shutdown, ixgb_shutdown),
167 static driver_t ixgb_driver = {
168 "ixgb", ixgb_methods, sizeof(struct adapter),
171 static devclass_t ixgb_devclass;
172 DRIVER_MODULE(ixgb, pci, ixgb_driver, ixgb_devclass, 0, 0);
174 MODULE_DEPEND(ixgb, pci, 1, 1, 1);
175 MODULE_DEPEND(ixgb, ether, 1, 1, 1);
177 /* some defines for controlling descriptor fetches in h/w */
178 #define RXDCTL_PTHRESH_DEFAULT 128 /* chip considers prefech below this */
179 #define RXDCTL_HTHRESH_DEFAULT 16 /* chip will only prefetch if tail is
180 * pushed this many descriptors from
182 #define RXDCTL_WTHRESH_DEFAULT 0 /* chip writes back at this many or RXT0 */
185 /*********************************************************************
186 * Device identification routine
188 * ixgb_probe determines if the driver should be loaded on
189 * adapter based on PCI vendor/device id of the adapter.
191 * return 0 on success, positive on failure
192 *********************************************************************/
195 ixgb_probe(device_t dev)
197 ixgb_vendor_info_t *ent;
199 u_int16_t pci_vendor_id = 0;
200 u_int16_t pci_device_id = 0;
201 u_int16_t pci_subvendor_id = 0;
202 u_int16_t pci_subdevice_id = 0;
203 char adapter_name[60];
205 INIT_DEBUGOUT("ixgb_probe: begin");
207 pci_vendor_id = pci_get_vendor(dev);
208 if (pci_vendor_id != IXGB_VENDOR_ID)
211 pci_device_id = pci_get_device(dev);
212 pci_subvendor_id = pci_get_subvendor(dev);
213 pci_subdevice_id = pci_get_subdevice(dev);
215 ent = ixgb_vendor_info_array;
216 while (ent->vendor_id != 0) {
217 if ((pci_vendor_id == ent->vendor_id) &&
218 (pci_device_id == ent->device_id) &&
220 ((pci_subvendor_id == ent->subvendor_id) ||
221 (ent->subvendor_id == PCI_ANY_ID)) &&
223 ((pci_subdevice_id == ent->subdevice_id) ||
224 (ent->subdevice_id == PCI_ANY_ID))) {
225 sprintf(adapter_name, "%s, Version - %s",
226 ixgb_strings[ent->index],
227 ixgb_driver_version);
228 device_set_desc_copy(dev, adapter_name);
229 return (BUS_PROBE_DEFAULT);
237 /*********************************************************************
238 * Device initialization routine
240 * The attach entry point is called when the driver is being loaded.
241 * This routine identifies the type of hardware, allocates all resources
242 * and initializes the hardware.
244 * return 0 on success, positive on failure
245 *********************************************************************/
248 ixgb_attach(device_t dev)
250 struct adapter *adapter;
254 device_printf(dev, "%s\n", ixgb_copyright);
255 INIT_DEBUGOUT("ixgb_attach: begin");
257 /* Allocate, clear, and link in our adapter structure */
258 if (!(adapter = device_get_softc(dev))) {
259 device_printf(dev, "adapter structure allocation failed\n");
262 bzero(adapter, sizeof(struct adapter));
264 adapter->osdep.dev = dev;
265 IXGB_LOCK_INIT(adapter, device_get_nameunit(dev));
267 if (ixgb_adapter_list != NULL)
268 ixgb_adapter_list->prev = adapter;
269 adapter->next = ixgb_adapter_list;
270 ixgb_adapter_list = adapter;
273 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
274 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
275 OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RW,
277 ixgb_sysctl_stats, "I", "Statistics");
279 callout_init_mtx(&adapter->timer, &adapter->mtx, 0);
281 /* Determine hardware revision */
282 ixgb_identify_hardware(adapter);
284 /* Parameters (to be read from user) */
285 adapter->num_tx_desc = IXGB_MAX_TXD;
286 adapter->num_rx_desc = IXGB_MAX_RXD;
287 adapter->tx_int_delay = TIDV;
288 adapter->rx_int_delay = RDTR;
289 adapter->rx_buffer_len = IXGB_RXBUFFER_2048;
291 adapter->hw.fc.high_water = FCRTH;
292 adapter->hw.fc.low_water = FCRTL;
293 adapter->hw.fc.pause_time = FCPAUSE;
294 adapter->hw.fc.send_xon = TRUE;
295 adapter->hw.fc.type = FLOW_CONTROL;
298 /* Set the max frame size assuming standard ethernet sized frames */
299 adapter->hw.max_frame_size =
300 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN;
302 if (ixgb_allocate_pci_resources(adapter)) {
303 device_printf(dev, "Allocation of PCI resources failed\n");
307 tsize = IXGB_ROUNDUP(adapter->num_tx_desc *
308 sizeof(struct ixgb_tx_desc), 4096);
310 /* Allocate Transmit Descriptor ring */
311 if (ixgb_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) {
312 device_printf(dev, "Unable to allocate TxDescriptor memory\n");
316 adapter->tx_desc_base = (struct ixgb_tx_desc *) adapter->txdma.dma_vaddr;
318 rsize = IXGB_ROUNDUP(adapter->num_rx_desc *
319 sizeof(struct ixgb_rx_desc), 4096);
321 /* Allocate Receive Descriptor ring */
322 if (ixgb_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) {
323 device_printf(dev, "Unable to allocate rx_desc memory\n");
327 adapter->rx_desc_base = (struct ixgb_rx_desc *) adapter->rxdma.dma_vaddr;
329 /* Allocate multicast array memory. */
330 adapter->mta = malloc(sizeof(u_int8_t) * IXGB_ETH_LENGTH_OF_ADDRESS *
331 MAX_NUM_MULTICAST_ADDRESSES, M_DEVBUF, M_NOWAIT);
332 if (adapter->mta == NULL) {
333 device_printf(dev, "Can not allocate multicast setup array\n");
338 /* Initialize the hardware */
339 if (ixgb_hardware_init(adapter)) {
340 device_printf(dev, "Unable to initialize the hardware\n");
344 /* Setup OS specific network interface */
345 if (ixgb_setup_interface(dev, adapter) != 0)
348 /* Initialize statistics */
349 ixgb_clear_hw_cntrs(&adapter->hw);
350 ixgb_update_stats_counters(adapter);
352 INIT_DEBUGOUT("ixgb_attach: end");
356 ixgb_dma_free(adapter, &adapter->rxdma);
358 ixgb_dma_free(adapter, &adapter->txdma);
361 if (adapter->ifp != NULL)
362 if_free(adapter->ifp);
363 ixgb_free_pci_resources(adapter);
364 sysctl_ctx_free(&adapter->sysctl_ctx);
365 free(adapter->mta, M_DEVBUF);
370 /*********************************************************************
371 * Device removal routine
373 * The detach entry point is called when the driver is being removed.
374 * This routine stops the adapter and deallocates all the resources
375 * that were allocated for driver operation.
377 * return 0 on success, positive on failure
378 *********************************************************************/
381 ixgb_detach(device_t dev)
383 struct adapter *adapter = device_get_softc(dev);
384 struct ifnet *ifp = adapter->ifp;
386 INIT_DEBUGOUT("ixgb_detach: begin");
388 #ifdef DEVICE_POLLING
389 if (ifp->if_capenable & IFCAP_POLLING)
390 ether_poll_deregister(ifp);
394 adapter->in_detach = 1;
397 IXGB_UNLOCK(adapter);
399 #if __FreeBSD_version < 500000
400 ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
404 callout_drain(&adapter->timer);
405 ixgb_free_pci_resources(adapter);
406 #if __FreeBSD_version >= 500000
410 /* Free Transmit Descriptor ring */
411 if (adapter->tx_desc_base) {
412 ixgb_dma_free(adapter, &adapter->txdma);
413 adapter->tx_desc_base = NULL;
415 /* Free Receive Descriptor ring */
416 if (adapter->rx_desc_base) {
417 ixgb_dma_free(adapter, &adapter->rxdma);
418 adapter->rx_desc_base = NULL;
420 /* Remove from the adapter list */
421 if (ixgb_adapter_list == adapter)
422 ixgb_adapter_list = adapter->next;
423 if (adapter->next != NULL)
424 adapter->next->prev = adapter->prev;
425 if (adapter->prev != NULL)
426 adapter->prev->next = adapter->next;
427 free(adapter->mta, M_DEVBUF);
429 IXGB_LOCK_DESTROY(adapter);
433 /*********************************************************************
435 * Shutdown entry point
437 **********************************************************************/
440 ixgb_shutdown(device_t dev)
442 struct adapter *adapter = device_get_softc(dev);
445 IXGB_UNLOCK(adapter);
450 /*********************************************************************
451 * Transmit entry point
453 * ixgb_start is called by the stack to initiate a transmit.
454 * The driver will remain in this routine as long as there are
455 * packets to transmit and transmit resources are available.
456 * In case resources are not available stack is notified and
457 * the packet is requeued.
458 **********************************************************************/
461 ixgb_start_locked(struct ifnet * ifp)
464 struct adapter *adapter = ifp->if_softc;
466 IXGB_LOCK_ASSERT(adapter);
468 if (!adapter->link_active)
471 while (ifp->if_snd.ifq_head != NULL) {
472 IF_DEQUEUE(&ifp->if_snd, m_head);
477 if (ixgb_encap(adapter, m_head)) {
478 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
479 IF_PREPEND(&ifp->if_snd, m_head);
482 /* Send a copy of the frame to the BPF listener */
483 #if __FreeBSD_version < 500000
485 bpf_mtap(ifp, m_head);
487 ETHER_BPF_MTAP(ifp, m_head);
489 /* Set timeout in case hardware has problems transmitting */
490 adapter->tx_timer = IXGB_TX_TIMEOUT;
497 ixgb_start(struct ifnet *ifp)
499 struct adapter *adapter = ifp->if_softc;
502 ixgb_start_locked(ifp);
503 IXGB_UNLOCK(adapter);
507 /*********************************************************************
510 * ixgb_ioctl is called when the user wants to configure the
513 * return 0 on success, positive on failure
514 **********************************************************************/
517 ixgb_ioctl(struct ifnet * ifp, IOCTL_CMD_TYPE command, caddr_t data)
520 struct ifreq *ifr = (struct ifreq *) data;
521 struct adapter *adapter = ifp->if_softc;
523 if (adapter->in_detach)
529 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)");
530 ether_ioctl(ifp, command, data);
533 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)");
534 if (ifr->ifr_mtu > IXGB_MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) {
538 ifp->if_mtu = ifr->ifr_mtu;
539 adapter->hw.max_frame_size =
540 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
542 ixgb_init_locked(adapter);
543 IXGB_UNLOCK(adapter);
547 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)");
549 if (ifp->if_flags & IFF_UP) {
550 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
551 ixgb_init_locked(adapter);
553 ixgb_disable_promisc(adapter);
554 ixgb_set_promisc(adapter);
556 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
560 IXGB_UNLOCK(adapter);
564 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI");
565 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
567 ixgb_disable_intr(adapter);
568 ixgb_set_multi(adapter);
569 ixgb_enable_intr(adapter);
570 IXGB_UNLOCK(adapter);
575 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)");
576 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command);
579 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)");
580 mask = ifr->ifr_reqcap ^ ifp->if_capenable;
581 #ifdef DEVICE_POLLING
582 if (mask & IFCAP_POLLING) {
583 if (ifr->ifr_reqcap & IFCAP_POLLING) {
584 error = ether_poll_register(ixgb_poll, ifp);
588 ixgb_disable_intr(adapter);
589 ifp->if_capenable |= IFCAP_POLLING;
590 IXGB_UNLOCK(adapter);
592 error = ether_poll_deregister(ifp);
593 /* Enable interrupt even in error case */
595 ixgb_enable_intr(adapter);
596 ifp->if_capenable &= ~IFCAP_POLLING;
597 IXGB_UNLOCK(adapter);
600 #endif /* DEVICE_POLLING */
601 if (mask & IFCAP_HWCSUM) {
602 if (IFCAP_HWCSUM & ifp->if_capenable)
603 ifp->if_capenable &= ~IFCAP_HWCSUM;
605 ifp->if_capenable |= IFCAP_HWCSUM;
606 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
611 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%X)\n", (int)command);
619 /*********************************************************************
620 * Watchdog entry point
622 * This routine is called whenever hardware quits transmitting.
624 **********************************************************************/
627 ixgb_watchdog(struct adapter *adapter)
634 * If we are in this routine because of pause frames, then don't
635 * reset the hardware.
637 if (IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_TXOFF) {
638 adapter->tx_timer = IXGB_TX_TIMEOUT;
641 if_printf(ifp, "watchdog timeout -- resetting\n");
644 ixgb_init_locked(adapter);
647 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
652 /*********************************************************************
655 * This routine is used in two ways. It is used by the stack as
656 * init entry point in network interface structure. It is also used
657 * by the driver as a hw/sw initialization routine to get to a
660 * return 0 on success, positive on failure
661 **********************************************************************/
664 ixgb_init_locked(struct adapter *adapter)
668 INIT_DEBUGOUT("ixgb_init: begin");
670 IXGB_LOCK_ASSERT(adapter);
675 /* Get the latest mac address, User can use a LAA */
676 bcopy(IF_LLADDR(ifp), adapter->hw.curr_mac_addr,
677 IXGB_ETH_LENGTH_OF_ADDRESS);
679 /* Initialize the hardware */
680 if (ixgb_hardware_init(adapter)) {
681 if_printf(ifp, "Unable to initialize the hardware\n");
684 ixgb_enable_vlans(adapter);
686 /* Prepare transmit descriptors and buffers */
687 if (ixgb_setup_transmit_structures(adapter)) {
688 if_printf(ifp, "Could not setup transmit structures\n");
692 ixgb_initialize_transmit_unit(adapter);
694 /* Setup Multicast table */
695 ixgb_set_multi(adapter);
697 /* Prepare receive descriptors and buffers */
698 if (ixgb_setup_receive_structures(adapter)) {
699 if_printf(ifp, "Could not setup receive structures\n");
703 ixgb_initialize_receive_unit(adapter);
705 /* Don't lose promiscuous settings */
706 ixgb_set_promisc(adapter);
709 ifp->if_drv_flags |= IFF_DRV_RUNNING;
710 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
713 if (ifp->if_capenable & IFCAP_TXCSUM)
714 ifp->if_hwassist = IXGB_CHECKSUM_FEATURES;
716 ifp->if_hwassist = 0;
719 /* Enable jumbo frames */
720 if (ifp->if_mtu > ETHERMTU) {
722 IXGB_WRITE_REG(&adapter->hw, MFS,
723 adapter->hw.max_frame_size << IXGB_MFS_SHIFT);
724 temp_reg = IXGB_READ_REG(&adapter->hw, CTRL0);
725 temp_reg |= IXGB_CTRL0_JFE;
726 IXGB_WRITE_REG(&adapter->hw, CTRL0, temp_reg);
728 callout_reset(&adapter->timer, hz, ixgb_local_timer, adapter);
729 ixgb_clear_hw_cntrs(&adapter->hw);
730 #ifdef DEVICE_POLLING
732 * Only disable interrupts if we are polling, make sure they are on
735 if (ifp->if_capenable & IFCAP_POLLING)
736 ixgb_disable_intr(adapter);
739 ixgb_enable_intr(adapter);
747 struct adapter *adapter = arg;
750 ixgb_init_locked(adapter);
751 IXGB_UNLOCK(adapter);
755 #ifdef DEVICE_POLLING
757 ixgb_poll_locked(struct ifnet * ifp, enum poll_cmd cmd, int count)
759 struct adapter *adapter = ifp->if_softc;
763 IXGB_LOCK_ASSERT(adapter);
765 if (cmd == POLL_AND_CHECK_STATUS) {
766 reg_icr = IXGB_READ_REG(&adapter->hw, ICR);
767 if (reg_icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) {
768 ixgb_check_for_link(&adapter->hw);
769 ixgb_print_link_status(adapter);
772 rx_npkts = ixgb_process_receive_interrupts(adapter, count);
773 ixgb_clean_transmit_interrupts(adapter);
775 if (ifp->if_snd.ifq_head != NULL)
776 ixgb_start_locked(ifp);
781 ixgb_poll(struct ifnet * ifp, enum poll_cmd cmd, int count)
783 struct adapter *adapter = ifp->if_softc;
787 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
788 rx_npkts = ixgb_poll_locked(ifp, cmd, count);
789 IXGB_UNLOCK(adapter);
792 #endif /* DEVICE_POLLING */
794 /*********************************************************************
796 * Interrupt Service routine
798 **********************************************************************/
803 u_int32_t loop_cnt = IXGB_MAX_INTR;
806 struct adapter *adapter = arg;
807 boolean_t rxdmt0 = FALSE;
813 #ifdef DEVICE_POLLING
814 if (ifp->if_capenable & IFCAP_POLLING) {
815 IXGB_UNLOCK(adapter);
820 reg_icr = IXGB_READ_REG(&adapter->hw, ICR);
822 IXGB_UNLOCK(adapter);
826 if (reg_icr & IXGB_INT_RXDMT0)
830 if (reg_icr & IXGB_INT_RXDMT0)
831 adapter->sv_stats.icr_rxdmt0++;
832 if (reg_icr & IXGB_INT_RXO)
833 adapter->sv_stats.icr_rxo++;
834 if (reg_icr & IXGB_INT_RXT0)
835 adapter->sv_stats.icr_rxt0++;
836 if (reg_icr & IXGB_INT_TXDW)
837 adapter->sv_stats.icr_TXDW++;
840 /* Link status change */
841 if (reg_icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) {
842 ixgb_check_for_link(&adapter->hw);
843 ixgb_print_link_status(adapter);
845 while (loop_cnt > 0) {
846 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
847 ixgb_process_receive_interrupts(adapter, -1);
848 ixgb_clean_transmit_interrupts(adapter);
853 if (rxdmt0 && adapter->raidc) {
854 IXGB_WRITE_REG(&adapter->hw, IMC, IXGB_INT_RXDMT0);
855 IXGB_WRITE_REG(&adapter->hw, IMS, IXGB_INT_RXDMT0);
857 if (ifp->if_drv_flags & IFF_DRV_RUNNING && ifp->if_snd.ifq_head != NULL)
858 ixgb_start_locked(ifp);
860 IXGB_UNLOCK(adapter);
865 /*********************************************************************
867 * Media Ioctl callback
869 * This routine is called whenever the user queries the status of
870 * the interface using ifconfig.
872 **********************************************************************/
874 ixgb_media_status(struct ifnet * ifp, struct ifmediareq * ifmr)
876 struct adapter *adapter = ifp->if_softc;
878 INIT_DEBUGOUT("ixgb_media_status: begin");
880 ixgb_check_for_link(&adapter->hw);
881 ixgb_print_link_status(adapter);
883 ifmr->ifm_status = IFM_AVALID;
884 ifmr->ifm_active = IFM_ETHER;
886 if (!adapter->hw.link_up)
889 ifmr->ifm_status |= IFM_ACTIVE;
890 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX;
895 /*********************************************************************
897 * Media Ioctl callback
899 * This routine is called when the user changes speed/duplex using
900 * media/mediopt option with ifconfig.
902 **********************************************************************/
904 ixgb_media_change(struct ifnet * ifp)
906 struct adapter *adapter = ifp->if_softc;
907 struct ifmedia *ifm = &adapter->media;
909 INIT_DEBUGOUT("ixgb_media_change: begin");
911 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
917 /*********************************************************************
919 * This routine maps the mbufs to tx descriptors.
921 * return 0 on success, positive on failure
922 **********************************************************************/
925 ixgb_encap(struct adapter * adapter, struct mbuf * m_head)
928 int i, j, error, nsegs;
930 #if __FreeBSD_version < 500000
931 struct ifvlan *ifv = NULL;
933 bus_dma_segment_t segs[IXGB_MAX_SCATTER];
935 struct ixgb_buffer *tx_buffer = NULL;
936 struct ixgb_tx_desc *current_tx_desc = NULL;
937 struct ifnet *ifp = adapter->ifp;
940 * Force a cleanup if number of TX descriptors available hits the
943 if (adapter->num_tx_desc_avail <= IXGB_TX_CLEANUP_THRESHOLD) {
944 ixgb_clean_transmit_interrupts(adapter);
946 if (adapter->num_tx_desc_avail <= IXGB_TX_CLEANUP_THRESHOLD) {
947 adapter->no_tx_desc_avail1++;
951 * Map the packet for DMA.
953 if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &map)) {
954 adapter->no_tx_map_avail++;
957 error = bus_dmamap_load_mbuf_sg(adapter->txtag, map, m_head, segs,
958 &nsegs, BUS_DMA_NOWAIT);
960 adapter->no_tx_dma_setup++;
961 if_printf(ifp, "ixgb_encap: bus_dmamap_load_mbuf failed; "
962 "error %u\n", error);
963 bus_dmamap_destroy(adapter->txtag, map);
966 KASSERT(nsegs != 0, ("ixgb_encap: empty packet"));
968 if (nsegs > adapter->num_tx_desc_avail) {
969 adapter->no_tx_desc_avail2++;
970 bus_dmamap_destroy(adapter->txtag, map);
973 if (ifp->if_hwassist > 0) {
974 ixgb_transmit_checksum_setup(adapter, m_head,
979 /* Find out if we are in vlan mode */
980 #if __FreeBSD_version < 500000
981 if ((m_head->m_flags & (M_PROTO1 | M_PKTHDR)) == (M_PROTO1 | M_PKTHDR) &&
982 m_head->m_pkthdr.rcvif != NULL &&
983 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN)
984 ifv = m_head->m_pkthdr.rcvif->if_softc;
985 #elseif __FreeBSD_version < 700000
986 mtag = VLAN_OUTPUT_TAG(ifp, m_head);
988 i = adapter->next_avail_tx_desc;
989 for (j = 0; j < nsegs; j++) {
990 tx_buffer = &adapter->tx_buffer_area[i];
991 current_tx_desc = &adapter->tx_desc_base[i];
993 current_tx_desc->buff_addr = htole64(segs[j].ds_addr);
994 current_tx_desc->cmd_type_len = (adapter->txd_cmd | segs[j].ds_len);
995 current_tx_desc->popts = txd_popts;
996 if (++i == adapter->num_tx_desc)
999 tx_buffer->m_head = NULL;
1002 adapter->num_tx_desc_avail -= nsegs;
1003 adapter->next_avail_tx_desc = i;
1005 #if __FreeBSD_version < 500000
1007 /* Set the vlan id */
1008 current_tx_desc->vlan = ifv->ifv_tag;
1009 #elseif __FreeBSD_version < 700000
1011 /* Set the vlan id */
1012 current_tx_desc->vlan = VLAN_TAG_VALUE(mtag);
1014 if (m_head->m_flags & M_VLANTAG) {
1015 current_tx_desc->vlan = m_head->m_pkthdr.ether_vtag;
1018 /* Tell hardware to add tag */
1019 current_tx_desc->cmd_type_len |= IXGB_TX_DESC_CMD_VLE;
1021 tx_buffer->m_head = m_head;
1022 tx_buffer->map = map;
1023 bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE);
1026 * Last Descriptor of Packet needs End Of Packet (EOP)
1028 current_tx_desc->cmd_type_len |= (IXGB_TX_DESC_CMD_EOP);
1031 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000
1032 * that this frame is available to transmit.
1034 IXGB_WRITE_REG(&adapter->hw, TDT, i);
1040 ixgb_set_promisc(struct adapter * adapter)
1044 struct ifnet *ifp = adapter->ifp;
1046 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
1048 if (ifp->if_flags & IFF_PROMISC) {
1049 reg_rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE);
1050 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1051 } else if (ifp->if_flags & IFF_ALLMULTI) {
1052 reg_rctl |= IXGB_RCTL_MPE;
1053 reg_rctl &= ~IXGB_RCTL_UPE;
1054 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1060 ixgb_disable_promisc(struct adapter * adapter)
1064 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
1066 reg_rctl &= (~IXGB_RCTL_UPE);
1067 reg_rctl &= (~IXGB_RCTL_MPE);
1068 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1074 /*********************************************************************
1077 * This routine is called whenever multicast address list is updated.
1079 **********************************************************************/
1082 ixgb_set_multi(struct adapter * adapter)
1084 u_int32_t reg_rctl = 0;
1086 struct ifmultiaddr *ifma;
1088 struct ifnet *ifp = adapter->ifp;
1090 IOCTL_DEBUGOUT("ixgb_set_multi: begin");
1093 bzero(mta, sizeof(u_int8_t) * IXGB_ETH_LENGTH_OF_ADDRESS *
1094 MAX_NUM_MULTICAST_ADDRESSES);
1096 if_maddr_rlock(ifp);
1097 #if __FreeBSD_version < 500000
1098 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1100 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
1102 if (ifma->ifma_addr->sa_family != AF_LINK)
1105 bcopy(LLADDR((struct sockaddr_dl *) ifma->ifma_addr),
1106 &mta[mcnt * IXGB_ETH_LENGTH_OF_ADDRESS], IXGB_ETH_LENGTH_OF_ADDRESS);
1109 if_maddr_runlock(ifp);
1111 if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) {
1112 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
1113 reg_rctl |= IXGB_RCTL_MPE;
1114 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
1116 ixgb_mc_addr_list_update(&adapter->hw, mta, mcnt, 0);
1122 /*********************************************************************
1125 * This routine checks for link status and updates statistics.
1127 **********************************************************************/
1130 ixgb_local_timer(void *arg)
1133 struct adapter *adapter = arg;
1136 IXGB_LOCK_ASSERT(adapter);
1138 ixgb_check_for_link(&adapter->hw);
1139 ixgb_print_link_status(adapter);
1140 ixgb_update_stats_counters(adapter);
1141 if (ixgb_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING) {
1142 ixgb_print_hw_stats(adapter);
1144 if (adapter->tx_timer != 0 && --adapter->tx_timer == 0)
1145 ixgb_watchdog(adapter);
1146 callout_reset(&adapter->timer, hz, ixgb_local_timer, adapter);
1150 ixgb_print_link_status(struct adapter * adapter)
1152 if (adapter->hw.link_up) {
1153 if (!adapter->link_active) {
1154 if_printf(adapter->ifp, "Link is up %d Mbps %s \n",
1157 adapter->link_active = 1;
1160 if (adapter->link_active) {
1161 if_printf(adapter->ifp, "Link is Down \n");
1162 adapter->link_active = 0;
1171 /*********************************************************************
1173 * This routine disables all traffic on the adapter by issuing a
1174 * global reset on the MAC and deallocates TX/RX buffers.
1176 **********************************************************************/
1179 ixgb_stop(void *arg)
1182 struct adapter *adapter = arg;
1185 IXGB_LOCK_ASSERT(adapter);
1187 INIT_DEBUGOUT("ixgb_stop: begin\n");
1188 ixgb_disable_intr(adapter);
1189 adapter->hw.adapter_stopped = FALSE;
1190 ixgb_adapter_stop(&adapter->hw);
1191 callout_stop(&adapter->timer);
1192 ixgb_free_transmit_structures(adapter);
1193 ixgb_free_receive_structures(adapter);
1195 /* Tell the stack that the interface is no longer active */
1196 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1197 adapter->tx_timer = 0;
1203 /*********************************************************************
1205 * Determine hardware revision.
1207 **********************************************************************/
1209 ixgb_identify_hardware(struct adapter * adapter)
1211 device_t dev = adapter->dev;
1213 /* Make sure our PCI config space has the necessary stuff set */
1214 pci_enable_busmaster(dev);
1215 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2);
1217 /* Save off the information about this board */
1218 adapter->hw.vendor_id = pci_get_vendor(dev);
1219 adapter->hw.device_id = pci_get_device(dev);
1220 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1);
1221 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2);
1222 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2);
1224 /* Set MacType, etc. based on this PCI info */
1225 switch (adapter->hw.device_id) {
1226 case IXGB_DEVICE_ID_82597EX:
1227 case IXGB_DEVICE_ID_82597EX_SR:
1228 adapter->hw.mac_type = ixgb_82597;
1231 INIT_DEBUGOUT1("Unknown device if 0x%x", adapter->hw.device_id);
1232 device_printf(dev, "unsupported device id 0x%x\n",
1233 adapter->hw.device_id);
1240 ixgb_allocate_pci_resources(struct adapter * adapter)
1243 device_t dev = adapter->dev;
1246 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
1249 if (!(adapter->res_memory)) {
1250 device_printf(dev, "Unable to allocate bus resource: memory\n");
1253 adapter->osdep.mem_bus_space_tag =
1254 rman_get_bustag(adapter->res_memory);
1255 adapter->osdep.mem_bus_space_handle =
1256 rman_get_bushandle(adapter->res_memory);
1257 adapter->hw.hw_addr = (uint8_t *) & adapter->osdep.mem_bus_space_handle;
1260 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ,
1262 RF_SHAREABLE | RF_ACTIVE);
1263 if (!(adapter->res_interrupt)) {
1265 "Unable to allocate bus resource: interrupt\n");
1268 if (bus_setup_intr(dev, adapter->res_interrupt,
1269 INTR_TYPE_NET | INTR_MPSAFE,
1270 NULL, (void (*) (void *))ixgb_intr, adapter,
1271 &adapter->int_handler_tag)) {
1272 device_printf(dev, "Error registering interrupt handler!\n");
1275 adapter->hw.back = &adapter->osdep;
1281 ixgb_free_pci_resources(struct adapter * adapter)
1283 device_t dev = adapter->dev;
1285 if (adapter->res_interrupt != NULL) {
1286 bus_teardown_intr(dev, adapter->res_interrupt,
1287 adapter->int_handler_tag);
1288 bus_release_resource(dev, SYS_RES_IRQ, 0,
1289 adapter->res_interrupt);
1291 if (adapter->res_memory != NULL) {
1292 bus_release_resource(dev, SYS_RES_MEMORY, IXGB_MMBA,
1293 adapter->res_memory);
1295 if (adapter->res_ioport != NULL) {
1296 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid,
1297 adapter->res_ioport);
1302 /*********************************************************************
1304 * Initialize the hardware to a configuration as specified by the
1305 * adapter structure. The controller is reset, the EEPROM is
1306 * verified, the MAC address is set, then the shared initialization
1307 * routines are called.
1309 **********************************************************************/
1311 ixgb_hardware_init(struct adapter * adapter)
1313 /* Issue a global reset */
1314 adapter->hw.adapter_stopped = FALSE;
1315 ixgb_adapter_stop(&adapter->hw);
1317 /* Make sure we have a good EEPROM before we read from it */
1318 if (!ixgb_validate_eeprom_checksum(&adapter->hw)) {
1319 device_printf(adapter->dev,
1320 "The EEPROM Checksum Is Not Valid\n");
1323 if (!ixgb_init_hw(&adapter->hw)) {
1324 device_printf(adapter->dev, "Hardware Initialization Failed");
1331 /*********************************************************************
1333 * Setup networking device structure and register an interface.
1335 **********************************************************************/
1337 ixgb_setup_interface(device_t dev, struct adapter * adapter)
1340 INIT_DEBUGOUT("ixgb_setup_interface: begin");
1342 ifp = adapter->ifp = if_alloc(IFT_ETHER);
1344 device_printf(dev, "can not allocate ifnet structure\n");
1347 #if __FreeBSD_version >= 502000
1348 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
1350 ifp->if_unit = device_get_unit(dev);
1351 ifp->if_name = "ixgb";
1353 ifp->if_baudrate = 1000000000;
1354 ifp->if_init = ixgb_init;
1355 ifp->if_softc = adapter;
1356 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1357 ifp->if_ioctl = ixgb_ioctl;
1358 ifp->if_start = ixgb_start;
1359 ifp->if_get_counter = ixgb_get_counter;
1360 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1;
1362 #if __FreeBSD_version < 500000
1363 ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
1365 ether_ifattach(ifp, adapter->hw.curr_mac_addr);
1368 ifp->if_capabilities = IFCAP_HWCSUM;
1371 * Tell the upper layer(s) we support long frames.
1373 ifp->if_hdrlen = sizeof(struct ether_vlan_header);
1375 #if __FreeBSD_version >= 500000
1376 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
1379 ifp->if_capenable = ifp->if_capabilities;
1381 #ifdef DEVICE_POLLING
1382 ifp->if_capabilities |= IFCAP_POLLING;
1386 * Specify the media types supported by this adapter and register
1387 * callbacks to update media and link information
1389 ifmedia_init(&adapter->media, IFM_IMASK, ixgb_media_change,
1391 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX,
1393 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX,
1395 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL);
1396 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO);
1401 /********************************************************************
1402 * Manage DMA'able memory.
1403 *******************************************************************/
1405 ixgb_dmamap_cb(void *arg, bus_dma_segment_t * segs, int nseg, int error)
1409 *(bus_addr_t *) arg = segs->ds_addr;
1414 ixgb_dma_malloc(struct adapter * adapter, bus_size_t size,
1415 struct ixgb_dma_alloc * dma, int mapflags)
1421 r = bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
1422 PAGE_SIZE, 0, /* alignment, bounds */
1423 BUS_SPACE_MAXADDR, /* lowaddr */
1424 BUS_SPACE_MAXADDR, /* highaddr */
1425 NULL, NULL, /* filter, filterarg */
1428 size, /* maxsegsize */
1429 BUS_DMA_ALLOCNOW, /* flags */
1430 #if __FreeBSD_version >= 502000
1431 NULL, /* lockfunc */
1432 NULL, /* lockfuncarg */
1436 device_printf(dev, "ixgb_dma_malloc: bus_dma_tag_create failed; "
1440 r = bus_dmamem_alloc(dma->dma_tag, (void **)&dma->dma_vaddr,
1441 BUS_DMA_NOWAIT, &dma->dma_map);
1443 device_printf(dev, "ixgb_dma_malloc: bus_dmamem_alloc failed; "
1447 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr,
1451 mapflags | BUS_DMA_NOWAIT);
1453 device_printf(dev, "ixgb_dma_malloc: bus_dmamap_load failed; "
1457 dma->dma_size = size;
1460 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
1462 bus_dma_tag_destroy(dma->dma_tag);
1464 dma->dma_tag = NULL;
1471 ixgb_dma_free(struct adapter * adapter, struct ixgb_dma_alloc * dma)
1473 bus_dmamap_unload(dma->dma_tag, dma->dma_map);
1474 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map);
1475 bus_dma_tag_destroy(dma->dma_tag);
1478 /*********************************************************************
1480 * Allocate memory for tx_buffer structures. The tx_buffer stores all
1481 * the information needed to transmit a packet on the wire.
1483 **********************************************************************/
1485 ixgb_allocate_transmit_structures(struct adapter * adapter)
1487 if (!(adapter->tx_buffer_area =
1488 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) *
1489 adapter->num_tx_desc, M_DEVBUF,
1490 M_NOWAIT | M_ZERO))) {
1491 device_printf(adapter->dev,
1492 "Unable to allocate tx_buffer memory\n");
1495 bzero(adapter->tx_buffer_area,
1496 sizeof(struct ixgb_buffer) * adapter->num_tx_desc);
1501 /*********************************************************************
1503 * Allocate and initialize transmit structures.
1505 **********************************************************************/
1507 ixgb_setup_transmit_structures(struct adapter * adapter)
1510 * Setup DMA descriptor areas.
1512 if (bus_dma_tag_create(bus_get_dma_tag(adapter->dev), /* parent */
1513 PAGE_SIZE, 0, /* alignment, bounds */
1514 BUS_SPACE_MAXADDR, /* lowaddr */
1515 BUS_SPACE_MAXADDR, /* highaddr */
1516 NULL, NULL, /* filter, filterarg */
1517 MCLBYTES * IXGB_MAX_SCATTER, /* maxsize */
1518 IXGB_MAX_SCATTER, /* nsegments */
1519 MCLBYTES, /* maxsegsize */
1520 BUS_DMA_ALLOCNOW, /* flags */
1521 #if __FreeBSD_version >= 502000
1522 NULL, /* lockfunc */
1523 NULL, /* lockfuncarg */
1526 device_printf(adapter->dev, "Unable to allocate TX DMA tag\n");
1529 if (ixgb_allocate_transmit_structures(adapter))
1532 bzero((void *)adapter->tx_desc_base,
1533 (sizeof(struct ixgb_tx_desc)) * adapter->num_tx_desc);
1535 adapter->next_avail_tx_desc = 0;
1536 adapter->oldest_used_tx_desc = 0;
1538 /* Set number of descriptors available */
1539 adapter->num_tx_desc_avail = adapter->num_tx_desc;
1541 /* Set checksum context */
1542 adapter->active_checksum_context = OFFLOAD_NONE;
1547 /*********************************************************************
1549 * Enable transmit unit.
1551 **********************************************************************/
1553 ixgb_initialize_transmit_unit(struct adapter * adapter)
1556 u_int64_t tdba = adapter->txdma.dma_paddr;
1558 /* Setup the Base and Length of the Tx Descriptor Ring */
1559 IXGB_WRITE_REG(&adapter->hw, TDBAL,
1560 (tdba & 0x00000000ffffffffULL));
1561 IXGB_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32));
1562 IXGB_WRITE_REG(&adapter->hw, TDLEN,
1563 adapter->num_tx_desc *
1564 sizeof(struct ixgb_tx_desc));
1566 /* Setup the HW Tx Head and Tail descriptor pointers */
1567 IXGB_WRITE_REG(&adapter->hw, TDH, 0);
1568 IXGB_WRITE_REG(&adapter->hw, TDT, 0);
1571 HW_DEBUGOUT2("Base = %x, Length = %x\n",
1572 IXGB_READ_REG(&adapter->hw, TDBAL),
1573 IXGB_READ_REG(&adapter->hw, TDLEN));
1575 IXGB_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay);
1578 /* Program the Transmit Control Register */
1579 reg_tctl = IXGB_READ_REG(&adapter->hw, TCTL);
1580 reg_tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE;
1581 IXGB_WRITE_REG(&adapter->hw, TCTL, reg_tctl);
1583 /* Setup Transmit Descriptor Settings for this adapter */
1584 adapter->txd_cmd = IXGB_TX_DESC_TYPE | IXGB_TX_DESC_CMD_RS;
1586 if (adapter->tx_int_delay > 0)
1587 adapter->txd_cmd |= IXGB_TX_DESC_CMD_IDE;
1591 /*********************************************************************
1593 * Free all transmit related data structures.
1595 **********************************************************************/
1597 ixgb_free_transmit_structures(struct adapter * adapter)
1599 struct ixgb_buffer *tx_buffer;
1602 INIT_DEBUGOUT("free_transmit_structures: begin");
1604 if (adapter->tx_buffer_area != NULL) {
1605 tx_buffer = adapter->tx_buffer_area;
1606 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) {
1607 if (tx_buffer->m_head != NULL) {
1608 bus_dmamap_unload(adapter->txtag, tx_buffer->map);
1609 bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
1610 m_freem(tx_buffer->m_head);
1612 tx_buffer->m_head = NULL;
1615 if (adapter->tx_buffer_area != NULL) {
1616 free(adapter->tx_buffer_area, M_DEVBUF);
1617 adapter->tx_buffer_area = NULL;
1619 if (adapter->txtag != NULL) {
1620 bus_dma_tag_destroy(adapter->txtag);
1621 adapter->txtag = NULL;
1626 /*********************************************************************
1628 * The offload context needs to be set when we transfer the first
1629 * packet of a particular protocol (TCP/UDP). We change the
1630 * context only if the protocol type changes.
1632 **********************************************************************/
1634 ixgb_transmit_checksum_setup(struct adapter * adapter,
1636 u_int8_t * txd_popts)
1638 struct ixgb_context_desc *TXD;
1639 struct ixgb_buffer *tx_buffer;
1642 if (mp->m_pkthdr.csum_flags) {
1644 if (mp->m_pkthdr.csum_flags & CSUM_TCP) {
1645 *txd_popts = IXGB_TX_DESC_POPTS_TXSM;
1646 if (adapter->active_checksum_context == OFFLOAD_TCP_IP)
1649 adapter->active_checksum_context = OFFLOAD_TCP_IP;
1650 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) {
1651 *txd_popts = IXGB_TX_DESC_POPTS_TXSM;
1652 if (adapter->active_checksum_context == OFFLOAD_UDP_IP)
1655 adapter->active_checksum_context = OFFLOAD_UDP_IP;
1666 * If we reach this point, the checksum offload context needs to be
1669 curr_txd = adapter->next_avail_tx_desc;
1670 tx_buffer = &adapter->tx_buffer_area[curr_txd];
1671 TXD = (struct ixgb_context_desc *) & adapter->tx_desc_base[curr_txd];
1674 TXD->tucss = ENET_HEADER_SIZE + sizeof(struct ip);
1679 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) {
1681 ENET_HEADER_SIZE + sizeof(struct ip) +
1682 offsetof(struct tcphdr, th_sum);
1683 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) {
1685 ENET_HEADER_SIZE + sizeof(struct ip) +
1686 offsetof(struct udphdr, uh_sum);
1688 TXD->cmd_type_len = IXGB_CONTEXT_DESC_CMD_TCP | IXGB_TX_DESC_CMD_RS | IXGB_CONTEXT_DESC_CMD_IDE;
1690 tx_buffer->m_head = NULL;
1692 if (++curr_txd == adapter->num_tx_desc)
1695 adapter->num_tx_desc_avail--;
1696 adapter->next_avail_tx_desc = curr_txd;
1700 /**********************************************************************
1702 * Examine each tx_buffer in the used queue. If the hardware is done
1703 * processing the packet then free associated resources. The
1704 * tx_buffer is put back on the free queue.
1706 **********************************************************************/
1708 ixgb_clean_transmit_interrupts(struct adapter * adapter)
1711 struct ixgb_buffer *tx_buffer;
1712 struct ixgb_tx_desc *tx_desc;
1714 IXGB_LOCK_ASSERT(adapter);
1716 if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
1720 adapter->clean_tx_interrupts++;
1722 num_avail = adapter->num_tx_desc_avail;
1723 i = adapter->oldest_used_tx_desc;
1725 tx_buffer = &adapter->tx_buffer_area[i];
1726 tx_desc = &adapter->tx_desc_base[i];
1728 while (tx_desc->status & IXGB_TX_DESC_STATUS_DD) {
1730 tx_desc->status = 0;
1733 if (tx_buffer->m_head) {
1734 bus_dmamap_sync(adapter->txtag, tx_buffer->map,
1735 BUS_DMASYNC_POSTWRITE);
1736 bus_dmamap_unload(adapter->txtag, tx_buffer->map);
1737 bus_dmamap_destroy(adapter->txtag, tx_buffer->map);
1738 m_freem(tx_buffer->m_head);
1739 tx_buffer->m_head = NULL;
1741 if (++i == adapter->num_tx_desc)
1744 tx_buffer = &adapter->tx_buffer_area[i];
1745 tx_desc = &adapter->tx_desc_base[i];
1748 adapter->oldest_used_tx_desc = i;
1751 * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack that
1752 * it is OK to send packets. If there are no pending descriptors,
1753 * clear the timeout. Otherwise, if some descriptors have been freed,
1754 * restart the timeout.
1756 if (num_avail > IXGB_TX_CLEANUP_THRESHOLD) {
1757 struct ifnet *ifp = adapter->ifp;
1759 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1760 if (num_avail == adapter->num_tx_desc)
1761 adapter->tx_timer = 0;
1762 else if (num_avail == adapter->num_tx_desc_avail)
1763 adapter->tx_timer = IXGB_TX_TIMEOUT;
1765 adapter->num_tx_desc_avail = num_avail;
1770 /*********************************************************************
1772 * Get a buffer from system mbuf buffer pool.
1774 **********************************************************************/
1776 ixgb_get_buf(int i, struct adapter * adapter,
1779 register struct mbuf *mp = nmp;
1780 struct ixgb_buffer *rx_buffer;
1789 mp = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
1792 adapter->mbuf_alloc_failed++;
1795 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
1797 mp->m_len = mp->m_pkthdr.len = MCLBYTES;
1798 mp->m_data = mp->m_ext.ext_buf;
1802 if (ifp->if_mtu <= ETHERMTU) {
1803 m_adj(mp, ETHER_ALIGN);
1805 rx_buffer = &adapter->rx_buffer_area[i];
1808 * Using memory from the mbuf cluster pool, invoke the bus_dma
1809 * machinery to arrange the memory mapping.
1811 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map,
1812 mtod(mp, void *), mp->m_len,
1813 ixgb_dmamap_cb, &paddr, 0);
1818 rx_buffer->m_head = mp;
1819 adapter->rx_desc_base[i].buff_addr = htole64(paddr);
1820 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD);
1825 /*********************************************************************
1827 * Allocate memory for rx_buffer structures. Since we use one
1828 * rx_buffer per received packet, the maximum number of rx_buffer's
1829 * that we'll need is equal to the number of receive descriptors
1830 * that we've allocated.
1832 **********************************************************************/
1834 ixgb_allocate_receive_structures(struct adapter * adapter)
1837 struct ixgb_buffer *rx_buffer;
1839 if (!(adapter->rx_buffer_area =
1840 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) *
1841 adapter->num_rx_desc, M_DEVBUF,
1842 M_NOWAIT | M_ZERO))) {
1843 device_printf(adapter->dev,
1844 "Unable to allocate rx_buffer memory\n");
1847 bzero(adapter->rx_buffer_area,
1848 sizeof(struct ixgb_buffer) * adapter->num_rx_desc);
1850 error = bus_dma_tag_create(bus_get_dma_tag(adapter->dev),/* parent */
1851 PAGE_SIZE, 0, /* alignment, bounds */
1852 BUS_SPACE_MAXADDR, /* lowaddr */
1853 BUS_SPACE_MAXADDR, /* highaddr */
1854 NULL, NULL, /* filter, filterarg */
1855 MCLBYTES, /* maxsize */
1857 MCLBYTES, /* maxsegsize */
1858 BUS_DMA_ALLOCNOW, /* flags */
1859 #if __FreeBSD_version >= 502000
1860 NULL, /* lockfunc */
1861 NULL, /* lockfuncarg */
1865 device_printf(adapter->dev, "ixgb_allocate_receive_structures: "
1866 "bus_dma_tag_create failed; error %u\n",
1870 rx_buffer = adapter->rx_buffer_area;
1871 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
1872 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT,
1875 device_printf(adapter->dev,
1876 "ixgb_allocate_receive_structures: "
1877 "bus_dmamap_create failed; error %u\n",
1883 for (i = 0; i < adapter->num_rx_desc; i++) {
1884 if (ixgb_get_buf(i, adapter, NULL) == ENOBUFS) {
1885 adapter->rx_buffer_area[i].m_head = NULL;
1886 adapter->rx_desc_base[i].buff_addr = 0;
1893 bus_dma_tag_destroy(adapter->rxtag);
1895 adapter->rxtag = NULL;
1896 free(adapter->rx_buffer_area, M_DEVBUF);
1897 adapter->rx_buffer_area = NULL;
1901 /*********************************************************************
1903 * Allocate and initialize receive structures.
1905 **********************************************************************/
1907 ixgb_setup_receive_structures(struct adapter * adapter)
1909 bzero((void *)adapter->rx_desc_base,
1910 (sizeof(struct ixgb_rx_desc)) * adapter->num_rx_desc);
1912 if (ixgb_allocate_receive_structures(adapter))
1915 /* Setup our descriptor pointers */
1916 adapter->next_rx_desc_to_check = 0;
1917 adapter->next_rx_desc_to_use = 0;
1921 /*********************************************************************
1923 * Enable receive unit.
1925 **********************************************************************/
1927 ixgb_initialize_receive_unit(struct adapter * adapter)
1930 u_int32_t reg_rxcsum;
1931 u_int32_t reg_rxdctl;
1933 u_int64_t rdba = adapter->rxdma.dma_paddr;
1938 * Make sure receives are disabled while setting up the descriptor
1941 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
1942 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl & ~IXGB_RCTL_RXEN);
1944 /* Set the Receive Delay Timer Register */
1945 IXGB_WRITE_REG(&adapter->hw, RDTR,
1946 adapter->rx_int_delay);
1949 /* Setup the Base and Length of the Rx Descriptor Ring */
1950 IXGB_WRITE_REG(&adapter->hw, RDBAL,
1951 (rdba & 0x00000000ffffffffULL));
1952 IXGB_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32));
1953 IXGB_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc *
1954 sizeof(struct ixgb_rx_desc));
1956 /* Setup the HW Rx Head and Tail Descriptor Pointers */
1957 IXGB_WRITE_REG(&adapter->hw, RDH, 0);
1959 IXGB_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1);
1963 reg_rxdctl = RXDCTL_WTHRESH_DEFAULT << IXGB_RXDCTL_WTHRESH_SHIFT
1964 | RXDCTL_HTHRESH_DEFAULT << IXGB_RXDCTL_HTHRESH_SHIFT
1965 | RXDCTL_PTHRESH_DEFAULT << IXGB_RXDCTL_PTHRESH_SHIFT;
1966 IXGB_WRITE_REG(&adapter->hw, RXDCTL, reg_rxdctl);
1970 if (adapter->raidc) {
1972 uint8_t poll_threshold;
1973 #define IXGB_RAIDC_POLL_DEFAULT 120
1975 poll_threshold = ((adapter->num_rx_desc - 1) >> 3);
1976 poll_threshold >>= 1;
1977 poll_threshold &= 0x3F;
1978 raidc = IXGB_RAIDC_EN | IXGB_RAIDC_RXT_GATE |
1979 (IXGB_RAIDC_POLL_DEFAULT << IXGB_RAIDC_POLL_SHIFT) |
1980 (adapter->rx_int_delay << IXGB_RAIDC_DELAY_SHIFT) |
1982 IXGB_WRITE_REG(&adapter->hw, RAIDC, raidc);
1984 /* Enable Receive Checksum Offload for TCP and UDP ? */
1985 if (ifp->if_capenable & IFCAP_RXCSUM) {
1986 reg_rxcsum = IXGB_READ_REG(&adapter->hw, RXCSUM);
1987 reg_rxcsum |= IXGB_RXCSUM_TUOFL;
1988 IXGB_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum);
1990 /* Setup the Receive Control Register */
1991 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL);
1992 reg_rctl &= ~(3 << IXGB_RCTL_MO_SHIFT);
1993 reg_rctl |= IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | IXGB_RCTL_SECRC |
1995 (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT);
1997 switch (adapter->rx_buffer_len) {
1999 case IXGB_RXBUFFER_2048:
2000 reg_rctl |= IXGB_RCTL_BSIZE_2048;
2002 case IXGB_RXBUFFER_4096:
2003 reg_rctl |= IXGB_RCTL_BSIZE_4096;
2005 case IXGB_RXBUFFER_8192:
2006 reg_rctl |= IXGB_RCTL_BSIZE_8192;
2008 case IXGB_RXBUFFER_16384:
2009 reg_rctl |= IXGB_RCTL_BSIZE_16384;
2013 reg_rctl |= IXGB_RCTL_RXEN;
2016 /* Enable Receives */
2017 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl);
2022 /*********************************************************************
2024 * Free receive related data structures.
2026 **********************************************************************/
2028 ixgb_free_receive_structures(struct adapter * adapter)
2030 struct ixgb_buffer *rx_buffer;
2033 INIT_DEBUGOUT("free_receive_structures: begin");
2035 if (adapter->rx_buffer_area != NULL) {
2036 rx_buffer = adapter->rx_buffer_area;
2037 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) {
2038 if (rx_buffer->map != NULL) {
2039 bus_dmamap_unload(adapter->rxtag, rx_buffer->map);
2040 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map);
2042 if (rx_buffer->m_head != NULL)
2043 m_freem(rx_buffer->m_head);
2044 rx_buffer->m_head = NULL;
2047 if (adapter->rx_buffer_area != NULL) {
2048 free(adapter->rx_buffer_area, M_DEVBUF);
2049 adapter->rx_buffer_area = NULL;
2051 if (adapter->rxtag != NULL) {
2052 bus_dma_tag_destroy(adapter->rxtag);
2053 adapter->rxtag = NULL;
2058 /*********************************************************************
2060 * This routine executes in interrupt context. It replenishes
2061 * the mbufs in the descriptor and sends data which has been
2062 * dma'ed into host memory to upper layer.
2064 * We loop at most count times if count is > 0, or until done if
2067 *********************************************************************/
2069 ixgb_process_receive_interrupts(struct adapter * adapter, int count)
2073 #if __FreeBSD_version < 500000
2074 struct ether_header *eh;
2078 u_int8_t accept_frame = 0;
2080 int next_to_use = 0;
2083 /* Pointer to the receive descriptor being examined. */
2084 struct ixgb_rx_desc *current_desc;
2086 IXGB_LOCK_ASSERT(adapter);
2089 i = adapter->next_rx_desc_to_check;
2090 next_to_use = adapter->next_rx_desc_to_use;
2091 eop_desc = adapter->next_rx_desc_to_check;
2092 current_desc = &adapter->rx_desc_base[i];
2094 if (!((current_desc->status) & IXGB_RX_DESC_STATUS_DD)) {
2096 adapter->no_pkts_avail++;
2100 while ((current_desc->status & IXGB_RX_DESC_STATUS_DD) && (count != 0)) {
2102 mp = adapter->rx_buffer_area[i].m_head;
2103 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map,
2104 BUS_DMASYNC_POSTREAD);
2106 if (current_desc->status & IXGB_RX_DESC_STATUS_EOP) {
2112 len = current_desc->length;
2114 if (current_desc->errors & (IXGB_RX_DESC_ERRORS_CE |
2115 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P |
2116 IXGB_RX_DESC_ERRORS_RXE)) {
2121 /* Assign correct length to the current fragment */
2124 if (adapter->fmp == NULL) {
2125 mp->m_pkthdr.len = len;
2126 adapter->fmp = mp; /* Store the first mbuf */
2129 /* Chain mbuf's together */
2130 mp->m_flags &= ~M_PKTHDR;
2131 adapter->lmp->m_next = mp;
2132 adapter->lmp = adapter->lmp->m_next;
2133 adapter->fmp->m_pkthdr.len += len;
2138 adapter->fmp->m_pkthdr.rcvif = ifp;
2140 #if __FreeBSD_version < 500000
2141 eh = mtod(adapter->fmp, struct ether_header *);
2143 /* Remove ethernet header from mbuf */
2144 m_adj(adapter->fmp, sizeof(struct ether_header));
2145 ixgb_receive_checksum(adapter, current_desc,
2148 if (current_desc->status & IXGB_RX_DESC_STATUS_VP)
2149 VLAN_INPUT_TAG(eh, adapter->fmp,
2150 current_desc->special);
2152 ether_input(ifp, eh, adapter->fmp);
2154 ixgb_receive_checksum(adapter, current_desc,
2156 #if __FreeBSD_version < 700000
2157 if (current_desc->status & IXGB_RX_DESC_STATUS_VP)
2158 VLAN_INPUT_TAG(ifp, adapter->fmp,
2159 current_desc->special);
2161 if (current_desc->status & IXGB_RX_DESC_STATUS_VP) {
2162 adapter->fmp->m_pkthdr.ether_vtag =
2163 current_desc->special;
2164 adapter->fmp->m_flags |= M_VLANTAG;
2168 if (adapter->fmp != NULL) {
2169 IXGB_UNLOCK(adapter);
2170 (*ifp->if_input) (ifp, adapter->fmp);
2175 adapter->fmp = NULL;
2176 adapter->lmp = NULL;
2178 adapter->rx_buffer_area[i].m_head = NULL;
2180 adapter->dropped_pkts++;
2181 if (adapter->fmp != NULL)
2182 m_freem(adapter->fmp);
2183 adapter->fmp = NULL;
2184 adapter->lmp = NULL;
2187 /* Zero out the receive descriptors status */
2188 current_desc->status = 0;
2190 /* Advance our pointers to the next descriptor */
2191 if (++i == adapter->num_rx_desc) {
2193 current_desc = adapter->rx_desc_base;
2197 adapter->next_rx_desc_to_check = i;
2200 i = (adapter->num_rx_desc - 1);
2203 * 82597EX: Workaround for redundent write back in receive descriptor ring (causes
2204 * memory corruption). Avoid using and re-submitting the most recently received RX
2205 * descriptor back to hardware.
2207 * if(Last written back descriptor == EOP bit set descriptor)
2208 * then avoid re-submitting the most recently received RX descriptor
2210 * if(Last written back descriptor != EOP bit set descriptor)
2211 * then avoid re-submitting the most recently received RX descriptors
2212 * till last EOP bit set descriptor.
2214 if (eop_desc != i) {
2215 if (++eop_desc == adapter->num_rx_desc)
2219 /* Replenish the descriptors with new mbufs till last EOP bit set descriptor */
2220 while (next_to_use != i) {
2221 current_desc = &adapter->rx_desc_base[next_to_use];
2222 if ((current_desc->errors & (IXGB_RX_DESC_ERRORS_CE |
2223 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P |
2224 IXGB_RX_DESC_ERRORS_RXE))) {
2225 mp = adapter->rx_buffer_area[next_to_use].m_head;
2226 ixgb_get_buf(next_to_use, adapter, mp);
2228 if (ixgb_get_buf(next_to_use, adapter, NULL) == ENOBUFS)
2231 /* Advance our pointers to the next descriptor */
2232 if (++next_to_use == adapter->num_rx_desc) {
2234 current_desc = adapter->rx_desc_base;
2238 adapter->next_rx_desc_to_use = next_to_use;
2239 if (--next_to_use < 0)
2240 next_to_use = (adapter->num_rx_desc - 1);
2241 /* Advance the IXGB's Receive Queue #0 "Tail Pointer" */
2242 IXGB_WRITE_REG(&adapter->hw, RDT, next_to_use);
2247 /*********************************************************************
2249 * Verify that the hardware indicated that the checksum is valid.
2250 * Inform the stack about the status of checksum so that stack
2251 * doesn't spend time verifying the checksum.
2253 *********************************************************************/
2255 ixgb_receive_checksum(struct adapter * adapter,
2256 struct ixgb_rx_desc * rx_desc,
2259 if (rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) {
2260 mp->m_pkthdr.csum_flags = 0;
2263 if (rx_desc->status & IXGB_RX_DESC_STATUS_IPCS) {
2265 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_IPE)) {
2266 /* IP Checksum Good */
2267 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED;
2268 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID;
2271 mp->m_pkthdr.csum_flags = 0;
2274 if (rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS) {
2276 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE)) {
2277 mp->m_pkthdr.csum_flags |=
2278 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR);
2279 mp->m_pkthdr.csum_data = htons(0xffff);
2287 ixgb_enable_vlans(struct adapter * adapter)
2291 ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
2292 ctrl |= IXGB_CTRL0_VME;
2293 IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
2300 ixgb_enable_intr(struct adapter * adapter)
2302 IXGB_WRITE_REG(&adapter->hw, IMS, (IXGB_INT_RXT0 | IXGB_INT_TXDW |
2303 IXGB_INT_RXDMT0 | IXGB_INT_LSC | IXGB_INT_RXO));
2308 ixgb_disable_intr(struct adapter * adapter)
2310 IXGB_WRITE_REG(&adapter->hw, IMC, ~0);
2315 ixgb_write_pci_cfg(struct ixgb_hw * hw,
2319 pci_write_config(((struct ixgb_osdep *) hw->back)->dev, reg,
2323 /**********************************************************************
2325 * Update the board statistics counters.
2327 **********************************************************************/
2329 ixgb_update_stats_counters(struct adapter * adapter)
2332 adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS);
2333 adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL);
2334 adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH);
2335 adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL);
2336 adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH);
2337 adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL);
2338 adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH);
2339 adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL);
2340 adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH);
2341 adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC);
2343 adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC);
2344 adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC);
2345 adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC);
2346 adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC);
2347 adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC);
2348 adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC);
2349 adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC);
2350 adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL);
2351 adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH);
2352 adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL);
2353 adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH);
2354 adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC);
2355 adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC);
2356 adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC);
2357 adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL);
2358 adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH);
2359 adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL);
2360 adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH);
2361 adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL);
2362 adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH);
2363 adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL);
2364 adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH);
2365 adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C);
2366 adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL);
2367 adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH);
2368 adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL);
2369 adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH);
2371 adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL);
2372 adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH);
2373 adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL);
2374 adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH);
2375 adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL);
2376 adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH);
2377 adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC);
2378 adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC);
2379 adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC);
2380 adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL);
2381 adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH);
2382 adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL);
2383 adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH);
2384 adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL);
2385 adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH);
2386 adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC);
2387 adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC);
2388 adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC);
2389 adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC);
2390 adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC);
2391 adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC);
2392 adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC);
2396 ixgb_get_counter(struct ifnet *ifp, ift_counter cnt)
2398 struct adapter *adapter;
2400 adapter = if_getsoftc(ifp);
2403 case IFCOUNTER_IPACKETS:
2404 return (adapter->stats.gprcl);
2405 case IFCOUNTER_OPACKETS:
2406 return ( adapter->stats.gptcl);
2407 case IFCOUNTER_IBYTES:
2408 return (adapter->stats.gorcl);
2409 case IFCOUNTER_OBYTES:
2410 return (adapter->stats.gotcl);
2411 case IFCOUNTER_IMCASTS:
2412 return ( adapter->stats.mprcl);
2413 case IFCOUNTER_COLLISIONS:
2415 case IFCOUNTER_IERRORS:
2416 return (adapter->dropped_pkts + adapter->stats.crcerrs +
2417 adapter->stats.rnbc + adapter->stats.mpc +
2418 adapter->stats.rlec);
2420 return (if_get_counter_default(ifp, cnt));
2424 /**********************************************************************
2426 * This routine is called only when ixgb_display_debug_stats is enabled.
2427 * This routine provides a way to take a look at important statistics
2428 * maintained by the driver and hardware.
2430 **********************************************************************/
2432 ixgb_print_hw_stats(struct adapter * adapter)
2434 char buf_speed[100], buf_type[100];
2435 ixgb_bus_speed bus_speed;
2436 ixgb_bus_type bus_type;
2441 device_printf(dev, "Packets not Avail = %ld\n",
2442 adapter->no_pkts_avail);
2443 device_printf(dev, "CleanTxInterrupts = %ld\n",
2444 adapter->clean_tx_interrupts);
2445 device_printf(dev, "ICR RXDMT0 = %lld\n",
2446 (long long)adapter->sv_stats.icr_rxdmt0);
2447 device_printf(dev, "ICR RXO = %lld\n",
2448 (long long)adapter->sv_stats.icr_rxo);
2449 device_printf(dev, "ICR RXT0 = %lld\n",
2450 (long long)adapter->sv_stats.icr_rxt0);
2451 device_printf(dev, "ICR TXDW = %lld\n",
2452 (long long)adapter->sv_stats.icr_TXDW);
2455 bus_speed = adapter->hw.bus.speed;
2456 bus_type = adapter->hw.bus.type;
2458 bus_speed == ixgb_bus_speed_33 ? "33MHz" :
2459 bus_speed == ixgb_bus_speed_66 ? "66MHz" :
2460 bus_speed == ixgb_bus_speed_100 ? "100MHz" :
2461 bus_speed == ixgb_bus_speed_133 ? "133MHz" :
2463 device_printf(dev, "PCI_Bus_Speed = %s\n",
2467 bus_type == ixgb_bus_type_pci ? "PCI" :
2468 bus_type == ixgb_bus_type_pcix ? "PCI-X" :
2470 device_printf(dev, "PCI_Bus_Type = %s\n",
2473 device_printf(dev, "Tx Descriptors not Avail1 = %ld\n",
2474 adapter->no_tx_desc_avail1);
2475 device_printf(dev, "Tx Descriptors not Avail2 = %ld\n",
2476 adapter->no_tx_desc_avail2);
2477 device_printf(dev, "Std Mbuf Failed = %ld\n",
2478 adapter->mbuf_alloc_failed);
2479 device_printf(dev, "Std Cluster Failed = %ld\n",
2480 adapter->mbuf_cluster_failed);
2482 device_printf(dev, "Defer count = %lld\n",
2483 (long long)adapter->stats.dc);
2484 device_printf(dev, "Missed Packets = %lld\n",
2485 (long long)adapter->stats.mpc);
2486 device_printf(dev, "Receive No Buffers = %lld\n",
2487 (long long)adapter->stats.rnbc);
2488 device_printf(dev, "Receive length errors = %lld\n",
2489 (long long)adapter->stats.rlec);
2490 device_printf(dev, "Crc errors = %lld\n",
2491 (long long)adapter->stats.crcerrs);
2492 device_printf(dev, "Driver dropped packets = %ld\n",
2493 adapter->dropped_pkts);
2495 device_printf(dev, "XON Rcvd = %lld\n",
2496 (long long)adapter->stats.xonrxc);
2497 device_printf(dev, "XON Xmtd = %lld\n",
2498 (long long)adapter->stats.xontxc);
2499 device_printf(dev, "XOFF Rcvd = %lld\n",
2500 (long long)adapter->stats.xoffrxc);
2501 device_printf(dev, "XOFF Xmtd = %lld\n",
2502 (long long)adapter->stats.xofftxc);
2504 device_printf(dev, "Good Packets Rcvd = %lld\n",
2505 (long long)adapter->stats.gprcl);
2506 device_printf(dev, "Good Packets Xmtd = %lld\n",
2507 (long long)adapter->stats.gptcl);
2509 device_printf(dev, "Jumbo frames recvd = %lld\n",
2510 (long long)adapter->stats.jprcl);
2511 device_printf(dev, "Jumbo frames Xmtd = %lld\n",
2512 (long long)adapter->stats.jptcl);
2519 ixgb_sysctl_stats(SYSCTL_HANDLER_ARGS)
2523 struct adapter *adapter;
2526 error = sysctl_handle_int(oidp, &result, 0, req);
2528 if (error || !req->newptr)
2532 adapter = (struct adapter *) arg1;
2533 ixgb_print_hw_stats(adapter);