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