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