if_em.c revision 128139
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 128139 2004-04-11 21:01:12Z ru $*/ 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#endif 1870 1871#ifdef DEVICE_POLLING 1872 ifp->if_capabilities |= IFCAP_POLLING; 1873 ifp->if_capenable |= IFCAP_POLLING; 1874#endif 1875 1876 /* 1877 * Specify the media types supported by this adapter and register 1878 * callbacks to update media and link information 1879 */ 1880 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1881 em_media_status); 1882 if (adapter->hw.media_type == em_media_type_fiber) { 1883 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1884 0, NULL); 1885 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1886 0, NULL); 1887 } else { 1888 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1889 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1890 0, NULL); 1891 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1892 0, NULL); 1893 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1894 0, NULL); 1895#if __FreeBSD_version < 500000 1896 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1897 0, NULL); 1898 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1899#else 1900 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1901 0, NULL); 1902 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1903#endif 1904 } 1905 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1906 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1907 1908 return; 1909} 1910 1911 1912/********************************************************************* 1913 * 1914 * Workaround for SmartSpeed on 82541 and 82547 controllers 1915 * 1916 **********************************************************************/ 1917static void 1918em_smartspeed(struct adapter *adapter) 1919{ 1920 uint16_t phy_tmp; 1921 1922 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 1923 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 1924 return; 1925 1926 if(adapter->smartspeed == 0) { 1927 /* If Master/Slave config fault is asserted twice, 1928 * we assume back-to-back */ 1929 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1930 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 1931 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1932 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 1933 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 1934 &phy_tmp); 1935 if(phy_tmp & CR_1000T_MS_ENABLE) { 1936 phy_tmp &= ~CR_1000T_MS_ENABLE; 1937 em_write_phy_reg(&adapter->hw, 1938 PHY_1000T_CTRL, phy_tmp); 1939 adapter->smartspeed++; 1940 if(adapter->hw.autoneg && 1941 !em_phy_setup_autoneg(&adapter->hw) && 1942 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 1943 &phy_tmp)) { 1944 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1945 MII_CR_RESTART_AUTO_NEG); 1946 em_write_phy_reg(&adapter->hw, 1947 PHY_CTRL, phy_tmp); 1948 } 1949 } 1950 } 1951 return; 1952 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 1953 /* If still no link, perhaps using 2/3 pair cable */ 1954 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 1955 phy_tmp |= CR_1000T_MS_ENABLE; 1956 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 1957 if(adapter->hw.autoneg && 1958 !em_phy_setup_autoneg(&adapter->hw) && 1959 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 1960 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1961 MII_CR_RESTART_AUTO_NEG); 1962 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 1963 } 1964 } 1965 /* Restart process after EM_SMARTSPEED_MAX iterations */ 1966 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 1967 adapter->smartspeed = 0; 1968 1969 return; 1970} 1971 1972 1973/* 1974 * Manage DMA'able memory. 1975 */ 1976static void 1977em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 1978{ 1979 if (error) 1980 return; 1981 *(bus_addr_t*) arg = segs->ds_addr; 1982 return; 1983} 1984 1985static int 1986em_dma_malloc(struct adapter *adapter, bus_size_t size, 1987 struct em_dma_alloc *dma, int mapflags) 1988{ 1989 int r; 1990 1991 r = bus_dma_tag_create(NULL, /* parent */ 1992 PAGE_SIZE, 0, /* alignment, bounds */ 1993 BUS_SPACE_MAXADDR, /* lowaddr */ 1994 BUS_SPACE_MAXADDR, /* highaddr */ 1995 NULL, NULL, /* filter, filterarg */ 1996 size, /* maxsize */ 1997 1, /* nsegments */ 1998 size, /* maxsegsize */ 1999 BUS_DMA_ALLOCNOW, /* flags */ 2000 NULL, /* lockfunc */ 2001 NULL, /* lockarg */ 2002 &dma->dma_tag); 2003 if (r != 0) { 2004 printf("em%d: em_dma_malloc: bus_dma_tag_create failed; " 2005 "error %u\n", adapter->unit, r); 2006 goto fail_0; 2007 } 2008 2009 r = bus_dmamap_create(dma->dma_tag, BUS_DMA_NOWAIT, &dma->dma_map); 2010 if (r != 0) { 2011 printf("em%d: em_dma_malloc: bus_dmamap_create failed; " 2012 "error %u\n", adapter->unit, r); 2013 goto fail_1; 2014 } 2015 2016 r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, 2017 BUS_DMA_NOWAIT, &dma->dma_map); 2018 if (r != 0) { 2019 printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; " 2020 "size %ju, error %d\n", adapter->unit, 2021 (uintmax_t)size, r); 2022 goto fail_2; 2023 } 2024 2025 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 2026 size, 2027 em_dmamap_cb, 2028 &dma->dma_paddr, 2029 mapflags | BUS_DMA_NOWAIT); 2030 if (r != 0) { 2031 printf("em%d: em_dma_malloc: bus_dmamap_load failed; " 2032 "error %u\n", adapter->unit, r); 2033 goto fail_3; 2034 } 2035 2036 dma->dma_size = size; 2037 return (0); 2038 2039fail_3: 2040 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2041fail_2: 2042 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2043fail_1: 2044 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 2045 bus_dma_tag_destroy(dma->dma_tag); 2046fail_0: 2047 dma->dma_map = NULL; 2048 dma->dma_tag = NULL; 2049 return (r); 2050} 2051 2052static void 2053em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) 2054{ 2055 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2056 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2057 bus_dmamap_destroy(dma->dma_tag, dma->dma_map); 2058 bus_dma_tag_destroy(dma->dma_tag); 2059} 2060 2061 2062/********************************************************************* 2063 * 2064 * Allocate memory for tx_buffer structures. The tx_buffer stores all 2065 * the information needed to transmit a packet on the wire. 2066 * 2067 **********************************************************************/ 2068static int 2069em_allocate_transmit_structures(struct adapter * adapter) 2070{ 2071 if (!(adapter->tx_buffer_area = 2072 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2073 adapter->num_tx_desc, M_DEVBUF, 2074 M_NOWAIT))) { 2075 printf("em%d: Unable to allocate tx_buffer memory\n", 2076 adapter->unit); 2077 return ENOMEM; 2078 } 2079 2080 bzero(adapter->tx_buffer_area, 2081 sizeof(struct em_buffer) * adapter->num_tx_desc); 2082 2083 return 0; 2084} 2085 2086/********************************************************************* 2087 * 2088 * Allocate and initialize transmit structures. 2089 * 2090 **********************************************************************/ 2091static int 2092em_setup_transmit_structures(struct adapter * adapter) 2093{ 2094 /* 2095 * Setup DMA descriptor areas. 2096 */ 2097 if (bus_dma_tag_create(NULL, /* parent */ 2098 PAGE_SIZE, 0, /* alignment, bounds */ 2099 BUS_SPACE_MAXADDR, /* lowaddr */ 2100 BUS_SPACE_MAXADDR, /* highaddr */ 2101 NULL, NULL, /* filter, filterarg */ 2102 MCLBYTES * 8, /* maxsize */ 2103 EM_MAX_SCATTER, /* nsegments */ 2104 MCLBYTES * 8, /* maxsegsize */ 2105 BUS_DMA_ALLOCNOW, /* flags */ 2106 NULL, /* lockfunc */ 2107 NULL, /* lockarg */ 2108 &adapter->txtag)) { 2109 printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit); 2110 return (ENOMEM); 2111 } 2112 2113 if (em_allocate_transmit_structures(adapter)) 2114 return (ENOMEM); 2115 2116 bzero((void *) adapter->tx_desc_base, 2117 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 2118 2119 adapter->next_avail_tx_desc = 0; 2120 adapter->oldest_used_tx_desc = 0; 2121 2122 /* Set number of descriptors available */ 2123 adapter->num_tx_desc_avail = adapter->num_tx_desc; 2124 2125 /* Set checksum context */ 2126 adapter->active_checksum_context = OFFLOAD_NONE; 2127 2128 return (0); 2129} 2130 2131/********************************************************************* 2132 * 2133 * Enable transmit unit. 2134 * 2135 **********************************************************************/ 2136static void 2137em_initialize_transmit_unit(struct adapter * adapter) 2138{ 2139 u_int32_t reg_tctl; 2140 u_int32_t reg_tipg = 0; 2141 u_int64_t bus_addr; 2142 2143 INIT_DEBUGOUT("em_initialize_transmit_unit: begin"); 2144 /* Setup the Base and Length of the Tx Descriptor Ring */ 2145 bus_addr = adapter->txdma.dma_paddr; 2146 E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr); 2147 E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32)); 2148 E1000_WRITE_REG(&adapter->hw, TDLEN, 2149 adapter->num_tx_desc * 2150 sizeof(struct em_tx_desc)); 2151 2152 /* Setup the HW Tx Head and Tail descriptor pointers */ 2153 E1000_WRITE_REG(&adapter->hw, TDH, 0); 2154 E1000_WRITE_REG(&adapter->hw, TDT, 0); 2155 2156 2157 HW_DEBUGOUT2("Base = %x, Length = %x\n", 2158 E1000_READ_REG(&adapter->hw, TDBAL), 2159 E1000_READ_REG(&adapter->hw, TDLEN)); 2160 2161 /* Set the default values for the Tx Inter Packet Gap timer */ 2162 switch (adapter->hw.mac_type) { 2163 case em_82542_rev2_0: 2164 case em_82542_rev2_1: 2165 reg_tipg = DEFAULT_82542_TIPG_IPGT; 2166 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2167 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2168 break; 2169 default: 2170 if (adapter->hw.media_type == em_media_type_fiber) 2171 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 2172 else 2173 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 2174 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2175 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2176 } 2177 2178 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 2179 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value); 2180 if(adapter->hw.mac_type >= em_82540) 2181 E1000_WRITE_REG(&adapter->hw, TADV, 2182 adapter->tx_abs_int_delay.value); 2183 2184 /* Program the Transmit Control Register */ 2185 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 2186 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 2187 if (adapter->link_duplex == 1) { 2188 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2189 } else { 2190 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2191 } 2192 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 2193 2194 /* Setup Transmit Descriptor Settings for this adapter */ 2195 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 2196 2197 if (adapter->tx_int_delay.value > 0) 2198 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 2199 2200 return; 2201} 2202 2203/********************************************************************* 2204 * 2205 * Free all transmit related data structures. 2206 * 2207 **********************************************************************/ 2208static void 2209em_free_transmit_structures(struct adapter * adapter) 2210{ 2211 struct em_buffer *tx_buffer; 2212 int i; 2213 2214 INIT_DEBUGOUT("free_transmit_structures: begin"); 2215 2216 if (adapter->tx_buffer_area != NULL) { 2217 tx_buffer = adapter->tx_buffer_area; 2218 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 2219 if (tx_buffer->m_head != NULL) { 2220 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2221 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2222 m_freem(tx_buffer->m_head); 2223 } 2224 tx_buffer->m_head = NULL; 2225 } 2226 } 2227 if (adapter->tx_buffer_area != NULL) { 2228 free(adapter->tx_buffer_area, M_DEVBUF); 2229 adapter->tx_buffer_area = NULL; 2230 } 2231 if (adapter->txtag != NULL) { 2232 bus_dma_tag_destroy(adapter->txtag); 2233 adapter->txtag = NULL; 2234 } 2235 return; 2236} 2237 2238/********************************************************************* 2239 * 2240 * The offload context needs to be set when we transfer the first 2241 * packet of a particular protocol (TCP/UDP). We change the 2242 * context only if the protocol type changes. 2243 * 2244 **********************************************************************/ 2245static void 2246em_transmit_checksum_setup(struct adapter * adapter, 2247 struct mbuf *mp, 2248 u_int32_t *txd_upper, 2249 u_int32_t *txd_lower) 2250{ 2251 struct em_context_desc *TXD; 2252 struct em_buffer *tx_buffer; 2253 int curr_txd; 2254 2255 if (mp->m_pkthdr.csum_flags) { 2256 2257 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 2258 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2259 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2260 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 2261 return; 2262 else 2263 adapter->active_checksum_context = OFFLOAD_TCP_IP; 2264 2265 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 2266 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2267 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2268 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 2269 return; 2270 else 2271 adapter->active_checksum_context = OFFLOAD_UDP_IP; 2272 } else { 2273 *txd_upper = 0; 2274 *txd_lower = 0; 2275 return; 2276 } 2277 } else { 2278 *txd_upper = 0; 2279 *txd_lower = 0; 2280 return; 2281 } 2282 2283 /* If we reach this point, the checksum offload context 2284 * needs to be reset. 2285 */ 2286 curr_txd = adapter->next_avail_tx_desc; 2287 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 2288 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 2289 2290 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 2291 TXD->lower_setup.ip_fields.ipcso = 2292 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 2293 TXD->lower_setup.ip_fields.ipcse = 2294 htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1); 2295 2296 TXD->upper_setup.tcp_fields.tucss = 2297 ETHER_HDR_LEN + sizeof(struct ip); 2298 TXD->upper_setup.tcp_fields.tucse = htole16(0); 2299 2300 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 2301 TXD->upper_setup.tcp_fields.tucso = 2302 ETHER_HDR_LEN + sizeof(struct ip) + 2303 offsetof(struct tcphdr, th_sum); 2304 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 2305 TXD->upper_setup.tcp_fields.tucso = 2306 ETHER_HDR_LEN + sizeof(struct ip) + 2307 offsetof(struct udphdr, uh_sum); 2308 } 2309 2310 TXD->tcp_seg_setup.data = htole32(0); 2311 TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT); 2312 2313 tx_buffer->m_head = NULL; 2314 2315 if (++curr_txd == adapter->num_tx_desc) 2316 curr_txd = 0; 2317 2318 adapter->num_tx_desc_avail--; 2319 adapter->next_avail_tx_desc = curr_txd; 2320 2321 return; 2322} 2323 2324/********************************************************************** 2325 * 2326 * Examine each tx_buffer in the used queue. If the hardware is done 2327 * processing the packet then free associated resources. The 2328 * tx_buffer is put back on the free queue. 2329 * 2330 **********************************************************************/ 2331static void 2332em_clean_transmit_interrupts(struct adapter * adapter) 2333{ 2334 int i, num_avail; 2335 struct em_buffer *tx_buffer; 2336 struct em_tx_desc *tx_desc; 2337 struct ifnet *ifp = &adapter->interface_data.ac_if; 2338 2339 mtx_assert(&adapter->mtx, MA_OWNED); 2340 2341 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2342 return; 2343 2344#ifdef DBG_STATS 2345 adapter->clean_tx_interrupts++; 2346#endif 2347 num_avail = adapter->num_tx_desc_avail; 2348 i = adapter->oldest_used_tx_desc; 2349 2350 tx_buffer = &adapter->tx_buffer_area[i]; 2351 tx_desc = &adapter->tx_desc_base[i]; 2352 2353 while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 2354 2355 tx_desc->upper.data = 0; 2356 num_avail++; 2357 2358 if (tx_buffer->m_head) { 2359 ifp->if_opackets++; 2360 bus_dmamap_sync(adapter->txtag, tx_buffer->map, 2361 BUS_DMASYNC_POSTWRITE); 2362 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2363 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2364 2365 m_freem(tx_buffer->m_head); 2366 tx_buffer->m_head = NULL; 2367 } 2368 2369 if (++i == adapter->num_tx_desc) 2370 i = 0; 2371 2372 tx_buffer = &adapter->tx_buffer_area[i]; 2373 tx_desc = &adapter->tx_desc_base[i]; 2374 } 2375 2376 adapter->oldest_used_tx_desc = i; 2377 2378 /* 2379 * If we have enough room, clear IFF_OACTIVE to tell the stack 2380 * that it is OK to send packets. 2381 * If there are no pending descriptors, clear the timeout. Otherwise, 2382 * if some descriptors have been freed, restart the timeout. 2383 */ 2384 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2385 ifp->if_flags &= ~IFF_OACTIVE; 2386 if (num_avail == adapter->num_tx_desc) 2387 ifp->if_timer = 0; 2388 else if (num_avail == adapter->num_tx_desc_avail) 2389 ifp->if_timer = EM_TX_TIMEOUT; 2390 } 2391 adapter->num_tx_desc_avail = num_avail; 2392 return; 2393} 2394 2395/********************************************************************* 2396 * 2397 * Get a buffer from system mbuf buffer pool. 2398 * 2399 **********************************************************************/ 2400static int 2401em_get_buf(int i, struct adapter *adapter, 2402 struct mbuf *nmp) 2403{ 2404 register struct mbuf *mp = nmp; 2405 struct em_buffer *rx_buffer; 2406 struct ifnet *ifp; 2407 bus_addr_t paddr; 2408 int error; 2409 2410 ifp = &adapter->interface_data.ac_if; 2411 2412 if (mp == NULL) { 2413 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 2414 if (mp == NULL) { 2415 adapter->mbuf_cluster_failed++; 2416 return(ENOBUFS); 2417 } 2418 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2419 } else { 2420 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2421 mp->m_data = mp->m_ext.ext_buf; 2422 mp->m_next = NULL; 2423 } 2424 2425 if (ifp->if_mtu <= ETHERMTU) { 2426 m_adj(mp, ETHER_ALIGN); 2427 } 2428 2429 rx_buffer = &adapter->rx_buffer_area[i]; 2430 2431 /* 2432 * Using memory from the mbuf cluster pool, invoke the 2433 * bus_dma machinery to arrange the memory mapping. 2434 */ 2435 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 2436 mtod(mp, void *), mp->m_len, 2437 em_dmamap_cb, &paddr, 0); 2438 if (error) { 2439 m_free(mp); 2440 return(error); 2441 } 2442 rx_buffer->m_head = mp; 2443 adapter->rx_desc_base[i].buffer_addr = htole64(paddr); 2444 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 2445 2446 return(0); 2447} 2448 2449/********************************************************************* 2450 * 2451 * Allocate memory for rx_buffer structures. Since we use one 2452 * rx_buffer per received packet, the maximum number of rx_buffer's 2453 * that we'll need is equal to the number of receive descriptors 2454 * that we've allocated. 2455 * 2456 **********************************************************************/ 2457static int 2458em_allocate_receive_structures(struct adapter * adapter) 2459{ 2460 int i, error; 2461 struct em_buffer *rx_buffer; 2462 2463 if (!(adapter->rx_buffer_area = 2464 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2465 adapter->num_rx_desc, M_DEVBUF, 2466 M_NOWAIT))) { 2467 printf("em%d: Unable to allocate rx_buffer memory\n", 2468 adapter->unit); 2469 return(ENOMEM); 2470 } 2471 2472 bzero(adapter->rx_buffer_area, 2473 sizeof(struct em_buffer) * adapter->num_rx_desc); 2474 2475 error = bus_dma_tag_create(NULL, /* parent */ 2476 PAGE_SIZE, 0, /* alignment, bounds */ 2477 BUS_SPACE_MAXADDR, /* lowaddr */ 2478 BUS_SPACE_MAXADDR, /* highaddr */ 2479 NULL, NULL, /* filter, filterarg */ 2480 MCLBYTES, /* maxsize */ 2481 1, /* nsegments */ 2482 MCLBYTES, /* maxsegsize */ 2483 BUS_DMA_ALLOCNOW, /* flags */ 2484 NULL, /* lockfunc */ 2485 NULL, /* lockarg */ 2486 &adapter->rxtag); 2487 if (error != 0) { 2488 printf("em%d: em_allocate_receive_structures: " 2489 "bus_dma_tag_create failed; error %u\n", 2490 adapter->unit, error); 2491 goto fail_0; 2492 } 2493 2494 rx_buffer = adapter->rx_buffer_area; 2495 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2496 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 2497 &rx_buffer->map); 2498 if (error != 0) { 2499 printf("em%d: em_allocate_receive_structures: " 2500 "bus_dmamap_create failed; error %u\n", 2501 adapter->unit, error); 2502 goto fail_1; 2503 } 2504 } 2505 2506 for (i = 0; i < adapter->num_rx_desc; i++) { 2507 error = em_get_buf(i, adapter, NULL); 2508 if (error != 0) { 2509 adapter->rx_buffer_area[i].m_head = NULL; 2510 adapter->rx_desc_base[i].buffer_addr = 0; 2511 return(error); 2512 } 2513 } 2514 2515 return(0); 2516 2517fail_1: 2518 bus_dma_tag_destroy(adapter->rxtag); 2519fail_0: 2520 adapter->rxtag = NULL; 2521 free(adapter->rx_buffer_area, M_DEVBUF); 2522 adapter->rx_buffer_area = NULL; 2523 return (error); 2524} 2525 2526/********************************************************************* 2527 * 2528 * Allocate and initialize receive structures. 2529 * 2530 **********************************************************************/ 2531static int 2532em_setup_receive_structures(struct adapter * adapter) 2533{ 2534 bzero((void *) adapter->rx_desc_base, 2535 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2536 2537 if (em_allocate_receive_structures(adapter)) 2538 return ENOMEM; 2539 2540 /* Setup our descriptor pointers */ 2541 adapter->next_rx_desc_to_check = 0; 2542 return(0); 2543} 2544 2545/********************************************************************* 2546 * 2547 * Enable receive unit. 2548 * 2549 **********************************************************************/ 2550static void 2551em_initialize_receive_unit(struct adapter * adapter) 2552{ 2553 u_int32_t reg_rctl; 2554 u_int32_t reg_rxcsum; 2555 struct ifnet *ifp; 2556 u_int64_t bus_addr; 2557 2558 INIT_DEBUGOUT("em_initialize_receive_unit: begin"); 2559 ifp = &adapter->interface_data.ac_if; 2560 2561 /* Make sure receives are disabled while setting up the descriptor ring */ 2562 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2563 2564 /* Set the Receive Delay Timer Register */ 2565 E1000_WRITE_REG(&adapter->hw, RDTR, 2566 adapter->rx_int_delay.value | E1000_RDT_FPDB); 2567 2568 if(adapter->hw.mac_type >= em_82540) { 2569 E1000_WRITE_REG(&adapter->hw, RADV, 2570 adapter->rx_abs_int_delay.value); 2571 2572 /* Set the interrupt throttling rate. Value is calculated 2573 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2574#define MAX_INTS_PER_SEC 8000 2575#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2576 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2577 } 2578 2579 /* Setup the Base and Length of the Rx Descriptor Ring */ 2580 bus_addr = adapter->rxdma.dma_paddr; 2581 E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr); 2582 E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32)); 2583 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 2584 sizeof(struct em_rx_desc)); 2585 2586 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2587 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2588 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2589 2590 /* Setup the Receive Control Register */ 2591 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2592 E1000_RCTL_RDMTS_HALF | 2593 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2594 2595 if (adapter->hw.tbi_compatibility_on == TRUE) 2596 reg_rctl |= E1000_RCTL_SBP; 2597 2598 2599 switch (adapter->rx_buffer_len) { 2600 default: 2601 case EM_RXBUFFER_2048: 2602 reg_rctl |= E1000_RCTL_SZ_2048; 2603 break; 2604 case EM_RXBUFFER_4096: 2605 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2606 break; 2607 case EM_RXBUFFER_8192: 2608 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2609 break; 2610 case EM_RXBUFFER_16384: 2611 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2612 break; 2613 } 2614 2615 if (ifp->if_mtu > ETHERMTU) 2616 reg_rctl |= E1000_RCTL_LPE; 2617 2618 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2619 if ((adapter->hw.mac_type >= em_82543) && 2620 (ifp->if_capenable & IFCAP_RXCSUM)) { 2621 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2622 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2623 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2624 } 2625 2626 /* Enable Receives */ 2627 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2628 2629 return; 2630} 2631 2632/********************************************************************* 2633 * 2634 * Free receive related data structures. 2635 * 2636 **********************************************************************/ 2637static void 2638em_free_receive_structures(struct adapter *adapter) 2639{ 2640 struct em_buffer *rx_buffer; 2641 int i; 2642 2643 INIT_DEBUGOUT("free_receive_structures: begin"); 2644 2645 if (adapter->rx_buffer_area != NULL) { 2646 rx_buffer = adapter->rx_buffer_area; 2647 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2648 if (rx_buffer->map != NULL) { 2649 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2650 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2651 } 2652 if (rx_buffer->m_head != NULL) 2653 m_freem(rx_buffer->m_head); 2654 rx_buffer->m_head = NULL; 2655 } 2656 } 2657 if (adapter->rx_buffer_area != NULL) { 2658 free(adapter->rx_buffer_area, M_DEVBUF); 2659 adapter->rx_buffer_area = NULL; 2660 } 2661 if (adapter->rxtag != NULL) { 2662 bus_dma_tag_destroy(adapter->rxtag); 2663 adapter->rxtag = NULL; 2664 } 2665 return; 2666} 2667 2668/********************************************************************* 2669 * 2670 * This routine executes in interrupt context. It replenishes 2671 * the mbufs in the descriptor and sends data which has been 2672 * dma'ed into host memory to upper layer. 2673 * 2674 * We loop at most count times if count is > 0, or until done if 2675 * count < 0. 2676 * 2677 *********************************************************************/ 2678static void 2679em_process_receive_interrupts(struct adapter * adapter, int count) 2680{ 2681 struct ifnet *ifp; 2682 struct mbuf *mp; 2683#if __FreeBSD_version < 500000 2684 struct ether_header *eh; 2685#endif 2686 u_int8_t accept_frame = 0; 2687 u_int8_t eop = 0; 2688 u_int16_t len, desc_len, prev_len_adj; 2689 int i; 2690 2691 /* Pointer to the receive descriptor being examined. */ 2692 struct em_rx_desc *current_desc; 2693 2694 mtx_assert(&adapter->mtx, MA_OWNED); 2695 2696 ifp = &adapter->interface_data.ac_if; 2697 i = adapter->next_rx_desc_to_check; 2698 current_desc = &adapter->rx_desc_base[i]; 2699 2700 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2701#ifdef DBG_STATS 2702 adapter->no_pkts_avail++; 2703#endif 2704 return; 2705 } 2706 2707 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2708 2709 mp = adapter->rx_buffer_area[i].m_head; 2710 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2711 BUS_DMASYNC_POSTREAD); 2712 2713 accept_frame = 1; 2714 prev_len_adj = 0; 2715 desc_len = le16toh(current_desc->length); 2716 if (current_desc->status & E1000_RXD_STAT_EOP) { 2717 count--; 2718 eop = 1; 2719 if (desc_len < ETHER_CRC_LEN) { 2720 len = 0; 2721 prev_len_adj = ETHER_CRC_LEN - desc_len; 2722 } 2723 else { 2724 len = desc_len - ETHER_CRC_LEN; 2725 } 2726 } else { 2727 eop = 0; 2728 len = desc_len; 2729 } 2730 2731 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2732 u_int8_t last_byte; 2733 u_int32_t pkt_len = desc_len; 2734 2735 if (adapter->fmp != NULL) 2736 pkt_len += adapter->fmp->m_pkthdr.len; 2737 2738 last_byte = *(mtod(mp, caddr_t) + desc_len - 1); 2739 2740 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2741 current_desc->errors, 2742 pkt_len, last_byte)) { 2743 em_tbi_adjust_stats(&adapter->hw, 2744 &adapter->stats, 2745 pkt_len, 2746 adapter->hw.mac_addr); 2747 if (len > 0) len--; 2748 } 2749 else { 2750 accept_frame = 0; 2751 } 2752 } 2753 2754 if (accept_frame) { 2755 2756 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2757 adapter->dropped_pkts++; 2758 em_get_buf(i, adapter, mp); 2759 if (adapter->fmp != NULL) 2760 m_freem(adapter->fmp); 2761 adapter->fmp = NULL; 2762 adapter->lmp = NULL; 2763 break; 2764 } 2765 2766 /* Assign correct length to the current fragment */ 2767 mp->m_len = len; 2768 2769 if (adapter->fmp == NULL) { 2770 mp->m_pkthdr.len = len; 2771 adapter->fmp = mp; /* Store the first mbuf */ 2772 adapter->lmp = mp; 2773 } else { 2774 /* Chain mbuf's together */ 2775 mp->m_flags &= ~M_PKTHDR; 2776 /* 2777 * Adjust length of previous mbuf in chain if we 2778 * received less than 4 bytes in the last descriptor. 2779 */ 2780 if (prev_len_adj > 0) { 2781 adapter->lmp->m_len -= prev_len_adj; 2782 adapter->fmp->m_pkthdr.len -= prev_len_adj; 2783 } 2784 adapter->lmp->m_next = mp; 2785 adapter->lmp = adapter->lmp->m_next; 2786 adapter->fmp->m_pkthdr.len += len; 2787 } 2788 2789 if (eop) { 2790 adapter->fmp->m_pkthdr.rcvif = ifp; 2791 ifp->if_ipackets++; 2792 2793#if __FreeBSD_version < 500000 2794 eh = mtod(adapter->fmp, struct ether_header *); 2795 /* Remove ethernet header from mbuf */ 2796 m_adj(adapter->fmp, sizeof(struct ether_header)); 2797 em_receive_checksum(adapter, current_desc, 2798 adapter->fmp); 2799 if (current_desc->status & E1000_RXD_STAT_VP) 2800 VLAN_INPUT_TAG(eh, adapter->fmp, 2801 (current_desc->special & 2802 E1000_RXD_SPC_VLAN_MASK)); 2803 else 2804 ether_input(ifp, eh, adapter->fmp); 2805#else 2806 2807 em_receive_checksum(adapter, current_desc, 2808 adapter->fmp); 2809 if (current_desc->status & E1000_RXD_STAT_VP) 2810 VLAN_INPUT_TAG(ifp, adapter->fmp, 2811 (current_desc->special & 2812 E1000_RXD_SPC_VLAN_MASK), 2813 adapter->fmp = NULL); 2814 2815 if (adapter->fmp != NULL) { 2816 EM_UNLOCK(adapter); 2817 (*ifp->if_input)(ifp, adapter->fmp); 2818 EM_LOCK(adapter); 2819 } 2820#endif 2821 adapter->fmp = NULL; 2822 adapter->lmp = NULL; 2823 } 2824 } else { 2825 adapter->dropped_pkts++; 2826 em_get_buf(i, adapter, mp); 2827 if (adapter->fmp != NULL) 2828 m_freem(adapter->fmp); 2829 adapter->fmp = NULL; 2830 adapter->lmp = NULL; 2831 } 2832 2833 /* Zero out the receive descriptors status */ 2834 current_desc->status = 0; 2835 2836 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2837 E1000_WRITE_REG(&adapter->hw, RDT, i); 2838 2839 /* Advance our pointers to the next descriptor */ 2840 if (++i == adapter->num_rx_desc) { 2841 i = 0; 2842 current_desc = adapter->rx_desc_base; 2843 } else 2844 current_desc++; 2845 } 2846 adapter->next_rx_desc_to_check = i; 2847 return; 2848} 2849 2850/********************************************************************* 2851 * 2852 * Verify that the hardware indicated that the checksum is valid. 2853 * Inform the stack about the status of checksum so that stack 2854 * doesn't spend time verifying the checksum. 2855 * 2856 *********************************************************************/ 2857static void 2858em_receive_checksum(struct adapter *adapter, 2859 struct em_rx_desc *rx_desc, 2860 struct mbuf *mp) 2861{ 2862 /* 82543 or newer only */ 2863 if ((adapter->hw.mac_type < em_82543) || 2864 /* Ignore Checksum bit is set */ 2865 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2866 mp->m_pkthdr.csum_flags = 0; 2867 return; 2868 } 2869 2870 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2871 /* Did it pass? */ 2872 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2873 /* IP Checksum Good */ 2874 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2875 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2876 2877 } else { 2878 mp->m_pkthdr.csum_flags = 0; 2879 } 2880 } 2881 2882 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2883 /* Did it pass? */ 2884 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2885 mp->m_pkthdr.csum_flags |= 2886 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2887 mp->m_pkthdr.csum_data = htons(0xffff); 2888 } 2889 } 2890 2891 return; 2892} 2893 2894 2895static void 2896em_enable_vlans(struct adapter *adapter) 2897{ 2898 uint32_t ctrl; 2899 2900 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 2901 2902 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2903 ctrl |= E1000_CTRL_VME; 2904 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2905 2906 return; 2907} 2908 2909static void 2910em_enable_intr(struct adapter * adapter) 2911{ 2912 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2913 return; 2914} 2915 2916static void 2917em_disable_intr(struct adapter *adapter) 2918{ 2919 E1000_WRITE_REG(&adapter->hw, IMC, 2920 (0xffffffff & ~E1000_IMC_RXSEQ)); 2921 return; 2922} 2923 2924static int 2925em_is_valid_ether_addr(u_int8_t *addr) 2926{ 2927 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; 2928 2929 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { 2930 return (FALSE); 2931 } 2932 2933 return(TRUE); 2934} 2935 2936void 2937em_write_pci_cfg(struct em_hw *hw, 2938 uint32_t reg, 2939 uint16_t *value) 2940{ 2941 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2942 *value, 2); 2943} 2944 2945void 2946em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2947 uint16_t *value) 2948{ 2949 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2950 reg, 2); 2951 return; 2952} 2953 2954void 2955em_pci_set_mwi(struct em_hw *hw) 2956{ 2957 pci_write_config(((struct em_osdep *)hw->back)->dev, 2958 PCIR_COMMAND, 2959 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 2960 return; 2961} 2962 2963void 2964em_pci_clear_mwi(struct em_hw *hw) 2965{ 2966 pci_write_config(((struct em_osdep *)hw->back)->dev, 2967 PCIR_COMMAND, 2968 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 2969 return; 2970} 2971 2972uint32_t 2973em_io_read(struct em_hw *hw, unsigned long port) 2974{ 2975 return(inl(port)); 2976} 2977 2978void 2979em_io_write(struct em_hw *hw, unsigned long port, uint32_t value) 2980{ 2981 outl(port, value); 2982 return; 2983} 2984 2985/********************************************************************* 2986* 82544 Coexistence issue workaround. 2987* There are 2 issues. 2988* 1. Transmit Hang issue. 2989* To detect this issue, following equation can be used... 2990* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 2991* If SUM[3:0] is in between 1 to 4, we will have this issue. 2992* 2993* 2. DAC issue. 2994* To detect this issue, following equation can be used... 2995* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 2996* If SUM[3:0] is in between 9 to c, we will have this issue. 2997* 2998* 2999* WORKAROUND: 3000* Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC) 3001* 3002*** *********************************************************************/ 3003static u_int32_t 3004em_fill_descriptors (u_int64_t address, 3005 u_int32_t length, 3006 PDESC_ARRAY desc_array) 3007{ 3008 /* Since issue is sensitive to length and address.*/ 3009 /* Let us first check the address...*/ 3010 u_int32_t safe_terminator; 3011 if (length <= 4) { 3012 desc_array->descriptor[0].address = address; 3013 desc_array->descriptor[0].length = length; 3014 desc_array->elements = 1; 3015 return desc_array->elements; 3016 } 3017 safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF); 3018 /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */ 3019 if (safe_terminator == 0 || 3020 (safe_terminator > 4 && 3021 safe_terminator < 9) || 3022 (safe_terminator > 0xC && 3023 safe_terminator <= 0xF)) { 3024 desc_array->descriptor[0].address = address; 3025 desc_array->descriptor[0].length = length; 3026 desc_array->elements = 1; 3027 return desc_array->elements; 3028 } 3029 3030 desc_array->descriptor[0].address = address; 3031 desc_array->descriptor[0].length = length - 4; 3032 desc_array->descriptor[1].address = address + (length - 4); 3033 desc_array->descriptor[1].length = 4; 3034 desc_array->elements = 2; 3035 return desc_array->elements; 3036} 3037 3038/********************************************************************** 3039 * 3040 * Update the board statistics counters. 3041 * 3042 **********************************************************************/ 3043static void 3044em_update_stats_counters(struct adapter *adapter) 3045{ 3046 struct ifnet *ifp; 3047 3048 if(adapter->hw.media_type == em_media_type_copper || 3049 (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) { 3050 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 3051 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 3052 } 3053 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 3054 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 3055 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 3056 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 3057 3058 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 3059 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 3060 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 3061 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 3062 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 3063 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 3064 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 3065 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 3066 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 3067 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 3068 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 3069 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 3070 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 3071 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 3072 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 3073 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 3074 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 3075 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 3076 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 3077 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 3078 3079 /* For the 64-bit byte counters the low dword must be read first. */ 3080 /* Both registers clear on the read of the high dword */ 3081 3082 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 3083 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 3084 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 3085 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 3086 3087 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 3088 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 3089 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 3090 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 3091 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 3092 3093 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 3094 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 3095 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 3096 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 3097 3098 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 3099 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 3100 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 3101 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 3102 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 3103 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 3104 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 3105 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 3106 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 3107 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 3108 3109 if (adapter->hw.mac_type >= em_82543) { 3110 adapter->stats.algnerrc += 3111 E1000_READ_REG(&adapter->hw, ALGNERRC); 3112 adapter->stats.rxerrc += 3113 E1000_READ_REG(&adapter->hw, RXERRC); 3114 adapter->stats.tncrs += 3115 E1000_READ_REG(&adapter->hw, TNCRS); 3116 adapter->stats.cexterr += 3117 E1000_READ_REG(&adapter->hw, CEXTERR); 3118 adapter->stats.tsctc += 3119 E1000_READ_REG(&adapter->hw, TSCTC); 3120 adapter->stats.tsctfc += 3121 E1000_READ_REG(&adapter->hw, TSCTFC); 3122 } 3123 ifp = &adapter->interface_data.ac_if; 3124 3125 /* Fill out the OS statistics structure */ 3126 ifp->if_ibytes = adapter->stats.gorcl; 3127 ifp->if_obytes = adapter->stats.gotcl; 3128 ifp->if_imcasts = adapter->stats.mprc; 3129 ifp->if_collisions = adapter->stats.colc; 3130 3131 /* Rx Errors */ 3132 ifp->if_ierrors = 3133 adapter->dropped_pkts + 3134 adapter->stats.rxerrc + 3135 adapter->stats.crcerrs + 3136 adapter->stats.algnerrc + 3137 adapter->stats.rlec + adapter->stats.rnbc + 3138 adapter->stats.mpc + adapter->stats.cexterr; 3139 3140 /* Tx Errors */ 3141 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 3142 3143} 3144 3145 3146/********************************************************************** 3147 * 3148 * This routine is called only when em_display_debug_stats is enabled. 3149 * This routine provides a way to take a look at important statistics 3150 * maintained by the driver and hardware. 3151 * 3152 **********************************************************************/ 3153static void 3154em_print_debug_info(struct adapter *adapter) 3155{ 3156 int unit = adapter->unit; 3157 uint8_t *hw_addr = adapter->hw.hw_addr; 3158 3159 printf("em%d: Adapter hardware address = %p \n", unit, hw_addr); 3160 printf("em%d:tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, 3161 E1000_READ_REG(&adapter->hw, TIDV), 3162 E1000_READ_REG(&adapter->hw, TADV)); 3163 printf("em%d:rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, 3164 E1000_READ_REG(&adapter->hw, RDTR), 3165 E1000_READ_REG(&adapter->hw, RADV)); 3166 3167#ifdef DBG_STATS 3168 printf("em%d: Packets not Avail = %ld\n", unit, 3169 adapter->no_pkts_avail); 3170 printf("em%d: CleanTxInterrupts = %ld\n", unit, 3171 adapter->clean_tx_interrupts); 3172#endif 3173 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 3174 (long long)adapter->tx_fifo_wrk, 3175 (long long)adapter->tx_fifo_reset); 3176 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 3177 E1000_READ_REG(&adapter->hw, TDH), 3178 E1000_READ_REG(&adapter->hw, TDT)); 3179 printf("em%d: Num Tx descriptors avail = %d\n", unit, 3180 adapter->num_tx_desc_avail); 3181 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 3182 adapter->no_tx_desc_avail1); 3183 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 3184 adapter->no_tx_desc_avail2); 3185 printf("em%d: Std mbuf failed = %ld\n", unit, 3186 adapter->mbuf_alloc_failed); 3187 printf("em%d: Std mbuf cluster failed = %ld\n", unit, 3188 adapter->mbuf_cluster_failed); 3189 printf("em%d: Driver dropped packets = %ld\n", unit, 3190 adapter->dropped_pkts); 3191 3192 return; 3193} 3194 3195static void 3196em_print_hw_stats(struct adapter *adapter) 3197{ 3198 int unit = adapter->unit; 3199 3200 printf("em%d: Excessive collisions = %lld\n", unit, 3201 (long long)adapter->stats.ecol); 3202 printf("em%d: Symbol errors = %lld\n", unit, 3203 (long long)adapter->stats.symerrs); 3204 printf("em%d: Sequence errors = %lld\n", unit, 3205 (long long)adapter->stats.sec); 3206 printf("em%d: Defer count = %lld\n", unit, 3207 (long long)adapter->stats.dc); 3208 3209 printf("em%d: Missed Packets = %lld\n", unit, 3210 (long long)adapter->stats.mpc); 3211 printf("em%d: Receive No Buffers = %lld\n", unit, 3212 (long long)adapter->stats.rnbc); 3213 printf("em%d: Receive length errors = %lld\n", unit, 3214 (long long)adapter->stats.rlec); 3215 printf("em%d: Receive errors = %lld\n", unit, 3216 (long long)adapter->stats.rxerrc); 3217 printf("em%d: Crc errors = %lld\n", unit, 3218 (long long)adapter->stats.crcerrs); 3219 printf("em%d: Alignment errors = %lld\n", unit, 3220 (long long)adapter->stats.algnerrc); 3221 printf("em%d: Carrier extension errors = %lld\n", unit, 3222 (long long)adapter->stats.cexterr); 3223 3224 printf("em%d: XON Rcvd = %lld\n", unit, 3225 (long long)adapter->stats.xonrxc); 3226 printf("em%d: XON Xmtd = %lld\n", unit, 3227 (long long)adapter->stats.xontxc); 3228 printf("em%d: XOFF Rcvd = %lld\n", unit, 3229 (long long)adapter->stats.xoffrxc); 3230 printf("em%d: XOFF Xmtd = %lld\n", unit, 3231 (long long)adapter->stats.xofftxc); 3232 3233 printf("em%d: Good Packets Rcvd = %lld\n", unit, 3234 (long long)adapter->stats.gprc); 3235 printf("em%d: Good Packets Xmtd = %lld\n", unit, 3236 (long long)adapter->stats.gptc); 3237 3238 return; 3239} 3240 3241static int 3242em_sysctl_debug_info(SYSCTL_HANDLER_ARGS) 3243{ 3244 int error; 3245 int result; 3246 struct adapter *adapter; 3247 3248 result = -1; 3249 error = sysctl_handle_int(oidp, &result, 0, req); 3250 3251 if (error || !req->newptr) 3252 return (error); 3253 3254 if (result == 1) { 3255 adapter = (struct adapter *)arg1; 3256 em_print_debug_info(adapter); 3257 } 3258 3259 return error; 3260} 3261 3262 3263static int 3264em_sysctl_stats(SYSCTL_HANDLER_ARGS) 3265{ 3266 int error; 3267 int result; 3268 struct adapter *adapter; 3269 3270 result = -1; 3271 error = sysctl_handle_int(oidp, &result, 0, req); 3272 3273 if (error || !req->newptr) 3274 return (error); 3275 3276 if (result == 1) { 3277 adapter = (struct adapter *)arg1; 3278 em_print_hw_stats(adapter); 3279 } 3280 3281 return error; 3282} 3283 3284static int 3285em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) 3286{ 3287 struct em_int_delay_info *info; 3288 struct adapter *adapter; 3289 u_int32_t regval; 3290 int error; 3291 int usecs; 3292 int ticks; 3293 int s; 3294 3295 info = (struct em_int_delay_info *)arg1; 3296 adapter = info->adapter; 3297 usecs = info->value; 3298 error = sysctl_handle_int(oidp, &usecs, 0, req); 3299 if (error != 0 || req->newptr == NULL) 3300 return error; 3301 if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535)) 3302 return EINVAL; 3303 info->value = usecs; 3304 ticks = E1000_USECS_TO_TICKS(usecs); 3305 3306 s = splimp(); 3307 regval = E1000_READ_OFFSET(&adapter->hw, info->offset); 3308 regval = (regval & ~0xffff) | (ticks & 0xffff); 3309 /* Handle a few special cases. */ 3310 switch (info->offset) { 3311 case E1000_RDTR: 3312 case E1000_82542_RDTR: 3313 regval |= E1000_RDT_FPDB; 3314 break; 3315 case E1000_TIDV: 3316 case E1000_82542_TIDV: 3317 if (ticks == 0) { 3318 adapter->txd_cmd &= ~E1000_TXD_CMD_IDE; 3319 /* Don't write 0 into the TIDV register. */ 3320 regval++; 3321 } else 3322 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 3323 break; 3324 } 3325 E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval); 3326 splx(s); 3327 return 0; 3328} 3329 3330static void 3331em_add_int_delay_sysctl(struct adapter *adapter, const char *name, 3332 const char *description, struct em_int_delay_info *info, 3333 int offset, int value) 3334{ 3335 info->adapter = adapter; 3336 info->offset = offset; 3337 info->value = value; 3338 SYSCTL_ADD_PROC(&adapter->sysctl_ctx, 3339 SYSCTL_CHILDREN(adapter->sysctl_tree), 3340 OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, 3341 info, 0, em_sysctl_int_delay, "I", description); 3342} 3343