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