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