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