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