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