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.5 2004/01/06 01:40:47 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 if_initname(ifp, "em", adapter->unit); 1639 ifp->if_mtu = ETHERMTU; 1640 ifp->if_output = ether_output; 1641 ifp->if_baudrate = 1000000000; 1642 ifp->if_init = em_init; 1643 ifp->if_softc = adapter; 1644 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1645 ifp->if_ioctl = em_ioctl; 1646 ifp->if_start = em_start; 1647 ifp->if_watchdog = em_watchdog; 1648 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1649 1650 #if __FreeBSD_version < 500000 1651 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1652 #else 1653 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1654 #endif 1655 1656 if (adapter->hw.mac_type >= em_82543) { 1657 ifp->if_capabilities = IFCAP_HWCSUM; 1658 ifp->if_capenable = ifp->if_capabilities; 1659 } 1660 1661 /* 1662 * Tell the upper layer(s) we support long frames. 1663 */ 1664 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1665 #if __FreeBSD_version >= 500000 1666 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1667 #endif 1668 1669 1670 /* 1671 * Specify the media types supported by this adapter and register 1672 * callbacks to update media and link information 1673 */ 1674 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1675 em_media_status); 1676 if (adapter->hw.media_type == em_media_type_fiber) { 1677 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1678 0, NULL); 1679 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1680 0, NULL); 1681 } else { 1682 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1683 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1684 0, NULL); 1685 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1686 0, NULL); 1687 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1688 0, NULL); 1689 #if __FreeBSD_version < 500000 1690 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1691 0, NULL); 1692 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1693 #else 1694 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1695 0, NULL); 1696 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1697 #endif 1698 } 1699 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1700 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1701 1702 return; 1703 } 1704 1705 1706 /********************************************************************* 1707 * 1708 * Workaround for SmartSpeed on 82541 and 82547 controllers 1709 * 1710 **********************************************************************/ 1711 static void 1712 em_smartspeed(struct adapter *adapter) 1713 { 1714 uint16_t phy_tmp; 1715 1716 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 1717 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 1718 return; 1719 1720 if(adapter->smartspeed == 0) { 1721 /* If Master/Slave config fault is asserted twice, 1722 * we assume back-to-back */ 1723 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1724 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 1725 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1726 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 1727 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 1728 &phy_tmp); 1729 if(phy_tmp & CR_1000T_MS_ENABLE) { 1730 phy_tmp &= ~CR_1000T_MS_ENABLE; 1731 em_write_phy_reg(&adapter->hw, 1732 PHY_1000T_CTRL, phy_tmp); 1733 adapter->smartspeed++; 1734 if(adapter->hw.autoneg && 1735 !em_phy_setup_autoneg(&adapter->hw) && 1736 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 1737 &phy_tmp)) { 1738 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1739 MII_CR_RESTART_AUTO_NEG); 1740 em_write_phy_reg(&adapter->hw, 1741 PHY_CTRL, phy_tmp); 1742 } 1743 } 1744 } 1745 return; 1746 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 1747 /* If still no link, perhaps using 2/3 pair cable */ 1748 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 1749 phy_tmp |= CR_1000T_MS_ENABLE; 1750 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 1751 if(adapter->hw.autoneg && 1752 !em_phy_setup_autoneg(&adapter->hw) && 1753 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 1754 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1755 MII_CR_RESTART_AUTO_NEG); 1756 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 1757 } 1758 } 1759 /* Restart process after EM_SMARTSPEED_MAX iterations */ 1760 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 1761 adapter->smartspeed = 0; 1762 1763 return; 1764 } 1765 1766 1767 /********************************************************************* 1768 * 1769 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1770 * the information needed to transmit a packet on the wire. 1771 * 1772 **********************************************************************/ 1773 static int 1774 em_allocate_transmit_structures(struct adapter * adapter) 1775 { 1776 if (!(adapter->tx_buffer_area = 1777 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 1778 adapter->num_tx_desc, M_DEVBUF, 1779 M_NOWAIT))) { 1780 printf("em%d: Unable to allocate tx_buffer memory\n", 1781 adapter->unit); 1782 return ENOMEM; 1783 } 1784 1785 bzero(adapter->tx_buffer_area, 1786 sizeof(struct em_buffer) * adapter->num_tx_desc); 1787 1788 return 0; 1789 } 1790 1791 /********************************************************************* 1792 * 1793 * Allocate and initialize transmit structures. 1794 * 1795 **********************************************************************/ 1796 static int 1797 em_setup_transmit_structures(struct adapter * adapter) 1798 { 1799 if (em_allocate_transmit_structures(adapter)) 1800 return ENOMEM; 1801 1802 bzero((void *) adapter->tx_desc_base, 1803 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 1804 1805 adapter->next_avail_tx_desc = 0; 1806 adapter->oldest_used_tx_desc = 0; 1807 1808 /* Set number of descriptors available */ 1809 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1810 1811 /* Set checksum context */ 1812 adapter->active_checksum_context = OFFLOAD_NONE; 1813 1814 return 0; 1815 } 1816 1817 /********************************************************************* 1818 * 1819 * Enable transmit unit. 1820 * 1821 **********************************************************************/ 1822 static void 1823 em_initialize_transmit_unit(struct adapter * adapter) 1824 { 1825 u_int32_t reg_tctl; 1826 u_int32_t reg_tipg = 0; 1827 u_int64_t tdba = vtophys((vm_offset_t)adapter->tx_desc_base); 1828 1829 /* Setup the Base and Length of the Tx Descriptor Ring */ 1830 E1000_WRITE_REG(&adapter->hw, TDBAL, 1831 (tdba & 0x00000000ffffffffULL)); 1832 E1000_WRITE_REG(&adapter->hw, TDBAH, (tdba >> 32)); 1833 E1000_WRITE_REG(&adapter->hw, TDLEN, 1834 adapter->num_tx_desc * 1835 sizeof(struct em_tx_desc)); 1836 1837 /* Setup the HW Tx Head and Tail descriptor pointers */ 1838 E1000_WRITE_REG(&adapter->hw, TDH, 0); 1839 E1000_WRITE_REG(&adapter->hw, TDT, 0); 1840 1841 1842 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1843 E1000_READ_REG(&adapter->hw, TDBAL), 1844 E1000_READ_REG(&adapter->hw, TDLEN)); 1845 1846 1847 /* Set the default values for the Tx Inter Packet Gap timer */ 1848 switch (adapter->hw.mac_type) { 1849 case em_82542_rev2_0: 1850 case em_82542_rev2_1: 1851 reg_tipg = DEFAULT_82542_TIPG_IPGT; 1852 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1853 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1854 break; 1855 default: 1856 if (adapter->hw.media_type == em_media_type_fiber) 1857 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1858 else 1859 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1860 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1861 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1862 } 1863 1864 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 1865 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1866 if(adapter->hw.mac_type >= em_82540) 1867 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay); 1868 1869 /* Program the Transmit Control Register */ 1870 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 1871 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1872 if (adapter->link_duplex == 1) { 1873 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1874 } else { 1875 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1876 } 1877 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1878 1879 /* Setup Transmit Descriptor Settings for this adapter */ 1880 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 1881 1882 if (adapter->tx_int_delay > 0) 1883 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1884 1885 return; 1886 } 1887 1888 /********************************************************************* 1889 * 1890 * Free all transmit related data structures. 1891 * 1892 **********************************************************************/ 1893 static void 1894 em_free_transmit_structures(struct adapter * adapter) 1895 { 1896 struct em_buffer *tx_buffer; 1897 int i; 1898 1899 INIT_DEBUGOUT("free_transmit_structures: begin"); 1900 1901 if (adapter->tx_buffer_area != NULL) { 1902 tx_buffer = adapter->tx_buffer_area; 1903 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1904 if (tx_buffer->m_head != NULL) 1905 m_freem(tx_buffer->m_head); 1906 tx_buffer->m_head = NULL; 1907 } 1908 } 1909 if (adapter->tx_buffer_area != NULL) { 1910 free(adapter->tx_buffer_area, M_DEVBUF); 1911 adapter->tx_buffer_area = NULL; 1912 } 1913 return; 1914 } 1915 1916 /********************************************************************* 1917 * 1918 * The offload context needs to be set when we transfer the first 1919 * packet of a particular protocol (TCP/UDP). We change the 1920 * context only if the protocol type changes. 1921 * 1922 **********************************************************************/ 1923 static void 1924 em_transmit_checksum_setup(struct adapter * adapter, 1925 struct mbuf *mp, 1926 u_int32_t *txd_upper, 1927 u_int32_t *txd_lower) 1928 { 1929 struct em_context_desc *TXD; 1930 struct em_buffer *tx_buffer; 1931 int curr_txd; 1932 1933 if (mp->m_pkthdr.csum_flags) { 1934 1935 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1936 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1937 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1938 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1939 return; 1940 else 1941 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1942 1943 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1944 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1945 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1946 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1947 return; 1948 else 1949 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1950 } else { 1951 *txd_upper = 0; 1952 *txd_lower = 0; 1953 return; 1954 } 1955 } else { 1956 *txd_upper = 0; 1957 *txd_lower = 0; 1958 return; 1959 } 1960 1961 /* If we reach this point, the checksum offload context 1962 * needs to be reset. 1963 */ 1964 curr_txd = adapter->next_avail_tx_desc; 1965 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 1966 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 1967 1968 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 1969 TXD->lower_setup.ip_fields.ipcso = 1970 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 1971 TXD->lower_setup.ip_fields.ipcse = 1972 ETHER_HDR_LEN + sizeof(struct ip) - 1; 1973 1974 TXD->upper_setup.tcp_fields.tucss = 1975 ETHER_HDR_LEN + sizeof(struct ip); 1976 TXD->upper_setup.tcp_fields.tucse = 0; 1977 1978 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1979 TXD->upper_setup.tcp_fields.tucso = 1980 ETHER_HDR_LEN + sizeof(struct ip) + 1981 offsetof(struct tcphdr, th_sum); 1982 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1983 TXD->upper_setup.tcp_fields.tucso = 1984 ETHER_HDR_LEN + sizeof(struct ip) + 1985 offsetof(struct udphdr, uh_sum); 1986 } 1987 1988 TXD->tcp_seg_setup.data = 0; 1989 TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT); 1990 1991 tx_buffer->m_head = NULL; 1992 1993 if (++curr_txd == adapter->num_tx_desc) 1994 curr_txd = 0; 1995 1996 adapter->num_tx_desc_avail--; 1997 adapter->next_avail_tx_desc = curr_txd; 1998 1999 return; 2000 } 2001 2002 /********************************************************************** 2003 * 2004 * Examine each tx_buffer in the used queue. If the hardware is done 2005 * processing the packet then free associated resources. The 2006 * tx_buffer is put back on the free queue. 2007 * 2008 **********************************************************************/ 2009 static void 2010 em_clean_transmit_interrupts(struct adapter * adapter) 2011 { 2012 int s; 2013 int i, num_avail; 2014 struct em_buffer *tx_buffer; 2015 struct em_tx_desc *tx_desc; 2016 struct ifnet *ifp = &adapter->interface_data.ac_if; 2017 2018 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2019 return; 2020 2021 s = splimp(); 2022 #ifdef DBG_STATS 2023 adapter->clean_tx_interrupts++; 2024 #endif 2025 num_avail = adapter->num_tx_desc_avail; 2026 i = adapter->oldest_used_tx_desc; 2027 2028 tx_buffer = &adapter->tx_buffer_area[i]; 2029 tx_desc = &adapter->tx_desc_base[i]; 2030 2031 while(tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 2032 2033 tx_desc->upper.data = 0; 2034 num_avail++; 2035 2036 if (tx_buffer->m_head) { 2037 ifp->if_opackets++; 2038 m_freem(tx_buffer->m_head); 2039 tx_buffer->m_head = NULL; 2040 } 2041 2042 if (++i == adapter->num_tx_desc) 2043 i = 0; 2044 2045 tx_buffer = &adapter->tx_buffer_area[i]; 2046 tx_desc = &adapter->tx_desc_base[i]; 2047 } 2048 2049 adapter->oldest_used_tx_desc = i; 2050 2051 /* 2052 * If we have enough room, clear IFF_OACTIVE to tell the stack 2053 * that it is OK to send packets. 2054 * If there are no pending descriptors, clear the timeout. Otherwise, 2055 * if some descriptors have been freed, restart the timeout. 2056 */ 2057 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2058 ifp->if_flags &= ~IFF_OACTIVE; 2059 if (num_avail == adapter->num_tx_desc) 2060 ifp->if_timer = 0; 2061 else if (num_avail == adapter->num_tx_desc_avail) 2062 ifp->if_timer = EM_TX_TIMEOUT; 2063 } 2064 adapter->num_tx_desc_avail = num_avail; 2065 splx(s); 2066 return; 2067 } 2068 2069 /********************************************************************* 2070 * 2071 * Get a buffer from system mbuf buffer pool. 2072 * 2073 **********************************************************************/ 2074 static int 2075 em_get_buf(int i, struct adapter *adapter, 2076 struct mbuf *nmp) 2077 { 2078 register struct mbuf *mp = nmp; 2079 struct ifnet *ifp; 2080 2081 ifp = &adapter->interface_data.ac_if; 2082 2083 if (mp == NULL) { 2084 MGETHDR(mp, M_DONTWAIT, MT_DATA); 2085 if (mp == NULL) { 2086 adapter->mbuf_alloc_failed++; 2087 return(ENOBUFS); 2088 } 2089 MCLGET(mp, M_DONTWAIT); 2090 if ((mp->m_flags & M_EXT) == 0) { 2091 m_freem(mp); 2092 adapter->mbuf_cluster_failed++; 2093 return(ENOBUFS); 2094 } 2095 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2096 } else { 2097 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2098 mp->m_data = mp->m_ext.ext_buf; 2099 mp->m_next = NULL; 2100 } 2101 2102 if (ifp->if_mtu <= ETHERMTU) { 2103 m_adj(mp, ETHER_ALIGN); 2104 } 2105 2106 adapter->rx_buffer_area[i].m_head = mp; 2107 adapter->rx_desc_base[i].buffer_addr = 2108 vtophys(mtod(mp, vm_offset_t)); 2109 2110 return(0); 2111 } 2112 2113 /********************************************************************* 2114 * 2115 * Allocate memory for rx_buffer structures. Since we use one 2116 * rx_buffer per received packet, the maximum number of rx_buffer's 2117 * that we'll need is equal to the number of receive descriptors 2118 * that we've allocated. 2119 * 2120 **********************************************************************/ 2121 static int 2122 em_allocate_receive_structures(struct adapter * adapter) 2123 { 2124 int i; 2125 2126 if (!(adapter->rx_buffer_area = 2127 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2128 adapter->num_rx_desc, M_DEVBUF, 2129 M_NOWAIT))) { 2130 printf("em%d: Unable to allocate rx_buffer memory\n", 2131 adapter->unit); 2132 return(ENOMEM); 2133 } 2134 2135 bzero(adapter->rx_buffer_area, 2136 sizeof(struct em_buffer) * adapter->num_rx_desc); 2137 2138 for (i = 0; i < adapter->num_rx_desc; i++) { 2139 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2140 adapter->rx_buffer_area[i].m_head = NULL; 2141 adapter->rx_desc_base[i].buffer_addr = 0; 2142 return(ENOBUFS); 2143 } 2144 } 2145 2146 return(0); 2147 } 2148 2149 /********************************************************************* 2150 * 2151 * Allocate and initialize receive structures. 2152 * 2153 **********************************************************************/ 2154 static int 2155 em_setup_receive_structures(struct adapter * adapter) 2156 { 2157 bzero((void *) adapter->rx_desc_base, 2158 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2159 2160 if (em_allocate_receive_structures(adapter)) 2161 return ENOMEM; 2162 2163 /* Setup our descriptor pointers */ 2164 adapter->next_rx_desc_to_check = 0; 2165 return(0); 2166 } 2167 2168 /********************************************************************* 2169 * 2170 * Enable receive unit. 2171 * 2172 **********************************************************************/ 2173 static void 2174 em_initialize_receive_unit(struct adapter * adapter) 2175 { 2176 u_int32_t reg_rctl; 2177 u_int32_t reg_rxcsum; 2178 struct ifnet *ifp; 2179 u_int64_t rdba = vtophys((vm_offset_t)adapter->rx_desc_base); 2180 2181 ifp = &adapter->interface_data.ac_if; 2182 2183 /* Make sure receives are disabled while setting up the descriptor ring */ 2184 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2185 2186 /* Set the Receive Delay Timer Register */ 2187 E1000_WRITE_REG(&adapter->hw, RDTR, 2188 adapter->rx_int_delay | E1000_RDT_FPDB); 2189 2190 if(adapter->hw.mac_type >= em_82540) { 2191 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay); 2192 2193 /* Set the interrupt throttling rate. Value is calculated 2194 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2195 #define MAX_INTS_PER_SEC 8000 2196 #define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2197 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2198 } 2199 2200 /* Setup the Base and Length of the Rx Descriptor Ring */ 2201 E1000_WRITE_REG(&adapter->hw, RDBAL, 2202 (rdba & 0x00000000ffffffffULL)); 2203 E1000_WRITE_REG(&adapter->hw, RDBAH, (rdba >> 32)); 2204 E1000_WRITE_REG(&adapter->hw, RDLEN, 2205 adapter->num_rx_desc * 2206 sizeof(struct em_rx_desc)); 2207 2208 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2209 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2210 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2211 2212 /* Setup the Receive Control Register */ 2213 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2214 E1000_RCTL_RDMTS_HALF | 2215 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2216 2217 if (adapter->hw.tbi_compatibility_on == TRUE) 2218 reg_rctl |= E1000_RCTL_SBP; 2219 2220 2221 switch (adapter->rx_buffer_len) { 2222 default: 2223 case EM_RXBUFFER_2048: 2224 reg_rctl |= E1000_RCTL_SZ_2048; 2225 break; 2226 case EM_RXBUFFER_4096: 2227 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2228 break; 2229 case EM_RXBUFFER_8192: 2230 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2231 break; 2232 case EM_RXBUFFER_16384: 2233 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2234 break; 2235 } 2236 2237 if (ifp->if_mtu > ETHERMTU) 2238 reg_rctl |= E1000_RCTL_LPE; 2239 2240 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2241 if ((adapter->hw.mac_type >= em_82543) && 2242 (ifp->if_capenable & IFCAP_RXCSUM)) { 2243 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2244 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2245 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2246 } 2247 2248 /* Enable Receives */ 2249 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2250 2251 return; 2252 } 2253 2254 /********************************************************************* 2255 * 2256 * Free receive related data structures. 2257 * 2258 **********************************************************************/ 2259 static void 2260 em_free_receive_structures(struct adapter *adapter) 2261 { 2262 struct em_buffer *rx_buffer; 2263 int i; 2264 2265 INIT_DEBUGOUT("free_receive_structures: begin"); 2266 2267 if (adapter->rx_buffer_area != NULL) { 2268 rx_buffer = adapter->rx_buffer_area; 2269 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2270 if (rx_buffer->m_head != NULL) 2271 m_freem(rx_buffer->m_head); 2272 rx_buffer->m_head = NULL; 2273 } 2274 } 2275 if (adapter->rx_buffer_area != NULL) { 2276 free(adapter->rx_buffer_area, M_DEVBUF); 2277 adapter->rx_buffer_area = NULL; 2278 } 2279 return; 2280 } 2281 2282 /********************************************************************* 2283 * 2284 * This routine executes in interrupt context. It replenishes 2285 * the mbufs in the descriptor and sends data which has been 2286 * dma'ed into host memory to upper layer. 2287 * 2288 * We loop at most count times if count is > 0, or until done if 2289 * count < 0. 2290 * 2291 *********************************************************************/ 2292 static void 2293 em_process_receive_interrupts(struct adapter * adapter, int count) 2294 { 2295 struct ifnet *ifp; 2296 struct mbuf *mp; 2297 #if __FreeBSD_version < 500000 2298 struct ether_header *eh; 2299 #endif 2300 u_int8_t accept_frame = 0; 2301 u_int8_t eop = 0; 2302 u_int16_t len; 2303 int i; 2304 2305 /* Pointer to the receive descriptor being examined. */ 2306 struct em_rx_desc *current_desc; 2307 2308 ifp = &adapter->interface_data.ac_if; 2309 i = adapter->next_rx_desc_to_check; 2310 current_desc = &adapter->rx_desc_base[i]; 2311 2312 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2313 #ifdef DBG_STATS 2314 adapter->no_pkts_avail++; 2315 #endif 2316 return; 2317 } 2318 2319 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2320 2321 mp = adapter->rx_buffer_area[i].m_head; 2322 2323 accept_frame = 1; 2324 if (current_desc->status & E1000_RXD_STAT_EOP) { 2325 count--; 2326 eop = 1; 2327 len = current_desc->length - ETHER_CRC_LEN; 2328 } else { 2329 eop = 0; 2330 len = current_desc->length; 2331 } 2332 2333 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2334 u_int8_t last_byte; 2335 u_int32_t pkt_len = current_desc->length; 2336 2337 if (adapter->fmp != NULL) 2338 pkt_len += adapter->fmp->m_pkthdr.len; 2339 2340 last_byte = *(mtod(mp, caddr_t) + 2341 current_desc->length - 1); 2342 2343 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2344 current_desc->errors, 2345 pkt_len, last_byte)) { 2346 em_tbi_adjust_stats(&adapter->hw, 2347 &adapter->stats, 2348 pkt_len, 2349 adapter->hw.mac_addr); 2350 len--; 2351 } 2352 else { 2353 accept_frame = 0; 2354 } 2355 } 2356 2357 if (accept_frame) { 2358 2359 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2360 adapter->dropped_pkts++; 2361 em_get_buf(i, adapter, mp); 2362 if (adapter->fmp != NULL) 2363 m_freem(adapter->fmp); 2364 adapter->fmp = NULL; 2365 adapter->lmp = NULL; 2366 break; 2367 } 2368 2369 /* Assign correct length to the current fragment */ 2370 mp->m_len = len; 2371 2372 if (adapter->fmp == NULL) { 2373 mp->m_pkthdr.len = len; 2374 adapter->fmp = mp; /* Store the first mbuf */ 2375 adapter->lmp = mp; 2376 } else { 2377 /* Chain mbuf's together */ 2378 mp->m_flags &= ~M_PKTHDR; 2379 adapter->lmp->m_next = mp; 2380 adapter->lmp = adapter->lmp->m_next; 2381 adapter->fmp->m_pkthdr.len += len; 2382 } 2383 2384 if (eop) { 2385 adapter->fmp->m_pkthdr.rcvif = ifp; 2386 ifp->if_ipackets++; 2387 2388 #if __FreeBSD_version < 500000 2389 eh = mtod(adapter->fmp, struct ether_header *); 2390 /* Remove ethernet header from mbuf */ 2391 m_adj(adapter->fmp, sizeof(struct ether_header)); 2392 em_receive_checksum(adapter, current_desc, 2393 adapter->fmp); 2394 if (current_desc->status & E1000_RXD_STAT_VP) 2395 VLAN_INPUT_TAG(eh, adapter->fmp, 2396 (current_desc->special & 2397 E1000_RXD_SPC_VLAN_MASK)); 2398 else 2399 ether_input(ifp, eh, adapter->fmp); 2400 #else 2401 2402 em_receive_checksum(adapter, current_desc, 2403 adapter->fmp); 2404 if (current_desc->status & E1000_RXD_STAT_VP) 2405 VLAN_INPUT_TAG(ifp, adapter->fmp, 2406 (current_desc->special & 2407 E1000_RXD_SPC_VLAN_MASK), 2408 adapter->fmp = NULL); 2409 2410 if (adapter->fmp != NULL) 2411 (*ifp->if_input)(ifp, adapter->fmp); 2412 #endif 2413 adapter->fmp = NULL; 2414 adapter->lmp = NULL; 2415 } 2416 } else { 2417 adapter->dropped_pkts++; 2418 em_get_buf(i, adapter, mp); 2419 if (adapter->fmp != NULL) 2420 m_freem(adapter->fmp); 2421 adapter->fmp = NULL; 2422 adapter->lmp = NULL; 2423 } 2424 2425 /* Zero out the receive descriptors status */ 2426 current_desc->status = 0; 2427 2428 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2429 E1000_WRITE_REG(&adapter->hw, RDT, i); 2430 2431 /* Advance our pointers to the next descriptor */ 2432 if (++i == adapter->num_rx_desc) { 2433 i = 0; 2434 current_desc = adapter->rx_desc_base; 2435 } else 2436 current_desc++; 2437 } 2438 adapter->next_rx_desc_to_check = i; 2439 return; 2440 } 2441 2442 /********************************************************************* 2443 * 2444 * Verify that the hardware indicated that the checksum is valid. 2445 * Inform the stack about the status of checksum so that stack 2446 * doesn't spend time verifying the checksum. 2447 * 2448 *********************************************************************/ 2449 static void 2450 em_receive_checksum(struct adapter *adapter, 2451 struct em_rx_desc *rx_desc, 2452 struct mbuf *mp) 2453 { 2454 /* 82543 or newer only */ 2455 if ((adapter->hw.mac_type < em_82543) || 2456 /* Ignore Checksum bit is set */ 2457 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2458 mp->m_pkthdr.csum_flags = 0; 2459 return; 2460 } 2461 2462 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2463 /* Did it pass? */ 2464 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2465 /* IP Checksum Good */ 2466 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2467 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2468 2469 } else { 2470 mp->m_pkthdr.csum_flags = 0; 2471 } 2472 } 2473 2474 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2475 /* Did it pass? */ 2476 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2477 mp->m_pkthdr.csum_flags |= 2478 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2479 mp->m_pkthdr.csum_data = htons(0xffff); 2480 } 2481 } 2482 2483 return; 2484 } 2485 2486 2487 static void 2488 em_enable_vlans(struct adapter *adapter) 2489 { 2490 uint32_t ctrl; 2491 2492 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 2493 2494 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2495 ctrl |= E1000_CTRL_VME; 2496 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2497 2498 return; 2499 } 2500 2501 static void 2502 em_enable_intr(struct adapter * adapter) 2503 { 2504 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2505 return; 2506 } 2507 2508 static void 2509 em_disable_intr(struct adapter *adapter) 2510 { 2511 E1000_WRITE_REG(&adapter->hw, IMC, 2512 (0xffffffff & ~E1000_IMC_RXSEQ)); 2513 return; 2514 } 2515 2516 static int 2517 em_is_valid_ether_addr(u_int8_t *addr) 2518 { 2519 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; 2520 2521 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { 2522 return (FALSE); 2523 } 2524 2525 return(TRUE); 2526 } 2527 2528 void 2529 em_write_pci_cfg(struct em_hw *hw, 2530 uint32_t reg, 2531 uint16_t *value) 2532 { 2533 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2534 *value, 2); 2535 } 2536 2537 void 2538 em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2539 uint16_t *value) 2540 { 2541 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2542 reg, 2); 2543 return; 2544 } 2545 2546 void 2547 em_pci_set_mwi(struct em_hw *hw) 2548 { 2549 pci_write_config(((struct em_osdep *)hw->back)->dev, 2550 PCIR_COMMAND, 2551 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 2552 return; 2553 } 2554 2555 void 2556 em_pci_clear_mwi(struct em_hw *hw) 2557 { 2558 pci_write_config(((struct em_osdep *)hw->back)->dev, 2559 PCIR_COMMAND, 2560 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 2561 return; 2562 } 2563 2564 uint32_t 2565 em_io_read(struct em_hw *hw, uint32_t port) 2566 { 2567 return(inl(port)); 2568 } 2569 2570 void 2571 em_io_write(struct em_hw *hw, uint32_t port, uint32_t value) 2572 { 2573 outl(port, value); 2574 return; 2575 } 2576 2577 2578 /********************************************************************** 2579 * 2580 * Update the board statistics counters. 2581 * 2582 **********************************************************************/ 2583 static void 2584 em_update_stats_counters(struct adapter *adapter) 2585 { 2586 struct ifnet *ifp; 2587 2588 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 2589 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 2590 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 2591 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 2592 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 2593 2594 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 2595 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 2596 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 2597 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 2598 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 2599 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 2600 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 2601 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 2602 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 2603 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 2604 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 2605 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 2606 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 2607 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 2608 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 2609 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 2610 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 2611 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 2612 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 2613 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 2614 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 2615 2616 /* For the 64-bit byte counters the low dword must be read first. */ 2617 /* Both registers clear on the read of the high dword */ 2618 2619 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 2620 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 2621 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 2622 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 2623 2624 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 2625 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 2626 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 2627 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 2628 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 2629 2630 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 2631 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 2632 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 2633 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 2634 2635 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 2636 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 2637 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 2638 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 2639 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 2640 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 2641 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 2642 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 2643 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 2644 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 2645 2646 if (adapter->hw.mac_type >= em_82543) { 2647 adapter->stats.algnerrc += 2648 E1000_READ_REG(&adapter->hw, ALGNERRC); 2649 adapter->stats.rxerrc += 2650 E1000_READ_REG(&adapter->hw, RXERRC); 2651 adapter->stats.tncrs += 2652 E1000_READ_REG(&adapter->hw, TNCRS); 2653 adapter->stats.cexterr += 2654 E1000_READ_REG(&adapter->hw, CEXTERR); 2655 adapter->stats.tsctc += 2656 E1000_READ_REG(&adapter->hw, TSCTC); 2657 adapter->stats.tsctfc += 2658 E1000_READ_REG(&adapter->hw, TSCTFC); 2659 } 2660 ifp = &adapter->interface_data.ac_if; 2661 2662 /* Fill out the OS statistics structure */ 2663 ifp->if_ibytes = adapter->stats.gorcl; 2664 ifp->if_obytes = adapter->stats.gotcl; 2665 ifp->if_imcasts = adapter->stats.mprc; 2666 ifp->if_collisions = adapter->stats.colc; 2667 2668 /* Rx Errors */ 2669 ifp->if_ierrors = 2670 adapter->dropped_pkts + 2671 adapter->stats.rxerrc + 2672 adapter->stats.crcerrs + 2673 adapter->stats.algnerrc + 2674 adapter->stats.rlec + adapter->stats.rnbc + 2675 adapter->stats.mpc + adapter->stats.cexterr; 2676 2677 /* Tx Errors */ 2678 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 2679 2680 } 2681 2682 2683 /********************************************************************** 2684 * 2685 * This routine is called only when em_display_debug_stats is enabled. 2686 * This routine provides a way to take a look at important statistics 2687 * maintained by the driver and hardware. 2688 * 2689 **********************************************************************/ 2690 static void 2691 em_print_debug_info(struct adapter *adapter) 2692 { 2693 int unit = adapter->unit; 2694 2695 #ifdef DBG_STATS 2696 printf("em%d: Packets not Avail = %ld\n", unit, 2697 adapter->no_pkts_avail); 2698 printf("em%d: CleanTxInterrupts = %ld\n", unit, 2699 adapter->clean_tx_interrupts); 2700 #endif 2701 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 2702 (long long)adapter->tx_fifo_wrk, 2703 (long long)adapter->tx_fifo_reset); 2704 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 2705 E1000_READ_REG(&adapter->hw, TDH), 2706 E1000_READ_REG(&adapter->hw, TDT)); 2707 printf("em%d: Num Tx descriptors avail = %d\n", unit, 2708 adapter->num_tx_desc_avail); 2709 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 2710 adapter->no_tx_desc_avail1); 2711 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 2712 adapter->no_tx_desc_avail2); 2713 printf("em%d: Std mbuf failed = %ld\n", unit, 2714 adapter->mbuf_alloc_failed); 2715 printf("em%d: Std mbuf cluster failed = %ld\n", unit, 2716 adapter->mbuf_cluster_failed); 2717 printf("em%d: Driver dropped packets = %ld\n", unit, 2718 adapter->dropped_pkts); 2719 2720 return; 2721 } 2722 2723 static void 2724 em_print_hw_stats(struct adapter *adapter) 2725 { 2726 int unit = adapter->unit; 2727 2728 printf("em%d: Excessive collisions = %lld\n", unit, 2729 (long long)adapter->stats.ecol); 2730 printf("em%d: Symbol errors = %lld\n", unit, 2731 (long long)adapter->stats.symerrs); 2732 printf("em%d: Sequence errors = %lld\n", unit, 2733 (long long)adapter->stats.sec); 2734 printf("em%d: Defer count = %lld\n", unit, 2735 (long long)adapter->stats.dc); 2736 2737 printf("em%d: Missed Packets = %lld\n", unit, 2738 (long long)adapter->stats.mpc); 2739 printf("em%d: Receive No Buffers = %lld\n", unit, 2740 (long long)adapter->stats.rnbc); 2741 printf("em%d: Receive length errors = %lld\n", unit, 2742 (long long)adapter->stats.rlec); 2743 printf("em%d: Receive errors = %lld\n", unit, 2744 (long long)adapter->stats.rxerrc); 2745 printf("em%d: Crc errors = %lld\n", unit, 2746 (long long)adapter->stats.crcerrs); 2747 printf("em%d: Alignment errors = %lld\n", unit, 2748 (long long)adapter->stats.algnerrc); 2749 printf("em%d: Carrier extension errors = %lld\n", unit, 2750 (long long)adapter->stats.cexterr); 2751 2752 printf("em%d: XON Rcvd = %lld\n", unit, 2753 (long long)adapter->stats.xonrxc); 2754 printf("em%d: XON Xmtd = %lld\n", unit, 2755 (long long)adapter->stats.xontxc); 2756 printf("em%d: XOFF Rcvd = %lld\n", unit, 2757 (long long)adapter->stats.xoffrxc); 2758 printf("em%d: XOFF Xmtd = %lld\n", unit, 2759 (long long)adapter->stats.xofftxc); 2760 2761 printf("em%d: Good Packets Rcvd = %lld\n", unit, 2762 (long long)adapter->stats.gprc); 2763 printf("em%d: Good Packets Xmtd = %lld\n", unit, 2764 (long long)adapter->stats.gptc); 2765 2766 return; 2767 } 2768 2769 static int 2770 em_sysctl_debug_info(SYSCTL_HANDLER_ARGS) 2771 { 2772 int error; 2773 int result; 2774 struct adapter *adapter; 2775 2776 result = -1; 2777 error = sysctl_handle_int(oidp, &result, 0, req); 2778 2779 if (error || !req->newptr) 2780 return (error); 2781 2782 if (result == 1) { 2783 adapter = (struct adapter *)arg1; 2784 em_print_debug_info(adapter); 2785 } 2786 2787 return error; 2788 } 2789 2790 2791 static int 2792 em_sysctl_stats(SYSCTL_HANDLER_ARGS) 2793 { 2794 int error; 2795 int result; 2796 struct adapter *adapter; 2797 2798 result = -1; 2799 error = sysctl_handle_int(oidp, &result, 0, req); 2800 2801 if (error || !req->newptr) 2802 return (error); 2803 2804 if (result == 1) { 2805 adapter = (struct adapter *)arg1; 2806 em_print_hw_stats(adapter); 2807 } 2808 2809 return error; 2810 } 2811 2812