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