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