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