if_em.c revision 114567
1/************************************************************************** 2 3Copyright (c) 2001-2003, 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/em/if_em.c 114567 2003-05-03 07:35:47Z pdeuskar $*/ 35 36#include <dev/em/if_em.h> 37 38/********************************************************************* 39 * Set this to one to display debug statistics 40 *********************************************************************/ 41int em_display_debug_stats = 0; 42 43/********************************************************************* 44 * Linked list of board private structures for all NICs found 45 *********************************************************************/ 46 47struct adapter *em_adapter_list = NULL; 48 49 50/********************************************************************* 51 * Driver version 52 *********************************************************************/ 53 54char em_driver_version[] = "1.5.31"; 55 56 57/********************************************************************* 58 * PCI Device ID Table 59 * 60 * Used by probe to select devices to load on 61 * Last field stores an index into em_strings 62 * Last entry must be all 0s 63 * 64 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 65 *********************************************************************/ 66 67static em_vendor_info_t em_vendor_info_array[] = 68{ 69 /* Intel(R) PRO/1000 Network Connection */ 70 { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0}, 71 { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0}, 72 { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0}, 73 { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0}, 74 { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0}, 75 { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0}, 76 { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0}, 77 { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0}, 78 { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0}, 79 { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0}, 80 { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0}, 81 { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0}, 82 { 0x8086, 0x1013, PCI_ANY_ID, PCI_ANY_ID, 0}, 83 { 0x8086, 0x1014, PCI_ANY_ID, PCI_ANY_ID, 0}, 84 { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0}, 85 { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0}, 86 { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0}, 87 { 0x8086, 0x1018, PCI_ANY_ID, PCI_ANY_ID, 0}, 88 { 0x8086, 0x1019, PCI_ANY_ID, PCI_ANY_ID, 0}, 89 { 0x8086, 0x101A, PCI_ANY_ID, PCI_ANY_ID, 0}, 90 { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0}, 91 /* required last entry */ 92 { 0, 0, 0, 0, 0} 93}; 94 95/********************************************************************* 96 * Table of branding strings for all supported NICs. 97 *********************************************************************/ 98 99static char *em_strings[] = { 100 "Intel(R) PRO/1000 Network Connection" 101}; 102 103/********************************************************************* 104 * Function prototypes 105 *********************************************************************/ 106static int em_probe(device_t); 107static int em_attach(device_t); 108static int em_detach(device_t); 109static int em_shutdown(device_t); 110static void em_intr(void *); 111static void em_start(struct ifnet *); 112static int em_ioctl(struct ifnet *, u_long, caddr_t); 113static void em_watchdog(struct ifnet *); 114static void em_init(void *); 115static void em_stop(void *); 116static void em_media_status(struct ifnet *, struct ifmediareq *); 117static int em_media_change(struct ifnet *); 118static void em_identify_hardware(struct adapter *); 119static int em_allocate_pci_resources(struct adapter *); 120static void em_free_pci_resources(struct adapter *); 121static void em_local_timer(void *); 122static int em_hardware_init(struct adapter *); 123static void em_setup_interface(device_t, struct adapter *); 124static int em_setup_transmit_structures(struct adapter *); 125static void em_initialize_transmit_unit(struct adapter *); 126static int em_setup_receive_structures(struct adapter *); 127static void em_initialize_receive_unit(struct adapter *); 128static void em_enable_intr(struct adapter *); 129static void em_disable_intr(struct adapter *); 130static void em_free_transmit_structures(struct adapter *); 131static void em_free_receive_structures(struct adapter *); 132static void em_update_stats_counters(struct adapter *); 133static void em_clean_transmit_interrupts(struct adapter *); 134static int em_allocate_receive_structures(struct adapter *); 135static int em_allocate_transmit_structures(struct adapter *); 136static void em_process_receive_interrupts(struct adapter *, int); 137static void em_receive_checksum(struct adapter *, 138 struct em_rx_desc *, 139 struct mbuf *); 140static void em_transmit_checksum_setup(struct adapter *, 141 struct mbuf *, 142 u_int32_t *, 143 u_int32_t *); 144static void em_set_promisc(struct adapter *); 145static void em_disable_promisc(struct adapter *); 146static void em_set_multi(struct adapter *); 147static void em_print_hw_stats(struct adapter *); 148static void em_print_link_status(struct adapter *); 149static int em_get_buf(int i, struct adapter *, 150 struct mbuf *); 151static void em_enable_vlans(struct adapter *); 152static int em_encap(struct adapter *, struct mbuf *); 153static void em_smartspeed(struct adapter *); 154static int em_82547_fifo_workaround(struct adapter *, int); 155static void em_82547_update_fifo_head(struct adapter *, int); 156static int em_82547_tx_fifo_reset(struct adapter *); 157static void em_82547_move_tail(void *arg); 158static int em_dma_malloc(struct adapter *, bus_size_t, 159 struct em_dma_alloc *, int); 160static void em_dma_free(struct adapter *, struct em_dma_alloc *); 161 162/********************************************************************* 163 * FreeBSD Device Interface Entry Points 164 *********************************************************************/ 165 166static device_method_t em_methods[] = { 167 /* Device interface */ 168 DEVMETHOD(device_probe, em_probe), 169 DEVMETHOD(device_attach, em_attach), 170 DEVMETHOD(device_detach, em_detach), 171 DEVMETHOD(device_shutdown, em_shutdown), 172 {0, 0} 173}; 174 175static driver_t em_driver = { 176 "em", em_methods, sizeof(struct adapter ), 177}; 178 179static devclass_t em_devclass; 180DRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0); 181MODULE_DEPEND(em, pci, 1, 1, 1); 182MODULE_DEPEND(em, ether, 1, 1, 1); 183 184/********************************************************************* 185 * Device identification routine 186 * 187 * em_probe determines if the driver should be loaded on 188 * adapter based on PCI vendor/device id of the adapter. 189 * 190 * return 0 on success, positive on failure 191 *********************************************************************/ 192 193static int 194em_probe(device_t dev) 195{ 196 em_vendor_info_t *ent; 197 198 u_int16_t pci_vendor_id = 0; 199 u_int16_t pci_device_id = 0; 200 u_int16_t pci_subvendor_id = 0; 201 u_int16_t pci_subdevice_id = 0; 202 char adapter_name[60]; 203 204 INIT_DEBUGOUT("em_probe: begin"); 205 206 pci_vendor_id = pci_get_vendor(dev); 207 if (pci_vendor_id != EM_VENDOR_ID) 208 return(ENXIO); 209 210 pci_device_id = pci_get_device(dev); 211 pci_subvendor_id = pci_get_subvendor(dev); 212 pci_subdevice_id = pci_get_subdevice(dev); 213 214 ent = em_vendor_info_array; 215 while (ent->vendor_id != 0) { 216 if ((pci_vendor_id == ent->vendor_id) && 217 (pci_device_id == ent->device_id) && 218 219 ((pci_subvendor_id == ent->subvendor_id) || 220 (ent->subvendor_id == PCI_ANY_ID)) && 221 222 ((pci_subdevice_id == ent->subdevice_id) || 223 (ent->subdevice_id == PCI_ANY_ID))) { 224 sprintf(adapter_name, "%s, Version - %s", 225 em_strings[ent->index], 226 em_driver_version); 227 device_set_desc_copy(dev, adapter_name); 228 return(0); 229 } 230 ent++; 231 } 232 233 return(ENXIO); 234} 235 236/********************************************************************* 237 * Device initialization routine 238 * 239 * The attach entry point is called when the driver is being loaded. 240 * This routine identifies the type of hardware, allocates all resources 241 * and initializes the hardware. 242 * 243 * return 0 on success, positive on failure 244 *********************************************************************/ 245 246static int 247em_attach(device_t dev) 248{ 249 struct adapter * adapter; 250 int s; 251 int tsize, rsize; 252 253 INIT_DEBUGOUT("em_attach: begin"); 254 s = splimp(); 255 256 /* Allocate, clear, and link in our adapter structure */ 257 if (!(adapter = device_get_softc(dev))) { 258 printf("em: adapter structure allocation failed\n"); 259 splx(s); 260 return(ENOMEM); 261 } 262 bzero(adapter, sizeof(struct adapter )); 263 adapter->dev = dev; 264 adapter->osdep.dev = dev; 265 adapter->unit = device_get_unit(dev); 266 267 if (em_adapter_list != NULL) 268 em_adapter_list->prev = adapter; 269 adapter->next = em_adapter_list; 270 em_adapter_list = adapter; 271 272 callout_handle_init(&adapter->timer_handle); 273 callout_handle_init(&adapter->tx_fifo_timer_handle); 274 275 /* Determine hardware revision */ 276 em_identify_hardware(adapter); 277 278 /* Parameters (to be read from user) */ 279 adapter->num_tx_desc = EM_MAX_TXD; 280 adapter->num_rx_desc = EM_MAX_RXD; 281 adapter->tx_int_delay = EM_TIDV; 282 adapter->tx_abs_int_delay = EM_TADV; 283 adapter->rx_int_delay = EM_RDTR; 284 adapter->rx_abs_int_delay = EM_RADV; 285 adapter->hw.autoneg = DO_AUTO_NEG; 286 adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; 287 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 288 adapter->hw.tbi_compatibility_en = TRUE; 289 adapter->rx_buffer_len = EM_RXBUFFER_2048; 290 291 /* These parameters control the automatic generation(Tx) and 292 * response(Rx) to Ethernet PAUSE frames. 293 */ 294 adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH; 295 adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH; 296 adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER; 297 adapter->hw.fc_send_xon = TRUE; 298 adapter->hw.fc = em_fc_full; 299 300 adapter->hw.phy_init_script = 1; 301 302 /* 303 * Set the max frame size assuming standard ethernet 304 * sized frames 305 */ 306 adapter->hw.max_frame_size = 307 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 308 309 adapter->hw.min_frame_size = 310 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; 311 312 /* 313 * This controls when hardware reports transmit completion 314 * status. 315 */ 316 adapter->hw.report_tx_early = 1; 317 318 319 if (em_allocate_pci_resources(adapter)) { 320 printf("em%d: Allocation of PCI resources failed\n", 321 adapter->unit); 322 em_free_pci_resources(adapter); 323 splx(s); 324 return(ENXIO); 325 } 326 327 328 /* Initialize eeprom parameters */ 329 em_init_eeprom_params(&adapter->hw); 330 331 tsize = EM_ROUNDUP(adapter->num_tx_desc * 332 sizeof(struct em_tx_desc), 4096); 333 334 /* Allocate Transmit Descriptor ring */ 335 if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) { 336 printf("em%d: Unable to allocate tx_desc memory\n", 337 adapter->unit); 338 em_free_pci_resources(adapter); 339 splx(s); 340 return(ENOMEM); 341 } 342 adapter->tx_desc_base = (struct em_tx_desc *) adapter->txdma.dma_vaddr; 343 344 rsize = EM_ROUNDUP(adapter->num_rx_desc * 345 sizeof(struct em_rx_desc), 4096); 346 347 /* Allocate Receive Descriptor ring */ 348 if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) { 349 printf("em%d: Unable to allocate rx_desc memory\n", 350 adapter->unit); 351 em_free_pci_resources(adapter); 352 em_dma_free(adapter, &adapter->txdma); 353 splx(s); 354 return(ENOMEM); 355 } 356 adapter->rx_desc_base = (struct em_rx_desc *) adapter->rxdma.dma_vaddr; 357 358 /* Initialize the hardware */ 359 if (em_hardware_init(adapter)) { 360 printf("em%d: Unable to initialize the hardware\n", 361 adapter->unit); 362 em_free_pci_resources(adapter); 363 em_dma_free(adapter, &adapter->txdma); 364 em_dma_free(adapter, &adapter->rxdma); 365 splx(s); 366 return(EIO); 367 } 368 369 /* Copy the permanent MAC address out of the EEPROM */ 370 if (em_read_mac_addr(&adapter->hw) < 0) { 371 printf("em%d: EEPROM read error while reading mac address\n", 372 adapter->unit); 373 em_free_pci_resources(adapter); 374 em_dma_free(adapter, &adapter->txdma); 375 em_dma_free(adapter, &adapter->rxdma); 376 splx(s); 377 return(EIO); 378 } 379 380 bcopy(adapter->hw.mac_addr, adapter->interface_data.ac_enaddr, 381 ETHER_ADDR_LEN); 382 383 /* Setup OS specific network interface */ 384 em_setup_interface(dev, adapter); 385 386 /* Initialize statistics */ 387 em_clear_hw_cntrs(&adapter->hw); 388 em_update_stats_counters(adapter); 389 adapter->hw.get_link_status = 1; 390 em_check_for_link(&adapter->hw); 391 392 /* Print the link status */ 393 if (adapter->link_active == 1) { 394 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 395 &adapter->link_duplex); 396 printf("em%d: Speed:%d Mbps Duplex:%s\n", 397 adapter->unit, 398 adapter->link_speed, 399 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 400 } else 401 printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); 402 403 INIT_DEBUGOUT("em_attach: end"); 404 splx(s); 405 return(0); 406} 407 408/********************************************************************* 409 * Device removal routine 410 * 411 * The detach entry point is called when the driver is being removed. 412 * This routine stops the adapter and deallocates all the resources 413 * that were allocated for driver operation. 414 * 415 * return 0 on success, positive on failure 416 *********************************************************************/ 417 418static int 419em_detach(device_t dev) 420{ 421 struct adapter * adapter = device_get_softc(dev); 422 struct ifnet *ifp = &adapter->interface_data.ac_if; 423 int s; 424 425 INIT_DEBUGOUT("em_detach: begin"); 426 s = splimp(); 427 428 em_stop(adapter); 429 em_phy_hw_reset(&adapter->hw); 430#if __FreeBSD_version < 500000 431 ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED); 432#else 433 ether_ifdetach(&adapter->interface_data.ac_if); 434#endif 435 em_free_pci_resources(adapter); 436 437 /* Free Transmit Descriptor ring */ 438 if (adapter->tx_desc_base) { 439 em_dma_free(adapter, &adapter->txdma); 440 adapter->tx_desc_base = NULL; 441 } 442 443 /* Free Receive Descriptor ring */ 444 if (adapter->rx_desc_base) { 445 em_dma_free(adapter, &adapter->rxdma); 446 adapter->rx_desc_base = NULL; 447 } 448 449 /* Remove from the adapter list */ 450 if (em_adapter_list == adapter) 451 em_adapter_list = adapter->next; 452 if (adapter->next != NULL) 453 adapter->next->prev = adapter->prev; 454 if (adapter->prev != NULL) 455 adapter->prev->next = adapter->next; 456 457 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 458 ifp->if_timer = 0; 459 460 splx(s); 461 return(0); 462} 463 464/********************************************************************* 465 * 466 * Shutdown entry point 467 * 468 **********************************************************************/ 469 470static int 471em_shutdown(device_t dev) 472{ 473 struct adapter *adapter = device_get_softc(dev); 474 em_stop(adapter); 475 return(0); 476} 477 478 479/********************************************************************* 480 * Transmit entry point 481 * 482 * em_start is called by the stack to initiate a transmit. 483 * The driver will remain in this routine as long as there are 484 * packets to transmit and transmit resources are available. 485 * In case resources are not available stack is notified and 486 * the packet is requeued. 487 **********************************************************************/ 488 489static void 490em_start(struct ifnet *ifp) 491{ 492 int s; 493 struct mbuf *m_head; 494 struct adapter *adapter = ifp->if_softc; 495 496 if (!adapter->link_active) 497 return; 498 499 s = splimp(); 500 while (ifp->if_snd.ifq_head != NULL) { 501 502 IF_DEQUEUE(&ifp->if_snd, m_head); 503 504 if (m_head == NULL) break; 505 506 if (em_encap(adapter, m_head)) { 507 ifp->if_flags |= IFF_OACTIVE; 508 IF_PREPEND(&ifp->if_snd, m_head); 509 break; 510 } 511 512 /* Send a copy of the frame to the BPF listener */ 513#if __FreeBSD_version < 500000 514 if (ifp->if_bpf) 515 bpf_mtap(ifp, m_head); 516#else 517 BPF_MTAP(ifp, m_head); 518#endif 519 520 /* Set timeout in case hardware has problems transmitting */ 521 ifp->if_timer = EM_TX_TIMEOUT; 522 523 } 524 splx(s); 525 return; 526} 527 528/********************************************************************* 529 * Ioctl entry point 530 * 531 * em_ioctl is called when the user wants to configure the 532 * interface. 533 * 534 * return 0 on success, positive on failure 535 **********************************************************************/ 536 537static int 538em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 539{ 540 int s, mask, error = 0; 541 struct ifreq *ifr = (struct ifreq *) data; 542 struct adapter * adapter = ifp->if_softc; 543 544 s = splimp(); 545 switch (command) { 546 case SIOCSIFADDR: 547 case SIOCGIFADDR: 548 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 549 ether_ioctl(ifp, command, data); 550 break; 551 case SIOCSIFMTU: 552 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 553 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) { 554 error = EINVAL; 555 } else { 556 ifp->if_mtu = ifr->ifr_mtu; 557 adapter->hw.max_frame_size = 558 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 559 em_init(adapter); 560 } 561 break; 562 case SIOCSIFFLAGS: 563 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 564 if (ifp->if_flags & IFF_UP) { 565 if (!(ifp->if_flags & IFF_RUNNING)) 566 em_init(adapter); 567 568 em_disable_promisc(adapter); 569 em_set_promisc(adapter); 570 } else { 571 if (ifp->if_flags & IFF_RUNNING) { 572 em_stop(adapter); 573 } 574 } 575 break; 576 case SIOCADDMULTI: 577 case SIOCDELMULTI: 578 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 579 if (ifp->if_flags & IFF_RUNNING) { 580 em_disable_intr(adapter); 581 em_set_multi(adapter); 582 if (adapter->hw.mac_type == em_82542_rev2_0) 583 em_initialize_receive_unit(adapter); 584 em_enable_intr(adapter); 585 } 586 break; 587 case SIOCSIFMEDIA: 588 case SIOCGIFMEDIA: 589 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 590 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 591 break; 592 case SIOCSIFCAP: 593 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 594 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 595 if (mask & IFCAP_HWCSUM) { 596 if (IFCAP_HWCSUM & ifp->if_capenable) 597 ifp->if_capenable &= ~IFCAP_HWCSUM; 598 else 599 ifp->if_capenable |= IFCAP_HWCSUM; 600 if (ifp->if_flags & IFF_RUNNING) 601 em_init(adapter); 602 } 603 break; 604 default: 605 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command); 606 error = EINVAL; 607 } 608 609 splx(s); 610 return(error); 611} 612 613/********************************************************************* 614 * Watchdog entry point 615 * 616 * This routine is called whenever hardware quits transmitting. 617 * 618 **********************************************************************/ 619 620static void 621em_watchdog(struct ifnet *ifp) 622{ 623 struct adapter * adapter; 624 adapter = ifp->if_softc; 625 626 /* If we are in this routine because of pause frames, then 627 * don't reset the hardware. 628 */ 629 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { 630 ifp->if_timer = EM_TX_TIMEOUT; 631 return; 632 } 633 634 printf("em%d: watchdog timeout -- resetting\n", adapter->unit); 635 636 ifp->if_flags &= ~IFF_RUNNING; 637 638 em_stop(adapter); 639 em_init(adapter); 640 641 ifp->if_oerrors++; 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 657em_init(void *arg) 658{ 659 int s; 660 struct ifnet *ifp; 661 struct adapter * adapter = arg; 662 663 INIT_DEBUGOUT("em_init: begin"); 664 665 s = splimp(); 666 667 em_stop(adapter); 668 669 /* Initialize the hardware */ 670 if (em_hardware_init(adapter)) { 671 printf("em%d: Unable to initialize the hardware\n", 672 adapter->unit); 673 splx(s); 674 return; 675 } 676 677 em_enable_vlans(adapter); 678 679 /* Prepare transmit descriptors and buffers */ 680 if (em_setup_transmit_structures(adapter)) { 681 printf("em%d: Could not setup transmit structures\n", 682 adapter->unit); 683 em_stop(adapter); 684 splx(s); 685 return; 686 } 687 em_initialize_transmit_unit(adapter); 688 689 /* Setup Multicast table */ 690 em_set_multi(adapter); 691 692 /* Prepare receive descriptors and buffers */ 693 if (em_setup_receive_structures(adapter)) { 694 printf("em%d: Could not setup receive structures\n", 695 adapter->unit); 696 em_stop(adapter); 697 splx(s); 698 return; 699 } 700 em_initialize_receive_unit(adapter); 701 702 ifp = &adapter->interface_data.ac_if; 703 ifp->if_flags |= IFF_RUNNING; 704 ifp->if_flags &= ~IFF_OACTIVE; 705 706 if (adapter->hw.mac_type >= em_82543) { 707 if (ifp->if_capenable & IFCAP_TXCSUM) 708 ifp->if_hwassist = EM_CHECKSUM_FEATURES; 709 else 710 ifp->if_hwassist = 0; 711 } 712 713 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 714 em_clear_hw_cntrs(&adapter->hw); 715#ifdef DEVICE_POLLING 716 /* 717 * Only enable interrupts if we are not polling, make sure 718 * they are off otherwise. 719 */ 720 if (ifp->if_ipending & IFF_POLLING) 721 em_disable_intr(adapter); 722 else 723#endif /* DEVICE_POLLING */ 724 em_enable_intr(adapter); 725 726 splx(s); 727 return; 728} 729 730 731#ifdef DEVICE_POLLING 732static poll_handler_t em_poll; 733 734static void 735em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) 736{ 737 struct adapter *adapter = ifp->if_softc; 738 u_int32_t reg_icr; 739 740 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */ 741 em_enable_intr(adapter); 742 return; 743 } 744 if (cmd == POLL_AND_CHECK_STATUS) { 745 reg_icr = E1000_READ_REG(&adapter->hw, ICR); 746 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 747 untimeout(em_local_timer, adapter, adapter->timer_handle); 748 adapter->hw.get_link_status = 1; 749 em_check_for_link(&adapter->hw); 750 em_print_link_status(adapter); 751 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 752 } 753 } 754 if (ifp->if_flags & IFF_RUNNING) { 755 em_process_receive_interrupts(adapter, count); 756 em_clean_transmit_interrupts(adapter); 757 } 758 759 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 760 em_start(ifp); 761} 762#endif /* DEVICE_POLLING */ 763 764/********************************************************************* 765 * 766 * Interrupt Service routine 767 * 768 **********************************************************************/ 769static void 770em_intr(void *arg) 771{ 772 u_int32_t loop_cnt = EM_MAX_INTR; 773 u_int32_t reg_icr; 774 struct ifnet *ifp; 775 struct adapter *adapter = arg; 776 777 ifp = &adapter->interface_data.ac_if; 778 779#ifdef DEVICE_POLLING 780 if (ifp->if_ipending & IFF_POLLING) 781 return; 782 783 if (ether_poll_register(em_poll, ifp)) { 784 em_disable_intr(adapter); 785 em_poll(ifp, 0, 1); 786 return; 787 } 788#endif /* DEVICE_POLLING */ 789 790 791 em_disable_intr(adapter); 792 while (loop_cnt > 0 && 793 (reg_icr = E1000_READ_REG(&adapter->hw, ICR)) != 0) { 794 795 /* Link status change */ 796 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 797 untimeout(em_local_timer, adapter, 798 adapter->timer_handle); 799 adapter->hw.get_link_status = 1; 800 em_check_for_link(&adapter->hw); 801 em_print_link_status(adapter); 802 adapter->timer_handle = 803 timeout(em_local_timer, adapter, 2*hz); 804 } 805 806 if (ifp->if_flags & IFF_RUNNING) { 807 em_process_receive_interrupts(adapter, -1); 808 em_clean_transmit_interrupts(adapter); 809 } 810 loop_cnt--; 811 } 812 813 em_enable_intr(adapter); 814 815 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 816 em_start(ifp); 817 818 return; 819} 820 821 822 823/********************************************************************* 824 * 825 * Media Ioctl callback 826 * 827 * This routine is called whenever the user queries the status of 828 * the interface using ifconfig. 829 * 830 **********************************************************************/ 831static void 832em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 833{ 834 struct adapter * adapter = ifp->if_softc; 835 836 INIT_DEBUGOUT("em_media_status: begin"); 837 838 em_check_for_link(&adapter->hw); 839 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 840 if (adapter->link_active == 0) { 841 em_get_speed_and_duplex(&adapter->hw, 842 &adapter->link_speed, 843 &adapter->link_duplex); 844 adapter->link_active = 1; 845 } 846 } else { 847 if (adapter->link_active == 1) { 848 adapter->link_speed = 0; 849 adapter->link_duplex = 0; 850 adapter->link_active = 0; 851 } 852 } 853 854 ifmr->ifm_status = IFM_AVALID; 855 ifmr->ifm_active = IFM_ETHER; 856 857 if (!adapter->link_active) 858 return; 859 860 ifmr->ifm_status |= IFM_ACTIVE; 861 862 if (adapter->hw.media_type == em_media_type_fiber) { 863 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 864 } else { 865 switch (adapter->link_speed) { 866 case 10: 867 ifmr->ifm_active |= IFM_10_T; 868 break; 869 case 100: 870 ifmr->ifm_active |= IFM_100_TX; 871 break; 872 case 1000: 873#if __FreeBSD_version < 500000 874 ifmr->ifm_active |= IFM_1000_TX; 875#else 876 ifmr->ifm_active |= IFM_1000_T; 877#endif 878 break; 879 } 880 if (adapter->link_duplex == FULL_DUPLEX) 881 ifmr->ifm_active |= IFM_FDX; 882 else 883 ifmr->ifm_active |= IFM_HDX; 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 897em_media_change(struct ifnet *ifp) 898{ 899 struct adapter * adapter = ifp->if_softc; 900 struct ifmedia *ifm = &adapter->media; 901 902 INIT_DEBUGOUT("em_media_change: begin"); 903 904 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 905 return(EINVAL); 906 907 switch (IFM_SUBTYPE(ifm->ifm_media)) { 908 case IFM_AUTO: 909 adapter->hw.autoneg = DO_AUTO_NEG; 910 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 911 break; 912 case IFM_1000_SX: 913#if __FreeBSD_version < 500000 914 case IFM_1000_TX: 915#else 916 case IFM_1000_T: 917#endif 918 adapter->hw.autoneg = DO_AUTO_NEG; 919 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 920 break; 921 case IFM_100_TX: 922 adapter->hw.autoneg = FALSE; 923 adapter->hw.autoneg_advertised = 0; 924 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 925 adapter->hw.forced_speed_duplex = em_100_full; 926 else 927 adapter->hw.forced_speed_duplex = em_100_half; 928 break; 929 case IFM_10_T: 930 adapter->hw.autoneg = FALSE; 931 adapter->hw.autoneg_advertised = 0; 932 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 933 adapter->hw.forced_speed_duplex = em_10_full; 934 else 935 adapter->hw.forced_speed_duplex = em_10_half; 936 break; 937 default: 938 printf("em%d: Unsupported media type\n", adapter->unit); 939 } 940 941 em_init(adapter); 942 943 return(0); 944} 945 946static void 947em_tx_cb(void *arg, bus_dma_segment_t *seg, int nsegs, bus_size_t mapsize, int error) 948{ 949 struct em_q *q = arg; 950 951 if (error) 952 return; 953 KASSERT(nsegs <= EM_MAX_SCATTER, 954 ("Too many DMA segments returned when mapping tx packet")); 955 q->nsegs = nsegs; 956 bcopy(seg, q->segs, nsegs * sizeof(seg[0])); 957} 958 959#define EM_FIFO_HDR 0x10 960#define EM_82547_PKT_THRESH 0x3e0 961#define EM_82547_TX_FIFO_SIZE 0x2800 962#define EM_82547_TX_FIFO_BEGIN 0xf00 963/********************************************************************* 964 * 965 * This routine maps the mbufs to tx descriptors. 966 * 967 * return 0 on success, positive on failure 968 **********************************************************************/ 969static int 970em_encap(struct adapter *adapter, struct mbuf *m_head) 971{ 972 u_int32_t txd_upper; 973 u_int32_t txd_lower; 974 int i, j, error; 975 976#if __FreeBSD_version < 500000 977 struct ifvlan *ifv = NULL; 978#else 979 struct m_tag *mtag; 980#endif 981 struct em_q q; 982 struct em_buffer *tx_buffer = NULL; 983 struct em_tx_desc *current_tx_desc = NULL; 984 struct ifnet *ifp = &adapter->interface_data.ac_if; 985 986 /* 987 * Force a cleanup if number of TX descriptors 988 * available hits the threshold 989 */ 990 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 991 em_clean_transmit_interrupts(adapter); 992 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 993 adapter->no_tx_desc_avail1++; 994 return(ENOBUFS); 995 } 996 } 997 998 /* 999 * Map the packet for DMA. 1000 */ 1001 if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &q.map)) { 1002 adapter->no_tx_map_avail++; 1003 return (ENOMEM); 1004 } 1005 error = bus_dmamap_load_mbuf(adapter->txtag, q.map, 1006 m_head, em_tx_cb, &q, BUS_DMA_NOWAIT); 1007 if (error != 0) { 1008 adapter->no_tx_dma_setup++; 1009 bus_dmamap_destroy(adapter->txtag, q.map); 1010 return (error); 1011 } 1012 KASSERT(q.nsegs != 0, ("em_encap: empty packet")); 1013 1014 if (q.nsegs > adapter->num_tx_desc_avail) { 1015 adapter->no_tx_desc_avail2++; 1016 bus_dmamap_destroy(adapter->txtag, q.map); 1017 return (ENOBUFS); 1018 } 1019 1020 1021 if (ifp->if_hwassist > 0) { 1022 em_transmit_checksum_setup(adapter, m_head, 1023 &txd_upper, &txd_lower); 1024 } else 1025 txd_upper = txd_lower = 0; 1026 1027 1028 /* Find out if we are in vlan mode */ 1029#if __FreeBSD_version < 500000 1030 if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) && 1031 m_head->m_pkthdr.rcvif != NULL && 1032 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN) 1033 ifv = m_head->m_pkthdr.rcvif->if_softc; 1034#else 1035 mtag = VLAN_OUTPUT_TAG(ifp, m_head); 1036#endif 1037 1038 i = adapter->next_avail_tx_desc; 1039 for (j = 0; j < q.nsegs; j++) { 1040 tx_buffer = &adapter->tx_buffer_area[i]; 1041 current_tx_desc = &adapter->tx_desc_base[i]; 1042 1043 current_tx_desc->buffer_addr = htole64(q.segs[j].ds_addr); 1044 current_tx_desc->lower.data = htole32( 1045 adapter->txd_cmd | txd_lower | q.segs[j].ds_len); 1046 current_tx_desc->upper.data = htole32(txd_upper); 1047 1048 if (++i == adapter->num_tx_desc) 1049 i = 0; 1050 1051 tx_buffer->m_head = NULL; 1052 } 1053 1054 adapter->num_tx_desc_avail -= q.nsegs; 1055 adapter->next_avail_tx_desc = i; 1056 1057#if __FreeBSD_version < 500000 1058 if (ifv != NULL) { 1059 /* Set the vlan id */ 1060 current_tx_desc->upper.fields.special = htole16(ifv->ifv_tag); 1061#else 1062 if (mtag != NULL) { 1063 /* Set the vlan id */ 1064 current_tx_desc->upper.fields.special = htole16(VLAN_TAG_VALUE(mtag)); 1065#endif 1066 1067 /* Tell hardware to add tag */ 1068 current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE); 1069 } 1070 1071 tx_buffer->m_head = m_head; 1072 tx_buffer->map = q.map; 1073 bus_dmamap_sync(adapter->txtag, q.map, BUS_DMASYNC_PREWRITE); 1074 1075 /* 1076 * Last Descriptor of Packet needs End Of Packet (EOP) 1077 */ 1078 current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP); 1079 1080 /* 1081 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 1082 * that this frame is available to transmit. 1083 */ 1084 if (adapter->hw.mac_type == em_82547 && 1085 adapter->link_duplex == HALF_DUPLEX) { 1086 em_82547_move_tail(adapter); 1087 } else { 1088 E1000_WRITE_REG(&adapter->hw, TDT, i); 1089 if (adapter->hw.mac_type == em_82547) { 1090 em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len); 1091 } 1092 } 1093 1094 return(0); 1095} 1096 1097/********************************************************************* 1098 * 1099 * 82547 workaround to avoid controller hang in half-duplex environment. 1100 * The workaround is to avoid queuing a large packet that would span 1101 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers 1102 * in this case. We do that only when FIFO is queiced. 1103 * 1104 **********************************************************************/ 1105static void 1106em_82547_move_tail(void *arg) 1107{ 1108 int s; 1109 struct adapter *adapter = arg; 1110 uint16_t hw_tdt; 1111 uint16_t sw_tdt; 1112 struct em_tx_desc *tx_desc; 1113 uint16_t length = 0; 1114 boolean_t eop = 0; 1115 1116 s = splimp(); 1117 hw_tdt = E1000_READ_REG(&adapter->hw, TDT); 1118 sw_tdt = adapter->next_avail_tx_desc; 1119 1120 while (hw_tdt != sw_tdt) { 1121 tx_desc = &adapter->tx_desc_base[hw_tdt]; 1122 length += tx_desc->lower.flags.length; 1123 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP; 1124 if(++hw_tdt == adapter->num_tx_desc) 1125 hw_tdt = 0; 1126 1127 if(eop) { 1128 if (em_82547_fifo_workaround(adapter, length)) { 1129 adapter->tx_fifo_wrk++; 1130 adapter->tx_fifo_timer_handle = 1131 timeout(em_82547_move_tail, 1132 adapter, 1); 1133 splx(s); 1134 return; 1135 } 1136 else { 1137 E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt); 1138 em_82547_update_fifo_head(adapter, length); 1139 length = 0; 1140 } 1141 } 1142 } 1143 splx(s); 1144 return; 1145} 1146 1147static int 1148em_82547_fifo_workaround(struct adapter *adapter, int len) 1149{ 1150 int fifo_space, fifo_pkt_len; 1151 1152 fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1153 1154 if (adapter->link_duplex == HALF_DUPLEX) { 1155 fifo_space = EM_82547_TX_FIFO_SIZE - adapter->tx_fifo_head; 1156 1157 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) { 1158 if (em_82547_tx_fifo_reset(adapter)) { 1159 return(0); 1160 } 1161 else { 1162 return(1); 1163 } 1164 } 1165 } 1166 1167 return(0); 1168} 1169 1170static void 1171em_82547_update_fifo_head(struct adapter *adapter, int len) 1172{ 1173 int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1174 1175 /* tx_fifo_head is always 16 byte aligned */ 1176 adapter->tx_fifo_head += fifo_pkt_len; 1177 if (adapter->tx_fifo_head >= EM_82547_TX_FIFO_SIZE) { 1178 adapter->tx_fifo_head -= EM_82547_TX_FIFO_SIZE; 1179 } 1180 1181 return; 1182} 1183 1184 1185static int 1186em_82547_tx_fifo_reset(struct adapter *adapter) 1187{ 1188 uint32_t tctl; 1189 1190 if ( (E1000_READ_REG(&adapter->hw, TDT) == 1191 E1000_READ_REG(&adapter->hw, TDH)) && 1192 (E1000_READ_REG(&adapter->hw, TDFT) == 1193 E1000_READ_REG(&adapter->hw, TDFH)) && 1194 (E1000_READ_REG(&adapter->hw, TDFTS) == 1195 E1000_READ_REG(&adapter->hw, TDFHS)) && 1196 (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) { 1197 1198 /* Disable TX unit */ 1199 tctl = E1000_READ_REG(&adapter->hw, TCTL); 1200 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN); 1201 1202 /* Reset FIFO pointers */ 1203 E1000_WRITE_REG(&adapter->hw, TDFT, EM_82547_TX_FIFO_BEGIN); 1204 E1000_WRITE_REG(&adapter->hw, TDFH, EM_82547_TX_FIFO_BEGIN); 1205 E1000_WRITE_REG(&adapter->hw, TDFTS, EM_82547_TX_FIFO_BEGIN); 1206 E1000_WRITE_REG(&adapter->hw, TDFHS, EM_82547_TX_FIFO_BEGIN); 1207 1208 /* Re-enable TX unit */ 1209 E1000_WRITE_REG(&adapter->hw, TCTL, tctl); 1210 E1000_WRITE_FLUSH(&adapter->hw); 1211 1212 adapter->tx_fifo_head = 0; 1213 adapter->tx_fifo_reset++; 1214 1215 return(TRUE); 1216 } 1217 else { 1218 return(FALSE); 1219 } 1220} 1221 1222static void 1223em_set_promisc(struct adapter * adapter) 1224{ 1225 1226 u_int32_t reg_rctl; 1227 struct ifnet *ifp = &adapter->interface_data.ac_if; 1228 1229 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1230 1231 if (ifp->if_flags & IFF_PROMISC) { 1232 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 1233 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1234 } else if (ifp->if_flags & IFF_ALLMULTI) { 1235 reg_rctl |= E1000_RCTL_MPE; 1236 reg_rctl &= ~E1000_RCTL_UPE; 1237 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1238 } 1239 1240 return; 1241} 1242 1243static void 1244em_disable_promisc(struct adapter * adapter) 1245{ 1246 u_int32_t reg_rctl; 1247 1248 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1249 1250 reg_rctl &= (~E1000_RCTL_UPE); 1251 reg_rctl &= (~E1000_RCTL_MPE); 1252 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1253 1254 return; 1255} 1256 1257 1258/********************************************************************* 1259 * Multicast Update 1260 * 1261 * This routine is called whenever multicast address list is updated. 1262 * 1263 **********************************************************************/ 1264 1265static void 1266em_set_multi(struct adapter * adapter) 1267{ 1268 u_int32_t reg_rctl = 0; 1269 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; 1270 struct ifmultiaddr *ifma; 1271 int mcnt = 0; 1272 struct ifnet *ifp = &adapter->interface_data.ac_if; 1273 1274 IOCTL_DEBUGOUT("em_set_multi: begin"); 1275 1276 if (adapter->hw.mac_type == em_82542_rev2_0) { 1277 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1278 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1279 em_pci_clear_mwi(&adapter->hw); 1280 } 1281 reg_rctl |= E1000_RCTL_RST; 1282 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1283 msec_delay(5); 1284 } 1285 1286#if __FreeBSD_version < 500000 1287 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1288#else 1289 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1290#endif 1291 if (ifma->ifma_addr->sa_family != AF_LINK) 1292 continue; 1293 1294 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break; 1295 1296 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1297 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 1298 mcnt++; 1299 } 1300 1301 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) { 1302 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1303 reg_rctl |= E1000_RCTL_MPE; 1304 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1305 } else 1306 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0); 1307 1308 if (adapter->hw.mac_type == em_82542_rev2_0) { 1309 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1310 reg_rctl &= ~E1000_RCTL_RST; 1311 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1312 msec_delay(5); 1313 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1314 em_pci_set_mwi(&adapter->hw); 1315 } 1316 } 1317 1318 return; 1319} 1320 1321 1322/********************************************************************* 1323 * Timer routine 1324 * 1325 * This routine checks for link status and updates statistics. 1326 * 1327 **********************************************************************/ 1328 1329static void 1330em_local_timer(void *arg) 1331{ 1332 int s; 1333 struct ifnet *ifp; 1334 struct adapter * adapter = arg; 1335 ifp = &adapter->interface_data.ac_if; 1336 1337 s = splimp(); 1338 1339 em_check_for_link(&adapter->hw); 1340 em_print_link_status(adapter); 1341 em_update_stats_counters(adapter); 1342 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 1343 em_print_hw_stats(adapter); 1344 } 1345 em_smartspeed(adapter); 1346 1347 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 1348 1349 splx(s); 1350 return; 1351} 1352 1353static void 1354em_print_link_status(struct adapter * adapter) 1355{ 1356 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1357 if (adapter->link_active == 0) { 1358 em_get_speed_and_duplex(&adapter->hw, 1359 &adapter->link_speed, 1360 &adapter->link_duplex); 1361 printf("em%d: Link is up %d Mbps %s\n", 1362 adapter->unit, 1363 adapter->link_speed, 1364 ((adapter->link_duplex == FULL_DUPLEX) ? 1365 "Full Duplex" : "Half Duplex")); 1366 adapter->link_active = 1; 1367 adapter->smartspeed = 0; 1368 } 1369 } else { 1370 if (adapter->link_active == 1) { 1371 adapter->link_speed = 0; 1372 adapter->link_duplex = 0; 1373 printf("em%d: Link is Down\n", adapter->unit); 1374 adapter->link_active = 0; 1375 } 1376 } 1377 1378 return; 1379} 1380 1381/********************************************************************* 1382 * 1383 * This routine disables all traffic on the adapter by issuing a 1384 * global reset on the MAC and deallocates TX/RX buffers. 1385 * 1386 **********************************************************************/ 1387 1388static void 1389em_stop(void *arg) 1390{ 1391 struct ifnet *ifp; 1392 struct adapter * adapter = arg; 1393 ifp = &adapter->interface_data.ac_if; 1394 1395 INIT_DEBUGOUT("em_stop: begin\n"); 1396 em_disable_intr(adapter); 1397 em_reset_hw(&adapter->hw); 1398 untimeout(em_local_timer, adapter, adapter->timer_handle); 1399 untimeout(em_82547_move_tail, adapter, 1400 adapter->tx_fifo_timer_handle); 1401 em_free_transmit_structures(adapter); 1402 em_free_receive_structures(adapter); 1403 1404 1405 /* Tell the stack that the interface is no longer active */ 1406 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1407 1408 return; 1409} 1410 1411 1412/********************************************************************* 1413 * 1414 * Determine hardware revision. 1415 * 1416 **********************************************************************/ 1417static void 1418em_identify_hardware(struct adapter * adapter) 1419{ 1420 device_t dev = adapter->dev; 1421 1422 /* Make sure our PCI config space has the necessary stuff set */ 1423 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1424 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1425 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1426 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1427 adapter->unit); 1428 adapter->hw.pci_cmd_word |= 1429 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1430 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1431 } 1432 1433 /* Save off the information about this board */ 1434 adapter->hw.vendor_id = pci_get_vendor(dev); 1435 adapter->hw.device_id = pci_get_device(dev); 1436 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1437 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1438 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1439 1440 /* Identify the MAC */ 1441 if (em_set_mac_type(&adapter->hw)) 1442 printf("em%d: Unknown MAC Type\n", adapter->unit); 1443 1444 return; 1445} 1446 1447static int 1448em_allocate_pci_resources(struct adapter * adapter) 1449{ 1450 int i, val, rid; 1451 device_t dev = adapter->dev; 1452 1453 rid = EM_MMBA; 1454 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, 1455 &rid, 0, ~0, 1, 1456 RF_ACTIVE); 1457 if (!(adapter->res_memory)) { 1458 printf("em%d: Unable to allocate bus resource: memory\n", 1459 adapter->unit); 1460 return(ENXIO); 1461 } 1462 adapter->osdep.mem_bus_space_tag = 1463 rman_get_bustag(adapter->res_memory); 1464 adapter->osdep.mem_bus_space_handle = 1465 rman_get_bushandle(adapter->res_memory); 1466 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1467 1468 1469 if (adapter->hw.mac_type > em_82543) { 1470 /* Figure our where our IO BAR is ? */ 1471 rid = EM_MMBA; 1472 for (i = 0; i < 5; i++) { 1473 val = pci_read_config(dev, rid, 4); 1474 if (val & 0x00000001) { 1475 adapter->io_rid = rid; 1476 break; 1477 } 1478 rid += 4; 1479 } 1480 1481 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT, 1482 &adapter->io_rid, 0, ~0, 1, 1483 RF_ACTIVE); 1484 if (!(adapter->res_ioport)) { 1485 printf("em%d: Unable to allocate bus resource: ioport\n", 1486 adapter->unit); 1487 return(ENXIO); 1488 } 1489 1490 adapter->hw.io_base = 1491 rman_get_start(adapter->res_ioport); 1492 } 1493 1494 rid = 0x0; 1495 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, 1496 &rid, 0, ~0, 1, 1497 RF_SHAREABLE | RF_ACTIVE); 1498 if (!(adapter->res_interrupt)) { 1499 printf("em%d: Unable to allocate bus resource: interrupt\n", 1500 adapter->unit); 1501 return(ENXIO); 1502 } 1503 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET, 1504 (void (*)(void *)) em_intr, adapter, 1505 &adapter->int_handler_tag)) { 1506 printf("em%d: Error registering interrupt handler!\n", 1507 adapter->unit); 1508 return(ENXIO); 1509 } 1510 1511 adapter->hw.back = &adapter->osdep; 1512 1513 return(0); 1514} 1515 1516static void 1517em_free_pci_resources(struct adapter * adapter) 1518{ 1519 device_t dev = adapter->dev; 1520 1521 if (adapter->res_interrupt != NULL) { 1522 bus_teardown_intr(dev, adapter->res_interrupt, 1523 adapter->int_handler_tag); 1524 bus_release_resource(dev, SYS_RES_IRQ, 0, 1525 adapter->res_interrupt); 1526 } 1527 if (adapter->res_memory != NULL) { 1528 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1529 adapter->res_memory); 1530 } 1531 1532 if (adapter->res_ioport != NULL) { 1533 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1534 adapter->res_ioport); 1535 } 1536 return; 1537} 1538 1539/********************************************************************* 1540 * 1541 * Initialize the hardware to a configuration as specified by the 1542 * adapter structure. The controller is reset, the EEPROM is 1543 * verified, the MAC address is set, then the shared initialization 1544 * routines are called. 1545 * 1546 **********************************************************************/ 1547static int 1548em_hardware_init(struct adapter * adapter) 1549{ 1550 /* Issue a global reset */ 1551 em_reset_hw(&adapter->hw); 1552 1553 /* When hardware is reset, fifo_head is also reset */ 1554 adapter->tx_fifo_head = 0; 1555 1556 /* Make sure we have a good EEPROM before we read from it */ 1557 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1558 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1559 adapter->unit); 1560 return(EIO); 1561 } 1562 1563 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1564 printf("em%d: EEPROM read error while reading part number\n", 1565 adapter->unit); 1566 return(EIO); 1567 } 1568 1569 if (em_init_hw(&adapter->hw) < 0) { 1570 printf("em%d: Hardware Initialization Failed", 1571 adapter->unit); 1572 return(EIO); 1573 } 1574 1575 em_check_for_link(&adapter->hw); 1576 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1577 adapter->link_active = 1; 1578 else 1579 adapter->link_active = 0; 1580 1581 if (adapter->link_active) { 1582 em_get_speed_and_duplex(&adapter->hw, 1583 &adapter->link_speed, 1584 &adapter->link_duplex); 1585 } else { 1586 adapter->link_speed = 0; 1587 adapter->link_duplex = 0; 1588 } 1589 1590 return(0); 1591} 1592 1593/********************************************************************* 1594 * 1595 * Setup networking device structure and register an interface. 1596 * 1597 **********************************************************************/ 1598static void 1599em_setup_interface(device_t dev, struct adapter * adapter) 1600{ 1601 struct ifnet *ifp; 1602 INIT_DEBUGOUT("em_setup_interface: begin"); 1603 1604 ifp = &adapter->interface_data.ac_if; 1605 ifp->if_unit = adapter->unit; 1606 ifp->if_name = "em"; 1607 ifp->if_mtu = ETHERMTU; 1608 ifp->if_output = ether_output; 1609 ifp->if_baudrate = 1000000000; 1610 ifp->if_init = em_init; 1611 ifp->if_softc = adapter; 1612 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1613 ifp->if_ioctl = em_ioctl; 1614 ifp->if_start = em_start; 1615 ifp->if_watchdog = em_watchdog; 1616 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1617 1618#if __FreeBSD_version < 500000 1619 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1620#else 1621 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1622#endif 1623 1624 if (adapter->hw.mac_type >= em_82543) { 1625 ifp->if_capabilities = IFCAP_HWCSUM; 1626 ifp->if_capenable = ifp->if_capabilities; 1627 } 1628 1629 /* 1630 * Tell the upper layer(s) we support long frames. 1631 */ 1632 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1633#if __FreeBSD_version >= 500000 1634 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1635#endif 1636 1637 1638 /* 1639 * Specify the media types supported by this adapter and register 1640 * callbacks to update media and link information 1641 */ 1642 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1643 em_media_status); 1644 if (adapter->hw.media_type == em_media_type_fiber) { 1645 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1646 0, NULL); 1647 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1648 0, NULL); 1649 } else { 1650 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1651 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1652 0, NULL); 1653 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1654 0, NULL); 1655 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1656 0, NULL); 1657#if __FreeBSD_version < 500000 1658 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1659 0, NULL); 1660 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1661#else 1662 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1663 0, NULL); 1664 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1665#endif 1666 } 1667 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1668 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1669 1670 return; 1671} 1672 1673 1674/********************************************************************* 1675 * 1676 * Workaround for SmartSpeed on 82541 and 82547 controllers 1677 * 1678 **********************************************************************/ 1679static void 1680em_smartspeed(struct adapter *adapter) 1681{ 1682 uint16_t phy_tmp; 1683 1684 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 1685 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 1686 return; 1687 1688 if(adapter->smartspeed == 0) { 1689 /* If Master/Slave config fault is asserted twice, 1690 * we assume back-to-back */ 1691 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1692 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 1693 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1694 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 1695 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 1696 &phy_tmp); 1697 if(phy_tmp & CR_1000T_MS_ENABLE) { 1698 phy_tmp &= ~CR_1000T_MS_ENABLE; 1699 em_write_phy_reg(&adapter->hw, 1700 PHY_1000T_CTRL, phy_tmp); 1701 adapter->smartspeed++; 1702 if(adapter->hw.autoneg && 1703 !em_phy_setup_autoneg(&adapter->hw) && 1704 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 1705 &phy_tmp)) { 1706 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1707 MII_CR_RESTART_AUTO_NEG); 1708 em_write_phy_reg(&adapter->hw, 1709 PHY_CTRL, phy_tmp); 1710 } 1711 } 1712 } 1713 return; 1714 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 1715 /* If still no link, perhaps using 2/3 pair cable */ 1716 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 1717 phy_tmp |= CR_1000T_MS_ENABLE; 1718 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 1719 if(adapter->hw.autoneg && 1720 !em_phy_setup_autoneg(&adapter->hw) && 1721 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 1722 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1723 MII_CR_RESTART_AUTO_NEG); 1724 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 1725 } 1726 } 1727 /* Restart process after EM_SMARTSPEED_MAX iterations */ 1728 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 1729 adapter->smartspeed = 0; 1730 1731 return; 1732} 1733 1734 1735/* 1736 * Manage DMA'able memory. 1737 */ 1738static void 1739em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1740{ 1741 if (error) 1742 return; 1743 *(bus_addr_t*) arg = segs->ds_addr; 1744 return; 1745} 1746 1747static int 1748em_dma_malloc(struct adapter *adapter, bus_size_t size, 1749 struct em_dma_alloc *dma, int mapflags) 1750{ 1751 int r; 1752 1753 r = bus_dma_tag_create(NULL, /* parent */ 1754 PAGE_SIZE, 0, /* alignment, bounds */ 1755 BUS_SPACE_MAXADDR, /* lowaddr */ 1756 BUS_SPACE_MAXADDR, /* highaddr */ 1757 NULL, NULL, /* filter, filterarg */ 1758 size, /* maxsize */ 1759 1, /* nsegments */ 1760 size, /* maxsegsize */ 1761 BUS_DMA_ALLOCNOW, /* flags */ 1762 &dma->dma_tag); 1763 if (r != 0) { 1764 printf("em%d: em_dma_malloc: bus_dma_tag_create failed; " 1765 "error %u\n", adapter->unit, r); 1766 goto fail_0; 1767 } 1768 1769 r = bus_dmamap_create(dma->dma_tag, BUS_DMA_NOWAIT, &dma->dma_map); 1770 if (r != 0) { 1771 printf("em%d: em_dma_malloc: bus_dmamap_create failed; " 1772 "error %u\n", adapter->unit, r); 1773 goto fail_1; 1774 } 1775 1776 r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, 1777 BUS_DMA_NOWAIT, &dma->dma_map); 1778 if (r != 0) { 1779 printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; " 1780 "size %u, error %u\n", adapter->unit, size, r); 1781 goto fail_2; 1782 } 1783 1784 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 1785 size, 1786 em_dmamap_cb, 1787 &dma->dma_paddr, 1788 mapflags | BUS_DMA_NOWAIT); 1789 if (r != 0) { 1790 printf("em%d: em_dma_malloc: bus_dmamap_load failed; " 1791 "error %u\n", adapter->unit, r); 1792 goto fail_3; 1793 } 1794 1795 dma->dma_size = size; 1796 return (0); 1797 1798fail_3: 1799 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 1800fail_2: 1801 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1802fail_1: 1803 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 1804 bus_dma_tag_destroy(dma->dma_tag); 1805fail_0: 1806 dma->dma_map = NULL; 1807 dma->dma_tag = NULL; 1808 return (r); 1809} 1810 1811static void 1812em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) 1813{ 1814 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 1815 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 1816 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 1817 bus_dma_tag_destroy(dma->dma_tag); 1818} 1819 1820 1821/********************************************************************* 1822 * 1823 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1824 * the information needed to transmit a packet on the wire. 1825 * 1826 **********************************************************************/ 1827static int 1828em_allocate_transmit_structures(struct adapter * adapter) 1829{ 1830 if (!(adapter->tx_buffer_area = 1831 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 1832 adapter->num_tx_desc, M_DEVBUF, 1833 M_NOWAIT))) { 1834 printf("em%d: Unable to allocate tx_buffer memory\n", 1835 adapter->unit); 1836 return ENOMEM; 1837 } 1838 1839 bzero(adapter->tx_buffer_area, 1840 sizeof(struct em_buffer) * adapter->num_tx_desc); 1841 1842 return 0; 1843} 1844 1845/********************************************************************* 1846 * 1847 * Allocate and initialize transmit structures. 1848 * 1849 **********************************************************************/ 1850static int 1851em_setup_transmit_structures(struct adapter * adapter) 1852{ 1853 /* 1854 * Setup DMA descriptor areas. 1855 */ 1856 if (bus_dma_tag_create(NULL, /* parent */ 1857 PAGE_SIZE, 0, /* alignment, bounds */ 1858 BUS_SPACE_MAXADDR, /* lowaddr */ 1859 BUS_SPACE_MAXADDR, /* highaddr */ 1860 NULL, NULL, /* filter, filterarg */ 1861 MCLBYTES * 8, /* maxsize */ 1862 EM_MAX_SCATTER, /* nsegments */ 1863 MCLBYTES * 8, /* maxsegsize */ 1864 BUS_DMA_ALLOCNOW, /* flags */ 1865 &adapter->txtag)) { 1866 printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit); 1867 return (ENOMEM); 1868 } 1869 1870 if (em_allocate_transmit_structures(adapter)) 1871 return (ENOMEM); 1872 1873 bzero((void *) adapter->tx_desc_base, 1874 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 1875 1876 adapter->next_avail_tx_desc = 0; 1877 adapter->oldest_used_tx_desc = 0; 1878 1879 /* Set number of descriptors available */ 1880 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1881 1882 /* Set checksum context */ 1883 adapter->active_checksum_context = OFFLOAD_NONE; 1884 1885 return (0); 1886} 1887 1888/********************************************************************* 1889 * 1890 * Enable transmit unit. 1891 * 1892 **********************************************************************/ 1893static void 1894em_initialize_transmit_unit(struct adapter * adapter) 1895{ 1896 u_int32_t reg_tctl; 1897 u_int32_t reg_tipg = 0; 1898 u_int64_t bus_addr; 1899 1900 /* Setup the Base and Length of the Tx Descriptor Ring */ 1901 bus_addr = adapter->txdma.dma_paddr; 1902 E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr); 1903 E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32)); 1904 E1000_WRITE_REG(&adapter->hw, TDLEN, 1905 adapter->num_tx_desc * 1906 sizeof(struct em_tx_desc)); 1907 1908 /* Setup the HW Tx Head and Tail descriptor pointers */ 1909 E1000_WRITE_REG(&adapter->hw, TDH, 0); 1910 E1000_WRITE_REG(&adapter->hw, TDT, 0); 1911 1912 1913 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1914 E1000_READ_REG(&adapter->hw, TDBAL), 1915 E1000_READ_REG(&adapter->hw, TDLEN)); 1916 1917 1918 /* Set the default values for the Tx Inter Packet Gap timer */ 1919 switch (adapter->hw.mac_type) { 1920 case em_82543: 1921 case em_82544: 1922 case em_82540: 1923 case em_82545: 1924 case em_82546: 1925 case em_82541: 1926 case em_82547: 1927 if (adapter->hw.media_type == em_media_type_fiber) 1928 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1929 else 1930 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1931 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1932 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1933 break; 1934 case em_82542_rev2_0: 1935 case em_82542_rev2_1: 1936 reg_tipg = DEFAULT_82542_TIPG_IPGT; 1937 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1938 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1939 break; 1940 default: 1941 printf("em%d: Invalid mac type detected\n", adapter->unit); 1942 } 1943 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 1944 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1945 if(adapter->hw.mac_type >= em_82540) 1946 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay); 1947 1948 /* Program the Transmit Control Register */ 1949 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 1950 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1951 if (adapter->link_duplex == 1) { 1952 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1953 } else { 1954 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1955 } 1956 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1957 1958 /* Setup Transmit Descriptor Settings for this adapter */ 1959 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 1960 1961 if (adapter->tx_int_delay > 0) 1962 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1963 1964 return; 1965} 1966 1967/********************************************************************* 1968 * 1969 * Free all transmit related data structures. 1970 * 1971 **********************************************************************/ 1972static void 1973em_free_transmit_structures(struct adapter * adapter) 1974{ 1975 struct em_buffer *tx_buffer; 1976 int i; 1977 1978 INIT_DEBUGOUT("free_transmit_structures: begin"); 1979 1980 if (adapter->tx_buffer_area != NULL) { 1981 tx_buffer = adapter->tx_buffer_area; 1982 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1983 if (tx_buffer->m_head != NULL) { 1984 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 1985 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 1986 m_freem(tx_buffer->m_head); 1987 } 1988 tx_buffer->m_head = NULL; 1989 } 1990 } 1991 if (adapter->tx_buffer_area != NULL) { 1992 free(adapter->tx_buffer_area, M_DEVBUF); 1993 adapter->tx_buffer_area = NULL; 1994 } 1995 if (adapter->txtag != NULL) { 1996 bus_dma_tag_destroy(adapter->txtag); 1997 adapter->txtag = NULL; 1998 } 1999 return; 2000} 2001 2002/********************************************************************* 2003 * 2004 * The offload context needs to be set when we transfer the first 2005 * packet of a particular protocol (TCP/UDP). We change the 2006 * context only if the protocol type changes. 2007 * 2008 **********************************************************************/ 2009static void 2010em_transmit_checksum_setup(struct adapter * adapter, 2011 struct mbuf *mp, 2012 u_int32_t *txd_upper, 2013 u_int32_t *txd_lower) 2014{ 2015 struct em_context_desc *TXD; 2016 struct em_buffer *tx_buffer; 2017 int curr_txd; 2018 2019 if (mp->m_pkthdr.csum_flags) { 2020 2021 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 2022 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2023 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2024 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 2025 return; 2026 else 2027 adapter->active_checksum_context = OFFLOAD_TCP_IP; 2028 2029 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 2030 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2031 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2032 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 2033 return; 2034 else 2035 adapter->active_checksum_context = OFFLOAD_UDP_IP; 2036 } else { 2037 *txd_upper = 0; 2038 *txd_lower = 0; 2039 return; 2040 } 2041 } else { 2042 *txd_upper = 0; 2043 *txd_lower = 0; 2044 return; 2045 } 2046 2047 /* If we reach this point, the checksum offload context 2048 * needs to be reset. 2049 */ 2050 curr_txd = adapter->next_avail_tx_desc; 2051 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 2052 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 2053 2054 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 2055 TXD->lower_setup.ip_fields.ipcso = 2056 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 2057 TXD->lower_setup.ip_fields.ipcse = 2058 htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1); 2059 2060 TXD->upper_setup.tcp_fields.tucss = 2061 ETHER_HDR_LEN + sizeof(struct ip); 2062 TXD->upper_setup.tcp_fields.tucse = htole16(0); 2063 2064 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 2065 TXD->upper_setup.tcp_fields.tucso = 2066 ETHER_HDR_LEN + sizeof(struct ip) + 2067 offsetof(struct tcphdr, th_sum); 2068 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 2069 TXD->upper_setup.tcp_fields.tucso = 2070 ETHER_HDR_LEN + sizeof(struct ip) + 2071 offsetof(struct udphdr, uh_sum); 2072 } 2073 2074 TXD->tcp_seg_setup.data = htole32(0); 2075 TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT); 2076 2077 tx_buffer->m_head = NULL; 2078 2079 if (++curr_txd == adapter->num_tx_desc) 2080 curr_txd = 0; 2081 2082 adapter->num_tx_desc_avail--; 2083 adapter->next_avail_tx_desc = curr_txd; 2084 2085 return; 2086} 2087 2088/********************************************************************** 2089 * 2090 * Examine each tx_buffer in the used queue. If the hardware is done 2091 * processing the packet then free associated resources. The 2092 * tx_buffer is put back on the free queue. 2093 * 2094 **********************************************************************/ 2095static void 2096em_clean_transmit_interrupts(struct adapter * adapter) 2097{ 2098 int s; 2099 int i, num_avail; 2100 struct em_buffer *tx_buffer; 2101 struct em_tx_desc *tx_desc; 2102 2103 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2104 return; 2105 2106 s = splimp(); 2107#ifdef DBG_STATS 2108 adapter->clean_tx_interrupts++; 2109#endif 2110 num_avail = adapter->num_tx_desc_avail; 2111 i = adapter->oldest_used_tx_desc; 2112 2113 tx_buffer = &adapter->tx_buffer_area[i]; 2114 tx_desc = &adapter->tx_desc_base[i]; 2115 2116 while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 2117 2118 tx_desc->upper.data = 0; 2119 num_avail++; 2120 2121 if (tx_buffer->m_head) { 2122 2123 bus_dmamap_sync(adapter->txtag, tx_buffer->map, 2124 BUS_DMASYNC_POSTWRITE); 2125 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2126 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2127 2128 m_freem(tx_buffer->m_head); 2129 tx_buffer->m_head = NULL; 2130 2131 } 2132 2133 if (++i == adapter->num_tx_desc) 2134 i = 0; 2135 2136 tx_buffer = &adapter->tx_buffer_area[i]; 2137 tx_desc = &adapter->tx_desc_base[i]; 2138 } 2139 2140 adapter->oldest_used_tx_desc = i; 2141 2142 /* 2143 * If we have enough room, clear IFF_OACTIVE to tell the stack 2144 * that it is OK to send packets. 2145 * If there are no pending descriptors, clear the timeout. Otherwise, 2146 * if some descriptors have been freed, restart the timeout. 2147 */ 2148 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2149 struct ifnet *ifp = &adapter->interface_data.ac_if; 2150 2151 ifp->if_flags &= ~IFF_OACTIVE; 2152 if (num_avail == adapter->num_tx_desc) 2153 ifp->if_timer = 0; 2154 else if (num_avail == adapter->num_tx_desc_avail) 2155 ifp->if_timer = EM_TX_TIMEOUT; 2156 } 2157 adapter->num_tx_desc_avail = num_avail; 2158 splx(s); 2159 return; 2160} 2161 2162/********************************************************************* 2163 * 2164 * Get a buffer from system mbuf buffer pool. 2165 * 2166 **********************************************************************/ 2167static int 2168em_get_buf(int i, struct adapter *adapter, 2169 struct mbuf *nmp) 2170{ 2171 register struct mbuf *mp = nmp; 2172 struct em_buffer *rx_buffer; 2173 struct ifnet *ifp; 2174 bus_addr_t paddr; 2175 int error; 2176 2177 ifp = &adapter->interface_data.ac_if; 2178 2179 if (mp == NULL) { 2180 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 2181 if (mp == NULL) { 2182 adapter->mbuf_cluster_failed++; 2183 return(ENOBUFS); 2184 } 2185 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2186 } else { 2187 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2188 mp->m_data = mp->m_ext.ext_buf; 2189 mp->m_next = NULL; 2190 } 2191 2192 if (ifp->if_mtu <= ETHERMTU) { 2193 m_adj(mp, ETHER_ALIGN); 2194 } 2195 2196 rx_buffer = &adapter->rx_buffer_area[i]; 2197 2198 /* 2199 * Using memory from the mbuf cluster pool, invoke the 2200 * bus_dma machinery to arrange the memory mapping. 2201 */ 2202 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 2203 mtod(mp, void *), mp->m_len, 2204 em_dmamap_cb, &paddr, 0); 2205 if (error) { 2206 m_free(mp); 2207 return(error); 2208 } 2209 rx_buffer->m_head = mp; 2210 adapter->rx_desc_base[i].buffer_addr = htole64(paddr); 2211 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 2212 2213 return(0); 2214} 2215 2216/********************************************************************* 2217 * 2218 * Allocate memory for rx_buffer structures. Since we use one 2219 * rx_buffer per received packet, the maximum number of rx_buffer's 2220 * that we'll need is equal to the number of receive descriptors 2221 * that we've allocated. 2222 * 2223 **********************************************************************/ 2224static int 2225em_allocate_receive_structures(struct adapter * adapter) 2226{ 2227 int i, error; 2228 struct em_buffer *rx_buffer; 2229 2230 if (!(adapter->rx_buffer_area = 2231 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2232 adapter->num_rx_desc, M_DEVBUF, 2233 M_NOWAIT))) { 2234 printf("em%d: Unable to allocate rx_buffer memory\n", 2235 adapter->unit); 2236 return(ENOMEM); 2237 } 2238 2239 bzero(adapter->rx_buffer_area, 2240 sizeof(struct em_buffer) * adapter->num_rx_desc); 2241 2242 error = bus_dma_tag_create(NULL, /* parent */ 2243 PAGE_SIZE, 0, /* alignment, bounds */ 2244 BUS_SPACE_MAXADDR, /* lowaddr */ 2245 BUS_SPACE_MAXADDR, /* highaddr */ 2246 NULL, NULL, /* filter, filterarg */ 2247 MCLBYTES, /* maxsize */ 2248 1, /* nsegments */ 2249 MCLBYTES, /* maxsegsize */ 2250 BUS_DMA_ALLOCNOW, /* flags */ 2251 &adapter->rxtag); 2252 if (error != 0) { 2253 printf("em%d: em_allocate_receive_structures: " 2254 "bus_dma_tag_create failed; error %u\n", 2255 adapter->unit, error); 2256 goto fail_0; 2257 } 2258 2259 rx_buffer = adapter->rx_buffer_area; 2260 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2261 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 2262 &rx_buffer->map); 2263 if (error != 0) { 2264 printf("em%d: em_allocate_receive_structures: " 2265 "bus_dmamap_create failed; error %u\n", 2266 adapter->unit, error); 2267 goto fail_1; 2268 } 2269 } 2270 2271 for (i = 0; i < adapter->num_rx_desc; i++) { 2272 error = em_get_buf(i, adapter, NULL); 2273 if (error != 0) { 2274 adapter->rx_buffer_area[i].m_head = NULL; 2275 adapter->rx_desc_base[i].buffer_addr = 0; 2276 return(error); 2277 } 2278 } 2279 2280 return(0); 2281 2282fail_1: 2283 bus_dma_tag_destroy(adapter->rxtag); 2284fail_0: 2285 adapter->rxtag = NULL; 2286 free(adapter->rx_buffer_area, M_DEVBUF); 2287 adapter->rx_buffer_area = NULL; 2288 return (error); 2289} 2290 2291/********************************************************************* 2292 * 2293 * Allocate and initialize receive structures. 2294 * 2295 **********************************************************************/ 2296static int 2297em_setup_receive_structures(struct adapter * adapter) 2298{ 2299 bzero((void *) adapter->rx_desc_base, 2300 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2301 2302 if (em_allocate_receive_structures(adapter)) 2303 return ENOMEM; 2304 2305 /* Setup our descriptor pointers */ 2306 adapter->next_rx_desc_to_check = 0; 2307 return(0); 2308} 2309 2310/********************************************************************* 2311 * 2312 * Enable receive unit. 2313 * 2314 **********************************************************************/ 2315static void 2316em_initialize_receive_unit(struct adapter * adapter) 2317{ 2318 u_int32_t reg_rctl; 2319 u_int32_t reg_rxcsum; 2320 struct ifnet *ifp; 2321 u_int64_t bus_addr; 2322 2323 ifp = &adapter->interface_data.ac_if; 2324 2325 /* Make sure receives are disabled while setting up the descriptor ring */ 2326 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2327 2328 /* Set the Receive Delay Timer Register */ 2329 E1000_WRITE_REG(&adapter->hw, RDTR, 2330 adapter->rx_int_delay | E1000_RDT_FPDB); 2331 2332 if(adapter->hw.mac_type >= em_82540) { 2333 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay); 2334 2335 /* Set the interrupt throttling rate. Value is calculated 2336 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2337#define MAX_INTS_PER_SEC 8000 2338#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2339 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2340 } 2341 2342 /* Setup the Base and Length of the Rx Descriptor Ring */ 2343 bus_addr = adapter->rxdma.dma_paddr; 2344 E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr); 2345 E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32)); 2346 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 2347 sizeof(struct em_rx_desc)); 2348 2349 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2350 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2351 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2352 2353 /* Setup the Receive Control Register */ 2354 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2355 E1000_RCTL_RDMTS_HALF | 2356 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2357 2358 if (adapter->hw.tbi_compatibility_on == TRUE) 2359 reg_rctl |= E1000_RCTL_SBP; 2360 2361 2362 switch (adapter->rx_buffer_len) { 2363 default: 2364 case EM_RXBUFFER_2048: 2365 reg_rctl |= E1000_RCTL_SZ_2048; 2366 break; 2367 case EM_RXBUFFER_4096: 2368 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2369 break; 2370 case EM_RXBUFFER_8192: 2371 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2372 break; 2373 case EM_RXBUFFER_16384: 2374 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2375 break; 2376 } 2377 2378 if (ifp->if_mtu > ETHERMTU) 2379 reg_rctl |= E1000_RCTL_LPE; 2380 2381 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2382 if ((adapter->hw.mac_type >= em_82543) && 2383 (ifp->if_capenable & IFCAP_RXCSUM)) { 2384 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2385 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2386 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2387 } 2388 2389 /* Enable Receives */ 2390 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2391 2392 return; 2393} 2394 2395/********************************************************************* 2396 * 2397 * Free receive related data structures. 2398 * 2399 **********************************************************************/ 2400static void 2401em_free_receive_structures(struct adapter *adapter) 2402{ 2403 struct em_buffer *rx_buffer; 2404 int i; 2405 2406 INIT_DEBUGOUT("free_receive_structures: begin"); 2407 2408 if (adapter->rx_buffer_area != NULL) { 2409 rx_buffer = adapter->rx_buffer_area; 2410 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2411 if (rx_buffer->map != NULL) { 2412 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2413 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2414 } 2415 if (rx_buffer->m_head != NULL) 2416 m_freem(rx_buffer->m_head); 2417 rx_buffer->m_head = NULL; 2418 } 2419 } 2420 if (adapter->rx_buffer_area != NULL) { 2421 free(adapter->rx_buffer_area, M_DEVBUF); 2422 adapter->rx_buffer_area = NULL; 2423 } 2424 if (adapter->rxtag != NULL) { 2425 bus_dma_tag_destroy(adapter->rxtag); 2426 adapter->rxtag = NULL; 2427 } 2428 return; 2429} 2430 2431/********************************************************************* 2432 * 2433 * This routine executes in interrupt context. It replenishes 2434 * the mbufs in the descriptor and sends data which has been 2435 * dma'ed into host memory to upper layer. 2436 * 2437 * We loop at most count times if count is > 0, or until done if 2438 * count < 0. 2439 * 2440 *********************************************************************/ 2441static void 2442em_process_receive_interrupts(struct adapter * adapter, int count) 2443{ 2444 struct ifnet *ifp; 2445 struct mbuf *mp; 2446#if __FreeBSD_version < 500000 2447 struct ether_header *eh; 2448#endif 2449 u_int8_t accept_frame = 0; 2450 u_int8_t eop = 0; 2451 u_int16_t len, desc_len; 2452 int i; 2453 2454 /* Pointer to the receive descriptor being examined. */ 2455 struct em_rx_desc *current_desc; 2456 2457 ifp = &adapter->interface_data.ac_if; 2458 i = adapter->next_rx_desc_to_check; 2459 current_desc = &adapter->rx_desc_base[i]; 2460 2461 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2462#ifdef DBG_STATS 2463 adapter->no_pkts_avail++; 2464#endif 2465 return; 2466 } 2467 2468 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2469 2470 mp = adapter->rx_buffer_area[i].m_head; 2471 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2472 BUS_DMASYNC_POSTREAD); 2473 2474 accept_frame = 1; 2475 desc_len = le16toh(current_desc->length); 2476 if (current_desc->status & E1000_RXD_STAT_EOP) { 2477 count--; 2478 eop = 1; 2479 len = desc_len - ETHER_CRC_LEN; 2480 } else { 2481 eop = 0; 2482 len = desc_len; 2483 } 2484 2485 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2486 u_int8_t last_byte; 2487 u_int32_t pkt_len = desc_len; 2488 2489 if (adapter->fmp != NULL) 2490 pkt_len += adapter->fmp->m_pkthdr.len; 2491 2492 last_byte = *(mtod(mp, caddr_t) + desc_len - 1); 2493 2494 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2495 current_desc->errors, 2496 pkt_len, last_byte)) { 2497 em_tbi_adjust_stats(&adapter->hw, 2498 &adapter->stats, 2499 pkt_len, 2500 adapter->hw.mac_addr); 2501 len--; 2502 } 2503 else { 2504 accept_frame = 0; 2505 } 2506 } 2507 2508 if (accept_frame) { 2509 2510 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2511 adapter->dropped_pkts++; 2512 em_get_buf(i, adapter, mp); 2513 if (adapter->fmp != NULL) 2514 m_freem(adapter->fmp); 2515 adapter->fmp = NULL; 2516 adapter->lmp = NULL; 2517 break; 2518 } 2519 2520 /* Assign correct length to the current fragment */ 2521 mp->m_len = len; 2522 2523 if (adapter->fmp == NULL) { 2524 mp->m_pkthdr.len = len; 2525 adapter->fmp = mp; /* Store the first mbuf */ 2526 adapter->lmp = mp; 2527 } else { 2528 /* Chain mbuf's together */ 2529 mp->m_flags &= ~M_PKTHDR; 2530 adapter->lmp->m_next = mp; 2531 adapter->lmp = adapter->lmp->m_next; 2532 adapter->fmp->m_pkthdr.len += len; 2533 } 2534 2535 if (eop) { 2536 adapter->fmp->m_pkthdr.rcvif = ifp; 2537 2538#if __FreeBSD_version < 500000 2539 eh = mtod(adapter->fmp, struct ether_header *); 2540 /* Remove ethernet header from mbuf */ 2541 m_adj(adapter->fmp, sizeof(struct ether_header)); 2542 em_receive_checksum(adapter, current_desc, 2543 adapter->fmp); 2544 if (current_desc->status & E1000_RXD_STAT_VP) 2545 VLAN_INPUT_TAG(eh, adapter->fmp, 2546 (current_desc->special & 2547 E1000_RXD_SPC_VLAN_MASK)); 2548 else 2549 ether_input(ifp, eh, adapter->fmp); 2550#else 2551 2552 em_receive_checksum(adapter, current_desc, 2553 adapter->fmp); 2554 if (current_desc->status & E1000_RXD_STAT_VP) 2555 VLAN_INPUT_TAG(ifp, adapter->fmp, 2556 (current_desc->special & 2557 E1000_RXD_SPC_VLAN_MASK), 2558 adapter->fmp = NULL); 2559 2560 if (adapter->fmp != NULL) 2561 (*ifp->if_input)(ifp, adapter->fmp); 2562#endif 2563 adapter->fmp = NULL; 2564 adapter->lmp = NULL; 2565 } 2566 } else { 2567 adapter->dropped_pkts++; 2568 em_get_buf(i, adapter, mp); 2569 if (adapter->fmp != NULL) 2570 m_freem(adapter->fmp); 2571 adapter->fmp = NULL; 2572 adapter->lmp = NULL; 2573 } 2574 2575 /* Zero out the receive descriptors status */ 2576 current_desc->status = 0; 2577 2578 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2579 E1000_WRITE_REG(&adapter->hw, RDT, i); 2580 2581 /* Advance our pointers to the next descriptor */ 2582 if (++i == adapter->num_rx_desc) { 2583 i = 0; 2584 current_desc = adapter->rx_desc_base; 2585 } else 2586 current_desc++; 2587 } 2588 adapter->next_rx_desc_to_check = i; 2589 return; 2590} 2591 2592/********************************************************************* 2593 * 2594 * Verify that the hardware indicated that the checksum is valid. 2595 * Inform the stack about the status of checksum so that stack 2596 * doesn't spend time verifying the checksum. 2597 * 2598 *********************************************************************/ 2599static void 2600em_receive_checksum(struct adapter *adapter, 2601 struct em_rx_desc *rx_desc, 2602 struct mbuf *mp) 2603{ 2604 /* 82543 or newer only */ 2605 if ((adapter->hw.mac_type < em_82543) || 2606 /* Ignore Checksum bit is set */ 2607 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2608 mp->m_pkthdr.csum_flags = 0; 2609 return; 2610 } 2611 2612 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2613 /* Did it pass? */ 2614 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2615 /* IP Checksum Good */ 2616 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2617 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2618 2619 } else { 2620 mp->m_pkthdr.csum_flags = 0; 2621 } 2622 } 2623 2624 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2625 /* Did it pass? */ 2626 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2627 mp->m_pkthdr.csum_flags |= 2628 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2629 mp->m_pkthdr.csum_data = htons(0xffff); 2630 } 2631 } 2632 2633 return; 2634} 2635 2636 2637static void 2638em_enable_vlans(struct adapter *adapter) 2639{ 2640 uint32_t ctrl; 2641 2642 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 2643 2644 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2645 ctrl |= E1000_CTRL_VME; 2646 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2647 2648 return; 2649} 2650 2651static void 2652em_enable_intr(struct adapter * adapter) 2653{ 2654 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2655 return; 2656} 2657 2658static void 2659em_disable_intr(struct adapter *adapter) 2660{ 2661 E1000_WRITE_REG(&adapter->hw, IMC, 2662 (0xffffffff & ~E1000_IMC_RXSEQ)); 2663 return; 2664} 2665 2666void 2667em_write_pci_cfg(struct em_hw *hw, 2668 uint32_t reg, 2669 uint16_t *value) 2670{ 2671 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2672 *value, 2); 2673} 2674 2675void 2676em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2677 uint16_t *value) 2678{ 2679 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2680 reg, 2); 2681 return; 2682} 2683 2684void 2685em_pci_set_mwi(struct em_hw *hw) 2686{ 2687 pci_write_config(((struct em_osdep *)hw->back)->dev, 2688 PCIR_COMMAND, 2689 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 2690 return; 2691} 2692 2693void 2694em_pci_clear_mwi(struct em_hw *hw) 2695{ 2696 pci_write_config(((struct em_osdep *)hw->back)->dev, 2697 PCIR_COMMAND, 2698 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 2699 return; 2700} 2701 2702uint32_t 2703em_io_read(struct em_hw *hw, uint32_t port) 2704{ 2705 return(inl(port)); 2706} 2707 2708void 2709em_io_write(struct em_hw *hw, uint32_t port, uint32_t value) 2710{ 2711 outl(port, value); 2712 return; 2713} 2714 2715/********************************************************************** 2716 * 2717 * Update the board statistics counters. 2718 * 2719 **********************************************************************/ 2720static void 2721em_update_stats_counters(struct adapter *adapter) 2722{ 2723 struct ifnet *ifp; 2724 2725 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 2726 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 2727 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 2728 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 2729 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 2730 2731 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 2732 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 2733 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 2734 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 2735 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 2736 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 2737 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 2738 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 2739 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 2740 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 2741 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 2742 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 2743 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 2744 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 2745 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 2746 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 2747 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 2748 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 2749 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 2750 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 2751 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 2752 2753 /* For the 64-bit byte counters the low dword must be read first. */ 2754 /* Both registers clear on the read of the high dword */ 2755 2756 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 2757 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 2758 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 2759 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 2760 2761 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 2762 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 2763 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 2764 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 2765 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 2766 2767 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 2768 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 2769 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 2770 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 2771 2772 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 2773 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 2774 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 2775 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 2776 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 2777 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 2778 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 2779 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 2780 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 2781 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 2782 2783 if (adapter->hw.mac_type >= em_82543) { 2784 adapter->stats.algnerrc += 2785 E1000_READ_REG(&adapter->hw, ALGNERRC); 2786 adapter->stats.rxerrc += 2787 E1000_READ_REG(&adapter->hw, RXERRC); 2788 adapter->stats.tncrs += 2789 E1000_READ_REG(&adapter->hw, TNCRS); 2790 adapter->stats.cexterr += 2791 E1000_READ_REG(&adapter->hw, CEXTERR); 2792 adapter->stats.tsctc += 2793 E1000_READ_REG(&adapter->hw, TSCTC); 2794 adapter->stats.tsctfc += 2795 E1000_READ_REG(&adapter->hw, TSCTFC); 2796 } 2797 ifp = &adapter->interface_data.ac_if; 2798 2799 /* Fill out the OS statistics structure */ 2800 ifp->if_ipackets = adapter->stats.gprc; 2801 ifp->if_opackets = adapter->stats.gptc; 2802 ifp->if_ibytes = adapter->stats.gorcl; 2803 ifp->if_obytes = adapter->stats.gotcl; 2804 ifp->if_imcasts = adapter->stats.mprc; 2805 ifp->if_collisions = adapter->stats.colc; 2806 2807 /* Rx Errors */ 2808 ifp->if_ierrors = 2809 adapter->dropped_pkts + 2810 adapter->stats.rxerrc + 2811 adapter->stats.crcerrs + 2812 adapter->stats.algnerrc + 2813 adapter->stats.rlec + adapter->stats.rnbc + 2814 adapter->stats.mpc + adapter->stats.cexterr; 2815 2816 /* Tx Errors */ 2817 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 2818 2819} 2820 2821 2822/********************************************************************** 2823 * 2824 * This routine is called only when em_display_debug_stats is enabled. 2825 * This routine provides a way to take a look at important statistics 2826 * maintained by the driver and hardware. 2827 * 2828 **********************************************************************/ 2829static void 2830em_print_hw_stats(struct adapter *adapter) 2831{ 2832 int unit = adapter->unit; 2833 2834#ifdef DBG_STATS 2835 printf("em%d: Packets not Avail = %ld\n", unit, 2836 adapter->no_pkts_avail); 2837 printf("em%d: CleanTxInterrupts = %ld\n", unit, 2838 adapter->clean_tx_interrupts); 2839#endif 2840 2841 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 2842 (long long)adapter->tx_fifo_wrk, 2843 (long long)adapter->tx_fifo_reset); 2844 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 2845 E1000_READ_REG(&adapter->hw, TDH), 2846 E1000_READ_REG(&adapter->hw, TDT)); 2847 printf("em%d: Excessive collisions = %lld\n", unit, 2848 (long long)adapter->stats.ecol); 2849 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 2850 adapter->no_tx_desc_avail1); 2851 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 2852 adapter->no_tx_desc_avail2); 2853 2854 printf("em%d: Symbol errors = %lld\n", unit, 2855 (long long)adapter->stats.symerrs); 2856 printf("em%d: Sequence errors = %lld\n", unit, 2857 (long long)adapter->stats.sec); 2858 printf("em%d: Defer count = %lld\n", unit, 2859 (long long)adapter->stats.dc); 2860 2861 printf("em%d: Missed Packets = %lld\n", unit, 2862 (long long)adapter->stats.mpc); 2863 printf("em%d: Receive No Buffers = %lld\n", unit, 2864 (long long)adapter->stats.rnbc); 2865 printf("em%d: Receive length errors = %lld\n", unit, 2866 (long long)adapter->stats.rlec); 2867 printf("em%d: Receive errors = %lld\n", unit, 2868 (long long)adapter->stats.rxerrc); 2869 printf("em%d: Crc errors = %lld\n", unit, 2870 (long long)adapter->stats.crcerrs); 2871 printf("em%d: Alignment errors = %lld\n", unit, 2872 (long long)adapter->stats.algnerrc); 2873 printf("em%d: Carrier extension errors = %lld\n", unit, 2874 (long long)adapter->stats.cexterr); 2875 printf("em%d: Driver dropped packets = %ld\n", unit, 2876 adapter->dropped_pkts); 2877 2878 printf("em%d: XON Rcvd = %lld\n", unit, 2879 (long long)adapter->stats.xonrxc); 2880 printf("em%d: XON Xmtd = %lld\n", unit, 2881 (long long)adapter->stats.xontxc); 2882 printf("em%d: XOFF Rcvd = %lld\n", unit, 2883 (long long)adapter->stats.xoffrxc); 2884 printf("em%d: XOFF Xmtd = %lld\n", unit, 2885 (long long)adapter->stats.xofftxc); 2886 2887 printf("em%d: Good Packets Rcvd = %lld\n", unit, 2888 (long long)adapter->stats.gprc); 2889 printf("em%d: Good Packets Xmtd = %lld\n", unit, 2890 (long long)adapter->stats.gptc); 2891 2892 return; 2893} 2894 2895