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