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