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