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