if_em.c revision 139549
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 139549 2005-01-01 19:57:23Z tackerman $*/ 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 1150static void 1151em_tx_cb(void *arg, bus_dma_segment_t *seg, int nsegs, bus_size_t mapsize, int error) 1152{ 1153 struct em_q *q = arg; 1154 1155 if (error) 1156 return; 1157 KASSERT(nsegs <= EM_MAX_SCATTER, 1158 ("Too many DMA segments returned when mapping tx packet")); 1159 q->nsegs = nsegs; 1160 bcopy(seg, q->segs, nsegs * sizeof(seg[0])); 1161} 1162 1163/********************************************************************* 1164 * 1165 * This routine maps the mbufs to tx descriptors. 1166 * 1167 * return 0 on success, positive on failure 1168 **********************************************************************/ 1169static int 1170em_encap(struct adapter *adapter, struct mbuf **m_headp) 1171{ 1172 u_int32_t txd_upper; 1173 u_int32_t txd_lower, txd_used = 0, txd_saved = 0; 1174 int i, j, error; 1175 u_int64_t address; 1176 1177 struct mbuf *m_head; 1178 1179 /* For 82544 Workaround */ 1180 DESC_ARRAY desc_array; 1181 u_int32_t array_elements; 1182 u_int32_t counter; 1183 1184#if __FreeBSD_version < 500000 1185 struct ifvlan *ifv = NULL; 1186#else 1187 struct m_tag *mtag; 1188#endif 1189 struct em_q q; 1190 struct em_buffer *tx_buffer = NULL; 1191 struct em_tx_desc *current_tx_desc = NULL; 1192 struct ifnet *ifp = &adapter->interface_data.ac_if; 1193 1194 m_head = *m_headp; 1195 1196 /* 1197 * Force a cleanup if number of TX descriptors 1198 * available hits the threshold 1199 */ 1200 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 1201 em_clean_transmit_interrupts(adapter); 1202 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 1203 adapter->no_tx_desc_avail1++; 1204 return(ENOBUFS); 1205 } 1206 } 1207 1208 /* 1209 * Map the packet for DMA. 1210 */ 1211 if (bus_dmamap_create(adapter->txtag, BUS_DMA_NOWAIT, &q.map)) { 1212 adapter->no_tx_map_avail++; 1213 return (ENOMEM); 1214 } 1215 error = bus_dmamap_load_mbuf(adapter->txtag, q.map, 1216 m_head, em_tx_cb, &q, BUS_DMA_NOWAIT); 1217 if (error != 0) { 1218 adapter->no_tx_dma_setup++; 1219 bus_dmamap_destroy(adapter->txtag, q.map); 1220 return (error); 1221 } 1222 KASSERT(q.nsegs != 0, ("em_encap: empty packet")); 1223 1224 if (q.nsegs > adapter->num_tx_desc_avail) { 1225 adapter->no_tx_desc_avail2++; 1226 bus_dmamap_destroy(adapter->txtag, q.map); 1227 return (ENOBUFS); 1228 } 1229 1230 1231 if (ifp->if_hwassist > 0) { 1232 em_transmit_checksum_setup(adapter, m_head, 1233 &txd_upper, &txd_lower); 1234 } else 1235 txd_upper = txd_lower = 0; 1236 1237 1238 /* Find out if we are in vlan mode */ 1239#if __FreeBSD_version < 500000 1240 if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) && 1241 m_head->m_pkthdr.rcvif != NULL && 1242 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN) 1243 ifv = m_head->m_pkthdr.rcvif->if_softc; 1244#else 1245 mtag = VLAN_OUTPUT_TAG(ifp, m_head); 1246#endif 1247 1248 /* 1249 * When operating in promiscuous mode, hardware encapsulation for 1250 * packets is disabled. This means we have to add the vlan 1251 * encapsulation in the driver, since it will have come down from the 1252 * VLAN layer with a tag instead of a VLAN header. 1253 */ 1254 if (mtag != NULL && adapter->em_insert_vlan_header) { 1255 struct ether_vlan_header *evl; 1256 struct ether_header eh; 1257 1258 m_head = m_pullup(m_head, sizeof(eh)); 1259 if (m_head == NULL) { 1260 *m_headp = NULL; 1261 bus_dmamap_destroy(adapter->txtag, q.map); 1262 return (ENOBUFS); 1263 } 1264 eh = *mtod(m_head, struct ether_header *); 1265 M_PREPEND(m_head, sizeof(*evl), M_DONTWAIT); 1266 if (m_head == NULL) { 1267 *m_headp = NULL; 1268 bus_dmamap_destroy(adapter->txtag, q.map); 1269 return (ENOBUFS); 1270 } 1271 m_head = m_pullup(m_head, sizeof(*evl)); 1272 if (m_head == NULL) { 1273 *m_headp = NULL; 1274 bus_dmamap_destroy(adapter->txtag, q.map); 1275 return (ENOBUFS); 1276 } 1277 evl = mtod(m_head, struct ether_vlan_header *); 1278 bcopy(&eh, evl, sizeof(*evl)); 1279 evl->evl_proto = evl->evl_encap_proto; 1280 evl->evl_encap_proto = htons(ETHERTYPE_VLAN); 1281 evl->evl_tag = htons(VLAN_TAG_VALUE(mtag)); 1282 m_tag_delete(m_head, mtag); 1283 mtag = NULL; 1284 *m_headp = m_head; 1285 } 1286 1287 i = adapter->next_avail_tx_desc; 1288 if (adapter->pcix_82544) { 1289 txd_saved = i; 1290 txd_used = 0; 1291 } 1292 for (j = 0; j < q.nsegs; j++) { 1293 /* If adapter is 82544 and on PCIX bus */ 1294 if(adapter->pcix_82544) { 1295 array_elements = 0; 1296 address = htole64(q.segs[j].ds_addr); 1297 /* 1298 * Check the Address and Length combination and 1299 * split the data accordingly 1300 */ 1301 array_elements = em_fill_descriptors(address, 1302 htole32(q.segs[j].ds_len), 1303 &desc_array); 1304 for (counter = 0; counter < array_elements; counter++) { 1305 if (txd_used == adapter->num_tx_desc_avail) { 1306 adapter->next_avail_tx_desc = txd_saved; 1307 adapter->no_tx_desc_avail2++; 1308 bus_dmamap_destroy(adapter->txtag, q.map); 1309 return (ENOBUFS); 1310 } 1311 tx_buffer = &adapter->tx_buffer_area[i]; 1312 current_tx_desc = &adapter->tx_desc_base[i]; 1313 current_tx_desc->buffer_addr = htole64( 1314 desc_array.descriptor[counter].address); 1315 current_tx_desc->lower.data = htole32( 1316 (adapter->txd_cmd | txd_lower | 1317 (u_int16_t)desc_array.descriptor[counter].length)); 1318 current_tx_desc->upper.data = htole32((txd_upper)); 1319 if (++i == adapter->num_tx_desc) 1320 i = 0; 1321 1322 tx_buffer->m_head = NULL; 1323 txd_used++; 1324 } 1325 } else { 1326 tx_buffer = &adapter->tx_buffer_area[i]; 1327 current_tx_desc = &adapter->tx_desc_base[i]; 1328 1329 current_tx_desc->buffer_addr = htole64(q.segs[j].ds_addr); 1330 current_tx_desc->lower.data = htole32( 1331 adapter->txd_cmd | txd_lower | q.segs[j].ds_len); 1332 current_tx_desc->upper.data = htole32(txd_upper); 1333 1334 if (++i == adapter->num_tx_desc) 1335 i = 0; 1336 1337 tx_buffer->m_head = NULL; 1338 } 1339 } 1340 1341 adapter->next_avail_tx_desc = i; 1342 if (adapter->pcix_82544) { 1343 adapter->num_tx_desc_avail -= txd_used; 1344 } 1345 else { 1346 adapter->num_tx_desc_avail -= q.nsegs; 1347 } 1348 1349#if __FreeBSD_version < 500000 1350 if (ifv != NULL) { 1351 /* Set the vlan id */ 1352 current_tx_desc->upper.fields.special = htole16(ifv->ifv_tag); 1353#else 1354 if (mtag != NULL) { 1355 /* Set the vlan id */ 1356 current_tx_desc->upper.fields.special = htole16(VLAN_TAG_VALUE(mtag)); 1357#endif 1358 1359 /* Tell hardware to add tag */ 1360 current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_VLE); 1361 } 1362 1363 tx_buffer->m_head = m_head; 1364 tx_buffer->map = q.map; 1365 bus_dmamap_sync(adapter->txtag, q.map, BUS_DMASYNC_PREWRITE); 1366 1367 /* 1368 * Last Descriptor of Packet needs End Of Packet (EOP) 1369 */ 1370 current_tx_desc->lower.data |= htole32(E1000_TXD_CMD_EOP); 1371 1372 /* 1373 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 1374 * that this frame is available to transmit. 1375 */ 1376 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, 1377 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 1378 if (adapter->hw.mac_type == em_82547 && 1379 adapter->link_duplex == HALF_DUPLEX) { 1380 em_82547_move_tail_locked(adapter); 1381 } else { 1382 E1000_WRITE_REG(&adapter->hw, TDT, i); 1383 if (adapter->hw.mac_type == em_82547) { 1384 em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len); 1385 } 1386 } 1387 1388 return(0); 1389} 1390 1391/********************************************************************* 1392 * 1393 * 82547 workaround to avoid controller hang in half-duplex environment. 1394 * The workaround is to avoid queuing a large packet that would span 1395 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers 1396 * in this case. We do that only when FIFO is quiescent. 1397 * 1398 **********************************************************************/ 1399static void 1400em_82547_move_tail_locked(struct adapter *adapter) 1401{ 1402 uint16_t hw_tdt; 1403 uint16_t sw_tdt; 1404 struct em_tx_desc *tx_desc; 1405 uint16_t length = 0; 1406 boolean_t eop = 0; 1407 1408 EM_LOCK_ASSERT(adapter); 1409 1410 hw_tdt = E1000_READ_REG(&adapter->hw, TDT); 1411 sw_tdt = adapter->next_avail_tx_desc; 1412 1413 while (hw_tdt != sw_tdt) { 1414 tx_desc = &adapter->tx_desc_base[hw_tdt]; 1415 length += tx_desc->lower.flags.length; 1416 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP; 1417 if(++hw_tdt == adapter->num_tx_desc) 1418 hw_tdt = 0; 1419 1420 if(eop) { 1421 if (em_82547_fifo_workaround(adapter, length)) { 1422 adapter->tx_fifo_wrk_cnt++; 1423 callout_reset(&adapter->tx_fifo_timer, 1, 1424 em_82547_move_tail, adapter); 1425 break; 1426 } 1427 E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt); 1428 em_82547_update_fifo_head(adapter, length); 1429 length = 0; 1430 } 1431 } 1432 return; 1433} 1434 1435static void 1436em_82547_move_tail(void *arg) 1437{ 1438 struct adapter *adapter = arg; 1439 1440 EM_LOCK(adapter); 1441 em_82547_move_tail_locked(adapter); 1442 EM_UNLOCK(adapter); 1443} 1444 1445static int 1446em_82547_fifo_workaround(struct adapter *adapter, int len) 1447{ 1448 int fifo_space, fifo_pkt_len; 1449 1450 fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1451 1452 if (adapter->link_duplex == HALF_DUPLEX) { 1453 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head; 1454 1455 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) { 1456 if (em_82547_tx_fifo_reset(adapter)) { 1457 return(0); 1458 } 1459 else { 1460 return(1); 1461 } 1462 } 1463 } 1464 1465 return(0); 1466} 1467 1468static void 1469em_82547_update_fifo_head(struct adapter *adapter, int len) 1470{ 1471 int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1472 1473 /* tx_fifo_head is always 16 byte aligned */ 1474 adapter->tx_fifo_head += fifo_pkt_len; 1475 if (adapter->tx_fifo_head >= adapter->tx_fifo_size) { 1476 adapter->tx_fifo_head -= adapter->tx_fifo_size; 1477 } 1478 1479 return; 1480} 1481 1482 1483static int 1484em_82547_tx_fifo_reset(struct adapter *adapter) 1485{ 1486 uint32_t tctl; 1487 1488 if ( (E1000_READ_REG(&adapter->hw, TDT) == 1489 E1000_READ_REG(&adapter->hw, TDH)) && 1490 (E1000_READ_REG(&adapter->hw, TDFT) == 1491 E1000_READ_REG(&adapter->hw, TDFH)) && 1492 (E1000_READ_REG(&adapter->hw, TDFTS) == 1493 E1000_READ_REG(&adapter->hw, TDFHS)) && 1494 (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) { 1495 1496 /* Disable TX unit */ 1497 tctl = E1000_READ_REG(&adapter->hw, TCTL); 1498 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN); 1499 1500 /* Reset FIFO pointers */ 1501 E1000_WRITE_REG(&adapter->hw, TDFT, adapter->tx_head_addr); 1502 E1000_WRITE_REG(&adapter->hw, TDFH, adapter->tx_head_addr); 1503 E1000_WRITE_REG(&adapter->hw, TDFTS, adapter->tx_head_addr); 1504 E1000_WRITE_REG(&adapter->hw, TDFHS, adapter->tx_head_addr); 1505 1506 /* Re-enable TX unit */ 1507 E1000_WRITE_REG(&adapter->hw, TCTL, tctl); 1508 E1000_WRITE_FLUSH(&adapter->hw); 1509 1510 adapter->tx_fifo_head = 0; 1511 adapter->tx_fifo_reset_cnt++; 1512 1513 return(TRUE); 1514 } 1515 else { 1516 return(FALSE); 1517 } 1518} 1519 1520static void 1521em_set_promisc(struct adapter * adapter) 1522{ 1523 1524 u_int32_t reg_rctl; 1525 u_int32_t ctrl; 1526 struct ifnet *ifp = &adapter->interface_data.ac_if; 1527 1528 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1529 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 1530 1531 if (ifp->if_flags & IFF_PROMISC) { 1532 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 1533 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1534 /* Disable VLAN stripping in promiscous mode 1535 * This enables bridging of vlan tagged frames to occur 1536 * and also allows vlan tags to be seen in tcpdump 1537 */ 1538 ctrl &= ~E1000_CTRL_VME; 1539 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 1540 adapter->em_insert_vlan_header = 1; 1541 } else if (ifp->if_flags & IFF_ALLMULTI) { 1542 reg_rctl |= E1000_RCTL_MPE; 1543 reg_rctl &= ~E1000_RCTL_UPE; 1544 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1545 adapter->em_insert_vlan_header = 0; 1546 } else 1547 adapter->em_insert_vlan_header = 0; 1548 1549 return; 1550} 1551 1552static void 1553em_disable_promisc(struct adapter * adapter) 1554{ 1555 u_int32_t reg_rctl; 1556 1557 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1558 1559 reg_rctl &= (~E1000_RCTL_UPE); 1560 reg_rctl &= (~E1000_RCTL_MPE); 1561 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1562 1563 em_enable_vlans(adapter); 1564 adapter->em_insert_vlan_header = 0; 1565 1566 return; 1567} 1568 1569 1570/********************************************************************* 1571 * Multicast Update 1572 * 1573 * This routine is called whenever multicast address list is updated. 1574 * 1575 **********************************************************************/ 1576 1577static void 1578em_set_multi(struct adapter * adapter) 1579{ 1580 u_int32_t reg_rctl = 0; 1581 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; 1582 struct ifmultiaddr *ifma; 1583 int mcnt = 0; 1584 struct ifnet *ifp = &adapter->interface_data.ac_if; 1585 1586 IOCTL_DEBUGOUT("em_set_multi: begin"); 1587 1588 if (adapter->hw.mac_type == em_82542_rev2_0) { 1589 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1590 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1591 em_pci_clear_mwi(&adapter->hw); 1592 } 1593 reg_rctl |= E1000_RCTL_RST; 1594 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1595 msec_delay(5); 1596 } 1597 1598#if __FreeBSD_version < 500000 1599 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1600#else 1601 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1602#endif 1603 if (ifma->ifma_addr->sa_family != AF_LINK) 1604 continue; 1605 1606 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break; 1607 1608 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1609 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 1610 mcnt++; 1611 } 1612 1613 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) { 1614 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1615 reg_rctl |= E1000_RCTL_MPE; 1616 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1617 } else 1618 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1); 1619 1620 if (adapter->hw.mac_type == em_82542_rev2_0) { 1621 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1622 reg_rctl &= ~E1000_RCTL_RST; 1623 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1624 msec_delay(5); 1625 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1626 em_pci_set_mwi(&adapter->hw); 1627 } 1628 } 1629 1630 return; 1631} 1632 1633 1634/********************************************************************* 1635 * Timer routine 1636 * 1637 * This routine checks for link status and updates statistics. 1638 * 1639 **********************************************************************/ 1640 1641static void 1642em_local_timer(void *arg) 1643{ 1644 struct ifnet *ifp; 1645 struct adapter * adapter = arg; 1646 ifp = &adapter->interface_data.ac_if; 1647 1648 EM_LOCK(adapter); 1649 1650 em_check_for_link(&adapter->hw); 1651 em_print_link_status(adapter); 1652 em_update_stats_counters(adapter); 1653 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 1654 em_print_hw_stats(adapter); 1655 } 1656 em_smartspeed(adapter); 1657 1658 callout_reset(&adapter->timer, 2*hz, em_local_timer, adapter); 1659 1660 EM_UNLOCK(adapter); 1661 return; 1662} 1663 1664static void 1665em_print_link_status(struct adapter * adapter) 1666{ 1667 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1668 if (adapter->link_active == 0) { 1669 em_get_speed_and_duplex(&adapter->hw, 1670 &adapter->link_speed, 1671 &adapter->link_duplex); 1672 if (bootverbose) 1673 printf("em%d: Link is up %d Mbps %s\n", 1674 adapter->unit, 1675 adapter->link_speed, 1676 ((adapter->link_duplex == FULL_DUPLEX) ? 1677 "Full Duplex" : "Half Duplex")); 1678 adapter->link_active = 1; 1679 adapter->smartspeed = 0; 1680 } 1681 } else { 1682 if (adapter->link_active == 1) { 1683 adapter->link_speed = 0; 1684 adapter->link_duplex = 0; 1685 if (bootverbose) 1686 printf("em%d: Link is Down\n", adapter->unit); 1687 adapter->link_active = 0; 1688 } 1689 } 1690 1691 return; 1692} 1693 1694/********************************************************************* 1695 * 1696 * This routine disables all traffic on the adapter by issuing a 1697 * global reset on the MAC and deallocates TX/RX buffers. 1698 * 1699 **********************************************************************/ 1700 1701static void 1702em_stop(void *arg) 1703{ 1704 struct ifnet *ifp; 1705 struct adapter * adapter = arg; 1706 ifp = &adapter->interface_data.ac_if; 1707 1708 mtx_assert(&adapter->mtx, MA_OWNED); 1709 1710 INIT_DEBUGOUT("em_stop: begin"); 1711 em_disable_intr(adapter); 1712 em_reset_hw(&adapter->hw); 1713 callout_stop(&adapter->timer); 1714 callout_stop(&adapter->tx_fifo_timer); 1715 em_free_transmit_structures(adapter); 1716 em_free_receive_structures(adapter); 1717 1718 1719 /* Tell the stack that the interface is no longer active */ 1720 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1721 1722 return; 1723} 1724 1725 1726/********************************************************************* 1727 * 1728 * Determine hardware revision. 1729 * 1730 **********************************************************************/ 1731static void 1732em_identify_hardware(struct adapter * adapter) 1733{ 1734 device_t dev = adapter->dev; 1735 1736 /* Make sure our PCI config space has the necessary stuff set */ 1737 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1738 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1739 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1740 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1741 adapter->unit); 1742 adapter->hw.pci_cmd_word |= 1743 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1744 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1745 } 1746 1747 /* Save off the information about this board */ 1748 adapter->hw.vendor_id = pci_get_vendor(dev); 1749 adapter->hw.device_id = pci_get_device(dev); 1750 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1751 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1752 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1753 1754 /* Identify the MAC */ 1755 if (em_set_mac_type(&adapter->hw)) 1756 printf("em%d: Unknown MAC Type\n", adapter->unit); 1757 1758 if(adapter->hw.mac_type == em_82541 || 1759 adapter->hw.mac_type == em_82541_rev_2 || 1760 adapter->hw.mac_type == em_82547 || 1761 adapter->hw.mac_type == em_82547_rev_2) 1762 adapter->hw.phy_init_script = TRUE; 1763 1764 return; 1765} 1766 1767static int 1768em_allocate_pci_resources(struct adapter * adapter) 1769{ 1770 int i, val, rid; 1771 device_t dev = adapter->dev; 1772 1773 rid = EM_MMBA; 1774 adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 1775 &rid, RF_ACTIVE); 1776 if (!(adapter->res_memory)) { 1777 printf("em%d: Unable to allocate bus resource: memory\n", 1778 adapter->unit); 1779 return(ENXIO); 1780 } 1781 adapter->osdep.mem_bus_space_tag = 1782 rman_get_bustag(adapter->res_memory); 1783 adapter->osdep.mem_bus_space_handle = 1784 rman_get_bushandle(adapter->res_memory); 1785 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1786 1787 1788 if (adapter->hw.mac_type > em_82543) { 1789 /* Figure our where our IO BAR is ? */ 1790 rid = EM_MMBA; 1791 for (i = 0; i < 5; i++) { 1792 val = pci_read_config(dev, rid, 4); 1793 if (val & 0x00000001) { 1794 adapter->io_rid = rid; 1795 break; 1796 } 1797 rid += 4; 1798 } 1799 1800 adapter->res_ioport = bus_alloc_resource_any(dev, 1801 SYS_RES_IOPORT, 1802 &adapter->io_rid, 1803 RF_ACTIVE); 1804 if (!(adapter->res_ioport)) { 1805 printf("em%d: Unable to allocate bus resource: ioport\n", 1806 adapter->unit); 1807 return(ENXIO); 1808 } 1809 1810 adapter->hw.io_base = 1811 rman_get_start(adapter->res_ioport); 1812 } 1813 1814 rid = 0x0; 1815 adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 1816 RF_SHAREABLE | 1817 RF_ACTIVE); 1818 if (!(adapter->res_interrupt)) { 1819 printf("em%d: Unable to allocate bus resource: interrupt\n", 1820 adapter->unit); 1821 return(ENXIO); 1822 } 1823 if (bus_setup_intr(dev, adapter->res_interrupt, 1824 INTR_TYPE_NET | INTR_MPSAFE, 1825 (void (*)(void *)) em_intr, adapter, 1826 &adapter->int_handler_tag)) { 1827 printf("em%d: Error registering interrupt handler!\n", 1828 adapter->unit); 1829 return(ENXIO); 1830 } 1831 1832 adapter->hw.back = &adapter->osdep; 1833 1834 return(0); 1835} 1836 1837static void 1838em_free_pci_resources(struct adapter * adapter) 1839{ 1840 device_t dev = adapter->dev; 1841 1842 if (adapter->res_interrupt != NULL) { 1843 bus_teardown_intr(dev, adapter->res_interrupt, 1844 adapter->int_handler_tag); 1845 bus_release_resource(dev, SYS_RES_IRQ, 0, 1846 adapter->res_interrupt); 1847 } 1848 if (adapter->res_memory != NULL) { 1849 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1850 adapter->res_memory); 1851 } 1852 1853 if (adapter->res_ioport != NULL) { 1854 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1855 adapter->res_ioport); 1856 } 1857 return; 1858} 1859 1860/********************************************************************* 1861 * 1862 * Initialize the hardware to a configuration as specified by the 1863 * adapter structure. The controller is reset, the EEPROM is 1864 * verified, the MAC address is set, then the shared initialization 1865 * routines are called. 1866 * 1867 **********************************************************************/ 1868static int 1869em_hardware_init(struct adapter * adapter) 1870{ 1871 INIT_DEBUGOUT("em_hardware_init: begin"); 1872 /* Issue a global reset */ 1873 em_reset_hw(&adapter->hw); 1874 1875 /* When hardware is reset, fifo_head is also reset */ 1876 adapter->tx_fifo_head = 0; 1877 1878 /* Make sure we have a good EEPROM before we read from it */ 1879 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1880 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1881 adapter->unit); 1882 return(EIO); 1883 } 1884 1885 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1886 printf("em%d: EEPROM read error while reading part number\n", 1887 adapter->unit); 1888 return(EIO); 1889 } 1890 1891 if (em_init_hw(&adapter->hw) < 0) { 1892 printf("em%d: Hardware Initialization Failed", 1893 adapter->unit); 1894 return(EIO); 1895 } 1896 1897 em_check_for_link(&adapter->hw); 1898 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1899 adapter->link_active = 1; 1900 else 1901 adapter->link_active = 0; 1902 1903 if (adapter->link_active) { 1904 em_get_speed_and_duplex(&adapter->hw, 1905 &adapter->link_speed, 1906 &adapter->link_duplex); 1907 } else { 1908 adapter->link_speed = 0; 1909 adapter->link_duplex = 0; 1910 } 1911 1912 return(0); 1913} 1914 1915/********************************************************************* 1916 * 1917 * Setup networking device structure and register an interface. 1918 * 1919 **********************************************************************/ 1920static void 1921em_setup_interface(device_t dev, struct adapter * adapter) 1922{ 1923 struct ifnet *ifp; 1924 INIT_DEBUGOUT("em_setup_interface: begin"); 1925 1926 ifp = &adapter->interface_data.ac_if; 1927 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1928 ifp->if_mtu = ETHERMTU; 1929 ifp->if_baudrate = 1000000000; 1930 ifp->if_init = em_init; 1931 ifp->if_softc = adapter; 1932 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1933 ifp->if_ioctl = em_ioctl; 1934 ifp->if_start = em_start; 1935 ifp->if_watchdog = em_watchdog; 1936 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1); 1937 ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1; 1938 IFQ_SET_READY(&ifp->if_snd); 1939 1940#if __FreeBSD_version < 500000 1941 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1942#else 1943 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1944#endif 1945 1946 ifp->if_capabilities = ifp->if_capenable = 0; 1947 1948 if (adapter->hw.mac_type >= em_82543) { 1949 ifp->if_capabilities |= IFCAP_HWCSUM; 1950 ifp->if_capenable |= IFCAP_HWCSUM; 1951 } 1952 1953 /* 1954 * Tell the upper layer(s) we support long frames. 1955 */ 1956 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1957#if __FreeBSD_version >= 500000 1958 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1959 ifp->if_capenable |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1960#endif 1961 1962#ifdef DEVICE_POLLING 1963 ifp->if_capabilities |= IFCAP_POLLING; 1964 ifp->if_capenable |= IFCAP_POLLING; 1965#endif 1966 1967 /* 1968 * Specify the media types supported by this adapter and register 1969 * callbacks to update media and link information 1970 */ 1971 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1972 em_media_status); 1973 if (adapter->hw.media_type == em_media_type_fiber) { 1974 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1975 0, NULL); 1976 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1977 0, NULL); 1978 } else { 1979 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1980 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1981 0, NULL); 1982 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1983 0, NULL); 1984 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1985 0, NULL); 1986#if __FreeBSD_version < 500000 1987 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1988 0, NULL); 1989 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1990#else 1991 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1992 0, NULL); 1993 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1994#endif 1995 } 1996 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1997 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1998 1999 return; 2000} 2001 2002 2003/********************************************************************* 2004 * 2005 * Workaround for SmartSpeed on 82541 and 82547 controllers 2006 * 2007 **********************************************************************/ 2008static void 2009em_smartspeed(struct adapter *adapter) 2010{ 2011 uint16_t phy_tmp; 2012 2013 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 2014 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 2015 return; 2016 2017 if(adapter->smartspeed == 0) { 2018 /* If Master/Slave config fault is asserted twice, 2019 * we assume back-to-back */ 2020 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 2021 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 2022 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 2023 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 2024 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 2025 &phy_tmp); 2026 if(phy_tmp & CR_1000T_MS_ENABLE) { 2027 phy_tmp &= ~CR_1000T_MS_ENABLE; 2028 em_write_phy_reg(&adapter->hw, 2029 PHY_1000T_CTRL, phy_tmp); 2030 adapter->smartspeed++; 2031 if(adapter->hw.autoneg && 2032 !em_phy_setup_autoneg(&adapter->hw) && 2033 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 2034 &phy_tmp)) { 2035 phy_tmp |= (MII_CR_AUTO_NEG_EN | 2036 MII_CR_RESTART_AUTO_NEG); 2037 em_write_phy_reg(&adapter->hw, 2038 PHY_CTRL, phy_tmp); 2039 } 2040 } 2041 } 2042 return; 2043 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 2044 /* If still no link, perhaps using 2/3 pair cable */ 2045 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 2046 phy_tmp |= CR_1000T_MS_ENABLE; 2047 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 2048 if(adapter->hw.autoneg && 2049 !em_phy_setup_autoneg(&adapter->hw) && 2050 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 2051 phy_tmp |= (MII_CR_AUTO_NEG_EN | 2052 MII_CR_RESTART_AUTO_NEG); 2053 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 2054 } 2055 } 2056 /* Restart process after EM_SMARTSPEED_MAX iterations */ 2057 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 2058 adapter->smartspeed = 0; 2059 2060 return; 2061} 2062 2063 2064/* 2065 * Manage DMA'able memory. 2066 */ 2067static void 2068em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 2069{ 2070 if (error) 2071 return; 2072 *(bus_addr_t*) arg = segs->ds_addr; 2073 return; 2074} 2075 2076static int 2077em_dma_malloc(struct adapter *adapter, bus_size_t size, 2078 struct em_dma_alloc *dma, int mapflags) 2079{ 2080 int r; 2081 2082 r = bus_dma_tag_create(NULL, /* parent */ 2083 PAGE_SIZE, 0, /* alignment, bounds */ 2084 BUS_SPACE_MAXADDR, /* lowaddr */ 2085 BUS_SPACE_MAXADDR, /* highaddr */ 2086 NULL, NULL, /* filter, filterarg */ 2087 size, /* maxsize */ 2088 1, /* nsegments */ 2089 size, /* maxsegsize */ 2090 BUS_DMA_ALLOCNOW, /* flags */ 2091 NULL, /* lockfunc */ 2092 NULL, /* lockarg */ 2093 &dma->dma_tag); 2094 if (r != 0) { 2095 printf("em%d: em_dma_malloc: bus_dma_tag_create failed; " 2096 "error %u\n", adapter->unit, r); 2097 goto fail_0; 2098 } 2099 2100 r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, 2101 BUS_DMA_NOWAIT, &dma->dma_map); 2102 if (r != 0) { 2103 printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; " 2104 "size %ju, error %d\n", adapter->unit, 2105 (uintmax_t)size, r); 2106 goto fail_2; 2107 } 2108 2109 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 2110 size, 2111 em_dmamap_cb, 2112 &dma->dma_paddr, 2113 mapflags | BUS_DMA_NOWAIT); 2114 if (r != 0) { 2115 printf("em%d: em_dma_malloc: bus_dmamap_load failed; " 2116 "error %u\n", adapter->unit, r); 2117 goto fail_3; 2118 } 2119 2120 dma->dma_size = size; 2121 return (0); 2122 2123fail_3: 2124 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2125fail_2: 2126 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2127 bus_dma_tag_destroy(dma->dma_tag); 2128fail_0: 2129 dma->dma_map = NULL; 2130 dma->dma_tag = NULL; 2131 return (r); 2132} 2133 2134static void 2135em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) 2136{ 2137 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2138 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2139 bus_dma_tag_destroy(dma->dma_tag); 2140} 2141 2142 2143/********************************************************************* 2144 * 2145 * Allocate memory for tx_buffer structures. The tx_buffer stores all 2146 * the information needed to transmit a packet on the wire. 2147 * 2148 **********************************************************************/ 2149static int 2150em_allocate_transmit_structures(struct adapter * adapter) 2151{ 2152 if (!(adapter->tx_buffer_area = 2153 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2154 adapter->num_tx_desc, M_DEVBUF, 2155 M_NOWAIT))) { 2156 printf("em%d: Unable to allocate tx_buffer memory\n", 2157 adapter->unit); 2158 return ENOMEM; 2159 } 2160 2161 bzero(adapter->tx_buffer_area, 2162 sizeof(struct em_buffer) * adapter->num_tx_desc); 2163 2164 return 0; 2165} 2166 2167/********************************************************************* 2168 * 2169 * Allocate and initialize transmit structures. 2170 * 2171 **********************************************************************/ 2172static int 2173em_setup_transmit_structures(struct adapter * adapter) 2174{ 2175 /* 2176 * Setup DMA descriptor areas. 2177 */ 2178 if (bus_dma_tag_create(NULL, /* parent */ 2179 1, 0, /* alignment, bounds */ 2180 BUS_SPACE_MAXADDR, /* lowaddr */ 2181 BUS_SPACE_MAXADDR, /* highaddr */ 2182 NULL, NULL, /* filter, filterarg */ 2183 MCLBYTES * 8, /* maxsize */ 2184 EM_MAX_SCATTER, /* nsegments */ 2185 MCLBYTES * 8, /* maxsegsize */ 2186 BUS_DMA_ALLOCNOW, /* flags */ 2187 NULL, /* lockfunc */ 2188 NULL, /* lockarg */ 2189 &adapter->txtag)) { 2190 printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit); 2191 return (ENOMEM); 2192 } 2193 2194 if (em_allocate_transmit_structures(adapter)) 2195 return (ENOMEM); 2196 2197 bzero((void *) adapter->tx_desc_base, 2198 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 2199 2200 adapter->next_avail_tx_desc = 0; 2201 adapter->oldest_used_tx_desc = 0; 2202 2203 /* Set number of descriptors available */ 2204 adapter->num_tx_desc_avail = adapter->num_tx_desc; 2205 2206 /* Set checksum context */ 2207 adapter->active_checksum_context = OFFLOAD_NONE; 2208 2209 return (0); 2210} 2211 2212/********************************************************************* 2213 * 2214 * Enable transmit unit. 2215 * 2216 **********************************************************************/ 2217static void 2218em_initialize_transmit_unit(struct adapter * adapter) 2219{ 2220 u_int32_t reg_tctl; 2221 u_int32_t reg_tipg = 0; 2222 u_int64_t bus_addr; 2223 2224 INIT_DEBUGOUT("em_initialize_transmit_unit: begin"); 2225 /* Setup the Base and Length of the Tx Descriptor Ring */ 2226 bus_addr = adapter->txdma.dma_paddr; 2227 E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr); 2228 E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32)); 2229 E1000_WRITE_REG(&adapter->hw, TDLEN, 2230 adapter->num_tx_desc * 2231 sizeof(struct em_tx_desc)); 2232 2233 /* Setup the HW Tx Head and Tail descriptor pointers */ 2234 E1000_WRITE_REG(&adapter->hw, TDH, 0); 2235 E1000_WRITE_REG(&adapter->hw, TDT, 0); 2236 2237 2238 HW_DEBUGOUT2("Base = %x, Length = %x\n", 2239 E1000_READ_REG(&adapter->hw, TDBAL), 2240 E1000_READ_REG(&adapter->hw, TDLEN)); 2241 2242 /* Set the default values for the Tx Inter Packet Gap timer */ 2243 switch (adapter->hw.mac_type) { 2244 case em_82542_rev2_0: 2245 case em_82542_rev2_1: 2246 reg_tipg = DEFAULT_82542_TIPG_IPGT; 2247 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2248 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2249 break; 2250 default: 2251 if (adapter->hw.media_type == em_media_type_fiber) 2252 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 2253 else 2254 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 2255 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2256 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2257 } 2258 2259 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 2260 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value); 2261 if(adapter->hw.mac_type >= em_82540) 2262 E1000_WRITE_REG(&adapter->hw, TADV, 2263 adapter->tx_abs_int_delay.value); 2264 2265 /* Program the Transmit Control Register */ 2266 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 2267 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 2268 if (adapter->link_duplex == 1) { 2269 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2270 } else { 2271 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2272 } 2273 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 2274 2275 /* Setup Transmit Descriptor Settings for this adapter */ 2276 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 2277 2278 if (adapter->tx_int_delay.value > 0) 2279 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 2280 2281 return; 2282} 2283 2284/********************************************************************* 2285 * 2286 * Free all transmit related data structures. 2287 * 2288 **********************************************************************/ 2289static void 2290em_free_transmit_structures(struct adapter * adapter) 2291{ 2292 struct em_buffer *tx_buffer; 2293 int i; 2294 2295 INIT_DEBUGOUT("free_transmit_structures: begin"); 2296 2297 if (adapter->tx_buffer_area != NULL) { 2298 tx_buffer = adapter->tx_buffer_area; 2299 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 2300 if (tx_buffer->m_head != NULL) { 2301 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2302 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2303 m_freem(tx_buffer->m_head); 2304 } 2305 tx_buffer->m_head = NULL; 2306 } 2307 } 2308 if (adapter->tx_buffer_area != NULL) { 2309 free(adapter->tx_buffer_area, M_DEVBUF); 2310 adapter->tx_buffer_area = NULL; 2311 } 2312 if (adapter->txtag != NULL) { 2313 bus_dma_tag_destroy(adapter->txtag); 2314 adapter->txtag = NULL; 2315 } 2316 return; 2317} 2318 2319/********************************************************************* 2320 * 2321 * The offload context needs to be set when we transfer the first 2322 * packet of a particular protocol (TCP/UDP). We change the 2323 * context only if the protocol type changes. 2324 * 2325 **********************************************************************/ 2326static void 2327em_transmit_checksum_setup(struct adapter * adapter, 2328 struct mbuf *mp, 2329 u_int32_t *txd_upper, 2330 u_int32_t *txd_lower) 2331{ 2332 struct em_context_desc *TXD; 2333 struct em_buffer *tx_buffer; 2334 int curr_txd; 2335 2336 if (mp->m_pkthdr.csum_flags) { 2337 2338 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 2339 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2340 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2341 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 2342 return; 2343 else 2344 adapter->active_checksum_context = OFFLOAD_TCP_IP; 2345 2346 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 2347 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2348 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2349 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 2350 return; 2351 else 2352 adapter->active_checksum_context = OFFLOAD_UDP_IP; 2353 } else { 2354 *txd_upper = 0; 2355 *txd_lower = 0; 2356 return; 2357 } 2358 } else { 2359 *txd_upper = 0; 2360 *txd_lower = 0; 2361 return; 2362 } 2363 2364 /* If we reach this point, the checksum offload context 2365 * needs to be reset. 2366 */ 2367 curr_txd = adapter->next_avail_tx_desc; 2368 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 2369 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 2370 2371 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 2372 TXD->lower_setup.ip_fields.ipcso = 2373 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 2374 TXD->lower_setup.ip_fields.ipcse = 2375 htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1); 2376 2377 TXD->upper_setup.tcp_fields.tucss = 2378 ETHER_HDR_LEN + sizeof(struct ip); 2379 TXD->upper_setup.tcp_fields.tucse = htole16(0); 2380 2381 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 2382 TXD->upper_setup.tcp_fields.tucso = 2383 ETHER_HDR_LEN + sizeof(struct ip) + 2384 offsetof(struct tcphdr, th_sum); 2385 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 2386 TXD->upper_setup.tcp_fields.tucso = 2387 ETHER_HDR_LEN + sizeof(struct ip) + 2388 offsetof(struct udphdr, uh_sum); 2389 } 2390 2391 TXD->tcp_seg_setup.data = htole32(0); 2392 TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT); 2393 2394 tx_buffer->m_head = NULL; 2395 2396 if (++curr_txd == adapter->num_tx_desc) 2397 curr_txd = 0; 2398 2399 adapter->num_tx_desc_avail--; 2400 adapter->next_avail_tx_desc = curr_txd; 2401 2402 return; 2403} 2404 2405/********************************************************************** 2406 * 2407 * Examine each tx_buffer in the used queue. If the hardware is done 2408 * processing the packet then free associated resources. The 2409 * tx_buffer is put back on the free queue. 2410 * 2411 **********************************************************************/ 2412static void 2413em_clean_transmit_interrupts(struct adapter * adapter) 2414{ 2415 int i, num_avail; 2416 struct em_buffer *tx_buffer; 2417 struct em_tx_desc *tx_desc; 2418 struct ifnet *ifp = &adapter->interface_data.ac_if; 2419 2420 mtx_assert(&adapter->mtx, MA_OWNED); 2421 2422 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2423 return; 2424 2425#ifdef DBG_STATS 2426 adapter->clean_tx_interrupts++; 2427#endif 2428 num_avail = adapter->num_tx_desc_avail; 2429 i = adapter->oldest_used_tx_desc; 2430 2431 tx_buffer = &adapter->tx_buffer_area[i]; 2432 tx_desc = &adapter->tx_desc_base[i]; 2433 2434 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, 2435 BUS_DMASYNC_POSTREAD); 2436 while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 2437 2438 tx_desc->upper.data = 0; 2439 num_avail++; 2440 2441 if (tx_buffer->m_head) { 2442 ifp->if_opackets++; 2443 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2444 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2445 2446 m_freem(tx_buffer->m_head); 2447 tx_buffer->m_head = NULL; 2448 } 2449 2450 if (++i == adapter->num_tx_desc) 2451 i = 0; 2452 2453 tx_buffer = &adapter->tx_buffer_area[i]; 2454 tx_desc = &adapter->tx_desc_base[i]; 2455 } 2456 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, 2457 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2458 2459 adapter->oldest_used_tx_desc = i; 2460 2461 /* 2462 * If we have enough room, clear IFF_OACTIVE to tell the stack 2463 * that it is OK to send packets. 2464 * If there are no pending descriptors, clear the timeout. Otherwise, 2465 * if some descriptors have been freed, restart the timeout. 2466 */ 2467 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2468 ifp->if_flags &= ~IFF_OACTIVE; 2469 if (num_avail == adapter->num_tx_desc) 2470 ifp->if_timer = 0; 2471 else if (num_avail == adapter->num_tx_desc_avail) 2472 ifp->if_timer = EM_TX_TIMEOUT; 2473 } 2474 adapter->num_tx_desc_avail = num_avail; 2475 return; 2476} 2477 2478/********************************************************************* 2479 * 2480 * Get a buffer from system mbuf buffer pool. 2481 * 2482 **********************************************************************/ 2483static int 2484em_get_buf(int i, struct adapter *adapter, 2485 struct mbuf *nmp) 2486{ 2487 register struct mbuf *mp = nmp; 2488 struct em_buffer *rx_buffer; 2489 struct ifnet *ifp; 2490 bus_addr_t paddr; 2491 int error; 2492 2493 ifp = &adapter->interface_data.ac_if; 2494 2495 if (mp == NULL) { 2496 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 2497 if (mp == NULL) { 2498 adapter->mbuf_cluster_failed++; 2499 return(ENOBUFS); 2500 } 2501 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2502 } else { 2503 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2504 mp->m_data = mp->m_ext.ext_buf; 2505 mp->m_next = NULL; 2506 } 2507 2508 if (ifp->if_mtu <= ETHERMTU) { 2509 m_adj(mp, ETHER_ALIGN); 2510 } 2511 2512 rx_buffer = &adapter->rx_buffer_area[i]; 2513 2514 /* 2515 * Using memory from the mbuf cluster pool, invoke the 2516 * bus_dma machinery to arrange the memory mapping. 2517 */ 2518 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 2519 mtod(mp, void *), mp->m_len, 2520 em_dmamap_cb, &paddr, 0); 2521 if (error) { 2522 m_free(mp); 2523 return(error); 2524 } 2525 rx_buffer->m_head = mp; 2526 adapter->rx_desc_base[i].buffer_addr = htole64(paddr); 2527 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 2528 2529 return(0); 2530} 2531 2532/********************************************************************* 2533 * 2534 * Allocate memory for rx_buffer structures. Since we use one 2535 * rx_buffer per received packet, the maximum number of rx_buffer's 2536 * that we'll need is equal to the number of receive descriptors 2537 * that we've allocated. 2538 * 2539 **********************************************************************/ 2540static int 2541em_allocate_receive_structures(struct adapter * adapter) 2542{ 2543 int i, error; 2544 struct em_buffer *rx_buffer; 2545 2546 if (!(adapter->rx_buffer_area = 2547 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2548 adapter->num_rx_desc, M_DEVBUF, 2549 M_NOWAIT))) { 2550 printf("em%d: Unable to allocate rx_buffer memory\n", 2551 adapter->unit); 2552 return(ENOMEM); 2553 } 2554 2555 bzero(adapter->rx_buffer_area, 2556 sizeof(struct em_buffer) * adapter->num_rx_desc); 2557 2558 error = bus_dma_tag_create(NULL, /* parent */ 2559 1, 0, /* alignment, bounds */ 2560 BUS_SPACE_MAXADDR, /* lowaddr */ 2561 BUS_SPACE_MAXADDR, /* highaddr */ 2562 NULL, NULL, /* filter, filterarg */ 2563 MCLBYTES, /* maxsize */ 2564 1, /* nsegments */ 2565 MCLBYTES, /* maxsegsize */ 2566 BUS_DMA_ALLOCNOW, /* flags */ 2567 NULL, /* lockfunc */ 2568 NULL, /* lockarg */ 2569 &adapter->rxtag); 2570 if (error != 0) { 2571 printf("em%d: em_allocate_receive_structures: " 2572 "bus_dma_tag_create failed; error %u\n", 2573 adapter->unit, error); 2574 goto fail_0; 2575 } 2576 2577 rx_buffer = adapter->rx_buffer_area; 2578 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2579 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 2580 &rx_buffer->map); 2581 if (error != 0) { 2582 printf("em%d: em_allocate_receive_structures: " 2583 "bus_dmamap_create failed; error %u\n", 2584 adapter->unit, error); 2585 goto fail_1; 2586 } 2587 } 2588 2589 for (i = 0; i < adapter->num_rx_desc; i++) { 2590 error = em_get_buf(i, adapter, NULL); 2591 if (error != 0) { 2592 adapter->rx_buffer_area[i].m_head = NULL; 2593 adapter->rx_desc_base[i].buffer_addr = 0; 2594 return(error); 2595 } 2596 } 2597 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2598 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2599 2600 return(0); 2601 2602fail_1: 2603 bus_dma_tag_destroy(adapter->rxtag); 2604fail_0: 2605 adapter->rxtag = NULL; 2606 free(adapter->rx_buffer_area, M_DEVBUF); 2607 adapter->rx_buffer_area = NULL; 2608 return (error); 2609} 2610 2611/********************************************************************* 2612 * 2613 * Allocate and initialize receive structures. 2614 * 2615 **********************************************************************/ 2616static int 2617em_setup_receive_structures(struct adapter * adapter) 2618{ 2619 bzero((void *) adapter->rx_desc_base, 2620 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2621 2622 if (em_allocate_receive_structures(adapter)) 2623 return ENOMEM; 2624 2625 /* Setup our descriptor pointers */ 2626 adapter->next_rx_desc_to_check = 0; 2627 return(0); 2628} 2629 2630/********************************************************************* 2631 * 2632 * Enable receive unit. 2633 * 2634 **********************************************************************/ 2635static void 2636em_initialize_receive_unit(struct adapter * adapter) 2637{ 2638 u_int32_t reg_rctl; 2639 u_int32_t reg_rxcsum; 2640 struct ifnet *ifp; 2641 u_int64_t bus_addr; 2642 2643 INIT_DEBUGOUT("em_initialize_receive_unit: begin"); 2644 ifp = &adapter->interface_data.ac_if; 2645 2646 /* Make sure receives are disabled while setting up the descriptor ring */ 2647 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2648 2649 /* Set the Receive Delay Timer Register */ 2650 E1000_WRITE_REG(&adapter->hw, RDTR, 2651 adapter->rx_int_delay.value | E1000_RDT_FPDB); 2652 2653 if(adapter->hw.mac_type >= em_82540) { 2654 E1000_WRITE_REG(&adapter->hw, RADV, 2655 adapter->rx_abs_int_delay.value); 2656 2657 /* Set the interrupt throttling rate. Value is calculated 2658 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2659#define MAX_INTS_PER_SEC 8000 2660#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2661 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2662 } 2663 2664 /* Setup the Base and Length of the Rx Descriptor Ring */ 2665 bus_addr = adapter->rxdma.dma_paddr; 2666 E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr); 2667 E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32)); 2668 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 2669 sizeof(struct em_rx_desc)); 2670 2671 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2672 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2673 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2674 2675 /* Setup the Receive Control Register */ 2676 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2677 E1000_RCTL_RDMTS_HALF | 2678 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2679 2680 if (adapter->hw.tbi_compatibility_on == TRUE) 2681 reg_rctl |= E1000_RCTL_SBP; 2682 2683 2684 switch (adapter->rx_buffer_len) { 2685 default: 2686 case EM_RXBUFFER_2048: 2687 reg_rctl |= E1000_RCTL_SZ_2048; 2688 break; 2689 case EM_RXBUFFER_4096: 2690 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2691 break; 2692 case EM_RXBUFFER_8192: 2693 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2694 break; 2695 case EM_RXBUFFER_16384: 2696 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2697 break; 2698 } 2699 2700 if (ifp->if_mtu > ETHERMTU) 2701 reg_rctl |= E1000_RCTL_LPE; 2702 2703 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2704 if ((adapter->hw.mac_type >= em_82543) && 2705 (ifp->if_capenable & IFCAP_RXCSUM)) { 2706 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2707 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2708 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2709 } 2710 2711 /* Enable Receives */ 2712 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2713 2714 return; 2715} 2716 2717/********************************************************************* 2718 * 2719 * Free receive related data structures. 2720 * 2721 **********************************************************************/ 2722static void 2723em_free_receive_structures(struct adapter *adapter) 2724{ 2725 struct em_buffer *rx_buffer; 2726 int i; 2727 2728 INIT_DEBUGOUT("free_receive_structures: begin"); 2729 2730 if (adapter->rx_buffer_area != NULL) { 2731 rx_buffer = adapter->rx_buffer_area; 2732 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2733 if (rx_buffer->map != NULL) { 2734 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2735 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2736 } 2737 if (rx_buffer->m_head != NULL) 2738 m_freem(rx_buffer->m_head); 2739 rx_buffer->m_head = NULL; 2740 } 2741 } 2742 if (adapter->rx_buffer_area != NULL) { 2743 free(adapter->rx_buffer_area, M_DEVBUF); 2744 adapter->rx_buffer_area = NULL; 2745 } 2746 if (adapter->rxtag != NULL) { 2747 bus_dma_tag_destroy(adapter->rxtag); 2748 adapter->rxtag = NULL; 2749 } 2750 return; 2751} 2752 2753/********************************************************************* 2754 * 2755 * This routine executes in interrupt context. It replenishes 2756 * the mbufs in the descriptor and sends data which has been 2757 * dma'ed into host memory to upper layer. 2758 * 2759 * We loop at most count times if count is > 0, or until done if 2760 * count < 0. 2761 * 2762 *********************************************************************/ 2763static void 2764em_process_receive_interrupts(struct adapter * adapter, int count) 2765{ 2766 struct ifnet *ifp; 2767 struct mbuf *mp; 2768#if __FreeBSD_version < 500000 2769 struct ether_header *eh; 2770#endif 2771 u_int8_t accept_frame = 0; 2772 u_int8_t eop = 0; 2773 u_int16_t len, desc_len, prev_len_adj; 2774 int i; 2775 2776 /* Pointer to the receive descriptor being examined. */ 2777 struct em_rx_desc *current_desc; 2778 2779 mtx_assert(&adapter->mtx, MA_OWNED); 2780 2781 ifp = &adapter->interface_data.ac_if; 2782 i = adapter->next_rx_desc_to_check; 2783 current_desc = &adapter->rx_desc_base[i]; 2784 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2785 BUS_DMASYNC_POSTREAD); 2786 2787 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2788#ifdef DBG_STATS 2789 adapter->no_pkts_avail++; 2790#endif 2791 return; 2792 } 2793 2794 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2795 2796 mp = adapter->rx_buffer_area[i].m_head; 2797 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2798 BUS_DMASYNC_POSTREAD); 2799 2800 accept_frame = 1; 2801 prev_len_adj = 0; 2802 desc_len = le16toh(current_desc->length); 2803 if (current_desc->status & E1000_RXD_STAT_EOP) { 2804 count--; 2805 eop = 1; 2806 if (desc_len < ETHER_CRC_LEN) { 2807 len = 0; 2808 prev_len_adj = ETHER_CRC_LEN - desc_len; 2809 } 2810 else { 2811 len = desc_len - ETHER_CRC_LEN; 2812 } 2813 } else { 2814 eop = 0; 2815 len = desc_len; 2816 } 2817 2818 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2819 u_int8_t last_byte; 2820 u_int32_t pkt_len = desc_len; 2821 2822 if (adapter->fmp != NULL) 2823 pkt_len += adapter->fmp->m_pkthdr.len; 2824 2825 last_byte = *(mtod(mp, caddr_t) + desc_len - 1); 2826 2827 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2828 current_desc->errors, 2829 pkt_len, last_byte)) { 2830 em_tbi_adjust_stats(&adapter->hw, 2831 &adapter->stats, 2832 pkt_len, 2833 adapter->hw.mac_addr); 2834 if (len > 0) len--; 2835 } 2836 else { 2837 accept_frame = 0; 2838 } 2839 } 2840 2841 if (accept_frame) { 2842 2843 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2844 adapter->dropped_pkts++; 2845 em_get_buf(i, adapter, mp); 2846 if (adapter->fmp != NULL) 2847 m_freem(adapter->fmp); 2848 adapter->fmp = NULL; 2849 adapter->lmp = NULL; 2850 break; 2851 } 2852 2853 /* Assign correct length to the current fragment */ 2854 mp->m_len = len; 2855 2856 if (adapter->fmp == NULL) { 2857 mp->m_pkthdr.len = len; 2858 adapter->fmp = mp; /* Store the first mbuf */ 2859 adapter->lmp = mp; 2860 } else { 2861 /* Chain mbuf's together */ 2862 mp->m_flags &= ~M_PKTHDR; 2863 /* 2864 * Adjust length of previous mbuf in chain if we 2865 * received less than 4 bytes in the last descriptor. 2866 */ 2867 if (prev_len_adj > 0) { 2868 adapter->lmp->m_len -= prev_len_adj; 2869 adapter->fmp->m_pkthdr.len -= prev_len_adj; 2870 } 2871 adapter->lmp->m_next = mp; 2872 adapter->lmp = adapter->lmp->m_next; 2873 adapter->fmp->m_pkthdr.len += len; 2874 } 2875 2876 if (eop) { 2877 adapter->fmp->m_pkthdr.rcvif = ifp; 2878 ifp->if_ipackets++; 2879 2880#if __FreeBSD_version < 500000 2881 eh = mtod(adapter->fmp, struct ether_header *); 2882 /* Remove ethernet header from mbuf */ 2883 m_adj(adapter->fmp, sizeof(struct ether_header)); 2884 em_receive_checksum(adapter, current_desc, 2885 adapter->fmp); 2886 if (current_desc->status & E1000_RXD_STAT_VP) 2887 VLAN_INPUT_TAG(eh, adapter->fmp, 2888 (current_desc->special & 2889 E1000_RXD_SPC_VLAN_MASK)); 2890 else 2891 ether_input(ifp, eh, adapter->fmp); 2892#else 2893 2894 em_receive_checksum(adapter, current_desc, 2895 adapter->fmp); 2896 if (current_desc->status & E1000_RXD_STAT_VP) 2897 VLAN_INPUT_TAG(ifp, adapter->fmp, 2898 (current_desc->special & 2899 E1000_RXD_SPC_VLAN_MASK), 2900 adapter->fmp = NULL); 2901 2902 if (adapter->fmp != NULL) { 2903 EM_UNLOCK(adapter); 2904 (*ifp->if_input)(ifp, adapter->fmp); 2905 EM_LOCK(adapter); 2906 } 2907#endif 2908 adapter->fmp = NULL; 2909 adapter->lmp = NULL; 2910 } 2911 } else { 2912 adapter->dropped_pkts++; 2913 em_get_buf(i, adapter, mp); 2914 if (adapter->fmp != NULL) 2915 m_freem(adapter->fmp); 2916 adapter->fmp = NULL; 2917 adapter->lmp = NULL; 2918 } 2919 2920 /* Zero out the receive descriptors status */ 2921 current_desc->status = 0; 2922 2923 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2924 E1000_WRITE_REG(&adapter->hw, RDT, i); 2925 2926 /* Advance our pointers to the next descriptor */ 2927 if (++i == adapter->num_rx_desc) { 2928 i = 0; 2929 current_desc = adapter->rx_desc_base; 2930 } else 2931 current_desc++; 2932 } 2933 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2934 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2935 adapter->next_rx_desc_to_check = i; 2936 return; 2937} 2938 2939/********************************************************************* 2940 * 2941 * Verify that the hardware indicated that the checksum is valid. 2942 * Inform the stack about the status of checksum so that stack 2943 * doesn't spend time verifying the checksum. 2944 * 2945 *********************************************************************/ 2946static void 2947em_receive_checksum(struct adapter *adapter, 2948 struct em_rx_desc *rx_desc, 2949 struct mbuf *mp) 2950{ 2951 /* 82543 or newer only */ 2952 if ((adapter->hw.mac_type < em_82543) || 2953 /* Ignore Checksum bit is set */ 2954 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2955 mp->m_pkthdr.csum_flags = 0; 2956 return; 2957 } 2958 2959 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2960 /* Did it pass? */ 2961 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2962 /* IP Checksum Good */ 2963 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2964 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2965 2966 } else { 2967 mp->m_pkthdr.csum_flags = 0; 2968 } 2969 } 2970 2971 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2972 /* Did it pass? */ 2973 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2974 mp->m_pkthdr.csum_flags |= 2975 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2976 mp->m_pkthdr.csum_data = htons(0xffff); 2977 } 2978 } 2979 2980 return; 2981} 2982 2983 2984static void 2985em_enable_vlans(struct adapter *adapter) 2986{ 2987 uint32_t ctrl; 2988 2989 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 2990 2991 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2992 ctrl |= E1000_CTRL_VME; 2993 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2994 2995 return; 2996} 2997 2998static void 2999em_enable_intr(struct adapter * adapter) 3000{ 3001 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 3002 return; 3003} 3004 3005static void 3006em_disable_intr(struct adapter *adapter) 3007{ 3008 /* 3009 * The first version of 82542 had an errata where when link was forced it 3010 * would stay up even up even if the cable was disconnected. Sequence errors 3011 * were used to detect the disconnect and then the driver would unforce the link. 3012 * This code in the in the ISR. For this to work correctly the Sequence error 3013 * interrupt had to be enabled all the time. 3014 */ 3015 3016 if (adapter->hw.mac_type == em_82542_rev2_0) 3017 E1000_WRITE_REG(&adapter->hw, IMC, 3018 (0xffffffff & ~E1000_IMC_RXSEQ)); 3019 else 3020 E1000_WRITE_REG(&adapter->hw, IMC, 3021 0xffffffff); 3022 return; 3023} 3024 3025static int 3026em_is_valid_ether_addr(u_int8_t *addr) 3027{ 3028 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; 3029 3030 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { 3031 return (FALSE); 3032 } 3033 3034 return(TRUE); 3035} 3036 3037void 3038em_write_pci_cfg(struct em_hw *hw, 3039 uint32_t reg, 3040 uint16_t *value) 3041{ 3042 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 3043 *value, 2); 3044} 3045 3046void 3047em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 3048 uint16_t *value) 3049{ 3050 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 3051 reg, 2); 3052 return; 3053} 3054 3055void 3056em_pci_set_mwi(struct em_hw *hw) 3057{ 3058 pci_write_config(((struct em_osdep *)hw->back)->dev, 3059 PCIR_COMMAND, 3060 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 3061 return; 3062} 3063 3064void 3065em_pci_clear_mwi(struct em_hw *hw) 3066{ 3067 pci_write_config(((struct em_osdep *)hw->back)->dev, 3068 PCIR_COMMAND, 3069 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 3070 return; 3071} 3072 3073uint32_t 3074em_io_read(struct em_hw *hw, unsigned long port) 3075{ 3076 return(inl(port)); 3077} 3078 3079void 3080em_io_write(struct em_hw *hw, unsigned long port, uint32_t value) 3081{ 3082 outl(port, value); 3083 return; 3084} 3085 3086/********************************************************************* 3087* 82544 Coexistence issue workaround. 3088* There are 2 issues. 3089* 1. Transmit Hang issue. 3090* To detect this issue, following equation can be used... 3091* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 3092* If SUM[3:0] is in between 1 to 4, we will have this issue. 3093* 3094* 2. DAC issue. 3095* To detect this issue, following equation can be used... 3096* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 3097* If SUM[3:0] is in between 9 to c, we will have this issue. 3098* 3099* 3100* WORKAROUND: 3101* Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC) 3102* 3103*** *********************************************************************/ 3104static u_int32_t 3105em_fill_descriptors (u_int64_t address, 3106 u_int32_t length, 3107 PDESC_ARRAY desc_array) 3108{ 3109 /* Since issue is sensitive to length and address.*/ 3110 /* Let us first check the address...*/ 3111 u_int32_t safe_terminator; 3112 if (length <= 4) { 3113 desc_array->descriptor[0].address = address; 3114 desc_array->descriptor[0].length = length; 3115 desc_array->elements = 1; 3116 return desc_array->elements; 3117 } 3118 safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF); 3119 /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */ 3120 if (safe_terminator == 0 || 3121 (safe_terminator > 4 && 3122 safe_terminator < 9) || 3123 (safe_terminator > 0xC && 3124 safe_terminator <= 0xF)) { 3125 desc_array->descriptor[0].address = address; 3126 desc_array->descriptor[0].length = length; 3127 desc_array->elements = 1; 3128 return desc_array->elements; 3129 } 3130 3131 desc_array->descriptor[0].address = address; 3132 desc_array->descriptor[0].length = length - 4; 3133 desc_array->descriptor[1].address = address + (length - 4); 3134 desc_array->descriptor[1].length = 4; 3135 desc_array->elements = 2; 3136 return desc_array->elements; 3137} 3138 3139/********************************************************************** 3140 * 3141 * Update the board statistics counters. 3142 * 3143 **********************************************************************/ 3144static void 3145em_update_stats_counters(struct adapter *adapter) 3146{ 3147 struct ifnet *ifp; 3148 3149 if(adapter->hw.media_type == em_media_type_copper || 3150 (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) { 3151 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 3152 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 3153 } 3154 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 3155 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 3156 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 3157 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 3158 3159 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 3160 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 3161 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 3162 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 3163 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 3164 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 3165 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 3166 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 3167 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 3168 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 3169 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 3170 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 3171 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 3172 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 3173 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 3174 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 3175 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 3176 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 3177 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 3178 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 3179 3180 /* For the 64-bit byte counters the low dword must be read first. */ 3181 /* Both registers clear on the read of the high dword */ 3182 3183 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 3184 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 3185 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 3186 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 3187 3188 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 3189 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 3190 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 3191 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 3192 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 3193 3194 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 3195 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 3196 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 3197 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 3198 3199 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 3200 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 3201 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 3202 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 3203 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 3204 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 3205 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 3206 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 3207 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 3208 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 3209 3210 if (adapter->hw.mac_type >= em_82543) { 3211 adapter->stats.algnerrc += 3212 E1000_READ_REG(&adapter->hw, ALGNERRC); 3213 adapter->stats.rxerrc += 3214 E1000_READ_REG(&adapter->hw, RXERRC); 3215 adapter->stats.tncrs += 3216 E1000_READ_REG(&adapter->hw, TNCRS); 3217 adapter->stats.cexterr += 3218 E1000_READ_REG(&adapter->hw, CEXTERR); 3219 adapter->stats.tsctc += 3220 E1000_READ_REG(&adapter->hw, TSCTC); 3221 adapter->stats.tsctfc += 3222 E1000_READ_REG(&adapter->hw, TSCTFC); 3223 } 3224 ifp = &adapter->interface_data.ac_if; 3225 3226 /* Fill out the OS statistics structure */ 3227 ifp->if_ibytes = adapter->stats.gorcl; 3228 ifp->if_obytes = adapter->stats.gotcl; 3229 ifp->if_imcasts = adapter->stats.mprc; 3230 ifp->if_collisions = adapter->stats.colc; 3231 3232 /* Rx Errors */ 3233 ifp->if_ierrors = 3234 adapter->dropped_pkts + 3235 adapter->stats.rxerrc + 3236 adapter->stats.crcerrs + 3237 adapter->stats.algnerrc + 3238 adapter->stats.rlec + 3239 adapter->stats.mpc + adapter->stats.cexterr; 3240 3241 /* Tx Errors */ 3242 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 3243 3244} 3245 3246 3247/********************************************************************** 3248 * 3249 * This routine is called only when em_display_debug_stats is enabled. 3250 * This routine provides a way to take a look at important statistics 3251 * maintained by the driver and hardware. 3252 * 3253 **********************************************************************/ 3254static void 3255em_print_debug_info(struct adapter *adapter) 3256{ 3257 int unit = adapter->unit; 3258 uint8_t *hw_addr = adapter->hw.hw_addr; 3259 3260 printf("em%d: Adapter hardware address = %p \n", unit, hw_addr); 3261 printf("em%d:CTRL = 0x%x\n", unit, 3262 E1000_READ_REG(&adapter->hw, CTRL)); 3263 printf("em%d:RCTL = 0x%x PS=(0x8402)\n", unit, 3264 E1000_READ_REG(&adapter->hw, RCTL)); 3265 printf("em%d:tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, 3266 E1000_READ_REG(&adapter->hw, TIDV), 3267 E1000_READ_REG(&adapter->hw, TADV)); 3268 printf("em%d:rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, 3269 E1000_READ_REG(&adapter->hw, RDTR), 3270 E1000_READ_REG(&adapter->hw, RADV)); 3271 3272#ifdef DBG_STATS 3273 printf("em%d: Packets not Avail = %ld\n", unit, 3274 adapter->no_pkts_avail); 3275 printf("em%d: CleanTxInterrupts = %ld\n", unit, 3276 adapter->clean_tx_interrupts); 3277#endif 3278 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 3279 (long long)adapter->tx_fifo_wrk_cnt, 3280 (long long)adapter->tx_fifo_reset_cnt); 3281 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 3282 E1000_READ_REG(&adapter->hw, TDH), 3283 E1000_READ_REG(&adapter->hw, TDT)); 3284 printf("em%d: Num Tx descriptors avail = %d\n", unit, 3285 adapter->num_tx_desc_avail); 3286 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 3287 adapter->no_tx_desc_avail1); 3288 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 3289 adapter->no_tx_desc_avail2); 3290 printf("em%d: Std mbuf failed = %ld\n", unit, 3291 adapter->mbuf_alloc_failed); 3292 printf("em%d: Std mbuf cluster failed = %ld\n", unit, 3293 adapter->mbuf_cluster_failed); 3294 printf("em%d: Driver dropped packets = %ld\n", unit, 3295 adapter->dropped_pkts); 3296 3297 return; 3298} 3299 3300static void 3301em_print_hw_stats(struct adapter *adapter) 3302{ 3303 int unit = adapter->unit; 3304 3305 printf("em%d: Excessive collisions = %lld\n", unit, 3306 (long long)adapter->stats.ecol); 3307 printf("em%d: Symbol errors = %lld\n", unit, 3308 (long long)adapter->stats.symerrs); 3309 printf("em%d: Sequence errors = %lld\n", unit, 3310 (long long)adapter->stats.sec); 3311 printf("em%d: Defer count = %lld\n", unit, 3312 (long long)adapter->stats.dc); 3313 3314 printf("em%d: Missed Packets = %lld\n", unit, 3315 (long long)adapter->stats.mpc); 3316 printf("em%d: Receive No Buffers = %lld\n", unit, 3317 (long long)adapter->stats.rnbc); 3318 printf("em%d: Receive length errors = %lld\n", unit, 3319 (long long)adapter->stats.rlec); 3320 printf("em%d: Receive errors = %lld\n", unit, 3321 (long long)adapter->stats.rxerrc); 3322 printf("em%d: Crc errors = %lld\n", unit, 3323 (long long)adapter->stats.crcerrs); 3324 printf("em%d: Alignment errors = %lld\n", unit, 3325 (long long)adapter->stats.algnerrc); 3326 printf("em%d: Carrier extension errors = %lld\n", unit, 3327 (long long)adapter->stats.cexterr); 3328 3329 printf("em%d: XON Rcvd = %lld\n", unit, 3330 (long long)adapter->stats.xonrxc); 3331 printf("em%d: XON Xmtd = %lld\n", unit, 3332 (long long)adapter->stats.xontxc); 3333 printf("em%d: XOFF Rcvd = %lld\n", unit, 3334 (long long)adapter->stats.xoffrxc); 3335 printf("em%d: XOFF Xmtd = %lld\n", unit, 3336 (long long)adapter->stats.xofftxc); 3337 3338 printf("em%d: Good Packets Rcvd = %lld\n", unit, 3339 (long long)adapter->stats.gprc); 3340 printf("em%d: Good Packets Xmtd = %lld\n", unit, 3341 (long long)adapter->stats.gptc); 3342 3343 return; 3344} 3345 3346static int 3347em_sysctl_debug_info(SYSCTL_HANDLER_ARGS) 3348{ 3349 int error; 3350 int result; 3351 struct adapter *adapter; 3352 3353 result = -1; 3354 error = sysctl_handle_int(oidp, &result, 0, req); 3355 3356 if (error || !req->newptr) 3357 return (error); 3358 3359 if (result == 1) { 3360 adapter = (struct adapter *)arg1; 3361 em_print_debug_info(adapter); 3362 } 3363 3364 return error; 3365} 3366 3367 3368static int 3369em_sysctl_stats(SYSCTL_HANDLER_ARGS) 3370{ 3371 int error; 3372 int result; 3373 struct adapter *adapter; 3374 3375 result = -1; 3376 error = sysctl_handle_int(oidp, &result, 0, req); 3377 3378 if (error || !req->newptr) 3379 return (error); 3380 3381 if (result == 1) { 3382 adapter = (struct adapter *)arg1; 3383 em_print_hw_stats(adapter); 3384 } 3385 3386 return error; 3387} 3388 3389static int 3390em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) 3391{ 3392 struct em_int_delay_info *info; 3393 struct adapter *adapter; 3394 u_int32_t regval; 3395 int error; 3396 int usecs; 3397 int ticks; 3398 int s; 3399 3400 info = (struct em_int_delay_info *)arg1; 3401 adapter = info->adapter; 3402 usecs = info->value; 3403 error = sysctl_handle_int(oidp, &usecs, 0, req); 3404 if (error != 0 || req->newptr == NULL) 3405 return error; 3406 if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535)) 3407 return EINVAL; 3408 info->value = usecs; 3409 ticks = E1000_USECS_TO_TICKS(usecs); 3410 3411 s = splimp(); 3412 regval = E1000_READ_OFFSET(&adapter->hw, info->offset); 3413 regval = (regval & ~0xffff) | (ticks & 0xffff); 3414 /* Handle a few special cases. */ 3415 switch (info->offset) { 3416 case E1000_RDTR: 3417 case E1000_82542_RDTR: 3418 regval |= E1000_RDT_FPDB; 3419 break; 3420 case E1000_TIDV: 3421 case E1000_82542_TIDV: 3422 if (ticks == 0) { 3423 adapter->txd_cmd &= ~E1000_TXD_CMD_IDE; 3424 /* Don't write 0 into the TIDV register. */ 3425 regval++; 3426 } else 3427 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 3428 break; 3429 } 3430 E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval); 3431 splx(s); 3432 return 0; 3433} 3434 3435static void 3436em_add_int_delay_sysctl(struct adapter *adapter, const char *name, 3437 const char *description, struct em_int_delay_info *info, 3438 int offset, int value) 3439{ 3440 info->adapter = adapter; 3441 info->offset = offset; 3442 info->value = value; 3443 SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev), 3444 SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), 3445 OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, 3446 info, 0, em_sysctl_int_delay, "I", description); 3447} 3448