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