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