if_em.c revision 106937
1/************************************************************************** 2 3Copyright (c) 2001-2002, 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 106937 2002-11-14 23:54:55Z sam $*/ 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.4.7"; 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 *********************************************************************/ 66static em_vendor_info_t em_vendor_info_array[] = 67{ 68 /* Intel(R) PRO/1000 Network Connection */ 69 { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0}, 70 { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0}, 71 { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0}, 72 { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0}, 73 { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0}, 74 { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0}, 75 { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0}, 76 { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0}, 77 { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0}, 78 { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0}, 79 { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0}, 80 { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0}, 81 { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0}, 82 { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0}, 83 { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0}, 84 { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0}, 85 /* required last entry */ 86 { 0, 0, 0, 0, 0} 87}; 88 89/********************************************************************* 90 * Table of branding strings for all supported NICs. 91 *********************************************************************/ 92 93static char *em_strings[] = { 94 "Intel(R) PRO/1000 Network Connection" 95}; 96 97/********************************************************************* 98 * Function prototypes 99 *********************************************************************/ 100static int em_probe(device_t); 101static int em_attach(device_t); 102static int em_detach(device_t); 103static int em_shutdown(device_t); 104static void em_intr(void *); 105static void em_start(struct ifnet *); 106static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t); 107static void em_watchdog(struct ifnet *); 108static void em_init(void *); 109static void em_stop(void *); 110static void em_media_status(struct ifnet *, struct ifmediareq *); 111static int em_media_change(struct ifnet *); 112static void em_identify_hardware(struct adapter *); 113static int em_allocate_pci_resources(struct adapter *); 114static void em_free_pci_resources(struct adapter *); 115static void em_local_timer(void *); 116static int em_hardware_init(struct adapter *); 117static void em_setup_interface(device_t, struct adapter *); 118static int em_setup_transmit_structures(struct adapter *); 119static void em_initialize_transmit_unit(struct adapter *); 120static int em_setup_receive_structures(struct adapter *); 121static void em_initialize_receive_unit(struct adapter *); 122static void em_enable_intr(struct adapter *); 123static void em_disable_intr(struct adapter *); 124static void em_free_transmit_structures(struct adapter *); 125static void em_free_receive_structures(struct adapter *); 126static void em_update_stats_counters(struct adapter *); 127static void em_clean_transmit_interrupts(struct adapter *); 128static int em_allocate_receive_structures(struct adapter *); 129static int em_allocate_transmit_structures(struct adapter *); 130static void em_process_receive_interrupts(struct adapter *); 131static void em_receive_checksum(struct adapter *, 132 struct em_rx_desc * rx_desc, 133 struct mbuf *); 134static void em_transmit_checksum_setup(struct adapter *, 135 struct mbuf *, 136 u_int32_t *, 137 u_int32_t *); 138static void em_set_promisc(struct adapter *); 139static void em_disable_promisc(struct adapter *); 140static void em_set_multi(struct adapter *); 141static void em_print_hw_stats(struct adapter *); 142static void em_print_link_status(struct adapter *); 143static int em_get_buf(struct em_rx_buffer *, struct adapter *, 144 struct mbuf *); 145static void em_enable_vlans(struct adapter *adapter); 146static int em_encap(struct adapter *adapter, struct mbuf *m_head); 147 148/********************************************************************* 149 * FreeBSD Device Interface Entry Points 150 *********************************************************************/ 151 152static device_method_t em_methods[] = { 153 /* Device interface */ 154 DEVMETHOD(device_probe, em_probe), 155 DEVMETHOD(device_attach, em_attach), 156 DEVMETHOD(device_detach, em_detach), 157 DEVMETHOD(device_shutdown, em_shutdown), 158 {0, 0} 159}; 160 161static driver_t em_driver = { 162 "em", em_methods, sizeof(struct adapter ), 163}; 164 165static devclass_t em_devclass; 166DRIVER_MODULE(if_em, pci, em_driver, em_devclass, 0, 0); 167 168/********************************************************************* 169 * Device identification routine 170 * 171 * em_probe determines if the driver should be loaded on 172 * adapter based on PCI vendor/device id of the adapter. 173 * 174 * return 0 on success, positive on failure 175 *********************************************************************/ 176 177static int 178em_probe(device_t dev) 179{ 180 em_vendor_info_t *ent; 181 182 u_int16_t pci_vendor_id = 0; 183 u_int16_t pci_device_id = 0; 184 u_int16_t pci_subvendor_id = 0; 185 u_int16_t pci_subdevice_id = 0; 186 char adapter_name[60]; 187 188 INIT_DEBUGOUT("em_probe: begin"); 189 190 pci_vendor_id = pci_get_vendor(dev); 191 if (pci_vendor_id != EM_VENDOR_ID) 192 return(ENXIO); 193 194 pci_device_id = pci_get_device(dev); 195 pci_subvendor_id = pci_get_subvendor(dev); 196 pci_subdevice_id = pci_get_subdevice(dev); 197 198 ent = em_vendor_info_array; 199 while (ent->vendor_id != 0) { 200 if ((pci_vendor_id == ent->vendor_id) && 201 (pci_device_id == ent->device_id) && 202 203 ((pci_subvendor_id == ent->subvendor_id) || 204 (ent->subvendor_id == PCI_ANY_ID)) && 205 206 ((pci_subdevice_id == ent->subdevice_id) || 207 (ent->subdevice_id == PCI_ANY_ID))) { 208 sprintf(adapter_name, "%s, Version - %s", 209 em_strings[ent->index], 210 em_driver_version); 211 device_set_desc_copy(dev, adapter_name); 212 return(0); 213 } 214 ent++; 215 } 216 217 return(ENXIO); 218} 219 220/********************************************************************* 221 * Device initialization routine 222 * 223 * The attach entry point is called when the driver is being loaded. 224 * This routine identifies the type of hardware, allocates all resources 225 * and initializes the hardware. 226 * 227 * return 0 on success, positive on failure 228 *********************************************************************/ 229 230static int 231em_attach(device_t dev) 232{ 233 struct adapter * adapter; 234 int s; 235 int tsize, rsize; 236 237 INIT_DEBUGOUT("em_attach: begin"); 238 s = splimp(); 239 240 /* Allocate, clear, and link in our adapter structure */ 241 if (!(adapter = device_get_softc(dev))) { 242 printf("em: adapter structure allocation failed\n"); 243 splx(s); 244 return(ENOMEM); 245 } 246 bzero(adapter, sizeof(struct adapter )); 247 adapter->dev = dev; 248 adapter->osdep.dev = dev; 249 adapter->unit = device_get_unit(dev); 250 251 if (em_adapter_list != NULL) 252 em_adapter_list->prev = adapter; 253 adapter->next = em_adapter_list; 254 em_adapter_list = adapter; 255 256 callout_handle_init(&adapter->timer_handle); 257 258 /* Determine hardware revision */ 259 em_identify_hardware(adapter); 260 261 /* Parameters (to be read from user) */ 262 adapter->num_tx_desc = EM_MAX_TXD; 263 adapter->num_rx_desc = EM_MAX_RXD; 264 adapter->tx_int_delay = EM_TIDV; 265 adapter->rx_int_delay = EM_RDTR; 266 adapter->hw.autoneg = DO_AUTO_NEG; 267 adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; 268 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 269 adapter->hw.tbi_compatibility_en = TRUE; 270 adapter->rx_buffer_len = EM_RXBUFFER_2048; 271 272 adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH; 273 adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH; 274 adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER; 275 adapter->hw.fc_send_xon = TRUE; 276 adapter->hw.fc = em_fc_full; 277 278 /* Set the max frame size assuming standard ethernet sized frames */ 279 adapter->hw.max_frame_size = 280 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 281 282 adapter->hw.min_frame_size = 283 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; 284 285 /* This controls when hardware reports transmit completion status. */ 286 if ((EM_REPORT_TX_EARLY == 0) || (EM_REPORT_TX_EARLY == 1)) { 287 adapter->hw.report_tx_early = EM_REPORT_TX_EARLY; 288 } else { 289 if (adapter->hw.mac_type < em_82543) { 290 adapter->hw.report_tx_early = 0; 291 } else { 292 adapter->hw.report_tx_early = 1; 293 } 294 } 295 296 if (em_allocate_pci_resources(adapter)) { 297 printf("em%d: Allocation of PCI resources failed\n", 298 adapter->unit); 299 em_free_pci_resources(adapter); 300 splx(s); 301 return(ENXIO); 302 } 303 304 tsize = EM_ROUNDUP(adapter->num_tx_desc * 305 sizeof(struct em_tx_desc), 4096); 306 307 /* Allocate Transmit Descriptor ring */ 308 if (!(adapter->tx_desc_base = (struct em_tx_desc *) 309 contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 310 printf("em%d: Unable to allocate TxDescriptor memory\n", 311 adapter->unit); 312 em_free_pci_resources(adapter); 313 splx(s); 314 return(ENOMEM); 315 } 316 317 rsize = EM_ROUNDUP(adapter->num_rx_desc * 318 sizeof(struct em_rx_desc), 4096); 319 320 /* Allocate Receive Descriptor ring */ 321 if (!(adapter->rx_desc_base = (struct em_rx_desc *) 322 contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 323 printf("em%d: Unable to allocate rx_desc memory\n", 324 adapter->unit); 325 em_free_pci_resources(adapter); 326 contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 327 splx(s); 328 return(ENOMEM); 329 } 330 331 /* Initialize the hardware */ 332 if (em_hardware_init(adapter)) { 333 printf("em%d: Unable to initialize the hardware\n", 334 adapter->unit); 335 em_free_pci_resources(adapter); 336 contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 337 contigfree(adapter->rx_desc_base, rsize, M_DEVBUF); 338 splx(s); 339 return(EIO); 340 } 341 342 /* Copy the permanent MAC address out of the EEPROM */ 343 if (em_read_mac_addr(&adapter->hw) < 0) { 344 printf("em%d: EEPROM read error while reading mac address\n", 345 adapter->unit); 346 return(EIO); 347 } 348 349 memcpy(adapter->interface_data.ac_enaddr, adapter->hw.mac_addr, 350 ETH_LENGTH_OF_ADDRESS); 351 352 /* Setup OS specific network interface */ 353 em_setup_interface(dev, adapter); 354 355 /* Initialize statistics */ 356 em_clear_hw_cntrs(&adapter->hw); 357 em_update_stats_counters(adapter); 358 adapter->hw.get_link_status = 1; 359 em_check_for_link(&adapter->hw); 360 361 /* Print the link status */ 362 if (adapter->link_active == 1) { 363 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 364 &adapter->link_duplex); 365 printf("em%d: Speed:%d Mbps Duplex:%s\n", 366 adapter->unit, 367 adapter->link_speed, 368 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 369 } else 370 printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); 371 372 373 INIT_DEBUGOUT("em_attach: end"); 374 splx(s); 375 return(0); 376} 377 378/********************************************************************* 379 * Device removal routine 380 * 381 * The detach entry point is called when the driver is being removed. 382 * This routine stops the adapter and deallocates all the resources 383 * that were allocated for driver operation. 384 * 385 * return 0 on success, positive on failure 386 *********************************************************************/ 387 388static int 389em_detach(device_t dev) 390{ 391 struct adapter * adapter = device_get_softc(dev); 392 struct ifnet *ifp = &adapter->interface_data.ac_if; 393 int s; 394 int size; 395 396 INIT_DEBUGOUT("em_detach: begin"); 397 s = splimp(); 398 399 em_stop(adapter); 400 em_phy_hw_reset(&adapter->hw); 401 ether_ifdetach(&adapter->interface_data.ac_if); 402 em_free_pci_resources(adapter); 403 404 size = EM_ROUNDUP(adapter->num_tx_desc * 405 sizeof(struct em_tx_desc), 4096); 406 407 /* Free Transmit Descriptor ring */ 408 if (adapter->tx_desc_base) { 409 contigfree(adapter->tx_desc_base, size, M_DEVBUF); 410 adapter->tx_desc_base = NULL; 411 } 412 413 size = EM_ROUNDUP(adapter->num_rx_desc * 414 sizeof(struct em_rx_desc), 4096); 415 416 /* Free Receive Descriptor ring */ 417 if (adapter->rx_desc_base) { 418 contigfree(adapter->rx_desc_base, size, M_DEVBUF); 419 adapter->rx_desc_base = NULL; 420 } 421 422 /* Remove from the adapter list */ 423 if (em_adapter_list == adapter) 424 em_adapter_list = adapter->next; 425 if (adapter->next != NULL) 426 adapter->next->prev = adapter->prev; 427 if (adapter->prev != NULL) 428 adapter->prev->next = adapter->next; 429 430 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 431 ifp->if_timer = 0; 432 433 splx(s); 434 return(0); 435} 436 437/********************************************************************* 438 * 439 * Shutdown entry point 440 * 441 **********************************************************************/ 442 443static int 444em_shutdown(device_t dev) 445{ 446 struct adapter *adapter = device_get_softc(dev); 447 em_stop(adapter); 448 return(0); 449} 450 451/********************************************************************* 452 * Transmit entry point 453 * 454 * em_start is called by the stack to initiate a transmit. 455 * The driver will remain in this routine as long as there are 456 * packets to transmit and transmit resources are available. 457 * In case resources are not available stack is notified and 458 * the packet is requeued. 459 **********************************************************************/ 460 461static void 462em_start(struct ifnet *ifp) 463{ 464 int s; 465 struct mbuf *m_head; 466 struct adapter *adapter = ifp->if_softc; 467 468 if (!adapter->link_active) 469 return; 470 471 s = splimp(); 472 while (ifp->if_snd.ifq_head != NULL) { 473 474 IF_DEQUEUE(&ifp->if_snd, m_head); 475 476 if (m_head == NULL) break; 477 478 if (em_encap(adapter, m_head)) { 479 ifp->if_flags |= IFF_OACTIVE; 480 IF_PREPEND(&ifp->if_snd, m_head); 481 break; 482 } 483 484 /* Send a copy of the frame to the BPF listener */ 485 BPF_MTAP(ifp, m_head); 486 487 /* Set timeout in case hardware has problems transmitting */ 488 ifp->if_timer = EM_TX_TIMEOUT; 489 490 } 491 splx(s); 492 return; 493} 494 495/********************************************************************* 496 * Ioctl entry point 497 * 498 * em_ioctl is called when the user wants to configure the 499 * interface. 500 * 501 * return 0 on success, positive on failure 502 **********************************************************************/ 503 504static int 505em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) 506{ 507 int s, mask, error = 0; 508 struct ifreq *ifr = (struct ifreq *) data; 509 struct adapter * adapter = ifp->if_softc; 510 511 s = splimp(); 512 switch (command) { 513 case SIOCSIFADDR: 514 case SIOCGIFADDR: 515 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 516 ether_ioctl(ifp, command, data); 517 break; 518 case SIOCSIFMTU: 519 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 520 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) { 521 error = EINVAL; 522 } else { 523 ifp->if_mtu = ifr->ifr_mtu; 524 adapter->hw.max_frame_size = 525 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 526 em_init(adapter); 527 } 528 break; 529 case SIOCSIFFLAGS: 530 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 531 if (ifp->if_flags & IFF_UP) { 532 if (ifp->if_flags & IFF_RUNNING && 533 ifp->if_flags & IFF_PROMISC) { 534 em_set_promisc(adapter); 535 } else if (ifp->if_flags & IFF_RUNNING && 536 !(ifp->if_flags & IFF_PROMISC)) { 537 em_disable_promisc(adapter); 538 } else 539 em_init(adapter); 540 } else { 541 if (ifp->if_flags & IFF_RUNNING) { 542 em_stop(adapter); 543 } 544 } 545 break; 546 case SIOCADDMULTI: 547 case SIOCDELMULTI: 548 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 549 if (ifp->if_flags & IFF_RUNNING) { 550 em_disable_intr(adapter); 551 em_set_multi(adapter); 552 if (adapter->hw.mac_type == em_82542_rev2_0) 553 em_initialize_receive_unit(adapter); 554 em_enable_intr(adapter); 555 } 556 break; 557 case SIOCSIFMEDIA: 558 case SIOCGIFMEDIA: 559 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 560 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 561 break; 562 case SIOCSIFCAP: 563 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 564 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 565 if (mask & IFCAP_HWCSUM) { 566 if (IFCAP_HWCSUM & ifp->if_capenable) 567 ifp->if_capenable &= ~IFCAP_HWCSUM; 568 else 569 ifp->if_capenable |= IFCAP_HWCSUM; 570 if (ifp->if_flags & IFF_RUNNING) 571 em_init(adapter); 572 } 573 break; 574 default: 575 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command); 576 error = EINVAL; 577 } 578 579 splx(s); 580 return(error); 581} 582 583/********************************************************************* 584 * Watchdog entry point 585 * 586 * This routine is called whenever hardware quits transmitting. 587 * 588 **********************************************************************/ 589 590static void 591em_watchdog(struct ifnet *ifp) 592{ 593 struct adapter * adapter; 594 adapter = ifp->if_softc; 595 596 /* If we are in this routine because of pause frames, then 597 * don't reset the hardware. 598 */ 599 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { 600 ifp->if_timer = EM_TX_TIMEOUT; 601 return; 602 } 603 604 printf("em%d: watchdog timeout -- resetting\n", adapter->unit); 605 606 ifp->if_flags &= ~IFF_RUNNING; 607 608 em_stop(adapter); 609 em_init(adapter); 610 611 ifp->if_oerrors++; 612 return; 613} 614 615/********************************************************************* 616 * Init entry point 617 * 618 * This routine is used in two ways. It is used by the stack as 619 * init entry point in network interface structure. It is also used 620 * by the driver as a hw/sw initialization routine to get to a 621 * consistent state. 622 * 623 * return 0 on success, positive on failure 624 **********************************************************************/ 625 626static void 627em_init(void *arg) 628{ 629 int s; 630 struct ifnet *ifp; 631 struct adapter * adapter = arg; 632 633 INIT_DEBUGOUT("em_init: begin"); 634 635 s = splimp(); 636 637 em_stop(adapter); 638 639 /* Initialize the hardware */ 640 if (em_hardware_init(adapter)) { 641 printf("em%d: Unable to initialize the hardware\n", 642 adapter->unit); 643 splx(s); 644 return; 645 } 646 647 em_enable_vlans(adapter); 648 649 /* Prepare transmit descriptors and buffers */ 650 if (em_setup_transmit_structures(adapter)) { 651 printf("em%d: Could not setup transmit structures\n", 652 adapter->unit); 653 em_stop(adapter); 654 splx(s); 655 return; 656 } 657 em_initialize_transmit_unit(adapter); 658 659 /* Setup Multicast table */ 660 em_set_multi(adapter); 661 662 /* Prepare receive descriptors and buffers */ 663 if (em_setup_receive_structures(adapter)) { 664 printf("em%d: Could not setup receive structures\n", 665 adapter->unit); 666 em_stop(adapter); 667 splx(s); 668 return; 669 } 670 em_initialize_receive_unit(adapter); 671 672 ifp = &adapter->interface_data.ac_if; 673 ifp->if_flags |= IFF_RUNNING; 674 ifp->if_flags &= ~IFF_OACTIVE; 675 676 if (adapter->hw.mac_type >= em_82543) { 677 if (ifp->if_capenable & IFCAP_TXCSUM) 678 ifp->if_hwassist = EM_CHECKSUM_FEATURES; 679 else 680 ifp->if_hwassist = 0; 681 } 682 683 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 684 em_clear_hw_cntrs(&adapter->hw); 685 em_enable_intr(adapter); 686 687 splx(s); 688 return; 689} 690 691/********************************************************************* 692 * 693 * Interrupt Service routine 694 * 695 **********************************************************************/ 696 697static void 698em_intr(void *arg) 699{ 700 u_int32_t loop_cnt = EM_MAX_INTR; 701 u_int32_t reg_icr; 702 struct ifnet *ifp; 703 struct adapter *adapter = arg; 704 705 ifp = &adapter->interface_data.ac_if; 706 707 em_disable_intr(adapter); 708 while (loop_cnt > 0 && 709 (reg_icr = E1000_READ_REG(&adapter->hw, ICR)) != 0) { 710 711 /* Link status change */ 712 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 713 untimeout(em_local_timer, adapter, 714 adapter->timer_handle); 715 adapter->hw.get_link_status = 1; 716 em_check_for_link(&adapter->hw); 717 em_print_link_status(adapter); 718 adapter->timer_handle = 719 timeout(em_local_timer, adapter, 2*hz); 720 } 721 722 if (ifp->if_flags & IFF_RUNNING) { 723 em_process_receive_interrupts(adapter); 724 em_clean_transmit_interrupts(adapter); 725 } 726 loop_cnt--; 727 } 728 729 em_enable_intr(adapter); 730 731 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 732 em_start(ifp); 733 734 return; 735} 736 737 738/********************************************************************* 739 * 740 * Media Ioctl callback 741 * 742 * This routine is called whenever the user queries the status of 743 * the interface using ifconfig. 744 * 745 **********************************************************************/ 746static void 747em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 748{ 749 struct adapter * adapter = ifp->if_softc; 750 751 INIT_DEBUGOUT("em_media_status: begin"); 752 753 em_check_for_link(&adapter->hw); 754 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 755 if (adapter->link_active == 0) { 756 em_get_speed_and_duplex(&adapter->hw, 757 &adapter->link_speed, 758 &adapter->link_duplex); 759 adapter->link_active = 1; 760 } 761 } else { 762 if (adapter->link_active == 1) { 763 adapter->link_speed = 0; 764 adapter->link_duplex = 0; 765 adapter->link_active = 0; 766 } 767 } 768 769 ifmr->ifm_status = IFM_AVALID; 770 ifmr->ifm_active = IFM_ETHER; 771 772 if (!adapter->link_active) 773 return; 774 775 ifmr->ifm_status |= IFM_ACTIVE; 776 777 if (adapter->hw.media_type == em_media_type_fiber) { 778 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 779 } else { 780 switch (adapter->link_speed) { 781 case 10: 782 ifmr->ifm_active |= IFM_10_T; 783 break; 784 case 100: 785 ifmr->ifm_active |= IFM_100_TX; 786 break; 787 case 1000: 788#if __FreeBSD_version < 500000 789 ifmr->ifm_active |= IFM_1000_TX; 790#else 791 ifmr->ifm_active |= IFM_1000_T; 792#endif 793 break; 794 } 795 if (adapter->link_duplex == FULL_DUPLEX) 796 ifmr->ifm_active |= IFM_FDX; 797 else 798 ifmr->ifm_active |= IFM_HDX; 799 } 800 return; 801} 802 803/********************************************************************* 804 * 805 * Media Ioctl callback 806 * 807 * This routine is called when the user changes speed/duplex using 808 * media/mediopt option with ifconfig. 809 * 810 **********************************************************************/ 811static int 812em_media_change(struct ifnet *ifp) 813{ 814 struct adapter * adapter = ifp->if_softc; 815 struct ifmedia *ifm = &adapter->media; 816 817 INIT_DEBUGOUT("em_media_change: begin"); 818 819 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 820 return(EINVAL); 821 822 switch (IFM_SUBTYPE(ifm->ifm_media)) { 823 case IFM_AUTO: 824 adapter->hw.autoneg = DO_AUTO_NEG; 825 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 826 break; 827 case IFM_1000_SX: 828#if __FreeBSD_version < 500000 829 case IFM_1000_TX: 830#else 831 case IFM_1000_T: 832#endif 833 adapter->hw.autoneg = DO_AUTO_NEG; 834 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 835 break; 836 case IFM_100_TX: 837 adapter->hw.autoneg = FALSE; 838 adapter->hw.autoneg_advertised = 0; 839 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 840 adapter->hw.forced_speed_duplex = em_100_full; 841 else 842 adapter->hw.forced_speed_duplex = em_100_half; 843 break; 844 case IFM_10_T: 845 adapter->hw.autoneg = FALSE; 846 adapter->hw.autoneg_advertised = 0; 847 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 848 adapter->hw.forced_speed_duplex = em_10_full; 849 else 850 adapter->hw.forced_speed_duplex = em_10_half; 851 break; 852 default: 853 printf("em%d: Unsupported media type\n", adapter->unit); 854 } 855 856 em_init(adapter); 857 858 return(0); 859} 860 861 862/********************************************************************* 863 * 864 * This routine maps the mbufs to tx descriptors. 865 * 866 * return 0 on success, positive on failure 867 **********************************************************************/ 868 869static int 870em_encap(struct adapter *adapter, struct mbuf *m_head) 871{ 872 vm_offset_t virtual_addr; 873 u_int32_t txd_upper; 874 u_int32_t txd_lower; 875 u_int16_t txd_used, count; 876 877 struct mbuf *mp; 878 struct em_tx_buffer *tx_buffer; 879 struct em_tx_desc *saved_tx_desc = NULL; 880 struct em_tx_desc *current_tx_desc = NULL; 881 struct ifnet *ifp = &adapter->interface_data.ac_if; 882 struct m_tag *mtag; 883 884 /* Force a cleanup if number of descriptors available hit the threshold */ 885 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) 886 em_clean_transmit_interrupts(adapter); 887 888 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 889 adapter->no_tx_desc_avail1++; 890 return (ENOBUFS); 891 } 892 893 /* Find out number of fragments in a mbuf chain */ 894 count = 0; 895 for (mp = m_head; mp != NULL; mp = mp->m_next) { 896 if (mp->m_len == 0) 897 continue; 898 count++; 899 } 900 901 /* Bail out if we don't have enough descriptors */ 902 if (adapter->num_tx_desc_avail <= count) { 903 em_clean_transmit_interrupts(adapter); 904 adapter->no_tx_desc_avail2++; 905 return (ENOBUFS); 906 } 907 908 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list); 909 if (!tx_buffer) { 910 adapter->no_tx_buffer_avail1++; 911 return (ENOBUFS); 912 } 913 914 /* Setup checksum context */ 915 if (ifp->if_hwassist > 0) { 916 em_transmit_checksum_setup(adapter, m_head, 917 &txd_upper, &txd_lower); 918 } else { 919 txd_upper = 0; 920 txd_lower = 0; 921 } 922 923 /* Find out if we are in vlan mode */ 924 mtag = VLAN_OUTPUT_TAG(ifp, m_head); 925 926 txd_used = 0; 927 saved_tx_desc = adapter->next_avail_tx_desc; 928 for (mp = m_head; mp != NULL; mp = mp->m_next) { 929 if (mp->m_len == 0) 930 continue; 931 932 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list); 933 if (!tx_buffer) { 934 adapter->no_tx_buffer_avail2++; 935 adapter->next_avail_tx_desc = saved_tx_desc; 936 return (ENOBUFS); 937 } 938 939 current_tx_desc = adapter->next_avail_tx_desc; 940 virtual_addr = mtod(mp, vm_offset_t); 941 current_tx_desc->buffer_addr = vtophys(virtual_addr); 942 943 current_tx_desc->lower.data = (adapter->txd_cmd | txd_lower | mp->m_len); 944 current_tx_desc->upper.data = (txd_upper); 945 946 if (current_tx_desc == adapter->last_tx_desc) 947 adapter->next_avail_tx_desc = 948 adapter->first_tx_desc; 949 else 950 adapter->next_avail_tx_desc++; 951 952 txd_used++; 953 954 tx_buffer->m_head = NULL; 955 tx_buffer->used_tx_desc = current_tx_desc; 956 STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry); 957 STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer, 958 em_tx_entry); 959 } 960 adapter->num_tx_desc_avail-= txd_used; 961 962 if (mtag != NULL) { 963 /* Tell hardware to add tag */ 964 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE; 965 966 /* Set the vlan id */ 967 current_tx_desc->upper.fields.special = VLAN_TAG_VALUE(mtag); 968 } 969 970 /* Last Descriptor of Packet needs End Of Packet (EOP) bit set. */ 971 current_tx_desc->lower.data |= E1000_TXD_CMD_EOP; 972 973 /* Save mbuf chain so that we can free it during transmit cleanup */ 974 tx_buffer->m_head = m_head; 975 976 /* 977 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 978 * that this frame is available to transmit. 979 */ 980 E1000_WRITE_REG(&adapter->hw, TDT, 981 (((uintptr_t) adapter->next_avail_tx_desc - 982 (uintptr_t) adapter->first_tx_desc) >> 4)); 983 984 return(0); 985} 986 987 988static void 989em_set_promisc(struct adapter * adapter) 990{ 991 992 u_int32_t reg_rctl; 993 struct ifnet *ifp = &adapter->interface_data.ac_if; 994 995 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 996 997 if (ifp->if_flags & IFF_PROMISC) { 998 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 999 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1000 } else if (ifp->if_flags & IFF_ALLMULTI) { 1001 reg_rctl |= E1000_RCTL_MPE; 1002 reg_rctl &= ~E1000_RCTL_UPE; 1003 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1004 } 1005 1006 return; 1007} 1008 1009static void 1010em_disable_promisc(struct adapter * adapter) 1011{ 1012 u_int32_t reg_rctl; 1013 1014 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1015 1016 reg_rctl &= (~E1000_RCTL_UPE); 1017 reg_rctl &= (~E1000_RCTL_MPE); 1018 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1019 1020 return; 1021} 1022 1023 1024/********************************************************************* 1025 * Multicast Update 1026 * 1027 * This routine is called whenever multicast address list is updated. 1028 * 1029 **********************************************************************/ 1030 1031static void 1032em_set_multi(struct adapter * adapter) 1033{ 1034 u_int32_t reg_rctl = 0; 1035 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; 1036 struct ifmultiaddr *ifma; 1037 int mcnt = 0; 1038 struct ifnet *ifp = &adapter->interface_data.ac_if; 1039 1040 IOCTL_DEBUGOUT("em_set_multi: begin"); 1041 1042 if (adapter->hw.mac_type == em_82542_rev2_0) { 1043 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1044 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1045 em_pci_clear_mwi(&adapter->hw); 1046 } 1047 reg_rctl |= E1000_RCTL_RST; 1048 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1049 msec_delay(5); 1050 } 1051 1052#if __FreeBSD_version < 500000 1053 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1054#else 1055 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1056#endif 1057 if (ifma->ifma_addr->sa_family != AF_LINK) 1058 continue; 1059 1060 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1061 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 1062 mcnt++; 1063 } 1064 1065 if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) { 1066 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1067 reg_rctl |= E1000_RCTL_MPE; 1068 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1069 } else 1070 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0); 1071 1072 if (adapter->hw.mac_type == em_82542_rev2_0) { 1073 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1074 reg_rctl &= ~E1000_RCTL_RST; 1075 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1076 msec_delay(5); 1077 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1078 em_pci_set_mwi(&adapter->hw); 1079 } 1080 } 1081 1082 return; 1083} 1084 1085 1086/********************************************************************* 1087 * Timer routine 1088 * 1089 * This routine checks for link status and updates statistics. 1090 * 1091 **********************************************************************/ 1092 1093static void 1094em_local_timer(void *arg) 1095{ 1096 int s; 1097 struct ifnet *ifp; 1098 struct adapter * adapter = arg; 1099 ifp = &adapter->interface_data.ac_if; 1100 1101 s = splimp(); 1102 1103 em_check_for_link(&adapter->hw); 1104 em_print_link_status(adapter); 1105 em_update_stats_counters(adapter); 1106 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 1107 em_print_hw_stats(adapter); 1108 } 1109 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 1110 1111 splx(s); 1112 return; 1113} 1114 1115static void 1116em_print_link_status(struct adapter * adapter) 1117{ 1118 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1119 if (adapter->link_active == 0) { 1120 em_get_speed_and_duplex(&adapter->hw, 1121 &adapter->link_speed, 1122 &adapter->link_duplex); 1123 printf("em%d: Link is up %d Mbps %s\n", 1124 adapter->unit, 1125 adapter->link_speed, 1126 ((adapter->link_duplex == FULL_DUPLEX) ? 1127 "Full Duplex" : "Half Duplex")); 1128 adapter->link_active = 1; 1129 } 1130 } else { 1131 if (adapter->link_active == 1) { 1132 adapter->link_speed = 0; 1133 adapter->link_duplex = 0; 1134 printf("em%d: Link is Down\n", adapter->unit); 1135 adapter->link_active = 0; 1136 } 1137 } 1138 1139 return; 1140} 1141 1142 1143/********************************************************************* 1144 * 1145 * This routine disables all traffic on the adapter by issuing a 1146 * global reset on the MAC and deallocates TX/RX buffers. 1147 * 1148 **********************************************************************/ 1149 1150static void 1151em_stop(void *arg) 1152{ 1153 struct ifnet *ifp; 1154 struct adapter * adapter = arg; 1155 ifp = &adapter->interface_data.ac_if; 1156 1157 INIT_DEBUGOUT("em_stop: begin\n"); 1158 em_disable_intr(adapter); 1159 em_reset_hw(&adapter->hw); 1160 untimeout(em_local_timer, adapter, adapter->timer_handle); 1161 em_free_transmit_structures(adapter); 1162 em_free_receive_structures(adapter); 1163 1164 1165 /* Tell the stack that the interface is no longer active */ 1166 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1167 1168 return; 1169} 1170 1171 1172/********************************************************************* 1173 * 1174 * Determine hardware revision. 1175 * 1176 **********************************************************************/ 1177static void 1178em_identify_hardware(struct adapter * adapter) 1179{ 1180 device_t dev = adapter->dev; 1181 1182 /* Make sure our PCI config space has the necessary stuff set */ 1183 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1184 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1185 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1186 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1187 adapter->unit); 1188 adapter->hw.pci_cmd_word |= 1189 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1190 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1191 } 1192 1193 /* Save off the information about this board */ 1194 adapter->hw.vendor_id = pci_get_vendor(dev); 1195 adapter->hw.device_id = pci_get_device(dev); 1196 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1197 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1198 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1199 1200 /* Identify the MAC */ 1201 if (em_set_mac_type(&adapter->hw)) 1202 printf("em%d: Unknown MAC Type\n", adapter->unit); 1203 1204 return; 1205} 1206 1207static int 1208em_allocate_pci_resources(struct adapter * adapter) 1209{ 1210 int i, val, rid; 1211 device_t dev = adapter->dev; 1212 1213 rid = EM_MMBA; 1214 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, 1215 &rid, 0, ~0, 1, 1216 RF_ACTIVE); 1217 if (!(adapter->res_memory)) { 1218 printf("em%d: Unable to allocate bus resource: memory\n", 1219 adapter->unit); 1220 return(ENXIO); 1221 } 1222 adapter->osdep.mem_bus_space_tag = 1223 rman_get_bustag(adapter->res_memory); 1224 adapter->osdep.mem_bus_space_handle = 1225 rman_get_bushandle(adapter->res_memory); 1226 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1227 1228 1229 if (adapter->hw.mac_type > em_82543) { 1230 /* Figure our where our IO BAR is ? */ 1231 rid = EM_MMBA; 1232 for (i = 0; i < 5; i++) { 1233 val = pci_read_config(dev, rid, 4); 1234 if (val & 0x00000001) { 1235 adapter->io_rid = rid; 1236 break; 1237 } 1238 rid += 4; 1239 } 1240 1241 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT, 1242 &adapter->io_rid, 0, ~0, 1, 1243 RF_ACTIVE); 1244 if (!(adapter->res_ioport)) { 1245 printf("em%d: Unable to allocate bus resource: ioport\n", 1246 adapter->unit); 1247 return(ENXIO); 1248 } 1249 1250 adapter->hw.io_base = 1251 rman_get_start(adapter->res_ioport); 1252 } 1253 1254 rid = 0x0; 1255 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, 1256 &rid, 0, ~0, 1, 1257 RF_SHAREABLE | RF_ACTIVE); 1258 if (!(adapter->res_interrupt)) { 1259 printf("em%d: Unable to allocate bus resource: interrupt\n", 1260 adapter->unit); 1261 return(ENXIO); 1262 } 1263 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET, 1264 (void (*)(void *)) em_intr, adapter, 1265 &adapter->int_handler_tag)) { 1266 printf("em%d: Error registering interrupt handler!\n", 1267 adapter->unit); 1268 return(ENXIO); 1269 } 1270 1271 adapter->hw.back = &adapter->osdep; 1272 1273 return(0); 1274} 1275 1276static void 1277em_free_pci_resources(struct adapter * adapter) 1278{ 1279 device_t dev = adapter->dev; 1280 1281 if (adapter->res_interrupt != NULL) { 1282 bus_teardown_intr(dev, adapter->res_interrupt, 1283 adapter->int_handler_tag); 1284 bus_release_resource(dev, SYS_RES_IRQ, 0, 1285 adapter->res_interrupt); 1286 } 1287 if (adapter->res_memory != NULL) { 1288 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1289 adapter->res_memory); 1290 } 1291 1292 if (adapter->res_ioport != NULL) { 1293 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1294 adapter->res_ioport); 1295 } 1296 return; 1297} 1298 1299/********************************************************************* 1300 * 1301 * Initialize the hardware to a configuration as specified by the 1302 * adapter structure. The controller is reset, the EEPROM is 1303 * verified, the MAC address is set, then the shared initialization 1304 * routines are called. 1305 * 1306 **********************************************************************/ 1307static int 1308em_hardware_init(struct adapter * adapter) 1309{ 1310 /* Issue a global reset */ 1311 em_reset_hw(&adapter->hw); 1312 1313 /* Make sure we have a good EEPROM before we read from it */ 1314 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1315 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1316 adapter->unit); 1317 return(EIO); 1318 } 1319 1320 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1321 printf("em%d: EEPROM read error while reading part number\n", 1322 adapter->unit); 1323 return(EIO); 1324 } 1325 1326 if (em_init_hw(&adapter->hw) < 0) { 1327 printf("em%d: Hardware Initialization Failed", 1328 adapter->unit); 1329 return(EIO); 1330 } 1331 1332 em_check_for_link(&adapter->hw); 1333 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1334 adapter->link_active = 1; 1335 else 1336 adapter->link_active = 0; 1337 1338 if (adapter->link_active) { 1339 em_get_speed_and_duplex(&adapter->hw, 1340 &adapter->link_speed, 1341 &adapter->link_duplex); 1342 } else { 1343 adapter->link_speed = 0; 1344 adapter->link_duplex = 0; 1345 } 1346 1347 return(0); 1348} 1349 1350/********************************************************************* 1351 * 1352 * Setup networking device structure and register an interface. 1353 * 1354 **********************************************************************/ 1355static void 1356em_setup_interface(device_t dev, struct adapter * adapter) 1357{ 1358 struct ifnet *ifp; 1359 INIT_DEBUGOUT("em_setup_interface: begin"); 1360 1361 ifp = &adapter->interface_data.ac_if; 1362 ifp->if_unit = adapter->unit; 1363 ifp->if_name = "em"; 1364 ifp->if_mtu = ETHERMTU; 1365 ifp->if_output = ether_output; 1366 ifp->if_baudrate = 1000000000; 1367 ifp->if_init = em_init; 1368 ifp->if_softc = adapter; 1369 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1370 ifp->if_ioctl = em_ioctl; 1371 ifp->if_start = em_start; 1372 ifp->if_watchdog = em_watchdog; 1373 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1374 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1375 1376 if (adapter->hw.mac_type >= em_82543) { 1377 ifp->if_capabilities = IFCAP_HWCSUM; 1378 ifp->if_capenable = ifp->if_capabilities; 1379 } 1380 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1381 1382 /* 1383 * Specify the media types supported by this adapter and register 1384 * callbacks to update media and link information 1385 */ 1386 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1387 em_media_status); 1388 if (adapter->hw.media_type == em_media_type_fiber) { 1389 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1390 0, NULL); 1391 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1392 0, NULL); 1393 } else { 1394 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1395 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1396 0, NULL); 1397 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1398 0, NULL); 1399 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1400 0, NULL); 1401#if __FreeBSD_version < 500000 1402 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1403 0, NULL); 1404 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1405#else 1406 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1407 0, NULL); 1408 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1409#endif 1410 } 1411 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1412 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1413 1414 return; 1415} 1416 1417 1418/********************************************************************* 1419 * 1420 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1421 * the information needed to transmit a packet on the wire. 1422 * 1423 **********************************************************************/ 1424static int 1425em_allocate_transmit_structures(struct adapter * adapter) 1426{ 1427 if (!(adapter->tx_buffer_area = 1428 (struct em_tx_buffer *) malloc(sizeof(struct em_tx_buffer) * 1429 adapter->num_tx_desc, M_DEVBUF, 1430 M_NOWAIT))) { 1431 printf("em%d: Unable to allocate tx_buffer memory\n", 1432 adapter->unit); 1433 return ENOMEM; 1434 } 1435 1436 bzero(adapter->tx_buffer_area, 1437 sizeof(struct em_tx_buffer) * adapter->num_tx_desc); 1438 1439 return 0; 1440} 1441 1442/********************************************************************* 1443 * 1444 * Allocate and initialize transmit structures. 1445 * 1446 **********************************************************************/ 1447static int 1448em_setup_transmit_structures(struct adapter * adapter) 1449{ 1450 struct em_tx_buffer *tx_buffer; 1451 int i; 1452 1453 if (em_allocate_transmit_structures(adapter)) 1454 return ENOMEM; 1455 1456 adapter->first_tx_desc = adapter->tx_desc_base; 1457 adapter->last_tx_desc = 1458 adapter->first_tx_desc + (adapter->num_tx_desc - 1); 1459 1460 1461 STAILQ_INIT(&adapter->free_tx_buffer_list); 1462 STAILQ_INIT(&adapter->used_tx_buffer_list); 1463 1464 tx_buffer = adapter->tx_buffer_area; 1465 1466 /* Setup the linked list of the tx_buffer's */ 1467 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1468 bzero((void *) tx_buffer, sizeof(struct em_tx_buffer)); 1469 STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, 1470 tx_buffer, em_tx_entry); 1471 } 1472 1473 bzero((void *) adapter->first_tx_desc, 1474 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 1475 1476 /* Setup TX descriptor pointers */ 1477 adapter->next_avail_tx_desc = adapter->first_tx_desc; 1478 1479 /* Set number of descriptors available */ 1480 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1481 1482 /* Set checksum context */ 1483 adapter->active_checksum_context = OFFLOAD_NONE; 1484 1485 return 0; 1486} 1487 1488/********************************************************************* 1489 * 1490 * Enable transmit unit. 1491 * 1492 **********************************************************************/ 1493static void 1494em_initialize_transmit_unit(struct adapter * adapter) 1495{ 1496 u_int32_t reg_tctl; 1497 u_int32_t reg_tipg = 0; 1498 1499 /* Setup the Base and Length of the Tx Descriptor Ring */ 1500 E1000_WRITE_REG(&adapter->hw, TDBAL, 1501 vtophys((vm_offset_t) adapter->tx_desc_base)); 1502 E1000_WRITE_REG(&adapter->hw, TDBAH, 0); 1503 E1000_WRITE_REG(&adapter->hw, TDLEN, 1504 adapter->num_tx_desc * 1505 sizeof(struct em_tx_desc)); 1506 1507 /* Setup the HW Tx Head and Tail descriptor pointers */ 1508 E1000_WRITE_REG(&adapter->hw, TDH, 0); 1509 E1000_WRITE_REG(&adapter->hw, TDT, 0); 1510 1511 1512 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1513 E1000_READ_REG(&adapter->hw, TDBAL), 1514 E1000_READ_REG(&adapter->hw, TDLEN)); 1515 1516 1517 /* Set the default values for the Tx Inter Packet Gap timer */ 1518 switch (adapter->hw.mac_type) { 1519 case em_82543: 1520 case em_82544: 1521 case em_82540: 1522 case em_82545: 1523 case em_82546: 1524 if (adapter->hw.media_type == em_media_type_fiber) 1525 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1526 else 1527 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1528 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1529 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1530 break; 1531 case em_82542_rev2_0: 1532 case em_82542_rev2_1: 1533 reg_tipg = DEFAULT_82542_TIPG_IPGT; 1534 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1535 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1536 break; 1537 default: 1538 printf("em%d: Invalid mac type detected\n", adapter->unit); 1539 } 1540 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 1541 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1542 1543 /* Program the Transmit Control Register */ 1544 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 1545 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1546 if (adapter->link_duplex == 1) { 1547 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1548 } else { 1549 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1550 } 1551 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1552 1553 /* Setup Transmit Descriptor Settings for this adapter */ 1554 adapter->txd_cmd = E1000_TXD_CMD_IFCS; 1555 1556 if (adapter->tx_int_delay > 0) 1557 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1558 1559 if (adapter->hw.report_tx_early == 1) 1560 adapter->txd_cmd |= E1000_TXD_CMD_RS; 1561 else 1562 adapter->txd_cmd |= E1000_TXD_CMD_RPS; 1563 1564 return; 1565} 1566 1567/********************************************************************* 1568 * 1569 * Free all transmit related data structures. 1570 * 1571 **********************************************************************/ 1572static void 1573em_free_transmit_structures(struct adapter * adapter) 1574{ 1575 struct em_tx_buffer *tx_buffer; 1576 int i; 1577 1578 INIT_DEBUGOUT("free_transmit_structures: begin"); 1579 1580 if (adapter->tx_buffer_area != NULL) { 1581 tx_buffer = adapter->tx_buffer_area; 1582 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1583 if (tx_buffer->m_head != NULL) 1584 m_freem(tx_buffer->m_head); 1585 tx_buffer->m_head = NULL; 1586 } 1587 } 1588 if (adapter->tx_buffer_area != NULL) { 1589 free(adapter->tx_buffer_area, M_DEVBUF); 1590 adapter->tx_buffer_area = NULL; 1591 } 1592 return; 1593} 1594 1595/********************************************************************* 1596 * 1597 * The offload context needs to be set when we transfer the first 1598 * packet of a particular protocol (TCP/UDP). We change the 1599 * context only if the protocol type changes. 1600 * 1601 **********************************************************************/ 1602static void 1603em_transmit_checksum_setup(struct adapter *adapter, 1604 struct mbuf *mp, 1605 u_int32_t *txd_upper, 1606 u_int32_t *txd_lower) 1607{ 1608 struct em_context_desc *TXD; 1609 struct em_tx_desc * current_tx_desc; 1610 struct em_tx_buffer *tx_buffer; 1611 1612 if (mp->m_pkthdr.csum_flags) { 1613 1614 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1615 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1616 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1617 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1618 return; 1619 else 1620 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1621 1622 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1623 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1624 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1625 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1626 return; 1627 else 1628 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1629 } else { 1630 *txd_upper = 0; 1631 *txd_lower = 0; 1632 return; 1633 } 1634 } else { 1635 *txd_upper = 0; 1636 *txd_lower = 0; 1637 return; 1638 } 1639 1640 /* If we reach this point, the checksum offload context 1641 * needs to be reset. 1642 */ 1643 current_tx_desc = adapter->next_avail_tx_desc; 1644 tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list); 1645 1646 TXD = (struct em_context_desc *)current_tx_desc; 1647 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 1648 TXD->lower_setup.ip_fields.ipcso = 1649 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 1650 TXD->lower_setup.ip_fields.ipcse = 1651 ETHER_HDR_LEN + sizeof(struct ip) - 1; 1652 1653 TXD->upper_setup.tcp_fields.tucss = 1654 ETHER_HDR_LEN + sizeof(struct ip); 1655 TXD->upper_setup.tcp_fields.tucse = 0; 1656 1657 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1658 TXD->upper_setup.tcp_fields.tucso = 1659 ETHER_HDR_LEN + sizeof(struct ip) + 1660 offsetof(struct tcphdr, th_sum); 1661 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1662 TXD->upper_setup.tcp_fields.tucso = 1663 ETHER_HDR_LEN + sizeof(struct ip) + 1664 offsetof(struct udphdr, uh_sum); 1665 } 1666 1667 TXD->tcp_seg_setup.data = 0; 1668 TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT); 1669 1670 if (current_tx_desc == adapter->last_tx_desc) 1671 adapter->next_avail_tx_desc = adapter->first_tx_desc; 1672 else 1673 adapter->next_avail_tx_desc++; 1674 1675 adapter->num_tx_desc_avail--; 1676 1677 tx_buffer->used_tx_desc = current_tx_desc; 1678 STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry); 1679 STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer, em_tx_entry); 1680 return; 1681} 1682 1683/********************************************************************** 1684 * 1685 * Examine each tx_buffer in the used queue. If the hardware is done 1686 * processing the packet then free associated resources. The 1687 * tx_buffer is put back on the free queue. 1688 * 1689 **********************************************************************/ 1690static void 1691em_clean_transmit_interrupts(struct adapter * adapter) 1692{ 1693 struct em_tx_buffer *tx_buffer; 1694 struct em_tx_desc *tx_desc; 1695 int s; 1696 struct ifnet *ifp; 1697 1698 s = splimp(); 1699#ifdef DBG_STATS 1700 adapter->clean_tx_interrupts++; 1701#endif 1702 1703 for (tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list); 1704 tx_buffer; 1705 tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list)) { 1706 1707 /* 1708 * Get hold of the next descriptor that the hardware will report status 1709 * back to. There is 1/1 correspondence between a tx descriptor 1710 * and tx_buffer. 1711 */ 1712 1713 tx_desc = tx_buffer->used_tx_desc; 1714 1715 /* 1716 * If the descriptor done bit is set, free tx_buffer and associated 1717 * resources 1718 */ 1719 if (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 1720 1721 tx_desc->upper.data = 0; 1722 adapter->num_tx_desc_avail++; 1723 1724 if (tx_buffer->m_head) { 1725 m_freem(tx_buffer->m_head); 1726 tx_buffer->m_head = NULL; 1727 } 1728 1729 STAILQ_REMOVE_HEAD(&adapter->used_tx_buffer_list, 1730 em_tx_entry); 1731 /* Return this tx_buffer back to the "free" list */ 1732 STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, 1733 tx_buffer, em_tx_entry); 1734 } else { 1735 /* 1736 * Found a tx_buffer that the em is not done with then there is 1737 * no reason to check the rest of the queue. 1738 */ 1739 break; 1740 } 1741 } /* end for each tx_buffer */ 1742 1743 ifp = &adapter->interface_data.ac_if; 1744 1745 /* Tell the stack that it is OK to send packets */ 1746 if (adapter->num_tx_desc_avail > EM_TX_CLEANUP_THRESHOLD) { 1747 ifp->if_timer = 0; 1748 ifp->if_flags &= ~IFF_OACTIVE; 1749 } 1750 splx(s); 1751 return; 1752} 1753 1754 1755/********************************************************************* 1756 * 1757 * Get a buffer from system mbuf buffer pool. 1758 * 1759 **********************************************************************/ 1760static int 1761em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *adapter, 1762 struct mbuf *mp) 1763{ 1764 struct mbuf *nmp; 1765 struct ifnet *ifp; 1766 1767 ifp = &adapter->interface_data.ac_if; 1768 1769 if (mp == NULL) { 1770 MGETHDR(nmp, M_DONTWAIT, MT_DATA); 1771 if (nmp == NULL) { 1772 adapter->mbuf_alloc_failed++; 1773 return(ENOBUFS); 1774 } 1775 MCLGET(nmp, M_DONTWAIT); 1776 if ((nmp->m_flags & M_EXT) == 0) { 1777 m_freem(nmp); 1778 adapter->mbuf_cluster_failed++; 1779 return(ENOBUFS); 1780 } 1781 nmp->m_len = nmp->m_pkthdr.len = MCLBYTES; 1782 } else { 1783 nmp = mp; 1784 nmp->m_len = nmp->m_pkthdr.len = MCLBYTES; 1785 nmp->m_data = nmp->m_ext.ext_buf; 1786 nmp->m_next = NULL; 1787 } 1788 1789 if (ifp->if_mtu <= ETHERMTU) { 1790 m_adj(nmp, ETHER_ALIGN); 1791 } 1792 1793 rx_buffer->m_head = nmp; 1794 rx_buffer->buffer_addr = vtophys(mtod(nmp, vm_offset_t)); 1795 1796 return(0); 1797} 1798 1799/********************************************************************* 1800 * 1801 * Allocate memory for rx_buffer structures. Since we use one 1802 * rx_buffer per received packet, the maximum number of rx_buffer's 1803 * that we'll need is equal to the number of receive descriptors 1804 * that we've allocated. 1805 * 1806 **********************************************************************/ 1807static int 1808em_allocate_receive_structures(struct adapter * adapter) 1809{ 1810 int i; 1811 struct em_rx_buffer *rx_buffer; 1812 1813 if (!(adapter->rx_buffer_area = 1814 (struct em_rx_buffer *) malloc(sizeof(struct em_rx_buffer) * 1815 adapter->num_rx_desc, M_DEVBUF, 1816 M_NOWAIT))) { 1817 printf("em%d: Unable to allocate rx_buffer memory\n", 1818 adapter->unit); 1819 return(ENOMEM); 1820 } 1821 1822 bzero(adapter->rx_buffer_area, 1823 sizeof(struct em_rx_buffer) * adapter->num_rx_desc); 1824 1825 for (i = 0, rx_buffer = adapter->rx_buffer_area; 1826 i < adapter->num_rx_desc; i++, rx_buffer++) { 1827 1828 if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) { 1829 rx_buffer->m_head = NULL; 1830 return(ENOBUFS); 1831 } 1832 } 1833 1834 return(0); 1835} 1836 1837/********************************************************************* 1838 * 1839 * Allocate and initialize receive structures. 1840 * 1841 **********************************************************************/ 1842static int 1843em_setup_receive_structures(struct adapter * adapter) 1844{ 1845 struct em_rx_buffer *rx_buffer; 1846 struct em_rx_desc *rx_desc; 1847 int i; 1848 1849 if (em_allocate_receive_structures(adapter)) 1850 return ENOMEM; 1851 1852 STAILQ_INIT(&adapter->rx_buffer_list); 1853 1854 adapter->first_rx_desc = 1855 (struct em_rx_desc *) adapter->rx_desc_base; 1856 adapter->last_rx_desc = 1857 adapter->first_rx_desc + (adapter->num_rx_desc - 1); 1858 1859 rx_buffer = (struct em_rx_buffer *) adapter->rx_buffer_area; 1860 1861 bzero((void *) adapter->first_rx_desc, 1862 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 1863 1864 /* Build a linked list of rx_buffer's */ 1865 for (i = 0, rx_desc = adapter->first_rx_desc; 1866 i < adapter->num_rx_desc; 1867 i++, rx_buffer++, rx_desc++) { 1868 if (rx_buffer->m_head == NULL) 1869 printf("em%d: Receive buffer memory not allocated", 1870 adapter->unit); 1871 else { 1872 rx_desc->buffer_addr = rx_buffer->buffer_addr; 1873 STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, 1874 rx_buffer, em_rx_entry); 1875 } 1876 } 1877 1878 /* Setup our descriptor pointers */ 1879 adapter->next_rx_desc_to_check = adapter->first_rx_desc; 1880 1881 return(0); 1882} 1883 1884/********************************************************************* 1885 * 1886 * Enable receive unit. 1887 * 1888 **********************************************************************/ 1889static void 1890em_initialize_receive_unit(struct adapter * adapter) 1891{ 1892 u_int32_t reg_rctl; 1893 u_int32_t reg_rxcsum; 1894 struct ifnet *ifp; 1895 1896 ifp = &adapter->interface_data.ac_if; 1897 1898 /* Make sure receives are disabled while setting up the descriptor ring */ 1899 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 1900 1901 /* Set the Receive Delay Timer Register */ 1902 E1000_WRITE_REG(&adapter->hw, RDTR, 1903 adapter->rx_int_delay | E1000_RDT_FPDB); 1904 1905 /* Setup the Base and Length of the Rx Descriptor Ring */ 1906 E1000_WRITE_REG(&adapter->hw, RDBAL, 1907 vtophys((vm_offset_t) adapter->rx_desc_base)); 1908 E1000_WRITE_REG(&adapter->hw, RDBAH, 0); 1909 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 1910 sizeof(struct em_rx_desc)); 1911 1912 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 1913 E1000_WRITE_REG(&adapter->hw, RDH, 0); 1914 E1000_WRITE_REG(&adapter->hw, RDT, 1915 (((uintptr_t) adapter->last_rx_desc - 1916 (uintptr_t) adapter->first_rx_desc) >> 4)); 1917 1918 /* Setup the Receive Control Register */ 1919 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 1920 E1000_RCTL_RDMTS_HALF | 1921 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 1922 1923 if (adapter->hw.tbi_compatibility_on == TRUE) 1924 reg_rctl |= E1000_RCTL_SBP; 1925 1926 1927 switch (adapter->rx_buffer_len) { 1928 default: 1929 case EM_RXBUFFER_2048: 1930 reg_rctl |= E1000_RCTL_SZ_2048; 1931 break; 1932 case EM_RXBUFFER_4096: 1933 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1934 break; 1935 case EM_RXBUFFER_8192: 1936 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1937 break; 1938 case EM_RXBUFFER_16384: 1939 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1940 break; 1941 } 1942 1943 if (ifp->if_mtu > ETHERMTU) 1944 reg_rctl |= E1000_RCTL_LPE; 1945 1946 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 1947 if ((adapter->hw.mac_type >= em_82543) && 1948 (ifp->if_capenable & IFCAP_RXCSUM)) { 1949 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 1950 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 1951 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 1952 } 1953 1954 /* Enable Receives */ 1955 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1956 1957 return; 1958} 1959 1960/********************************************************************* 1961 * 1962 * Free receive related data structures. 1963 * 1964 **********************************************************************/ 1965static void 1966em_free_receive_structures(struct adapter * adapter) 1967{ 1968 struct em_rx_buffer *rx_buffer; 1969 int i; 1970 1971 INIT_DEBUGOUT("free_receive_structures: begin"); 1972 1973 if (adapter->rx_buffer_area != NULL) { 1974 rx_buffer = adapter->rx_buffer_area; 1975 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 1976 if (rx_buffer->m_head != NULL) 1977 m_freem(rx_buffer->m_head); 1978 rx_buffer->m_head = NULL; 1979 } 1980 } 1981 if (adapter->rx_buffer_area != NULL) { 1982 free(adapter->rx_buffer_area, M_DEVBUF); 1983 adapter->rx_buffer_area = NULL; 1984 } 1985 return; 1986} 1987 1988/********************************************************************* 1989 * 1990 * This routine executes in interrupt context. It replenishes 1991 * the mbufs in the descriptor and sends data which has been 1992 * dma'ed into host memory to upper layer. 1993 * 1994 *********************************************************************/ 1995static void 1996em_process_receive_interrupts(struct adapter * adapter) 1997{ 1998 struct mbuf *mp; 1999 struct ifnet *ifp; 2000 u_int16_t len; 2001 u_int8_t last_byte; 2002 u_int8_t accept_frame = 0; 2003 u_int8_t eop = 0; 2004 u_int32_t pkt_len = 0; 2005 2006 /* Pointer to the receive descriptor being examined. */ 2007 struct em_rx_desc *current_desc; 2008 struct em_rx_desc *last_desc_processed; 2009 struct em_rx_buffer *rx_buffer; 2010 2011 ifp = &adapter->interface_data.ac_if; 2012 current_desc = adapter->next_rx_desc_to_check; 2013 2014 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2015#ifdef DBG_STATS 2016 adapter->no_pkts_avail++; 2017#endif 2018 return; 2019 } 2020 2021 while (current_desc->status & E1000_RXD_STAT_DD) { 2022 2023 /* Get a pointer to the actual receive buffer */ 2024 rx_buffer = STAILQ_FIRST(&adapter->rx_buffer_list); 2025 2026 if (rx_buffer == NULL) { 2027 printf("em%d: Found null rx_buffer\n", adapter->unit); 2028 return; 2029 } 2030 2031 mp = rx_buffer->m_head; 2032 accept_frame = 1; 2033 2034 if (current_desc->status & E1000_RXD_STAT_EOP) { 2035 eop = 1; 2036 len = current_desc->length - ETHER_CRC_LEN; 2037 } else { 2038 eop = 0; 2039 len = current_desc->length; 2040 } 2041 2042 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2043 2044 /* Compute packet length for tbi_accept macro */ 2045 pkt_len = current_desc->length; 2046 if (adapter->fmp != NULL) { 2047 pkt_len += adapter->fmp->m_pkthdr.len; 2048 } 2049 2050 last_byte = *(mtod(rx_buffer->m_head,caddr_t) + 2051 current_desc->length - 1); 2052 2053 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2054 current_desc->errors, 2055 pkt_len, last_byte)) { 2056 em_tbi_adjust_stats(&adapter->hw, 2057 &adapter->stats, 2058 pkt_len, 2059 adapter->hw.mac_addr); 2060 len--; 2061 } else { 2062 accept_frame = 0; 2063 } 2064 } 2065 2066 if (accept_frame) { 2067 2068 if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) { 2069 adapter->dropped_pkts++; 2070 em_get_buf(rx_buffer, adapter, mp); 2071 if (adapter->fmp != NULL) m_freem(adapter->fmp); 2072 adapter->fmp = NULL; 2073 adapter->lmp = NULL; 2074 break; 2075 } 2076 2077 /* Assign correct length to the current fragment */ 2078 mp->m_len = len; 2079 2080 if (adapter->fmp == NULL) { 2081 mp->m_pkthdr.len = len; 2082 adapter->fmp = mp; /* Store the first mbuf */ 2083 adapter->lmp = mp; 2084 } else { 2085 /* Chain mbuf's together */ 2086 mp->m_flags &= ~M_PKTHDR; 2087 adapter->lmp->m_next = mp; 2088 adapter->lmp = adapter->lmp->m_next; 2089 adapter->fmp->m_pkthdr.len += len; 2090 } 2091 2092 if (eop) { 2093 adapter->fmp->m_pkthdr.rcvif = ifp; 2094 em_receive_checksum(adapter, current_desc, 2095 adapter->fmp); 2096 if (current_desc->status & E1000_RXD_STAT_VP) 2097 VLAN_INPUT_TAG(ifp, adapter->fmp, 2098 current_desc->special, 2099 adapter->fmp = NULL); 2100 if (adapter->fmp != NULL) 2101 (*ifp->if_input)(ifp, adapter->fmp); 2102 2103 adapter->fmp = NULL; 2104 adapter->lmp = NULL; 2105 } 2106 } else { 2107 adapter->dropped_pkts++; 2108 em_get_buf(rx_buffer, adapter, mp); 2109 if (adapter->fmp != NULL) m_freem(adapter->fmp); 2110 adapter->fmp = NULL; 2111 adapter->lmp = NULL; 2112 } 2113 2114 /* Zero out the receive descriptors status */ 2115 current_desc->status = 0; 2116 2117 if (rx_buffer->m_head != NULL) { 2118 current_desc->buffer_addr = rx_buffer->buffer_addr; 2119 } 2120 2121 /* Advance our pointers to the next descriptor (checking for wrap). */ 2122 if (current_desc == adapter->last_rx_desc) 2123 adapter->next_rx_desc_to_check = adapter->first_rx_desc; 2124 else 2125 ((adapter)->next_rx_desc_to_check)++; 2126 2127 last_desc_processed = current_desc; 2128 current_desc = adapter->next_rx_desc_to_check; 2129 /* 2130 * Put the buffer that we just indicated back at the end of our list 2131 */ 2132 STAILQ_REMOVE_HEAD(&adapter->rx_buffer_list, em_rx_entry); 2133 STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, 2134 rx_buffer, em_rx_entry); 2135 2136 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2137 E1000_WRITE_REG(&adapter->hw, RDT, 2138 (((u_long) last_desc_processed - 2139 (u_long) adapter->first_rx_desc) >> 4)); 2140 } 2141 return; 2142} 2143 2144/********************************************************************* 2145 * 2146 * Verify that the hardware indicated that the checksum is valid. 2147 * Inform the stack about the status of checksum so that stack 2148 * doesn't spend time verifying the checksum. 2149 * 2150 *********************************************************************/ 2151static void 2152em_receive_checksum(struct adapter *adapter, 2153 struct em_rx_desc *rx_desc, 2154 struct mbuf *mp) 2155{ 2156 /* 82543 or newer only */ 2157 if ((adapter->hw.mac_type < em_82543) || 2158 /* Ignore Checksum bit is set */ 2159 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2160 mp->m_pkthdr.csum_flags = 0; 2161 return; 2162 } 2163 2164 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2165 /* Did it pass? */ 2166 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2167 /* IP Checksum Good */ 2168 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2169 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2170 2171 } else { 2172 mp->m_pkthdr.csum_flags = 0; 2173 } 2174 } 2175 2176 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2177 /* Did it pass? */ 2178 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2179 mp->m_pkthdr.csum_flags |= 2180 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2181 mp->m_pkthdr.csum_data = htons(0xffff); 2182 } 2183 } 2184 2185 return; 2186} 2187 2188 2189static void em_enable_vlans(struct adapter *adapter) 2190{ 2191 uint32_t ctrl; 2192 2193 E1000_WRITE_REG(&adapter->hw, VET, QTAG_TYPE); 2194 2195 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2196 ctrl |= E1000_CTRL_VME; 2197 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2198 2199 return; 2200} 2201 2202static void 2203em_enable_intr(struct adapter * adapter) 2204{ 2205 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2206 return; 2207} 2208 2209static void 2210em_disable_intr(struct adapter *adapter) 2211{ 2212 E1000_WRITE_REG(&adapter->hw, IMC, 2213 (0xffffffff & ~E1000_IMC_RXSEQ)); 2214 return; 2215} 2216 2217void 2218em_write_pci_cfg(struct em_hw *hw, 2219 uint32_t reg, 2220 uint16_t *value) 2221{ 2222 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2223 *value, 2); 2224} 2225 2226void 2227em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2228 uint16_t *value) 2229{ 2230 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2231 reg, 2); 2232 return; 2233} 2234 2235 2236void 2237em_pci_set_mwi(struct em_hw *hw) 2238{ 2239 pci_write_config(((struct em_osdep *)hw->back)->dev, 2240 PCIR_COMMAND, 2241 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 2242 return; 2243} 2244 2245void 2246em_pci_clear_mwi(struct em_hw *hw) 2247{ 2248 pci_write_config(((struct em_osdep *)hw->back)->dev, 2249 PCIR_COMMAND, 2250 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 2251 return; 2252} 2253 2254uint32_t 2255em_io_read(struct em_hw *hw, uint32_t port) 2256{ 2257 return(inl(port)); 2258} 2259 2260void 2261em_io_write(struct em_hw *hw, uint32_t port, uint32_t value) 2262{ 2263 outl(port, value); 2264 return; 2265} 2266 2267 2268/********************************************************************** 2269 * 2270 * Update the board statistics counters. 2271 * 2272 **********************************************************************/ 2273static void 2274em_update_stats_counters(struct adapter *adapter) 2275{ 2276 struct ifnet *ifp; 2277 2278 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 2279 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 2280 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 2281 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 2282 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 2283 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 2284 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 2285 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 2286 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 2287 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 2288 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 2289 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 2290 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 2291 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 2292 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 2293 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 2294 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 2295 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 2296 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 2297 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 2298 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 2299 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 2300 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 2301 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 2302 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 2303 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 2304 2305 /* For the 64-bit byte counters the low dword must be read first. */ 2306 /* Both registers clear on the read of the high dword */ 2307 2308 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 2309 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 2310 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 2311 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 2312 2313 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 2314 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 2315 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 2316 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 2317 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 2318 2319 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 2320 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 2321 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 2322 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 2323 2324 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 2325 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 2326 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 2327 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 2328 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 2329 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 2330 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 2331 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 2332 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 2333 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 2334 2335 if (adapter->hw.mac_type >= em_82543) { 2336 adapter->stats.algnerrc += 2337 E1000_READ_REG(&adapter->hw, ALGNERRC); 2338 adapter->stats.rxerrc += 2339 E1000_READ_REG(&adapter->hw, RXERRC); 2340 adapter->stats.tncrs += 2341 E1000_READ_REG(&adapter->hw, TNCRS); 2342 adapter->stats.cexterr += 2343 E1000_READ_REG(&adapter->hw, CEXTERR); 2344 adapter->stats.tsctc += 2345 E1000_READ_REG(&adapter->hw, TSCTC); 2346 adapter->stats.tsctfc += 2347 E1000_READ_REG(&adapter->hw, TSCTFC); 2348 } 2349 ifp = &adapter->interface_data.ac_if; 2350 2351 /* Fill out the OS statistics structure */ 2352 ifp->if_ipackets = adapter->stats.gprc; 2353 ifp->if_opackets = adapter->stats.gptc; 2354 ifp->if_ibytes = adapter->stats.gorcl; 2355 ifp->if_obytes = adapter->stats.gotcl; 2356 ifp->if_imcasts = adapter->stats.mprc; 2357 ifp->if_collisions = adapter->stats.colc; 2358 2359 /* Rx Errors */ 2360 ifp->if_ierrors = 2361 adapter->dropped_pkts + 2362 adapter->stats.rxerrc + 2363 adapter->stats.crcerrs + 2364 adapter->stats.algnerrc + 2365 adapter->stats.rlec + adapter->stats.rnbc + 2366 adapter->stats.mpc + adapter->stats.cexterr; 2367 2368 /* Tx Errors */ 2369 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 2370 2371} 2372 2373 2374/********************************************************************** 2375 * 2376 * This routine is called only when em_display_debug_stats is enabled. 2377 * This routine provides a way to take a look at important statistics 2378 * maintained by the driver and hardware. 2379 * 2380 **********************************************************************/ 2381static void 2382em_print_hw_stats(struct adapter *adapter) 2383{ 2384 int unit = adapter->unit; 2385 2386#ifdef DBG_STATS 2387 printf("em%d: Packets not Avail = %ld\n", unit, 2388 adapter->no_pkts_avail); 2389 printf("em%d: CleanTxInterrupts = %ld\n", unit, 2390 adapter->clean_tx_interrupts); 2391#endif 2392 2393 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 2394 adapter->no_tx_desc_avail1); 2395 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 2396 adapter->no_tx_desc_avail2); 2397 printf("em%d: Tx Buffer not avail1 = %ld\n", unit, 2398 adapter->no_tx_buffer_avail1); 2399 printf("em%d: Tx Buffer not avail2 = %ld\n", unit, 2400 adapter->no_tx_buffer_avail2); 2401 printf("em%d: Std Mbuf Failed = %ld\n",unit, 2402 adapter->mbuf_alloc_failed); 2403 printf("em%d: Std Cluster Failed = %ld\n",unit, 2404 adapter->mbuf_cluster_failed); 2405 printf("em%d: Number of TX desc avail = %d\n", unit, 2406 adapter->num_tx_desc_avail); 2407 2408 printf("em%d: Symbol errors = %lld\n", unit, 2409 (long long)adapter->stats.symerrs); 2410 printf("em%d: Sequence errors = %lld\n", unit, 2411 (long long)adapter->stats.sec); 2412 printf("em%d: Defer count = %lld\n", unit, 2413 (long long)adapter->stats.dc); 2414 2415 printf("em%d: Missed Packets = %lld\n", unit, 2416 (long long)adapter->stats.mpc); 2417 printf("em%d: Receive No Buffers = %lld\n", unit, 2418 (long long)adapter->stats.rnbc); 2419 printf("em%d: Receive length errors = %lld\n", unit, 2420 (long long)adapter->stats.rlec); 2421 printf("em%d: Receive errors = %lld\n", unit, 2422 (long long)adapter->stats.rxerrc); 2423 printf("em%d: Crc errors = %lld\n", unit, 2424 (long long)adapter->stats.crcerrs); 2425 printf("em%d: Alignment errors = %lld\n", unit, 2426 (long long)adapter->stats.algnerrc); 2427 printf("em%d: Carrier extension errors = %lld\n", unit, 2428 (long long)adapter->stats.cexterr); 2429 printf("em%d: Driver dropped packets = %ld\n", unit, 2430 adapter->dropped_pkts); 2431 2432 printf("em%d: XON Rcvd = %lld\n", unit, 2433 (long long)adapter->stats.xonrxc); 2434 printf("em%d: XON Xmtd = %lld\n", unit, 2435 (long long)adapter->stats.xontxc); 2436 printf("em%d: XOFF Rcvd = %lld\n", unit, 2437 (long long)adapter->stats.xoffrxc); 2438 printf("em%d: XOFF Xmtd = %lld\n", unit, 2439 (long long)adapter->stats.xofftxc); 2440 2441 printf("em%d: Good Packets Rcvd = %lld\n", unit, 2442 (long long)adapter->stats.gprc); 2443 printf("em%d: Good Packets Xmtd = %lld\n", unit, 2444 (long long)adapter->stats.gptc); 2445 2446 return; 2447} 2448 2449