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