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