if_em.c revision 102242
125537Sdfr/************************************************************************** 225537Sdfr 325537SdfrCopyright (c) 2001-2002 Intel Corporation 425537SdfrAll rights reserved. 525537Sdfr 625537SdfrRedistribution and use in source and binary forms of the Software, with or 725537Sdfrwithout modification, are permitted provided that the following conditions 825537Sdfrare met: 925537Sdfr 1025537Sdfr 1. Redistributions of source code of the Software may retain the above 1125537Sdfr copyright notice, this list of conditions and the following disclaimer. 1225537Sdfr 1325537Sdfr 2. Redistributions in binary form of the Software may reproduce the above 1425537Sdfr copyright notice, this list of conditions and the following disclaimer 1525537Sdfr in the documentation and/or other materials provided with the 1625537Sdfr distribution. 1725537Sdfr 1825537Sdfr 3. Neither the name of the Intel Corporation nor the names of its 1925537Sdfr contributors shall be used to endorse or promote products derived from 2025537Sdfr this Software without specific prior written permission. 2125537Sdfr 2225537SdfrTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2325537SdfrAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2425537SdfrIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2525537SdfrARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR ITS CONTRIBUTORS BE LIABLE 2625537SdfrFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27140482SpsDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 28140482SpsSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 29116182SobrienCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30116182SobrienLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31116182SobrienOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3225537SdfrSUCH DAMAGE. 3325537Sdfr 3425537Sdfr***************************************************************************/ 3550107Smsmith 3625537Sdfr/*$FreeBSD: head/sys/dev/em/if_em.c 102242 2002-08-21 23:44:15Z pdeuskar $*/ 3725537Sdfr 3825537Sdfr#include <dev/em/if_em.h> 3930994Sphk 4082749Sdillon/********************************************************************* 4182749Sdillon * Set this to one to display debug statistics 42134092Struckman *********************************************************************/ 4392547Sarrint em_display_debug_stats = 0; 4492547Sarr 4592547Sarr/********************************************************************* 4625537Sdfr * Linked list of board private structures for all NICs found 4769774Sphk *********************************************************************/ 4825537Sdfr 4960938Sjakestruct adapter *em_adapter_list = NULL; 5025537Sdfr 5190963Sarr 5290963Sarr/********************************************************************* 5390963Sarr * Driver version 5490963Sarr *********************************************************************/ 5590963Sarr 5690963Sarrchar em_driver_version[] = "1.3.15"; 5790963Sarr 5890963Sarr 5990963Sarr/********************************************************************* 6025537Sdfr * PCI Device ID Table 6125537Sdfr * 6290963Sarr * Used by probe to select devices to load on 6325537Sdfr * Last field stores an index into em_strings 6425537Sdfr * Last entry must be all 0s 6592547Sarr * 6625537Sdfr * { Vendor ID, Device ID, SubVendor ID, SubDevice ID, String Index } 6790963Sarr *********************************************************************/ 6825537Sdfrstatic em_vendor_info_t em_vendor_info_array[] = 6952991Speter{ 7090963Sarr /* Intel(R) PRO/1000 Network Connection */ 7152991Speter { 0x8086, 0x1000, PCI_ANY_ID, PCI_ANY_ID, 0}, 72132167Sphk { 0x8086, 0x1001, PCI_ANY_ID, PCI_ANY_ID, 0}, 73132167Sphk { 0x8086, 0x1004, PCI_ANY_ID, PCI_ANY_ID, 0}, 74132167Sphk { 0x8086, 0x1008, PCI_ANY_ID, PCI_ANY_ID, 0}, 75132167Sphk { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0}, 76132167Sphk { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0}, 77132167Sphk { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0}, 78132167Sphk { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0}, 79132167Sphk { 0x8086, 0x100F, PCI_ANY_ID, PCI_ANY_ID, 0}, 80132167Sphk { 0x8086, 0x1010, PCI_ANY_ID, PCI_ANY_ID, 0}, 8152991Speter { 0x8086, 0x1011, PCI_ANY_ID, PCI_ANY_ID, 0}, 8252991Speter { 0x8086, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0}, 8325537Sdfr /* required last entry */ 8490963Sarr { 0, 0, 0, 0, 0} 8525537Sdfr}; 8690963Sarr 8792547Sarr 8890963Sarr/********************************************************************* 89108905Speter * Table of branding strings for all supported NICs. 9090963Sarr *********************************************************************/ 9125537Sdfr 9225537Sdfrstatic char *em_strings[] = { 93177253Srwatson "Intel(R) PRO/1000 Network Connection" 9425537Sdfr}; 9525537Sdfr 9690963Sarr/********************************************************************* 9725537Sdfr * Function prototypes 9890963Sarr *********************************************************************/ 9925537Sdfrstatic int em_probe(device_t); 100134092Struckmanstatic int em_attach(device_t); 101134092Struckmanstatic int em_detach(device_t); 102159957Sjhbstatic int em_shutdown(device_t); 10392547Sarrstatic void em_intr(void *); 10490963Sarrstatic void em_start(struct ifnet *); 10590963Sarrstatic int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t); 10692547Sarrstatic void em_watchdog(struct ifnet *); 107159957Sjhbstatic void em_init(void *); 10825537Sdfrstatic void em_stop(void *); 10925537Sdfrstatic void em_media_status(struct ifnet *, struct ifmediareq *); 11025537Sdfrstatic int em_media_change(struct ifnet *); 11143387Sdillonstatic void em_identify_hardware(struct adapter *); 11225537Sdfrstatic int em_allocate_pci_resources(struct adapter *); 11390963Sarrstatic void em_free_pci_resources(struct adapter *); 11490963Sarrstatic void em_local_timer(void *); 11590963Sarrstatic int em_hardware_init(struct adapter *); 11625537Sdfrstatic void em_setup_interface(device_t, struct adapter *); 117159957Sjhbstatic int em_setup_transmit_structures(struct adapter *); 11892547Sarrstatic void em_initialize_transmit_unit(struct adapter *); 11990963Sarrstatic int em_setup_receive_structures(struct adapter *); 12090963Sarrstatic void em_initialize_receive_unit(struct adapter *); 12191067Sarrstatic void em_enable_intr(struct adapter *); 12290963Sarrstatic void em_disable_intr(struct adapter *); 12392547Sarrstatic void em_free_transmit_structures(struct adapter *); 12490963Sarrstatic void em_free_receive_structures(struct adapter *); 12590963Sarrstatic void em_update_stats_counters(struct adapter *); 12690963Sarrstatic void em_clean_transmit_interrupts(struct adapter *); 12792547Sarrstatic int em_allocate_receive_structures(struct adapter *); 12890963Sarrstatic int em_allocate_transmit_structures(struct adapter *); 12992547Sarrstatic void em_process_receive_interrupts(struct adapter *); 13091261Speterstatic void em_receive_checksum(struct adapter *, 13191261Speter struct em_rx_desc * rx_desc, 13291067Sarr struct mbuf *); 13390963Sarrstatic int em_transmit_checksum_setup(struct adapter *, 134159957Sjhb struct mbuf *, 13525537Sdfr u_int32_t *, 13625537Sdfr u_int32_t *); 13725537Sdfrstatic void em_set_promisc(struct adapter *); 13846693Speterstatic void em_disable_promisc(struct adapter *); 13925537Sdfrstatic void em_set_multi(struct adapter *); 14090963Sarrstatic void em_print_hw_stats(struct adapter *); 14190963Sarrstatic void em_print_link_status(struct adapter *); 14225537Sdfrstatic int em_get_buf(int i, struct adapter *, 143159634Smaxim struct mbuf *); 14490963Sarrstatic void em_enable_vlans(struct adapter *adapter); 14590963Sarr 146159634Smaxim/********************************************************************* 14791067Sarr * FreeBSD Device Interface Entry Points 14890963Sarr *********************************************************************/ 14990980Sarr 15090963Sarrstatic device_method_t em_methods[] = { 15190963Sarr /* Device interface */ 152111119Simp DEVMETHOD(device_probe, em_probe), 153159634Smaxim DEVMETHOD(device_attach, em_attach), 154159634Smaxim DEVMETHOD(device_detach, em_detach), 15590980Sarr DEVMETHOD(device_shutdown, em_shutdown), 156159634Smaxim {0, 0} 15790963Sarr}; 15890963Sarr 15990963Sarrstatic driver_t em_driver = { 16090963Sarr "em", em_methods, sizeof(struct adapter ), 16190963Sarr}; 16290963Sarr 16390963Sarrstatic devclass_t em_devclass; 16490963SarrDRIVER_MODULE(if_em, pci, em_driver, em_devclass, 0, 0); 16525537Sdfr 16690963Sarr/********************************************************************* 16790963Sarr * Device identification routine 16890963Sarr * 16992547Sarr * em_probe determines if the driver should be loaded on 17090980Sarr * adapter based on PCI vendor/device id of the adapter. 17125537Sdfr * 17225537Sdfr * return 0 on success, positive on failure 17325537Sdfr *********************************************************************/ 17425537Sdfr 17525537Sdfrstatic int 17625537Sdfrem_probe(device_t dev) 17792547Sarr{ 17892547Sarr em_vendor_info_t *ent; 17990963Sarr 18090963Sarr u_int16_t pci_vendor_id = 0; 18125537Sdfr u_int16_t pci_device_id = 0; 18225537Sdfr u_int16_t pci_subvendor_id = 0; 18325537Sdfr u_int16_t pci_subdevice_id = 0; 18425537Sdfr char adapter_name[60]; 18525537Sdfr 18625537Sdfr INIT_DEBUGOUT("em_probe: begin"); 18792547Sarr 18892547Sarr pci_vendor_id = pci_get_vendor(dev); 18990963Sarr if (pci_vendor_id != EM_VENDOR_ID) 19090963Sarr return(ENXIO); 19125537Sdfr 19290963Sarr pci_device_id = pci_get_device(dev); 19392547Sarr pci_subvendor_id = pci_get_subvendor(dev); 19490963Sarr pci_subdevice_id = pci_get_subdevice(dev); 19590963Sarr 19690963Sarr ent = em_vendor_info_array; 19790963Sarr while (ent->vendor_id != 0) { 19890963Sarr if ((pci_vendor_id == ent->vendor_id) && 19992547Sarr (pci_device_id == ent->device_id) && 20090963Sarr 20192547Sarr ((pci_subvendor_id == ent->subvendor_id) || 20225537Sdfr (ent->subvendor_id == PCI_ANY_ID)) && 20325537Sdfr 20425537Sdfr ((pci_subdevice_id == ent->subdevice_id) || 20525537Sdfr (ent->subdevice_id == PCI_ANY_ID))) { 20690963Sarr sprintf(adapter_name, "%s, Version - %s", 20725537Sdfr em_strings[ent->index], 20890963Sarr em_driver_version); 20990963Sarr device_set_desc_copy(dev, adapter_name); 21025537Sdfr return(0); 21192547Sarr } 21292547Sarr ent++; 21390963Sarr } 21490963Sarr 21590963Sarr return(ENXIO); 21690980Sarr} 21790963Sarr 21890980Sarr/********************************************************************* 21925537Sdfr * Device initialization routine 22025537Sdfr * 22125537Sdfr * The attach entry point is called when the driver is being loaded. 22225537Sdfr * This routine identifies the type of hardware, allocates all resources 22325537Sdfr * and initializes the hardware. 22492547Sarr * 22525537Sdfr * return 0 on success, positive on failure 22692547Sarr *********************************************************************/ 22792547Sarr 22892547Sarrstatic int 22992547Sarrem_attach(device_t dev) 23092547Sarr{ 23192547Sarr struct adapter * adapter; 23225537Sdfr int s; 23325537Sdfr int tsize, rsize; 23425537Sdfr 235132117Sphk INIT_DEBUGOUT("em_attach: begin"); 23625537Sdfr s = splimp(); 237132117Sphk 23890963Sarr /* Allocate, clear, and link in our adapter structure */ 239159957Sjhb if (!(adapter = device_get_softc(dev))) { 240132117Sphk printf("em: adapter structure allocation failed\n"); 241132199Sphk splx(s); 242132117Sphk return(ENOMEM); 243159957Sjhb } 244159957Sjhb bzero(adapter, sizeof(struct adapter )); 245159957Sjhb adapter->dev = dev; 246159957Sjhb adapter->osdep.dev = dev; 24725537Sdfr adapter->unit = device_get_unit(dev); 24825537Sdfr 24925537Sdfr if (em_adapter_list != NULL) 25025537Sdfr em_adapter_list->prev = adapter; 25125537Sdfr adapter->next = em_adapter_list; 25290963Sarr em_adapter_list = adapter; 25392547Sarr 25490980Sarr callout_handle_init(&adapter->timer_handle); 25525537Sdfr 25625537Sdfr /* Determine hardware revision */ 25725537Sdfr em_identify_hardware(adapter); 25825537Sdfr 25925537Sdfr /* Parameters (to be read from user) */ 26090963Sarr adapter->num_tx_desc = MAX_TXD; 26192547Sarr adapter->num_rx_desc = MAX_RXD; 26290980Sarr adapter->tx_int_delay = TIDV; 26325537Sdfr adapter->rx_int_delay = RIDV; 26425537Sdfr adapter->hw.autoneg = DO_AUTO_NEG; 26542435Sdfr adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; 26642435Sdfr adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 26742435Sdfr adapter->hw.tbi_compatibility_en = TRUE; 26890963Sarr adapter->rx_buffer_len = EM_RXBUFFER_2048; 26992547Sarr 27090963Sarr adapter->hw.fc_high_water = FC_DEFAULT_HI_THRESH; 27142435Sdfr adapter->hw.fc_low_water = FC_DEFAULT_LO_THRESH; 27242435Sdfr adapter->hw.fc_pause_time = FC_DEFAULT_TX_TIMER; 273157818Sjhb adapter->hw.fc_send_xon = TRUE; 274157818Sjhb adapter->hw.fc = em_fc_full; 275157818Sjhb 276157818Sjhb /* Set the max frame size assuming standard ethernet sized frames */ 277157818Sjhb adapter->hw.max_frame_size = 278157818Sjhb ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; 279157818Sjhb 28025537Sdfr adapter->hw.min_frame_size = 28125537Sdfr MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; 28225537Sdfr 28325537Sdfr /* This controls when hardware reports transmit completion status. */ 28483366Sjulian if ((EM_REPORT_TX_EARLY == 0) || (EM_REPORT_TX_EARLY == 1)) { 28525537Sdfr adapter->hw.report_tx_early = EM_REPORT_TX_EARLY; 28690963Sarr } else { 28790963Sarr if (adapter->hw.mac_type < em_82543) { 28825537Sdfr adapter->hw.report_tx_early = 0; 28998835Sarr } else { 29082749Sdillon adapter->hw.report_tx_early = 1; 29192547Sarr } 292107849Salfred } 29390963Sarr 29490963Sarr if (em_allocate_pci_resources(adapter)) { 29590963Sarr printf("em%d: Allocation of PCI resources failed\n", 29690963Sarr adapter->unit); 29790963Sarr em_free_pci_resources(adapter); 29890963Sarr splx(s); 29990963Sarr return(ENXIO); 300107849Salfred } 30190963Sarr 30290963Sarr tsize = EM_ROUNDUP(adapter->num_tx_desc * 30390963Sarr sizeof(struct em_tx_desc), 4096); 30490963Sarr 30590963Sarr /* Allocate Transmit Descriptor ring */ 30690963Sarr if (!(adapter->tx_desc_base = (struct em_tx_desc *) 30782749Sdillon contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 30890963Sarr printf("em%d: Unable to allocate TxDescriptor memory\n", 30982749Sdillon adapter->unit); 31092547Sarr em_free_pci_resources(adapter); 31190963Sarr splx(s); 31225537Sdfr return(ENOMEM); 31325537Sdfr } 31425537Sdfr 31583366Sjulian rsize = EM_ROUNDUP(adapter->num_rx_desc * 31625537Sdfr sizeof(struct em_rx_desc), 4096); 31790963Sarr 31890963Sarr /* Allocate Receive Descriptor ring */ 31925537Sdfr if (!(adapter->rx_desc_base = (struct em_rx_desc *) 32090963Sarr contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { 32125537Sdfr printf("em%d: Unable to allocate rx_desc memory\n", 32292547Sarr adapter->unit); 323107849Salfred em_free_pci_resources(adapter); 32490963Sarr contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 32590963Sarr splx(s); 32690963Sarr return(ENOMEM); 32790963Sarr } 32890963Sarr 32990963Sarr /* Initialize the hardware */ 33090963Sarr if (em_hardware_init(adapter)) { 33190963Sarr printf("em%d: Unable to initialize the hardware\n", 33290963Sarr adapter->unit); 33392547Sarr em_free_pci_resources(adapter); 33490963Sarr contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); 33525537Sdfr contigfree(adapter->rx_desc_base, rsize, M_DEVBUF); 33625537Sdfr splx(s); 33742435Sdfr return(EIO); 33891067Sarr } 33991067Sarr 34091067Sarr /* Copy the permanent MAC address out of the EEPROM */ 34191067Sarr if (em_read_mac_addr(&adapter->hw) < 0) { 34242435Sdfr printf("em%d: EEPROM read error while reading mac address\n", 34342435Sdfr adapter->unit); 34425537Sdfr return(EIO); 34583366Sjulian } 34625537Sdfr 34790963Sarr memcpy(adapter->interface_data.ac_enaddr, adapter->hw.mac_addr, 34892547Sarr ETH_LENGTH_OF_ADDRESS); 34990963Sarr 35092547Sarr /* Setup OS specific network interface */ 35190963Sarr em_setup_interface(dev, adapter); 35292547Sarr 35325537Sdfr /* Initialize statistics */ 35492547Sarr em_clear_hw_cntrs(&adapter->hw); 355107849Salfred em_update_stats_counters(adapter); 35690963Sarr adapter->hw.get_link_status = 1; 35792547Sarr em_check_for_link(&adapter->hw); 35898835Sarr 35990963Sarr /* Print the link status */ 36092547Sarr if (adapter->link_active == 1) { 36192547Sarr em_get_speed_and_duplex(&adapter->hw, &adapter->link_speed, 36292547Sarr &adapter->link_duplex); 36392547Sarr printf("em%d: Speed:%d Mbps Duplex:%s\n", 36492547Sarr adapter->unit, 365107849Salfred adapter->link_speed, 36625537Sdfr adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); 36790963Sarr } else 36890963Sarr printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); 36990963Sarr 37090963Sarr 37198835Sarr INIT_DEBUGOUT("em_attach: end"); 37290963Sarr splx(s); 37398835Sarr return(0); 37498835Sarr} 37590963Sarr 37690963Sarr/********************************************************************* 37790963Sarr * Device removal routine 37892547Sarr * 37998835Sarr * The detach entry point is called when the driver is being removed. 38025537Sdfr * This routine stops the adapter and deallocates all the resources 38192547Sarr * that were allocated for driver operation. 38298835Sarr * 38392547Sarr * return 0 on success, positive on failure 38498835Sarr *********************************************************************/ 38525537Sdfr 38690963Sarrstatic int 38790963Sarrem_detach(device_t dev) 38890963Sarr{ 38998835Sarr struct adapter * adapter = device_get_softc(dev); 39092547Sarr struct ifnet *ifp = &adapter->interface_data.ac_if; 39192547Sarr int s; 39298835Sarr int size; 39390963Sarr 39490980Sarr INIT_DEBUGOUT("em_detach: begin"); 39525537Sdfr s = splimp(); 39625537Sdfr 39725537Sdfr em_stop(adapter); 39883366Sjulian em_phy_hw_reset(&adapter->hw); 39925537Sdfr ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED); 40090963Sarr em_free_pci_resources(adapter); 40190963Sarr 40290963Sarr size = EM_ROUNDUP(adapter->num_tx_desc * 40325537Sdfr sizeof(struct em_tx_desc), 4096); 404107849Salfred 40598835Sarr /* Free Transmit Descriptor ring */ 40625537Sdfr if (adapter->tx_desc_base) { 40792547Sarr contigfree(adapter->tx_desc_base, size, M_DEVBUF); 40890963Sarr adapter->tx_desc_base = NULL; 40990963Sarr } 41090963Sarr 41190963Sarr size = EM_ROUNDUP(adapter->num_rx_desc * 41292547Sarr sizeof(struct em_rx_desc), 4096); 41392547Sarr 41490980Sarr /* Free Receive Descriptor ring */ 41525537Sdfr if (adapter->rx_desc_base) { 416140482Sps contigfree(adapter->rx_desc_base, size, M_DEVBUF); 417176252Sjhb adapter->rx_desc_base = NULL; 418176252Sjhb } 419140482Sps 420140482Sps /* Remove from the adapter list */ 421174377Sjhb if (em_adapter_list == adapter) 422140482Sps em_adapter_list = adapter->next; 423140482Sps if (adapter->next != NULL) 424140482Sps adapter->next->prev = adapter->prev; 425140482Sps if (adapter->prev != NULL) 426140482Sps adapter->prev->next = adapter->next; 427140482Sps 428140482Sps ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 429140482Sps ifp->if_timer = 0; 430140482Sps 431140482Sps splx(s); 432140482Sps return(0); 433140482Sps} 434140482Sps 435140482Spsstatic int 436140482Spsem_shutdown(device_t dev) 437140482Sps{ 438140482Sps struct adapter *adapter = device_get_softc(dev); 439140482Sps em_stop(adapter); 440140482Sps return(0); 441140482Sps} 442140482Sps 443140482Sps 444140482Sps/********************************************************************* 445140482Sps * Transmit entry point 446140482Sps * 447140482Sps * em_start is called by the stack to initiate a transmit. 448140482Sps * The driver will remain in this routine as long as there are 449140482Sps * packets to transmit and transmit resources are available. 450140482Sps * In case resources are not available stack is notified and 451140482Sps * the packet is requeued. 452140482Sps **********************************************************************/ 453140482Sps 454140482Spsstatic void 455140482Spsem_start(struct ifnet *ifp) 456140482Sps{ 457140482Sps int s; 458140482Sps struct mbuf *m_head, *mp; 459140482Sps vm_offset_t virtual_addr; 460140482Sps u_int32_t txd_upper; 461142067Sps u_int32_t txd_lower; 462142067Sps struct em_tx_buffer *tx_buffer; 463142067Sps struct em_tx_desc *current_tx_desc = NULL; 464142067Sps struct adapter * adapter = ifp->if_softc; 465140482Sps 466140482Sps if (!adapter->link_active) 467140482Sps return; 468140482Sps 469140482Sps s = splimp(); 470140482Sps while (ifp->if_snd.ifq_head != NULL) { 471140482Sps int i, count = 0; 472140482Sps struct ifvlan *ifv = NULL; 473140482Sps 474140482Sps IF_DEQUEUE(&ifp->if_snd, m_head); 475140482Sps 476140482Sps if (m_head == NULL) break; 477140482Sps 478140482Sps /* If num_tx_desc_avail is less than threshold, call 479140482Sps * clean_transmit_interrupts to reclaim TX descriptors 480140482Sps */ 481140482Sps if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD) 482140482Sps em_clean_transmit_interrupts(adapter); 483140482Sps 484140482Sps /* If num_tx_desc_avail is still less than threshold, 485140482Sps * prepend the mbuf to the head of the queue. 486140482Sps */ 487140482Sps if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD) { 488140482Sps ifp->if_flags |= IFF_OACTIVE; 489140482Sps IF_PREPEND(&ifp->if_snd, m_head); 490140482Sps adapter->no_tx_desc_avail++; 491140482Sps break; 492140482Sps } 493140482Sps 494140482Sps i = adapter->next_avail_tx_desc; 495 tx_buffer = &adapter->tx_buffer_area[i]; 496 tx_buffer->m_head = m_head; 497 tx_buffer->num_tx_desc_used = 0; 498 499 if (ifp->if_hwassist > 0) { 500 if (em_transmit_checksum_setup(adapter, m_head, 501 &txd_upper, &txd_lower)) { 502 /* 503 * if we change context, one tx_desc is used, 504 * so count it and advance pointer (i) 505 */ 506 count = 1; 507 if (++i == adapter->num_tx_desc) 508 i = 0; 509 510 } 511 } 512 else 513 txd_upper = txd_lower = 0; 514 515 for (mp = m_head; mp != NULL; mp = mp->m_next) { 516 if (mp->m_len == 0) 517 continue; 518 current_tx_desc = &adapter->tx_desc_base[i]; 519 virtual_addr = mtod(mp, vm_offset_t); 520 current_tx_desc->buffer_addr = vtophys(virtual_addr); 521 522 current_tx_desc->lower.data = (txd_lower | mp->m_len); 523 current_tx_desc->upper.data = (txd_upper); 524 525 if (++i == adapter->num_tx_desc) 526 i = 0; 527 count++; 528 529 } 530 531 tx_buffer->num_tx_desc_used = count; 532 adapter->num_tx_desc_avail -= count; 533 adapter->next_avail_tx_desc = i; 534 535 /* Find out if we are in vlan mode */ 536 if ((m_head->m_flags & (M_PROTO1|M_PKTHDR)) == (M_PROTO1|M_PKTHDR) && 537 m_head->m_pkthdr.rcvif != NULL && 538 m_head->m_pkthdr.rcvif->if_type == IFT_L2VLAN) 539 ifv = m_head->m_pkthdr.rcvif->if_softc; 540 541 if (ifv != NULL) { 542 /* Tell hardware to add tag */ 543 current_tx_desc->lower.data |= E1000_TXD_CMD_VLE; 544 545 /* Set the vlan id */ 546 current_tx_desc->upper.fields.special = ifv->ifv_tag; 547 } 548 549 /* 550 * Last Descriptor of Packet needs End Of Packet (EOP), Report Status 551 * (RS) and append Ethernet CRC (IFCS) bits set. 552 */ 553 current_tx_desc->lower.data |= (adapter->txd_cmd | E1000_TXD_CMD_EOP); 554 555 /* Send a copy of the frame to the BPF listener */ 556 if (ifp->if_bpf) 557 bpf_mtap(ifp, m_head); 558 559 /* 560 * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 561 * that this frame is available to transmit. 562 */ 563 E1000_WRITE_REG(&adapter->hw, TDT, i); 564 } /* end of while loop */ 565 566 splx(s); 567 568 /* Set timeout in case chip has problems transmitting */ 569 ifp->if_timer = EM_TX_TIMEOUT; 570 571 return; 572} 573 574/********************************************************************* 575 * Ioctl entry point 576 * 577 * em_ioctl is called when the user wants to configure the 578 * interface. 579 * 580 * return 0 on success, positive on failure 581 **********************************************************************/ 582 583static int 584em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) 585{ 586 int s, mask, error = 0; 587 struct ifreq *ifr = (struct ifreq *) data; 588 struct adapter * adapter = ifp->if_softc; 589 590 s = splimp(); 591 switch (command) { 592 case SIOCSIFADDR: 593 case SIOCGIFADDR: 594 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFADDR (Get/Set Interface Addr)"); 595 ether_ioctl(ifp, command, data); 596 break; 597 case SIOCSIFMTU: 598 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); 599 if (ifr->ifr_mtu > MAX_JUMBO_FRAME_SIZE - ETHER_HDR_LEN) { 600 error = EINVAL; 601 } else { 602 ifp->if_mtu = ifr->ifr_mtu; 603 adapter->hw.max_frame_size = 604 ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; 605 em_init(adapter); 606 } 607 break; 608 case SIOCSIFFLAGS: 609 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); 610 if (ifp->if_flags & IFF_UP) { 611 if (ifp->if_flags & IFF_RUNNING && 612 ifp->if_flags & IFF_PROMISC) { 613 em_set_promisc(adapter); 614 } else if (ifp->if_flags & IFF_RUNNING && 615 !(ifp->if_flags & IFF_PROMISC)) { 616 em_disable_promisc(adapter); 617 } else 618 em_init(adapter); 619 } else { 620 if (ifp->if_flags & IFF_RUNNING) { 621 em_stop(adapter); 622 } 623 } 624 break; 625 case SIOCADDMULTI: 626 case SIOCDELMULTI: 627 IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); 628 if (ifp->if_flags & IFF_RUNNING) { 629 em_disable_intr(adapter); 630 em_set_multi(adapter); 631 if (adapter->hw.mac_type == em_82542_rev2_0) 632 em_initialize_receive_unit(adapter); 633 em_enable_intr(adapter); 634 } 635 break; 636 case SIOCSIFMEDIA: 637 case SIOCGIFMEDIA: 638 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); 639 error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); 640 break; 641 case SIOCSIFCAP: 642 IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); 643 mask = ifr->ifr_reqcap ^ ifp->if_capenable; 644 if (mask & IFCAP_HWCSUM) { 645 if (IFCAP_HWCSUM & ifp->if_capenable) 646 ifp->if_capenable &= ~IFCAP_HWCSUM; 647 else 648 ifp->if_capenable |= IFCAP_HWCSUM; 649 if (ifp->if_flags & IFF_RUNNING) 650 em_init(adapter); 651 } 652 break; 653 default: 654 IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command); 655 error = EINVAL; 656 } 657 658 splx(s); 659 return(error); 660} 661 662static void 663em_set_promisc(struct adapter * adapter) 664{ 665 666 u_int32_t reg_rctl; 667 struct ifnet *ifp = &adapter->interface_data.ac_if; 668 669 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 670 671 if (ifp->if_flags & IFF_PROMISC) { 672 reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); 673 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 674 } else if (ifp->if_flags & IFF_ALLMULTI) { 675 reg_rctl |= E1000_RCTL_MPE; 676 reg_rctl &= ~E1000_RCTL_UPE; 677 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 678 } 679 680 return; 681} 682 683static void 684em_disable_promisc(struct adapter * adapter) 685{ 686 u_int32_t reg_rctl; 687 688 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 689 690 reg_rctl &= (~E1000_RCTL_UPE); 691 reg_rctl &= (~E1000_RCTL_MPE); 692 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 693 694 return; 695} 696 697 698/********************************************************************* 699 * Multicast Update 700 * 701 * This routine is called whenever multicast address list is updated. 702 * 703 **********************************************************************/ 704 705static void 706em_set_multi(struct adapter * adapter) 707{ 708 u_int32_t reg_rctl = 0; 709 u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; 710 u_int16_t pci_cmd_word; 711 struct ifmultiaddr *ifma; 712 int mcnt = 0; 713 struct ifnet *ifp = &adapter->interface_data.ac_if; 714 715 IOCTL_DEBUGOUT("em_set_multi: begin"); 716 717 if (adapter->hw.mac_type == em_82542_rev2_0) { 718 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 719 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 720 pci_cmd_word = adapter->hw.pci_cmd_word & 721 ~CMD_MEM_WRT_INVALIDATE; 722 pci_write_config(adapter->dev, PCIR_COMMAND, pci_cmd_word, 2); 723 } 724 reg_rctl |= E1000_RCTL_RST; 725 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 726 msec_delay(5); 727 } 728 729#if __FreeBSD_version < 500000 730 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 731#else 732 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 733#endif 734 if (ifma->ifma_addr->sa_family != AF_LINK) 735 continue; 736 737 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 738 &mta[mcnt*ETH_LENGTH_OF_ADDRESS], ETH_LENGTH_OF_ADDRESS); 739 mcnt++; 740 } 741 742 if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) { 743 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 744 reg_rctl |= E1000_RCTL_MPE; 745 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 746 } else 747 em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0); 748 749 if (adapter->hw.mac_type == em_82542_rev2_0) { 750 reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); 751 reg_rctl &= ~E1000_RCTL_RST; 752 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 753 msec_delay(5); 754 if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { 755 pci_write_config(adapter->dev, PCIR_COMMAND, 756 adapter->hw.pci_cmd_word, 2); 757 } 758 } 759 760 return; 761} 762 763/********************************************************************* 764 * Watchdog entry point 765 * 766 * This routine is called whenever hardware quits transmitting. 767 * 768 **********************************************************************/ 769 770static void 771em_watchdog(struct ifnet *ifp) 772{ 773 struct adapter * adapter; 774 adapter = ifp->if_softc; 775 776 /* If we are in this routine because of pause frames, then 777 * don't reset the hardware. 778 */ 779 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { 780 ifp->if_timer = EM_TX_TIMEOUT; 781 return; 782 } 783 784 printf("em%d: watchdog timeout -- resetting\n", adapter->unit); 785 786 ifp->if_flags &= ~IFF_RUNNING; 787 788 em_stop(adapter); 789 em_init(adapter); 790 791 ifp->if_oerrors++; 792 return; 793} 794 795/********************************************************************* 796 * Timer routine 797 * 798 * This routine checks for link status and updates statistics. 799 * 800 **********************************************************************/ 801 802static void 803em_local_timer(void *arg) 804{ 805 int s; 806 struct ifnet *ifp; 807 struct adapter * adapter = arg; 808 ifp = &adapter->interface_data.ac_if; 809 810 s = splimp(); 811 812 em_check_for_link(&adapter->hw); 813 em_print_link_status(adapter); 814 em_update_stats_counters(adapter); 815 if (em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { 816 em_print_hw_stats(adapter); 817 } 818 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 819 820 splx(s); 821 return; 822} 823 824static void 825em_print_link_status(struct adapter * adapter) 826{ 827 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 828 if (adapter->link_active == 0) { 829 em_get_speed_and_duplex(&adapter->hw, 830 &adapter->link_speed, 831 &adapter->link_duplex); 832 printf("em%d: Link is up %d Mbps %s\n", 833 adapter->unit, 834 adapter->link_speed, 835 ((adapter->link_duplex == FULL_DUPLEX) ? 836 "Full Duplex" : "Half Duplex")); 837 adapter->link_active = 1; 838 } 839 } else { 840 if (adapter->link_active == 1) { 841 adapter->link_speed = 0; 842 adapter->link_duplex = 0; 843 printf("em%d: Link is Down\n", adapter->unit); 844 adapter->link_active = 0; 845 } 846 } 847 848 return; 849} 850 851/********************************************************************* 852 * Init entry point 853 * 854 * This routine is used in two ways. It is used by the stack as 855 * init entry point in network interface structure. It is also used 856 * by the driver as a hw/sw initialization routine to get to a 857 * consistent state. 858 * 859 * return 0 on success, positive on failure 860 **********************************************************************/ 861 862static void 863em_init(void *arg) 864{ 865 int s; 866 struct ifnet *ifp; 867 struct adapter * adapter = arg; 868 869 INIT_DEBUGOUT("em_init: begin"); 870 871 s = splimp(); 872 873 em_stop(adapter); 874 875 /* Initialize the hardware */ 876 if (em_hardware_init(adapter)) { 877 printf("em%d: Unable to initialize the hardware\n", 878 adapter->unit); 879 splx(s); 880 return; 881 } 882 883 em_enable_vlans(adapter); 884 885 /* Prepare transmit descriptors and buffers */ 886 if (em_setup_transmit_structures(adapter)) { 887 printf("em%d: Could not setup transmit structures\n", 888 adapter->unit); 889 em_stop(adapter); 890 splx(s); 891 return; 892 } 893 em_initialize_transmit_unit(adapter); 894 895 /* Setup Multicast table */ 896 em_set_multi(adapter); 897 898 /* Prepare receive descriptors and buffers */ 899 if (em_setup_receive_structures(adapter)) { 900 printf("em%d: Could not setup receive structures\n", 901 adapter->unit); 902 em_stop(adapter); 903 splx(s); 904 return; 905 } 906 em_initialize_receive_unit(adapter); 907 908 ifp = &adapter->interface_data.ac_if; 909 ifp->if_flags |= IFF_RUNNING; 910 ifp->if_flags &= ~IFF_OACTIVE; 911 912 if (adapter->hw.mac_type >= em_82543) { 913 if (ifp->if_capenable & IFCAP_TXCSUM) 914 ifp->if_hwassist = EM_CHECKSUM_FEATURES; 915 else 916 ifp->if_hwassist = 0; 917 } 918 919 adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); 920 em_clear_hw_cntrs(&adapter->hw); 921 em_enable_intr(adapter); 922 923 splx(s); 924 return; 925} 926 927 928/********************************************************************* 929 * 930 * This routine disables all traffic on the adapter by issuing a 931 * global reset on the MAC and deallocates TX/RX buffers. 932 * 933 **********************************************************************/ 934 935static void 936em_stop(void *arg) 937{ 938 struct ifnet *ifp; 939 struct adapter * adapter = arg; 940 ifp = &adapter->interface_data.ac_if; 941 942 INIT_DEBUGOUT("em_stop: begin\n"); 943 em_disable_intr(adapter); 944 em_reset_hw(&adapter->hw); 945 untimeout(em_local_timer, adapter, adapter->timer_handle); 946 em_free_transmit_structures(adapter); 947 em_free_receive_structures(adapter); 948 949 950 /* Tell the stack that the interface is no longer active */ 951 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 952 953 return; 954} 955 956/********************************************************************* 957 * 958 * Interrupt Service routine 959 * 960 **********************************************************************/ 961 962static void 963em_intr(void *arg) 964{ 965 u_int32_t loop_cnt = EM_MAX_INTR; 966 u_int32_t reg_icr; 967 struct ifnet *ifp; 968 struct adapter *adapter = arg; 969 970 ifp = &adapter->interface_data.ac_if; 971 972 em_disable_intr(adapter); 973 while (loop_cnt > 0 && 974 (reg_icr = E1000_READ_REG(&adapter->hw, ICR)) != 0) { 975 976 /* Link status change */ 977 if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { 978 untimeout(em_local_timer, adapter, 979 adapter->timer_handle); 980 adapter->hw.get_link_status = 1; 981 em_check_for_link(&adapter->hw); 982 em_print_link_status(adapter); 983 adapter->timer_handle = 984 timeout(em_local_timer, adapter, 2*hz); 985 } 986 987 if (ifp->if_flags & IFF_RUNNING) { 988 em_process_receive_interrupts(adapter); 989 em_clean_transmit_interrupts(adapter); 990 } 991 loop_cnt--; 992 } 993 994 em_enable_intr(adapter); 995 996 if (ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) 997 em_start(ifp); 998 999 return; 1000} 1001 1002 1003/********************************************************************* 1004 * 1005 * Media Ioctl callback 1006 * 1007 * This routine is called whenever the user queries the status of 1008 * the interface using ifconfig. 1009 * 1010 **********************************************************************/ 1011static void 1012em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 1013{ 1014 struct adapter * adapter = ifp->if_softc; 1015 1016 INIT_DEBUGOUT("em_media_status: begin"); 1017 1018 em_check_for_link(&adapter->hw); 1019 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { 1020 if (adapter->link_active == 0) { 1021 em_get_speed_and_duplex(&adapter->hw, 1022 &adapter->link_speed, 1023 &adapter->link_duplex); 1024 adapter->link_active = 1; 1025 } 1026 } else { 1027 if (adapter->link_active == 1) { 1028 adapter->link_speed = 0; 1029 adapter->link_duplex = 0; 1030 adapter->link_active = 0; 1031 } 1032 } 1033 1034 ifmr->ifm_status = IFM_AVALID; 1035 ifmr->ifm_active = IFM_ETHER; 1036 1037 if (!adapter->link_active) 1038 return; 1039 1040 ifmr->ifm_status |= IFM_ACTIVE; 1041 1042 if (adapter->hw.media_type == em_media_type_fiber) { 1043 ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; 1044 } else { 1045 switch (adapter->link_speed) { 1046 case 10: 1047 ifmr->ifm_active |= IFM_10_T; 1048 break; 1049 case 100: 1050 ifmr->ifm_active |= IFM_100_TX; 1051 break; 1052 case 1000: 1053#if __FreeBSD_version < 500000 1054 ifmr->ifm_active |= IFM_1000_TX; 1055#else 1056 ifmr->ifm_active |= IFM_1000_T; 1057#endif 1058 break; 1059 } 1060 if (adapter->link_duplex == FULL_DUPLEX) 1061 ifmr->ifm_active |= IFM_FDX; 1062 else 1063 ifmr->ifm_active |= IFM_HDX; 1064 } 1065 return; 1066} 1067 1068/********************************************************************* 1069 * 1070 * Media Ioctl callback 1071 * 1072 * This routine is called when the user changes speed/duplex using 1073 * media/mediopt option with ifconfig. 1074 * 1075 **********************************************************************/ 1076static int 1077em_media_change(struct ifnet *ifp) 1078{ 1079 struct adapter * adapter = ifp->if_softc; 1080 struct ifmedia *ifm = &adapter->media; 1081 1082 INIT_DEBUGOUT("em_media_change: begin"); 1083 1084 if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) 1085 return(EINVAL); 1086 1087 switch (IFM_SUBTYPE(ifm->ifm_media)) { 1088 case IFM_AUTO: 1089 adapter->hw.autoneg = DO_AUTO_NEG; 1090 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 1091 break; 1092 case IFM_1000_SX: 1093#if __FreeBSD_version < 500000 1094 case IFM_1000_TX: 1095#else 1096 case IFM_1000_T: 1097#endif 1098 adapter->hw.autoneg = DO_AUTO_NEG; 1099 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 1100 break; 1101 case IFM_100_TX: 1102 adapter->hw.autoneg = FALSE; 1103 adapter->hw.autoneg_advertised = 0; 1104 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 1105 adapter->hw.forced_speed_duplex = em_100_full; 1106 else 1107 adapter->hw.forced_speed_duplex = em_100_half; 1108 break; 1109 case IFM_10_T: 1110 adapter->hw.autoneg = FALSE; 1111 adapter->hw.autoneg_advertised = 0; 1112 if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) 1113 adapter->hw.forced_speed_duplex = em_10_full; 1114 else 1115 adapter->hw.forced_speed_duplex = em_10_half; 1116 break; 1117 default: 1118 printf("em%d: Unsupported media type\n", adapter->unit); 1119 } 1120 1121 em_init(adapter); 1122 1123 return(0); 1124} 1125/* Section end: Other registered entry points */ 1126 1127 1128/********************************************************************* 1129 * 1130 * Determine hardware revision. 1131 * 1132 **********************************************************************/ 1133static void 1134em_identify_hardware(struct adapter * adapter) 1135{ 1136 device_t dev = adapter->dev; 1137 1138 /* Make sure our PCI config space has the necessary stuff set */ 1139 adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); 1140 if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && 1141 (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { 1142 printf("em%d: Memory Access and/or Bus Master bits were not set!\n", 1143 adapter->unit); 1144 adapter->hw.pci_cmd_word |= 1145 (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); 1146 pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); 1147 } 1148 1149 /* Save off the information about this board */ 1150 adapter->hw.vendor_id = pci_get_vendor(dev); 1151 adapter->hw.device_id = pci_get_device(dev); 1152 adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); 1153 adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); 1154 adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); 1155 1156 1157 /* Set MacType, etc. based on this PCI info */ 1158 switch (adapter->hw.device_id) { 1159 case E1000_DEV_ID_82542: 1160 adapter->hw.mac_type = (adapter->hw.revision_id == 3) ? 1161 em_82542_rev2_1 : em_82542_rev2_0; 1162 break; 1163 case E1000_DEV_ID_82543GC_FIBER: 1164 case E1000_DEV_ID_82543GC_COPPER: 1165 adapter->hw.mac_type = em_82543; 1166 break; 1167 case E1000_DEV_ID_82544EI_FIBER: 1168 case E1000_DEV_ID_82544EI_COPPER: 1169 case E1000_DEV_ID_82544GC_COPPER: 1170 case E1000_DEV_ID_82544GC_LOM: 1171 adapter->hw.mac_type = em_82544; 1172 break; 1173 case E1000_DEV_ID_82540EM: 1174 adapter->hw.mac_type = em_82540; 1175 break; 1176 case E1000_DEV_ID_82545EM_FIBER: 1177 case E1000_DEV_ID_82545EM_COPPER: 1178 adapter->hw.mac_type = em_82545; 1179 break; 1180 case E1000_DEV_ID_82546EB_FIBER: 1181 case E1000_DEV_ID_82546EB_COPPER: 1182 adapter->hw.mac_type = em_82546; 1183 break; 1184 default: 1185 INIT_DEBUGOUT1("Unknown device id 0x%x", adapter->hw.device_id); 1186 } 1187 return; 1188} 1189 1190static int 1191em_allocate_pci_resources(struct adapter * adapter) 1192{ 1193 int i, val, rid; 1194 device_t dev = adapter->dev; 1195 1196 rid = EM_MMBA; 1197 adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, 1198 &rid, 0, ~0, 1, 1199 RF_ACTIVE); 1200 if (!(adapter->res_memory)) { 1201 printf("em%d: Unable to allocate bus resource: memory\n", 1202 adapter->unit); 1203 return(ENXIO); 1204 } 1205 adapter->osdep.mem_bus_space_tag = 1206 rman_get_bustag(adapter->res_memory); 1207 adapter->osdep.mem_bus_space_handle = 1208 rman_get_bushandle(adapter->res_memory); 1209 adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; 1210 1211 1212 if (adapter->hw.mac_type > em_82543) { 1213 /* Figure our where our IO BAR is ? */ 1214 rid = EM_MMBA; 1215 for (i = 0; i < 5; i++) { 1216 val = pci_read_config(dev, rid, 4); 1217 if (val & 0x00000001) { 1218 adapter->io_rid = rid; 1219 break; 1220 } 1221 rid += 4; 1222 } 1223 1224 adapter->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT, 1225 &adapter->io_rid, 0, ~0, 1, 1226 RF_ACTIVE); 1227 if (!(adapter->res_ioport)) { 1228 printf("em%d: Unable to allocate bus resource: ioport\n", 1229 adapter->unit); 1230 return(ENXIO); 1231 } 1232 1233 adapter->hw.io_base = 1234 rman_get_start(adapter->res_ioport); 1235 } 1236 1237 rid = 0x0; 1238 adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, 1239 &rid, 0, ~0, 1, 1240 RF_SHAREABLE | RF_ACTIVE); 1241 if (!(adapter->res_interrupt)) { 1242 printf("em%d: Unable to allocate bus resource: interrupt\n", 1243 adapter->unit); 1244 return(ENXIO); 1245 } 1246 if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET, 1247 (void (*)(void *)) em_intr, adapter, 1248 &adapter->int_handler_tag)) { 1249 printf("em%d: Error registering interrupt handler!\n", 1250 adapter->unit); 1251 return(ENXIO); 1252 } 1253 1254 adapter->hw.back = &adapter->osdep; 1255 1256 return(0); 1257} 1258 1259static void 1260em_free_pci_resources(struct adapter * adapter) 1261{ 1262 device_t dev = adapter->dev; 1263 1264 if (adapter->res_interrupt != NULL) { 1265 bus_teardown_intr(dev, adapter->res_interrupt, 1266 adapter->int_handler_tag); 1267 bus_release_resource(dev, SYS_RES_IRQ, 0, 1268 adapter->res_interrupt); 1269 } 1270 if (adapter->res_memory != NULL) { 1271 bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, 1272 adapter->res_memory); 1273 } 1274 1275 if (adapter->res_ioport != NULL) { 1276 bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, 1277 adapter->res_ioport); 1278 } 1279 return; 1280} 1281 1282/********************************************************************* 1283 * 1284 * Initialize the hardware to a configuration as specified by the 1285 * adapter structure. The controller is reset, the EEPROM is 1286 * verified, the MAC address is set, then the shared initialization 1287 * routines are called. 1288 * 1289 **********************************************************************/ 1290static int 1291em_hardware_init(struct adapter * adapter) 1292{ 1293 /* Issue a global reset */ 1294 em_reset_hw(&adapter->hw); 1295 1296 /* Make sure we have a good EEPROM before we read from it */ 1297 if (em_validate_eeprom_checksum(&adapter->hw) < 0) { 1298 printf("em%d: The EEPROM Checksum Is Not Valid\n", 1299 adapter->unit); 1300 return(EIO); 1301 } 1302 1303 if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { 1304 printf("em%d: EEPROM read error while reading part number\n", 1305 adapter->unit); 1306 return(EIO); 1307 } 1308 1309 if (em_init_hw(&adapter->hw) < 0) { 1310 printf("em%d: Hardware Initialization Failed", 1311 adapter->unit); 1312 return(EIO); 1313 } 1314 1315 em_check_for_link(&adapter->hw); 1316 if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) 1317 adapter->link_active = 1; 1318 else 1319 adapter->link_active = 0; 1320 1321 if (adapter->link_active) { 1322 em_get_speed_and_duplex(&adapter->hw, 1323 &adapter->link_speed, 1324 &adapter->link_duplex); 1325 } else { 1326 adapter->link_speed = 0; 1327 adapter->link_duplex = 0; 1328 } 1329 1330 return(0); 1331} 1332 1333/********************************************************************* 1334 * 1335 * Setup networking device structure and register an interface. 1336 * 1337 **********************************************************************/ 1338static void 1339em_setup_interface(device_t dev, struct adapter * adapter) 1340{ 1341 struct ifnet *ifp; 1342 INIT_DEBUGOUT("em_setup_interface: begin"); 1343 1344 ifp = &adapter->interface_data.ac_if; 1345 ifp->if_unit = adapter->unit; 1346 ifp->if_name = "em"; 1347 ifp->if_mtu = ETHERMTU; 1348 ifp->if_output = ether_output; 1349 ifp->if_baudrate = 1000000000; 1350 ifp->if_init = em_init; 1351 ifp->if_softc = adapter; 1352 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 1353 ifp->if_ioctl = em_ioctl; 1354 ifp->if_start = em_start; 1355 ifp->if_watchdog = em_watchdog; 1356 ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; 1357 ether_ifattach(ifp, ETHER_BPF_SUPPORTED); 1358 1359 if (adapter->hw.mac_type >= em_82543) { 1360 ifp->if_capabilities = IFCAP_HWCSUM; 1361 ifp->if_capenable = ifp->if_capabilities; 1362 } 1363 1364 /* 1365 * Specify the media types supported by this adapter and register 1366 * callbacks to update media and link information 1367 */ 1368 ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, 1369 em_media_status); 1370 if (adapter->hw.media_type == em_media_type_fiber) { 1371 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 1372 0, NULL); 1373 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, 1374 0, NULL); 1375 } else { 1376 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); 1377 ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 1378 0, NULL); 1379 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 1380 0, NULL); 1381 ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 1382 0, NULL); 1383#if __FreeBSD_version < 500000 1384 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 1385 0, NULL); 1386 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); 1387#else 1388 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 1389 0, NULL); 1390 ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); 1391#endif 1392 } 1393 ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); 1394 ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); 1395 1396 return; 1397} 1398 1399 1400/********************************************************************* 1401 * 1402 * Allocate memory for tx_buffer structures. The tx_buffer stores all 1403 * the information needed to transmit a packet on the wire. 1404 * 1405 **********************************************************************/ 1406static int 1407em_allocate_transmit_structures(struct adapter * adapter) 1408{ 1409 if (!(adapter->tx_buffer_area = 1410 (struct em_tx_buffer *) malloc(sizeof(struct em_tx_buffer) * 1411 adapter->num_tx_desc, M_DEVBUF, 1412 M_NOWAIT))) { 1413 printf("em%d: Unable to allocate tx_buffer memory\n", 1414 adapter->unit); 1415 return ENOMEM; 1416 } 1417 1418 bzero(adapter->tx_buffer_area, 1419 sizeof(struct em_tx_buffer) * adapter->num_tx_desc); 1420 1421 return 0; 1422} 1423 1424/********************************************************************* 1425 * 1426 * Allocate and initialize transmit structures. 1427 * 1428 **********************************************************************/ 1429static int 1430em_setup_transmit_structures(struct adapter * adapter) 1431{ 1432 if (em_allocate_transmit_structures(adapter)) 1433 return ENOMEM; 1434 1435 bzero((void *) adapter->tx_desc_base, 1436 (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); 1437 1438 adapter->next_avail_tx_desc = 0; 1439 1440 /* Set number of descriptors available */ 1441 adapter->num_tx_desc_avail = adapter->num_tx_desc; 1442 1443 /* Set checksum context */ 1444 adapter->active_checksum_context = OFFLOAD_NONE; 1445 1446 return 0; 1447} 1448 1449/********************************************************************* 1450 * 1451 * Enable transmit unit. 1452 * 1453 **********************************************************************/ 1454static void 1455em_initialize_transmit_unit(struct adapter * adapter) 1456{ 1457 u_int32_t reg_tctl; 1458 u_int32_t reg_tipg = 0; 1459 1460 /* Setup the Base and Length of the Tx Descriptor Ring */ 1461 E1000_WRITE_REG(&adapter->hw, TDBAL, 1462 vtophys((vm_offset_t) adapter->tx_desc_base)); 1463 E1000_WRITE_REG(&adapter->hw, TDBAH, 0); 1464 E1000_WRITE_REG(&adapter->hw, TDLEN, 1465 adapter->num_tx_desc * 1466 sizeof(struct em_tx_desc)); 1467 1468 /* Setup the HW Tx Head and Tail descriptor pointers */ 1469 E1000_WRITE_REG(&adapter->hw, TDH, 0); 1470 E1000_WRITE_REG(&adapter->hw, TDT, 0); 1471 1472 1473 HW_DEBUGOUT2("Base = %x, Length = %x\n", 1474 E1000_READ_REG(&adapter->hw, TDBAL), 1475 E1000_READ_REG(&adapter->hw, TDLEN)); 1476 1477 1478 /* Set the default values for the Tx Inter Packet Gap timer */ 1479 switch (adapter->hw.mac_type) { 1480 case em_82543: 1481 case em_82544: 1482 case em_82540: 1483 case em_82545: 1484 case em_82546: 1485 if (adapter->hw.media_type == em_media_type_fiber) 1486 reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; 1487 else 1488 reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; 1489 reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1490 reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1491 break; 1492 case em_82542_rev2_0: 1493 case em_82542_rev2_1: 1494 reg_tipg = DEFAULT_82542_TIPG_IPGT; 1495 reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; 1496 reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; 1497 break; 1498 default: 1499 printf("em%d: Invalid mac type detected\n", adapter->unit); 1500 } 1501 E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); 1502 E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay); 1503 1504 /* Program the Transmit Control Register */ 1505 reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | 1506 (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); 1507 if (adapter->link_duplex == 1) { 1508 reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1509 } else { 1510 reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; 1511 } 1512 E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); 1513 1514 /* Setup Transmit Descriptor Settings for this adapter */ 1515 adapter->txd_cmd = E1000_TXD_CMD_IFCS; 1516 1517 if (adapter->tx_int_delay > 0) 1518 adapter->txd_cmd |= E1000_TXD_CMD_IDE; 1519 1520 if (adapter->hw.report_tx_early == 1) 1521 adapter->txd_cmd |= E1000_TXD_CMD_RS; 1522 else 1523 adapter->txd_cmd |= E1000_TXD_CMD_RPS; 1524 1525 return; 1526} 1527 1528/********************************************************************* 1529 * 1530 * Free all transmit related data structures. 1531 * 1532 **********************************************************************/ 1533static void 1534em_free_transmit_structures(struct adapter * adapter) 1535{ 1536 struct em_tx_buffer *tx_buffer; 1537 int i; 1538 1539 INIT_DEBUGOUT("free_transmit_structures: begin"); 1540 1541 if (adapter->tx_buffer_area != NULL) { 1542 tx_buffer = adapter->tx_buffer_area; 1543 for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { 1544 if (tx_buffer->m_head != NULL) 1545 m_freem(tx_buffer->m_head); 1546 tx_buffer->m_head = NULL; 1547 } 1548 } 1549 if (adapter->tx_buffer_area != NULL) { 1550 free(adapter->tx_buffer_area, M_DEVBUF); 1551 adapter->tx_buffer_area = NULL; 1552 } 1553 return; 1554} 1555 1556/********************************************************************* 1557 * 1558 * The offload context needs to be set when we transfer the first 1559 * packet of a particular protocol (TCP/UDP). We change the 1560 * context only if the protocol type changes. 1561 * Return 1 on context change, 0 otherwise. 1562 * 1563 **********************************************************************/ 1564static int 1565em_transmit_checksum_setup(struct adapter * adapter, 1566 struct mbuf *mp, 1567 u_int32_t *txd_upper, 1568 u_int32_t *txd_lower) 1569{ 1570 struct em_context_desc *TXD; 1571 1572 if (mp->m_pkthdr.csum_flags) { 1573 1574 if (mp->m_pkthdr.csum_flags & CSUM_TCP) { 1575 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1576 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1577 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) 1578 return (0); 1579 else 1580 adapter->active_checksum_context = OFFLOAD_TCP_IP; 1581 1582 } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { 1583 *txd_upper = E1000_TXD_POPTS_TXSM << 8; 1584 *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; 1585 if (adapter->active_checksum_context == OFFLOAD_UDP_IP) 1586 return(0); 1587 else 1588 adapter->active_checksum_context = OFFLOAD_UDP_IP; 1589 } else { 1590 *txd_upper = 0; 1591 *txd_lower = 0; 1592 return (0); 1593 } 1594 } else { 1595 *txd_upper = 0; 1596 *txd_lower = 0; 1597 return (0); 1598 } 1599 1600 /* If we reach this point, the checksum offload context 1601 * needs to be reset. 1602 */ 1603 TXD = (struct em_context_desc *) 1604 &adapter->tx_desc_base[adapter->next_avail_tx_desc]; 1605 1606 TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; 1607 TXD->lower_setup.ip_fields.ipcso = 1608 ETHER_HDR_LEN + offsetof(struct ip, ip_sum); 1609 TXD->lower_setup.ip_fields.ipcse = 1610 ETHER_HDR_LEN + sizeof(struct ip) - 1; 1611 1612 TXD->upper_setup.tcp_fields.tucss = 1613 ETHER_HDR_LEN + sizeof(struct ip); 1614 TXD->upper_setup.tcp_fields.tucse = 0; 1615 1616 if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { 1617 TXD->upper_setup.tcp_fields.tucso = 1618 ETHER_HDR_LEN + sizeof(struct ip) + 1619 offsetof(struct tcphdr, th_sum); 1620 } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { 1621 TXD->upper_setup.tcp_fields.tucso = 1622 ETHER_HDR_LEN + sizeof(struct ip) + 1623 offsetof(struct udphdr, uh_sum); 1624 } 1625 1626 TXD->tcp_seg_setup.data = 0; 1627 TXD->cmd_and_length = E1000_TXD_CMD_DEXT; 1628 1629 return(1); 1630} 1631 1632 1633/********************************************************************* 1634 * 1635 * Get a buffer from system mbuf buffer pool. 1636 * 1637 **********************************************************************/ 1638static int 1639em_get_buf(int i, struct adapter *adapter, 1640 struct mbuf *nmp) 1641{ 1642 register struct mbuf *mp = nmp; 1643 struct ifnet *ifp; 1644 1645 ifp = &adapter->interface_data.ac_if; 1646 1647 if (mp == NULL) { 1648 MGETHDR(mp, M_DONTWAIT, MT_DATA); 1649 if (mp == NULL) { 1650 adapter->mbuf_alloc_failed++; 1651 return(ENOBUFS); 1652 } 1653 MCLGET(mp, M_DONTWAIT); 1654 if ((mp->m_flags & M_EXT) == 0) { 1655 m_freem(mp); 1656 adapter->mbuf_cluster_failed++; 1657 return(ENOBUFS); 1658 } 1659 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1660 } else { 1661 mp->m_len = mp->m_pkthdr.len = MCLBYTES; 1662 mp->m_data = mp->m_ext.ext_buf; 1663 mp->m_next = NULL; 1664 } 1665 1666 if (ifp->if_mtu <= ETHERMTU) { 1667 m_adj(mp, ETHER_ALIGN); 1668 } 1669 1670 adapter->rx_buffer_area[i].m_head = mp; 1671 adapter->rx_desc_base[i].buffer_addr = 1672 vtophys(mtod(mp, vm_offset_t)); 1673 1674 return(0); 1675} 1676 1677/********************************************************************* 1678 * 1679 * Allocate memory for rx_buffer structures. Since we use one 1680 * rx_buffer per received packet, the maximum number of rx_buffer's 1681 * that we'll need is equal to the number of receive descriptors 1682 * that we've allocated. 1683 * 1684 **********************************************************************/ 1685static int 1686em_allocate_receive_structures(struct adapter * adapter) 1687{ 1688 int i; 1689 1690 if (!(adapter->rx_buffer_area = 1691 (struct em_rx_buffer *) malloc(sizeof(struct em_rx_buffer) * 1692 adapter->num_rx_desc, M_DEVBUF, 1693 M_NOWAIT))) { 1694 printf("em%d: Unable to allocate rx_buffer memory\n", 1695 adapter->unit); 1696 return(ENOMEM); 1697 } 1698 1699 bzero(adapter->rx_buffer_area, 1700 sizeof(struct em_rx_buffer) * adapter->num_rx_desc); 1701 1702 for (i = 0; i < adapter->num_rx_desc; i++) { 1703 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 1704 adapter->rx_buffer_area[i].m_head = NULL; 1705 adapter->rx_desc_base[i].buffer_addr = 0; 1706 return(ENOBUFS); 1707 } 1708 } 1709 1710 return(0); 1711} 1712 1713/********************************************************************* 1714 * 1715 * Allocate and initialize receive structures. 1716 * 1717 **********************************************************************/ 1718static int 1719em_setup_receive_structures(struct adapter * adapter) 1720{ 1721 bzero((void *) adapter->rx_desc_base, 1722 (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); 1723 1724 if (em_allocate_receive_structures(adapter)) 1725 return ENOMEM; 1726 1727 /* Setup our descriptor pointers */ 1728 adapter->next_rx_desc_to_check = 0; 1729 return(0); 1730} 1731 1732/********************************************************************* 1733 * 1734 * Enable receive unit. 1735 * 1736 **********************************************************************/ 1737static void 1738em_initialize_receive_unit(struct adapter * adapter) 1739{ 1740 u_int32_t reg_rctl; 1741 u_int32_t reg_rxcsum; 1742 struct ifnet *ifp; 1743 1744 ifp = &adapter->interface_data.ac_if; 1745 1746 /* Make sure receives are disabled while setting up the descriptor ring */ 1747 E1000_WRITE_REG(&adapter->hw, RCTL, 0); 1748 1749 /* Set the Receive Delay Timer Register */ 1750 E1000_WRITE_REG(&adapter->hw, RDTR, 1751 adapter->rx_int_delay | E1000_RDT_FPDB); 1752 1753 /* Setup the Base and Length of the Rx Descriptor Ring */ 1754 E1000_WRITE_REG(&adapter->hw, RDBAL, 1755 vtophys((vm_offset_t) adapter->rx_desc_base)); 1756 E1000_WRITE_REG(&adapter->hw, RDBAH, 0); 1757 E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * 1758 sizeof(struct em_rx_desc)); 1759 1760 /* Setup the HW Rx Head and Tail Descriptor Pointers */ 1761 E1000_WRITE_REG(&adapter->hw, RDH, 0); 1762 E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); 1763 1764 /* Setup the Receive Control Register */ 1765 reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | 1766 E1000_RCTL_RDMTS_HALF | 1767 (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); 1768 1769 if (adapter->hw.tbi_compatibility_on == TRUE) 1770 reg_rctl |= E1000_RCTL_SBP; 1771 1772 1773 switch (adapter->rx_buffer_len) { 1774 default: 1775 case EM_RXBUFFER_2048: 1776 reg_rctl |= E1000_RCTL_SZ_2048; 1777 break; 1778 case EM_RXBUFFER_4096: 1779 reg_rctl |= E1000_RCTL_SZ_4096 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1780 break; 1781 case EM_RXBUFFER_8192: 1782 reg_rctl |= E1000_RCTL_SZ_8192 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1783 break; 1784 case EM_RXBUFFER_16384: 1785 reg_rctl |= E1000_RCTL_SZ_16384 | E1000_RCTL_BSEX | E1000_RCTL_LPE; 1786 break; 1787 } 1788 1789 if (ifp->if_mtu > ETHERMTU) 1790 reg_rctl |= E1000_RCTL_LPE; 1791 1792 /* Enable 82543 Receive Checksum Offload for TCP and UDP */ 1793 if ((adapter->hw.mac_type >= em_82543) && 1794 (ifp->if_capenable & IFCAP_RXCSUM)) { 1795 reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); 1796 reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); 1797 E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); 1798 } 1799 1800 /* Enable Receives */ 1801 E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); 1802 1803 return; 1804} 1805 1806/********************************************************************* 1807 * 1808 * Free receive related data structures. 1809 * 1810 **********************************************************************/ 1811static void 1812em_free_receive_structures(struct adapter * adapter) 1813{ 1814 struct em_rx_buffer *rx_buffer; 1815 int i; 1816 1817 INIT_DEBUGOUT("free_receive_structures: begin"); 1818 1819 if (adapter->rx_buffer_area != NULL) { 1820 rx_buffer = adapter->rx_buffer_area; 1821 for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { 1822 if (rx_buffer->m_head != NULL) 1823 m_freem(rx_buffer->m_head); 1824 rx_buffer->m_head = NULL; 1825 } 1826 } 1827 if (adapter->rx_buffer_area != NULL) { 1828 free(adapter->rx_buffer_area, M_DEVBUF); 1829 adapter->rx_buffer_area = NULL; 1830 } 1831 return; 1832} 1833 1834/********************************************************************* 1835 * 1836 * This routine executes in interrupt context. It replenishes 1837 * the mbufs in the descriptor and sends data which has been 1838 * dma'ed into host memory to upper layer. 1839 * 1840 *********************************************************************/ 1841static void 1842em_process_receive_interrupts(struct adapter * adapter) 1843{ 1844 struct ifnet *ifp; 1845 struct ether_header *eh; 1846 u_int8_t accept_frame = 0; 1847 int i; 1848 1849 /* Pointer to the receive descriptor being examined. */ 1850 struct em_rx_desc *current_desc; 1851 1852 ifp = &adapter->interface_data.ac_if; 1853 i = adapter->next_rx_desc_to_check; 1854 current_desc = &adapter->rx_desc_base[i]; 1855 1856 if (!((current_desc->status) & E1000_RXD_STAT_DD)) { 1857#ifdef DBG_STATS 1858 adapter->no_pkts_avail++; 1859#endif 1860 return; 1861 } 1862 1863 while (current_desc->status & E1000_RXD_STAT_DD) { 1864 struct mbuf *mp = adapter->rx_buffer_area[i].m_head; 1865 int eop, len; 1866 1867 accept_frame = 1; 1868 if (current_desc->status & E1000_RXD_STAT_EOP) { 1869 eop = 1; 1870 len = current_desc->length - ETHER_CRC_LEN; 1871 } else { 1872 eop = 0; 1873 len = current_desc->length; 1874 } 1875 1876 if (current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { 1877 u_int8_t last_byte; 1878 u_int32_t pkt_len = current_desc->length; 1879 1880 if (adapter->fmp != NULL) 1881 pkt_len += adapter->fmp->m_pkthdr.len; 1882 1883 last_byte = *(mtod(mp, caddr_t) + 1884 current_desc->length - 1); 1885 1886 if (TBI_ACCEPT(&adapter->hw, current_desc->status, 1887 current_desc->errors, 1888 pkt_len, last_byte)) { 1889 em_tbi_adjust_stats(&adapter->hw, 1890 &adapter->stats, 1891 pkt_len, 1892 adapter->hw.mac_addr); 1893 len--; 1894 } 1895 else { 1896 accept_frame = 0; 1897 } 1898 } 1899 1900 if (accept_frame) { 1901 1902 if (em_get_buf(i, adapter, NULL) == ENOBUFS) { 1903 adapter->dropped_pkts++; 1904 em_get_buf(i, adapter, mp); 1905 if (adapter->fmp != NULL) 1906 m_freem(adapter->fmp); 1907 adapter->fmp = NULL; 1908 adapter->lmp = NULL; 1909 break; 1910 } 1911 1912 /* Assign correct length to the current fragment */ 1913 mp->m_len = len; 1914 1915 if (adapter->fmp == NULL) { 1916 mp->m_pkthdr.len = len; 1917 adapter->fmp = mp; /* Store the first mbuf */ 1918 adapter->lmp = mp; 1919 } else { 1920 /* Chain mbuf's together */ 1921 mp->m_flags &= ~M_PKTHDR; 1922 adapter->lmp->m_next = mp; 1923 adapter->lmp = adapter->lmp->m_next; 1924 adapter->fmp->m_pkthdr.len += len; 1925 } 1926 1927 if (eop) { 1928 adapter->fmp->m_pkthdr.rcvif = ifp; 1929 1930 eh = mtod(adapter->fmp, struct ether_header *); 1931 1932 /* Remove ethernet header from mbuf */ 1933 m_adj(adapter->fmp, sizeof(struct ether_header)); 1934 em_receive_checksum(adapter, current_desc, 1935 adapter->fmp); 1936 if (current_desc->status & E1000_RXD_STAT_VP) 1937 VLAN_INPUT_TAG(eh, adapter->fmp, 1938 current_desc->special); 1939 else 1940 ether_input(ifp, eh, adapter->fmp); 1941 1942 adapter->fmp = NULL; 1943 adapter->lmp = NULL; 1944 } 1945 } else { 1946 adapter->dropped_pkts++; 1947 em_get_buf(i, adapter, mp); 1948 if (adapter->fmp != NULL) 1949 m_freem(adapter->fmp); 1950 adapter->fmp = NULL; 1951 adapter->lmp = NULL; 1952 } 1953 1954 /* Zero out the receive descriptors status */ 1955 current_desc->status = 0; 1956 1957 /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ 1958 E1000_WRITE_REG(&adapter->hw, RDT, i); 1959 1960 /* Advance our pointers to the next descriptor */ 1961 if (++i == adapter->num_rx_desc) { 1962 i = 0; 1963 current_desc = adapter->rx_desc_base; 1964 } else 1965 current_desc++; 1966 } 1967 adapter->next_rx_desc_to_check = i; 1968 return; 1969} 1970 1971/********************************************************************* 1972 * 1973 * Verify that the hardware indicated that the checksum is valid. 1974 * Inform the stack about the status of checksum so that stack 1975 * doesn't spend time verifying the checksum. 1976 * 1977 *********************************************************************/ 1978static void 1979em_receive_checksum(struct adapter *adapter, 1980 struct em_rx_desc *rx_desc, 1981 struct mbuf *mp) 1982{ 1983 /* 82543 or newer only */ 1984 if ((adapter->hw.mac_type < em_82543) || 1985 /* Ignore Checksum bit is set */ 1986 (rx_desc->status & E1000_RXD_STAT_IXSM)) { 1987 mp->m_pkthdr.csum_flags = 0; 1988 return; 1989 } 1990 1991 if (rx_desc->status & E1000_RXD_STAT_IPCS) { 1992 /* Did it pass? */ 1993 if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { 1994 /* IP Checksum Good */ 1995 mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; 1996 mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; 1997 1998 } else { 1999 mp->m_pkthdr.csum_flags = 0; 2000 } 2001 } 2002 2003 if (rx_desc->status & E1000_RXD_STAT_TCPCS) { 2004 /* Did it pass? */ 2005 if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { 2006 mp->m_pkthdr.csum_flags |= 2007 (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); 2008 mp->m_pkthdr.csum_data = htons(0xffff); 2009 } 2010 } 2011 2012 return; 2013} 2014 2015 2016static void em_enable_vlans(struct adapter *adapter) 2017{ 2018 uint32_t ctrl; 2019 2020 E1000_WRITE_REG(&adapter->hw, VET, QTAG_TYPE); 2021 2022 ctrl = E1000_READ_REG(&adapter->hw, CTRL); 2023 ctrl |= E1000_CTRL_VME; 2024 E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); 2025 2026 return; 2027} 2028 2029static void 2030em_enable_intr(struct adapter * adapter) 2031{ 2032 E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); 2033 return; 2034} 2035 2036static void 2037em_disable_intr(struct adapter *adapter) 2038{ 2039 E1000_WRITE_REG(&adapter->hw, IMC, 2040 (0xffffffff & ~E1000_IMC_RXSEQ)); 2041 return; 2042} 2043 2044void em_write_pci_cfg(struct em_hw *hw, 2045 uint32_t reg, 2046 uint16_t *value) 2047{ 2048 pci_write_config(((struct em_osdep *)hw->back)->dev, reg, 2049 *value, 2); 2050} 2051 2052void em_read_pci_cfg(struct em_hw *hw, uint32_t reg, 2053 uint16_t *value) 2054{ 2055 *value = pci_read_config(((struct em_osdep *)hw->back)->dev, 2056 reg, 2); 2057 return; 2058} 2059 2060uint32_t em_io_read(struct em_hw *hw, uint32_t port) 2061{ 2062 return(inl(port)); 2063} 2064 2065void em_io_write(struct em_hw *hw, uint32_t port, uint32_t value) 2066{ 2067 outl(port, value); 2068 return; 2069} 2070 2071/********************************************************************** 2072 * 2073 * Update the board statistics counters. 2074 * 2075 **********************************************************************/ 2076static void 2077em_update_stats_counters(struct adapter *adapter) 2078{ 2079 struct ifnet *ifp; 2080 2081 adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); 2082 adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); 2083 adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); 2084 adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); 2085 adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); 2086 adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); 2087 adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); 2088 adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); 2089 adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); 2090 adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); 2091 adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); 2092 adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); 2093 adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); 2094 adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); 2095 adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); 2096 adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); 2097 adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); 2098 adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); 2099 adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); 2100 adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); 2101 adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); 2102 adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); 2103 adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); 2104 adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); 2105 adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); 2106 adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); 2107 2108 /* For the 64-bit byte counters the low dword must be read first. */ 2109 /* Both registers clear on the read of the high dword */ 2110 2111 adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); 2112 adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); 2113 adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); 2114 adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); 2115 2116 adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); 2117 adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); 2118 adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); 2119 adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); 2120 adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); 2121 2122 adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); 2123 adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); 2124 adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); 2125 adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); 2126 2127 adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); 2128 adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); 2129 adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); 2130 adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); 2131 adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); 2132 adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); 2133 adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); 2134 adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); 2135 adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); 2136 adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); 2137 2138 if (adapter->hw.mac_type >= em_82543) { 2139 adapter->stats.algnerrc += 2140 E1000_READ_REG(&adapter->hw, ALGNERRC); 2141 adapter->stats.rxerrc += 2142 E1000_READ_REG(&adapter->hw, RXERRC); 2143 adapter->stats.tncrs += 2144 E1000_READ_REG(&adapter->hw, TNCRS); 2145 adapter->stats.cexterr += 2146 E1000_READ_REG(&adapter->hw, CEXTERR); 2147 adapter->stats.tsctc += 2148 E1000_READ_REG(&adapter->hw, TSCTC); 2149 adapter->stats.tsctfc += 2150 E1000_READ_REG(&adapter->hw, TSCTFC); 2151 } 2152 ifp = &adapter->interface_data.ac_if; 2153 2154 /* Fill out the OS statistics structure */ 2155 ifp->if_ipackets = adapter->stats.gprc; 2156 ifp->if_opackets = adapter->stats.gptc; 2157 ifp->if_ibytes = adapter->stats.gorcl; 2158 ifp->if_obytes = adapter->stats.gotcl; 2159 ifp->if_imcasts = adapter->stats.mprc; 2160 ifp->if_collisions = adapter->stats.colc; 2161 2162 /* Rx Errors */ 2163 ifp->if_ierrors = 2164 adapter->dropped_pkts + 2165 adapter->stats.rxerrc + 2166 adapter->stats.crcerrs + 2167 adapter->stats.algnerrc + 2168 adapter->stats.rlec + adapter->stats.rnbc + 2169 adapter->stats.mpc + adapter->stats.cexterr; 2170 2171 /* Tx Errors */ 2172 ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; 2173 2174} 2175 2176 2177/********************************************************************** 2178 * 2179 * This routine is called only when em_display_debug_stats is enabled. 2180 * This routine provides a way to take a look at important statistics 2181 * maintained by the driver and hardware. 2182 * 2183 **********************************************************************/ 2184static void 2185em_print_hw_stats(struct adapter *adapter) 2186{ 2187 int unit = adapter->unit; 2188 2189#ifdef DBG_STATS 2190 printf("em%d: Packets not Avail = %ld\n", unit, 2191 adapter->no_pkts_avail); 2192 printf("em%d: CleanTxInterrupts = %ld\n", unit, 2193 adapter->clean_tx_interrupts); 2194#endif 2195 2196 printf("em%d: Tx Descriptors not Avail = %ld\n", unit, 2197 adapter->no_tx_desc_avail); 2198 printf("em%d: Tx Buffer not avail1 = %ld\n", unit, 2199 adapter->no_tx_buffer_avail1); 2200 printf("em%d: Tx Buffer not avail2 = %ld\n", unit, 2201 adapter->no_tx_buffer_avail2); 2202 printf("em%d: Std Mbuf Failed = %ld\n",unit, 2203 adapter->mbuf_alloc_failed); 2204 printf("em%d: Std Cluster Failed = %ld\n",unit, 2205 adapter->mbuf_cluster_failed); 2206 2207 printf("em%d: Symbol errors = %lld\n", unit, 2208 (long long)adapter->stats.symerrs); 2209 printf("em%d: Sequence errors = %lld\n", unit, 2210 (long long)adapter->stats.sec); 2211 printf("em%d: Defer count = %lld\n", unit, 2212 (long long)adapter->stats.dc); 2213 2214 printf("em%d: Missed Packets = %lld\n", unit, 2215 (long long)adapter->stats.mpc); 2216 printf("em%d: Receive No Buffers = %lld\n", unit, 2217 (long long)adapter->stats.rnbc); 2218 printf("em%d: Receive length errors = %lld\n", unit, 2219 (long long)adapter->stats.rlec); 2220 printf("em%d: Receive errors = %lld\n", unit, 2221 (long long)adapter->stats.rxerrc); 2222 printf("em%d: Crc errors = %lld\n", unit, 2223 (long long)adapter->stats.crcerrs); 2224 printf("em%d: Alignment errors = %lld\n", unit, 2225 (long long)adapter->stats.algnerrc); 2226 printf("em%d: Carrier extension errors = %lld\n", unit, 2227 (long long)adapter->stats.cexterr); 2228 printf("em%d: Driver dropped packets = %ld\n", unit, 2229 adapter->dropped_pkts); 2230 2231 printf("em%d: XON Rcvd = %lld\n", unit, 2232 (long long)adapter->stats.xonrxc); 2233 printf("em%d: XON Xmtd = %lld\n", unit, 2234 (long long)adapter->stats.xontxc); 2235 printf("em%d: XOFF Rcvd = %lld\n", unit, 2236 (long long)adapter->stats.xoffrxc); 2237 printf("em%d: XOFF Xmtd = %lld\n", unit, 2238 (long long)adapter->stats.xofftxc); 2239 2240 printf("em%d: Good Packets Rcvd = %lld\n", unit, 2241 (long long)adapter->stats.gprc); 2242 printf("em%d: Good Packets Xmtd = %lld\n", unit, 2243 (long long)adapter->stats.gptc); 2244 2245 return; 2246} 2247 2248 2249/********************************************************************** 2250 * 2251 * Examine each tx_buffer in the used queue. If the hardware is done 2252 * processing the packet then free associated resources. The 2253 * tx_buffer is put back on the free queue. 2254 * 2255 **********************************************************************/ 2256static void 2257em_clean_transmit_interrupts(struct adapter * adapter) 2258{ 2259 int s; 2260 int i, num_avail; 2261 2262 if (adapter->num_tx_desc_avail == adapter->num_tx_desc) 2263 return; 2264 2265 s = splimp(); 2266#ifdef DBG_STATS 2267 adapter->clean_tx_interrupts++; 2268#endif 2269 /* 2270 * Keep the number of descriptors available in a local 2271 * variable (to ease updates and also check if some descriptors 2272 * have been freed). 2273 * Set i to the oldest used buffer (and descriptor), which is 2274 * i = (next_avail + num_avail) % num_tx_desc 2275 * This is the index of the buffer we look at. 2276 */ 2277 num_avail = adapter->num_tx_desc_avail; 2278 i = adapter->next_avail_tx_desc + num_avail; 2279 if (i >= adapter->num_tx_desc) 2280 i -= adapter->num_tx_desc; 2281 2282 for (;;) { 2283 struct em_tx_buffer *tx_buffer = &adapter->tx_buffer_area[i]; 2284 2285 /* 2286 * Exit from the loop if the buffer is not in use. 2287 * Otherwise locate the last descriptor of the buffer, and 2288 * check its status as reported by the hardware. If the 2289 * hardware is done with it (E1000_TXD_STAT_DD is set) 2290 * we can free the buffer and all of its resources (mbuf 2291 * and descriptors), otherwise we exit from the loop. 2292 */ 2293 if (tx_buffer->num_tx_desc_used == 0) 2294 break; 2295 2296 i += (tx_buffer->num_tx_desc_used - 1); 2297 if (i >= adapter->num_tx_desc) 2298 i -= adapter->num_tx_desc; 2299 2300 if (!(adapter->tx_desc_base[i].upper.fields.status 2301 & E1000_TXD_STAT_DD)) 2302 break; 2303 2304 /* 2305 * Free tx_buffer, mbuf and descriptors. 2306 * Advance index (i) to oldest used tx buffer. 2307 */ 2308 if (tx_buffer->m_head) { 2309 m_freem(tx_buffer->m_head); 2310 tx_buffer->m_head = NULL; 2311 } 2312 num_avail += tx_buffer->num_tx_desc_used; 2313 tx_buffer->num_tx_desc_used = 0; 2314 if (++i == adapter->num_tx_desc) 2315 i = 0; 2316 } 2317 2318 /* 2319 * If we have enough room, clear IFF_OACTIVE to tell the stack 2320 * that it is OK to send packets. 2321 * If there are no pending descriptors, clear the timeout. Otherwise, 2322 * if some descriptors have been freed, restart the timeout. 2323 */ 2324 if (num_avail > TX_CLEANUP_THRESHOLD) { 2325 struct ifnet *ifp = &adapter->interface_data.ac_if; 2326 2327 ifp->if_flags &= ~IFF_OACTIVE; 2328 if (num_avail == adapter->num_tx_desc) 2329 ifp->if_timer = 0; 2330 else if (num_avail == adapter->num_tx_desc_avail) 2331 ifp->if_timer = EM_TX_TIMEOUT; 2332 } 2333 adapter->num_tx_desc_avail = num_avail; 2334 splx(s); 2335 return; 2336} 2337 2338