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