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