if_em.c revision 113506
174462Salfred/************************************************************************** 274462Salfred 374462SalfredCopyright (c) 2001-2003, Intel Corporation 474462SalfredAll rights reserved. 574462Salfred 674462SalfredRedistribution and use in source and binary forms, with or without 774462Salfredmodification, are permitted provided that the following conditions are met: 874462Salfred 974462Salfred 1. Redistributions of source code must retain the above copyright notice, 1074462Salfred this list of conditions and the following disclaimer. 1174462Salfred 1274462Salfred 2. Redistributions in binary form must reproduce the above copyright 1374462Salfred notice, this list of conditions and the following disclaimer in the 1474462Salfred documentation and/or other materials provided with the distribution. 1574462Salfred 1674462Salfred 3. Neither the name of the Intel Corporation nor the names of its 1774462Salfred contributors may be used to endorse or promote products derived from 1874462Salfred this software without specific prior written permission. 1974462Salfred 2074462SalfredTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2174462SalfredAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2274462SalfredIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2374462SalfredARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 2474462SalfredLIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2574462SalfredCONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2674462SalfredSUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2774462SalfredINTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2874462SalfredCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2974462SalfredARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 3074462SalfredPOSSIBILITY OF SUCH DAMAGE. 3174462Salfred 3274462Salfred***************************************************************************/ 3374462Salfred 3474462Salfred/*$FreeBSD: head/sys/dev/em/if_em.c 113506 2003-04-15 06:37:30Z mdodd $*/ 3574462Salfred 3674462Salfred#include <dev/em/if_em.h> 3774462Salfred 3874462Salfred/********************************************************************* 3974462Salfred * Set this to one to display debug statistics 4074462Salfred *********************************************************************/ 4174462Salfredint em_display_debug_stats = 0; 4274462Salfred 4374462Salfred/********************************************************************* 4474462Salfred * Linked list of board private structures for all NICs found 4574462Salfred *********************************************************************/ 4674462Salfred 4774462Salfredstruct adapter *em_adapter_list = NULL; 4874462Salfred 4974462Salfred 5074462Salfred/********************************************************************* 5174462Salfred * Driver version 5274462Salfred *********************************************************************/ 5374462Salfred 5474462Salfredchar em_driver_version[] = "1.5.31"; 5574462Salfred 5674462Salfred 5774462Salfred/********************************************************************* 5874462Salfred * PCI Device ID Table 5974462Salfred * 6074462Salfred * Used by probe to select devices to load on 6174462Salfred * Last field stores an index into em_strings 6274462Salfred * Last entry must be all 0s 6374462Salfred * 6474462Salfred * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 6574462Salfred *********************************************************************/ 6674462Salfred 6774462Salfredstatic em_vendor_info_t em_vendor_info_array[] = 6874462Salfred{ 6974462Salfred /* Intel(R) PRO/1000 Network Connection */ 7074462Salfred { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0}, 7174462Salfred { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0}, 7274462Salfred { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0}, 7374462Salfred { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0}, 7474462Salfred { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0}, 7574462Salfred { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0}, 7674462Salfred { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0}, 7774462Salfred { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0}, 7874462Salfred { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0}, 7974462Salfred { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0}, 8074462Salfred { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0}, 8174462Salfred { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0}, 8274462Salfred { 0x8086, 0x1013, PCI_ANY_ID, PCI_ANY_ID, 0}, 8374462Salfred { 0x8086, 0x1014, PCI_ANY_ID, PCI_ANY_ID, 0}, 8474462Salfred { 0x8086, 0x1015, PCI_ANY_ID, PCI_ANY_ID, 0}, 8574462Salfred { 0x8086, 0x1016, PCI_ANY_ID, PCI_ANY_ID, 0}, 8674462Salfred { 0x8086, 0x1017, PCI_ANY_ID, PCI_ANY_ID, 0}, 8774462Salfred { 0x8086, 0x1018, PCI_ANY_ID, PCI_ANY_ID, 0}, 8874462Salfred { 0x8086, 0x1019, PCI_ANY_ID, PCI_ANY_ID, 0}, 8974462Salfred { 0x8086, 0x101A, PCI_ANY_ID, PCI_ANY_ID, 0}, 9074462Salfred { 0x8086, 0x101E, PCI_ANY_ID, PCI_ANY_ID, 0}, 9174462Salfred /* required last entry */ 9274462Salfred { 0, 0, 0, 0, 0} 9374462Salfred}; 9474462Salfred 9574462Salfred/********************************************************************* 9674462Salfred * Table of branding strings for all supported NICs. 9774462Salfred *********************************************************************/ 9874462Salfred 9974462Salfredstatic char *em_strings[] = { 10074462Salfred "Intel(R) PRO/1000 Network Connection" 10174462Salfred}; 10274462Salfred 10374462Salfred/********************************************************************* 10474462Salfred * Function prototypes 10574462Salfred *********************************************************************/ 10674462Salfredstatic int em_probe(device_t); 10774462Salfredstatic int em_attach(device_t); 10874462Salfredstatic int em_detach(device_t); 10974462Salfredstatic int em_shutdown(device_t); 11074462Salfredstatic void em_intr(void *); 11174462Salfredstatic void em_start(struct ifnet *); 11274462Salfredstatic int em_ioctl(struct ifnet *, u_long, caddr_t); 11374462Salfredstatic void em_watchdog(struct ifnet *); 11474462Salfredstatic void em_init(void *); 11574462Salfredstatic void em_stop(void *); 11674462Salfredstatic void em_media_status(struct ifnet *, struct ifmediareq *); 11774462Salfredstatic int em_media_change(struct ifnet *); 11874462Salfredstatic void em_identify_hardware(struct adapter *); 11974462Salfredstatic int em_allocate_pci_resources(struct adapter *); 12074462Salfredstatic void em_free_pci_resources(struct adapter *); 12174462Salfredstatic void em_local_timer(void *); 12274462Salfredstatic int em_hardware_init(struct adapter *); 12374462Salfredstatic void em_setup_interface(device_t, struct adapter *); 12474462Salfredstatic int em_setup_transmit_structures(struct adapter *); 12574462Salfredstatic void em_initialize_transmit_unit(struct adapter *); 12674462Salfredstatic int em_setup_receive_structures(struct adapter *); 12774462Salfredstatic void em_initialize_receive_unit(struct adapter *); 12874462Salfredstatic void em_enable_intr(struct adapter *); 12974462Salfredstatic void em_disable_intr(struct adapter *); 13074462Salfredstatic void em_free_transmit_structures(struct adapter *); 13174462Salfredstatic void em_free_receive_structures(struct adapter *); 13274462Salfredstatic void em_update_stats_counters(struct adapter *); 13374462Salfredstatic void em_clean_transmit_interrupts(struct adapter *); 13474462Salfredstatic int em_allocate_receive_structures(struct adapter *); 13574462Salfredstatic int em_allocate_transmit_structures(struct adapter *); 13674462Salfredstatic void em_process_receive_interrupts(struct adapter *, int); 13774462Salfredstatic void em_receive_checksum(struct adapter *, 13874462Salfred struct em_rx_desc *, 13974462Salfred struct mbuf *); 14074462Salfredstatic void em_transmit_checksum_setup(struct adapter *, 14174462Salfred struct mbuf *, 14274462Salfred u_int32_t *, 14374462Salfred u_int32_t *); 14474462Salfredstatic void em_set_promisc(struct adapter *); 14574462Salfredstatic void em_disable_promisc(struct adapter *); 14674462Salfredstatic void em_set_multi(struct adapter *); 14774462Salfredstatic void em_print_hw_stats(struct adapter *); 14874462Salfredstatic void em_print_link_status(struct adapter *); 14974462Salfredstatic int em_get_buf(int i, struct adapter *, 15074462Salfred struct mbuf *); 15174462Salfredstatic void em_enable_vlans(struct adapter *); 15274462Salfredstatic int em_encap(struct adapter *, struct mbuf *); 15374462Salfredstatic void em_smartspeed(struct adapter *); 15474462Salfredstatic int em_82547_fifo_workaround(struct adapter *, int); 15574462Salfredstatic void em_82547_update_fifo_head(struct adapter *, int); 15674462Salfredstatic int em_82547_tx_fifo_reset(struct adapter *); 15774462Salfredstatic void em_82547_move_tail(void *arg); 15874462Salfred 15974462Salfred/********************************************************************* 16074462Salfred * FreeBSD Device Interface Entry Points 16174462Salfred *********************************************************************/ 16274462Salfred 16374462Salfredstatic device_method_t em_methods[] = { 16474462Salfred /* Device interface */ 16574462Salfred DEVMETHOD(device_probe, em_probe), 16674462Salfred DEVMETHOD(device_attach, em_attach), 16774462Salfred DEVMETHOD(device_detach, em_detach), 16874462Salfred DEVMETHOD(device_shutdown, em_shutdown), 16974462Salfred {0, 0} 17074462Salfred}; 17174462Salfred 17274462Salfredstatic driver_t em_driver = { 17374462Salfred "em", em_methods, sizeof(struct adapter ), 17474462Salfred}; 17574462Salfred 17674462Salfredstatic devclass_t em_devclass; 17774462SalfredDRIVER_MODULE(em, pci, em_driver, em_devclass, 0, 0); 17874462SalfredMODULE_DEPEND(em, pci, 1, 1, 1); 17974462SalfredMODULE_DEPEND(em, ether, 1, 1, 1); 18074462Salfred 18174462Salfred/********************************************************************* 18274462Salfred * Device identification routine 18374462Salfred * 18474462Salfred * em_probe determines if the driver should be loaded on 18574462Salfred * adapter based on PCI vendor/device id of the adapter. 18674462Salfred * 18774462Salfred * return 0 on success, positive on failure 18874462Salfred *********************************************************************/ 18974462Salfred 19074462Salfredstatic int 19174462Salfredem_probe(device_t dev) 19274462Salfred{ 19374462Salfred em_vendor_info_t *ent; 19474462Salfred 19574462Salfred u_int16_t pci_vendor_id = 0; 19674462Salfred u_int16_t pci_device_id = 0; 19774462Salfred u_int16_t pci_subvendor_id = 0; 19874462Salfred u_int16_t pci_subdevice_id = 0; 19974462Salfred char adapter_name[60]; 20074462Salfred 20174462Salfred INIT_DEBUGOUT("em_probe: begin"); 20274462Salfred 20374462Salfred pci_vendor_id = pci_get_vendor(dev); 20474462Salfred if (pci_vendor_id != EM_VENDOR_ID) 20574462Salfred return(ENXIO); 20674462Salfred 20774462Salfred pci_device_id = pci_get_device(dev); 20874462Salfred pci_subvendor_id = pci_get_subvendor(dev); 20974462Salfred pci_subdevice_id = pci_get_subdevice(dev); 21074462Salfred 21174462Salfred ent = em_vendor_info_array; 21274462Salfred while (ent->vendor_id != 0) { 21374462Salfred if ((pci_vendor_id == ent->vendor_id) && 21474462Salfred (pci_device_id == ent->device_id) && 21574462Salfred 21674462Salfred ((pci_subvendor_id == ent->subvendor_id) || 21774462Salfred (ent->subvendor_id == PCI_ANY_ID)) && 21874462Salfred 21974462Salfred ((pci_subdevice_id == ent->subdevice_id) || 22074462Salfred (ent->subdevice_id == PCI_ANY_ID))) { 22174462Salfred sprintf(adapter_name, "%s, Version - %s", 22274462Salfred em_strings[ent->index], 22374462Salfred em_driver_version); 22474462Salfred device_set_desc_copy(dev, adapter_name); 22574462Salfred return(0); 22674462Salfred } 22774462Salfred ent++; 22874462Salfred } 22974462Salfred 23074462Salfred return(ENXIO); 23174462Salfred} 23274462Salfred 23374462Salfred/********************************************************************* 23474462Salfred * Device initialization routine 23574462Salfred * 23674462Salfred * The attach entry point is called when the driver is being loaded. 23774462Salfred * This routine identifies the type of hardware, allocates all resources 23874462Salfred * and initializes the hardware. 23974462Salfred * 24074462Salfred * return 0 on success, positive on failure 24174462Salfred *********************************************************************/ 24274462Salfred 24374462Salfredstatic int 24474462Salfredem_attach(device_t dev) 24574462Salfred{ 24674462Salfred struct adapter * adapter; 24774462Salfred int s; 24874462Salfred int tsize, rsize; 24974462Salfred 25074462Salfred INIT_DEBUGOUT("em_attach: begin"); 25174462Salfred s = splimp(); 25274462Salfred 25374462Salfred /* Allocate, clear, and link in our adapter structure */ 25474462Salfred if (!(adapter = device_get_softc(dev))) { 25574462Salfred printf("em: adapter structure allocation failed\n"); 25674462Salfred splx(s); 25774462Salfred return(ENOMEM); 25874462Salfred } 25974462Salfred bzero(adapter, sizeof(struct adapter )); 26074462Salfred adapter->dev = dev; 26174462Salfred adapter->osdep.dev = dev; 26274462Salfred adapter->unit = device_get_unit(dev); 26374462Salfred 26474462Salfred if (em_adapter_list != NULL) 26574462Salfred em_adapter_list->prev = adapter; 26674462Salfred adapter->next = em_adapter_list; 26774462Salfred em_adapter_list = adapter; 26874462Salfred 26974462Salfred callout_handle_init(&adapter->timer_handle); 27074462Salfred callout_handle_init(&adapter->tx_fifo_timer_handle); 27174462Salfred 27274462Salfred /* Determine hardware revision */ 27374462Salfred em_identify_hardware(adapter); 27474462Salfred 27574462Salfred /* Parameters (to be read from user) */ 27674462Salfred adapter->num_tx_desc = EM_MAX_TXD; 27774462Salfred adapter->num_rx_desc = EM_MAX_RXD; 27874462Salfred adapter->tx_int_delay = EM_TIDV; 27974462Salfred adapter->tx_abs_int_delay = EM_TADV; 28074462Salfred adapter->rx_int_delay = EM_RDTR; 28174462Salfred adapter->rx_abs_int_delay = EM_RADV; 28274462Salfred adapter->hw.autoneg = DO_AUTO_NEG; 28374462Salfred adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; 28474462Salfred adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 28574462Salfred adapter->hw.tbi_compatibility_en = TRUE; 28674462Salfred adapter->rx_buffer_len = EM_RXBUFFER_2048; 28774462Salfred 28874462Salfred /* These parameters control the automatic generation(Tx) and 28974462Salfred * response(Rx) to Ethernet PAUSE frames. 29074462Salfred */ 29174462Salfred adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH; 29274462Salfred adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH; 29374462Salfred adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER; 29474462Salfred adapter->hw.fc_send_xon = TRUE; 29574462Salfred adapter->hw.fc = em_fc_full; 29674462Salfred 29774462Salfred adapter->hw.phy_init_script = 1; 29874462Salfred 29974462Salfred /* 30074462Salfred * Set the max frame size assuming standard ethernet 30174462Salfred * sized frames 30274462Salfred */ 30374462Salfred adapter->hw.max_frame_size = 30474462Salfred ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 30574462Salfred 30674462Salfred adapter->hw.min_frame_size = 30774462Salfred MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; 30874462Salfred 30974462Salfred /* 31074462Salfred * This controls when hardware reports transmit completion 31174462Salfred * status. 31274462Salfred */ 31374462Salfred adapter->hw.report_tx_early = 1; 31474462Salfred 31574462Salfred 31674462Salfred if (em_allocate_pci_resources(adapter)) { 31774462Salfred printf("em%d: Allocation of PCI resources failed\n", 31874462Salfred adapter->unit); 31974462Salfred em_free_pci_resources(adapter); 32074462Salfred splx(s); 32174462Salfred return(ENXIO); 32274462Salfred } 32374462Salfred 32474462Salfred 32574462Salfred /* Initialize eeprom parameters */ 32674462Salfred em_init_eeprom_params(&adapter->hw); 32774462Salfred 32874462Salfred tsize = EM_ROUNDUP(adapter->num_tx_desc * 32974801Salfred sizeof(struct em_tx_desc), 4096); 33074462Salfred 33174462Salfred /* Allocate Transmit Descriptor ring */ 33274462Salfred if (!(adapter->tx_desc_base = (struct em_tx_desc *) 33374462Salfred contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 33474462Salfred printf("em%d: Unable to allocate TxDescriptor memory\n", 33574462Salfred adapter->unit); 33674462Salfred em_free_pci_resources(adapter); 33774462Salfred splx(s); 33874462Salfred return(ENOMEM); 33974462Salfred } 34074462Salfred 34174462Salfred rsize = EM_ROUNDUP(adapter->num_rx_desc * 34274462Salfred sizeof(struct em_rx_desc), 4096); 34374462Salfred 34474462Salfred /* Allocate Receive Descriptor ring */ 34574462Salfred if (!(adapter->rx_desc_base = (struct em_rx_desc *) 34674462Salfred contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 34774462Salfred printf("em%d: Unable to allocate rx_desc memory\n", 34874462Salfred adapter->unit); 34974462Salfred em_free_pci_resources(adapter); 35074462Salfred contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 35174462Salfred splx(s); 35274462Salfred return(ENOMEM); 35374462Salfred } 35474462Salfred 35574462Salfred /* Initialize the hardware */ 35674462Salfred if (em_hardware_init(adapter)) { 35774462Salfred printf("em%d: Unable to initialize the hardware\n", 35874462Salfred adapter->unit); 35974462Salfred em_free_pci_resources(adapter); 36074462Salfred contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 36174462Salfred contigfree(adapter->rx_desc_base, rsize, M_DEVBUF); 36274462Salfred splx(s); 36374462Salfred return(EIO); 36474462Salfred } 36574462Salfred 36674462Salfred /* Copy the permanent MAC address out of the EEPROM */ 36774462Salfred if (em_read_mac_addr(&adapter->hw) < 0) { 36874462Salfred printf("em%d: EEPROM read error while reading mac address\n", 36974462Salfred adapter->unit); 37074462Salfred em_free_pci_resources(adapter); 37174462Salfred contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 37274462Salfred contigfree(adapter->rx_desc_base, rsize, M_DEVBUF); 37374462Salfred splx(s); 37474462Salfred return(EIO); 37574462Salfred } 37674462Salfred 37774462Salfred bcopy(adapter->hw.mac_addr, adapter->interface_data.ac_enaddr, 37874462Salfred ETHER_ADDR_LEN); 37974462Salfred 38074462Salfred /* Setup OS specific network interface */ 38174462Salfred em_setup_interface(dev, adapter); 38274462Salfred 38374462Salfred /* Initialize statistics */ 38474462Salfred em_clear_hw_cntrs(&adapter->hw); 38574462Salfred em_update_stats_counters(adapter); 38674462Salfred adapter->hw.get_link_status = 1; 38774462Salfred em_check_for_link(&adapter->hw); 38874462Salfred 38974462Salfred /* Print the link status */ 39074462Salfred if (adapter->link_active == 1) { 39174462Salfred em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 39274462Salfred &adapter->link_duplex); 39374462Salfred printf("em%d: Speed:%d Mbps Duplex:%s\n", 39474462Salfred adapter->unit, 39574462Salfred adapter->link_speed, 39674462Salfred adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 39774462Salfred } else 39874462Salfred printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); 39974462Salfred 40074462Salfred INIT_DEBUGOUT("em_attach: end"); 40174462Salfred splx(s); 40274462Salfred return(0); 40374462Salfred} 40474462Salfred 40574462Salfred/********************************************************************* 40674462Salfred * Device removal routine 40774462Salfred * 40874462Salfred * The detach entry point is called when the driver is being removed. 40974462Salfred * This routine stops the adapter and deallocates all the resources 41074462Salfred * that were allocated for driver operation. 41174462Salfred * 41274462Salfred * return 0 on success, positive on failure 41374462Salfred *********************************************************************/ 41474462Salfred 41574462Salfredstatic int 41674462Salfredem_detach(device_t dev) 41774462Salfred{ 41874462Salfred struct adapter * adapter = device_get_softc(dev); 41974462Salfred struct ifnet *ifp = &adapter->interface_data.ac_if; 42074462Salfred int s; 42174462Salfred int size; 42274462Salfred 42374462Salfred INIT_DEBUGOUT("em_detach: begin"); 42474462Salfred s = splimp(); 42574462Salfred 42674462Salfred em_stop(adapter); 42774462Salfred em_phy_hw_reset(&adapter->hw); 42874462Salfred#if __FreeBSD_version < 500000 42974462Salfred ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED); 43074462Salfred#else 43174462Salfred ether_ifdetach(&adapter->interface_data.ac_if); 43274462Salfred#endif 43374462Salfred em_free_pci_resources(adapter); 43474462Salfred 43574462Salfred size = EM_ROUNDUP(adapter->num_tx_desc * 43674462Salfred sizeof(struct em_tx_desc), 4096); 43774462Salfred 43874462Salfred /* Free Transmit Descriptor ring */ 43974462Salfred if (adapter->tx_desc_base) { 44074462Salfred contigfree(adapter->tx_desc_base, size, M_DEVBUF); 44174462Salfred adapter->tx_desc_base = NULL; 44274462Salfred } 44374462Salfred 44474462Salfred size = EM_ROUNDUP(adapter->num_rx_desc * 44574462Salfred sizeof(struct em_rx_desc), 4096); 44674462Salfred 44774462Salfred /* Free Receive Descriptor ring */ 44874462Salfred if (adapter->rx_desc_base) { 44974462Salfred contigfree(adapter->rx_desc_base, size, M_DEVBUF); 45074462Salfred adapter->rx_desc_base = NULL; 45174462Salfred } 45274462Salfred 45374462Salfred /* Remove from the adapter list */ 45474462Salfred if (em_adapter_list == adapter) 45574462Salfred em_adapter_list = adapter->next; 45674462Salfred if (adapter->next != NULL) 45774462Salfred adapter->next->prev = adapter->prev; 45874462Salfred if (adapter->prev != NULL) 45974462Salfred adapter->prev->next = adapter->next; 46074462Salfred 46174462Salfred ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 46274462Salfred ifp->if_timer = 0; 46374462Salfred 46474462Salfred splx(s); 46574462Salfred return(0); 46674462Salfred} 46774462Salfred 46874462Salfred/********************************************************************* 46974462Salfred * 47074462Salfred * Shutdown entry point 47174462Salfred * 47274462Salfred **********************************************************************/ 47374462Salfred 47474462Salfredstatic int 47574462Salfredem_shutdown(device_t dev) 47674462Salfred{ 47774462Salfred struct adapter *adapter = device_get_softc(dev); 47874462Salfred em_stop(adapter); 47974462Salfred return(0); 48074462Salfred} 48174462Salfred 48274462Salfred 48374462Salfred/********************************************************************* 48474462Salfred * Transmit entry point 48574462Salfred * 48674462Salfred * em_start is called by the stack to initiate a transmit. 48774462Salfred * The driver will remain in this routine as long as there are 48874462Salfred * packets to transmit and transmit resources are available. 48974462Salfred * In case resources are not available stack is notified and 49074462Salfred * the packet is requeued. 49174462Salfred **********************************************************************/ 49274462Salfred 49374462Salfredstatic void 49474462Salfredem_start(struct ifnet *ifp) 49574462Salfred{ 49674462Salfred int s; 49774462Salfred struct mbuf *m_head; 49874462Salfred struct adapter *adapter = ifp->if_softc; 49974462Salfred 50074462Salfred if (!adapter->link_active) 50174462Salfred return; 50274462Salfred 50374462Salfred s = splimp(); 50474462Salfred while (ifp->if_snd.ifq_head != NULL) { 50574462Salfred 50674462Salfred IF_DEQUEUE(&ifp->if_snd, m_head); 50774462Salfred 50874462Salfred if (m_head == NULL) break; 50974462Salfred 51074462Salfred if (em_encap(adapter, m_head)) { 51174462Salfred ifp->if_flags |= IFF_OACTIVE; 51274462Salfred IF_PREPEND(&ifp->if_snd, m_head); 51374462Salfred break; 51474462Salfred } 51574462Salfred 51674462Salfred /* Send a copy of the frame to the BPF listener */ 51774462Salfred#if __FreeBSD_version < 500000 51874462Salfred if (ifp->if_bpf) 51974462Salfred bpf_mtap(ifp, m_head); 52074462Salfred#else 52174462Salfred BPF_MTAP(ifp, m_head); 52274462Salfred#endif 52374462Salfred 52474462Salfred /* Set timeout in case hardware has problems transmitting */ 52574462Salfred ifp->if_timer = EM_TX_TIMEOUT; 52674462Salfred 52774462Salfred } 52874462Salfred splx(s); 52974462Salfred return; 53074462Salfred} 53174462Salfred 53274462Salfred/********************************************************************* 53374462Salfred * Ioctl entry point 53474462Salfred * 53574462Salfred * em_ioctl is called when the user wants to configure the 53674462Salfred * interface. 53774462Salfred * 53874462Salfred * return 0 on success, positive on failure 53974462Salfred **********************************************************************/ 54074462Salfred 54174462Salfredstatic int 54274462Salfredem_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 54374462Salfred{ 54474462Salfred int s, mask, error = 0; 54574462Salfred struct ifreq *ifr = (struct ifreq *) data; 54674462Salfred struct adapter * adapter = ifp->if_softc; 54774462Salfred 54874462Salfred s = splimp(); 54974462Salfred switch (command) { 55074462Salfred case SIOCSIFADDR: 55174462Salfred case SIOCGIFADDR: 55274462Salfred IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 55374462Salfred ether_ioctl(ifp, command, data); 55474462Salfred break; 555 case SIOCSIFMTU: 556 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 557 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) { 558 error = EINVAL; 559 } else { 560 ifp->if_mtu = ifr->ifr_mtu; 561 adapter->hw.max_frame_size = 562 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 563 em_init(adapter); 564 } 565 break; 566 case SIOCSIFFLAGS: 567 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 568 if (ifp->if_flags & IFF_UP) { 569 if (!(ifp->if_flags & IFF_RUNNING)) 570 em_init(adapter); 571 572 em_disable_promisc(adapter); 573 em_set_promisc(adapter); 574 } else { 575 if (ifp->if_flags & IFF_RUNNING) { 576 em_stop(adapter); 577 } 578 } 579 break; 580 case SIOCADDMULTI: 581 case SIOCDELMULTI: 582 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 583 if (ifp->if_flags & IFF_RUNNING) { 584 em_disable_intr(adapter); 585 em_set_multi(adapter); 586 if (adapter->hw.mac_type == em_82542_rev2_0) 587 em_initialize_receive_unit(adapter); 588 em_enable_intr(adapter); 589 } 590 break; 591 case SIOCSIFMEDIA: 592 case SIOCGIFMEDIA: 593 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 594 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 595 break; 596 case SIOCSIFCAP: 597 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 598 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 599 if (mask & IFCAP_HWCSUM) { 600 if (IFCAP_HWCSUM & ifp->if_capenable) 601 ifp->if_capenable &= ~IFCAP_HWCSUM; 602 else 603 ifp->if_capenable |= IFCAP_HWCSUM; 604 if (ifp->if_flags & IFF_RUNNING) 605 em_init(adapter); 606 } 607 break; 608 default: 609 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command); 610 error = EINVAL; 611 } 612 613 splx(s); 614 return(error); 615} 616 617/********************************************************************* 618 * Watchdog entry point 619 * 620 * This routine is called whenever hardware quits transmitting. 621 * 622 **********************************************************************/ 623 624static void 625em_watchdog(struct ifnet *ifp) 626{ 627 struct adapter * adapter; 628 adapter = ifp->if_softc; 629 630 /* If we are in this routine because of pause frames, then 631 * don't reset the hardware. 632 */ 633 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { 634 ifp->if_timer = EM_TX_TIMEOUT; 635 return; 636 } 637 638 printf("em%d: watchdog timeout -- resetting\n", adapter->unit); 639 640 ifp->if_flags &= ~IFF_RUNNING; 641 642 em_stop(adapter); 643 em_init(adapter); 644 645 ifp->if_oerrors++; 646 return; 647} 648 649/********************************************************************* 650 * Init entry point 651 * 652 * This routine is used in two ways. It is used by the stack as 653 * init entry point in network interface structure. It is also used 654 * by the driver as a hw/sw initialization routine to get to a 655 * consistent state. 656 * 657 * return 0 on success, positive on failure 658 **********************************************************************/ 659 660static void 661em_init(void *arg) 662{ 663 int s; 664 struct ifnet *ifp; 665 struct adapter * adapter = arg; 666 667 INIT_DEBUGOUT("em_init: begin"); 668 669 s = splimp(); 670 671 em_stop(adapter); 672 673 /* Initialize the hardware */ 674 if (em_hardware_init(adapter)) { 675 printf("em%d: Unable to initialize the hardware\n", 676 adapter->unit); 677 splx(s); 678 return; 679 } 680 681 em_enable_vlans(adapter); 682 683 /* Prepare transmit descriptors and buffers */ 684 if (em_setup_transmit_structures(adapter)) { 685 printf("em%d: Could not setup transmit structures\n", 686 adapter->unit); 687 em_stop(adapter); 688 splx(s); 689 return; 690 } 691 em_initialize_transmit_unit(adapter); 692 693 /* Setup Multicast table */ 694 em_set_multi(adapter); 695 696 /* Prepare receive descriptors and buffers */ 697 if (em_setup_receive_structures(adapter)) { 698 printf("em%d: Could not setup receive structures\n", 699 adapter->unit); 700 em_stop(adapter); 701 splx(s); 702 return; 703 } 704 em_initialize_receive_unit(adapter); 705 706 ifp = &adapter->interface_data.ac_if; 707 ifp->if_flags |= IFF_RUNNING; 708 ifp->if_flags &= ~IFF_OACTIVE; 709 710 if (adapter->hw.mac_type >= em_82543) { 711 if (ifp->if_capenable & IFCAP_TXCSUM) 712 ifp->if_hwassist = EM_CHECKSUM_FEATURES; 713 else 714 ifp->if_hwassist = 0; 715 } 716 717 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 718 em_clear_hw_cntrs(&adapter->hw); 719#ifdef DEVICE_POLLING 720 /* 721 * Only enable interrupts if we are not polling, make sure 722 * they are off otherwise. 723 */ 724 if (ifp->if_ipending & IFF_POLLING) 725 em_disable_intr(adapter); 726 else 727#endif /* DEVICE_POLLING */ 728 em_enable_intr(adapter); 729 730 splx(s); 731 return; 732} 733 734 735#ifdef DEVICE_POLLING 736static poll_handler_t em_poll; 737 738static void 739em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) 740{ 741 struct adapter *adapter = ifp->if_softc; 742 u_int32_t reg_icr; 743 744 if (cmd == POLL_DEREGISTER) { /* final call, enable interrupts */ 745 em_enable_intr(adapter); 746 return; 747 } 748 if (cmd == POLL_AND_CHECK_STATUS) { 749 reg_icr = E1000_READ_REG(&adapter->hw, ICR); 750 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 751 untimeout(em_local_timer, adapter, adapter->timer_handle); 752 adapter->hw.get_link_status = 1; 753 em_check_for_link(&adapter->hw); 754 em_print_link_status(adapter); 755 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 756 } 757 } 758 if (ifp->if_flags & IFF_RUNNING) { 759 em_process_receive_interrupts(adapter, count); 760 em_clean_transmit_interrupts(adapter); 761 } 762 763 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 764 em_start(ifp); 765} 766#endif /* DEVICE_POLLING */ 767 768/********************************************************************* 769 * 770 * Interrupt Service routine 771 * 772 **********************************************************************/ 773static void 774em_intr(void *arg) 775{ 776 u_int32_t loop_cnt = EM_MAX_INTR; 777 u_int32_t reg_icr; 778 struct ifnet *ifp; 779 struct adapter *adapter = arg; 780 781 ifp = &adapter->interface_data.ac_if; 782 783#ifdef DEVICE_POLLING 784 if (ifp->if_ipending & IFF_POLLING) 785 return; 786 787 if (ether_poll_register(em_poll, ifp)) { 788 em_disable_intr(adapter); 789 em_poll(ifp, 0, 1); 790 return; 791 } 792#endif /* DEVICE_POLLING */ 793 794 795 em_disable_intr(adapter); 796 while (loop_cnt > 0 && 797 (reg_icr = E1000_READ_REG(&adapter->hw, ICR)) != 0) { 798 799 /* Link status change */ 800 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 801 untimeout(em_local_timer, adapter, 802 adapter->timer_handle); 803 adapter->hw.get_link_status = 1; 804 em_check_for_link(&adapter->hw); 805 em_print_link_status(adapter); 806 adapter->timer_handle = 807 timeout(em_local_timer, adapter, 2*hz); 808 } 809 810 if (ifp->if_flags & IFF_RUNNING) { 811 em_process_receive_interrupts(adapter, -1); 812 em_clean_transmit_interrupts(adapter); 813 } 814 loop_cnt--; 815 } 816 817 em_enable_intr(adapter); 818 819 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 820 em_start(ifp); 821 822 return; 823} 824 825 826 827/********************************************************************* 828 * 829 * Media Ioctl callback 830 * 831 * This routine is called whenever the user queries the status of 832 * the interface using ifconfig. 833 * 834 **********************************************************************/ 835static void 836em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 837{ 838 struct adapter * adapter = ifp->if_softc; 839 840 INIT_DEBUGOUT("em_media_status: begin"); 841 842 em_check_for_link(&adapter->hw); 843 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 844 if (adapter->link_active == 0) { 845 em_get_speed_and_duplex(&adapter->hw, 846 &adapter->link_speed, 847 &adapter->link_duplex); 848 adapter->link_active = 1; 849 } 850 } else { 851 if (adapter->link_active == 1) { 852 adapter->link_speed = 0; 853 adapter->link_duplex = 0; 854 adapter->link_active = 0; 855 } 856 } 857 858 ifmr->ifm_status = IFM_AVALID; 859 ifmr->ifm_active = IFM_ETHER; 860 861 if (!adapter->link_active) 862 return; 863 864 ifmr->ifm_status |= IFM_ACTIVE; 865 866 if (adapter->hw.media_type == em_media_type_fiber) { 867 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 868 } else { 869 switch (adapter->link_speed) { 870 case 10: 871 ifmr->ifm_active |= IFM_10_T; 872 break; 873 case 100: 874 ifmr->ifm_active |= IFM_100_TX; 875 break; 876 case 1000: 877#if __FreeBSD_version < 500000 878 ifmr->ifm_active |= IFM_1000_TX; 879#else 880 ifmr->ifm_active |= IFM_1000_T; 881#endif 882 break; 883 } 884 if (adapter->link_duplex == FULL_DUPLEX) 885 ifmr->ifm_active |= IFM_FDX; 886 else 887 ifmr->ifm_active |= IFM_HDX; 888 } 889 return; 890} 891 892/********************************************************************* 893 * 894 * Media Ioctl callback 895 * 896 * This routine is called when the user changes speed/duplex using 897 * media/mediopt option with ifconfig. 898 * 899 **********************************************************************/ 900static int 901em_media_change(struct ifnet *ifp) 902{ 903 struct adapter * adapter = ifp->if_softc; 904 struct ifmedia *ifm = &adapter->media; 905 906 INIT_DEBUGOUT("em_media_change: begin"); 907 908 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 909 return(EINVAL); 910 911 switch (IFM_SUBTYPE(ifm->ifm_media)) { 912 case IFM_AUTO: 913 adapter->hw.autoneg = DO_AUTO_NEG; 914 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 915 break; 916 case IFM_1000_SX: 917#if __FreeBSD_version < 500000 918 case IFM_1000_TX: 919#else 920 case IFM_1000_T: 921#endif 922 adapter->hw.autoneg = DO_AUTO_NEG; 923 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 924 break; 925 case IFM_100_TX: 926 adapter->hw.autoneg = FALSE; 927 adapter->hw.autoneg_advertised = 0; 928 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 929 adapter->hw.forced_speed_duplex = em_100_full; 930 else 931 adapter->hw.forced_speed_duplex = em_100_half; 932 break; 933 case IFM_10_T: 934 adapter->hw.autoneg = FALSE; 935 adapter->hw.autoneg_advertised = 0; 936 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 937 adapter->hw.forced_speed_duplex = em_10_full; 938 else 939 adapter->hw.forced_speed_duplex = em_10_half; 940 break; 941 default: 942 printf("em%d: Unsupported media type\n", adapter->unit); 943 } 944 945 em_init(adapter); 946 947 return(0); 948} 949 950#define EM_FIFO_HDR 0x10 951#define EM_82547_PKT_THRESH 0x3e0 952#define EM_82547_TX_FIFO_SIZE 0x2800 953#define EM_82547_TX_FIFO_BEGIN 0xf00 954/********************************************************************* 955 * 956 * This routine maps the mbufs to tx descriptors. 957 * 958 * return 0 on success, positive on failure 959 **********************************************************************/ 960 961static int 962em_encap(struct adapter *adapter, struct mbuf *m_head) 963{ 964 vm_offset_t virtual_addr; 965 u_int32_t txd_upper; 966 u_int32_t txd_lower; 967 int txd_used, i, txd_saved; 968 struct mbuf *mp; 969 970#if __FreeBSD_version < 500000 971 struct ifvlan *ifv = NULL; 972#else 973 struct m_tag *mtag; 974#endif 975 struct em_buffer *tx_buffer = NULL; 976 struct em_tx_desc *current_tx_desc = NULL; 977 struct ifnet *ifp = &adapter->interface_data.ac_if; 978 979 /* 980 * Force a cleanup if number of TX descriptors 981 * available hits the threshold 982 */ 983 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) 984 em_clean_transmit_interrupts(adapter); 985 986 if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { 987 adapter->no_tx_desc_avail1++; 988 return (ENOBUFS); 989 } 990 991 if (ifp->if_hwassist > 0) { 992 em_transmit_checksum_setup(adapter, m_head, 993 &txd_upper, &txd_lower); 994 } 995 else 996 txd_upper = txd_lower = 0; 997 998 999 /* Find out if we are in vlan mode */ 1000#if __FreeBSD_version < 500000 1001 if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) && 1002 m_head->m_pkthdr.rcvif != NULL && 1003 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN) 1004 ifv = m_head->m_pkthdr.rcvif->if_softc; 1005#else 1006 mtag = VLAN_OUTPUT_TAG(ifp, m_head); 1007#endif 1008 1009 i = adapter->next_avail_tx_desc; 1010 txd_saved = i; 1011 txd_used = 0; 1012 for (mp = m_head; mp != NULL; mp = mp->m_next) { 1013 if (mp->m_len == 0) 1014 continue; 1015 1016 if (txd_used == adapter->num_tx_desc_avail) { 1017 adapter->next_avail_tx_desc = txd_saved; 1018 adapter->no_tx_desc_avail2++; 1019 return (ENOBUFS); 1020 } 1021 1022 tx_buffer = &adapter->tx_buffer_area[i]; 1023 current_tx_desc = &adapter->tx_desc_base[i]; 1024 virtual_addr = mtod(mp, vm_offset_t); 1025 current_tx_desc->buffer_addr = vtophys(virtual_addr); 1026 1027 current_tx_desc->lower.data = (adapter->txd_cmd | txd_lower | mp->m_len); 1028 current_tx_desc->upper.data = (txd_upper); 1029 1030 if (++i == adapter->num_tx_desc) 1031 i = 0; 1032 1033 tx_buffer->m_head = NULL; 1034 1035 txd_used++; 1036 } 1037 1038 adapter->num_tx_desc_avail -= txd_used; 1039 adapter->next_avail_tx_desc = i; 1040 1041#if __FreeBSD_version < 500000 1042 if (ifv != NULL) { 1043 /* Set the vlan id */ 1044 current_tx_desc->upper.fields.special = ifv->ifv_tag; 1045#else 1046 if (mtag != NULL) { 1047 /* Set the vlan id */ 1048 current_tx_desc->upper.fields.special = VLAN_TAG_VALUE(mtag); 1049#endif 1050 /* Tell hardware to add tag */ 1051 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE; 1052 } 1053 1054 tx_buffer->m_head = m_head; 1055 1056 /* 1057 * Last Descriptor of Packet needs End Of Packet (EOP) 1058 */ 1059 current_tx_desc->lower.data |= (E1000_TXD_CMD_EOP); 1060 1061 /* 1062 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 1063 * that this frame is available to transmit. 1064 */ 1065 if (adapter->hw.mac_type == em_82547 && 1066 adapter->link_duplex == HALF_DUPLEX) { 1067 em_82547_move_tail(adapter); 1068 } 1069 else { 1070 E1000_WRITE_REG(&adapter->hw, TDT, i); 1071 if (adapter->hw.mac_type == em_82547) { 1072 em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len); 1073 } 1074 } 1075 1076 return (0); 1077} 1078 1079 1080/********************************************************************* 1081 * 1082 * 82547 workaround to avoid controller hang in half-duplex environment. 1083 * The workaround is to avoid queuing a large packet that would span 1084 * the internal Tx FIFO ring boundary. We need to reset the FIFO pointers 1085 * in this case. We do that only when FIFO is queiced. 1086 * 1087 **********************************************************************/ 1088static void 1089em_82547_move_tail(void *arg) 1090{ 1091 int s; 1092 struct adapter *adapter = arg; 1093 uint16_t hw_tdt; 1094 uint16_t sw_tdt; 1095 struct em_tx_desc *tx_desc; 1096 uint16_t length = 0; 1097 boolean_t eop = 0; 1098 1099 s = splimp(); 1100 hw_tdt = E1000_READ_REG(&adapter->hw, TDT); 1101 sw_tdt = adapter->next_avail_tx_desc; 1102 1103 while (hw_tdt != sw_tdt) { 1104 tx_desc = &adapter->tx_desc_base[hw_tdt]; 1105 length += tx_desc->lower.flags.length; 1106 eop = tx_desc->lower.data & E1000_TXD_CMD_EOP; 1107 if(++hw_tdt == adapter->num_tx_desc) 1108 hw_tdt = 0; 1109 1110 if(eop) { 1111 if (em_82547_fifo_workaround(adapter, length)) { 1112 adapter->tx_fifo_wrk++; 1113 adapter->tx_fifo_timer_handle = 1114 timeout(em_82547_move_tail, 1115 adapter, 1); 1116 splx(s); 1117 return; 1118 } 1119 else { 1120 E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt); 1121 em_82547_update_fifo_head(adapter, length); 1122 length = 0; 1123 } 1124 } 1125 } 1126 splx(s); 1127 return; 1128} 1129 1130static int 1131em_82547_fifo_workaround(struct adapter *adapter, int len) 1132{ 1133 int fifo_space, fifo_pkt_len; 1134 1135 fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1136 1137 if (adapter->link_duplex == HALF_DUPLEX) { 1138 fifo_space = EM_82547_TX_FIFO_SIZE - adapter->tx_fifo_head; 1139 1140 if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) { 1141 if (em_82547_tx_fifo_reset(adapter)) { 1142 return(0); 1143 } 1144 else { 1145 return(1); 1146 } 1147 } 1148 } 1149 1150 return(0); 1151} 1152 1153static void 1154em_82547_update_fifo_head(struct adapter *adapter, int len) 1155{ 1156 int fifo_pkt_len = EM_ROUNDUP(len + EM_FIFO_HDR, EM_FIFO_HDR); 1157 1158 /* tx_fifo_head is always 16 byte aligned */ 1159 adapter->tx_fifo_head += fifo_pkt_len; 1160 if (adapter->tx_fifo_head >= EM_82547_TX_FIFO_SIZE) { 1161 adapter->tx_fifo_head -= EM_82547_TX_FIFO_SIZE; 1162 } 1163 1164 return; 1165} 1166 1167 1168static int 1169em_82547_tx_fifo_reset(struct adapter *adapter) 1170{ 1171 uint32_t tctl; 1172 1173 if ( (E1000_READ_REG(&adapter->hw, TDT) == 1174 E1000_READ_REG(&adapter->hw, TDH)) && 1175 (E1000_READ_REG(&adapter->hw, TDFT) == 1176 E1000_READ_REG(&adapter->hw, TDFH)) && 1177 (E1000_READ_REG(&adapter->hw, TDFTS) == 1178 E1000_READ_REG(&adapter->hw, TDFHS)) && 1179 (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) { 1180 1181 /* Disable TX unit */ 1182 tctl = E1000_READ_REG(&adapter->hw, TCTL); 1183 E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN); 1184 1185 /* Reset FIFO pointers */ 1186 E1000_WRITE_REG(&adapter->hw, TDFT, EM_82547_TX_FIFO_BEGIN); 1187 E1000_WRITE_REG(&adapter->hw, TDFH, EM_82547_TX_FIFO_BEGIN); 1188 E1000_WRITE_REG(&adapter->hw, TDFTS, EM_82547_TX_FIFO_BEGIN); 1189 E1000_WRITE_REG(&adapter->hw, TDFHS, EM_82547_TX_FIFO_BEGIN); 1190 1191 /* Re-enable TX unit */ 1192 E1000_WRITE_REG(&adapter->hw, TCTL, tctl); 1193 E1000_WRITE_FLUSH(&adapter->hw); 1194 1195 adapter->tx_fifo_head = 0; 1196 adapter->tx_fifo_reset++; 1197 1198 return(TRUE); 1199 } 1200 else { 1201 return(FALSE); 1202 } 1203} 1204 1205static void 1206em_set_promisc(struct adapter * adapter) 1207{ 1208 1209 u_int32_t reg_rctl; 1210 struct ifnet *ifp = &adapter->interface_data.ac_if; 1211 1212 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1213 1214 if (ifp->if_flags & IFF_PROMISC) { 1215 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 1216 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1217 } else if (ifp->if_flags & IFF_ALLMULTI) { 1218 reg_rctl |= E1000_RCTL_MPE; 1219 reg_rctl &= ~E1000_RCTL_UPE; 1220 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1221 } 1222 1223 return; 1224} 1225 1226static void 1227em_disable_promisc(struct adapter * adapter) 1228{ 1229 u_int32_t reg_rctl; 1230 1231 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1232 1233 reg_rctl &= (~E1000_RCTL_UPE); 1234 reg_rctl &= (~E1000_RCTL_MPE); 1235 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1236 1237 return; 1238} 1239 1240 1241/********************************************************************* 1242 * Multicast Update 1243 * 1244 * This routine is called whenever multicast address list is updated. 1245 * 1246 **********************************************************************/ 1247 1248static void 1249em_set_multi(struct adapter * adapter) 1250{ 1251 u_int32_t reg_rctl = 0; 1252 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; 1253 struct ifmultiaddr *ifma; 1254 int mcnt = 0; 1255 struct ifnet *ifp = &adapter->interface_data.ac_if; 1256 1257 IOCTL_DEBUGOUT("em_set_multi: begin"); 1258 1259 if (adapter->hw.mac_type == em_82542_rev2_0) { 1260 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1261 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1262 em_pci_clear_mwi(&adapter->hw); 1263 } 1264 reg_rctl |= E1000_RCTL_RST; 1265 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1266 msec_delay(5); 1267 } 1268 1269#if __FreeBSD_version < 500000 1270 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1271#else 1272 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1273#endif 1274 if (ifma->ifma_addr->sa_family != AF_LINK) 1275 continue; 1276 1277 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES) break; 1278 1279 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 1280 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 1281 mcnt++; 1282 } 1283 1284 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) { 1285 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1286 reg_rctl |= E1000_RCTL_MPE; 1287 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1288 } else 1289 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0); 1290 1291 if (adapter->hw.mac_type == em_82542_rev2_0) { 1292 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 1293 reg_rctl &= ~E1000_RCTL_RST; 1294 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1295 msec_delay(5); 1296 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 1297 em_pci_set_mwi(&adapter->hw); 1298 } 1299 } 1300 1301 return; 1302} 1303 1304 1305/********************************************************************* 1306 * Timer routine 1307 * 1308 * This routine checks for link status and updates statistics. 1309 * 1310 **********************************************************************/ 1311 1312static void 1313em_local_timer(void *arg) 1314{ 1315 int s; 1316 struct ifnet *ifp; 1317 struct adapter * adapter = arg; 1318 ifp = &adapter->interface_data.ac_if; 1319 1320 s = splimp(); 1321 1322 em_check_for_link(&adapter->hw); 1323 em_print_link_status(adapter); 1324 em_update_stats_counters(adapter); 1325 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 1326 em_print_hw_stats(adapter); 1327 } 1328 em_smartspeed(adapter); 1329 1330 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 1331 1332 splx(s); 1333 return; 1334} 1335 1336static void 1337em_print_link_status(struct adapter * adapter) 1338{ 1339 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1340 if (adapter->link_active == 0) { 1341 em_get_speed_and_duplex(&adapter->hw, 1342 &adapter->link_speed, 1343 &adapter->link_duplex); 1344 printf("em%d: Link is up %d Mbps %s\n", 1345 adapter->unit, 1346 adapter->link_speed, 1347 ((adapter->link_duplex == FULL_DUPLEX) ? 1348 "Full Duplex" : "Half Duplex")); 1349 adapter->link_active = 1; 1350 adapter->smartspeed = 0; 1351 } 1352 } else { 1353 if (adapter->link_active == 1) { 1354 adapter->link_speed = 0; 1355 adapter->link_duplex = 0; 1356 printf("em%d: Link is Down\n", adapter->unit); 1357 adapter->link_active = 0; 1358 } 1359 } 1360 1361 return; 1362} 1363 1364/********************************************************************* 1365 * 1366 * This routine disables all traffic on the adapter by issuing a 1367 * global reset on the MAC and deallocates TX/RX buffers. 1368 * 1369 **********************************************************************/ 1370 1371static void 1372em_stop(void *arg) 1373{ 1374 struct ifnet *ifp; 1375 struct adapter * adapter = arg; 1376 ifp = &adapter->interface_data.ac_if; 1377 1378 INIT_DEBUGOUT("em_stop: begin\n"); 1379 em_disable_intr(adapter); 1380 em_reset_hw(&adapter->hw); 1381 untimeout(em_local_timer, adapter, adapter->timer_handle); 1382 untimeout(em_82547_move_tail, adapter, 1383 adapter->tx_fifo_timer_handle); 1384 em_free_transmit_structures(adapter); 1385 em_free_receive_structures(adapter); 1386 1387 1388 /* Tell the stack that the interface is no longer active */ 1389 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 1390 1391 return; 1392} 1393 1394 1395/********************************************************************* 1396 * 1397 * Determine hardware revision. 1398 * 1399 **********************************************************************/ 1400static void 1401em_identify_hardware(struct adapter * adapter) 1402{ 1403 device_t dev = adapter->dev; 1404 1405 /* Make sure our PCI config space has the necessary stuff set */ 1406 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1407 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1408 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1409 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1410 adapter->unit); 1411 adapter->hw.pci_cmd_word |= 1412 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1413 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1414 } 1415 1416 /* Save off the information about this board */ 1417 adapter->hw.vendor_id = pci_get_vendor(dev); 1418 adapter->hw.device_id = pci_get_device(dev); 1419 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1420 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1421 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1422 1423 /* Identify the MAC */ 1424 if (em_set_mac_type(&adapter->hw)) 1425 printf("em%d: Unknown MAC Type\n", adapter->unit); 1426 1427 return; 1428} 1429 1430static int 1431em_allocate_pci_resources(struct adapter * adapter) 1432{ 1433 int i, val, rid; 1434 device_t dev = adapter->dev; 1435 1436 rid = EM_MMBA; 1437 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, 1438 &rid, 0, ~0, 1, 1439 RF_ACTIVE); 1440 if (!(adapter->res_memory)) { 1441 printf("em%d: Unable to allocate bus resource: memory\n", 1442 adapter->unit); 1443 return(ENXIO); 1444 } 1445 adapter->osdep.mem_bus_space_tag = 1446 rman_get_bustag(adapter->res_memory); 1447 adapter->osdep.mem_bus_space_handle = 1448 rman_get_bushandle(adapter->res_memory); 1449 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1450 1451 1452 if (adapter->hw.mac_type > em_82543) { 1453 /* Figure our where our IO BAR is ? */ 1454 rid = EM_MMBA; 1455 for (i = 0; i < 5; i++) { 1456 val = pci_read_config(dev, rid, 4); 1457 if (val & 0x00000001) { 1458 adapter->io_rid = rid; 1459 break; 1460 } 1461 rid += 4; 1462 } 1463 1464 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT, 1465 &adapter->io_rid, 0, ~0, 1, 1466 RF_ACTIVE); 1467 if (!(adapter->res_ioport)) { 1468 printf("em%d: Unable to allocate bus resource: ioport\n", 1469 adapter->unit); 1470 return(ENXIO); 1471 } 1472 1473 adapter->hw.io_base = 1474 rman_get_start(adapter->res_ioport); 1475 } 1476 1477 rid = 0x0; 1478 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, 1479 &rid, 0, ~0, 1, 1480 RF_SHAREABLE | RF_ACTIVE); 1481 if (!(adapter->res_interrupt)) { 1482 printf("em%d: Unable to allocate bus resource: interrupt\n", 1483 adapter->unit); 1484 return(ENXIO); 1485 } 1486 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET, 1487 (void (*)(void *)) em_intr, adapter, 1488 &adapter->int_handler_tag)) { 1489 printf("em%d: Error registering interrupt handler!\n", 1490 adapter->unit); 1491 return(ENXIO); 1492 } 1493 1494 adapter->hw.back = &adapter->osdep; 1495 1496 return(0); 1497} 1498 1499static void 1500em_free_pci_resources(struct adapter * adapter) 1501{ 1502 device_t dev = adapter->dev; 1503 1504 if (adapter->res_interrupt != NULL) { 1505 bus_teardown_intr(dev, adapter->res_interrupt, 1506 adapter->int_handler_tag); 1507 bus_release_resource(dev, SYS_RES_IRQ, 0, 1508 adapter->res_interrupt); 1509 } 1510 if (adapter->res_memory != NULL) { 1511 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1512 adapter->res_memory); 1513 } 1514 1515 if (adapter->res_ioport != NULL) { 1516 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1517 adapter->res_ioport); 1518 } 1519 return; 1520} 1521 1522/********************************************************************* 1523 * 1524 * Initialize the hardware to a configuration as specified by the 1525 * adapter structure. The controller is reset, the EEPROM is 1526 * verified, the MAC address is set, then the shared initialization 1527 * routines are called. 1528 * 1529 **********************************************************************/ 1530static int 1531em_hardware_init(struct adapter * adapter) 1532{ 1533 /* Issue a global reset */ 1534 em_reset_hw(&adapter->hw); 1535 1536 /* When hardware is reset, fifo_head is also reset */ 1537 adapter->tx_fifo_head = 0; 1538 1539 /* Make sure we have a good EEPROM before we read from it */ 1540 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1541 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1542 adapter->unit); 1543 return(EIO); 1544 } 1545 1546 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1547 printf("em%d: EEPROM read error while reading part number\n", 1548 adapter->unit); 1549 return(EIO); 1550 } 1551 1552 if (em_init_hw(&adapter->hw) < 0) { 1553 printf("em%d: Hardware Initialization Failed", 1554 adapter->unit); 1555 return(EIO); 1556 } 1557 1558 em_check_for_link(&adapter->hw); 1559 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1560 adapter->link_active = 1; 1561 else 1562 adapter->link_active = 0; 1563 1564 if (adapter->link_active) { 1565 em_get_speed_and_duplex(&adapter->hw, 1566 &adapter->link_speed, 1567 &adapter->link_duplex); 1568 } else { 1569 adapter->link_speed = 0; 1570 adapter->link_duplex = 0; 1571 } 1572 1573 return(0); 1574} 1575 1576/********************************************************************* 1577 * 1578 * Setup networking device structure and register an interface. 1579 * 1580 **********************************************************************/ 1581static void 1582em_setup_interface(device_t dev, struct adapter * adapter) 1583{ 1584 struct ifnet *ifp; 1585 INIT_DEBUGOUT("em_setup_interface: begin"); 1586 1587 ifp = &adapter->interface_data.ac_if; 1588 ifp->if_unit = adapter->unit; 1589 ifp->if_name = "em"; 1590 ifp->if_mtu = ETHERMTU; 1591 ifp->if_output = ether_output; 1592 ifp->if_baudrate = 1000000000; 1593 ifp->if_init = em_init; 1594 ifp->if_softc = adapter; 1595 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1596 ifp->if_ioctl = em_ioctl; 1597 ifp->if_start = em_start; 1598 ifp->if_watchdog = em_watchdog; 1599 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1600 1601#if __FreeBSD_version < 500000 1602 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1603#else 1604 ether_ifattach(ifp, adapter->interface_data.ac_enaddr); 1605#endif 1606 1607 if (adapter->hw.mac_type >= em_82543) { 1608 ifp->if_capabilities = IFCAP_HWCSUM; 1609 ifp->if_capenable = ifp->if_capabilities; 1610 } 1611 1612#if __FreeBSD_version >= 500000 1613 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU; 1614#endif 1615 1616 1617 /* 1618 * Specify the media types supported by this adapter and register 1619 * callbacks to update media and link information 1620 */ 1621 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1622 em_media_status); 1623 if (adapter->hw.media_type == em_media_type_fiber) { 1624 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1625 0, NULL); 1626 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1627 0, NULL); 1628 } else { 1629 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1630 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1631 0, NULL); 1632 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1633 0, NULL); 1634 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1635 0, NULL); 1636#if __FreeBSD_version < 500000 1637 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1638 0, NULL); 1639 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1640#else 1641 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1642 0, NULL); 1643 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1644#endif 1645 } 1646 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1647 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1648 1649 return; 1650} 1651 1652 1653/********************************************************************* 1654 * 1655 * Workaround for SmartSpeed on 82541 and 82547 controllers 1656 * 1657 **********************************************************************/ 1658static void 1659em_smartspeed(struct adapter *adapter) 1660{ 1661 uint16_t phy_tmp; 1662 1663 if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || 1664 !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) 1665 return; 1666 1667 if(adapter->smartspeed == 0) { 1668 /* If Master/Slave config fault is asserted twice, 1669 * we assume back-to-back */ 1670 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1671 if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; 1672 em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); 1673 if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { 1674 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, 1675 &phy_tmp); 1676 if(phy_tmp & CR_1000T_MS_ENABLE) { 1677 phy_tmp &= ~CR_1000T_MS_ENABLE; 1678 em_write_phy_reg(&adapter->hw, 1679 PHY_1000T_CTRL, phy_tmp); 1680 adapter->smartspeed++; 1681 if(adapter->hw.autoneg && 1682 !em_phy_setup_autoneg(&adapter->hw) && 1683 !em_read_phy_reg(&adapter->hw, PHY_CTRL, 1684 &phy_tmp)) { 1685 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1686 MII_CR_RESTART_AUTO_NEG); 1687 em_write_phy_reg(&adapter->hw, 1688 PHY_CTRL, phy_tmp); 1689 } 1690 } 1691 } 1692 return; 1693 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { 1694 /* If still no link, perhaps using 2/3 pair cable */ 1695 em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); 1696 phy_tmp |= CR_1000T_MS_ENABLE; 1697 em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); 1698 if(adapter->hw.autoneg && 1699 !em_phy_setup_autoneg(&adapter->hw) && 1700 !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { 1701 phy_tmp |= (MII_CR_AUTO_NEG_EN | 1702 MII_CR_RESTART_AUTO_NEG); 1703 em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); 1704 } 1705 } 1706 /* Restart process after EM_SMARTSPEED_MAX iterations */ 1707 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) 1708 adapter->smartspeed = 0; 1709 1710 return; 1711} 1712 1713 1714/********************************************************************* 1715 * 1716 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1717 * the information needed to transmit a packet on the wire. 1718 * 1719 **********************************************************************/ 1720static int 1721em_allocate_transmit_structures(struct adapter * adapter) 1722{ 1723 if (!(adapter->tx_buffer_area = 1724 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 1725 adapter->num_tx_desc, M_DEVBUF, 1726 M_NOWAIT))) { 1727 printf("em%d: Unable to allocate tx_buffer memory\n", 1728 adapter->unit); 1729 return ENOMEM; 1730 } 1731 1732 bzero(adapter->tx_buffer_area, 1733 sizeof(struct em_buffer) * adapter->num_tx_desc); 1734 1735 return 0; 1736} 1737 1738/********************************************************************* 1739 * 1740 * Allocate and initialize transmit structures. 1741 * 1742 **********************************************************************/ 1743static int 1744em_setup_transmit_structures(struct adapter * adapter) 1745{ 1746 if (em_allocate_transmit_structures(adapter)) 1747 return ENOMEM; 1748 1749 bzero((void *) adapter->tx_desc_base, 1750 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 1751 1752 adapter->next_avail_tx_desc = 0; 1753 adapter->oldest_used_tx_desc = 0; 1754 1755 /* Set number of descriptors available */ 1756 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1757 1758 /* Set checksum context */ 1759 adapter->active_checksum_context = OFFLOAD_NONE; 1760 1761 return 0; 1762} 1763 1764/********************************************************************* 1765 * 1766 * Enable transmit unit. 1767 * 1768 **********************************************************************/ 1769static void 1770em_initialize_transmit_unit(struct adapter * adapter) 1771{ 1772 u_int32_t reg_tctl; 1773 u_int32_t reg_tipg = 0; 1774 1775 /* Setup the Base and Length of the Tx Descriptor Ring */ 1776 E1000_WRITE_REG(&adapter->hw, TDBAL, 1777 vtophys((vm_offset_t) adapter->tx_desc_base)); 1778 E1000_WRITE_REG(&adapter->hw, TDBAH, 0); 1779 E1000_WRITE_REG(&adapter->hw, TDLEN, 1780 adapter->num_tx_desc * 1781 sizeof(struct em_tx_desc)); 1782 1783 /* Setup the HW Tx Head and Tail descriptor pointers */ 1784 E1000_WRITE_REG(&adapter->hw, TDH, 0); 1785 E1000_WRITE_REG(&adapter->hw, TDT, 0); 1786 1787 1788 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1789 E1000_READ_REG(&adapter->hw, TDBAL), 1790 E1000_READ_REG(&adapter->hw, TDLEN)); 1791 1792 1793 /* Set the default values for the Tx Inter Packet Gap timer */ 1794 switch (adapter->hw.mac_type) { 1795 case em_82543: 1796 case em_82544: 1797 case em_82540: 1798 case em_82545: 1799 case em_82546: 1800 case em_82541: 1801 case em_82547: 1802 if (adapter->hw.media_type == em_media_type_fiber) 1803 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1804 else 1805 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1806 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1807 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1808 break; 1809 case em_82542_rev2_0: 1810 case em_82542_rev2_1: 1811 reg_tipg = DEFAULT_82542_TIPG_IPGT; 1812 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1813 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1814 break; 1815 default: 1816 printf("em%d: Invalid mac type detected\n", adapter->unit); 1817 } 1818 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 1819 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1820 if(adapter->hw.mac_type >= em_82540) 1821 E1000_WRITE_REG(&adapter->hw, TADV, adapter->tx_abs_int_delay); 1822 1823 /* Program the Transmit Control Register */ 1824 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 1825 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1826 if (adapter->link_duplex == 1) { 1827 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1828 } else { 1829 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1830 } 1831 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1832 1833 /* Setup Transmit Descriptor Settings for this adapter */ 1834 adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; 1835 1836 if (adapter->tx_int_delay > 0) 1837 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1838 1839 return; 1840} 1841 1842/********************************************************************* 1843 * 1844 * Free all transmit related data structures. 1845 * 1846 **********************************************************************/ 1847static void 1848em_free_transmit_structures(struct adapter * adapter) 1849{ 1850 struct em_buffer *tx_buffer; 1851 int i; 1852 1853 INIT_DEBUGOUT("free_transmit_structures: begin"); 1854 1855 if (adapter->tx_buffer_area != NULL) { 1856 tx_buffer = adapter->tx_buffer_area; 1857 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1858 if (tx_buffer->m_head != NULL) 1859 m_freem(tx_buffer->m_head); 1860 tx_buffer->m_head = NULL; 1861 } 1862 } 1863 if (adapter->tx_buffer_area != NULL) { 1864 free(adapter->tx_buffer_area, M_DEVBUF); 1865 adapter->tx_buffer_area = NULL; 1866 } 1867 return; 1868} 1869 1870/********************************************************************* 1871 * 1872 * The offload context needs to be set when we transfer the first 1873 * packet of a particular protocol (TCP/UDP). We change the 1874 * context only if the protocol type changes. 1875 * 1876 **********************************************************************/ 1877static void 1878em_transmit_checksum_setup(struct adapter * adapter, 1879 struct mbuf *mp, 1880 u_int32_t *txd_upper, 1881 u_int32_t *txd_lower) 1882{ 1883 struct em_context_desc *TXD; 1884 struct em_buffer *tx_buffer; 1885 int curr_txd; 1886 1887 if (mp->m_pkthdr.csum_flags) { 1888 1889 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1890 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1891 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1892 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1893 return; 1894 else 1895 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1896 1897 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1898 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1899 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1900 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1901 return; 1902 else 1903 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1904 } else { 1905 *txd_upper = 0; 1906 *txd_lower = 0; 1907 return; 1908 } 1909 } else { 1910 *txd_upper = 0; 1911 *txd_lower = 0; 1912 return; 1913 } 1914 1915 /* If we reach this point, the checksum offload context 1916 * needs to be reset. 1917 */ 1918 curr_txd = adapter->next_avail_tx_desc; 1919 tx_buffer = &adapter->tx_buffer_area[curr_txd]; 1920 TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; 1921 1922 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 1923 TXD->lower_setup.ip_fields.ipcso = 1924 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 1925 TXD->lower_setup.ip_fields.ipcse = 1926 ETHER_HDR_LEN + sizeof(struct ip) - 1; 1927 1928 TXD->upper_setup.tcp_fields.tucss = 1929 ETHER_HDR_LEN + sizeof(struct ip); 1930 TXD->upper_setup.tcp_fields.tucse = 0; 1931 1932 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1933 TXD->upper_setup.tcp_fields.tucso = 1934 ETHER_HDR_LEN + sizeof(struct ip) + 1935 offsetof(struct tcphdr, th_sum); 1936 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1937 TXD->upper_setup.tcp_fields.tucso = 1938 ETHER_HDR_LEN + sizeof(struct ip) + 1939 offsetof(struct udphdr, uh_sum); 1940 } 1941 1942 TXD->tcp_seg_setup.data = 0; 1943 TXD->cmd_and_length = (adapter->txd_cmd | E1000_TXD_CMD_DEXT); 1944 1945 tx_buffer->m_head = NULL; 1946 1947 if (++curr_txd == adapter->num_tx_desc) 1948 curr_txd = 0; 1949 1950 adapter->num_tx_desc_avail--; 1951 adapter->next_avail_tx_desc = curr_txd; 1952 1953 return; 1954} 1955 1956/********************************************************************** 1957 * 1958 * Examine each tx_buffer in the used queue. If the hardware is done 1959 * processing the packet then free associated resources. The 1960 * tx_buffer is put back on the free queue. 1961 * 1962 **********************************************************************/ 1963static void 1964em_clean_transmit_interrupts(struct adapter * adapter) 1965{ 1966 int s; 1967 int i, num_avail; 1968 struct em_buffer *tx_buffer; 1969 struct em_tx_desc *tx_desc; 1970 1971 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 1972 return; 1973 1974 s = splimp(); 1975#ifdef DBG_STATS 1976 adapter->clean_tx_interrupts++; 1977#endif 1978 num_avail = adapter->num_tx_desc_avail; 1979 i = adapter->oldest_used_tx_desc; 1980 1981 tx_buffer = &adapter->tx_buffer_area[i]; 1982 tx_desc = &adapter->tx_desc_base[i]; 1983 1984 while(tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { 1985 1986 tx_desc->upper.data = 0; 1987 num_avail++; 1988 1989 if (tx_buffer->m_head) { 1990 m_freem(tx_buffer->m_head); 1991 tx_buffer->m_head = NULL; 1992 } 1993 1994 if (++i == adapter->num_tx_desc) 1995 i = 0; 1996 1997 tx_buffer = &adapter->tx_buffer_area[i]; 1998 tx_desc = &adapter->tx_desc_base[i]; 1999 } 2000 2001 adapter->oldest_used_tx_desc = i; 2002 2003 /* 2004 * If we have enough room, clear IFF_OACTIVE to tell the stack 2005 * that it is OK to send packets. 2006 * If there are no pending descriptors, clear the timeout. Otherwise, 2007 * if some descriptors have been freed, restart the timeout. 2008 */ 2009 if (num_avail > EM_TX_CLEANUP_THRESHOLD) { 2010 struct ifnet *ifp = &adapter->interface_data.ac_if; 2011 2012 ifp->if_flags &= ~IFF_OACTIVE; 2013 if (num_avail == adapter->num_tx_desc) 2014 ifp->if_timer = 0; 2015 else if (num_avail == adapter->num_tx_desc_avail) 2016 ifp->if_timer = EM_TX_TIMEOUT; 2017 } 2018 adapter->num_tx_desc_avail = num_avail; 2019 splx(s); 2020 return; 2021} 2022 2023/********************************************************************* 2024 * 2025 * Get a buffer from system mbuf buffer pool. 2026 * 2027 **********************************************************************/ 2028static int 2029em_get_buf(int i, struct adapter *adapter, 2030 struct mbuf *nmp) 2031{ 2032 register struct mbuf *mp = nmp; 2033 struct ifnet *ifp; 2034 2035 ifp = &adapter->interface_data.ac_if; 2036 2037 if (mp == NULL) { 2038 MGETHDR(mp, M_DONTWAIT, MT_DATA); 2039 if (mp == NULL) { 2040 adapter->mbuf_alloc_failed++; 2041 return(ENOBUFS); 2042 } 2043 MCLGET(mp, M_DONTWAIT); 2044 if ((mp->m_flags & M_EXT) == 0) { 2045 m_freem(mp); 2046 adapter->mbuf_cluster_failed++; 2047 return(ENOBUFS); 2048 } 2049 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2050 } else { 2051 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 2052 mp->m_data = mp->m_ext.ext_buf; 2053 mp->m_next = NULL; 2054 } 2055 2056 if (ifp->if_mtu <= ETHERMTU) { 2057 m_adj(mp, ETHER_ALIGN); 2058 } 2059 2060 adapter->rx_buffer_area[i].m_head = mp; 2061 adapter->rx_desc_base[i].buffer_addr = 2062 vtophys(mtod(mp, vm_offset_t)); 2063 2064 return(0); 2065} 2066 2067/********************************************************************* 2068 * 2069 * Allocate memory for rx_buffer structures. Since we use one 2070 * rx_buffer per received packet, the maximum number of rx_buffer's 2071 * that we'll need is equal to the number of receive descriptors 2072 * that we've allocated. 2073 * 2074 **********************************************************************/ 2075static int 2076em_allocate_receive_structures(struct adapter * adapter) 2077{ 2078 int i; 2079 2080 if (!(adapter->rx_buffer_area = 2081 (struct em_buffer *) malloc(sizeof(struct em_buffer) * 2082 adapter->num_rx_desc, M_DEVBUF, 2083 M_NOWAIT))) { 2084 printf("em%d: Unable to allocate rx_buffer memory\n", 2085 adapter->unit); 2086 return(ENOMEM); 2087 } 2088 2089 bzero(adapter->rx_buffer_area, 2090 sizeof(struct em_buffer) * adapter->num_rx_desc); 2091 2092 for (i = 0; i < adapter->num_rx_desc; i++) { 2093 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2094 adapter->rx_buffer_area[i].m_head = NULL; 2095 adapter->rx_desc_base[i].buffer_addr = 0; 2096 return(ENOBUFS); 2097 } 2098 } 2099 2100 return(0); 2101} 2102 2103/********************************************************************* 2104 * 2105 * Allocate and initialize receive structures. 2106 * 2107 **********************************************************************/ 2108static int 2109em_setup_receive_structures(struct adapter * adapter) 2110{ 2111 bzero((void *) adapter->rx_desc_base, 2112 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 2113 2114 if (em_allocate_receive_structures(adapter)) 2115 return ENOMEM; 2116 2117 /* Setup our descriptor pointers */ 2118 adapter->next_rx_desc_to_check = 0; 2119 return(0); 2120} 2121 2122/********************************************************************* 2123 * 2124 * Enable receive unit. 2125 * 2126 **********************************************************************/ 2127static void 2128em_initialize_receive_unit(struct adapter * adapter) 2129{ 2130 u_int32_t reg_rctl; 2131 u_int32_t reg_rxcsum; 2132 struct ifnet *ifp; 2133 2134 ifp = &adapter->interface_data.ac_if; 2135 2136 /* Make sure receives are disabled while setting up the descriptor ring */ 2137 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 2138 2139 /* Set the Receive Delay Timer Register */ 2140 E1000_WRITE_REG(&adapter->hw, RDTR, 2141 adapter->rx_int_delay | E1000_RDT_FPDB); 2142 2143 if(adapter->hw.mac_type >= em_82540) { 2144 E1000_WRITE_REG(&adapter->hw, RADV, adapter->rx_abs_int_delay); 2145 2146 /* Set the interrupt throttling rate. Value is calculated 2147 * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ 2148#define MAX_INTS_PER_SEC 8000 2149#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) 2150 E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); 2151 } 2152 2153 /* Setup the Base and Length of the Rx Descriptor Ring */ 2154 E1000_WRITE_REG(&adapter->hw, RDBAL, 2155 vtophys((vm_offset_t) adapter->rx_desc_base)); 2156 E1000_WRITE_REG(&adapter->hw, RDBAH, 0); 2157 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 2158 sizeof(struct em_rx_desc)); 2159 2160 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 2161 E1000_WRITE_REG(&adapter->hw, RDH, 0); 2162 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 2163 2164 /* Setup the Receive Control Register */ 2165 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 2166 E1000_RCTL_RDMTS_HALF | 2167 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 2168 2169 if (adapter->hw.tbi_compatibility_on == TRUE) 2170 reg_rctl |= E1000_RCTL_SBP; 2171 2172 2173 switch (adapter->rx_buffer_len) { 2174 default: 2175 case EM_RXBUFFER_2048: 2176 reg_rctl |= E1000_RCTL_SZ_2048; 2177 break; 2178 case EM_RXBUFFER_4096: 2179 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2180 break; 2181 case EM_RXBUFFER_8192: 2182 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2183 break; 2184 case EM_RXBUFFER_16384: 2185 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 2186 break; 2187 } 2188 2189 if (ifp->if_mtu > ETHERMTU) 2190 reg_rctl |= E1000_RCTL_LPE; 2191 2192 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 2193 if ((adapter->hw.mac_type >= em_82543) && 2194 (ifp->if_capenable & IFCAP_RXCSUM)) { 2195 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 2196 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 2197 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 2198 } 2199 2200 /* Enable Receives */ 2201 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 2202 2203 return; 2204} 2205 2206/********************************************************************* 2207 * 2208 * Free receive related data structures. 2209 * 2210 **********************************************************************/ 2211static void 2212em_free_receive_structures(struct adapter *adapter) 2213{ 2214 struct em_buffer *rx_buffer; 2215 int i; 2216 2217 INIT_DEBUGOUT("free_receive_structures: begin"); 2218 2219 if (adapter->rx_buffer_area != NULL) { 2220 rx_buffer = adapter->rx_buffer_area; 2221 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 2222 if (rx_buffer->m_head != NULL) 2223 m_freem(rx_buffer->m_head); 2224 rx_buffer->m_head = NULL; 2225 } 2226 } 2227 if (adapter->rx_buffer_area != NULL) { 2228 free(adapter->rx_buffer_area, M_DEVBUF); 2229 adapter->rx_buffer_area = NULL; 2230 } 2231 return; 2232} 2233 2234/********************************************************************* 2235 * 2236 * This routine executes in interrupt context. It replenishes 2237 * the mbufs in the descriptor and sends data which has been 2238 * dma'ed into host memory to upper layer. 2239 * 2240 * We loop at most count times if count is > 0, or until done if 2241 * count < 0. 2242 * 2243 *********************************************************************/ 2244static void 2245em_process_receive_interrupts(struct adapter * adapter, int count) 2246{ 2247 struct ifnet *ifp; 2248 struct mbuf *mp; 2249#if __FreeBSD_version < 500000 2250 struct ether_header *eh; 2251#endif 2252 u_int8_t accept_frame = 0; 2253 u_int8_t eop = 0; 2254 u_int16_t len; 2255 int i; 2256 2257 /* Pointer to the receive descriptor being examined. */ 2258 struct em_rx_desc *current_desc; 2259 2260 ifp = &adapter->interface_data.ac_if; 2261 i = adapter->next_rx_desc_to_check; 2262 current_desc = &adapter->rx_desc_base[i]; 2263 2264 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 2265#ifdef DBG_STATS 2266 adapter->no_pkts_avail++; 2267#endif 2268 return; 2269 } 2270 2271 while ((current_desc->status & E1000_RXD_STAT_DD) && (count != 0)) { 2272 2273 mp = adapter->rx_buffer_area[i].m_head; 2274 2275 accept_frame = 1; 2276 if (current_desc->status & E1000_RXD_STAT_EOP) { 2277 count--; 2278 eop = 1; 2279 len = current_desc->length - ETHER_CRC_LEN; 2280 } else { 2281 eop = 0; 2282 len = current_desc->length; 2283 } 2284 2285 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 2286 u_int8_t last_byte; 2287 u_int32_t pkt_len = current_desc->length; 2288 2289 if (adapter->fmp != NULL) 2290 pkt_len += adapter->fmp->m_pkthdr.len; 2291 2292 last_byte = *(mtod(mp, caddr_t) + 2293 current_desc->length - 1); 2294 2295 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 2296 current_desc->errors, 2297 pkt_len, last_byte)) { 2298 em_tbi_adjust_stats(&adapter->hw, 2299 &adapter->stats, 2300 pkt_len, 2301 adapter->hw.mac_addr); 2302 len--; 2303 } 2304 else { 2305 accept_frame = 0; 2306 } 2307 } 2308 2309 if (accept_frame) { 2310 2311 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 2312 adapter->dropped_pkts++; 2313 em_get_buf(i, adapter, mp); 2314 if (adapter->fmp != NULL) 2315 m_freem(adapter->fmp); 2316 adapter->fmp = NULL; 2317 adapter->lmp = NULL; 2318 break; 2319 } 2320 2321 /* Assign correct length to the current fragment */ 2322 mp->m_len = len; 2323 2324 if (adapter->fmp == NULL) { 2325 mp->m_pkthdr.len = len; 2326 adapter->fmp = mp; /* Store the first mbuf */ 2327 adapter->lmp = mp; 2328 } else { 2329 /* Chain mbuf's together */ 2330 mp->m_flags &= ~M_PKTHDR; 2331 adapter->lmp->m_next = mp; 2332 adapter->lmp = adapter->lmp->m_next; 2333 adapter->fmp->m_pkthdr.len += len; 2334 } 2335 2336 if (eop) { 2337 adapter->fmp->m_pkthdr.rcvif = ifp; 2338 2339#if __FreeBSD_version < 500000 2340 eh = mtod(adapter->fmp, struct ether_header *); 2341 /* Remove ethernet header from mbuf */ 2342 m_adj(adapter->fmp, sizeof(struct ether_header)); 2343 em_receive_checksum(adapter, current_desc, 2344 adapter->fmp); 2345 if (current_desc->status & E1000_RXD_STAT_VP) 2346 VLAN_INPUT_TAG(eh, adapter->fmp, 2347 (current_desc->special & 2348 E1000_RXD_SPC_VLAN_MASK)); 2349 else 2350 ether_input(ifp, eh, adapter->fmp); 2351#else 2352 2353 em_receive_checksum(adapter, current_desc, 2354 adapter->fmp); 2355 if (current_desc->status & E1000_RXD_STAT_VP) 2356 VLAN_INPUT_TAG(ifp, adapter->fmp, 2357 (current_desc->special & 2358 E1000_RXD_SPC_VLAN_MASK), 2359 adapter->fmp = NULL); 2360 2361 if (adapter->fmp != NULL) 2362 (*ifp->if_input)(ifp, adapter->fmp); 2363#endif 2364 adapter->fmp = NULL; 2365 adapter->lmp = NULL; 2366 } 2367 } else { 2368 adapter->dropped_pkts++; 2369 em_get_buf(i, adapter, mp); 2370 if (adapter->fmp != NULL) 2371 m_freem(adapter->fmp); 2372 adapter->fmp = NULL; 2373 adapter->lmp = NULL; 2374 } 2375 2376 /* Zero out the receive descriptors status */ 2377 current_desc->status = 0; 2378 2379 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 2380 E1000_WRITE_REG(&adapter->hw, RDT, i); 2381 2382 /* Advance our pointers to the next descriptor */ 2383 if (++i == adapter->num_rx_desc) { 2384 i = 0; 2385 current_desc = adapter->rx_desc_base; 2386 } else 2387 current_desc++; 2388 } 2389 adapter->next_rx_desc_to_check = i; 2390 return; 2391} 2392 2393/********************************************************************* 2394 * 2395 * Verify that the hardware indicated that the checksum is valid. 2396 * Inform the stack about the status of checksum so that stack 2397 * doesn't spend time verifying the checksum. 2398 * 2399 *********************************************************************/ 2400static void 2401em_receive_checksum(struct adapter *adapter, 2402 struct em_rx_desc *rx_desc, 2403 struct mbuf *mp) 2404{ 2405 /* 82543 or newer only */ 2406 if ((adapter->hw.mac_type < em_82543) || 2407 /* Ignore Checksum bit is set */ 2408 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 2409 mp->m_pkthdr.csum_flags = 0; 2410 return; 2411 } 2412 2413 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 2414 /* Did it pass? */ 2415 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 2416 /* IP Checksum Good */ 2417 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 2418 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 2419 2420 } else { 2421 mp->m_pkthdr.csum_flags = 0; 2422 } 2423 } 2424 2425 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2426 /* Did it pass? */ 2427 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2428 mp->m_pkthdr.csum_flags |= 2429 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2430 mp->m_pkthdr.csum_data = htons(0xffff); 2431 } 2432 } 2433 2434 return; 2435} 2436 2437 2438static void 2439em_enable_vlans(struct adapter *adapter) 2440{ 2441 uint32_t ctrl; 2442 2443 E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); 2444 2445 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2446 ctrl |= E1000_CTRL_VME; 2447 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2448 2449 return; 2450} 2451 2452static void 2453em_enable_intr(struct adapter * adapter) 2454{ 2455 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2456 return; 2457} 2458 2459static void 2460em_disable_intr(struct adapter *adapter) 2461{ 2462 E1000_WRITE_REG(&adapter->hw, IMC, 2463 (0xffffffff & ~E1000_IMC_RXSEQ)); 2464 return; 2465} 2466 2467void 2468em_write_pci_cfg(struct em_hw *hw, 2469 uint32_t reg, 2470 uint16_t *value) 2471{ 2472 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2473 *value, 2); 2474} 2475 2476void 2477em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2478 uint16_t *value) 2479{ 2480 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2481 reg, 2); 2482 return; 2483} 2484 2485void 2486em_pci_set_mwi(struct em_hw *hw) 2487{ 2488 pci_write_config(((struct em_osdep *)hw->back)->dev, 2489 PCIR_COMMAND, 2490 (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); 2491 return; 2492} 2493 2494void 2495em_pci_clear_mwi(struct em_hw *hw) 2496{ 2497 pci_write_config(((struct em_osdep *)hw->back)->dev, 2498 PCIR_COMMAND, 2499 (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); 2500 return; 2501} 2502 2503uint32_t 2504em_io_read(struct em_hw *hw, uint32_t port) 2505{ 2506 return(inl(port)); 2507} 2508 2509void 2510em_io_write(struct em_hw *hw, uint32_t port, uint32_t value) 2511{ 2512 outl(port, value); 2513 return; 2514} 2515 2516/********************************************************************** 2517 * 2518 * Update the board statistics counters. 2519 * 2520 **********************************************************************/ 2521static void 2522em_update_stats_counters(struct adapter *adapter) 2523{ 2524 struct ifnet *ifp; 2525 2526 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 2527 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 2528 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 2529 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 2530 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 2531 2532 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 2533 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 2534 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 2535 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 2536 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 2537 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 2538 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 2539 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 2540 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 2541 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 2542 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 2543 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 2544 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 2545 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 2546 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 2547 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 2548 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 2549 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 2550 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 2551 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 2552 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 2553 2554 /* For the 64-bit byte counters the low dword must be read first. */ 2555 /* Both registers clear on the read of the high dword */ 2556 2557 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 2558 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 2559 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 2560 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 2561 2562 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 2563 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 2564 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 2565 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 2566 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 2567 2568 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 2569 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 2570 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 2571 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 2572 2573 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 2574 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 2575 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 2576 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 2577 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 2578 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 2579 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 2580 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 2581 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 2582 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 2583 2584 if (adapter->hw.mac_type >= em_82543) { 2585 adapter->stats.algnerrc += 2586 E1000_READ_REG(&adapter->hw, ALGNERRC); 2587 adapter->stats.rxerrc += 2588 E1000_READ_REG(&adapter->hw, RXERRC); 2589 adapter->stats.tncrs += 2590 E1000_READ_REG(&adapter->hw, TNCRS); 2591 adapter->stats.cexterr += 2592 E1000_READ_REG(&adapter->hw, CEXTERR); 2593 adapter->stats.tsctc += 2594 E1000_READ_REG(&adapter->hw, TSCTC); 2595 adapter->stats.tsctfc += 2596 E1000_READ_REG(&adapter->hw, TSCTFC); 2597 } 2598 ifp = &adapter->interface_data.ac_if; 2599 2600 /* Fill out the OS statistics structure */ 2601 ifp->if_ipackets = adapter->stats.gprc; 2602 ifp->if_opackets = adapter->stats.gptc; 2603 ifp->if_ibytes = adapter->stats.gorcl; 2604 ifp->if_obytes = adapter->stats.gotcl; 2605 ifp->if_imcasts = adapter->stats.mprc; 2606 ifp->if_collisions = adapter->stats.colc; 2607 2608 /* Rx Errors */ 2609 ifp->if_ierrors = 2610 adapter->dropped_pkts + 2611 adapter->stats.rxerrc + 2612 adapter->stats.crcerrs + 2613 adapter->stats.algnerrc + 2614 adapter->stats.rlec + adapter->stats.rnbc + 2615 adapter->stats.mpc + adapter->stats.cexterr; 2616 2617 /* Tx Errors */ 2618 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 2619 2620} 2621 2622 2623/********************************************************************** 2624 * 2625 * This routine is called only when em_display_debug_stats is enabled. 2626 * This routine provides a way to take a look at important statistics 2627 * maintained by the driver and hardware. 2628 * 2629 **********************************************************************/ 2630static void 2631em_print_hw_stats(struct adapter *adapter) 2632{ 2633 int unit = adapter->unit; 2634 2635#ifdef DBG_STATS 2636 printf("em%d: Packets not Avail = %ld\n", unit, 2637 adapter->no_pkts_avail); 2638 printf("em%d: CleanTxInterrupts = %ld\n", unit, 2639 adapter->clean_tx_interrupts); 2640#endif 2641 2642 printf("em%d: fifo workaround = %lld, fifo_reset = %lld\n", unit, 2643 (long long)adapter->tx_fifo_wrk, 2644 (long long)adapter->tx_fifo_reset); 2645 printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, 2646 E1000_READ_REG(&adapter->hw, TDH), 2647 E1000_READ_REG(&adapter->hw, TDT)); 2648 printf("em%d: Excessive collisions = %lld\n", unit, 2649 (long long)adapter->stats.ecol); 2650 printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, 2651 adapter->no_tx_desc_avail1); 2652 printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, 2653 adapter->no_tx_desc_avail2); 2654 2655 printf("em%d: Symbol errors = %lld\n", unit, 2656 (long long)adapter->stats.symerrs); 2657 printf("em%d: Sequence errors = %lld\n", unit, 2658 (long long)adapter->stats.sec); 2659 printf("em%d: Defer count = %lld\n", unit, 2660 (long long)adapter->stats.dc); 2661 2662 printf("em%d: Missed Packets = %lld\n", unit, 2663 (long long)adapter->stats.mpc); 2664 printf("em%d: Receive No Buffers = %lld\n", unit, 2665 (long long)adapter->stats.rnbc); 2666 printf("em%d: Receive length errors = %lld\n", unit, 2667 (long long)adapter->stats.rlec); 2668 printf("em%d: Receive errors = %lld\n", unit, 2669 (long long)adapter->stats.rxerrc); 2670 printf("em%d: Crc errors = %lld\n", unit, 2671 (long long)adapter->stats.crcerrs); 2672 printf("em%d: Alignment errors = %lld\n", unit, 2673 (long long)adapter->stats.algnerrc); 2674 printf("em%d: Carrier extension errors = %lld\n", unit, 2675 (long long)adapter->stats.cexterr); 2676 printf("em%d: Driver dropped packets = %ld\n", unit, 2677 adapter->dropped_pkts); 2678 2679 printf("em%d: XON Rcvd = %lld\n", unit, 2680 (long long)adapter->stats.xonrxc); 2681 printf("em%d: XON Xmtd = %lld\n", unit, 2682 (long long)adapter->stats.xontxc); 2683 printf("em%d: XOFF Rcvd = %lld\n", unit, 2684 (long long)adapter->stats.xoffrxc); 2685 printf("em%d: XOFF Xmtd = %lld\n", unit, 2686 (long long)adapter->stats.xofftxc); 2687 2688 printf("em%d: Good Packets Rcvd = %lld\n", unit, 2689 (long long)adapter->stats.gprc); 2690 printf("em%d: Good Packets Xmtd = %lld\n", unit, 2691 (long long)adapter->stats.gptc); 2692 2693 return; 2694} 2695 2696