if_ixgb.c revision 133704
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 133704 2004-08-14 00:17:04Z rwatson $*/ 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 IFF_NEEDSGIANT; 1324 ifp->if_ioctl = ixgb_ioctl; 1325 ifp->if_start = ixgb_start; 1326 ifp->if_watchdog = ixgb_watchdog; 1327 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1328 1329#if __FreeBSD_version < 500000 1330 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1331#else 1332 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1333#endif 1334 1335 ifp->if_capabilities = IFCAP_HWCSUM; 1336 ifp->if_capenable = ifp->if_capabilities; 1337 1338 /* 1339 * Tell the upper layer(s) we support long frames. 1340 */ 1341 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1342 1343#if __FreeBSD_version >= 500000 1344 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1345#endif 1346 /* 1347 * Specify the media types supported by this adapter and register 1348 * callbacks to update media and link information 1349 */ 1350 ifmedia_init(&adapter->media, IFM_IMASK, ixgb_media_change, 1351 ixgb_media_status); 1352 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1353 0, NULL); 1354 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1355 0, NULL); 1356 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1357 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1358 1359 return; 1360} 1361 1362/******************************************************************** 1363 * Manage DMA'able memory. 1364 *******************************************************************/ 1365static void 1366ixgb_dmamap_cb(void *arg, bus_dma_segment_t * segs, int nseg, int error) 1367{ 1368 if (error) 1369 return; 1370 *(bus_addr_t *) arg = segs->ds_addr; 1371 return; 1372} 1373 1374static int 1375ixgb_dma_malloc(struct adapter * adapter, bus_size_t size, 1376 struct ixgb_dma_alloc * dma, int mapflags) 1377{ 1378 int r; 1379 1380 r = bus_dma_tag_create(NULL, /* parent */ 1381 PAGE_SIZE, 0, /* alignment, bounds */ 1382 BUS_SPACE_MAXADDR, /* lowaddr */ 1383 BUS_SPACE_MAXADDR, /* highaddr */ 1384 NULL, NULL, /* filter, filterarg */ 1385 size, /* maxsize */ 1386 1, /* nsegments */ 1387 size, /* maxsegsize */ 1388 BUS_DMA_ALLOCNOW, /* flags */ 1389#if __FreeBSD_version >= 502000 1390 NULL, /* lockfunc */ 1391 NULL, /* lockfuncarg */ 1392#endif 1393 &dma->dma_tag); 1394 if (r != 0) { 1395 printf("ixgb%d: ixgb_dma_malloc: bus_dma_tag_create failed; " 1396 "error %u\n", adapter->unit, r); 1397 goto fail_0; 1398 } 1399 r = bus_dmamap_create(dma->dma_tag, BUS_DMA_NOWAIT, &dma->dma_map); 1400 if (r != 0) { 1401 printf("ixgb%d: ixgb_dma_malloc: bus_dmamap_create failed; " 1402 "error %u\n", adapter->unit, r); 1403 goto fail_1; 1404 } 1405 r = bus_dmamem_alloc(dma->dma_tag, (void **)&dma->dma_vaddr, 1406 BUS_DMA_NOWAIT, &dma->dma_map); 1407 if (r != 0) { 1408 printf("ixgb%d: ixgb_dma_malloc: bus_dmamem_alloc failed; " 1409 "error %u\n", adapter->unit, r); 1410 goto fail_2; 1411 } 1412 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 1413 size, 1414 ixgb_dmamap_cb, 1415 &dma->dma_paddr, 1416 mapflags | BUS_DMA_NOWAIT); 1417 if (r != 0) { 1418 printf("ixgb%d: ixgb_dma_malloc: bus_dmamap_load failed; " 1419 "error %u\n", adapter->unit, r); 1420 goto fail_3; 1421 } 1422 dma->dma_size = size; 1423 return (0); 1424fail_3: 1425 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 1426fail_2: 1427 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1428fail_1: 1429 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 1430 bus_dma_tag_destroy(dma->dma_tag); 1431fail_0: 1432 dma->dma_map = NULL; 1433 dma->dma_tag = NULL; 1434 return (r); 1435} 1436 1437 1438 1439static void 1440ixgb_dma_free(struct adapter * adapter, struct ixgb_dma_alloc * dma) 1441{ 1442 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 1443 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1444 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 1445 bus_dma_tag_destroy(dma->dma_tag); 1446} 1447 1448/********************************************************************* 1449 * 1450 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1451 * the information needed to transmit a packet on the wire. 1452 * 1453 **********************************************************************/ 1454static int 1455ixgb_allocate_transmit_structures(struct adapter * adapter) 1456{ 1457 if (!(adapter->tx_buffer_area = 1458 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) * 1459 adapter->num_tx_desc, M_DEVBUF, 1460 M_NOWAIT | M_ZERO))) { 1461 printf("ixgb%d: Unable to allocate tx_buffer memory\n", 1462 adapter->unit); 1463 return ENOMEM; 1464 } 1465 bzero(adapter->tx_buffer_area, 1466 sizeof(struct ixgb_buffer) * adapter->num_tx_desc); 1467 1468 return 0; 1469} 1470 1471/********************************************************************* 1472 * 1473 * Allocate and initialize transmit structures. 1474 * 1475 **********************************************************************/ 1476static int 1477ixgb_setup_transmit_structures(struct adapter * adapter) 1478{ 1479 /* 1480 * Setup DMA descriptor areas. 1481 */ 1482 if (bus_dma_tag_create(NULL, /* parent */ 1483 PAGE_SIZE, 0, /* alignment, bounds */ 1484 BUS_SPACE_MAXADDR, /* lowaddr */ 1485 BUS_SPACE_MAXADDR, /* highaddr */ 1486 NULL, NULL, /* filter, filterarg */ 1487 MCLBYTES * IXGB_MAX_SCATTER, /* maxsize */ 1488 IXGB_MAX_SCATTER, /* nsegments */ 1489 MCLBYTES, /* maxsegsize */ 1490 BUS_DMA_ALLOCNOW, /* flags */ 1491#if __FreeBSD_version >= 502000 1492 NULL, /* lockfunc */ 1493 NULL, /* lockfuncarg */ 1494#endif 1495 &adapter->txtag)) { 1496 printf("ixgb%d: Unable to allocate TX DMA tag\n", adapter->unit); 1497 return (ENOMEM); 1498 } 1499 if (ixgb_allocate_transmit_structures(adapter)) 1500 return ENOMEM; 1501 1502 bzero((void *)adapter->tx_desc_base, 1503 (sizeof(struct ixgb_tx_desc)) * adapter->num_tx_desc); 1504 1505 adapter->next_avail_tx_desc = 0; 1506 adapter->oldest_used_tx_desc = 0; 1507 1508 /* Set number of descriptors available */ 1509 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1510 1511 /* Set checksum context */ 1512 adapter->active_checksum_context = OFFLOAD_NONE; 1513 1514 return 0; 1515} 1516 1517/********************************************************************* 1518 * 1519 * Enable transmit unit. 1520 * 1521 **********************************************************************/ 1522static void 1523ixgb_initialize_transmit_unit(struct adapter * adapter) 1524{ 1525 u_int32_t reg_tctl; 1526 u_int64_t tdba = vtophys((vm_offset_t) adapter->tx_desc_base); 1527 1528 /* Setup the Base and Length of the Tx Descriptor Ring */ 1529 IXGB_WRITE_REG(&adapter->hw, TDBAL, 1530 (tdba & 0x00000000ffffffffULL)); 1531 IXGB_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32)); 1532 IXGB_WRITE_REG(&adapter->hw, TDLEN, 1533 adapter->num_tx_desc * 1534 sizeof(struct ixgb_tx_desc)); 1535 1536 /* Setup the HW Tx Head and Tail descriptor pointers */ 1537 IXGB_WRITE_REG(&adapter->hw, TDH, 0); 1538 IXGB_WRITE_REG(&adapter->hw, TDT, 0); 1539 1540 1541 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1542 IXGB_READ_REG(&adapter->hw, TDBAL), 1543 IXGB_READ_REG(&adapter->hw, TDLEN)); 1544 1545 IXGB_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1546 1547 1548 /* Program the Transmit Control Register */ 1549 reg_tctl = IXGB_READ_REG(&adapter->hw, TCTL); 1550 reg_tctl = IXGB_TCTL_TCE | IXGB_TCTL_TXEN | IXGB_TCTL_TPDE; 1551 IXGB_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1552 1553 /* Setup Transmit Descriptor Settings for this adapter */ 1554 adapter->txd_cmd = IXGB_TX_DESC_TYPE | IXGB_TX_DESC_CMD_RS; 1555 1556 if (adapter->tx_int_delay > 0) 1557 adapter->txd_cmd |= IXGB_TX_DESC_CMD_IDE; 1558 return; 1559} 1560 1561/********************************************************************* 1562 * 1563 * Free all transmit related data structures. 1564 * 1565 **********************************************************************/ 1566static void 1567ixgb_free_transmit_structures(struct adapter * adapter) 1568{ 1569 struct ixgb_buffer *tx_buffer; 1570 int i; 1571 1572 INIT_DEBUGOUT("free_transmit_structures: begin"); 1573 1574 if (adapter->tx_buffer_area != NULL) { 1575 tx_buffer = adapter->tx_buffer_area; 1576 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1577 if (tx_buffer->m_head != NULL) { 1578 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 1579 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 1580 m_freem(tx_buffer->m_head); 1581 } 1582 tx_buffer->m_head = NULL; 1583 } 1584 } 1585 if (adapter->tx_buffer_area != NULL) { 1586 free(adapter->tx_buffer_area, M_DEVBUF); 1587 adapter->tx_buffer_area = NULL; 1588 } 1589 if (adapter->txtag != NULL) { 1590 bus_dma_tag_destroy(adapter->txtag); 1591 adapter->txtag = NULL; 1592 } 1593 return; 1594} 1595 1596/********************************************************************* 1597 * 1598 * The offload context needs to be set when we transfer the first 1599 * packet of a particular protocol (TCP/UDP). We change the 1600 * context only if the protocol type changes. 1601 * 1602 **********************************************************************/ 1603static void 1604ixgb_transmit_checksum_setup(struct adapter * adapter, 1605 struct mbuf * mp, 1606 u_int8_t * txd_popts) 1607{ 1608 struct ixgb_context_desc *TXD; 1609 struct ixgb_buffer *tx_buffer; 1610 int curr_txd; 1611 1612 if (mp->m_pkthdr.csum_flags) { 1613 1614 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1615 *txd_popts = IXGB_TX_DESC_POPTS_TXSM; 1616 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1617 return; 1618 else 1619 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1620 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1621 *txd_popts = IXGB_TX_DESC_POPTS_TXSM; 1622 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1623 return; 1624 else 1625 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1626 } else { 1627 *txd_popts = 0; 1628 return; 1629 } 1630 } else { 1631 *txd_popts = 0; 1632 return; 1633 } 1634 1635 /* 1636 * If we reach this point, the checksum offload context needs to be 1637 * reset. 1638 */ 1639 curr_txd = adapter->next_avail_tx_desc; 1640 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 1641 TXD = (struct ixgb_context_desc *) & adapter->tx_desc_base[curr_txd]; 1642 1643 1644 TXD->tucss = ENET_HEADER_SIZE + sizeof(struct ip); 1645 TXD->tucse = 0; 1646 1647 TXD->mss = 0; 1648 1649 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1650 TXD->tucso = 1651 ENET_HEADER_SIZE + sizeof(struct ip) + 1652 offsetof(struct tcphdr, th_sum); 1653 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1654 TXD->tucso = 1655 ENET_HEADER_SIZE + sizeof(struct ip) + 1656 offsetof(struct udphdr, uh_sum); 1657 } 1658 TXD->cmd_type_len = IXGB_CONTEXT_DESC_CMD_TCP | IXGB_TX_DESC_CMD_RS | IXGB_CONTEXT_DESC_CMD_IDE; 1659 1660 tx_buffer->m_head = NULL; 1661 1662 if (++curr_txd == adapter->num_tx_desc) 1663 curr_txd = 0; 1664 1665 adapter->num_tx_desc_avail--; 1666 adapter->next_avail_tx_desc = curr_txd; 1667 return; 1668} 1669 1670/********************************************************************** 1671 * 1672 * Examine each tx_buffer in the used queue. If the hardware is done 1673 * processing the packet then free associated resources. The 1674 * tx_buffer is put back on the free queue. 1675 * 1676 **********************************************************************/ 1677static void 1678ixgb_clean_transmit_interrupts(struct adapter * adapter) 1679{ 1680 int s; 1681 int i, num_avail; 1682 struct ixgb_buffer *tx_buffer; 1683 struct ixgb_tx_desc *tx_desc; 1684 1685 1686 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 1687 return; 1688 1689 s = splimp(); 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 splx(s); 1738 return; 1739} 1740 1741 1742/********************************************************************* 1743 * 1744 * Get a buffer from system mbuf buffer pool. 1745 * 1746 **********************************************************************/ 1747static int 1748ixgb_get_buf(int i, struct adapter * adapter, 1749 struct mbuf * nmp) 1750{ 1751 register struct mbuf *mp = nmp; 1752 struct ixgb_buffer *rx_buffer; 1753 struct ifnet *ifp; 1754 bus_addr_t paddr; 1755 int error; 1756 1757 ifp = &adapter->interface_data.ac_if; 1758 1759 if (mp == NULL) { 1760 1761 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 1762 1763 if (mp == NULL) { 1764 adapter->mbuf_alloc_failed++; 1765 return (ENOBUFS); 1766 } 1767 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1768 } else { 1769 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1770 mp->m_data = mp->m_ext.ext_buf; 1771 mp->m_next = NULL; 1772 } 1773 1774 if (ifp->if_mtu <= ETHERMTU) { 1775 m_adj(mp, ETHER_ALIGN); 1776 } 1777 rx_buffer = &adapter->rx_buffer_area[i]; 1778 1779 /* 1780 * Using memory from the mbuf cluster pool, invoke the bus_dma 1781 * machinery to arrange the memory mapping. 1782 */ 1783 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 1784 mtod(mp, void *), mp->m_len, 1785 ixgb_dmamap_cb, &paddr, 0); 1786 if (error) { 1787 m_free(mp); 1788 return (error); 1789 } 1790 rx_buffer->m_head = mp; 1791 adapter->rx_desc_base[i].buff_addr = htole64(paddr); 1792 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 1793 1794 return (0); 1795} 1796 1797/********************************************************************* 1798 * 1799 * Allocate memory for rx_buffer structures. Since we use one 1800 * rx_buffer per received packet, the maximum number of rx_buffer's 1801 * that we'll need is equal to the number of receive descriptors 1802 * that we've allocated. 1803 * 1804 **********************************************************************/ 1805static int 1806ixgb_allocate_receive_structures(struct adapter * adapter) 1807{ 1808 int i, error; 1809 struct ixgb_buffer *rx_buffer; 1810 1811 if (!(adapter->rx_buffer_area = 1812 (struct ixgb_buffer *) malloc(sizeof(struct ixgb_buffer) * 1813 adapter->num_rx_desc, M_DEVBUF, 1814 M_NOWAIT | M_ZERO))) { 1815 printf("ixgb%d: Unable to allocate rx_buffer memory\n", 1816 adapter->unit); 1817 return (ENOMEM); 1818 } 1819 bzero(adapter->rx_buffer_area, 1820 sizeof(struct ixgb_buffer) * adapter->num_rx_desc); 1821 1822 error = bus_dma_tag_create(NULL, /* parent */ 1823 PAGE_SIZE, 0, /* alignment, bounds */ 1824 BUS_SPACE_MAXADDR, /* lowaddr */ 1825 BUS_SPACE_MAXADDR, /* highaddr */ 1826 NULL, NULL, /* filter, filterarg */ 1827 MCLBYTES, /* maxsize */ 1828 1, /* nsegments */ 1829 MCLBYTES, /* maxsegsize */ 1830 BUS_DMA_ALLOCNOW, /* flags */ 1831#if __FreeBSD_version >= 502000 1832 NULL, /* lockfunc */ 1833 NULL, /* lockfuncarg */ 1834#endif 1835 &adapter->rxtag); 1836 if (error != 0) { 1837 printf("ixgb%d: ixgb_allocate_receive_structures: " 1838 "bus_dma_tag_create failed; error %u\n", 1839 adapter->unit, error); 1840 goto fail_0; 1841 } 1842 rx_buffer = adapter->rx_buffer_area; 1843 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 1844 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 1845 &rx_buffer->map); 1846 if (error != 0) { 1847 printf("ixgb%d: ixgb_allocate_receive_structures: " 1848 "bus_dmamap_create failed; error %u\n", 1849 adapter->unit, error); 1850 goto fail_1; 1851 } 1852 } 1853 1854 for (i = 0; i < adapter->num_rx_desc; i++) { 1855 if (ixgb_get_buf(i, adapter, NULL) == ENOBUFS) { 1856 adapter->rx_buffer_area[i].m_head = NULL; 1857 adapter->rx_desc_base[i].buff_addr = 0; 1858 return (ENOBUFS); 1859 } 1860 } 1861 1862 return (0); 1863fail_1: 1864 bus_dma_tag_destroy(adapter->rxtag); 1865fail_0: 1866 adapter->rxtag = NULL; 1867 free(adapter->rx_buffer_area, M_DEVBUF); 1868 adapter->rx_buffer_area = NULL; 1869 return (error); 1870} 1871 1872/********************************************************************* 1873 * 1874 * Allocate and initialize receive structures. 1875 * 1876 **********************************************************************/ 1877static int 1878ixgb_setup_receive_structures(struct adapter * adapter) 1879{ 1880 bzero((void *)adapter->rx_desc_base, 1881 (sizeof(struct ixgb_rx_desc)) * adapter->num_rx_desc); 1882 1883 if (ixgb_allocate_receive_structures(adapter)) 1884 return ENOMEM; 1885 1886 /* Setup our descriptor pointers */ 1887 adapter->next_rx_desc_to_check = 0; 1888 adapter->next_rx_desc_to_use = 0; 1889 return (0); 1890} 1891 1892/********************************************************************* 1893 * 1894 * Enable receive unit. 1895 * 1896 **********************************************************************/ 1897static void 1898ixgb_initialize_receive_unit(struct adapter * adapter) 1899{ 1900 u_int32_t reg_rctl; 1901 u_int32_t reg_rxcsum; 1902 u_int32_t reg_rxdctl; 1903 struct ifnet *ifp; 1904 u_int64_t rdba = vtophys((vm_offset_t) adapter->rx_desc_base); 1905 1906 ifp = &adapter->interface_data.ac_if; 1907 1908 /* 1909 * Make sure receives are disabled while setting up the descriptor 1910 * ring 1911 */ 1912 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1913 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl & ~IXGB_RCTL_RXEN); 1914 1915 /* Set the Receive Delay Timer Register */ 1916 IXGB_WRITE_REG(&adapter->hw, RDTR, 1917 adapter->rx_int_delay); 1918 1919 1920 /* Setup the Base and Length of the Rx Descriptor Ring */ 1921 IXGB_WRITE_REG(&adapter->hw, RDBAL, 1922 (rdba & 0x00000000ffffffffULL)); 1923 IXGB_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32)); 1924 IXGB_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 1925 sizeof(struct ixgb_rx_desc)); 1926 1927 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 1928 IXGB_WRITE_REG(&adapter->hw, RDH, 0); 1929 1930 IXGB_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 1931 1932 1933 1934 reg_rxdctl = RXDCTL_WTHRESH_DEFAULT << IXGB_RXDCTL_WTHRESH_SHIFT 1935 | RXDCTL_HTHRESH_DEFAULT << IXGB_RXDCTL_HTHRESH_SHIFT 1936 | RXDCTL_PTHRESH_DEFAULT << IXGB_RXDCTL_PTHRESH_SHIFT; 1937 IXGB_WRITE_REG(&adapter->hw, RXDCTL, reg_rxdctl); 1938 1939 1940 adapter->raidc = 1; 1941 if (adapter->raidc) { 1942 uint32_t raidc; 1943 uint8_t poll_threshold; 1944#define IXGB_RAIDC_POLL_DEFAULT 120 1945 1946 poll_threshold = ((adapter->num_rx_desc - 1) >> 3); 1947 poll_threshold >>= 1; 1948 poll_threshold &= 0x3F; 1949 raidc = IXGB_RAIDC_EN | IXGB_RAIDC_RXT_GATE | 1950 (IXGB_RAIDC_POLL_DEFAULT << IXGB_RAIDC_POLL_SHIFT) | 1951 (adapter->rx_int_delay << IXGB_RAIDC_DELAY_SHIFT) | 1952 poll_threshold; 1953 IXGB_WRITE_REG(&adapter->hw, RAIDC, raidc); 1954 } 1955 /* Enable Receive Checksum Offload for TCP and UDP ? */ 1956 if (ifp->if_capenable & IFCAP_RXCSUM) { 1957 reg_rxcsum = IXGB_READ_REG(&adapter->hw, RXCSUM); 1958 reg_rxcsum |= IXGB_RXCSUM_TUOFL; 1959 IXGB_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 1960 } 1961 /* Setup the Receive Control Register */ 1962 reg_rctl = IXGB_READ_REG(&adapter->hw, RCTL); 1963 reg_rctl &= ~(3 << IXGB_RCTL_MO_SHIFT); 1964 reg_rctl |= IXGB_RCTL_BAM | IXGB_RCTL_RDMTS_1_2 | IXGB_RCTL_SECRC | 1965 IXGB_RCTL_CFF | 1966 (adapter->hw.mc_filter_type << IXGB_RCTL_MO_SHIFT); 1967 1968 switch (adapter->rx_buffer_len) { 1969 default: 1970 case IXGB_RXBUFFER_2048: 1971 reg_rctl |= IXGB_RCTL_BSIZE_2048; 1972 break; 1973 case IXGB_RXBUFFER_4096: 1974 reg_rctl |= IXGB_RCTL_BSIZE_4096; 1975 break; 1976 case IXGB_RXBUFFER_8192: 1977 reg_rctl |= IXGB_RCTL_BSIZE_8192; 1978 break; 1979 case IXGB_RXBUFFER_16384: 1980 reg_rctl |= IXGB_RCTL_BSIZE_16384; 1981 break; 1982 } 1983 1984 reg_rctl |= IXGB_RCTL_RXEN; 1985 1986 1987 /* Enable Receives */ 1988 IXGB_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1989 1990 return; 1991} 1992 1993/********************************************************************* 1994 * 1995 * Free receive related data structures. 1996 * 1997 **********************************************************************/ 1998static void 1999ixgb_free_receive_structures(struct adapter * adapter) 2000{ 2001 struct ixgb_buffer *rx_buffer; 2002 int i; 2003 2004 INIT_DEBUGOUT("free_receive_structures: begin"); 2005 2006 if (adapter->rx_buffer_area != NULL) { 2007 rx_buffer = adapter->rx_buffer_area; 2008 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2009 if (rx_buffer->map != NULL) { 2010 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2011 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2012 } 2013 if (rx_buffer->m_head != NULL) 2014 m_freem(rx_buffer->m_head); 2015 rx_buffer->m_head = NULL; 2016 } 2017 } 2018 if (adapter->rx_buffer_area != NULL) { 2019 free(adapter->rx_buffer_area, M_DEVBUF); 2020 adapter->rx_buffer_area = NULL; 2021 } 2022 if (adapter->rxtag != NULL) { 2023 bus_dma_tag_destroy(adapter->rxtag); 2024 adapter->rxtag = NULL; 2025 } 2026 return; 2027} 2028 2029/********************************************************************* 2030 * 2031 * This routine executes in interrupt context. It replenishes 2032 * the mbufs in the descriptor and sends data which has been 2033 * dma'ed into host memory to upper layer. 2034 * 2035 * We loop at most count times if count is > 0, or until done if 2036 * count < 0. 2037 * 2038 *********************************************************************/ 2039static void 2040ixgb_process_receive_interrupts(struct adapter * adapter, int count) 2041{ 2042 struct ifnet *ifp; 2043 struct mbuf *mp; 2044#if __FreeBSD_version < 500000 2045 struct ether_header *eh; 2046#endif 2047 int eop = 0; 2048 int len; 2049 u_int8_t accept_frame = 0; 2050 int i; 2051 int next_to_use = 0; 2052 int eop_desc; 2053 /* Pointer to the receive descriptor being examined. */ 2054 struct ixgb_rx_desc *current_desc; 2055 2056 ifp = &adapter->interface_data.ac_if; 2057 i = adapter->next_rx_desc_to_check; 2058 next_to_use = adapter->next_rx_desc_to_use; 2059 eop_desc = adapter->next_rx_desc_to_check; 2060 current_desc = &adapter->rx_desc_base[i]; 2061 2062 if (!((current_desc->status) & IXGB_RX_DESC_STATUS_DD)) { 2063#ifdef _SV_ 2064 adapter->no_pkts_avail++; 2065#endif 2066 return; 2067 } 2068 while ((current_desc->status & IXGB_RX_DESC_STATUS_DD) && (count != 0)) { 2069 2070 mp = adapter->rx_buffer_area[i].m_head; 2071 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2072 BUS_DMASYNC_POSTREAD); 2073 accept_frame = 1; 2074 if (current_desc->status & IXGB_RX_DESC_STATUS_EOP) { 2075 count--; 2076 eop = 1; 2077 } else { 2078 eop = 0; 2079 } 2080 len = current_desc->length; 2081 2082 if (current_desc->errors & (IXGB_RX_DESC_ERRORS_CE | 2083 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P | 2084 IXGB_RX_DESC_ERRORS_RXE)) { 2085 accept_frame = 0; 2086 } 2087 if (accept_frame) { 2088 2089 /* Assign correct length to the current fragment */ 2090 mp->m_len = len; 2091 2092 if (adapter->fmp == NULL) { 2093 mp->m_pkthdr.len = len; 2094 adapter->fmp = mp; /* Store the first mbuf */ 2095 adapter->lmp = mp; 2096 } else { 2097 /* Chain mbuf's together */ 2098 mp->m_flags &= ~M_PKTHDR; 2099 adapter->lmp->m_next = mp; 2100 adapter->lmp = adapter->lmp->m_next; 2101 adapter->fmp->m_pkthdr.len += len; 2102 } 2103 2104 if (eop) { 2105 eop_desc = i; 2106 adapter->fmp->m_pkthdr.rcvif = ifp; 2107 2108#if __FreeBSD_version < 500000 2109 eh = mtod(adapter->fmp, struct ether_header *); 2110 2111 /* Remove ethernet header from mbuf */ 2112 m_adj(adapter->fmp, sizeof(struct ether_header)); 2113 ixgb_receive_checksum(adapter, current_desc, 2114 adapter->fmp); 2115 2116 if (current_desc->status & IXGB_RX_DESC_STATUS_VP) 2117 VLAN_INPUT_TAG(eh, adapter->fmp, 2118 current_desc->special); 2119 else 2120 ether_input(ifp, eh, adapter->fmp); 2121#else 2122 ixgb_receive_checksum(adapter, current_desc, 2123 adapter->fmp); 2124 if (current_desc->status & IXGB_RX_DESC_STATUS_VP) 2125 VLAN_INPUT_TAG(ifp, adapter->fmp, 2126 current_desc->special, 2127 adapter->fmp = NULL); 2128 2129 if (adapter->fmp != NULL) 2130 (*ifp->if_input) (ifp, adapter->fmp); 2131#endif 2132 adapter->fmp = NULL; 2133 adapter->lmp = NULL; 2134 } 2135 adapter->rx_buffer_area[i].m_head = NULL; 2136 } else { 2137 adapter->dropped_pkts++; 2138 if (adapter->fmp != NULL) 2139 m_freem(adapter->fmp); 2140 adapter->fmp = NULL; 2141 adapter->lmp = NULL; 2142 } 2143 2144 /* Zero out the receive descriptors status */ 2145 current_desc->status = 0; 2146 2147 /* Advance our pointers to the next descriptor */ 2148 if (++i == adapter->num_rx_desc) { 2149 i = 0; 2150 current_desc = adapter->rx_desc_base; 2151 } else 2152 current_desc++; 2153 } 2154 adapter->next_rx_desc_to_check = i; 2155 2156 if (--i < 0) 2157 i = (adapter->num_rx_desc - 1); 2158 2159 /* 2160 * 82597EX: Workaround for redundent write back in receive descriptor ring (causes 2161 * memory corruption). Avoid using and re-submitting the most recently received RX 2162 * descriptor back to hardware. 2163 * 2164 * if(Last written back descriptor == EOP bit set descriptor) 2165 * then avoid re-submitting the most recently received RX descriptor 2166 * back to hardware. 2167 * if(Last written back descriptor != EOP bit set descriptor) 2168 * then avoid re-submitting the most recently received RX descriptors 2169 * till last EOP bit set descriptor. 2170 */ 2171 if (eop_desc != i) { 2172 if (++eop_desc == adapter->num_rx_desc) 2173 eop_desc = 0; 2174 i = eop_desc; 2175 } 2176 /* Replenish the descriptors with new mbufs till last EOP bit set descriptor */ 2177 while (next_to_use != i) { 2178 current_desc = &adapter->rx_desc_base[next_to_use]; 2179 if ((current_desc->errors & (IXGB_RX_DESC_ERRORS_CE | 2180 IXGB_RX_DESC_ERRORS_SE | IXGB_RX_DESC_ERRORS_P | 2181 IXGB_RX_DESC_ERRORS_RXE))) { 2182 mp = adapter->rx_buffer_area[next_to_use].m_head; 2183 ixgb_get_buf(next_to_use, adapter, mp); 2184 } else { 2185 if (ixgb_get_buf(next_to_use, adapter, NULL) == ENOBUFS) 2186 break; 2187 } 2188 /* Advance our pointers to the next descriptor */ 2189 if (++next_to_use == adapter->num_rx_desc) { 2190 next_to_use = 0; 2191 current_desc = adapter->rx_desc_base; 2192 } else 2193 current_desc++; 2194 } 2195 adapter->next_rx_desc_to_use = next_to_use; 2196 if (--next_to_use < 0) 2197 next_to_use = (adapter->num_rx_desc - 1); 2198 /* Advance the IXGB's Receive Queue #0 "Tail Pointer" */ 2199 IXGB_WRITE_REG(&adapter->hw, RDT, next_to_use); 2200 2201 return; 2202} 2203 2204/********************************************************************* 2205 * 2206 * Verify that the hardware indicated that the checksum is valid. 2207 * Inform the stack about the status of checksum so that stack 2208 * doesn't spend time verifying the checksum. 2209 * 2210 *********************************************************************/ 2211static void 2212ixgb_receive_checksum(struct adapter * adapter, 2213 struct ixgb_rx_desc * rx_desc, 2214 struct mbuf * mp) 2215{ 2216 if (rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) { 2217 mp->m_pkthdr.csum_flags = 0; 2218 return; 2219 } 2220 if (rx_desc->status & IXGB_RX_DESC_STATUS_IPCS) { 2221 /* Did it pass? */ 2222 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_IPE)) { 2223 /* IP Checksum Good */ 2224 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2225 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2226 2227 } else { 2228 mp->m_pkthdr.csum_flags = 0; 2229 } 2230 } 2231 if (rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS) { 2232 /* Did it pass? */ 2233 if (!(rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE)) { 2234 mp->m_pkthdr.csum_flags |= 2235 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2236 mp->m_pkthdr.csum_data = htons(0xffff); 2237 } 2238 } 2239 return; 2240} 2241 2242 2243static void 2244ixgb_enable_vlans(struct adapter * adapter) 2245{ 2246 uint32_t ctrl; 2247 2248 ctrl = IXGB_READ_REG(&adapter->hw, CTRL0); 2249 ctrl |= IXGB_CTRL0_VME; 2250 IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl); 2251 2252 return; 2253} 2254 2255 2256static void 2257ixgb_enable_intr(struct adapter * adapter) 2258{ 2259 IXGB_WRITE_REG(&adapter->hw, IMS, (IXGB_INT_RXT0 | IXGB_INT_TXDW | 2260 IXGB_INT_RXDMT0 | IXGB_INT_LSC | IXGB_INT_RXO)); 2261 return; 2262} 2263 2264static void 2265ixgb_disable_intr(struct adapter * adapter) 2266{ 2267 IXGB_WRITE_REG(&adapter->hw, IMC, ~0); 2268 return; 2269} 2270 2271void 2272ixgb_write_pci_cfg(struct ixgb_hw * hw, 2273 uint32_t reg, 2274 uint16_t * value) 2275{ 2276 pci_write_config(((struct ixgb_osdep *) hw->back)->dev, reg, 2277 *value, 2); 2278} 2279 2280/********************************************************************** 2281 * 2282 * Update the board statistics counters. 2283 * 2284 **********************************************************************/ 2285static void 2286ixgb_update_stats_counters(struct adapter * adapter) 2287{ 2288 struct ifnet *ifp; 2289 2290 adapter->stats.crcerrs += IXGB_READ_REG(&adapter->hw, CRCERRS); 2291 adapter->stats.gprcl += IXGB_READ_REG(&adapter->hw, GPRCL); 2292 adapter->stats.gprch += IXGB_READ_REG(&adapter->hw, GPRCH); 2293 adapter->stats.gorcl += IXGB_READ_REG(&adapter->hw, GORCL); 2294 adapter->stats.gorch += IXGB_READ_REG(&adapter->hw, GORCH); 2295 adapter->stats.bprcl += IXGB_READ_REG(&adapter->hw, BPRCL); 2296 adapter->stats.bprch += IXGB_READ_REG(&adapter->hw, BPRCH); 2297 adapter->stats.mprcl += IXGB_READ_REG(&adapter->hw, MPRCL); 2298 adapter->stats.mprch += IXGB_READ_REG(&adapter->hw, MPRCH); 2299 adapter->stats.roc += IXGB_READ_REG(&adapter->hw, ROC); 2300 2301 adapter->stats.mpc += IXGB_READ_REG(&adapter->hw, MPC); 2302 adapter->stats.dc += IXGB_READ_REG(&adapter->hw, DC); 2303 adapter->stats.rlec += IXGB_READ_REG(&adapter->hw, RLEC); 2304 adapter->stats.xonrxc += IXGB_READ_REG(&adapter->hw, XONRXC); 2305 adapter->stats.xontxc += IXGB_READ_REG(&adapter->hw, XONTXC); 2306 adapter->stats.xoffrxc += IXGB_READ_REG(&adapter->hw, XOFFRXC); 2307 adapter->stats.xofftxc += IXGB_READ_REG(&adapter->hw, XOFFTXC); 2308 adapter->stats.gptcl += IXGB_READ_REG(&adapter->hw, GPTCL); 2309 adapter->stats.gptch += IXGB_READ_REG(&adapter->hw, GPTCH); 2310 adapter->stats.gotcl += IXGB_READ_REG(&adapter->hw, GOTCL); 2311 adapter->stats.gotch += IXGB_READ_REG(&adapter->hw, GOTCH); 2312 adapter->stats.ruc += IXGB_READ_REG(&adapter->hw, RUC); 2313 adapter->stats.rfc += IXGB_READ_REG(&adapter->hw, RFC); 2314 adapter->stats.rjc += IXGB_READ_REG(&adapter->hw, RJC); 2315 adapter->stats.torl += IXGB_READ_REG(&adapter->hw, TORL); 2316 adapter->stats.torh += IXGB_READ_REG(&adapter->hw, TORH); 2317 adapter->stats.totl += IXGB_READ_REG(&adapter->hw, TOTL); 2318 adapter->stats.toth += IXGB_READ_REG(&adapter->hw, TOTH); 2319 adapter->stats.tprl += IXGB_READ_REG(&adapter->hw, TPRL); 2320 adapter->stats.tprh += IXGB_READ_REG(&adapter->hw, TPRH); 2321 adapter->stats.tptl += IXGB_READ_REG(&adapter->hw, TPTL); 2322 adapter->stats.tpth += IXGB_READ_REG(&adapter->hw, TPTH); 2323 adapter->stats.plt64c += IXGB_READ_REG(&adapter->hw, PLT64C); 2324 adapter->stats.mptcl += IXGB_READ_REG(&adapter->hw, MPTCL); 2325 adapter->stats.mptch += IXGB_READ_REG(&adapter->hw, MPTCH); 2326 adapter->stats.bptcl += IXGB_READ_REG(&adapter->hw, BPTCL); 2327 adapter->stats.bptch += IXGB_READ_REG(&adapter->hw, BPTCH); 2328 2329 adapter->stats.uprcl += IXGB_READ_REG(&adapter->hw, UPRCL); 2330 adapter->stats.uprch += IXGB_READ_REG(&adapter->hw, UPRCH); 2331 adapter->stats.vprcl += IXGB_READ_REG(&adapter->hw, VPRCL); 2332 adapter->stats.vprch += IXGB_READ_REG(&adapter->hw, VPRCH); 2333 adapter->stats.jprcl += IXGB_READ_REG(&adapter->hw, JPRCL); 2334 adapter->stats.jprch += IXGB_READ_REG(&adapter->hw, JPRCH); 2335 adapter->stats.rnbc += IXGB_READ_REG(&adapter->hw, RNBC); 2336 adapter->stats.icbc += IXGB_READ_REG(&adapter->hw, ICBC); 2337 adapter->stats.ecbc += IXGB_READ_REG(&adapter->hw, ECBC); 2338 adapter->stats.uptcl += IXGB_READ_REG(&adapter->hw, UPTCL); 2339 adapter->stats.uptch += IXGB_READ_REG(&adapter->hw, UPTCH); 2340 adapter->stats.vptcl += IXGB_READ_REG(&adapter->hw, VPTCL); 2341 adapter->stats.vptch += IXGB_READ_REG(&adapter->hw, VPTCH); 2342 adapter->stats.jptcl += IXGB_READ_REG(&adapter->hw, JPTCL); 2343 adapter->stats.jptch += IXGB_READ_REG(&adapter->hw, JPTCH); 2344 adapter->stats.tsctc += IXGB_READ_REG(&adapter->hw, TSCTC); 2345 adapter->stats.tsctfc += IXGB_READ_REG(&adapter->hw, TSCTFC); 2346 adapter->stats.ibic += IXGB_READ_REG(&adapter->hw, IBIC); 2347 adapter->stats.lfc += IXGB_READ_REG(&adapter->hw, LFC); 2348 adapter->stats.pfrc += IXGB_READ_REG(&adapter->hw, PFRC); 2349 adapter->stats.pftc += IXGB_READ_REG(&adapter->hw, PFTC); 2350 adapter->stats.mcfrc += IXGB_READ_REG(&adapter->hw, MCFRC); 2351 2352 ifp = &adapter->interface_data.ac_if; 2353 2354 /* Fill out the OS statistics structure */ 2355 ifp->if_ipackets = adapter->stats.gprcl; 2356 ifp->if_opackets = adapter->stats.gptcl; 2357 ifp->if_ibytes = adapter->stats.gorcl; 2358 ifp->if_obytes = adapter->stats.gotcl; 2359 ifp->if_imcasts = adapter->stats.mprcl; 2360 ifp->if_collisions = 0; 2361 2362 /* Rx Errors */ 2363 ifp->if_ierrors = 2364 adapter->dropped_pkts + 2365 adapter->stats.crcerrs + 2366 adapter->stats.rnbc + 2367 adapter->stats.mpc + 2368 adapter->stats.rlec; 2369 2370 2371} 2372 2373 2374/********************************************************************** 2375 * 2376 * This routine is called only when ixgb_display_debug_stats is enabled. 2377 * This routine provides a way to take a look at important statistics 2378 * maintained by the driver and hardware. 2379 * 2380 **********************************************************************/ 2381static void 2382ixgb_print_hw_stats(struct adapter * adapter) 2383{ 2384 char buf_speed[100], buf_type[100]; 2385 ixgb_bus_speed bus_speed; 2386 ixgb_bus_type bus_type; 2387 int unit = adapter->unit; 2388 2389#ifdef _SV_ 2390 printf("ixgb%d: Packets not Avail = %ld\n", unit, 2391 adapter->no_pkts_avail); 2392 printf("ixgb%d: CleanTxInterrupts = %ld\n", unit, 2393 adapter->clean_tx_interrupts); 2394 printf("ixgb%d: ICR RXDMT0 = %lld\n", unit, 2395 (long long)adapter->sv_stats.icr_rxdmt0); 2396 printf("ixgb%d: ICR RXO = %lld\n", unit, 2397 (long long)adapter->sv_stats.icr_rxo); 2398 printf("ixgb%d: ICR RXT0 = %lld\n", unit, 2399 (long long)adapter->sv_stats.icr_rxt0); 2400 printf("ixgb%d: ICR TXDW = %lld\n", unit, 2401 (long long)adapter->sv_stats.icr_TXDW); 2402#endif /* _SV_ */ 2403 2404 bus_speed = adapter->hw.bus.speed; 2405 bus_type = adapter->hw.bus.type; 2406 sprintf(buf_speed, 2407 bus_speed == ixgb_bus_speed_33 ? "33MHz" : 2408 bus_speed == ixgb_bus_speed_66 ? "66MHz" : 2409 bus_speed == ixgb_bus_speed_100 ? "100MHz" : 2410 bus_speed == ixgb_bus_speed_133 ? "133MHz" : 2411 "UNKNOWN"); 2412 printf("ixgb%d: PCI_Bus_Speed = %s\n", unit, 2413 buf_speed); 2414 2415 sprintf(buf_type, 2416 bus_type == ixgb_bus_type_pci ? "PCI" : 2417 bus_type == ixgb_bus_type_pcix ? "PCI-X" : 2418 "UNKNOWN"); 2419 printf("ixgb%d: PCI_Bus_Type = %s\n", unit, 2420 buf_type); 2421 2422 printf("ixgb%d: Tx Descriptors not Avail1 = %ld\n", unit, 2423 adapter->no_tx_desc_avail1); 2424 printf("ixgb%d: Tx Descriptors not Avail2 = %ld\n", unit, 2425 adapter->no_tx_desc_avail2); 2426 printf("ixgb%d: Std Mbuf Failed = %ld\n", unit, 2427 adapter->mbuf_alloc_failed); 2428 printf("ixgb%d: Std Cluster Failed = %ld\n", unit, 2429 adapter->mbuf_cluster_failed); 2430 2431 printf("ixgb%d: Defer count = %lld\n", unit, 2432 (long long)adapter->stats.dc); 2433 printf("ixgb%d: Missed Packets = %lld\n", unit, 2434 (long long)adapter->stats.mpc); 2435 printf("ixgb%d: Receive No Buffers = %lld\n", unit, 2436 (long long)adapter->stats.rnbc); 2437 printf("ixgb%d: Receive length errors = %lld\n", unit, 2438 (long long)adapter->stats.rlec); 2439 printf("ixgb%d: Crc errors = %lld\n", unit, 2440 (long long)adapter->stats.crcerrs); 2441 printf("ixgb%d: Driver dropped packets = %ld\n", unit, 2442 adapter->dropped_pkts); 2443 2444 printf("ixgb%d: XON Rcvd = %lld\n", unit, 2445 (long long)adapter->stats.xonrxc); 2446 printf("ixgb%d: XON Xmtd = %lld\n", unit, 2447 (long long)adapter->stats.xontxc); 2448 printf("ixgb%d: XOFF Rcvd = %lld\n", unit, 2449 (long long)adapter->stats.xoffrxc); 2450 printf("ixgb%d: XOFF Xmtd = %lld\n", unit, 2451 (long long)adapter->stats.xofftxc); 2452 2453 printf("ixgb%d: Good Packets Rcvd = %lld\n", unit, 2454 (long long)adapter->stats.gprcl); 2455 printf("ixgb%d: Good Packets Xmtd = %lld\n", unit, 2456 (long long)adapter->stats.gptcl); 2457 2458 printf("ixgb%d: Jumbo frames recvd = %lld\n", unit, 2459 (long long)adapter->stats.jprcl); 2460 printf("ixgb%d: Jumbo frames Xmtd = %lld\n", unit, 2461 (long long)adapter->stats.jptcl); 2462 2463 return; 2464 2465} 2466 2467static int 2468ixgb_sysctl_stats(SYSCTL_HANDLER_ARGS) 2469{ 2470 int error; 2471 int result; 2472 struct adapter *adapter; 2473 2474 result = -1; 2475 error = sysctl_handle_int(oidp, &result, 0, req); 2476 2477 if (error || !req->newptr) 2478 return (error); 2479 2480 if (result == 1) { 2481 adapter = (struct adapter *) arg1; 2482 ixgb_print_hw_stats(adapter); 2483 } 2484 return error; 2485} 2486