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