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