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