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