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