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