if_ixgb.c revision 148637
1/******************************************************************************* 2 3Copyright (c) 2001-2004, Intel Corporation 4All rights reserved. 5 6Redistribution and use in source and binary forms, with or without 7modification, are permitted provided that the following conditions are met: 8 9 1. Redistributions of source code must retain the above copyright notice, 10 this list of conditions and the following disclaimer. 11 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. 15 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. 19 20THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30POSSIBILITY OF SUCH DAMAGE. 31 32***************************************************************************/ 33 34/*$FreeBSD: head/sys/dev/ixgb/if_ixgb.c 148637 2005-08-02 09:27:42Z brueffer $*/ 35 36#include <dev/ixgb/if_ixgb.h> 37 38/********************************************************************* 39 * Set this to one to display debug statistics 40 *********************************************************************/ 41int ixgb_display_debug_stats = 0; 42 43/********************************************************************* 44 * Linked list of board private structures for all NICs found 45 *********************************************************************/ 46 47struct adapter *ixgb_adapter_list = NULL; 48 49 50 51/********************************************************************* 52 * Driver version 53 *********************************************************************/ 54 55char ixgb_driver_version[] = "1.0.6"; 56char ixgb_copyright[] = "Copyright (c) 2001-2004 Intel Corporation."; 57 58/********************************************************************* 59 * PCI Device ID Table 60 * 61 * Used by probe to select devices to load on 62 * Last field stores an index into ixgb_strings 63 * Last entry must be all 0s 64 * 65 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 66 *********************************************************************/ 67 68static ixgb_vendor_info_t ixgb_vendor_info_array[] = 69{ 70 /* Intel(R) PRO/10000 Network Connection */ 71 {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX, PCI_ANY_ID, PCI_ANY_ID, 0}, 72 {INTEL_VENDOR_ID, IXGB_DEVICE_ID_82597EX_SR, PCI_ANY_ID, PCI_ANY_ID, 0}, 73 /* required last entry */ 74 {0, 0, 0, 0, 0} 75}; 76 77/********************************************************************* 78 * Table of branding strings for all supported NICs. 79 *********************************************************************/ 80 81static char *ixgb_strings[] = { 82 "Intel(R) PRO/10GbE Network Driver" 83}; 84 85/********************************************************************* 86 * Function prototypes 87 *********************************************************************/ 88static int ixgb_probe(device_t); 89static int ixgb_attach(device_t); 90static int ixgb_detach(device_t); 91static int ixgb_shutdown(device_t); 92static void ixgb_intr(void *); 93static void ixgb_start(struct ifnet *); 94static void ixgb_start_locked(struct ifnet *); 95static int ixgb_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t); 96static void ixgb_watchdog(struct ifnet *); 97static void ixgb_init(void *); 98static void ixgb_init_locked(struct adapter *); 99static void ixgb_stop(void *); 100static void ixgb_media_status(struct ifnet *, struct ifmediareq *); 101static int ixgb_media_change(struct ifnet *); 102static void ixgb_identify_hardware(struct adapter *); 103static int ixgb_allocate_pci_resources(struct adapter *); 104static void ixgb_free_pci_resources(struct adapter *); 105static void ixgb_local_timer(void *); 106static int ixgb_hardware_init(struct adapter *); 107static void ixgb_setup_interface(device_t, struct adapter *); 108static int ixgb_setup_transmit_structures(struct adapter *); 109static void ixgb_initialize_transmit_unit(struct adapter *); 110static int ixgb_setup_receive_structures(struct adapter *); 111static void ixgb_initialize_receive_unit(struct adapter *); 112static void ixgb_enable_intr(struct adapter *); 113static void ixgb_disable_intr(struct adapter *); 114static void ixgb_free_transmit_structures(struct adapter *); 115static void ixgb_free_receive_structures(struct adapter *); 116static void ixgb_update_stats_counters(struct adapter *); 117static void ixgb_clean_transmit_interrupts(struct adapter *); 118static int ixgb_allocate_receive_structures(struct adapter *); 119static int ixgb_allocate_transmit_structures(struct adapter *); 120static void ixgb_process_receive_interrupts(struct adapter *, int); 121static void 122ixgb_receive_checksum(struct adapter *, 123 struct ixgb_rx_desc * rx_desc, 124 struct mbuf *); 125static void 126ixgb_transmit_checksum_setup(struct adapter *, 127 struct mbuf *, 128 u_int8_t *); 129static void ixgb_set_promisc(struct adapter *); 130static void ixgb_disable_promisc(struct adapter *); 131static void ixgb_set_multi(struct adapter *); 132static void ixgb_print_hw_stats(struct adapter *); 133static void ixgb_print_link_status(struct adapter *); 134static int 135ixgb_get_buf(int i, struct adapter *, 136 struct mbuf *); 137static void ixgb_enable_vlans(struct adapter * adapter); 138static int ixgb_encap(struct adapter * adapter, struct mbuf * m_head); 139static int ixgb_sysctl_stats(SYSCTL_HANDLER_ARGS); 140static int 141ixgb_dma_malloc(struct adapter *, bus_size_t, 142 struct ixgb_dma_alloc *, int); 143static void ixgb_dma_free(struct adapter *, struct ixgb_dma_alloc *); 144 145/********************************************************************* 146 * FreeBSD Device Interface Entry Points 147 *********************************************************************/ 148 149static device_method_t ixgb_methods[] = { 150 /* Device interface */ 151 DEVMETHOD(device_probe, ixgb_probe), 152 DEVMETHOD(device_attach, ixgb_attach), 153 DEVMETHOD(device_detach, ixgb_detach), 154 DEVMETHOD(device_shutdown, ixgb_shutdown), 155 {0, 0} 156}; 157 158static driver_t ixgb_driver = { 159 "ixgb", ixgb_methods, sizeof(struct adapter), 160}; 161 162static devclass_t ixgb_devclass; 163DRIVER_MODULE(if_ixgb, pci, ixgb_driver, ixgb_devclass, 0, 0); 164 165MODULE_DEPEND(if_ixgb, pci, 1, 1, 1); 166MODULE_DEPEND(if_ixgb, ether, 1, 1, 1); 167 168/* some defines for controlling descriptor fetches in h/w */ 169#define RXDCTL_PTHRESH_DEFAULT 128 /* chip considers prefech below this */ 170#define RXDCTL_HTHRESH_DEFAULT 16 /* chip will only prefetch if tail is 171 * pushed this many descriptors from 172 * head */ 173#define RXDCTL_WTHRESH_DEFAULT 0 /* chip writes back at this many or RXT0 */ 174 175 176/********************************************************************* 177 * Device identification routine 178 * 179 * ixgb_probe determines if the driver should be loaded on 180 * adapter based on PCI vendor/device id of the adapter. 181 * 182 * return 0 on success, positive on failure 183 *********************************************************************/ 184 185static int 186ixgb_probe(device_t dev) 187{ 188 ixgb_vendor_info_t *ent; 189 190 u_int16_t pci_vendor_id = 0; 191 u_int16_t pci_device_id = 0; 192 u_int16_t pci_subvendor_id = 0; 193 u_int16_t pci_subdevice_id = 0; 194 char adapter_name[60]; 195 196 INIT_DEBUGOUT("ixgb_probe: begin"); 197 198 pci_vendor_id = pci_get_vendor(dev); 199 if (pci_vendor_id != IXGB_VENDOR_ID) 200 return (ENXIO); 201 202 pci_device_id = pci_get_device(dev); 203 pci_subvendor_id = pci_get_subvendor(dev); 204 pci_subdevice_id = pci_get_subdevice(dev); 205 206 ent = ixgb_vendor_info_array; 207 while (ent->vendor_id != 0) { 208 if ((pci_vendor_id == ent->vendor_id) && 209 (pci_device_id == ent->device_id) && 210 211 ((pci_subvendor_id == ent->subvendor_id) || 212 (ent->subvendor_id == PCI_ANY_ID)) && 213 214 ((pci_subdevice_id == ent->subdevice_id) || 215 (ent->subdevice_id == PCI_ANY_ID))) { 216 sprintf(adapter_name, "%s, Version - %s", 217 ixgb_strings[ent->index], 218 ixgb_driver_version); 219 device_set_desc_copy(dev, adapter_name); 220 return (BUS_PROBE_DEFAULT); 221 } 222 ent++; 223 } 224 225 return (ENXIO); 226} 227 228/********************************************************************* 229 * Device initialization routine 230 * 231 * The attach entry point is called when the driver is being loaded. 232 * This routine identifies the type of hardware, allocates all resources 233 * and initializes the hardware. 234 * 235 * return 0 on success, positive on failure 236 *********************************************************************/ 237 238static int 239ixgb_attach(device_t dev) 240{ 241 struct adapter *adapter; 242 int tsize, rsize; 243 int error = 0; 244 245 printf("ixgb%d: %s\n", device_get_unit(dev), ixgb_copyright); 246 INIT_DEBUGOUT("ixgb_attach: begin"); 247 248 /* Allocate, clear, and link in our adapter structure */ 249 if (!(adapter = device_get_softc(dev))) { 250 printf("ixgb: adapter structure allocation failed\n"); 251 return (ENOMEM); 252 } 253 bzero(adapter, sizeof(struct adapter)); 254 adapter->dev = dev; 255 adapter->osdep.dev = dev; 256 adapter->unit = device_get_unit(dev); 257 IXGB_LOCK_INIT(adapter, device_get_nameunit(dev)); 258 259 if (ixgb_adapter_list != NULL) 260 ixgb_adapter_list->prev = adapter; 261 adapter->next = ixgb_adapter_list; 262 ixgb_adapter_list = adapter; 263 264 /* SYSCTL APIs */ 265 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 266 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 267 OID_AUTO, "stats", CTLTYPE_INT | CTLFLAG_RW, 268 (void *)adapter, 0, 269 ixgb_sysctl_stats, "I", "Statistics"); 270 271 callout_init(&adapter->timer, CALLOUT_MPSAFE); 272 273 /* Determine hardware revision */ 274 ixgb_identify_hardware(adapter); 275 276 /* Parameters (to be read from user) */ 277 adapter->num_tx_desc = IXGB_MAX_TXD; 278 adapter->num_rx_desc = IXGB_MAX_RXD; 279 adapter->tx_int_delay = TIDV; 280 adapter->rx_int_delay = RDTR; 281 adapter->rx_buffer_len = IXGB_RXBUFFER_2048; 282 283 adapter->hw.fc.high_water = FCRTH; 284 adapter->hw.fc.low_water = FCRTL; 285 adapter->hw.fc.pause_time = FCPAUSE; 286 adapter->hw.fc.send_xon = TRUE; 287 adapter->hw.fc.type = FLOW_CONTROL; 288 289 290 /* Set the max frame size assuming standard ethernet sized frames */ 291 adapter->hw.max_frame_size = 292 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 293 294 if (ixgb_allocate_pci_resources(adapter)) { 295 printf("ixgb%d: Allocation of PCI resources failed\n", 296 adapter->unit); 297 error = ENXIO; 298 goto err_pci; 299 } 300 tsize = IXGB_ROUNDUP(adapter->num_tx_desc * 301 sizeof(struct ixgb_tx_desc), 4096); 302 303 /* Allocate Transmit Descriptor ring */ 304 if (ixgb_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) { 305 printf("ixgb%d: Unable to allocate TxDescriptor memory\n", 306 adapter->unit); 307 error = ENOMEM; 308 goto err_tx_desc; 309 } 310 adapter->tx_desc_base = (struct ixgb_tx_desc *) adapter->txdma.dma_vaddr; 311 312 rsize = IXGB_ROUNDUP(adapter->num_rx_desc * 313 sizeof(struct ixgb_rx_desc), 4096); 314 315 /* Allocate Receive Descriptor ring */ 316 if (ixgb_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) { 317 printf("ixgb%d: Unable to allocate rx_desc memory\n", 318 adapter->unit); 319 error = ENOMEM; 320 goto err_rx_desc; 321 } 322 adapter->rx_desc_base = (struct ixgb_rx_desc *) adapter->rxdma.dma_vaddr; 323 324 /* Initialize the hardware */ 325 if (ixgb_hardware_init(adapter)) { 326 printf("ixgb%d: Unable to initialize the hardware\n", 327 adapter->unit); 328 error = EIO; 329 goto err_hw_init; 330 } 331 /* Setup OS specific network interface */ 332 ixgb_setup_interface(dev, adapter); 333 334 /* Initialize statistics */ 335 ixgb_clear_hw_cntrs(&adapter->hw); 336 ixgb_update_stats_counters(adapter); 337 338 INIT_DEBUGOUT("ixgb_attach: end"); 339 return (0); 340 341err_hw_init: 342 ixgb_dma_free(adapter, &adapter->rxdma); 343err_rx_desc: 344 ixgb_dma_free(adapter, &adapter->txdma); 345err_tx_desc: 346err_pci: 347 ixgb_free_pci_resources(adapter); 348 sysctl_ctx_free(&adapter->sysctl_ctx); 349 return (error); 350 351} 352 353/********************************************************************* 354 * Device removal routine 355 * 356 * The detach entry point is called when the driver is being removed. 357 * This routine stops the adapter and deallocates all the resources 358 * that were allocated for driver operation. 359 * 360 * return 0 on success, positive on failure 361 *********************************************************************/ 362 363static int 364ixgb_detach(device_t dev) 365{ 366 struct adapter *adapter = device_get_softc(dev); 367 struct ifnet *ifp = adapter->ifp; 368 369 INIT_DEBUGOUT("ixgb_detach: begin"); 370 371 IXGB_LOCK(adapter); 372 adapter->in_detach = 1; 373 374 ixgb_stop(adapter); 375 IXGB_UNLOCK(adapter); 376 377#if __FreeBSD_version < 500000 378 ether_ifdetach(adapter->ifp, ETHER_BPF_SUPPORTED); 379#else 380 ether_ifdetach(adapter->ifp); 381 if_free(adapter->ifp); 382#endif 383 ixgb_free_pci_resources(adapter); 384 385 386 /* Free Transmit Descriptor ring */ 387 if (adapter->tx_desc_base) { 388 ixgb_dma_free(adapter, &adapter->txdma); 389 adapter->tx_desc_base = NULL; 390 } 391 /* Free Receive Descriptor ring */ 392 if (adapter->rx_desc_base) { 393 ixgb_dma_free(adapter, &adapter->rxdma); 394 adapter->rx_desc_base = NULL; 395 } 396 /* Remove from the adapter list */ 397 if (ixgb_adapter_list == adapter) 398 ixgb_adapter_list = adapter->next; 399 if (adapter->next != NULL) 400 adapter->next->prev = adapter->prev; 401 if (adapter->prev != NULL) 402 adapter->prev->next = adapter->next; 403 404 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 405 ifp->if_timer = 0; 406 407 IXGB_LOCK_DESTROY(adapter); 408 return (0); 409} 410 411/********************************************************************* 412 * 413 * Shutdown entry point 414 * 415 **********************************************************************/ 416 417static int 418ixgb_shutdown(device_t dev) 419{ 420 struct adapter *adapter = device_get_softc(dev); 421 IXGB_LOCK(adapter); 422 ixgb_stop(adapter); 423 IXGB_UNLOCK(adapter); 424 return (0); 425} 426 427 428/********************************************************************* 429 * Transmit entry point 430 * 431 * ixgb_start is called by the stack to initiate a transmit. 432 * The driver will remain in this routine as long as there are 433 * packets to transmit and transmit resources are available. 434 * In case resources are not available stack is notified and 435 * the packet is requeued. 436 **********************************************************************/ 437 438static void 439ixgb_start_locked(struct ifnet * ifp) 440{ 441 struct mbuf *m_head; 442 struct adapter *adapter = ifp->if_softc; 443 444 IXGB_LOCK_ASSERT(adapter); 445 446 if (!adapter->link_active) 447 return; 448 449 while (ifp->if_snd.ifq_head != NULL) { 450 IF_DEQUEUE(&ifp->if_snd, m_head); 451 452 if (m_head == NULL) 453 break; 454 455 if (ixgb_encap(adapter, m_head)) { 456 ifp->if_flags |= IFF_OACTIVE; 457 IF_PREPEND(&ifp->if_snd, m_head); 458 break; 459 } 460 /* Send a copy of the frame to the BPF listener */ 461#if __FreeBSD_version < 500000 462 if (ifp->if_bpf) 463 bpf_mtap(ifp, m_head); 464#else 465 BPF_MTAP(ifp, m_head); 466#endif 467 /* Set timeout in case hardware has problems transmitting */ 468 ifp->if_timer = IXGB_TX_TIMEOUT; 469 470 } 471 return; 472} 473 474static void 475ixgb_start(struct ifnet *ifp) 476{ 477 struct adapter *adapter = ifp->if_softc; 478 479 IXGB_LOCK(adapter); 480 ixgb_start_locked(ifp); 481 IXGB_UNLOCK(adapter); 482 return; 483} 484 485/********************************************************************* 486 * Ioctl entry point 487 * 488 * ixgb_ioctl is called when the user wants to configure the 489 * interface. 490 * 491 * return 0 on success, positive on failure 492 **********************************************************************/ 493 494static int 495ixgb_ioctl(struct ifnet * ifp, IOCTL_CMD_TYPE command, caddr_t data) 496{ 497 int mask, error = 0; 498 struct ifreq *ifr = (struct ifreq *) data; 499 struct adapter *adapter = ifp->if_softc; 500 501 if (adapter->in_detach) 502 goto out; 503 504 switch (command) { 505 case SIOCSIFADDR: 506 case SIOCGIFADDR: 507 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 508 ether_ioctl(ifp, command, data); 509 break; 510 case SIOCSIFMTU: 511 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 512 if (ifr->ifr_mtu > IXGB_MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) { 513 error = EINVAL; 514 } else { 515 IXGB_LOCK(adapter); 516 ifp->if_mtu = ifr->ifr_mtu; 517 adapter->hw.max_frame_size = 518 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 519 520 ixgb_init_locked(adapter); 521 IXGB_UNLOCK(adapter); 522 } 523 break; 524 case SIOCSIFFLAGS: 525 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 526 IXGB_LOCK(adapter); 527 if (ifp->if_flags & IFF_UP) { 528 if (!(ifp->if_flags & IFF_RUNNING)) { 529 ixgb_init_locked(adapter); 530 } 531 ixgb_disable_promisc(adapter); 532 ixgb_set_promisc(adapter); 533 } else { 534 if (ifp->if_flags & IFF_RUNNING) { 535 ixgb_stop(adapter); 536 } 537 } 538 IXGB_UNLOCK(adapter); 539 break; 540 case SIOCADDMULTI: 541 case SIOCDELMULTI: 542 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 543 if (ifp->if_flags & IFF_RUNNING) { 544 IXGB_LOCK(adapter); 545 ixgb_disable_intr(adapter); 546 ixgb_set_multi(adapter); 547 ixgb_enable_intr(adapter); 548 IXGB_UNLOCK(adapter); 549 } 550 break; 551 case SIOCSIFMEDIA: 552 case SIOCGIFMEDIA: 553 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 554 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 555 break; 556 case SIOCSIFCAP: 557 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 558 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 559 if (mask & IFCAP_HWCSUM) { 560 if (IFCAP_HWCSUM & ifp->if_capenable) 561 ifp->if_capenable &= ~IFCAP_HWCSUM; 562 else 563 ifp->if_capenable |= IFCAP_HWCSUM; 564 if (ifp->if_flags & IFF_RUNNING) 565 ixgb_init(adapter); 566 } 567 break; 568 default: 569 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%X)\n", (int)command); 570 error = EINVAL; 571 } 572 573out: 574 return (error); 575} 576 577/********************************************************************* 578 * Watchdog entry point 579 * 580 * This routine is called whenever hardware quits transmitting. 581 * 582 **********************************************************************/ 583 584static void 585ixgb_watchdog(struct ifnet * ifp) 586{ 587 struct adapter *adapter; 588 adapter = ifp->if_softc; 589 590 /* 591 * If we are in this routine because of pause frames, then don't 592 * reset the hardware. 593 */ 594 if (IXGB_READ_REG(&adapter->hw, STATUS) & IXGB_STATUS_TXOFF) { 595 ifp->if_timer = IXGB_TX_TIMEOUT; 596 return; 597 } 598 printf("ixgb%d: watchdog timeout -- resetting\n", adapter->unit); 599 600 ifp->if_flags &= ~IFF_RUNNING; 601 602 603 ixgb_stop(adapter); 604 ixgb_init(adapter); 605 606 607 ifp->if_oerrors++; 608 609 return; 610} 611 612/********************************************************************* 613 * Init entry point 614 * 615 * This routine is used in two ways. It is used by the stack as 616 * init entry point in network interface structure. It is also used 617 * by the driver as a hw/sw initialization routine to get to a 618 * consistent state. 619 * 620 * return 0 on success, positive on failure 621 **********************************************************************/ 622 623static void 624ixgb_init_locked(struct adapter *adapter) 625{ 626 struct ifnet *ifp; 627 628 INIT_DEBUGOUT("ixgb_init: begin"); 629 630 IXGB_LOCK_ASSERT(adapter); 631 632 ixgb_stop(adapter); 633 634 /* Get the latest mac address, User can use a LAA */ 635 bcopy(IFP2ENADDR(adapter->ifp), adapter->hw.curr_mac_addr, 636 IXGB_ETH_LENGTH_OF_ADDRESS); 637 638 /* Initialize the hardware */ 639 if (ixgb_hardware_init(adapter)) { 640 printf("ixgb%d: Unable to initialize the hardware\n", 641 adapter->unit); 642 return; 643 } 644 ixgb_enable_vlans(adapter); 645 646 /* Prepare transmit descriptors and buffers */ 647 if (ixgb_setup_transmit_structures(adapter)) { 648 printf("ixgb%d: Could not setup transmit structures\n", 649 adapter->unit); 650 ixgb_stop(adapter); 651 return; 652 } 653 ixgb_initialize_transmit_unit(adapter); 654 655 /* Setup Multicast table */ 656 ixgb_set_multi(adapter); 657 658 /* Prepare receive descriptors and buffers */ 659 if (ixgb_setup_receive_structures(adapter)) { 660 printf("ixgb%d: Could not setup receive structures\n", 661 adapter->unit); 662 ixgb_stop(adapter); 663 return; 664 } 665 ixgb_initialize_receive_unit(adapter); 666 667 /* Don't loose promiscuous settings */ 668 ixgb_set_promisc(adapter); 669 670 ifp = adapter->ifp; 671 ifp->if_flags |= IFF_RUNNING; 672 ifp->if_flags &= ~IFF_OACTIVE; 673 674 675 if (ifp->if_capenable & IFCAP_TXCSUM) 676 ifp->if_hwassist = IXGB_CHECKSUM_FEATURES; 677 else 678 ifp->if_hwassist = 0; 679 680 681 /* Enable jumbo frames */ 682 if (ifp->if_mtu > ETHERMTU) { 683 uint32_t temp_reg; 684 IXGB_WRITE_REG(&adapter->hw, MFS, 685 adapter->hw.max_frame_size << IXGB_MFS_SHIFT); 686 temp_reg = IXGB_READ_REG(&adapter->hw, CTRL0); 687 temp_reg |= IXGB_CTRL0_JFE; 688 IXGB_WRITE_REG(&adapter->hw, CTRL0, temp_reg); 689 } 690 callout_reset(&adapter->timer, 2 * hz, ixgb_local_timer, adapter); 691 ixgb_clear_hw_cntrs(&adapter->hw); 692#ifdef DEVICE_POLLING 693 /* 694 * Only disable interrupts if we are polling, make sure they are on 695 * otherwise. 696 */ 697 if (ifp->if_flags & IFF_POLLING) 698 ixgb_disable_intr(adapter); 699 else 700#endif /* DEVICE_POLLING */ 701 ixgb_enable_intr(adapter); 702 703 return; 704} 705 706static void 707ixgb_init(void *arg) 708{ 709 struct adapter *adapter = arg; 710 711 IXGB_LOCK(adapter); 712 ixgb_init_locked(adapter); 713 IXGB_UNLOCK(adapter); 714 return; 715} 716 717#ifdef DEVICE_POLLING 718static poll_handler_t ixgb_poll; 719 720static void 721ixgb_poll_locked(struct ifnet * ifp, enum poll_cmd cmd, int count) 722{ 723 struct adapter *adapter = ifp->if_softc; 724 u_int32_t reg_icr; 725 726 IXGB_LOCK_ASSERT(adapter); 727 728 if (!(ifp->if_capenable & IFCAP_POLLING)) { 729 ether_poll_deregister(ifp); 730 cmd = POLL_DEREGISTER; 731 } 732 733 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */ 734 ixgb_enable_intr(adapter); 735 return; 736 } 737 if (cmd == POLL_AND_CHECK_STATUS) { 738 reg_icr = IXGB_READ_REG(&adapter->hw, ICR); 739 if (reg_icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) { 740 callout_stop(&adapter->timer); 741 ixgb_check_for_link(&adapter->hw); 742 ixgb_print_link_status(adapter); 743 callout_reset(&adapter->timer, 2 * hz, ixgb_local_timer, 744 adapter); 745 } 746 } 747 if (ifp->if_flags & IFF_RUNNING) { 748 ixgb_process_receive_interrupts(adapter, count); 749 ixgb_clean_transmit_interrupts(adapter); 750 } 751 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 752 ixgb_start_locked(ifp); 753} 754 755static void 756ixgb_poll(struct ifnet * ifp, enum poll_cmd cmd, int count) 757{ 758 struct adapter *adapter = ifp->if_softc; 759 760 IXGB_LOCK(adapter); 761 ixgb_poll_locked(ifp, cmd, count); 762 IXGB_UNLOCK(adapter); 763} 764#endif /* DEVICE_POLLING */ 765 766/********************************************************************* 767 * 768 * Interrupt Service routine 769 * 770 **********************************************************************/ 771 772static void 773ixgb_intr(void *arg) 774{ 775 u_int32_t loop_cnt = IXGB_MAX_INTR; 776 u_int32_t reg_icr; 777 struct ifnet *ifp; 778 struct adapter *adapter = arg; 779 boolean_t rxdmt0 = FALSE; 780 781 IXGB_LOCK(adapter); 782 783 ifp = adapter->ifp; 784 785#ifdef DEVICE_POLLING 786 if (ifp->if_flags & IFF_POLLING) { 787 IXGB_UNLOCK(adapter); 788 return; 789 } 790 791 if ((ifp->if_capenable & IFCAP_POLLING) && 792 ether_poll_register(ixgb_poll, ifp)) { 793 ixgb_disable_intr(adapter); 794 ixgb_poll_locked(ifp, 0, 1); 795 IXGB_UNLOCK(adapter); 796 return; 797 } 798#endif /* DEVICE_POLLING */ 799 800 reg_icr = IXGB_READ_REG(&adapter->hw, ICR); 801 if (reg_icr == 0) { 802 IXGB_UNLOCK(adapter); 803 return; 804 } 805 806 if (reg_icr & IXGB_INT_RXDMT0) 807 rxdmt0 = TRUE; 808 809#ifdef _SV_ 810 if (reg_icr & IXGB_INT_RXDMT0) 811 adapter->sv_stats.icr_rxdmt0++; 812 if (reg_icr & IXGB_INT_RXO) 813 adapter->sv_stats.icr_rxo++; 814 if (reg_icr & IXGB_INT_RXT0) 815 adapter->sv_stats.icr_rxt0++; 816 if (reg_icr & IXGB_INT_TXDW) 817 adapter->sv_stats.icr_TXDW++; 818#endif /* _SV_ */ 819 820 /* Link status change */ 821 if (reg_icr & (IXGB_INT_RXSEQ | IXGB_INT_LSC)) { 822 callout_stop(&adapter->timer); 823 ixgb_check_for_link(&adapter->hw); 824 ixgb_print_link_status(adapter); 825 callout_reset(&adapter->timer, 2 * hz, ixgb_local_timer, 826 adapter); 827 } 828 while (loop_cnt > 0) { 829 if (ifp->if_flags & IFF_RUNNING) { 830 ixgb_process_receive_interrupts(adapter, -1); 831 ixgb_clean_transmit_interrupts(adapter); 832 } 833 loop_cnt--; 834 } 835 836 if (rxdmt0 && adapter->raidc) { 837 IXGB_WRITE_REG(&adapter->hw, IMC, IXGB_INT_RXDMT0); 838 IXGB_WRITE_REG(&adapter->hw, IMS, IXGB_INT_RXDMT0); 839 } 840 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 841 ixgb_start_locked(ifp); 842 843 IXGB_UNLOCK(adapter); 844 return; 845} 846 847 848/********************************************************************* 849 * 850 * Media Ioctl callback 851 * 852 * This routine is called whenever the user queries the status of 853 * the interface using ifconfig. 854 * 855 **********************************************************************/ 856static void 857ixgb_media_status(struct ifnet * ifp, struct ifmediareq * ifmr) 858{ 859 struct adapter *adapter = ifp->if_softc; 860 861 INIT_DEBUGOUT("ixgb_media_status: begin"); 862 863 ixgb_check_for_link(&adapter->hw); 864 ixgb_print_link_status(adapter); 865 866 ifmr->ifm_status = IFM_AVALID; 867 ifmr->ifm_active = IFM_ETHER; 868 869 if (!adapter->hw.link_up) 870 return; 871 872 ifmr->ifm_status |= IFM_ACTIVE; 873 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 874 875 return; 876} 877 878/********************************************************************* 879 * 880 * Media Ioctl callback 881 * 882 * This routine is called when the user changes speed/duplex using 883 * media/mediopt option with ifconfig. 884 * 885 **********************************************************************/ 886static int 887ixgb_media_change(struct ifnet * ifp) 888{ 889 struct adapter *adapter = ifp->if_softc; 890 struct ifmedia *ifm = &adapter->media; 891 892 INIT_DEBUGOUT("ixgb_media_change: begin"); 893 894 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 895 return (EINVAL); 896 897 return (0); 898} 899 900/********************************************************************* 901 * 902 * This routine maps the mbufs to tx descriptors. 903 * 904 * return 0 on success, positive on failure 905 **********************************************************************/ 906 907static int 908ixgb_encap(struct adapter * adapter, struct mbuf * m_head) 909{ 910 u_int8_t txd_popts; 911 int i, j, error, nsegs; 912 913#if __FreeBSD_version < 500000 914 struct ifvlan *ifv = NULL; 915#else 916 struct m_tag *mtag; 917#endif 918 bus_dma_segment_t segs[IXGB_MAX_SCATTER]; 919 bus_dmamap_t map; 920 struct ixgb_buffer *tx_buffer = NULL; 921 struct ixgb_tx_desc *current_tx_desc = NULL; 922 struct ifnet *ifp = adapter->ifp; 923 924 /* 925 * Force a cleanup if number of TX descriptors available hits the 926 * threshold 927 */ 928 if (adapter->num_tx_desc_avail <= IXGB_TX_CLEANUP_THRESHOLD) { 929 ixgb_clean_transmit_interrupts(adapter); 930 } 931 if (adapter->num_tx_desc_avail <= IXGB_TX_CLEANUP_THRESHOLD) { 932 adapter->no_tx_desc_avail1++; 933 return (ENOBUFS); 934 } 935 /* 936 * Map the packet for DMA. 937 */ 938 if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &map)) { 939 adapter->no_tx_map_avail++; 940 return (ENOMEM); 941 } 942 error = bus_dmamap_load_mbuf_sg(adapter->txtag, map, m_head, segs, 943 &nsegs, BUS_DMA_NOWAIT); 944 if (error != 0) { 945 adapter->no_tx_dma_setup++; 946 printf("ixgb%d: ixgb_encap: bus_dmamap_load_mbuf failed; " 947 "error %u\n", adapter->unit, error); 948 bus_dmamap_destroy(adapter->txtag, map); 949 return (error); 950 } 951 KASSERT(nsegs != 0, ("ixgb_encap: empty packet")); 952 953 if (nsegs > adapter->num_tx_desc_avail) { 954 adapter->no_tx_desc_avail2++; 955 bus_dmamap_destroy(adapter->txtag, map); 956 return (ENOBUFS); 957 } 958 if (ifp->if_hwassist > 0) { 959 ixgb_transmit_checksum_setup(adapter, m_head, 960 &txd_popts); 961 } else 962 txd_popts = 0; 963 964 /* Find out if we are in vlan mode */ 965#if __FreeBSD_version < 500000 966 if ((m_head->m_flags & (M_PROTO1 | M_PKTHDR)) == (M_PROTO1 | M_PKTHDR) && 967 m_head->m_pkthdr.rcvif != NULL && 968 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN) 969 ifv = m_head->m_pkthdr.rcvif->if_softc; 970#else 971 mtag = VLAN_OUTPUT_TAG(ifp, m_head); 972#endif 973 i = adapter->next_avail_tx_desc; 974 for (j = 0; j < nsegs; j++) { 975 tx_buffer = &adapter->tx_buffer_area[i]; 976 current_tx_desc = &adapter->tx_desc_base[i]; 977 978 current_tx_desc->buff_addr = htole64(segs[j].ds_addr); 979 current_tx_desc->cmd_type_len = (adapter->txd_cmd | segs[j].ds_len); 980 current_tx_desc->popts = txd_popts; 981 if (++i == adapter->num_tx_desc) 982 i = 0; 983 984 tx_buffer->m_head = NULL; 985 } 986 987 adapter->num_tx_desc_avail -= nsegs; 988 adapter->next_avail_tx_desc = i; 989 990#if __FreeBSD_version < 500000 991 if (ifv != NULL) { 992 /* Set the vlan id */ 993 current_tx_desc->vlan = ifv->ifv_tag; 994#else 995 if (mtag != NULL) { 996 /* Set the vlan id */ 997 current_tx_desc->vlan = VLAN_TAG_VALUE(mtag); 998#endif 999 1000 /* Tell hardware to add tag */ 1001 current_tx_desc->cmd_type_len |= IXGB_TX_DESC_CMD_VLE; 1002 } 1003 tx_buffer->m_head = m_head; 1004 tx_buffer->map = map; 1005 bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE); 1006 1007 /* 1008 * Last Descriptor of Packet needs End Of Packet (EOP) 1009 */ 1010 current_tx_desc->cmd_type_len |= (IXGB_TX_DESC_CMD_EOP); 1011 1012 /* 1013 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 1014 * that this frame is available to transmit. 1015 */ 1016 IXGB_WRITE_REG(&adapter->hw, TDT, i); 1017 1018 return (0); 1019} 1020 1021static void 1022ixgb_set_promisc(struct adapter * adapter) 1023{ 1024 1025 u_int32_t reg_rctl; 1026 struct ifnet *ifp = adapter->ifp; 1027 1028 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1029 1030 if (ifp->if_flags & IFF_PROMISC) { 1031 reg_rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE); 1032 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1033 } else if (ifp->if_flags & IFF_ALLMULTI) { 1034 reg_rctl |= IXGB_RCTL_MPE; 1035 reg_rctl &= ~IXGB_RCTL_UPE; 1036 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1037 } 1038 return; 1039} 1040 1041static void 1042ixgb_disable_promisc(struct adapter * adapter) 1043{ 1044 u_int32_t reg_rctl; 1045 1046 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1047 1048 reg_rctl &= (~IXGB_RCTL_UPE); 1049 reg_rctl &= (~IXGB_RCTL_MPE); 1050 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1051 1052 return; 1053} 1054 1055 1056/********************************************************************* 1057 * Multicast Update 1058 * 1059 * This routine is called whenever multicast address list is updated. 1060 * 1061 **********************************************************************/ 1062 1063static void 1064ixgb_set_multi(struct adapter * adapter) 1065{ 1066 u_int32_t reg_rctl = 0; 1067 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * IXGB_ETH_LENGTH_OF_ADDRESS]; 1068 struct ifmultiaddr *ifma; 1069 int mcnt = 0; 1070 struct ifnet *ifp = adapter->ifp; 1071 1072 IOCTL_DEBUGOUT("ixgb_set_multi: begin"); 1073 1074#if __FreeBSD_version < 500000 1075 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1076#else 1077 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1078#endif 1079 if (ifma->ifma_addr->sa_family != AF_LINK) 1080 continue; 1081 1082 bcopy(LLADDR((struct sockaddr_dl *) ifma->ifma_addr), 1083 &mta[mcnt * IXGB_ETH_LENGTH_OF_ADDRESS], IXGB_ETH_LENGTH_OF_ADDRESS); 1084 mcnt++; 1085 } 1086 1087 if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) { 1088 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1089 reg_rctl |= IXGB_RCTL_MPE; 1090 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1091 } else 1092 ixgb_mc_addr_list_update(&adapter->hw, mta, mcnt, 0); 1093 1094 return; 1095} 1096 1097 1098/********************************************************************* 1099 * Timer routine 1100 * 1101 * This routine checks for link status and updates statistics. 1102 * 1103 **********************************************************************/ 1104 1105static void 1106ixgb_local_timer(void *arg) 1107{ 1108 struct ifnet *ifp; 1109 struct adapter *adapter = arg; 1110 ifp = adapter->ifp; 1111 1112 IXGB_LOCK(adapter); 1113 1114 ixgb_check_for_link(&adapter->hw); 1115 ixgb_print_link_status(adapter); 1116 ixgb_update_stats_counters(adapter); 1117 if (ixgb_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 1118 ixgb_print_hw_stats(adapter); 1119 } 1120 callout_reset(&adapter->timer, 2 * hz, ixgb_local_timer, adapter); 1121 1122 IXGB_UNLOCK(adapter); 1123 return; 1124} 1125 1126static void 1127ixgb_print_link_status(struct adapter * adapter) 1128{ 1129 if (adapter->hw.link_up) { 1130 if (!adapter->link_active) { 1131 printf("ixgb%d: Link is up %d Mbps %s \n", 1132 adapter->unit, 1133 10000, 1134 "Full Duplex"); 1135 adapter->link_active = 1; 1136 } 1137 } else { 1138 if (adapter->link_active) { 1139 printf("ixgb%d: Link is Down \n", adapter->unit); 1140 adapter->link_active = 0; 1141 } 1142 } 1143 1144 return; 1145} 1146 1147 1148 1149/********************************************************************* 1150 * 1151 * This routine disables all traffic on the adapter by issuing a 1152 * global reset on the MAC and deallocates TX/RX buffers. 1153 * 1154 **********************************************************************/ 1155 1156static void 1157ixgb_stop(void *arg) 1158{ 1159 struct ifnet *ifp; 1160 struct adapter *adapter = arg; 1161 ifp = adapter->ifp; 1162 1163 IXGB_LOCK_ASSERT(adapter); 1164 1165 INIT_DEBUGOUT("ixgb_stop: begin\n"); 1166 ixgb_disable_intr(adapter); 1167 adapter->hw.adapter_stopped = FALSE; 1168 ixgb_adapter_stop(&adapter->hw); 1169 callout_stop(&adapter->timer); 1170 ixgb_free_transmit_structures(adapter); 1171 ixgb_free_receive_structures(adapter); 1172 1173 1174 /* Tell the stack that the interface is no longer active */ 1175 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1176 1177 return; 1178} 1179 1180 1181/********************************************************************* 1182 * 1183 * Determine hardware revision. 1184 * 1185 **********************************************************************/ 1186static void 1187ixgb_identify_hardware(struct adapter * adapter) 1188{ 1189 device_t dev = adapter->dev; 1190 1191 /* Make sure our PCI config space has the necessary stuff set */ 1192 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1193 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1194 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1195 printf("ixgb%d: Memory Access and/or Bus Master bits were not set!\n", 1196 adapter->unit); 1197 adapter->hw.pci_cmd_word |= 1198 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1199 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1200 } 1201 /* Save off the information about this board */ 1202 adapter->hw.vendor_id = pci_get_vendor(dev); 1203 adapter->hw.device_id = pci_get_device(dev); 1204 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1205 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1206 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1207 1208 /* Set MacType, etc. based on this PCI info */ 1209 switch (adapter->hw.device_id) { 1210 case IXGB_DEVICE_ID_82597EX: 1211 case IXGB_DEVICE_ID_82597EX_SR: 1212 adapter->hw.mac_type = ixgb_82597; 1213 break; 1214 default: 1215 INIT_DEBUGOUT1("Unknown device if 0x%x", adapter->hw.device_id); 1216 printf("ixgb%d: unsupported device id 0x%x\n", adapter->unit, adapter->hw.device_id); 1217 } 1218 1219 return; 1220} 1221 1222static int 1223ixgb_allocate_pci_resources(struct adapter * adapter) 1224{ 1225 int rid; 1226 device_t dev = adapter->dev; 1227 1228 rid = IXGB_MMBA; 1229 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, 1230 &rid, 0, ~0, 1, 1231 RF_ACTIVE); 1232 if (!(adapter->res_memory)) { 1233 printf("ixgb%d: Unable to allocate bus resource: memory\n", 1234 adapter->unit); 1235 return (ENXIO); 1236 } 1237 adapter->osdep.mem_bus_space_tag = 1238 rman_get_bustag(adapter->res_memory); 1239 adapter->osdep.mem_bus_space_handle = 1240 rman_get_bushandle(adapter->res_memory); 1241 adapter->hw.hw_addr = (uint8_t *) & adapter->osdep.mem_bus_space_handle; 1242 1243 rid = 0x0; 1244 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, 1245 &rid, 0, ~0, 1, 1246 RF_SHAREABLE | RF_ACTIVE); 1247 if (!(adapter->res_interrupt)) { 1248 printf("ixgb%d: Unable to allocate bus resource: interrupt\n", 1249 adapter->unit); 1250 return (ENXIO); 1251 } 1252 if (bus_setup_intr(dev, adapter->res_interrupt, 1253 INTR_TYPE_NET | INTR_MPSAFE, 1254 (void (*) (void *))ixgb_intr, adapter, 1255 &adapter->int_handler_tag)) { 1256 printf("ixgb%d: Error registering interrupt handler!\n", 1257 adapter->unit); 1258 return (ENXIO); 1259 } 1260 adapter->hw.back = &adapter->osdep; 1261 1262 return (0); 1263} 1264 1265static void 1266ixgb_free_pci_resources(struct adapter * adapter) 1267{ 1268 device_t dev = adapter->dev; 1269 1270 if (adapter->res_interrupt != NULL) { 1271 bus_teardown_intr(dev, adapter->res_interrupt, 1272 adapter->int_handler_tag); 1273 bus_release_resource(dev, SYS_RES_IRQ, 0, 1274 adapter->res_interrupt); 1275 } 1276 if (adapter->res_memory != NULL) { 1277 bus_release_resource(dev, SYS_RES_MEMORY, IXGB_MMBA, 1278 adapter->res_memory); 1279 } 1280 if (adapter->res_ioport != NULL) { 1281 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1282 adapter->res_ioport); 1283 } 1284 return; 1285} 1286 1287/********************************************************************* 1288 * 1289 * Initialize the hardware to a configuration as specified by the 1290 * adapter structure. The controller is reset, the EEPROM is 1291 * verified, the MAC address is set, then the shared initialization 1292 * routines are called. 1293 * 1294 **********************************************************************/ 1295static int 1296ixgb_hardware_init(struct adapter * adapter) 1297{ 1298 /* Issue a global reset */ 1299 adapter->hw.adapter_stopped = FALSE; 1300 ixgb_adapter_stop(&adapter->hw); 1301 1302 /* Make sure we have a good EEPROM before we read from it */ 1303 if (!ixgb_validate_eeprom_checksum(&adapter->hw)) { 1304 printf("ixgb%d: The EEPROM Checksum Is Not Valid\n", 1305 adapter->unit); 1306 return (EIO); 1307 } 1308 if (!ixgb_init_hw(&adapter->hw)) { 1309 printf("ixgb%d: Hardware Initialization Failed", 1310 adapter->unit); 1311 return (EIO); 1312 } 1313 1314 return (0); 1315} 1316 1317/********************************************************************* 1318 * 1319 * Setup networking device structure and register an interface. 1320 * 1321 **********************************************************************/ 1322static void 1323ixgb_setup_interface(device_t dev, struct adapter * adapter) 1324{ 1325 struct ifnet *ifp; 1326 INIT_DEBUGOUT("ixgb_setup_interface: begin"); 1327 1328 ifp = adapter->ifp = if_alloc(IFT_ETHER); 1329 if (ifp == NULL) 1330 panic("%s: can not if_alloc()\n", device_get_nameunit(dev)); 1331#if __FreeBSD_version >= 502000 1332 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1333#else 1334 ifp->if_unit = adapter->unit; 1335 ifp->if_name = "ixgb"; 1336#endif 1337 ifp->if_mtu = ETHERMTU; 1338 ifp->if_baudrate = 1000000000; 1339 ifp->if_init = ixgb_init; 1340 ifp->if_softc = adapter; 1341 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1342 ifp->if_ioctl = ixgb_ioctl; 1343 ifp->if_start = ixgb_start; 1344 ifp->if_watchdog = ixgb_watchdog; 1345 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1346 1347#if __FreeBSD_version < 500000 1348 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1349#else 1350 ether_ifattach(ifp, adapter->hw.curr_mac_addr); 1351#endif 1352 1353 ifp->if_capabilities = IFCAP_HWCSUM; 1354#ifdef DEVICE_POLLING 1355 ifp->if_capabilities |= IFCAP_POLLING; 1356#endif 1357 1358 /* 1359 * Tell the upper layer(s) we support long frames. 1360 */ 1361 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1362 1363#if __FreeBSD_version >= 500000 1364 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1365#endif 1366 1367 ifp->if_capenable = ifp->if_capabilities; 1368 1369 /* 1370 * Specify the media types supported by this adapter and register 1371 * callbacks to update media and link information 1372 */ 1373 ifmedia_init(&adapter->media, IFM_IMASK, ixgb_media_change, 1374 ixgb_media_status); 1375 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1376 0, NULL); 1377 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1378 0, NULL); 1379 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1380 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1381 1382 return; 1383} 1384 1385/******************************************************************** 1386 * Manage DMA'able memory. 1387 *******************************************************************/ 1388static void 1389ixgb_dmamap_cb(void *arg, bus_dma_segment_t * segs, int nseg, int error) 1390{ 1391 if (error) 1392 return; 1393 *(bus_addr_t *) arg = segs->ds_addr; 1394 return; 1395} 1396 1397static int 1398ixgb_dma_malloc(struct adapter * adapter, bus_size_t size, 1399 struct ixgb_dma_alloc * dma, int mapflags) 1400{ 1401 int r; 1402 1403 r = bus_dma_tag_create(NULL, /* parent */ 1404 PAGE_SIZE, 0, /* alignment, bounds */ 1405 BUS_SPACE_MAXADDR, /* lowaddr */ 1406 BUS_SPACE_MAXADDR, /* highaddr */ 1407 NULL, NULL, /* filter, filterarg */ 1408 size, /* maxsize */ 1409 1, /* nsegments */ 1410 size, /* maxsegsize */ 1411 BUS_DMA_ALLOCNOW, /* flags */ 1412#if __FreeBSD_version >= 502000 1413 NULL, /* lockfunc */ 1414 NULL, /* lockfuncarg */ 1415#endif 1416 &dma->dma_tag); 1417 if (r != 0) { 1418 printf("ixgb%d: ixgb_dma_malloc: bus_dma_tag_create failed; " 1419 "error %u\n", adapter->unit, r); 1420 goto fail_0; 1421 } 1422 r = bus_dmamem_alloc(dma->dma_tag, (void **)&dma->dma_vaddr, 1423 BUS_DMA_NOWAIT, &dma->dma_map); 1424 if (r != 0) { 1425 printf("ixgb%d: ixgb_dma_malloc: bus_dmamem_alloc failed; " 1426 "error %u\n", adapter->unit, r); 1427 goto fail_1; 1428 } 1429 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 1430 size, 1431 ixgb_dmamap_cb, 1432 &dma->dma_paddr, 1433 mapflags | BUS_DMA_NOWAIT); 1434 if (r != 0) { 1435 printf("ixgb%d: ixgb_dma_malloc: bus_dmamap_load failed; " 1436 "error %u\n", adapter->unit, r); 1437 goto fail_2; 1438 } 1439 dma->dma_size = size; 1440 return (0); 1441fail_2: 1442 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1443fail_1: 1444 bus_dma_tag_destroy(dma->dma_tag); 1445fail_0: 1446 dma->dma_map = NULL; 1447 dma->dma_tag = NULL; 1448 return (r); 1449} 1450 1451 1452 1453static void 1454ixgb_dma_free(struct adapter * adapter, struct ixgb_dma_alloc * dma) 1455{ 1456 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 1457 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1458 bus_dma_tag_destroy(dma->dma_tag); 1459} 1460 1461/********************************************************************* 1462 * 1463 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1464 * the information needed to transmit a packet on the wire. 1465 * 1466 **********************************************************************/ 1467static int 1468ixgb_allocate_transmit_structures(struct adapter * adapter) 1469{ 1470 if (!(adapter->tx_buffer_area = 1471 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) * 1472 adapter->num_tx_desc, M_DEVBUF, 1473 M_NOWAIT | M_ZERO))) { 1474 printf("ixgb%d: Unable to allocate tx_buffer memory\n", 1475 adapter->unit); 1476 return ENOMEM; 1477 } 1478 bzero(adapter->tx_buffer_area, 1479 sizeof(struct ixgb_buffer) * adapter->num_tx_desc); 1480 1481 return 0; 1482} 1483 1484/********************************************************************* 1485 * 1486 * Allocate and initialize transmit structures. 1487 * 1488 **********************************************************************/ 1489static int 1490ixgb_setup_transmit_structures(struct adapter * adapter) 1491{ 1492 /* 1493 * Setup DMA descriptor areas. 1494 */ 1495 if (bus_dma_tag_create(NULL, /* parent */ 1496 PAGE_SIZE, 0, /* alignment, bounds */ 1497 BUS_SPACE_MAXADDR, /* lowaddr */ 1498 BUS_SPACE_MAXADDR, /* highaddr */ 1499 NULL, NULL, /* filter, filterarg */ 1500 MCLBYTES * IXGB_MAX_SCATTER, /* maxsize */ 1501 IXGB_MAX_SCATTER, /* nsegments */ 1502 MCLBYTES, /* maxsegsize */ 1503 BUS_DMA_ALLOCNOW, /* flags */ 1504#if __FreeBSD_version >= 502000 1505 NULL, /* lockfunc */ 1506 NULL, /* lockfuncarg */ 1507#endif 1508 &adapter->txtag)) { 1509 printf("ixgb%d: Unable to allocate TX DMA tag\n", adapter->unit); 1510 return (ENOMEM); 1511 } 1512 if (ixgb_allocate_transmit_structures(adapter)) 1513 return ENOMEM; 1514 1515 bzero((void *)adapter->tx_desc_base, 1516 (sizeof(struct ixgb_tx_desc)) * adapter->num_tx_desc); 1517 1518 adapter->next_avail_tx_desc = 0; 1519 adapter->oldest_used_tx_desc = 0; 1520 1521 /* Set number of descriptors available */ 1522 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1523 1524 /* Set checksum context */ 1525 adapter->active_checksum_context = OFFLOAD_NONE; 1526 1527 return 0; 1528} 1529 1530/********************************************************************* 1531 * 1532 * Enable transmit unit. 1533 * 1534 **********************************************************************/ 1535static void 1536ixgb_initialize_transmit_unit(struct adapter * adapter) 1537{ 1538 u_int32_t reg_tctl; 1539 u_int64_t tdba = adapter->txdma.dma_paddr; 1540 1541 /* Setup the Base and Length of the Tx Descriptor Ring */ 1542 IXGB_WRITE_REG(&adapter->hw, TDBAL, 1543 (tdba & 0x00000000ffffffffULL)); 1544 IXGB_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32)); 1545 IXGB_WRITE_REG(&adapter->hw, TDLEN, 1546 adapter->num_tx_desc * 1547 sizeof(struct ixgb_tx_desc)); 1548 1549 /* Setup the HW Tx Head and Tail descriptor pointers */ 1550 IXGB_WRITE_REG(&adapter->hw, TDH, 0); 1551 IXGB_WRITE_REG(&adapter->hw, TDT, 0); 1552 1553 1554 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1555 IXGB_READ_REG(&adapter->hw, TDBAL), 1556 IXGB_READ_REG(&adapter->hw, TDLEN)); 1557 1558 IXGB_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1559 1560 1561 /* Program the Transmit Control Register */ 1562 reg_tctl = IXGB_READ_REG(&adapter->hw, TCTL); 1563 reg_tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE; 1564 IXGB_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1565 1566 /* Setup Transmit Descriptor Settings for this adapter */ 1567 adapter->txd_cmd = IXGB_TX_DESC_TYPE | IXGB_TX_DESC_CMD_RS; 1568 1569 if (adapter->tx_int_delay > 0) 1570 adapter->txd_cmd |= IXGB_TX_DESC_CMD_IDE; 1571 return; 1572} 1573 1574/********************************************************************* 1575 * 1576 * Free all transmit related data structures. 1577 * 1578 **********************************************************************/ 1579static void 1580ixgb_free_transmit_structures(struct adapter * adapter) 1581{ 1582 struct ixgb_buffer *tx_buffer; 1583 int i; 1584 1585 INIT_DEBUGOUT("free_transmit_structures: begin"); 1586 1587 if (adapter->tx_buffer_area != NULL) { 1588 tx_buffer = adapter->tx_buffer_area; 1589 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1590 if (tx_buffer->m_head != NULL) { 1591 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 1592 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 1593 m_freem(tx_buffer->m_head); 1594 } 1595 tx_buffer->m_head = NULL; 1596 } 1597 } 1598 if (adapter->tx_buffer_area != NULL) { 1599 free(adapter->tx_buffer_area, M_DEVBUF); 1600 adapter->tx_buffer_area = NULL; 1601 } 1602 if (adapter->txtag != NULL) { 1603 bus_dma_tag_destroy(adapter->txtag); 1604 adapter->txtag = NULL; 1605 } 1606 return; 1607} 1608 1609/********************************************************************* 1610 * 1611 * The offload context needs to be set when we transfer the first 1612 * packet of a particular protocol (TCP/UDP). We change the 1613 * context only if the protocol type changes. 1614 * 1615 **********************************************************************/ 1616static void 1617ixgb_transmit_checksum_setup(struct adapter * adapter, 1618 struct mbuf * mp, 1619 u_int8_t * txd_popts) 1620{ 1621 struct ixgb_context_desc *TXD; 1622 struct ixgb_buffer *tx_buffer; 1623 int curr_txd; 1624 1625 if (mp->m_pkthdr.csum_flags) { 1626 1627 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1628 *txd_popts = IXGB_TX_DESC_POPTS_TXSM; 1629 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1630 return; 1631 else 1632 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1633 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1634 *txd_popts = IXGB_TX_DESC_POPTS_TXSM; 1635 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1636 return; 1637 else 1638 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1639 } else { 1640 *txd_popts = 0; 1641 return; 1642 } 1643 } else { 1644 *txd_popts = 0; 1645 return; 1646 } 1647 1648 /* 1649 * If we reach this point, the checksum offload context needs to be 1650 * reset. 1651 */ 1652 curr_txd = adapter->next_avail_tx_desc; 1653 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 1654 TXD = (struct ixgb_context_desc *) & adapter->tx_desc_base[curr_txd]; 1655 1656 1657 TXD->tucss = ENET_HEADER_SIZE + sizeof(struct ip); 1658 TXD->tucse = 0; 1659 1660 TXD->mss = 0; 1661 1662 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1663 TXD->tucso = 1664 ENET_HEADER_SIZE + sizeof(struct ip) + 1665 offsetof(struct tcphdr, th_sum); 1666 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1667 TXD->tucso = 1668 ENET_HEADER_SIZE + sizeof(struct ip) + 1669 offsetof(struct udphdr, uh_sum); 1670 } 1671 TXD->cmd_type_len = IXGB_CONTEXT_DESC_CMD_TCP | IXGB_TX_DESC_CMD_RS | IXGB_CONTEXT_DESC_CMD_IDE; 1672 1673 tx_buffer->m_head = NULL; 1674 1675 if (++curr_txd == adapter->num_tx_desc) 1676 curr_txd = 0; 1677 1678 adapter->num_tx_desc_avail--; 1679 adapter->next_avail_tx_desc = curr_txd; 1680 return; 1681} 1682 1683/********************************************************************** 1684 * 1685 * Examine each tx_buffer in the used queue. If the hardware is done 1686 * processing the packet then free associated resources. The 1687 * tx_buffer is put back on the free queue. 1688 * 1689 **********************************************************************/ 1690static void 1691ixgb_clean_transmit_interrupts(struct adapter * adapter) 1692{ 1693 int i, num_avail; 1694 struct ixgb_buffer *tx_buffer; 1695 struct ixgb_tx_desc *tx_desc; 1696 1697 IXGB_LOCK_ASSERT(adapter); 1698 1699 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 1700 return; 1701 1702#ifdef _SV_ 1703 adapter->clean_tx_interrupts++; 1704#endif 1705 num_avail = adapter->num_tx_desc_avail; 1706 i = adapter->oldest_used_tx_desc; 1707 1708 tx_buffer = &adapter->tx_buffer_area[i]; 1709 tx_desc = &adapter->tx_desc_base[i]; 1710 1711 while (tx_desc->status & IXGB_TX_DESC_STATUS_DD) { 1712 1713 tx_desc->status = 0; 1714 num_avail++; 1715 1716 if (tx_buffer->m_head) { 1717 bus_dmamap_sync(adapter->txtag, tx_buffer->map, 1718 BUS_DMASYNC_POSTWRITE); 1719 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 1720 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 1721 m_freem(tx_buffer->m_head); 1722 tx_buffer->m_head = NULL; 1723 } 1724 if (++i == adapter->num_tx_desc) 1725 i = 0; 1726 1727 tx_buffer = &adapter->tx_buffer_area[i]; 1728 tx_desc = &adapter->tx_desc_base[i]; 1729 } 1730 1731 adapter->oldest_used_tx_desc = i; 1732 1733 /* 1734 * If we have enough room, clear IFF_OACTIVE to tell the stack that 1735 * it is OK to send packets. If there are no pending descriptors, 1736 * clear the timeout. Otherwise, if some descriptors have been freed, 1737 * restart the timeout. 1738 */ 1739 if (num_avail > IXGB_TX_CLEANUP_THRESHOLD) { 1740 struct ifnet *ifp = adapter->ifp; 1741 1742 ifp->if_flags &= ~IFF_OACTIVE; 1743 if (num_avail == adapter->num_tx_desc) 1744 ifp->if_timer = 0; 1745 else if (num_avail == adapter->num_tx_desc_avail) 1746 ifp->if_timer = IXGB_TX_TIMEOUT; 1747 } 1748 adapter->num_tx_desc_avail = num_avail; 1749 return; 1750} 1751 1752 1753/********************************************************************* 1754 * 1755 * Get a buffer from system mbuf buffer pool. 1756 * 1757 **********************************************************************/ 1758static int 1759ixgb_get_buf(int i, struct adapter * adapter, 1760 struct mbuf * nmp) 1761{ 1762 register struct mbuf *mp = nmp; 1763 struct ixgb_buffer *rx_buffer; 1764 struct ifnet *ifp; 1765 bus_addr_t paddr; 1766 int error; 1767 1768 ifp = adapter->ifp; 1769 1770 if (mp == NULL) { 1771 1772 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 1773 1774 if (mp == NULL) { 1775 adapter->mbuf_alloc_failed++; 1776 return (ENOBUFS); 1777 } 1778 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1779 } else { 1780 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1781 mp->m_data = mp->m_ext.ext_buf; 1782 mp->m_next = NULL; 1783 } 1784 1785 if (ifp->if_mtu <= ETHERMTU) { 1786 m_adj(mp, ETHER_ALIGN); 1787 } 1788 rx_buffer = &adapter->rx_buffer_area[i]; 1789 1790 /* 1791 * Using memory from the mbuf cluster pool, invoke the bus_dma 1792 * machinery to arrange the memory mapping. 1793 */ 1794 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 1795 mtod(mp, void *), mp->m_len, 1796 ixgb_dmamap_cb, &paddr, 0); 1797 if (error) { 1798 m_free(mp); 1799 return (error); 1800 } 1801 rx_buffer->m_head = mp; 1802 adapter->rx_desc_base[i].buff_addr = htole64(paddr); 1803 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 1804 1805 return (0); 1806} 1807 1808/********************************************************************* 1809 * 1810 * Allocate memory for rx_buffer structures. Since we use one 1811 * rx_buffer per received packet, the maximum number of rx_buffer's 1812 * that we'll need is equal to the number of receive descriptors 1813 * that we've allocated. 1814 * 1815 **********************************************************************/ 1816static int 1817ixgb_allocate_receive_structures(struct adapter * adapter) 1818{ 1819 int i, error; 1820 struct ixgb_buffer *rx_buffer; 1821 1822 if (!(adapter->rx_buffer_area = 1823 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) * 1824 adapter->num_rx_desc, M_DEVBUF, 1825 M_NOWAIT | M_ZERO))) { 1826 printf("ixgb%d: Unable to allocate rx_buffer memory\n", 1827 adapter->unit); 1828 return (ENOMEM); 1829 } 1830 bzero(adapter->rx_buffer_area, 1831 sizeof(struct ixgb_buffer) * adapter->num_rx_desc); 1832 1833 error = bus_dma_tag_create(NULL, /* parent */ 1834 PAGE_SIZE, 0, /* alignment, bounds */ 1835 BUS_SPACE_MAXADDR, /* lowaddr */ 1836 BUS_SPACE_MAXADDR, /* highaddr */ 1837 NULL, NULL, /* filter, filterarg */ 1838 MCLBYTES, /* maxsize */ 1839 1, /* nsegments */ 1840 MCLBYTES, /* maxsegsize */ 1841 BUS_DMA_ALLOCNOW, /* flags */ 1842#if __FreeBSD_version >= 502000 1843 NULL, /* lockfunc */ 1844 NULL, /* lockfuncarg */ 1845#endif 1846 &adapter->rxtag); 1847 if (error != 0) { 1848 printf("ixgb%d: ixgb_allocate_receive_structures: " 1849 "bus_dma_tag_create failed; error %u\n", 1850 adapter->unit, error); 1851 goto fail_0; 1852 } 1853 rx_buffer = adapter->rx_buffer_area; 1854 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 1855 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 1856 &rx_buffer->map); 1857 if (error != 0) { 1858 printf("ixgb%d: ixgb_allocate_receive_structures: " 1859 "bus_dmamap_create failed; error %u\n", 1860 adapter->unit, error); 1861 goto fail_1; 1862 } 1863 } 1864 1865 for (i = 0; i < adapter->num_rx_desc; i++) { 1866 if (ixgb_get_buf(i, adapter, NULL) == ENOBUFS) { 1867 adapter->rx_buffer_area[i].m_head = NULL; 1868 adapter->rx_desc_base[i].buff_addr = 0; 1869 return (ENOBUFS); 1870 } 1871 } 1872 1873 return (0); 1874fail_1: 1875 bus_dma_tag_destroy(adapter->rxtag); 1876fail_0: 1877 adapter->rxtag = NULL; 1878 free(adapter->rx_buffer_area, M_DEVBUF); 1879 adapter->rx_buffer_area = NULL; 1880 return (error); 1881} 1882 1883/********************************************************************* 1884 * 1885 * Allocate and initialize receive structures. 1886 * 1887 **********************************************************************/ 1888static int 1889ixgb_setup_receive_structures(struct adapter * adapter) 1890{ 1891 bzero((void *)adapter->rx_desc_base, 1892 (sizeof(struct ixgb_rx_desc)) * adapter->num_rx_desc); 1893 1894 if (ixgb_allocate_receive_structures(adapter)) 1895 return ENOMEM; 1896 1897 /* Setup our descriptor pointers */ 1898 adapter->next_rx_desc_to_check = 0; 1899 adapter->next_rx_desc_to_use = 0; 1900 return (0); 1901} 1902 1903/********************************************************************* 1904 * 1905 * Enable receive unit. 1906 * 1907 **********************************************************************/ 1908static void 1909ixgb_initialize_receive_unit(struct adapter * adapter) 1910{ 1911 u_int32_t reg_rctl; 1912 u_int32_t reg_rxcsum; 1913 u_int32_t reg_rxdctl; 1914 struct ifnet *ifp; 1915 u_int64_t rdba = adapter->rxdma.dma_paddr; 1916 1917 ifp = adapter->ifp; 1918 1919 /* 1920 * Make sure receives are disabled while setting up the descriptor 1921 * ring 1922 */ 1923 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1924 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl & ~IXGB_RCTL_RXEN); 1925 1926 /* Set the Receive Delay Timer Register */ 1927 IXGB_WRITE_REG(&adapter->hw, RDTR, 1928 adapter->rx_int_delay); 1929 1930 1931 /* Setup the Base and Length of the Rx Descriptor Ring */ 1932 IXGB_WRITE_REG(&adapter->hw, RDBAL, 1933 (rdba & 0x00000000ffffffffULL)); 1934 IXGB_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32)); 1935 IXGB_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 1936 sizeof(struct ixgb_rx_desc)); 1937 1938 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 1939 IXGB_WRITE_REG(&adapter->hw, RDH, 0); 1940 1941 IXGB_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 1942 1943 1944 1945 reg_rxdctl = RXDCTL_WTHRESH_DEFAULT << IXGB_RXDCTL_WTHRESH_SHIFT 1946 | RXDCTL_HTHRESH_DEFAULT << IXGB_RXDCTL_HTHRESH_SHIFT 1947 | RXDCTL_PTHRESH_DEFAULT << IXGB_RXDCTL_PTHRESH_SHIFT; 1948 IXGB_WRITE_REG(&adapter->hw, RXDCTL, reg_rxdctl); 1949 1950 1951 adapter->raidc = 1; 1952 if (adapter->raidc) { 1953 uint32_t raidc; 1954 uint8_t poll_threshold; 1955#define IXGB_RAIDC_POLL_DEFAULT 120 1956 1957 poll_threshold = ((adapter->num_rx_desc - 1) >> 3); 1958 poll_threshold >>= 1; 1959 poll_threshold &= 0x3F; 1960 raidc = IXGB_RAIDC_EN | IXGB_RAIDC_RXT_GATE | 1961 (IXGB_RAIDC_POLL_DEFAULT << IXGB_RAIDC_POLL_SHIFT) | 1962 (adapter->rx_int_delay << IXGB_RAIDC_DELAY_SHIFT) | 1963 poll_threshold; 1964 IXGB_WRITE_REG(&adapter->hw, RAIDC, raidc); 1965 } 1966 /* Enable Receive Checksum Offload for TCP and UDP ? */ 1967 if (ifp->if_capenable & IFCAP_RXCSUM) { 1968 reg_rxcsum = IXGB_READ_REG(&adapter->hw, RXCSUM); 1969 reg_rxcsum |= IXGB_RXCSUM_TUOFL; 1970 IXGB_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 1971 } 1972 /* Setup the Receive Control Register */ 1973 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1974 reg_rctl &= ~(3 << IXGB_RCTL_MO_SHIFT); 1975 reg_rctl |= IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | IXGB_RCTL_SECRC | 1976 IXGB_RCTL_CFF | 1977 (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT); 1978 1979 switch (adapter->rx_buffer_len) { 1980 default: 1981 case IXGB_RXBUFFER_2048: 1982 reg_rctl |= IXGB_RCTL_BSIZE_2048; 1983 break; 1984 case IXGB_RXBUFFER_4096: 1985 reg_rctl |= IXGB_RCTL_BSIZE_4096; 1986 break; 1987 case IXGB_RXBUFFER_8192: 1988 reg_rctl |= IXGB_RCTL_BSIZE_8192; 1989 break; 1990 case IXGB_RXBUFFER_16384: 1991 reg_rctl |= IXGB_RCTL_BSIZE_16384; 1992 break; 1993 } 1994 1995 reg_rctl |= IXGB_RCTL_RXEN; 1996 1997 1998 /* Enable Receives */ 1999 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2000 2001 return; 2002} 2003 2004/********************************************************************* 2005 * 2006 * Free receive related data structures. 2007 * 2008 **********************************************************************/ 2009static void 2010ixgb_free_receive_structures(struct adapter * adapter) 2011{ 2012 struct ixgb_buffer *rx_buffer; 2013 int i; 2014 2015 INIT_DEBUGOUT("free_receive_structures: begin"); 2016 2017 if (adapter->rx_buffer_area != NULL) { 2018 rx_buffer = adapter->rx_buffer_area; 2019 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2020 if (rx_buffer->map != NULL) { 2021 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2022 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2023 } 2024 if (rx_buffer->m_head != NULL) 2025 m_freem(rx_buffer->m_head); 2026 rx_buffer->m_head = NULL; 2027 } 2028 } 2029 if (adapter->rx_buffer_area != NULL) { 2030 free(adapter->rx_buffer_area, M_DEVBUF); 2031 adapter->rx_buffer_area = NULL; 2032 } 2033 if (adapter->rxtag != NULL) { 2034 bus_dma_tag_destroy(adapter->rxtag); 2035 adapter->rxtag = NULL; 2036 } 2037 return; 2038} 2039 2040/********************************************************************* 2041 * 2042 * This routine executes in interrupt context. It replenishes 2043 * the mbufs in the descriptor and sends data which has been 2044 * dma'ed into host memory to upper layer. 2045 * 2046 * We loop at most count times if count is > 0, or until done if 2047 * count < 0. 2048 * 2049 *********************************************************************/ 2050static void 2051ixgb_process_receive_interrupts(struct adapter * adapter, int count) 2052{ 2053 struct ifnet *ifp; 2054 struct mbuf *mp; 2055#if __FreeBSD_version < 500000 2056 struct ether_header *eh; 2057#endif 2058 int eop = 0; 2059 int len; 2060 u_int8_t accept_frame = 0; 2061 int i; 2062 int next_to_use = 0; 2063 int eop_desc; 2064 /* Pointer to the receive descriptor being examined. */ 2065 struct ixgb_rx_desc *current_desc; 2066 2067 IXGB_LOCK_ASSERT(adapter); 2068 2069 ifp = adapter->ifp; 2070 i = adapter->next_rx_desc_to_check; 2071 next_to_use = adapter->next_rx_desc_to_use; 2072 eop_desc = adapter->next_rx_desc_to_check; 2073 current_desc = &adapter->rx_desc_base[i]; 2074 2075 if (!((current_desc->status) & IXGB_RX_DESC_STATUS_DD)) { 2076#ifdef _SV_ 2077 adapter->no_pkts_avail++; 2078#endif 2079 return; 2080 } 2081 while ((current_desc->status & IXGB_RX_DESC_STATUS_DD) && (count != 0)) { 2082 2083 mp = adapter->rx_buffer_area[i].m_head; 2084 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2085 BUS_DMASYNC_POSTREAD); 2086 accept_frame = 1; 2087 if (current_desc->status & IXGB_RX_DESC_STATUS_EOP) { 2088 count--; 2089 eop = 1; 2090 } else { 2091 eop = 0; 2092 } 2093 len = current_desc->length; 2094 2095 if (current_desc->errors & (IXGB_RX_DESC_ERRORS_CE | 2096 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P | 2097 IXGB_RX_DESC_ERRORS_RXE)) { 2098 accept_frame = 0; 2099 } 2100 if (accept_frame) { 2101 2102 /* Assign correct length to the current fragment */ 2103 mp->m_len = len; 2104 2105 if (adapter->fmp == NULL) { 2106 mp->m_pkthdr.len = len; 2107 adapter->fmp = mp; /* Store the first mbuf */ 2108 adapter->lmp = mp; 2109 } else { 2110 /* Chain mbuf's together */ 2111 mp->m_flags &= ~M_PKTHDR; 2112 adapter->lmp->m_next = mp; 2113 adapter->lmp = adapter->lmp->m_next; 2114 adapter->fmp->m_pkthdr.len += len; 2115 } 2116 2117 if (eop) { 2118 eop_desc = i; 2119 adapter->fmp->m_pkthdr.rcvif = ifp; 2120 2121#if __FreeBSD_version < 500000 2122 eh = mtod(adapter->fmp, struct ether_header *); 2123 2124 /* Remove ethernet header from mbuf */ 2125 m_adj(adapter->fmp, sizeof(struct ether_header)); 2126 ixgb_receive_checksum(adapter, current_desc, 2127 adapter->fmp); 2128 2129 if (current_desc->status & IXGB_RX_DESC_STATUS_VP) 2130 VLAN_INPUT_TAG(eh, adapter->fmp, 2131 current_desc->special); 2132 else 2133 ether_input(ifp, eh, adapter->fmp); 2134#else 2135 ixgb_receive_checksum(adapter, current_desc, 2136 adapter->fmp); 2137 if (current_desc->status & IXGB_RX_DESC_STATUS_VP) 2138 VLAN_INPUT_TAG(ifp, adapter->fmp, 2139 current_desc->special, 2140 adapter->fmp = NULL); 2141 2142 if (adapter->fmp != NULL) { 2143 IXGB_UNLOCK(adapter); 2144 (*ifp->if_input) (ifp, adapter->fmp); 2145 IXGB_LOCK(adapter); 2146 } 2147#endif 2148 adapter->fmp = NULL; 2149 adapter->lmp = NULL; 2150 } 2151 adapter->rx_buffer_area[i].m_head = NULL; 2152 } else { 2153 adapter->dropped_pkts++; 2154 if (adapter->fmp != NULL) 2155 m_freem(adapter->fmp); 2156 adapter->fmp = NULL; 2157 adapter->lmp = NULL; 2158 } 2159 2160 /* Zero out the receive descriptors status */ 2161 current_desc->status = 0; 2162 2163 /* Advance our pointers to the next descriptor */ 2164 if (++i == adapter->num_rx_desc) { 2165 i = 0; 2166 current_desc = adapter->rx_desc_base; 2167 } else 2168 current_desc++; 2169 } 2170 adapter->next_rx_desc_to_check = i; 2171 2172 if (--i < 0) 2173 i = (adapter->num_rx_desc - 1); 2174 2175 /* 2176 * 82597EX: Workaround for redundent write back in receive descriptor ring (causes 2177 * memory corruption). Avoid using and re-submitting the most recently received RX 2178 * descriptor back to hardware. 2179 * 2180 * if(Last written back descriptor == EOP bit set descriptor) 2181 * then avoid re-submitting the most recently received RX descriptor 2182 * back to hardware. 2183 * if(Last written back descriptor != EOP bit set descriptor) 2184 * then avoid re-submitting the most recently received RX descriptors 2185 * till last EOP bit set descriptor. 2186 */ 2187 if (eop_desc != i) { 2188 if (++eop_desc == adapter->num_rx_desc) 2189 eop_desc = 0; 2190 i = eop_desc; 2191 } 2192 /* Replenish the descriptors with new mbufs till last EOP bit set descriptor */ 2193 while (next_to_use != i) { 2194 current_desc = &adapter->rx_desc_base[next_to_use]; 2195 if ((current_desc->errors & (IXGB_RX_DESC_ERRORS_CE | 2196 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P | 2197 IXGB_RX_DESC_ERRORS_RXE))) { 2198 mp = adapter->rx_buffer_area[next_to_use].m_head; 2199 ixgb_get_buf(next_to_use, adapter, mp); 2200 } else { 2201 if (ixgb_get_buf(next_to_use, adapter, NULL) == ENOBUFS) 2202 break; 2203 } 2204 /* Advance our pointers to the next descriptor */ 2205 if (++next_to_use == adapter->num_rx_desc) { 2206 next_to_use = 0; 2207 current_desc = adapter->rx_desc_base; 2208 } else 2209 current_desc++; 2210 } 2211 adapter->next_rx_desc_to_use = next_to_use; 2212 if (--next_to_use < 0) 2213 next_to_use = (adapter->num_rx_desc - 1); 2214 /* Advance the IXGB's Receive Queue #0 "Tail Pointer" */ 2215 IXGB_WRITE_REG(&adapter->hw, RDT, next_to_use); 2216 2217 return; 2218} 2219 2220/********************************************************************* 2221 * 2222 * Verify that the hardware indicated that the checksum is valid. 2223 * Inform the stack about the status of checksum so that stack 2224 * doesn't spend time verifying the checksum. 2225 * 2226 *********************************************************************/ 2227static void 2228ixgb_receive_checksum(struct adapter * adapter, 2229 struct ixgb_rx_desc * rx_desc, 2230 struct mbuf * mp) 2231{ 2232 if (rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) { 2233 mp->m_pkthdr.csum_flags = 0; 2234 return; 2235 } 2236 if (rx_desc->status & IXGB_RX_DESC_STATUS_IPCS) { 2237 /* Did it pass? */ 2238 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_IPE)) { 2239 /* IP Checksum Good */ 2240 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2241 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2242 2243 } else { 2244 mp->m_pkthdr.csum_flags = 0; 2245 } 2246 } 2247 if (rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS) { 2248 /* Did it pass? */ 2249 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE)) { 2250 mp->m_pkthdr.csum_flags |= 2251 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2252 mp->m_pkthdr.csum_data = htons(0xffff); 2253 } 2254 } 2255 return; 2256} 2257 2258 2259static void 2260ixgb_enable_vlans(struct adapter * adapter) 2261{ 2262 uint32_t ctrl; 2263 2264 ctrl = IXGB_READ_REG(&adapter->hw, CTRL0); 2265 ctrl |= IXGB_CTRL0_VME; 2266 IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl); 2267 2268 return; 2269} 2270 2271 2272static void 2273ixgb_enable_intr(struct adapter * adapter) 2274{ 2275 IXGB_WRITE_REG(&adapter->hw, IMS, (IXGB_INT_RXT0 | IXGB_INT_TXDW | 2276 IXGB_INT_RXDMT0 | IXGB_INT_LSC | IXGB_INT_RXO)); 2277 return; 2278} 2279 2280static void 2281ixgb_disable_intr(struct adapter * adapter) 2282{ 2283 IXGB_WRITE_REG(&adapter->hw, IMC, ~0); 2284 return; 2285} 2286 2287void 2288ixgb_write_pci_cfg(struct ixgb_hw * hw, 2289 uint32_t reg, 2290 uint16_t * value) 2291{ 2292 pci_write_config(((struct ixgb_osdep *) hw->back)->dev, reg, 2293 *value, 2); 2294} 2295 2296/********************************************************************** 2297 * 2298 * Update the board statistics counters. 2299 * 2300 **********************************************************************/ 2301static void 2302ixgb_update_stats_counters(struct adapter * adapter) 2303{ 2304 struct ifnet *ifp; 2305 2306 adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS); 2307 adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL); 2308 adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH); 2309 adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL); 2310 adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH); 2311 adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL); 2312 adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH); 2313 adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL); 2314 adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH); 2315 adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC); 2316 2317 adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC); 2318 adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC); 2319 adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC); 2320 adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC); 2321 adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC); 2322 adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC); 2323 adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC); 2324 adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL); 2325 adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH); 2326 adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL); 2327 adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH); 2328 adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC); 2329 adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC); 2330 adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC); 2331 adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL); 2332 adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH); 2333 adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL); 2334 adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH); 2335 adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL); 2336 adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH); 2337 adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL); 2338 adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH); 2339 adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C); 2340 adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL); 2341 adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH); 2342 adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL); 2343 adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH); 2344 2345 adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL); 2346 adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH); 2347 adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL); 2348 adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH); 2349 adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL); 2350 adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH); 2351 adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC); 2352 adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC); 2353 adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC); 2354 adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL); 2355 adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH); 2356 adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL); 2357 adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH); 2358 adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL); 2359 adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH); 2360 adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC); 2361 adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC); 2362 adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC); 2363 adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC); 2364 adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC); 2365 adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC); 2366 adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC); 2367 2368 ifp = adapter->ifp; 2369 2370 /* Fill out the OS statistics structure */ 2371 ifp->if_ipackets = adapter->stats.gprcl; 2372 ifp->if_opackets = adapter->stats.gptcl; 2373 ifp->if_ibytes = adapter->stats.gorcl; 2374 ifp->if_obytes = adapter->stats.gotcl; 2375 ifp->if_imcasts = adapter->stats.mprcl; 2376 ifp->if_collisions = 0; 2377 2378 /* Rx Errors */ 2379 ifp->if_ierrors = 2380 adapter->dropped_pkts + 2381 adapter->stats.crcerrs + 2382 adapter->stats.rnbc + 2383 adapter->stats.mpc + 2384 adapter->stats.rlec; 2385 2386 2387} 2388 2389 2390/********************************************************************** 2391 * 2392 * This routine is called only when ixgb_display_debug_stats is enabled. 2393 * This routine provides a way to take a look at important statistics 2394 * maintained by the driver and hardware. 2395 * 2396 **********************************************************************/ 2397static void 2398ixgb_print_hw_stats(struct adapter * adapter) 2399{ 2400 char buf_speed[100], buf_type[100]; 2401 ixgb_bus_speed bus_speed; 2402 ixgb_bus_type bus_type; 2403 int unit = adapter->unit; 2404 2405#ifdef _SV_ 2406 printf("ixgb%d: Packets not Avail = %ld\n", unit, 2407 adapter->no_pkts_avail); 2408 printf("ixgb%d: CleanTxInterrupts = %ld\n", unit, 2409 adapter->clean_tx_interrupts); 2410 printf("ixgb%d: ICR RXDMT0 = %lld\n", unit, 2411 (long long)adapter->sv_stats.icr_rxdmt0); 2412 printf("ixgb%d: ICR RXO = %lld\n", unit, 2413 (long long)adapter->sv_stats.icr_rxo); 2414 printf("ixgb%d: ICR RXT0 = %lld\n", unit, 2415 (long long)adapter->sv_stats.icr_rxt0); 2416 printf("ixgb%d: ICR TXDW = %lld\n", unit, 2417 (long long)adapter->sv_stats.icr_TXDW); 2418#endif /* _SV_ */ 2419 2420 bus_speed = adapter->hw.bus.speed; 2421 bus_type = adapter->hw.bus.type; 2422 sprintf(buf_speed, 2423 bus_speed == ixgb_bus_speed_33 ? "33MHz" : 2424 bus_speed == ixgb_bus_speed_66 ? "66MHz" : 2425 bus_speed == ixgb_bus_speed_100 ? "100MHz" : 2426 bus_speed == ixgb_bus_speed_133 ? "133MHz" : 2427 "UNKNOWN"); 2428 printf("ixgb%d: PCI_Bus_Speed = %s\n", unit, 2429 buf_speed); 2430 2431 sprintf(buf_type, 2432 bus_type == ixgb_bus_type_pci ? "PCI" : 2433 bus_type == ixgb_bus_type_pcix ? "PCI-X" : 2434 "UNKNOWN"); 2435 printf("ixgb%d: PCI_Bus_Type = %s\n", unit, 2436 buf_type); 2437 2438 printf("ixgb%d: Tx Descriptors not Avail1 = %ld\n", unit, 2439 adapter->no_tx_desc_avail1); 2440 printf("ixgb%d: Tx Descriptors not Avail2 = %ld\n", unit, 2441 adapter->no_tx_desc_avail2); 2442 printf("ixgb%d: Std Mbuf Failed = %ld\n", unit, 2443 adapter->mbuf_alloc_failed); 2444 printf("ixgb%d: Std Cluster Failed = %ld\n", unit, 2445 adapter->mbuf_cluster_failed); 2446 2447 printf("ixgb%d: Defer count = %lld\n", unit, 2448 (long long)adapter->stats.dc); 2449 printf("ixgb%d: Missed Packets = %lld\n", unit, 2450 (long long)adapter->stats.mpc); 2451 printf("ixgb%d: Receive No Buffers = %lld\n", unit, 2452 (long long)adapter->stats.rnbc); 2453 printf("ixgb%d: Receive length errors = %lld\n", unit, 2454 (long long)adapter->stats.rlec); 2455 printf("ixgb%d: Crc errors = %lld\n", unit, 2456 (long long)adapter->stats.crcerrs); 2457 printf("ixgb%d: Driver dropped packets = %ld\n", unit, 2458 adapter->dropped_pkts); 2459 2460 printf("ixgb%d: XON Rcvd = %lld\n", unit, 2461 (long long)adapter->stats.xonrxc); 2462 printf("ixgb%d: XON Xmtd = %lld\n", unit, 2463 (long long)adapter->stats.xontxc); 2464 printf("ixgb%d: XOFF Rcvd = %lld\n", unit, 2465 (long long)adapter->stats.xoffrxc); 2466 printf("ixgb%d: XOFF Xmtd = %lld\n", unit, 2467 (long long)adapter->stats.xofftxc); 2468 2469 printf("ixgb%d: Good Packets Rcvd = %lld\n", unit, 2470 (long long)adapter->stats.gprcl); 2471 printf("ixgb%d: Good Packets Xmtd = %lld\n", unit, 2472 (long long)adapter->stats.gptcl); 2473 2474 printf("ixgb%d: Jumbo frames recvd = %lld\n", unit, 2475 (long long)adapter->stats.jprcl); 2476 printf("ixgb%d: Jumbo frames Xmtd = %lld\n", unit, 2477 (long long)adapter->stats.jptcl); 2478 2479 return; 2480 2481} 2482 2483static int 2484ixgb_sysctl_stats(SYSCTL_HANDLER_ARGS) 2485{ 2486 int error; 2487 int result; 2488 struct adapter *adapter; 2489 2490 result = -1; 2491 error = sysctl_handle_int(oidp, &result, 0, req); 2492 2493 if (error || !req->newptr) 2494 return (error); 2495 2496 if (result == 1) { 2497 adapter = (struct adapter *) arg1; 2498 ixgb_print_hw_stats(adapter); 2499 } 2500 return error; 2501} 2502