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