if_em.c revision 150710
1184610Salfred/************************************************************************** 2184610Salfred 3184610SalfredCopyright (c) 2001-2005, Intel Corporation 4184610SalfredAll rights reserved. 5184610Salfred 6184610SalfredRedistribution and use in source and binary forms, with or without 7184610Salfredmodification, are permitted provided that the following conditions are met: 8184610Salfred 9184610Salfred 1. Redistributions of source code must retain the above copyright notice, 10184610Salfred this list of conditions and the following disclaimer. 11184610Salfred 12184610Salfred 2. Redistributions in binary form must reproduce the above copyright 13184610Salfred notice, this list of conditions and the following disclaimer in the 14184610Salfred documentation and/or other materials provided with the distribution. 15184610Salfred 16184610Salfred 3. Neither the name of the Intel Corporation nor the names of its 17184610Salfred contributors may be used to endorse or promote products derived from 18184610Salfred this software without specific prior written permission. 19184610Salfred 20184610SalfredTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 21184610SalfredAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22184610SalfredIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23184610SalfredARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24184610SalfredLIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25184610SalfredCONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26184610SalfredSUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27184610SalfredINTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28184610SalfredCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29184610SalfredARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30193640SariffPOSSIBILITY OF SUCH DAMAGE. 31193640Sariff 32193640Sariff***************************************************************************/ 33193640Sariff 34184610Salfred/*$FreeBSD: head/sys/dev/em/if_em.c 150710 2005-09-29 13:23:34Z glebius $*/ 35184610Salfred 36188957Sthompsa#include <dev/em/if_em.h> 37184610Salfred 38184610Salfred/********************************************************************* 39184610Salfred * Set this to one to display debug statistics 40184610Salfred *********************************************************************/ 41184610Salfredint em_display_debug_stats = 0; 42184610Salfred 43184610Salfred/********************************************************************* 44184610Salfred * Linked list of board private structures for all NICs found 45184610Salfred *********************************************************************/ 46184610Salfred 47184610Salfredstruct adapter *em_adapter_list = NULL; 48184610Salfred 49184610Salfred 50184610Salfred/********************************************************************* 51184610Salfred * Driver version 52184610Salfred *********************************************************************/ 53184610Salfred 54184610Salfredchar em_driver_version[] = "2.1.7"; 55184610Salfred 56184610Salfred 57184610Salfred/********************************************************************* 58184610Salfred * PCI Device ID Table 59184610Salfred * 60184610Salfred * Used by probe to select devices to load on 61184610Salfred * Last field stores an index into em_strings 62184610Salfred * Last entry must be all 0s 63193640Sariff * 64184610Salfred * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 65184610Salfred *********************************************************************/ 66184610Salfred 67184610Salfredstatic em_vendor_info_t em_vendor_info_array[] = 68184610Salfred{ 69193640Sariff /* Intel(R) PRO/1000 Network Connection */ 70184610Salfred { 0x8086, E1000_DEV_ID_82540EM, PCI_ANY_ID, PCI_ANY_ID, 0}, 71184610Salfred { 0x8086, E1000_DEV_ID_82540EM_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, 72184610Salfred { 0x8086, E1000_DEV_ID_82540EP, PCI_ANY_ID, PCI_ANY_ID, 0}, 73184610Salfred { 0x8086, E1000_DEV_ID_82540EP_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, 74184610Salfred { 0x8086, E1000_DEV_ID_82540EP_LP, PCI_ANY_ID, PCI_ANY_ID, 0}, 75184610Salfred 76184610Salfred { 0x8086, E1000_DEV_ID_82541EI, PCI_ANY_ID, PCI_ANY_ID, 0}, 77184610Salfred { 0x8086, E1000_DEV_ID_82541ER, PCI_ANY_ID, PCI_ANY_ID, 0}, 78184610Salfred { 0x8086, E1000_DEV_ID_82541ER_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, 79184610Salfred { 0x8086, E1000_DEV_ID_82541EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, 80184610Salfred { 0x8086, E1000_DEV_ID_82541GI, PCI_ANY_ID, PCI_ANY_ID, 0}, 81184610Salfred { 0x8086, E1000_DEV_ID_82541GI_LF, PCI_ANY_ID, PCI_ANY_ID, 0}, 82184610Salfred { 0x8086, E1000_DEV_ID_82541GI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, 83184610Salfred 84184610Salfred { 0x8086, E1000_DEV_ID_82542, PCI_ANY_ID, PCI_ANY_ID, 0}, 85184610Salfred 86184610Salfred { 0x8086, E1000_DEV_ID_82543GC_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 87184610Salfred { 0x8086, E1000_DEV_ID_82543GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 88184610Salfred 89184610Salfred { 0x8086, E1000_DEV_ID_82544EI_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 90184610Salfred { 0x8086, E1000_DEV_ID_82544EI_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 91184610Salfred { 0x8086, E1000_DEV_ID_82544GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 92184610Salfred { 0x8086, E1000_DEV_ID_82544GC_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, 93184610Salfred 94193640Sariff { 0x8086, E1000_DEV_ID_82545EM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 95184610Salfred { 0x8086, E1000_DEV_ID_82545EM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 96184610Salfred { 0x8086, E1000_DEV_ID_82545GM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 97184610Salfred { 0x8086, E1000_DEV_ID_82545GM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 98184610Salfred { 0x8086, E1000_DEV_ID_82545GM_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, 99184610Salfred 100184610Salfred { 0x8086, E1000_DEV_ID_82546EB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 101184610Salfred { 0x8086, E1000_DEV_ID_82546EB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 102184610Salfred { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 103184610Salfred { 0x8086, E1000_DEV_ID_82546GB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 104184610Salfred { 0x8086, E1000_DEV_ID_82546GB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, 105184610Salfred { 0x8086, E1000_DEV_ID_82546GB_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, 106193640Sariff { 0x8086, E1000_DEV_ID_82546GB_PCIE, PCI_ANY_ID, PCI_ANY_ID, 0}, 107193640Sariff { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, 108193640Sariff 109193640Sariff { 0x8086, E1000_DEV_ID_82547EI, PCI_ANY_ID, PCI_ANY_ID, 0}, 110193640Sariff { 0x8086, E1000_DEV_ID_82547EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, 111193640Sariff { 0x8086, E1000_DEV_ID_82547GI, PCI_ANY_ID, PCI_ANY_ID, 0}, 112184610Salfred 113184610Salfred { 0x8086, E1000_DEV_ID_82573E, PCI_ANY_ID, PCI_ANY_ID, 0}, 114184610Salfred { 0x8086, E1000_DEV_ID_82573E_IAMT, PCI_ANY_ID, PCI_ANY_ID, 0}, 115184610Salfred 116184610Salfred /* required last entry */ 117184610Salfred { 0, 0, 0, 0, 0} 118184610Salfred}; 119184610Salfred 120184610Salfred/********************************************************************* 121184610Salfred * Table of branding strings for all supported NICs. 122193640Sariff *********************************************************************/ 123193640Sariff 124184610Salfredstatic char *em_strings[] = { 125184610Salfred "Intel(R) PRO/1000 Network Connection" 126184610Salfred}; 127184610Salfred 128184610Salfred/********************************************************************* 129184610Salfred * Function prototypes 130184610Salfred *********************************************************************/ 131184610Salfredstatic int em_probe(device_t); 132184610Salfredstatic int em_attach(device_t); 133184610Salfredstatic int em_detach(device_t); 134184610Salfredstatic int em_shutdown(device_t); 135184610Salfredstatic void em_intr(void *); 136184610Salfredstatic void em_start(struct ifnet *); 137184610Salfredstatic int em_ioctl(struct ifnet *, u_long, caddr_t); 138184610Salfredstatic void em_watchdog(struct ifnet *); 139184610Salfredstatic void em_init(void *); 140184610Salfredstatic void em_init_locked(struct adapter *); 141184610Salfredstatic void em_stop(void *); 142184610Salfredstatic void em_media_status(struct ifnet *, struct ifmediareq *); 143184610Salfredstatic int em_media_change(struct ifnet *); 144184610Salfredstatic void em_identify_hardware(struct adapter *); 145184610Salfredstatic int em_allocate_pci_resources(struct adapter *); 146184610Salfredstatic void em_free_pci_resources(struct adapter *); 147184610Salfredstatic void em_local_timer(void *); 148184610Salfredstatic int em_hardware_init(struct adapter *); 149184610Salfredstatic void em_setup_interface(device_t, struct adapter *); 150184610Salfredstatic int em_setup_transmit_structures(struct adapter *); 151184610Salfredstatic void em_initialize_transmit_unit(struct adapter *); 152184610Salfredstatic int em_setup_receive_structures(struct adapter *); 153184610Salfredstatic void em_initialize_receive_unit(struct adapter *); 154193640Sariffstatic void em_enable_intr(struct adapter *); 155184610Salfredstatic void em_disable_intr(struct adapter *); 156184610Salfredstatic void em_free_transmit_structures(struct adapter *); 157184610Salfredstatic void em_free_receive_structures(struct adapter *); 158184610Salfredstatic void em_update_stats_counters(struct adapter *); 159184610Salfredstatic void em_clean_transmit_interrupts(struct adapter *); 160184610Salfredstatic int em_allocate_receive_structures(struct adapter *); 161184610Salfredstatic int em_allocate_transmit_structures(struct adapter *); 162184610Salfredstatic void em_process_receive_interrupts(struct adapter *, int); 163184610Salfredstatic void em_receive_checksum(struct adapter *, 164184610Salfred struct em_rx_desc *, 165184610Salfred struct mbuf *); 166184610Salfredstatic void em_transmit_checksum_setup(struct adapter *, 167184610Salfred struct mbuf *, 168184610Salfred u_int32_t *, 169184610Salfred u_int32_t *); 170184610Salfredstatic void em_set_promisc(struct adapter *); 171184610Salfredstatic void em_disable_promisc(struct adapter *); 172184610Salfredstatic void em_set_multi(struct adapter *); 173184610Salfredstatic void em_print_hw_stats(struct adapter *); 174184610Salfredstatic void em_print_link_status(struct adapter *); 175184610Salfredstatic int em_get_buf(int i, struct adapter *, 176184610Salfred struct mbuf *); 177184610Salfredstatic void em_enable_vlans(struct adapter *); 178184610Salfredstatic void em_disable_vlans(struct adapter *); 179184610Salfredstatic int em_encap(struct adapter *, struct mbuf **); 180184610Salfredstatic void em_smartspeed(struct adapter *); 181184610Salfredstatic int em_82547_fifo_workaround(struct adapter *, int); 182184610Salfredstatic void em_82547_update_fifo_head(struct adapter *, int); 183184610Salfredstatic int em_82547_tx_fifo_reset(struct adapter *); 184184610Salfredstatic void em_82547_move_tail(void *arg); 185193640Sariffstatic void em_82547_move_tail_locked(struct adapter *); 186184610Salfredstatic int em_dma_malloc(struct adapter *, bus_size_t, 187184610Salfred struct em_dma_alloc *, int); 188184610Salfredstatic void em_dma_free(struct adapter *, struct em_dma_alloc *); 189184610Salfredstatic void em_print_debug_info(struct adapter *); 190184610Salfredstatic int em_is_valid_ether_addr(u_int8_t *); 191184610Salfredstatic int em_sysctl_stats(SYSCTL_HANDLER_ARGS); 192184610Salfredstatic int em_sysctl_debug_info(SYSCTL_HANDLER_ARGS); 193184610Salfredstatic u_int32_t em_fill_descriptors (u_int64_t address, 194184610Salfred u_int32_t length, 195184610Salfred PDESC_ARRAY desc_array); 196184610Salfredstatic int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS); 197184610Salfredstatic void em_add_int_delay_sysctl(struct adapter *, const char *, 198184610Salfred const char *, struct em_int_delay_info *, 199184610Salfred int, int); 200184610Salfred 201184610Salfred/********************************************************************* 202184610Salfred * FreeBSD Device Interface Entry Points 203184610Salfred *********************************************************************/ 204184610Salfred 205184610Salfredstatic device_method_t em_methods[] = { 206184610Salfred /* Device interface */ 207184610Salfred DEVMETHOD(device_probe, em_probe), 208184610Salfred DEVMETHOD(device_attach, em_attach), 209184610Salfred DEVMETHOD(device_detach, em_detach), 210184610Salfred DEVMETHOD(device_shutdown, em_shutdown), 211184610Salfred {0, 0} 212184610Salfred}; 213184610Salfred 214184610Salfredstatic driver_t em_driver = { 215184610Salfred "em", em_methods, sizeof(struct adapter ), 216184610Salfred}; 217184610Salfred 218184610Salfredstatic devclass_t em_devclass; 219184610SalfredDRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0); 220184610SalfredMODULE_DEPEND(em, pci, 1, 1, 1); 221184610SalfredMODULE_DEPEND(em, ether, 1, 1, 1); 222184610Salfred 223184610Salfred/********************************************************************* 224184610Salfred * Tunable default values. 225184610Salfred *********************************************************************/ 226184610Salfred 227184610Salfred#define E1000_TICKS_TO_USECS(ticks) ((1024 * (ticks) + 500) / 1000) 228184610Salfred#define E1000_USECS_TO_TICKS(usecs) ((1000 * (usecs) + 512) / 1024) 229184610Salfred 230184610Salfredstatic int em_tx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TIDV); 231184610Salfredstatic int em_rx_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RDTR); 232184610Salfredstatic int em_tx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_TADV); 233184610Salfredstatic int em_rx_abs_int_delay_dflt = E1000_TICKS_TO_USECS(EM_RADV); 234184610Salfred 235184610SalfredTUNABLE_INT("hw.em.tx_int_delay", &em_tx_int_delay_dflt); 236184610SalfredTUNABLE_INT("hw.em.rx_int_delay", &em_rx_int_delay_dflt); 237184610SalfredTUNABLE_INT("hw.em.tx_abs_int_delay", &em_tx_abs_int_delay_dflt); 238184610SalfredTUNABLE_INT("hw.em.rx_abs_int_delay", &em_rx_abs_int_delay_dflt); 239184610Salfred 240184610Salfred/********************************************************************* 241184610Salfred * Device identification routine 242184610Salfred * 243 * em_probe determines if the driver should be loaded on 244 * adapter based on PCI vendor/device id of the adapter. 245 * 246 * return BUS_PROBE_DEFAULT on success, positive on failure 247 *********************************************************************/ 248 249static int 250em_probe(device_t dev) 251{ 252 em_vendor_info_t *ent; 253 254 u_int16_t pci_vendor_id = 0; 255 u_int16_t pci_device_id = 0; 256 u_int16_t pci_subvendor_id = 0; 257 u_int16_t pci_subdevice_id = 0; 258 char adapter_name[60]; 259 260 INIT_DEBUGOUT("em_probe: begin"); 261 262 pci_vendor_id = pci_get_vendor(dev); 263 if (pci_vendor_id != EM_VENDOR_ID) 264 return(ENXIO); 265 266 pci_device_id = pci_get_device(dev); 267 pci_subvendor_id = pci_get_subvendor(dev); 268 pci_subdevice_id = pci_get_subdevice(dev); 269 270 ent = em_vendor_info_array; 271 while (ent->vendor_id != 0) { 272 if ((pci_vendor_id == ent->vendor_id) && 273 (pci_device_id == ent->device_id) && 274 275 ((pci_subvendor_id == ent->subvendor_id) || 276 (ent->subvendor_id == PCI_ANY_ID)) && 277 278 ((pci_subdevice_id == ent->subdevice_id) || 279 (ent->subdevice_id == PCI_ANY_ID))) { 280 sprintf(adapter_name, "%s, Version - %s", 281 em_strings[ent->index], 282 em_driver_version); 283 device_set_desc_copy(dev, adapter_name); 284 return(BUS_PROBE_DEFAULT); 285 } 286 ent++; 287 } 288 289 return(ENXIO); 290} 291 292/********************************************************************* 293 * Device initialization routine 294 * 295 * The attach entry point is called when the driver is being loaded. 296 * This routine identifies the type of hardware, allocates all resources 297 * and initializes the hardware. 298 * 299 * return 0 on success, positive on failure 300 *********************************************************************/ 301 302static int 303em_attach(device_t dev) 304{ 305 struct adapter * adapter; 306 int tsize, rsize; 307 int error = 0; 308 309 INIT_DEBUGOUT("em_attach: begin"); 310 311 /* Allocate, clear, and link in our adapter structure */ 312 if (!(adapter = device_get_softc(dev))) { 313 printf("em: adapter structure allocation failed\n"); 314 return(ENOMEM); 315 } 316 bzero(adapter, sizeof(struct adapter )); 317 adapter->dev = dev; 318 adapter->osdep.dev = dev; 319 adapter->unit = device_get_unit(dev); 320 EM_LOCK_INIT(adapter, device_get_nameunit(dev)); 321 322 if (em_adapter_list != NULL) 323 em_adapter_list->prev = adapter; 324 adapter->next = em_adapter_list; 325 em_adapter_list = adapter; 326 327 /* SYSCTL stuff */ 328 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 329 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 330 OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW, 331 (void *)adapter, 0, 332 em_sysctl_debug_info, "I", "Debug Information"); 333 334 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 335 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 336 OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW, 337 (void *)adapter, 0, 338 em_sysctl_stats, "I", "Statistics"); 339 340 callout_init(&adapter->timer, CALLOUT_MPSAFE); 341 callout_init(&adapter->tx_fifo_timer, CALLOUT_MPSAFE); 342 343 /* Determine hardware revision */ 344 em_identify_hardware(adapter); 345 346 /* Set up some sysctls for the tunable interrupt delays */ 347 em_add_int_delay_sysctl(adapter, "rx_int_delay", 348 "receive interrupt delay in usecs", &adapter->rx_int_delay, 349 E1000_REG_OFFSET(&adapter->hw, RDTR), em_rx_int_delay_dflt); 350 em_add_int_delay_sysctl(adapter, "tx_int_delay", 351 "transmit interrupt delay in usecs", &adapter->tx_int_delay, 352 E1000_REG_OFFSET(&adapter->hw, TIDV), em_tx_int_delay_dflt); 353 if (adapter->hw.mac_type >= em_82540) { 354 em_add_int_delay_sysctl(adapter, "rx_abs_int_delay", 355 "receive interrupt delay limit in usecs", 356 &adapter->rx_abs_int_delay, 357 E1000_REG_OFFSET(&adapter->hw, RADV), 358 em_rx_abs_int_delay_dflt); 359 em_add_int_delay_sysctl(adapter, "tx_abs_int_delay", 360 "transmit interrupt delay limit in usecs", 361 &adapter->tx_abs_int_delay, 362 E1000_REG_OFFSET(&adapter->hw, TADV), 363 em_tx_abs_int_delay_dflt); 364 } 365 366 /* Parameters (to be read from user) */ 367 adapter->num_tx_desc = EM_MAX_TXD; 368 adapter->num_rx_desc = EM_MAX_RXD; 369 adapter->hw.autoneg = DO_AUTO_NEG; 370 adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; 371 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 372 adapter->hw.tbi_compatibility_en = TRUE; 373 adapter->rx_buffer_len = EM_RXBUFFER_2048; 374 375 /* 376 * These parameters control the automatic generation(Tx) and 377 * response(Rx) to Ethernet PAUSE frames. 378 */ 379 adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH; 380 adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH; 381 adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER; 382 adapter->hw.fc_send_xon = TRUE; 383 adapter->hw.fc = em_fc_full; 384 385 adapter->hw.phy_init_script = 1; 386 adapter->hw.phy_reset_disable = FALSE; 387 388#ifndef EM_MASTER_SLAVE 389 adapter->hw.master_slave = em_ms_hw_default; 390#else 391 adapter->hw.master_slave = EM_MASTER_SLAVE; 392#endif 393 /* 394 * Set the max frame size assuming standard ethernet 395 * sized frames 396 */ 397 adapter->hw.max_frame_size = 398 ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 399 400 adapter->hw.min_frame_size = 401 MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; 402 403 /* 404 * This controls when hardware reports transmit completion 405 * status. 406 */ 407 adapter->hw.report_tx_early = 1; 408 409 410 if (em_allocate_pci_resources(adapter)) { 411 printf("em%d: Allocation of PCI resources failed\n", 412 adapter->unit); 413 error = ENXIO; 414 goto err_pci; 415 } 416 417 418 /* Initialize eeprom parameters */ 419 em_init_eeprom_params(&adapter->hw); 420 421 tsize = EM_ROUNDUP(adapter->num_tx_desc * 422 sizeof(struct em_tx_desc), 4096); 423 424 /* Allocate Transmit Descriptor ring */ 425 if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) { 426 printf("em%d: Unable to allocate tx_desc memory\n", 427 adapter->unit); 428 error = ENOMEM; 429 goto err_tx_desc; 430 } 431 adapter->tx_desc_base = (struct em_tx_desc *) adapter->txdma.dma_vaddr; 432 433 rsize = EM_ROUNDUP(adapter->num_rx_desc * 434 sizeof(struct em_rx_desc), 4096); 435 436 /* Allocate Receive Descriptor ring */ 437 if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) { 438 printf("em%d: Unable to allocate rx_desc memory\n", 439 adapter->unit); 440 error = ENOMEM; 441 goto err_rx_desc; 442 } 443 adapter->rx_desc_base = (struct em_rx_desc *) adapter->rxdma.dma_vaddr; 444 445 /* Initialize the hardware */ 446 if (em_hardware_init(adapter)) { 447 printf("em%d: Unable to initialize the hardware\n", 448 adapter->unit); 449 error = EIO; 450 goto err_hw_init; 451 } 452 453 /* Copy the permanent MAC address out of the EEPROM */ 454 if (em_read_mac_addr(&adapter->hw) < 0) { 455 printf("em%d: EEPROM read error while reading mac address\n", 456 adapter->unit); 457 error = EIO; 458 goto err_mac_addr; 459 } 460 461 if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) { 462 printf("em%d: Invalid mac address\n", adapter->unit); 463 error = EIO; 464 goto err_mac_addr; 465 } 466 467 /* Setup OS specific network interface */ 468 em_setup_interface(dev, adapter); 469 470 /* Initialize statistics */ 471 em_clear_hw_cntrs(&adapter->hw); 472 em_update_stats_counters(adapter); 473 adapter->hw.get_link_status = 1; 474 em_check_for_link(&adapter->hw); 475 476 /* Print the link status */ 477 if (adapter->link_active == 1) { 478 em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 479 &adapter->link_duplex); 480 printf("em%d: Speed:%d Mbps Duplex:%s\n", 481 adapter->unit, 482 adapter->link_speed, 483 adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 484 } else 485 printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); 486 487 /* Identify 82544 on PCIX */ 488 em_get_bus_info(&adapter->hw); 489 if(adapter->hw.bus_type == em_bus_type_pcix && 490 adapter->hw.mac_type == em_82544) { 491 adapter->pcix_82544 = TRUE; 492 } 493 else { 494 adapter->pcix_82544 = FALSE; 495 } 496 INIT_DEBUGOUT("em_attach: end"); 497 return(0); 498 499err_mac_addr: 500err_hw_init: 501 em_dma_free(adapter, &adapter->rxdma); 502err_rx_desc: 503 em_dma_free(adapter, &adapter->txdma); 504err_tx_desc: 505err_pci: 506 em_free_pci_resources(adapter); 507 return(error); 508 509} 510 511/********************************************************************* 512 * Device removal routine 513 * 514 * The detach entry point is called when the driver is being removed. 515 * This routine stops the adapter and deallocates all the resources 516 * that were allocated for driver operation. 517 * 518 * return 0 on success, positive on failure 519 *********************************************************************/ 520 521static int 522em_detach(device_t dev) 523{ 524 struct adapter * adapter = device_get_softc(dev); 525 struct ifnet *ifp = adapter->ifp; 526 527 INIT_DEBUGOUT("em_detach: begin"); 528 529 EM_LOCK(adapter); 530 adapter->in_detach = 1; 531 em_stop(adapter); 532 em_phy_hw_reset(&adapter->hw); 533 EM_UNLOCK(adapter); 534#if __FreeBSD_version < 500000 535 ether_ifdetach(adapter->ifp, ETHER_BPF_SUPPORTED); 536#else 537 ether_ifdetach(adapter->ifp); 538#endif 539 em_free_pci_resources(adapter); 540 bus_generic_detach(dev); 541#if __FreeBSD_version >= 500000 542 if_free(ifp); 543#endif 544 545 /* Free Transmit Descriptor ring */ 546 if (adapter->tx_desc_base) { 547 em_dma_free(adapter, &adapter->txdma); 548 adapter->tx_desc_base = NULL; 549 } 550 551 /* Free Receive Descriptor ring */ 552 if (adapter->rx_desc_base) { 553 em_dma_free(adapter, &adapter->rxdma); 554 adapter->rx_desc_base = NULL; 555 } 556 557 /* Remove from the adapter list */ 558 if (em_adapter_list == adapter) 559 em_adapter_list = adapter->next; 560 if (adapter->next != NULL) 561 adapter->next->prev = adapter->prev; 562 if (adapter->prev != NULL) 563 adapter->prev->next = adapter->next; 564 565 EM_LOCK_DESTROY(adapter); 566 567 return(0); 568} 569 570/********************************************************************* 571 * 572 * Shutdown entry point 573 * 574 **********************************************************************/ 575 576static int 577em_shutdown(device_t dev) 578{ 579 struct adapter *adapter = device_get_softc(dev); 580 EM_LOCK(adapter); 581 em_stop(adapter); 582 EM_UNLOCK(adapter); 583 return(0); 584} 585 586 587/********************************************************************* 588 * Transmit entry point 589 * 590 * em_start is called by the stack to initiate a transmit. 591 * The driver will remain in this routine as long as there are 592 * packets to transmit and transmit resources are available. 593 * In case resources are not available stack is notified and 594 * the packet is requeued. 595 **********************************************************************/ 596 597static void 598em_start_locked(struct ifnet *ifp) 599{ 600 struct mbuf *m_head; 601 struct adapter *adapter = ifp->if_softc; 602 603 mtx_assert(&adapter->mtx, MA_OWNED); 604 605 if (!adapter->link_active) 606 return; 607 608 while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) { 609 610 IFQ_DRV_DEQUEUE(&ifp->if_snd, m_head); 611 612 if (m_head == NULL) break; 613 614 /* 615 * em_encap() can modify our pointer, and or make it NULL on 616 * failure. In that event, we can't requeue. 617 */ 618 if (em_encap(adapter, &m_head)) { 619 if (m_head == NULL) 620 break; 621 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 622 IFQ_DRV_PREPEND(&ifp->if_snd, m_head); 623 break; 624 } 625 626 /* Send a copy of the frame to the BPF listener */ 627#if __FreeBSD_version < 500000 628 if (ifp->if_bpf) 629 bpf_mtap(ifp, m_head); 630#else 631 BPF_MTAP(ifp, m_head); 632#endif 633 634 /* Set timeout in case hardware has problems transmitting */ 635 ifp->if_timer = EM_TX_TIMEOUT; 636 637 } 638 return; 639} 640 641static void 642em_start(struct ifnet *ifp) 643{ 644 struct adapter *adapter = ifp->if_softc; 645 646 EM_LOCK(adapter); 647 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 648 em_start_locked(ifp); 649 EM_UNLOCK(adapter); 650 return; 651} 652 653/********************************************************************* 654 * Ioctl entry point 655 * 656 * em_ioctl is called when the user wants to configure the 657 * interface. 658 * 659 * return 0 on success, positive on failure 660 **********************************************************************/ 661 662static int 663em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 664{ 665 int mask, reinit, error = 0; 666 struct ifreq *ifr = (struct ifreq *) data; 667 struct adapter * adapter = ifp->if_softc; 668 669 if (adapter->in_detach) return(error); 670 671 switch (command) { 672 case SIOCSIFADDR: 673 case SIOCGIFADDR: 674 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 675 ether_ioctl(ifp, command, data); 676 break; 677 case SIOCSIFMTU: 678 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 679 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN || \ 680 /* 82573 does not support jumbo frames */ 681 (adapter->hw.mac_type == em_82573 && ifr->ifr_mtu > ETHERMTU) ) { 682 error = EINVAL; 683 } else { 684 EM_LOCK(adapter); 685 ifp->if_mtu = ifr->ifr_mtu; 686 adapter->hw.max_frame_size = 687 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 688 em_init_locked(adapter); 689 EM_UNLOCK(adapter); 690 } 691 break; 692 case SIOCSIFFLAGS: 693 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 694 EM_LOCK(adapter); 695 if (ifp->if_flags & IFF_UP) { 696 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { 697 em_init_locked(adapter); 698 } 699 700 em_disable_promisc(adapter); 701 em_set_promisc(adapter); 702 } else { 703 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 704 em_stop(adapter); 705 } 706 } 707 EM_UNLOCK(adapter); 708 break; 709 case SIOCADDMULTI: 710 case SIOCDELMULTI: 711 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 712 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 713 EM_LOCK(adapter); 714 em_disable_intr(adapter); 715 em_set_multi(adapter); 716 if (adapter->hw.mac_type == em_82542_rev2_0) { 717 em_initialize_receive_unit(adapter); 718 } 719#ifdef DEVICE_POLLING 720 if (!(ifp->if_flags & IFF_POLLING)) 721#endif 722 em_enable_intr(adapter); 723 EM_UNLOCK(adapter); 724 } 725 break; 726 case SIOCSIFMEDIA: 727 case SIOCGIFMEDIA: 728 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 729 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 730 break; 731 case SIOCSIFCAP: 732 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 733 reinit = 0; 734 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 735 if (mask & IFCAP_POLLING) 736 ifp->if_capenable ^= IFCAP_POLLING; 737 if (mask & IFCAP_HWCSUM) { 738 ifp->if_capenable ^= IFCAP_HWCSUM; 739 reinit = 1; 740 } 741 if (mask & IFCAP_VLAN_HWTAGGING) { 742 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING; 743 reinit = 1; 744 } 745 if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING)) 746 em_init(adapter); 747 break; 748 default: 749 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%x)", (int)command); 750 error = EINVAL; 751 } 752 753 return(error); 754} 755 756/********************************************************************* 757 * Watchdog entry point 758 * 759 * This routine is called whenever hardware quits transmitting. 760 * 761 **********************************************************************/ 762 763static void 764em_watchdog(struct ifnet *ifp) 765{ 766 struct adapter * adapter; 767 adapter = ifp->if_softc; 768 769 /* If we are in this routine because of pause frames, then 770 * don't reset the hardware. 771 */ 772 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { 773 ifp->if_timer = EM_TX_TIMEOUT; 774 return; 775 } 776 777 if (em_check_for_link(&adapter->hw)) 778 printf("em%d: watchdog timeout -- resetting\n", adapter->unit); 779 780 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 781 782 em_init(adapter); 783 784 ifp->if_oerrors++; 785 return; 786} 787 788/********************************************************************* 789 * Init entry point 790 * 791 * This routine is used in two ways. It is used by the stack as 792 * init entry point in network interface structure. It is also used 793 * by the driver as a hw/sw initialization routine to get to a 794 * consistent state. 795 * 796 * return 0 on success, positive on failure 797 **********************************************************************/ 798 799static void 800em_init_locked(struct adapter * adapter) 801{ 802 struct ifnet *ifp; 803 804 uint32_t pba; 805 ifp = adapter->ifp; 806 807 INIT_DEBUGOUT("em_init: begin"); 808 809 mtx_assert(&adapter->mtx, MA_OWNED); 810 811 em_stop(adapter); 812 813 /* Packet Buffer Allocation (PBA) 814 * Writing PBA sets the receive portion of the buffer 815 * the remainder is used for the transmit buffer. 816 * 817 * Devices before the 82547 had a Packet Buffer of 64K. 818 * Default allocation: PBA=48K for Rx, leaving 16K for Tx. 819 * After the 82547 the buffer was reduced to 40K. 820 * Default allocation: PBA=30K for Rx, leaving 10K for Tx. 821 * Note: default does not leave enough room for Jumbo Frame >10k. 822 */ 823 if(adapter->hw.mac_type < em_82547) { 824 /* Total FIFO is 64K */ 825 if(adapter->rx_buffer_len > EM_RXBUFFER_8192) 826 pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */ 827 else 828 pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */ 829 } else { 830 /* Total FIFO is 40K */ 831 if(adapter->hw.max_frame_size > EM_RXBUFFER_8192) { 832 pba = E1000_PBA_22K; /* 22K for Rx, 18K for Tx */ 833 } else { 834 pba = E1000_PBA_30K; /* 30K for Rx, 10K for Tx */ 835 } 836 adapter->tx_fifo_head = 0; 837 adapter->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT; 838 adapter->tx_fifo_size = (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT; 839 } 840 INIT_DEBUGOUT1("em_init: pba=%dK",pba); 841 E1000_WRITE_REG(&adapter->hw, PBA, pba); 842 843 /* Get the latest mac address, User can use a LAA */ 844 bcopy(IFP2ENADDR(adapter->ifp), adapter->hw.mac_addr, 845 ETHER_ADDR_LEN); 846 847 /* Initialize the hardware */ 848 if (em_hardware_init(adapter)) { 849 printf("em%d: Unable to initialize the hardware\n", 850 adapter->unit); 851 return; 852 } 853 854 if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) 855 em_enable_vlans(adapter); 856 857 /* Prepare transmit descriptors and buffers */ 858 if (em_setup_transmit_structures(adapter)) { 859 printf("em%d: Could not setup transmit structures\n", 860 adapter->unit); 861 em_stop(adapter); 862 return; 863 } 864 em_initialize_transmit_unit(adapter); 865 866 /* Setup Multicast table */ 867 em_set_multi(adapter); 868 869 /* Prepare receive descriptors and buffers */ 870 if (em_setup_receive_structures(adapter)) { 871 printf("em%d: Could not setup receive structures\n", 872 adapter->unit); 873 em_stop(adapter); 874 return; 875 } 876 em_initialize_receive_unit(adapter); 877 878 /* Don't loose promiscuous settings */ 879 em_set_promisc(adapter); 880 881 ifp->if_drv_flags |= IFF_DRV_RUNNING; 882 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 883 884 if (adapter->hw.mac_type >= em_82543) { 885 if (ifp->if_capenable & IFCAP_TXCSUM) 886 ifp->if_hwassist = EM_CHECKSUM_FEATURES; 887 else 888 ifp->if_hwassist = 0; 889 } 890 891 callout_reset(&adapter->timer, hz, em_local_timer, adapter); 892 em_clear_hw_cntrs(&adapter->hw); 893#ifdef DEVICE_POLLING 894 /* 895 * Only enable interrupts if we are not polling, make sure 896 * they are off otherwise. 897 */ 898 if (ifp->if_flags & IFF_POLLING) 899 em_disable_intr(adapter); 900 else 901#endif /* DEVICE_POLLING */ 902 em_enable_intr(adapter); 903 904 /* Don't reset the phy next time init gets called */ 905 adapter->hw.phy_reset_disable = TRUE; 906 907 return; 908} 909 910static void 911em_init(void *arg) 912{ 913 struct adapter * adapter = arg; 914 915 EM_LOCK(adapter); 916 em_init_locked(adapter); 917 EM_UNLOCK(adapter); 918 return; 919} 920 921 922#ifdef DEVICE_POLLING 923static poll_handler_t em_poll; 924 925static void 926em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count) 927{ 928 struct adapter *adapter = ifp->if_softc; 929 u_int32_t reg_icr; 930 931 mtx_assert(&adapter->mtx, MA_OWNED); 932 933 if (!(ifp->if_capenable & IFCAP_POLLING)) { 934 ether_poll_deregister(ifp); 935 cmd = POLL_DEREGISTER; 936 } 937 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */ 938 em_enable_intr(adapter); 939 return; 940 } 941 if (cmd == POLL_AND_CHECK_STATUS) { 942 reg_icr = E1000_READ_REG(&adapter->hw, ICR); 943 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 944 callout_stop(&adapter->timer); 945 adapter->hw.get_link_status = 1; 946 em_check_for_link(&adapter->hw); 947 em_print_link_status(adapter); 948 callout_reset(&adapter->timer, hz, em_local_timer, adapter); 949 } 950 } 951 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 952 em_process_receive_interrupts(adapter, count); 953 em_clean_transmit_interrupts(adapter); 954 } 955 956 if (ifp->if_drv_flags & IFF_DRV_RUNNING && 957 !IFQ_DRV_IS_EMPTY(&ifp->if_snd)) 958 em_start_locked(ifp); 959} 960 961static void 962em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) 963{ 964 struct adapter *adapter = ifp->if_softc; 965 966 EM_LOCK(adapter); 967 em_poll_locked(ifp, cmd, count); 968 EM_UNLOCK(adapter); 969} 970#endif /* DEVICE_POLLING */ 971 972/********************************************************************* 973 * 974 * Interrupt Service routine 975 * 976 **********************************************************************/ 977static void 978em_intr(void *arg) 979{ 980 u_int32_t loop_cnt = EM_MAX_INTR; 981 u_int32_t reg_icr; 982 struct ifnet *ifp; 983 struct adapter *adapter = arg; 984 985 EM_LOCK(adapter); 986 987 ifp = adapter->ifp; 988 989#ifdef DEVICE_POLLING 990 if (ifp->if_flags & IFF_POLLING) { 991 EM_UNLOCK(adapter); 992 return; 993 } 994 995 if ((ifp->if_capenable & IFCAP_POLLING) && 996 ether_poll_register(em_poll, ifp)) { 997 em_disable_intr(adapter); 998 em_poll_locked(ifp, 0, 1); 999 EM_UNLOCK(adapter); 1000 return; 1001 } 1002#endif /* DEVICE_POLLING */ 1003 1004 reg_icr = E1000_READ_REG(&adapter->hw, ICR); 1005 if (!reg_icr) { 1006 EM_UNLOCK(adapter); 1007 return; 1008 } 1009 1010 /* Link status change */ 1011 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 1012 callout_stop(&adapter->timer); 1013 adapter->hw.get_link_status = 1; 1014 em_check_for_link(&adapter->hw); 1015 em_print_link_status(adapter); 1016 callout_reset(&adapter->timer, hz, em_local_timer, adapter); 1017 } 1018 1019 while (loop_cnt > 0) { 1020 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 1021 em_process_receive_interrupts(adapter, -1); 1022 em_clean_transmit_interrupts(adapter); 1023 } 1024 loop_cnt--; 1025 } 1026 1027 if (ifp->if_drv_flags & IFF_DRV_RUNNING && 1028 !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->ifp; 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->ifp; 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->ifp; 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->ifp; 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_ADDR_LOCK(ifp); 1603#if __FreeBSD_version < 500000 1604 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1605#else 1606 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1607#endif 1608 if (ifma->ifma_addr->sa_family != AF_LINK) 1609 continue; 1610 1611 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break; 1612 1613 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1614 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 1615 mcnt++; 1616 } 1617 IF_ADDR_UNLOCK(ifp); 1618 1619 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) { 1620 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1621 reg_rctl |= E1000_RCTL_MPE; 1622 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1623 } else 1624 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1); 1625 1626 if (adapter->hw.mac_type == em_82542_rev2_0) { 1627 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1628 reg_rctl &= ~E1000_RCTL_RST; 1629 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1630 msec_delay(5); 1631 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1632 em_pci_set_mwi(&adapter->hw); 1633 } 1634 } 1635 1636 return; 1637} 1638 1639 1640/********************************************************************* 1641 * Timer routine 1642 * 1643 * This routine checks for link status and updates statistics. 1644 * 1645 **********************************************************************/ 1646 1647static void 1648em_local_timer(void *arg) 1649{ 1650 struct ifnet *ifp; 1651 struct adapter * adapter = arg; 1652 ifp = adapter->ifp; 1653 1654 EM_LOCK(adapter); 1655 1656 em_check_for_link(&adapter->hw); 1657 em_print_link_status(adapter); 1658 em_update_stats_counters(adapter); 1659 if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING) { 1660 em_print_hw_stats(adapter); 1661 } 1662 em_smartspeed(adapter); 1663 1664 callout_reset(&adapter->timer, hz, em_local_timer, adapter); 1665 1666 EM_UNLOCK(adapter); 1667 return; 1668} 1669 1670static void 1671em_print_link_status(struct adapter * adapter) 1672{ 1673 struct ifnet *ifp = adapter->ifp; 1674 1675 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1676 if (adapter->link_active == 0) { 1677 em_get_speed_and_duplex(&adapter->hw, 1678 &adapter->link_speed, 1679 &adapter->link_duplex); 1680 if (bootverbose) 1681 printf("em%d: Link is up %d Mbps %s\n", 1682 adapter->unit, 1683 adapter->link_speed, 1684 ((adapter->link_duplex == FULL_DUPLEX) ? 1685 "Full Duplex" : "Half Duplex")); 1686 adapter->link_active = 1; 1687 adapter->smartspeed = 0; 1688 if_link_state_change(ifp, LINK_STATE_UP); 1689 } 1690 } else { 1691 if (adapter->link_active == 1) { 1692 adapter->link_speed = 0; 1693 adapter->link_duplex = 0; 1694 if (bootverbose) 1695 printf("em%d: Link is Down\n", adapter->unit); 1696 adapter->link_active = 0; 1697 if_link_state_change(ifp, LINK_STATE_DOWN); 1698 } 1699 } 1700 1701 return; 1702} 1703 1704/********************************************************************* 1705 * 1706 * This routine disables all traffic on the adapter by issuing a 1707 * global reset on the MAC and deallocates TX/RX buffers. 1708 * 1709 **********************************************************************/ 1710 1711static void 1712em_stop(void *arg) 1713{ 1714 struct ifnet *ifp; 1715 struct adapter * adapter = arg; 1716 ifp = adapter->ifp; 1717 1718 mtx_assert(&adapter->mtx, MA_OWNED); 1719 1720 INIT_DEBUGOUT("em_stop: begin"); 1721#ifdef DEVICE_POLLING 1722 ether_poll_deregister(ifp); 1723#endif 1724 em_disable_intr(adapter); 1725 em_reset_hw(&adapter->hw); 1726 callout_stop(&adapter->timer); 1727 callout_stop(&adapter->tx_fifo_timer); 1728 em_free_transmit_structures(adapter); 1729 em_free_receive_structures(adapter); 1730 1731 1732 /* Tell the stack that the interface is no longer active */ 1733 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 1734 1735 return; 1736} 1737 1738 1739/********************************************************************* 1740 * 1741 * Determine hardware revision. 1742 * 1743 **********************************************************************/ 1744static void 1745em_identify_hardware(struct adapter * adapter) 1746{ 1747 device_t dev = adapter->dev; 1748 1749 /* Make sure our PCI config space has the necessary stuff set */ 1750 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1751 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1752 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1753 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1754 adapter->unit); 1755 adapter->hw.pci_cmd_word |= 1756 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1757 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1758 } 1759 1760 /* Save off the information about this board */ 1761 adapter->hw.vendor_id = pci_get_vendor(dev); 1762 adapter->hw.device_id = pci_get_device(dev); 1763 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1764 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1765 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1766 1767 /* Identify the MAC */ 1768 if (em_set_mac_type(&adapter->hw)) 1769 printf("em%d: Unknown MAC Type\n", adapter->unit); 1770 1771 if(adapter->hw.mac_type == em_82541 || 1772 adapter->hw.mac_type == em_82541_rev_2 || 1773 adapter->hw.mac_type == em_82547 || 1774 adapter->hw.mac_type == em_82547_rev_2) 1775 adapter->hw.phy_init_script = TRUE; 1776 1777 return; 1778} 1779 1780static int 1781em_allocate_pci_resources(struct adapter * adapter) 1782{ 1783 int i, val, rid; 1784 device_t dev = adapter->dev; 1785 1786 rid = EM_MMBA; 1787 adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 1788 &rid, RF_ACTIVE); 1789 if (!(adapter->res_memory)) { 1790 printf("em%d: Unable to allocate bus resource: memory\n", 1791 adapter->unit); 1792 return(ENXIO); 1793 } 1794 adapter->osdep.mem_bus_space_tag = 1795 rman_get_bustag(adapter->res_memory); 1796 adapter->osdep.mem_bus_space_handle = 1797 rman_get_bushandle(adapter->res_memory); 1798 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1799 1800 1801 if (adapter->hw.mac_type > em_82543) { 1802 /* Figure our where our IO BAR is ? */ 1803 rid = EM_MMBA; 1804 for (i = 0; i < 5; i++) { 1805 val = pci_read_config(dev, rid, 4); 1806 if (val & 0x00000001) { 1807 adapter->io_rid = rid; 1808 break; 1809 } 1810 rid += 4; 1811 } 1812 1813 adapter->res_ioport = bus_alloc_resource_any(dev, 1814 SYS_RES_IOPORT, 1815 &adapter->io_rid, 1816 RF_ACTIVE); 1817 if (!(adapter->res_ioport)) { 1818 printf("em%d: Unable to allocate bus resource: ioport\n", 1819 adapter->unit); 1820 return(ENXIO); 1821 } 1822 1823 adapter->hw.io_base = 1824 rman_get_start(adapter->res_ioport); 1825 } 1826 1827 rid = 0x0; 1828 adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 1829 RF_SHAREABLE | 1830 RF_ACTIVE); 1831 if (!(adapter->res_interrupt)) { 1832 printf("em%d: Unable to allocate bus resource: interrupt\n", 1833 adapter->unit); 1834 return(ENXIO); 1835 } 1836 if (bus_setup_intr(dev, adapter->res_interrupt, 1837 INTR_TYPE_NET | INTR_MPSAFE, 1838 (void (*)(void *)) em_intr, adapter, 1839 &adapter->int_handler_tag)) { 1840 printf("em%d: Error registering interrupt handler!\n", 1841 adapter->unit); 1842 return(ENXIO); 1843 } 1844 1845 adapter->hw.back = &adapter->osdep; 1846 1847 return(0); 1848} 1849 1850static void 1851em_free_pci_resources(struct adapter * adapter) 1852{ 1853 device_t dev = adapter->dev; 1854 1855 if (adapter->res_interrupt != NULL) { 1856 bus_teardown_intr(dev, adapter->res_interrupt, 1857 adapter->int_handler_tag); 1858 bus_release_resource(dev, SYS_RES_IRQ, 0, 1859 adapter->res_interrupt); 1860 } 1861 if (adapter->res_memory != NULL) { 1862 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1863 adapter->res_memory); 1864 } 1865 1866 if (adapter->res_ioport != NULL) { 1867 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1868 adapter->res_ioport); 1869 } 1870 return; 1871} 1872 1873/********************************************************************* 1874 * 1875 * Initialize the hardware to a configuration as specified by the 1876 * adapter structure. The controller is reset, the EEPROM is 1877 * verified, the MAC address is set, then the shared initialization 1878 * routines are called. 1879 * 1880 **********************************************************************/ 1881static int 1882em_hardware_init(struct adapter * adapter) 1883{ 1884 INIT_DEBUGOUT("em_hardware_init: begin"); 1885 /* Issue a global reset */ 1886 em_reset_hw(&adapter->hw); 1887 1888 /* When hardware is reset, fifo_head is also reset */ 1889 adapter->tx_fifo_head = 0; 1890 1891 /* Make sure we have a good EEPROM before we read from it */ 1892 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1893 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1894 adapter->unit); 1895 return(EIO); 1896 } 1897 1898 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1899 printf("em%d: EEPROM read error while reading part number\n", 1900 adapter->unit); 1901 return(EIO); 1902 } 1903 1904 if (em_init_hw(&adapter->hw) < 0) { 1905 printf("em%d: Hardware Initialization Failed", 1906 adapter->unit); 1907 return(EIO); 1908 } 1909 1910 em_check_for_link(&adapter->hw); 1911 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1912 adapter->link_active = 1; 1913 else 1914 adapter->link_active = 0; 1915 1916 if (adapter->link_active) { 1917 em_get_speed_and_duplex(&adapter->hw, 1918 &adapter->link_speed, 1919 &adapter->link_duplex); 1920 } else { 1921 adapter->link_speed = 0; 1922 adapter->link_duplex = 0; 1923 } 1924 1925 return(0); 1926} 1927 1928/********************************************************************* 1929 * 1930 * Setup networking device structure and register an interface. 1931 * 1932 **********************************************************************/ 1933static void 1934em_setup_interface(device_t dev, struct adapter * adapter) 1935{ 1936 struct ifnet *ifp; 1937 INIT_DEBUGOUT("em_setup_interface: begin"); 1938 1939 ifp = adapter->ifp = if_alloc(IFT_ETHER); 1940 if (ifp == NULL) 1941 panic("%s: can not if_alloc()", device_get_nameunit(dev)); 1942 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 1943 ifp->if_mtu = ETHERMTU; 1944 ifp->if_baudrate = 1000000000; 1945 ifp->if_init = em_init; 1946 ifp->if_softc = adapter; 1947 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1948 ifp->if_ioctl = em_ioctl; 1949 ifp->if_start = em_start; 1950 ifp->if_watchdog = em_watchdog; 1951 IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1); 1952 ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1; 1953 IFQ_SET_READY(&ifp->if_snd); 1954 1955#if __FreeBSD_version < 500000 1956 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1957#else 1958 ether_ifattach(ifp, adapter->hw.mac_addr); 1959#endif 1960 1961 ifp->if_capabilities = ifp->if_capenable = 0; 1962 1963 if (adapter->hw.mac_type >= em_82543) { 1964 ifp->if_capabilities |= IFCAP_HWCSUM; 1965 ifp->if_capenable |= IFCAP_HWCSUM; 1966 } 1967 1968 /* 1969 * Tell the upper layer(s) we support long frames. 1970 */ 1971 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header); 1972#if __FreeBSD_version >= 500000 1973 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1974 ifp->if_capenable |= IFCAP_VLAN_MTU; 1975#endif 1976 1977#ifdef DEVICE_POLLING 1978 ifp->if_capabilities |= IFCAP_POLLING; 1979 ifp->if_capenable |= IFCAP_POLLING; 1980#endif 1981 1982 /* 1983 * Specify the media types supported by this adapter and register 1984 * callbacks to update media and link information 1985 */ 1986 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1987 em_media_status); 1988 if (adapter->hw.media_type == em_media_type_fiber) { 1989 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1990 0, NULL); 1991 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1992 0, NULL); 1993 } else { 1994 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1995 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1996 0, NULL); 1997 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1998 0, NULL); 1999 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 2000 0, NULL); 2001#if __FreeBSD_version < 500000 2002 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 2003 0, NULL); 2004 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 2005#else 2006 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 2007 0, NULL); 2008 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 2009#endif 2010 } 2011 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 2012 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 2013 2014 return; 2015} 2016 2017 2018/********************************************************************* 2019 * 2020 * Workaround for SmartSpeed on 82541 and 82547 controllers 2021 * 2022 **********************************************************************/ 2023static void 2024em_smartspeed(struct adapter *adapter) 2025{ 2026 uint16_t phy_tmp; 2027 2028 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 2029 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 2030 return; 2031 2032 if(adapter->smartspeed == 0) { 2033 /* If Master/Slave config fault is asserted twice, 2034 * we assume back-to-back */ 2035 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 2036 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 2037 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 2038 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 2039 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 2040 &phy_tmp); 2041 if(phy_tmp & CR_1000T_MS_ENABLE) { 2042 phy_tmp &= ~CR_1000T_MS_ENABLE; 2043 em_write_phy_reg(&adapter->hw, 2044 PHY_1000T_CTRL, phy_tmp); 2045 adapter->smartspeed++; 2046 if(adapter->hw.autoneg && 2047 !em_phy_setup_autoneg(&adapter->hw) && 2048 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 2049 &phy_tmp)) { 2050 phy_tmp |= (MII_CR_AUTO_NEG_EN | 2051 MII_CR_RESTART_AUTO_NEG); 2052 em_write_phy_reg(&adapter->hw, 2053 PHY_CTRL, phy_tmp); 2054 } 2055 } 2056 } 2057 return; 2058 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 2059 /* If still no link, perhaps using 2/3 pair cable */ 2060 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 2061 phy_tmp |= CR_1000T_MS_ENABLE; 2062 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 2063 if(adapter->hw.autoneg && 2064 !em_phy_setup_autoneg(&adapter->hw) && 2065 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 2066 phy_tmp |= (MII_CR_AUTO_NEG_EN | 2067 MII_CR_RESTART_AUTO_NEG); 2068 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 2069 } 2070 } 2071 /* Restart process after EM_SMARTSPEED_MAX iterations */ 2072 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 2073 adapter->smartspeed = 0; 2074 2075 return; 2076} 2077 2078 2079/* 2080 * Manage DMA'able memory. 2081 */ 2082static void 2083em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) 2084{ 2085 if (error) 2086 return; 2087 *(bus_addr_t*) arg = segs->ds_addr; 2088 return; 2089} 2090 2091static int 2092em_dma_malloc(struct adapter *adapter, bus_size_t size, 2093 struct em_dma_alloc *dma, int mapflags) 2094{ 2095 int r; 2096 2097 r = bus_dma_tag_create(NULL, /* parent */ 2098 PAGE_SIZE, 0, /* alignment, bounds */ 2099 BUS_SPACE_MAXADDR, /* lowaddr */ 2100 BUS_SPACE_MAXADDR, /* highaddr */ 2101 NULL, NULL, /* filter, filterarg */ 2102 size, /* maxsize */ 2103 1, /* nsegments */ 2104 size, /* maxsegsize */ 2105 BUS_DMA_ALLOCNOW, /* flags */ 2106 NULL, /* lockfunc */ 2107 NULL, /* lockarg */ 2108 &dma->dma_tag); 2109 if (r != 0) { 2110 printf("em%d: em_dma_malloc: bus_dma_tag_create failed; " 2111 "error %u\n", adapter->unit, r); 2112 goto fail_0; 2113 } 2114 2115 r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, 2116 BUS_DMA_NOWAIT, &dma->dma_map); 2117 if (r != 0) { 2118 printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; " 2119 "size %ju, error %d\n", adapter->unit, 2120 (uintmax_t)size, r); 2121 goto fail_2; 2122 } 2123 2124 r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, 2125 size, 2126 em_dmamap_cb, 2127 &dma->dma_paddr, 2128 mapflags | BUS_DMA_NOWAIT); 2129 if (r != 0) { 2130 printf("em%d: em_dma_malloc: bus_dmamap_load failed; " 2131 "error %u\n", adapter->unit, r); 2132 goto fail_3; 2133 } 2134 2135 dma->dma_size = size; 2136 return (0); 2137 2138fail_3: 2139 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2140fail_2: 2141 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2142 bus_dma_tag_destroy(dma->dma_tag); 2143fail_0: 2144 dma->dma_map = NULL; 2145 dma->dma_tag = NULL; 2146 return (r); 2147} 2148 2149static void 2150em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) 2151{ 2152 bus_dmamap_unload(dma->dma_tag, dma->dma_map); 2153 bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); 2154 bus_dma_tag_destroy(dma->dma_tag); 2155} 2156 2157 2158/********************************************************************* 2159 * 2160 * Allocate memory for tx_buffer structures. The tx_buffer stores all 2161 * the information needed to transmit a packet on the wire. 2162 * 2163 **********************************************************************/ 2164static int 2165em_allocate_transmit_structures(struct adapter * adapter) 2166{ 2167 if (!(adapter->tx_buffer_area = 2168 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2169 adapter->num_tx_desc, M_DEVBUF, 2170 M_NOWAIT))) { 2171 printf("em%d: Unable to allocate tx_buffer memory\n", 2172 adapter->unit); 2173 return ENOMEM; 2174 } 2175 2176 bzero(adapter->tx_buffer_area, 2177 sizeof(struct em_buffer) * adapter->num_tx_desc); 2178 2179 return 0; 2180} 2181 2182/********************************************************************* 2183 * 2184 * Allocate and initialize transmit structures. 2185 * 2186 **********************************************************************/ 2187static int 2188em_setup_transmit_structures(struct adapter * adapter) 2189{ 2190 /* 2191 * Setup DMA descriptor areas. 2192 */ 2193 if (bus_dma_tag_create(NULL, /* parent */ 2194 1, 0, /* alignment, bounds */ 2195 BUS_SPACE_MAXADDR, /* lowaddr */ 2196 BUS_SPACE_MAXADDR, /* highaddr */ 2197 NULL, NULL, /* filter, filterarg */ 2198 MCLBYTES * 8, /* maxsize */ 2199 EM_MAX_SCATTER, /* nsegments */ 2200 MCLBYTES * 8, /* maxsegsize */ 2201 BUS_DMA_ALLOCNOW, /* flags */ 2202 NULL, /* lockfunc */ 2203 NULL, /* lockarg */ 2204 &adapter->txtag)) { 2205 printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit); 2206 return (ENOMEM); 2207 } 2208 2209 if (em_allocate_transmit_structures(adapter)) 2210 return (ENOMEM); 2211 2212 bzero((void *) adapter->tx_desc_base, 2213 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 2214 2215 adapter->next_avail_tx_desc = 0; 2216 adapter->oldest_used_tx_desc = 0; 2217 2218 /* Set number of descriptors available */ 2219 adapter->num_tx_desc_avail = adapter->num_tx_desc; 2220 2221 /* Set checksum context */ 2222 adapter->active_checksum_context = OFFLOAD_NONE; 2223 2224 return (0); 2225} 2226 2227/********************************************************************* 2228 * 2229 * Enable transmit unit. 2230 * 2231 **********************************************************************/ 2232static void 2233em_initialize_transmit_unit(struct adapter * adapter) 2234{ 2235 u_int32_t reg_tctl; 2236 u_int32_t reg_tipg = 0; 2237 u_int64_t bus_addr; 2238 2239 INIT_DEBUGOUT("em_initialize_transmit_unit: begin"); 2240 /* Setup the Base and Length of the Tx Descriptor Ring */ 2241 bus_addr = adapter->txdma.dma_paddr; 2242 E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr); 2243 E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32)); 2244 E1000_WRITE_REG(&adapter->hw, TDLEN, 2245 adapter->num_tx_desc * 2246 sizeof(struct em_tx_desc)); 2247 2248 /* Setup the HW Tx Head and Tail descriptor pointers */ 2249 E1000_WRITE_REG(&adapter->hw, TDH, 0); 2250 E1000_WRITE_REG(&adapter->hw, TDT, 0); 2251 2252 2253 HW_DEBUGOUT2("Base = %x, Length = %x\n", 2254 E1000_READ_REG(&adapter->hw, TDBAL), 2255 E1000_READ_REG(&adapter->hw, TDLEN)); 2256 2257 /* Set the default values for the Tx Inter Packet Gap timer */ 2258 switch (adapter->hw.mac_type) { 2259 case em_82542_rev2_0: 2260 case em_82542_rev2_1: 2261 reg_tipg = DEFAULT_82542_TIPG_IPGT; 2262 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2263 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2264 break; 2265 default: 2266 if (adapter->hw.media_type == em_media_type_fiber) 2267 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 2268 else 2269 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 2270 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 2271 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 2272 } 2273 2274 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 2275 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value); 2276 if(adapter->hw.mac_type >= em_82540) 2277 E1000_WRITE_REG(&adapter->hw, TADV, 2278 adapter->tx_abs_int_delay.value); 2279 2280 /* Program the Transmit Control Register */ 2281 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 2282 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 2283 if (adapter->hw.mac_type >= em_82573) 2284 reg_tctl |= E1000_TCTL_MULR; 2285 if (adapter->link_duplex == 1) { 2286 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2287 } else { 2288 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 2289 } 2290 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 2291 2292 /* Setup Transmit Descriptor Settings for this adapter */ 2293 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 2294 2295 if (adapter->tx_int_delay.value > 0) 2296 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 2297 2298 return; 2299} 2300 2301/********************************************************************* 2302 * 2303 * Free all transmit related data structures. 2304 * 2305 **********************************************************************/ 2306static void 2307em_free_transmit_structures(struct adapter * adapter) 2308{ 2309 struct em_buffer *tx_buffer; 2310 int i; 2311 2312 INIT_DEBUGOUT("free_transmit_structures: begin"); 2313 2314 if (adapter->tx_buffer_area != NULL) { 2315 tx_buffer = adapter->tx_buffer_area; 2316 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 2317 if (tx_buffer->m_head != NULL) { 2318 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2319 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2320 m_freem(tx_buffer->m_head); 2321 } 2322 tx_buffer->m_head = NULL; 2323 } 2324 } 2325 if (adapter->tx_buffer_area != NULL) { 2326 free(adapter->tx_buffer_area, M_DEVBUF); 2327 adapter->tx_buffer_area = NULL; 2328 } 2329 if (adapter->txtag != NULL) { 2330 bus_dma_tag_destroy(adapter->txtag); 2331 adapter->txtag = NULL; 2332 } 2333 return; 2334} 2335 2336/********************************************************************* 2337 * 2338 * The offload context needs to be set when we transfer the first 2339 * packet of a particular protocol (TCP/UDP). We change the 2340 * context only if the protocol type changes. 2341 * 2342 **********************************************************************/ 2343static void 2344em_transmit_checksum_setup(struct adapter * adapter, 2345 struct mbuf *mp, 2346 u_int32_t *txd_upper, 2347 u_int32_t *txd_lower) 2348{ 2349 struct em_context_desc *TXD; 2350 struct em_buffer *tx_buffer; 2351 int curr_txd; 2352 2353 if (mp->m_pkthdr.csum_flags) { 2354 2355 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 2356 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2357 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2358 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 2359 return; 2360 else 2361 adapter->active_checksum_context = OFFLOAD_TCP_IP; 2362 2363 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 2364 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 2365 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 2366 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 2367 return; 2368 else 2369 adapter->active_checksum_context = OFFLOAD_UDP_IP; 2370 } else { 2371 *txd_upper = 0; 2372 *txd_lower = 0; 2373 return; 2374 } 2375 } else { 2376 *txd_upper = 0; 2377 *txd_lower = 0; 2378 return; 2379 } 2380 2381 /* If we reach this point, the checksum offload context 2382 * needs to be reset. 2383 */ 2384 curr_txd = adapter->next_avail_tx_desc; 2385 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 2386 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 2387 2388 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 2389 TXD->lower_setup.ip_fields.ipcso = 2390 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 2391 TXD->lower_setup.ip_fields.ipcse = 2392 htole16(ETHER_HDR_LEN + sizeof(struct ip) - 1); 2393 2394 TXD->upper_setup.tcp_fields.tucss = 2395 ETHER_HDR_LEN + sizeof(struct ip); 2396 TXD->upper_setup.tcp_fields.tucse = htole16(0); 2397 2398 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 2399 TXD->upper_setup.tcp_fields.tucso = 2400 ETHER_HDR_LEN + sizeof(struct ip) + 2401 offsetof(struct tcphdr, th_sum); 2402 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 2403 TXD->upper_setup.tcp_fields.tucso = 2404 ETHER_HDR_LEN + sizeof(struct ip) + 2405 offsetof(struct udphdr, uh_sum); 2406 } 2407 2408 TXD->tcp_seg_setup.data = htole32(0); 2409 TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT); 2410 2411 tx_buffer->m_head = NULL; 2412 2413 if (++curr_txd == adapter->num_tx_desc) 2414 curr_txd = 0; 2415 2416 adapter->num_tx_desc_avail--; 2417 adapter->next_avail_tx_desc = curr_txd; 2418 2419 return; 2420} 2421 2422/********************************************************************** 2423 * 2424 * Examine each tx_buffer in the used queue. If the hardware is done 2425 * processing the packet then free associated resources. The 2426 * tx_buffer is put back on the free queue. 2427 * 2428 **********************************************************************/ 2429static void 2430em_clean_transmit_interrupts(struct adapter * adapter) 2431{ 2432 int i, num_avail; 2433 struct em_buffer *tx_buffer; 2434 struct em_tx_desc *tx_desc; 2435 struct ifnet *ifp = adapter->ifp; 2436 2437 mtx_assert(&adapter->mtx, MA_OWNED); 2438 2439 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2440 return; 2441 2442 num_avail = adapter->num_tx_desc_avail; 2443 i = adapter->oldest_used_tx_desc; 2444 2445 tx_buffer = &adapter->tx_buffer_area[i]; 2446 tx_desc = &adapter->tx_desc_base[i]; 2447 2448 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, 2449 BUS_DMASYNC_POSTREAD); 2450 while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 2451 2452 tx_desc->upper.data = 0; 2453 num_avail++; 2454 2455 if (tx_buffer->m_head) { 2456 ifp->if_opackets++; 2457 bus_dmamap_unload(adapter->txtag, tx_buffer->map); 2458 bus_dmamap_destroy(adapter->txtag, tx_buffer->map); 2459 2460 m_freem(tx_buffer->m_head); 2461 tx_buffer->m_head = NULL; 2462 } 2463 2464 if (++i == adapter->num_tx_desc) 2465 i = 0; 2466 2467 tx_buffer = &adapter->tx_buffer_area[i]; 2468 tx_desc = &adapter->tx_desc_base[i]; 2469 } 2470 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, 2471 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2472 2473 adapter->oldest_used_tx_desc = i; 2474 2475 /* 2476 * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack 2477 * that it is OK to send packets. 2478 * If there are no pending descriptors, clear the timeout. Otherwise, 2479 * if some descriptors have been freed, restart the timeout. 2480 */ 2481 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2482 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 2483 if (num_avail == adapter->num_tx_desc) 2484 ifp->if_timer = 0; 2485 else if (num_avail == adapter->num_tx_desc_avail) 2486 ifp->if_timer = EM_TX_TIMEOUT; 2487 } 2488 adapter->num_tx_desc_avail = num_avail; 2489 return; 2490} 2491 2492/********************************************************************* 2493 * 2494 * Get a buffer from system mbuf buffer pool. 2495 * 2496 **********************************************************************/ 2497static int 2498em_get_buf(int i, struct adapter *adapter, 2499 struct mbuf *nmp) 2500{ 2501 register struct mbuf *mp = nmp; 2502 struct em_buffer *rx_buffer; 2503 struct ifnet *ifp; 2504 bus_addr_t paddr; 2505 int error; 2506 2507 ifp = adapter->ifp; 2508 2509 if (mp == NULL) { 2510 mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 2511 if (mp == NULL) { 2512 adapter->mbuf_cluster_failed++; 2513 return(ENOBUFS); 2514 } 2515 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2516 } else { 2517 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2518 mp->m_data = mp->m_ext.ext_buf; 2519 mp->m_next = NULL; 2520 } 2521 2522 if (ifp->if_mtu <= ETHERMTU) { 2523 m_adj(mp, ETHER_ALIGN); 2524 } 2525 2526 rx_buffer = &adapter->rx_buffer_area[i]; 2527 2528 /* 2529 * Using memory from the mbuf cluster pool, invoke the 2530 * bus_dma machinery to arrange the memory mapping. 2531 */ 2532 error = bus_dmamap_load(adapter->rxtag, rx_buffer->map, 2533 mtod(mp, void *), mp->m_len, 2534 em_dmamap_cb, &paddr, 0); 2535 if (error) { 2536 m_free(mp); 2537 return(error); 2538 } 2539 rx_buffer->m_head = mp; 2540 adapter->rx_desc_base[i].buffer_addr = htole64(paddr); 2541 bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); 2542 2543 return(0); 2544} 2545 2546/********************************************************************* 2547 * 2548 * Allocate memory for rx_buffer structures. Since we use one 2549 * rx_buffer per received packet, the maximum number of rx_buffer's 2550 * that we'll need is equal to the number of receive descriptors 2551 * that we've allocated. 2552 * 2553 **********************************************************************/ 2554static int 2555em_allocate_receive_structures(struct adapter * adapter) 2556{ 2557 int i, error; 2558 struct em_buffer *rx_buffer; 2559 2560 if (!(adapter->rx_buffer_area = 2561 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2562 adapter->num_rx_desc, M_DEVBUF, 2563 M_NOWAIT))) { 2564 printf("em%d: Unable to allocate rx_buffer memory\n", 2565 adapter->unit); 2566 return(ENOMEM); 2567 } 2568 2569 bzero(adapter->rx_buffer_area, 2570 sizeof(struct em_buffer) * adapter->num_rx_desc); 2571 2572 error = bus_dma_tag_create(NULL, /* parent */ 2573 1, 0, /* alignment, bounds */ 2574 BUS_SPACE_MAXADDR, /* lowaddr */ 2575 BUS_SPACE_MAXADDR, /* highaddr */ 2576 NULL, NULL, /* filter, filterarg */ 2577 MCLBYTES, /* maxsize */ 2578 1, /* nsegments */ 2579 MCLBYTES, /* maxsegsize */ 2580 BUS_DMA_ALLOCNOW, /* flags */ 2581 NULL, /* lockfunc */ 2582 NULL, /* lockarg */ 2583 &adapter->rxtag); 2584 if (error != 0) { 2585 printf("em%d: em_allocate_receive_structures: " 2586 "bus_dma_tag_create failed; error %u\n", 2587 adapter->unit, error); 2588 goto fail_0; 2589 } 2590 2591 rx_buffer = adapter->rx_buffer_area; 2592 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2593 error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, 2594 &rx_buffer->map); 2595 if (error != 0) { 2596 printf("em%d: em_allocate_receive_structures: " 2597 "bus_dmamap_create failed; error %u\n", 2598 adapter->unit, error); 2599 goto fail_1; 2600 } 2601 } 2602 2603 for (i = 0; i < adapter->num_rx_desc; i++) { 2604 error = em_get_buf(i, adapter, NULL); 2605 if (error != 0) { 2606 adapter->rx_buffer_area[i].m_head = NULL; 2607 adapter->rx_desc_base[i].buffer_addr = 0; 2608 return(error); 2609 } 2610 } 2611 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2612 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2613 2614 return(0); 2615 2616fail_1: 2617 bus_dma_tag_destroy(adapter->rxtag); 2618fail_0: 2619 adapter->rxtag = NULL; 2620 free(adapter->rx_buffer_area, M_DEVBUF); 2621 adapter->rx_buffer_area = NULL; 2622 return (error); 2623} 2624 2625/********************************************************************* 2626 * 2627 * Allocate and initialize receive structures. 2628 * 2629 **********************************************************************/ 2630static int 2631em_setup_receive_structures(struct adapter * adapter) 2632{ 2633 bzero((void *) adapter->rx_desc_base, 2634 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2635 2636 if (em_allocate_receive_structures(adapter)) 2637 return ENOMEM; 2638 2639 /* Setup our descriptor pointers */ 2640 adapter->next_rx_desc_to_check = 0; 2641 return(0); 2642} 2643 2644/********************************************************************* 2645 * 2646 * Enable receive unit. 2647 * 2648 **********************************************************************/ 2649static void 2650em_initialize_receive_unit(struct adapter * adapter) 2651{ 2652 u_int32_t reg_rctl; 2653 u_int32_t reg_rxcsum; 2654 struct ifnet *ifp; 2655 u_int64_t bus_addr; 2656 2657 INIT_DEBUGOUT("em_initialize_receive_unit: begin"); 2658 ifp = adapter->ifp; 2659 2660 /* Make sure receives are disabled while setting up the descriptor ring */ 2661 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2662 2663 /* Set the Receive Delay Timer Register */ 2664 E1000_WRITE_REG(&adapter->hw, RDTR, 2665 adapter->rx_int_delay.value | E1000_RDT_FPDB); 2666 2667 if(adapter->hw.mac_type >= em_82540) { 2668 E1000_WRITE_REG(&adapter->hw, RADV, 2669 adapter->rx_abs_int_delay.value); 2670 2671 /* Set the interrupt throttling rate. Value is calculated 2672 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2673#define MAX_INTS_PER_SEC 8000 2674#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2675 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2676 } 2677 2678 /* Setup the Base and Length of the Rx Descriptor Ring */ 2679 bus_addr = adapter->rxdma.dma_paddr; 2680 E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr); 2681 E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32)); 2682 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 2683 sizeof(struct em_rx_desc)); 2684 2685 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2686 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2687 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2688 2689 /* Setup the Receive Control Register */ 2690 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2691 E1000_RCTL_RDMTS_HALF | 2692 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2693 2694 if (adapter->hw.tbi_compatibility_on == TRUE) 2695 reg_rctl |= E1000_RCTL_SBP; 2696 2697 2698 switch (adapter->rx_buffer_len) { 2699 default: 2700 case EM_RXBUFFER_2048: 2701 reg_rctl |= E1000_RCTL_SZ_2048; 2702 break; 2703 case EM_RXBUFFER_4096: 2704 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2705 break; 2706 case EM_RXBUFFER_8192: 2707 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2708 break; 2709 case EM_RXBUFFER_16384: 2710 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2711 break; 2712 } 2713 2714 if (ifp->if_mtu > ETHERMTU) 2715 reg_rctl |= E1000_RCTL_LPE; 2716 2717 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2718 if ((adapter->hw.mac_type >= em_82543) && 2719 (ifp->if_capenable & IFCAP_RXCSUM)) { 2720 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2721 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2722 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2723 } 2724 2725 /* Enable Receives */ 2726 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2727 2728 return; 2729} 2730 2731/********************************************************************* 2732 * 2733 * Free receive related data structures. 2734 * 2735 **********************************************************************/ 2736static void 2737em_free_receive_structures(struct adapter *adapter) 2738{ 2739 struct em_buffer *rx_buffer; 2740 int i; 2741 2742 INIT_DEBUGOUT("free_receive_structures: begin"); 2743 2744 if (adapter->rx_buffer_area != NULL) { 2745 rx_buffer = adapter->rx_buffer_area; 2746 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2747 if (rx_buffer->map != NULL) { 2748 bus_dmamap_unload(adapter->rxtag, rx_buffer->map); 2749 bus_dmamap_destroy(adapter->rxtag, rx_buffer->map); 2750 } 2751 if (rx_buffer->m_head != NULL) 2752 m_freem(rx_buffer->m_head); 2753 rx_buffer->m_head = NULL; 2754 } 2755 } 2756 if (adapter->rx_buffer_area != NULL) { 2757 free(adapter->rx_buffer_area, M_DEVBUF); 2758 adapter->rx_buffer_area = NULL; 2759 } 2760 if (adapter->rxtag != NULL) { 2761 bus_dma_tag_destroy(adapter->rxtag); 2762 adapter->rxtag = NULL; 2763 } 2764 return; 2765} 2766 2767/********************************************************************* 2768 * 2769 * This routine executes in interrupt context. It replenishes 2770 * the mbufs in the descriptor and sends data which has been 2771 * dma'ed into host memory to upper layer. 2772 * 2773 * We loop at most count times if count is > 0, or until done if 2774 * count < 0. 2775 * 2776 *********************************************************************/ 2777static void 2778em_process_receive_interrupts(struct adapter * adapter, int count) 2779{ 2780 struct ifnet *ifp; 2781 struct mbuf *mp; 2782#if __FreeBSD_version < 500000 2783 struct ether_header *eh; 2784#endif 2785 u_int8_t accept_frame = 0; 2786 u_int8_t eop = 0; 2787 u_int16_t len, desc_len, prev_len_adj; 2788 int i; 2789 2790 /* Pointer to the receive descriptor being examined. */ 2791 struct em_rx_desc *current_desc; 2792 2793 mtx_assert(&adapter->mtx, MA_OWNED); 2794 2795 ifp = adapter->ifp; 2796 i = adapter->next_rx_desc_to_check; 2797 current_desc = &adapter->rx_desc_base[i]; 2798 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2799 BUS_DMASYNC_POSTREAD); 2800 2801 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2802 return; 2803 } 2804 2805 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2806 2807 mp = adapter->rx_buffer_area[i].m_head; 2808 bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, 2809 BUS_DMASYNC_POSTREAD); 2810 2811 accept_frame = 1; 2812 prev_len_adj = 0; 2813 desc_len = le16toh(current_desc->length); 2814 if (current_desc->status & E1000_RXD_STAT_EOP) { 2815 count--; 2816 eop = 1; 2817 if (desc_len < ETHER_CRC_LEN) { 2818 len = 0; 2819 prev_len_adj = ETHER_CRC_LEN - desc_len; 2820 } 2821 else { 2822 len = desc_len - ETHER_CRC_LEN; 2823 } 2824 } else { 2825 eop = 0; 2826 len = desc_len; 2827 } 2828 2829 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2830 u_int8_t last_byte; 2831 u_int32_t pkt_len = desc_len; 2832 2833 if (adapter->fmp != NULL) 2834 pkt_len += adapter->fmp->m_pkthdr.len; 2835 2836 last_byte = *(mtod(mp, caddr_t) + desc_len - 1); 2837 2838 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2839 current_desc->errors, 2840 pkt_len, last_byte)) { 2841 em_tbi_adjust_stats(&adapter->hw, 2842 &adapter->stats, 2843 pkt_len, 2844 adapter->hw.mac_addr); 2845 if (len > 0) len--; 2846 } 2847 else { 2848 accept_frame = 0; 2849 } 2850 } 2851 2852 if (accept_frame) { 2853 2854 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2855 adapter->dropped_pkts++; 2856 em_get_buf(i, adapter, mp); 2857 if (adapter->fmp != NULL) 2858 m_freem(adapter->fmp); 2859 adapter->fmp = NULL; 2860 adapter->lmp = NULL; 2861 break; 2862 } 2863 2864 /* Assign correct length to the current fragment */ 2865 mp->m_len = len; 2866 2867 if (adapter->fmp == NULL) { 2868 mp->m_pkthdr.len = len; 2869 adapter->fmp = mp; /* Store the first mbuf */ 2870 adapter->lmp = mp; 2871 } else { 2872 /* Chain mbuf's together */ 2873 mp->m_flags &= ~M_PKTHDR; 2874 /* 2875 * Adjust length of previous mbuf in chain if we 2876 * received less than 4 bytes in the last descriptor. 2877 */ 2878 if (prev_len_adj > 0) { 2879 adapter->lmp->m_len -= prev_len_adj; 2880 adapter->fmp->m_pkthdr.len -= prev_len_adj; 2881 } 2882 adapter->lmp->m_next = mp; 2883 adapter->lmp = adapter->lmp->m_next; 2884 adapter->fmp->m_pkthdr.len += len; 2885 } 2886 2887 if (eop) { 2888 adapter->fmp->m_pkthdr.rcvif = ifp; 2889 ifp->if_ipackets++; 2890 2891#if __FreeBSD_version < 500000 2892 eh = mtod(adapter->fmp, struct ether_header *); 2893 /* Remove ethernet header from mbuf */ 2894 m_adj(adapter->fmp, sizeof(struct ether_header)); 2895 em_receive_checksum(adapter, current_desc, 2896 adapter->fmp); 2897 if (current_desc->status & E1000_RXD_STAT_VP) 2898 VLAN_INPUT_TAG(eh, adapter->fmp, 2899 (current_desc->special & 2900 E1000_RXD_SPC_VLAN_MASK)); 2901 else 2902 ether_input(ifp, eh, adapter->fmp); 2903#else 2904 2905 em_receive_checksum(adapter, current_desc, 2906 adapter->fmp); 2907 if (current_desc->status & E1000_RXD_STAT_VP) 2908 VLAN_INPUT_TAG(ifp, adapter->fmp, 2909 (current_desc->special & 2910 E1000_RXD_SPC_VLAN_MASK), 2911 adapter->fmp = NULL); 2912 2913 if (adapter->fmp != NULL) { 2914 struct mbuf *m = adapter->fmp; 2915 2916 adapter->fmp = NULL; 2917 EM_UNLOCK(adapter); 2918 (*ifp->if_input)(ifp, m); 2919 EM_LOCK(adapter); 2920 } 2921#endif 2922 adapter->lmp = NULL; 2923 } 2924 } else { 2925 adapter->dropped_pkts++; 2926 em_get_buf(i, adapter, mp); 2927 if (adapter->fmp != NULL) 2928 m_freem(adapter->fmp); 2929 adapter->fmp = NULL; 2930 adapter->lmp = NULL; 2931 } 2932 2933 /* Zero out the receive descriptors status */ 2934 current_desc->status = 0; 2935 2936 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2937 E1000_WRITE_REG(&adapter->hw, RDT, i); 2938 2939 /* Advance our pointers to the next descriptor */ 2940 if (++i == adapter->num_rx_desc) { 2941 i = 0; 2942 current_desc = adapter->rx_desc_base; 2943 } else 2944 current_desc++; 2945 } 2946 bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, 2947 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); 2948 adapter->next_rx_desc_to_check = i; 2949 return; 2950} 2951 2952/********************************************************************* 2953 * 2954 * Verify that the hardware indicated that the checksum is valid. 2955 * Inform the stack about the status of checksum so that stack 2956 * doesn't spend time verifying the checksum. 2957 * 2958 *********************************************************************/ 2959static void 2960em_receive_checksum(struct adapter *adapter, 2961 struct em_rx_desc *rx_desc, 2962 struct mbuf *mp) 2963{ 2964 /* 82543 or newer only */ 2965 if ((adapter->hw.mac_type < em_82543) || 2966 /* Ignore Checksum bit is set */ 2967 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2968 mp->m_pkthdr.csum_flags = 0; 2969 return; 2970 } 2971 2972 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2973 /* Did it pass? */ 2974 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2975 /* IP Checksum Good */ 2976 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2977 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2978 2979 } else { 2980 mp->m_pkthdr.csum_flags = 0; 2981 } 2982 } 2983 2984 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2985 /* Did it pass? */ 2986 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2987 mp->m_pkthdr.csum_flags |= 2988 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2989 mp->m_pkthdr.csum_data = htons(0xffff); 2990 } 2991 } 2992 2993 return; 2994} 2995 2996 2997static void 2998em_enable_vlans(struct adapter *adapter) 2999{ 3000 uint32_t ctrl; 3001 3002 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 3003 3004 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 3005 ctrl |= E1000_CTRL_VME; 3006 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 3007 3008 return; 3009} 3010 3011static void 3012em_disable_vlans(struct adapter *adapter) 3013{ 3014 uint32_t ctrl; 3015 3016 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 3017 ctrl &= ~E1000_CTRL_VME; 3018 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 3019 3020 return; 3021} 3022 3023static void 3024em_enable_intr(struct adapter * adapter) 3025{ 3026 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 3027 return; 3028} 3029 3030static void 3031em_disable_intr(struct adapter *adapter) 3032{ 3033 /* 3034 * The first version of 82542 had an errata where when link was forced it 3035 * would stay up even up even if the cable was disconnected. Sequence errors 3036 * were used to detect the disconnect and then the driver would unforce the link. 3037 * This code in the in the ISR. For this to work correctly the Sequence error 3038 * interrupt had to be enabled all the time. 3039 */ 3040 3041 if (adapter->hw.mac_type == em_82542_rev2_0) 3042 E1000_WRITE_REG(&adapter->hw, IMC, 3043 (0xffffffff & ~E1000_IMC_RXSEQ)); 3044 else 3045 E1000_WRITE_REG(&adapter->hw, IMC, 3046 0xffffffff); 3047 return; 3048} 3049 3050static int 3051em_is_valid_ether_addr(u_int8_t *addr) 3052{ 3053 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; 3054 3055 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { 3056 return (FALSE); 3057 } 3058 3059 return(TRUE); 3060} 3061 3062void 3063em_write_pci_cfg(struct em_hw *hw, 3064 uint32_t reg, 3065 uint16_t *value) 3066{ 3067 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 3068 *value, 2); 3069} 3070 3071void 3072em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 3073 uint16_t *value) 3074{ 3075 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 3076 reg, 2); 3077 return; 3078} 3079 3080void 3081em_pci_set_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 3089void 3090em_pci_clear_mwi(struct em_hw *hw) 3091{ 3092 pci_write_config(((struct em_osdep *)hw->back)->dev, 3093 PCIR_COMMAND, 3094 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 3095 return; 3096} 3097 3098uint32_t 3099em_io_read(struct em_hw *hw, unsigned long port) 3100{ 3101 return(inl(port)); 3102} 3103 3104void 3105em_io_write(struct em_hw *hw, unsigned long port, uint32_t value) 3106{ 3107 outl(port, value); 3108 return; 3109} 3110 3111/********************************************************************* 3112* 82544 Coexistence issue workaround. 3113* There are 2 issues. 3114* 1. Transmit Hang issue. 3115* To detect this issue, following equation can be used... 3116* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 3117* If SUM[3:0] is in between 1 to 4, we will have this issue. 3118* 3119* 2. DAC issue. 3120* To detect this issue, following equation can be used... 3121* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. 3122* If SUM[3:0] is in between 9 to c, we will have this issue. 3123* 3124* 3125* WORKAROUND: 3126* Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC) 3127* 3128*** *********************************************************************/ 3129static u_int32_t 3130em_fill_descriptors (u_int64_t address, 3131 u_int32_t length, 3132 PDESC_ARRAY desc_array) 3133{ 3134 /* Since issue is sensitive to length and address.*/ 3135 /* Let us first check the address...*/ 3136 u_int32_t safe_terminator; 3137 if (length <= 4) { 3138 desc_array->descriptor[0].address = address; 3139 desc_array->descriptor[0].length = length; 3140 desc_array->elements = 1; 3141 return desc_array->elements; 3142 } 3143 safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF); 3144 /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */ 3145 if (safe_terminator == 0 || 3146 (safe_terminator > 4 && 3147 safe_terminator < 9) || 3148 (safe_terminator > 0xC && 3149 safe_terminator <= 0xF)) { 3150 desc_array->descriptor[0].address = address; 3151 desc_array->descriptor[0].length = length; 3152 desc_array->elements = 1; 3153 return desc_array->elements; 3154 } 3155 3156 desc_array->descriptor[0].address = address; 3157 desc_array->descriptor[0].length = length - 4; 3158 desc_array->descriptor[1].address = address + (length - 4); 3159 desc_array->descriptor[1].length = 4; 3160 desc_array->elements = 2; 3161 return desc_array->elements; 3162} 3163 3164/********************************************************************** 3165 * 3166 * Update the board statistics counters. 3167 * 3168 **********************************************************************/ 3169static void 3170em_update_stats_counters(struct adapter *adapter) 3171{ 3172 struct ifnet *ifp; 3173 3174 if(adapter->hw.media_type == em_media_type_copper || 3175 (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) { 3176 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 3177 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 3178 } 3179 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 3180 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 3181 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 3182 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 3183 3184 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 3185 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 3186 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 3187 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 3188 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 3189 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 3190 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 3191 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 3192 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 3193 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 3194 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 3195 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 3196 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 3197 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 3198 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 3199 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 3200 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 3201 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 3202 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 3203 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 3204 3205 /* For the 64-bit byte counters the low dword must be read first. */ 3206 /* Both registers clear on the read of the high dword */ 3207 3208 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 3209 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 3210 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 3211 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 3212 3213 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 3214 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 3215 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 3216 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 3217 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 3218 3219 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 3220 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 3221 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 3222 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 3223 3224 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 3225 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 3226 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 3227 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 3228 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 3229 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 3230 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 3231 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 3232 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 3233 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 3234 3235 if (adapter->hw.mac_type >= em_82543) { 3236 adapter->stats.algnerrc += 3237 E1000_READ_REG(&adapter->hw, ALGNERRC); 3238 adapter->stats.rxerrc += 3239 E1000_READ_REG(&adapter->hw, RXERRC); 3240 adapter->stats.tncrs += 3241 E1000_READ_REG(&adapter->hw, TNCRS); 3242 adapter->stats.cexterr += 3243 E1000_READ_REG(&adapter->hw, CEXTERR); 3244 adapter->stats.tsctc += 3245 E1000_READ_REG(&adapter->hw, TSCTC); 3246 adapter->stats.tsctfc += 3247 E1000_READ_REG(&adapter->hw, TSCTFC); 3248 } 3249 ifp = adapter->ifp; 3250 3251 /* Fill out the OS statistics structure */ 3252 ifp->if_ibytes = adapter->stats.gorcl; 3253 ifp->if_obytes = adapter->stats.gotcl; 3254 ifp->if_imcasts = adapter->stats.mprc; 3255 ifp->if_collisions = adapter->stats.colc; 3256 3257 /* Rx Errors */ 3258 ifp->if_ierrors = 3259 adapter->dropped_pkts + 3260 adapter->stats.rxerrc + 3261 adapter->stats.crcerrs + 3262 adapter->stats.algnerrc + 3263 adapter->stats.rlec + 3264 adapter->stats.mpc + adapter->stats.cexterr; 3265 3266 /* Tx Errors */ 3267 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 3268 3269} 3270 3271 3272/********************************************************************** 3273 * 3274 * This routine is called only when em_display_debug_stats is enabled. 3275 * This routine provides a way to take a look at important statistics 3276 * maintained by the driver and hardware. 3277 * 3278 **********************************************************************/ 3279static void 3280em_print_debug_info(struct adapter *adapter) 3281{ 3282 int unit = adapter->unit; 3283 uint8_t *hw_addr = adapter->hw.hw_addr; 3284 3285 printf("em%d: Adapter hardware address = %p \n", unit, hw_addr); 3286 printf("em%d:CTRL = 0x%x\n", unit, 3287 E1000_READ_REG(&adapter->hw, CTRL)); 3288 printf("em%d:RCTL = 0x%x PS=(0x8402)\n", unit, 3289 E1000_READ_REG(&adapter->hw, RCTL)); 3290 printf("em%d:tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, 3291 E1000_READ_REG(&adapter->hw, TIDV), 3292 E1000_READ_REG(&adapter->hw, TADV)); 3293 printf("em%d:rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, 3294 E1000_READ_REG(&adapter->hw, RDTR), 3295 E1000_READ_REG(&adapter->hw, RADV)); 3296 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 3297 (long long)adapter->tx_fifo_wrk_cnt, 3298 (long long)adapter->tx_fifo_reset_cnt); 3299 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 3300 E1000_READ_REG(&adapter->hw, TDH), 3301 E1000_READ_REG(&adapter->hw, TDT)); 3302 printf("em%d: Num Tx descriptors avail = %d\n", unit, 3303 adapter->num_tx_desc_avail); 3304 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 3305 adapter->no_tx_desc_avail1); 3306 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 3307 adapter->no_tx_desc_avail2); 3308 printf("em%d: Std mbuf failed = %ld\n", unit, 3309 adapter->mbuf_alloc_failed); 3310 printf("em%d: Std mbuf cluster failed = %ld\n", unit, 3311 adapter->mbuf_cluster_failed); 3312 printf("em%d: Driver dropped packets = %ld\n", unit, 3313 adapter->dropped_pkts); 3314 3315 return; 3316} 3317 3318static void 3319em_print_hw_stats(struct adapter *adapter) 3320{ 3321 int unit = adapter->unit; 3322 3323 printf("em%d: Excessive collisions = %lld\n", unit, 3324 (long long)adapter->stats.ecol); 3325 printf("em%d: Symbol errors = %lld\n", unit, 3326 (long long)adapter->stats.symerrs); 3327 printf("em%d: Sequence errors = %lld\n", unit, 3328 (long long)adapter->stats.sec); 3329 printf("em%d: Defer count = %lld\n", unit, 3330 (long long)adapter->stats.dc); 3331 3332 printf("em%d: Missed Packets = %lld\n", unit, 3333 (long long)adapter->stats.mpc); 3334 printf("em%d: Receive No Buffers = %lld\n", unit, 3335 (long long)adapter->stats.rnbc); 3336 printf("em%d: Receive length errors = %lld\n", unit, 3337 (long long)adapter->stats.rlec); 3338 printf("em%d: Receive errors = %lld\n", unit, 3339 (long long)adapter->stats.rxerrc); 3340 printf("em%d: Crc errors = %lld\n", unit, 3341 (long long)adapter->stats.crcerrs); 3342 printf("em%d: Alignment errors = %lld\n", unit, 3343 (long long)adapter->stats.algnerrc); 3344 printf("em%d: Carrier extension errors = %lld\n", unit, 3345 (long long)adapter->stats.cexterr); 3346 3347 printf("em%d: XON Rcvd = %lld\n", unit, 3348 (long long)adapter->stats.xonrxc); 3349 printf("em%d: XON Xmtd = %lld\n", unit, 3350 (long long)adapter->stats.xontxc); 3351 printf("em%d: XOFF Rcvd = %lld\n", unit, 3352 (long long)adapter->stats.xoffrxc); 3353 printf("em%d: XOFF Xmtd = %lld\n", unit, 3354 (long long)adapter->stats.xofftxc); 3355 3356 printf("em%d: Good Packets Rcvd = %lld\n", unit, 3357 (long long)adapter->stats.gprc); 3358 printf("em%d: Good Packets Xmtd = %lld\n", unit, 3359 (long long)adapter->stats.gptc); 3360 3361 return; 3362} 3363 3364static int 3365em_sysctl_debug_info(SYSCTL_HANDLER_ARGS) 3366{ 3367 int error; 3368 int result; 3369 struct adapter *adapter; 3370 3371 result = -1; 3372 error = sysctl_handle_int(oidp, &result, 0, req); 3373 3374 if (error || !req->newptr) 3375 return (error); 3376 3377 if (result == 1) { 3378 adapter = (struct adapter *)arg1; 3379 em_print_debug_info(adapter); 3380 } 3381 3382 return error; 3383} 3384 3385 3386static int 3387em_sysctl_stats(SYSCTL_HANDLER_ARGS) 3388{ 3389 int error; 3390 int result; 3391 struct adapter *adapter; 3392 3393 result = -1; 3394 error = sysctl_handle_int(oidp, &result, 0, req); 3395 3396 if (error || !req->newptr) 3397 return (error); 3398 3399 if (result == 1) { 3400 adapter = (struct adapter *)arg1; 3401 em_print_hw_stats(adapter); 3402 } 3403 3404 return error; 3405} 3406 3407static int 3408em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) 3409{ 3410 struct em_int_delay_info *info; 3411 struct adapter *adapter; 3412 u_int32_t regval; 3413 int error; 3414 int usecs; 3415 int ticks; 3416 int s; 3417 3418 info = (struct em_int_delay_info *)arg1; 3419 adapter = info->adapter; 3420 usecs = info->value; 3421 error = sysctl_handle_int(oidp, &usecs, 0, req); 3422 if (error != 0 || req->newptr == NULL) 3423 return error; 3424 if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535)) 3425 return EINVAL; 3426 info->value = usecs; 3427 ticks = E1000_USECS_TO_TICKS(usecs); 3428 3429 s = splimp(); 3430 regval = E1000_READ_OFFSET(&adapter->hw, info->offset); 3431 regval = (regval & ~0xffff) | (ticks & 0xffff); 3432 /* Handle a few special cases. */ 3433 switch (info->offset) { 3434 case E1000_RDTR: 3435 case E1000_82542_RDTR: 3436 regval |= E1000_RDT_FPDB; 3437 break; 3438 case E1000_TIDV: 3439 case E1000_82542_TIDV: 3440 if (ticks == 0) { 3441 adapter->txd_cmd &= ~E1000_TXD_CMD_IDE; 3442 /* Don't write 0 into the TIDV register. */ 3443 regval++; 3444 } else 3445 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 3446 break; 3447 } 3448 E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval); 3449 splx(s); 3450 return 0; 3451} 3452 3453static void 3454em_add_int_delay_sysctl(struct adapter *adapter, const char *name, 3455 const char *description, struct em_int_delay_info *info, 3456 int offset, int value) 3457{ 3458 info->adapter = adapter; 3459 info->offset = offset; 3460 info->value = value; 3461 SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev), 3462 SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), 3463 OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, 3464 info, 0, em_sysctl_int_delay, "I", description); 3465} 3466