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