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