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