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