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