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