From eb0ec0898261dbc58c328c818adcd8e8fe66bf17 Mon Sep 17 00:00:00 2001 From: Gleb Smirnoff Date: Wed, 15 Feb 2006 08:39:50 +0000 Subject: [PATCH] - Second style(9) megacleanup. - Rename "adapter" to "sc"/"softc", to be like other drivers. (-13 Kb less source code) --- sys/dev/em/if_em.c | 3072 ++++++++++++++++++-------------------- sys/dev/em/if_em.h | 273 ++-- sys/dev/em/if_em_osdep.h | 2 +- 3 files changed, 1601 insertions(+), 1746 deletions(-) diff --git a/sys/dev/em/if_em.c b/sys/dev/em/if_em.c index 878f9601ca42..4085a34f72da 100644 --- a/sys/dev/em/if_em.c +++ b/sys/dev/em/if_em.c @@ -79,7 +79,7 @@ POSSIBILITY OF SUCH DAMAGE. /********************************************************************* * Set this to one to display debug statistics *********************************************************************/ -int em_display_debug_stats = 0; +int em_display_debug_stats = 0; /********************************************************************* * Driver version @@ -100,64 +100,64 @@ char em_driver_version[] = "Version - 3.2.18"; static em_vendor_info_t em_vendor_info_array[] = { - /* Intel(R) PRO/1000 Network Connection */ - { 0x8086, E1000_DEV_ID_82540EM, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82540EM_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82540EP, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82540EP_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82540EP_LP, PCI_ANY_ID, PCI_ANY_ID, 0}, + /* Intel(R) PRO/1000 Network Connection */ + { 0x8086, E1000_DEV_ID_82540EM, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82540EM_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82540EP, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82540EP_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82540EP_LP, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541EI, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541ER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541ER_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541GI, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541GI_LF, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82541GI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541EI, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541ER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541ER_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541GI, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541GI_LF, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82541GI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82542, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82542, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82543GC_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82543GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82543GC_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82543GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82544EI_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82544EI_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82544GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82544GC_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82544EI_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82544EI_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82544GC_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82544GC_LOM, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82545EM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82545EM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82545GM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82545GM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82545GM_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82545EM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82545EM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82545GM_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82545GM_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82545GM_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546EB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546EB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546GB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546GB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546GB_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546GB_PCIE, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546EB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546EB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546EB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546GB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546GB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546GB_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546GB_PCIE, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82546GB_QUAD_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82547EI, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82547EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82547GI, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82547EI, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82547EI_MOBILE, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82547GI, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82571EB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82571EB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82571EB_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82571EB_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82571EB_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82571EB_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82572EI_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82572EI_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82572EI_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82572EI_COPPER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82572EI_FIBER, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82572EI_SERDES, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82573E, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82573E_IAMT, PCI_ANY_ID, PCI_ANY_ID, 0}, - { 0x8086, E1000_DEV_ID_82573L, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82573E, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82573E_IAMT, PCI_ANY_ID, PCI_ANY_ID, 0}, + { 0x8086, E1000_DEV_ID_82573L, PCI_ANY_ID, PCI_ANY_ID, 0}, - /* required last entry */ - { 0, 0, 0, 0, 0} + /* required last entry */ + { 0, 0, 0, 0, 0} }; /********************************************************************* @@ -171,91 +171,85 @@ static char *em_strings[] = { /********************************************************************* * Function prototypes *********************************************************************/ -static int em_probe(device_t); -static int em_attach(device_t); -static int em_detach(device_t); -static int em_shutdown(device_t); -static int em_suspend(device_t); -static int em_resume(device_t); -static void em_intr(void *); +static int em_probe(device_t); +static int em_attach(device_t); +static int em_detach(device_t); +static int em_shutdown(device_t); +static int em_suspend(device_t); +static int em_resume(device_t); +static void em_intr(void *); #ifndef NO_EM_FASTINTR -static void em_intr_fast(void *); +static void em_intr_fast(void *); #endif -static void em_start(struct ifnet *); -static void em_start_locked(struct ifnet *ifp); -static int em_ioctl(struct ifnet *, u_long, caddr_t); -static void em_watchdog(struct ifnet *); -static void em_init(void *); -static void em_init_locked(struct adapter *); -static void em_stop(void *); -static void em_media_status(struct ifnet *, struct ifmediareq *); -static int em_media_change(struct ifnet *); -static void em_identify_hardware(struct adapter *); -static int em_allocate_pci_resources(struct adapter *); -static int em_allocate_intr(struct adapter *); -static void em_free_intr(struct adapter *); -static void em_free_pci_resources(struct adapter *); -static void em_local_timer(void *); -static int em_hardware_init(struct adapter *); -static void em_setup_interface(device_t, struct adapter *); -static int em_setup_transmit_structures(struct adapter *); -static void em_initialize_transmit_unit(struct adapter *); -static int em_setup_receive_structures(struct adapter *); -static void em_initialize_receive_unit(struct adapter *); -static void em_enable_intr(struct adapter *); -static void em_disable_intr(struct adapter *); -static void em_free_transmit_structures(struct adapter *); -static void em_free_receive_structures(struct adapter *); -static void em_update_stats_counters(struct adapter *); -static void em_clean_transmit_interrupts(struct adapter *); -static int em_allocate_receive_structures(struct adapter *); -static int em_allocate_transmit_structures(struct adapter *); -static int em_process_receive_interrupts(struct adapter *, int); +static void em_start(struct ifnet *); +static void em_start_locked(struct ifnet *ifp); +static int em_ioctl(struct ifnet *, u_long, caddr_t); +static void em_watchdog(struct ifnet *); +static void em_init(void *); +static void em_init_locked(struct em_softc *); +static void em_stop(void *); +static void em_media_status(struct ifnet *, struct ifmediareq *); +static int em_media_change(struct ifnet *); +static void em_identify_hardware(struct em_softc *); +static int em_allocate_pci_resources(struct em_softc *); +static int em_allocate_intr(struct em_softc *); +static void em_free_intr(struct em_softc *); +static void em_free_pci_resources(struct em_softc *); +static void em_local_timer(void *); +static int em_hardware_init(struct em_softc *); +static void em_setup_interface(device_t, struct em_softc *); +static int em_setup_transmit_structures(struct em_softc *); +static void em_initialize_transmit_unit(struct em_softc *); +static int em_setup_receive_structures(struct em_softc *); +static void em_initialize_receive_unit(struct em_softc *); +static void em_enable_intr(struct em_softc *); +static void em_disable_intr(struct em_softc *); +static void em_free_transmit_structures(struct em_softc *); +static void em_free_receive_structures(struct em_softc *); +static void em_update_stats_counters(struct em_softc *); +static void em_txeof(struct em_softc *); +static int em_allocate_receive_structures(struct em_softc *); +static int em_allocate_transmit_structures(struct em_softc *); +static int em_rxeof(struct em_softc *, int); #ifndef __NO_STRICT_ALIGNMENT -static int em_fixup_rx(struct adapter *); +static int em_fixup_rx(struct em_softc *); #endif -static void em_receive_checksum(struct adapter *, - struct em_rx_desc *, - struct mbuf *); -static void em_transmit_checksum_setup(struct adapter *, - struct mbuf *, - u_int32_t *, - u_int32_t *); -static void em_set_promisc(struct adapter *); -static void em_disable_promisc(struct adapter *); -static void em_set_multi(struct adapter *); -static void em_print_hw_stats(struct adapter *); -static void em_print_link_status(struct adapter *); -static int em_get_buf(int i, struct adapter *, - struct mbuf *); -static void em_enable_vlans(struct adapter *); -static void em_disable_vlans(struct adapter *); -static int em_encap(struct adapter *, struct mbuf **); -static void em_smartspeed(struct adapter *); -static int em_82547_fifo_workaround(struct adapter *, int); -static void em_82547_update_fifo_head(struct adapter *, int); -static int em_82547_tx_fifo_reset(struct adapter *); -static void em_82547_move_tail(void *arg); -static void em_82547_move_tail_locked(struct adapter *); -static int em_dma_malloc(struct adapter *, bus_size_t, - struct em_dma_alloc *, int); -static void em_dma_free(struct adapter *, struct em_dma_alloc *); -static void em_print_debug_info(struct adapter *); -static int em_is_valid_ether_addr(u_int8_t *); -static int em_sysctl_stats(SYSCTL_HANDLER_ARGS); -static int em_sysctl_debug_info(SYSCTL_HANDLER_ARGS); -static u_int32_t em_fill_descriptors (bus_addr_t address, - u_int32_t length, - PDESC_ARRAY desc_array); -static int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS); -static void em_add_int_delay_sysctl(struct adapter *, const char *, - const char *, struct em_int_delay_info *, - int, int); +static void em_receive_checksum(struct em_softc *, struct em_rx_desc *, + struct mbuf *); +static void em_transmit_checksum_setup(struct em_softc *, struct mbuf *, + uint32_t *, uint32_t *); +static void em_set_promisc(struct em_softc *); +static void em_disable_promisc(struct em_softc *); +static void em_set_multi(struct em_softc *); +static void em_print_hw_stats(struct em_softc *); +static void em_print_link_status(struct em_softc *); +static int em_get_buf(int i, struct em_softc *, struct mbuf *); +static void em_enable_vlans(struct em_softc *); +static void em_disable_vlans(struct em_softc *); +static int em_encap(struct em_softc *, struct mbuf **); +static void em_smartspeed(struct em_softc *); +static int em_82547_fifo_workaround(struct em_softc *, int); +static void em_82547_update_fifo_head(struct em_softc *, int); +static int em_82547_tx_fifo_reset(struct em_softc *); +static void em_82547_move_tail(void *arg); +static void em_82547_move_tail_locked(struct em_softc *); +static int em_dma_malloc(struct em_softc *, bus_size_t, + struct em_dma_alloc *, int); +static void em_dma_free(struct em_softc *, struct em_dma_alloc *); +static void em_print_debug_info(struct em_softc *); +static int em_is_valid_ether_addr(uint8_t *); +static int em_sysctl_stats(SYSCTL_HANDLER_ARGS); +static int em_sysctl_debug_info(SYSCTL_HANDLER_ARGS); +static uint32_t em_fill_descriptors (bus_addr_t address, uint32_t length, + PDESC_ARRAY desc_array); +static int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS); +static void em_add_int_delay_sysctl(struct em_softc *, const char *, + const char *, struct em_int_delay_info *, int, int); #ifndef NO_EM_FASTINTR -static void em_add_int_process_limit(struct adapter *, const char *, - const char *, int *, int); -static void em_handle_rxtx(void *context, int pending); -static void em_handle_link(void *context, int pending); +static void em_add_int_process_limit(struct em_softc *, const char *, + const char *, int *, int); +static void em_handle_rxtx(void *context, int pending); +static void em_handle_link(void *context, int pending); #endif #ifdef DEVICE_POLLING static poll_handler_t em_poll; @@ -277,7 +271,7 @@ static device_method_t em_methods[] = { }; static driver_t em_driver = { - "em", em_methods, sizeof(struct adapter ), + "em", em_methods, sizeof(struct em_softc), }; static devclass_t em_devclass; @@ -322,19 +316,18 @@ TUNABLE_INT("hw.em.rx_process_limit", &em_rx_process_limit); static int em_probe(device_t dev) { + char adapter_name[60]; + uint16_t pci_vendor_id = 0; + uint16_t pci_device_id = 0; + uint16_t pci_subvendor_id = 0; + uint16_t pci_subdevice_id = 0; em_vendor_info_t *ent; - u_int16_t pci_vendor_id = 0; - u_int16_t pci_device_id = 0; - u_int16_t pci_subvendor_id = 0; - u_int16_t pci_subdevice_id = 0; - char adapter_name[60]; - INIT_DEBUGOUT("em_probe: begin"); pci_vendor_id = pci_get_vendor(dev); if (pci_vendor_id != EM_VENDOR_ID) - return(ENXIO); + return (ENXIO); pci_device_id = pci_get_device(dev); pci_subvendor_id = pci_get_subvendor(dev); @@ -346,20 +339,20 @@ em_probe(device_t dev) (pci_device_id == ent->device_id) && ((pci_subvendor_id == ent->subvendor_id) || - (ent->subvendor_id == PCI_ANY_ID)) && + (ent->subvendor_id == PCI_ANY_ID)) && ((pci_subdevice_id == ent->subdevice_id) || - (ent->subdevice_id == PCI_ANY_ID))) { + (ent->subdevice_id == PCI_ANY_ID))) { sprintf(adapter_name, "%s %s", em_strings[ent->index], em_driver_version); device_set_desc_copy(dev, adapter_name); - return(BUS_PROBE_DEFAULT); + return (BUS_PROBE_DEFAULT); } ent++; } - return(ENXIO); + return (ENXIO); } /********************************************************************* @@ -375,66 +368,57 @@ em_probe(device_t dev) static int em_attach(device_t dev) { - struct adapter * adapter; - int tsize, rsize; + struct em_softc *sc; + int tsize, rsize; int error = 0; INIT_DEBUGOUT("em_attach: begin"); - /* Allocate, clear, and link in our adapter structure */ - if (!(adapter = device_get_softc(dev))) { - printf("em: adapter structure allocation failed\n"); - return(ENOMEM); - } - bzero(adapter, sizeof(struct adapter )); - adapter->dev = dev; - adapter->osdep.dev = dev; - adapter->unit = device_get_unit(dev); - EM_LOCK_INIT(adapter, device_get_nameunit(dev)); + sc = device_get_softc(dev); + sc->dev = sc->osdep.dev = dev; + EM_LOCK_INIT(sc, device_get_nameunit(dev)); /* SYSCTL stuff */ - SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), - SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), - OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW, - (void *)adapter, 0, - em_sysctl_debug_info, "I", "Debug Information"); + SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), + OID_AUTO, "debug_info", CTLTYPE_INT|CTLFLAG_RW, sc, 0, + em_sysctl_debug_info, "I", "Debug Information"); - SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), - SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), - OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW, - (void *)adapter, 0, - em_sysctl_stats, "I", "Statistics"); + SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), + OID_AUTO, "stats", CTLTYPE_INT|CTLFLAG_RW, sc, 0, + em_sysctl_stats, "I", "Statistics"); - callout_init(&adapter->timer, CALLOUT_MPSAFE); - callout_init(&adapter->tx_fifo_timer, CALLOUT_MPSAFE); + callout_init(&sc->timer, CALLOUT_MPSAFE); + callout_init(&sc->tx_fifo_timer, CALLOUT_MPSAFE); /* Determine hardware revision */ - em_identify_hardware(adapter); + em_identify_hardware(sc); /* Set up some sysctls for the tunable interrupt delays */ - em_add_int_delay_sysctl(adapter, "rx_int_delay", - "receive interrupt delay in usecs", &adapter->rx_int_delay, - E1000_REG_OFFSET(&adapter->hw, RDTR), em_rx_int_delay_dflt); - em_add_int_delay_sysctl(adapter, "tx_int_delay", - "transmit interrupt delay in usecs", &adapter->tx_int_delay, - E1000_REG_OFFSET(&adapter->hw, TIDV), em_tx_int_delay_dflt); - if (adapter->hw.mac_type >= em_82540) { - em_add_int_delay_sysctl(adapter, "rx_abs_int_delay", + em_add_int_delay_sysctl(sc, "rx_int_delay", + "receive interrupt delay in usecs", &sc->rx_int_delay, + E1000_REG_OFFSET(&sc->hw, RDTR), em_rx_int_delay_dflt); + em_add_int_delay_sysctl(sc, "tx_int_delay", + "transmit interrupt delay in usecs", &sc->tx_int_delay, + E1000_REG_OFFSET(&sc->hw, TIDV), em_tx_int_delay_dflt); + if (sc->hw.mac_type >= em_82540) { + em_add_int_delay_sysctl(sc, "rx_abs_int_delay", "receive interrupt delay limit in usecs", - &adapter->rx_abs_int_delay, - E1000_REG_OFFSET(&adapter->hw, RADV), + &sc->rx_abs_int_delay, + E1000_REG_OFFSET(&sc->hw, RADV), em_rx_abs_int_delay_dflt); - em_add_int_delay_sysctl(adapter, "tx_abs_int_delay", + em_add_int_delay_sysctl(sc, "tx_abs_int_delay", "transmit interrupt delay limit in usecs", - &adapter->tx_abs_int_delay, - E1000_REG_OFFSET(&adapter->hw, TADV), + &sc->tx_abs_int_delay, + E1000_REG_OFFSET(&sc->hw, TADV), em_tx_abs_int_delay_dflt); } /* Sysctls for limiting the amount of work done in the taskqueue */ #ifndef NO_EM_FASTINTR - em_add_int_process_limit(adapter, "rx_processing_limit", - "max number of rx packets to process", &adapter->rx_process_limit, + em_add_int_process_limit(sc, "rx_processing_limit", + "max number of rx packets to process", &sc->rx_process_limit, em_rx_process_limit); #endif @@ -444,161 +428,148 @@ em_attach(device_t dev) * of E1000_DBA_ALIGN. */ if (((em_txd * sizeof(struct em_tx_desc)) % E1000_DBA_ALIGN) != 0 || - (adapter->hw.mac_type >= em_82544 && em_txd > EM_MAX_TXD) || - (adapter->hw.mac_type < em_82544 && em_txd > EM_MAX_TXD_82543) || + (sc->hw.mac_type >= em_82544 && em_txd > EM_MAX_TXD) || + (sc->hw.mac_type < em_82544 && em_txd > EM_MAX_TXD_82543) || (em_txd < EM_MIN_TXD)) { - printf("em%d: Using %d TX descriptors instead of %d!\n", - adapter->unit, EM_DEFAULT_TXD, em_txd); - adapter->num_tx_desc = EM_DEFAULT_TXD; + device_printf(dev, "Using %d TX descriptors instead of %d!\n", + EM_DEFAULT_TXD, em_txd); + sc->num_tx_desc = EM_DEFAULT_TXD; } else - adapter->num_tx_desc = em_txd; + sc->num_tx_desc = em_txd; if (((em_rxd * sizeof(struct em_rx_desc)) % E1000_DBA_ALIGN) != 0 || - (adapter->hw.mac_type >= em_82544 && em_rxd > EM_MAX_RXD) || - (adapter->hw.mac_type < em_82544 && em_rxd > EM_MAX_RXD_82543) || + (sc->hw.mac_type >= em_82544 && em_rxd > EM_MAX_RXD) || + (sc->hw.mac_type < em_82544 && em_rxd > EM_MAX_RXD_82543) || (em_rxd < EM_MIN_RXD)) { - printf("em%d: Using %d RX descriptors instead of %d!\n", - adapter->unit, EM_DEFAULT_RXD, em_rxd); - adapter->num_rx_desc = EM_DEFAULT_RXD; + device_printf(dev, "Using %d RX descriptors instead of %d!\n", + EM_DEFAULT_RXD, em_rxd); + sc->num_rx_desc = EM_DEFAULT_RXD; } else - adapter->num_rx_desc = em_rxd; + sc->num_rx_desc = em_rxd; - adapter->hw.autoneg = DO_AUTO_NEG; - adapter->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; - adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; - adapter->hw.tbi_compatibility_en = TRUE; - adapter->rx_buffer_len = EM_RXBUFFER_2048; + sc->hw.autoneg = DO_AUTO_NEG; + sc->hw.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; + sc->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; + sc->hw.tbi_compatibility_en = TRUE; + sc->rx_buffer_len = EM_RXBUFFER_2048; - adapter->hw.phy_init_script = 1; - adapter->hw.phy_reset_disable = FALSE; + sc->hw.phy_init_script = 1; + sc->hw.phy_reset_disable = FALSE; #ifndef EM_MASTER_SLAVE - adapter->hw.master_slave = em_ms_hw_default; + sc->hw.master_slave = em_ms_hw_default; #else - adapter->hw.master_slave = EM_MASTER_SLAVE; + sc->hw.master_slave = EM_MASTER_SLAVE; #endif /* * Set the max frame size assuming standard ethernet * sized frames. */ - adapter->hw.max_frame_size = - ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; + sc->hw.max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; - adapter->hw.min_frame_size = - MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; + sc->hw.min_frame_size = MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; /* * This controls when hardware reports transmit completion * status. */ - adapter->hw.report_tx_early = 1; - - if (em_allocate_pci_resources(adapter)) { - printf("em%d: Allocation of PCI resources failed\n", - adapter->unit); - error = ENXIO; - goto err_pci; + sc->hw.report_tx_early = 1; + if (em_allocate_pci_resources(sc)) { + device_printf(dev, "Allocation of PCI resources failed\n"); + error = ENXIO; + goto err_pci; } - /* Initialize eeprom parameters */ - em_init_eeprom_params(&adapter->hw); + em_init_eeprom_params(&sc->hw); - tsize = roundup2(adapter->num_tx_desc * sizeof(struct em_tx_desc), + tsize = roundup2(sc->num_tx_desc * sizeof(struct em_tx_desc), E1000_DBA_ALIGN); /* Allocate Transmit Descriptor ring */ - if (em_dma_malloc(adapter, tsize, &adapter->txdma, BUS_DMA_NOWAIT)) { - printf("em%d: Unable to allocate tx_desc memory\n", - adapter->unit); + if (em_dma_malloc(sc, tsize, &sc->txdma, BUS_DMA_NOWAIT)) { + device_printf(dev, "Unable to allocate tx_desc memory\n"); error = ENOMEM; - goto err_tx_desc; - } - adapter->tx_desc_base = (struct em_tx_desc *) adapter->txdma.dma_vaddr; + goto err_tx_desc; + } + sc->tx_desc_base = (struct em_tx_desc *)sc->txdma.dma_vaddr; - rsize = roundup2(adapter->num_rx_desc * sizeof(struct em_rx_desc), + rsize = roundup2(sc->num_rx_desc * sizeof(struct em_rx_desc), E1000_DBA_ALIGN); /* Allocate Receive Descriptor ring */ - if (em_dma_malloc(adapter, rsize, &adapter->rxdma, BUS_DMA_NOWAIT)) { - printf("em%d: Unable to allocate rx_desc memory\n", - adapter->unit); + if (em_dma_malloc(sc, rsize, &sc->rxdma, BUS_DMA_NOWAIT)) { + device_printf(dev, "Unable to allocate rx_desc memory\n"); error = ENOMEM; - goto err_rx_desc; - } - adapter->rx_desc_base = (struct em_rx_desc *) adapter->rxdma.dma_vaddr; + goto err_rx_desc; + } + sc->rx_desc_base = (struct em_rx_desc *)sc->rxdma.dma_vaddr; /* Initialize the hardware */ - if (em_hardware_init(adapter)) { - printf("em%d: Unable to initialize the hardware\n", - adapter->unit); + if (em_hardware_init(sc)) { + device_printf(dev, "Unable to initialize the hardware\n"); error = EIO; - goto err_hw_init; + goto err_hw_init; } /* Copy the permanent MAC address out of the EEPROM */ - if (em_read_mac_addr(&adapter->hw) < 0) { - printf("em%d: EEPROM read error while reading mac address\n", - adapter->unit); + if (em_read_mac_addr(&sc->hw) < 0) { + device_printf(dev, "EEPROM read error while reading MAC" + " address\n"); error = EIO; - goto err_mac_addr; + goto err_hw_init; } - if (!em_is_valid_ether_addr(adapter->hw.mac_addr)) { - printf("em%d: Invalid mac address\n", adapter->unit); - error = EIO; - goto err_mac_addr; - } + if (!em_is_valid_ether_addr(sc->hw.mac_addr)) { + device_printf(dev, "Invalid MAC address\n"); + error = EIO; + goto err_hw_init; + } /* Setup OS specific network interface */ - em_setup_interface(dev, adapter); + em_setup_interface(dev, sc); - em_allocate_intr(adapter); + em_allocate_intr(sc); /* Initialize statistics */ - em_clear_hw_cntrs(&adapter->hw); - em_update_stats_counters(adapter); - adapter->hw.get_link_status = 1; - em_check_for_link(&adapter->hw); + em_clear_hw_cntrs(&sc->hw); + em_update_stats_counters(sc); + sc->hw.get_link_status = 1; + em_check_for_link(&sc->hw); if (bootverbose) { /* Print the link status */ - if (adapter->link_active == 1) { - em_get_speed_and_duplex(&adapter->hw, - &adapter->link_speed, &adapter->link_duplex); - printf("em%d: Speed:%d Mbps Duplex:%s\n", - adapter->unit, - adapter->link_speed, - adapter->link_duplex == FULL_DUPLEX ? "Full" : - "Half"); + if (sc->link_active == 1) { + em_get_speed_and_duplex(&sc->hw, &sc->link_speed, + &sc->link_duplex); + device_printf(dev, "Speed:%d Mbps Duplex:%s\n", + sc->link_speed, sc->link_duplex == FULL_DUPLEX ? + "Full" : "Half"); } else - printf("em%d: Speed:N/A Duplex:N/A\n", - adapter->unit); + device_printf(dev, "Speed:N/A Duplex:N/A\n"); } /* Identify 82544 on PCIX */ - em_get_bus_info(&adapter->hw); - if(adapter->hw.bus_type == em_bus_type_pcix && - adapter->hw.mac_type == em_82544) { - adapter->pcix_82544 = TRUE; - } - else { - adapter->pcix_82544 = FALSE; - } - INIT_DEBUGOUT("em_attach: end"); - return(0); + em_get_bus_info(&sc->hw); + if(sc->hw.bus_type == em_bus_type_pcix && sc->hw.mac_type == em_82544) + sc->pcix_82544 = TRUE; + else + sc->pcix_82544 = FALSE; + + INIT_DEBUGOUT("em_attach: end"); + + return (0); -err_mac_addr: err_hw_init: - em_dma_free(adapter, &adapter->rxdma); + em_dma_free(sc, &sc->rxdma); err_rx_desc: - em_dma_free(adapter, &adapter->txdma); + em_dma_free(sc, &sc->txdma); err_tx_desc: err_pci: - em_free_intr(adapter); - em_free_pci_resources(adapter); - EM_LOCK_DESTROY(adapter); - return(error); + em_free_intr(sc); + em_free_pci_resources(sc); + EM_LOCK_DESTROY(sc); + return (error); } /********************************************************************* @@ -614,8 +585,8 @@ em_attach(device_t dev) static int em_detach(device_t dev) { - struct adapter * adapter = device_get_softc(dev); - struct ifnet *ifp = adapter->ifp; + struct em_softc *sc = device_get_softc(dev); + struct ifnet *ifp = sc->ifp; INIT_DEBUGOUT("em_detach: begin"); @@ -624,33 +595,33 @@ em_detach(device_t dev) ether_poll_deregister(ifp); #endif - em_free_intr(adapter); - EM_LOCK(adapter); - adapter->in_detach = 1; - em_stop(adapter); - em_phy_hw_reset(&adapter->hw); - EM_UNLOCK(adapter); - ether_ifdetach(adapter->ifp); + em_free_intr(sc); + EM_LOCK(sc); + sc->in_detach = 1; + em_stop(sc); + em_phy_hw_reset(&sc->hw); + EM_UNLOCK(sc); + ether_ifdetach(sc->ifp); - em_free_pci_resources(adapter); + em_free_pci_resources(sc); bus_generic_detach(dev); if_free(ifp); /* Free Transmit Descriptor ring */ - if (adapter->tx_desc_base) { - em_dma_free(adapter, &adapter->txdma); - adapter->tx_desc_base = NULL; - } + if (sc->tx_desc_base) { + em_dma_free(sc, &sc->txdma); + sc->tx_desc_base = NULL; + } - /* Free Receive Descriptor ring */ - if (adapter->rx_desc_base) { - em_dma_free(adapter, &adapter->rxdma); - adapter->rx_desc_base = NULL; - } + /* Free Receive Descriptor ring */ + if (sc->rx_desc_base) { + em_dma_free(sc, &sc->rxdma); + sc->rx_desc_base = NULL; + } - EM_LOCK_DESTROY(adapter); + EM_LOCK_DESTROY(sc); - return(0); + return (0); } /********************************************************************* @@ -662,11 +633,11 @@ em_detach(device_t dev) static int em_shutdown(device_t dev) { - struct adapter *adapter = device_get_softc(dev); - EM_LOCK(adapter); - em_stop(adapter); - EM_UNLOCK(adapter); - return(0); + struct em_softc *sc = device_get_softc(dev); + EM_LOCK(sc); + em_stop(sc); + EM_UNLOCK(sc); + return (0); } /* @@ -675,11 +646,11 @@ em_shutdown(device_t dev) static int em_suspend(device_t dev) { - struct adapter *adapter = device_get_softc(dev); + struct em_softc *sc = device_get_softc(dev); - EM_LOCK(adapter); - em_stop(adapter); - EM_UNLOCK(adapter); + EM_LOCK(sc); + em_stop(sc); + EM_UNLOCK(sc); return bus_generic_suspend(dev); } @@ -687,15 +658,15 @@ em_suspend(device_t dev) static int em_resume(device_t dev) { - struct adapter *adapter = device_get_softc(dev); - struct ifnet *ifp = adapter->ifp; + struct em_softc *sc = device_get_softc(dev); + struct ifnet *ifp = sc->ifp; - EM_LOCK(adapter); - em_init_locked(adapter); + EM_LOCK(sc); + em_init_locked(sc); if ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING)) em_start_locked(ifp); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); return bus_generic_resume(dev); } @@ -714,12 +685,12 @@ em_resume(device_t dev) static void em_start_locked(struct ifnet *ifp) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; struct mbuf *m_head; - mtx_assert(&adapter->mtx, MA_OWNED); + EM_LOCK_ASSERT(sc); - if (!adapter->link_active) + if (!sc->link_active) return; while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) { @@ -731,7 +702,7 @@ em_start_locked(struct ifnet *ifp) * em_encap() can modify our pointer, and or make it NULL on * failure. In that event, we can't requeue. */ - if (em_encap(adapter, &m_head)) { + if (em_encap(sc, &m_head)) { if (m_head == NULL) break; ifp->if_drv_flags |= IFF_DRV_OACTIVE; @@ -750,12 +721,12 @@ em_start_locked(struct ifnet *ifp) static void em_start(struct ifnet *ifp) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; - EM_LOCK(adapter); + EM_LOCK(sc); if (ifp->if_drv_flags & IFF_DRV_RUNNING) em_start_locked(ifp); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } /********************************************************************* @@ -770,12 +741,12 @@ em_start(struct ifnet *ifp) static int em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; struct ifreq *ifr = (struct ifreq *)data; int error = 0; - if (adapter->in_detach) - return(error); + if (sc->in_detach) + return (error); switch (command) { case SIOCSIFADDR: @@ -789,7 +760,7 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFMTU (Set Interface MTU)"); - switch (adapter->hw.mac_type) { + switch (sc->hw.mac_type) { case em_82571: case em_82572: max_frame_size = 10500; @@ -807,52 +778,52 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) break; } - EM_LOCK(adapter); + EM_LOCK(sc); ifp->if_mtu = ifr->ifr_mtu; - adapter->hw.max_frame_size = + sc->hw.max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; - em_init_locked(adapter); - EM_UNLOCK(adapter); + em_init_locked(sc); + EM_UNLOCK(sc); break; } case SIOCSIFFLAGS: IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFFLAGS (Set Interface Flags)"); - EM_LOCK(adapter); + EM_LOCK(sc); if (ifp->if_flags & IFF_UP) { if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { - em_init_locked(adapter); + em_init_locked(sc); } - em_disable_promisc(adapter); - em_set_promisc(adapter); + em_disable_promisc(sc); + em_set_promisc(sc); } else { if (ifp->if_drv_flags & IFF_DRV_RUNNING) { - em_stop(adapter); + em_stop(sc); } } - EM_UNLOCK(adapter); + EM_UNLOCK(sc); break; case SIOCADDMULTI: case SIOCDELMULTI: IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); if (ifp->if_drv_flags & IFF_DRV_RUNNING) { - EM_LOCK(adapter); - em_disable_intr(adapter); - em_set_multi(adapter); - if (adapter->hw.mac_type == em_82542_rev2_0) { - em_initialize_receive_unit(adapter); + EM_LOCK(sc); + em_disable_intr(sc); + em_set_multi(sc); + if (sc->hw.mac_type == em_82542_rev2_0) { + em_initialize_receive_unit(sc); } #ifdef DEVICE_POLLING - if (!(ifp->if_capenable & IFCAP_POLLING)) + if (!(ifp->if_capenable & IFCAP_POLLING)) #endif - em_enable_intr(adapter); - EM_UNLOCK(adapter); + em_enable_intr(sc); + EM_UNLOCK(sc); } break; case SIOCSIFMEDIA: case SIOCGIFMEDIA: IOCTL_DEBUGOUT("ioctl rcv'd: SIOCxIFMEDIA (Get/Set Interface Media)"); - error = ifmedia_ioctl(ifp, ifr, &adapter->media, command); + error = ifmedia_ioctl(ifp, ifr, &sc->media, command); break; case SIOCSIFCAP: { @@ -866,18 +837,18 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) if (ifr->ifr_reqcap & IFCAP_POLLING) { error = ether_poll_register(em_poll, ifp); if (error) - return(error); - EM_LOCK(adapter); - em_disable_intr(adapter); + return (error); + EM_LOCK(sc); + em_disable_intr(sc); ifp->if_capenable |= IFCAP_POLLING; - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } else { error = ether_poll_deregister(ifp); /* Enable interrupt even in error case */ - EM_LOCK(adapter); - em_enable_intr(adapter); + EM_LOCK(sc); + em_enable_intr(sc); ifp->if_capenable &= ~IFCAP_POLLING; - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } } #endif @@ -890,7 +861,7 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) reinit = 1; } if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING)) - em_init(adapter); + em_init(sc); VLAN_CAPABILITIES(ifp); break; } @@ -899,7 +870,7 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) error = EINVAL; } - return(error); + return (error); } /********************************************************************* @@ -912,26 +883,26 @@ em_ioctl(struct ifnet *ifp, u_long command, caddr_t data) static void em_watchdog(struct ifnet *ifp) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; - EM_LOCK(adapter); + EM_LOCK(sc); /* If we are in this routine because of pause frames, then * don't reset the hardware. */ - if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_TXOFF) { + if (E1000_READ_REG(&sc->hw, STATUS) & E1000_STATUS_TXOFF) { ifp->if_timer = EM_TX_TIMEOUT; - EM_UNLOCK(adapter); + EM_UNLOCK(sc); return; } - if (!em_check_for_link(&adapter->hw)) - printf("em%d: watchdog timeout -- resetting\n", adapter->unit); + if (em_check_for_link(&sc->hw) == 0) + device_printf(sc->dev, "watchdog timeout -- resetting\n"); ifp->if_drv_flags &= ~IFF_DRV_RUNNING; - adapter->watchdog_events++; + sc->watchdog_events++; - em_init_locked(adapter); - EM_UNLOCK(adapter); + em_init_locked(sc); + EM_UNLOCK(sc); } /********************************************************************* @@ -946,34 +917,33 @@ em_watchdog(struct ifnet *ifp) **********************************************************************/ static void -em_init_locked(struct adapter * adapter) +em_init_locked(struct em_softc *sc) { - struct ifnet *ifp; - + struct ifnet *ifp = sc->ifp; + device_t dev = sc->dev; uint32_t pba; - ifp = adapter->ifp; INIT_DEBUGOUT("em_init: begin"); - mtx_assert(&adapter->mtx, MA_OWNED); + EM_LOCK_ASSERT(sc); - em_stop(adapter); + em_stop(sc); /* * Packet Buffer Allocation (PBA) * Writing PBA sets the receive portion of the buffer * the remainder is used for the transmit buffer. */ - switch (adapter->hw.mac_type) { + switch (sc->hw.mac_type) { case em_82547: case em_82547_rev_2: /* 82547: Total Packet Buffer is 40K */ - if (adapter->hw.max_frame_size > EM_RXBUFFER_8192) + if (sc->hw.max_frame_size > EM_RXBUFFER_8192) pba = E1000_PBA_22K; /* 22K for Rx, 18K for Tx */ else pba = E1000_PBA_30K; /* 30K for Rx, 10K for Tx */ - adapter->tx_fifo_head = 0; - adapter->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT; - adapter->tx_fifo_size = (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT; + sc->tx_fifo_head = 0; + sc->tx_head_addr = pba << EM_TX_HEAD_ADDR_SHIFT; + sc->tx_fifo_size = (E1000_PBA_40K - pba) << EM_PBA_BYTES_SHIFT; break; case em_82571: /* 82571: Total Packet Buffer is 48K */ case em_82572: /* 82572: Total Packet Buffer is 48K */ @@ -985,91 +955,84 @@ em_init_locked(struct adapter * adapter) break; default: /* Devices before 82547 had a Packet Buffer of 64K. */ - if(adapter->hw.max_frame_size > EM_RXBUFFER_8192) + if(sc->hw.max_frame_size > EM_RXBUFFER_8192) pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */ else pba = E1000_PBA_48K; /* 48K for Rx, 16K for Tx */ } INIT_DEBUGOUT1("em_init: pba=%dK",pba); - E1000_WRITE_REG(&adapter->hw, PBA, pba); + E1000_WRITE_REG(&sc->hw, PBA, pba); /* Get the latest mac address, User can use a LAA */ - bcopy(IF_LLADDR(adapter->ifp), adapter->hw.mac_addr, - ETHER_ADDR_LEN); + bcopy(IF_LLADDR(sc->ifp), sc->hw.mac_addr, ETHER_ADDR_LEN); /* Initialize the hardware */ - if (em_hardware_init(adapter)) { - printf("em%d: Unable to initialize the hardware\n", - adapter->unit); + if (em_hardware_init(sc)) { + device_printf(dev, "Unable to initialize the hardware\n"); return; } if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) - em_enable_vlans(adapter); + em_enable_vlans(sc); /* Prepare transmit descriptors and buffers */ - if (em_setup_transmit_structures(adapter)) { - printf("em%d: Could not setup transmit structures\n", - adapter->unit); - em_stop(adapter); + if (em_setup_transmit_structures(sc)) { + device_printf(dev, "Could not setup transmit structures\n"); + em_stop(sc); return; } - em_initialize_transmit_unit(adapter); + em_initialize_transmit_unit(sc); /* Setup Multicast table */ - em_set_multi(adapter); + em_set_multi(sc); /* Prepare receive descriptors and buffers */ - if (em_setup_receive_structures(adapter)) { - printf("em%d: Could not setup receive structures\n", - adapter->unit); - em_stop(adapter); + if (em_setup_receive_structures(sc)) { + device_printf(dev, "Could not setup receive structures\n"); + em_stop(sc); return; } - em_initialize_receive_unit(adapter); + em_initialize_receive_unit(sc); /* Don't loose promiscuous settings */ - em_set_promisc(adapter); + em_set_promisc(sc); ifp->if_drv_flags |= IFF_DRV_RUNNING; ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; - if (adapter->hw.mac_type >= em_82543) { + if (sc->hw.mac_type >= em_82543) { if (ifp->if_capenable & IFCAP_TXCSUM) ifp->if_hwassist = EM_CHECKSUM_FEATURES; else ifp->if_hwassist = 0; } - callout_reset(&adapter->timer, hz, em_local_timer, adapter); - em_clear_hw_cntrs(&adapter->hw); + callout_reset(&sc->timer, hz, em_local_timer, sc); + em_clear_hw_cntrs(&sc->hw); #ifdef DEVICE_POLLING - /* - * Only enable interrupts if we are not polling, make sure - * they are off otherwise. - */ - if (ifp->if_capenable & IFCAP_POLLING) - em_disable_intr(adapter); - else + /* + * Only enable interrupts if we are not polling, make sure + * they are off otherwise. + */ + if (ifp->if_capenable & IFCAP_POLLING) + em_disable_intr(sc); + else #endif /* DEVICE_POLLING */ - em_enable_intr(adapter); + em_enable_intr(sc); /* Don't reset the phy next time init gets called */ - adapter->hw.phy_reset_disable = TRUE; - - return; + sc->hw.phy_reset_disable = TRUE; } static void em_init(void *arg) { - struct adapter * adapter = arg; + struct em_softc *sc = arg; - EM_LOCK(adapter); - em_init_locked(adapter); - EM_UNLOCK(adapter); - return; + EM_LOCK(sc); + em_init_locked(sc); + EM_UNLOCK(sc); } @@ -1077,24 +1040,23 @@ em_init(void *arg) static void em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; uint32_t reg_icr; - mtx_assert(&adapter->mtx, MA_OWNED); + EM_LOCK_ASSERT(sc); if (cmd == POLL_AND_CHECK_STATUS) { - reg_icr = E1000_READ_REG(&adapter->hw, ICR); + reg_icr = E1000_READ_REG(&sc->hw, ICR); if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { - callout_stop(&adapter->timer); - adapter->hw.get_link_status = 1; - em_check_for_link(&adapter->hw); - em_print_link_status(adapter); - callout_reset(&adapter->timer, hz, em_local_timer, - adapter); + callout_stop(&sc->timer); + sc->hw.get_link_status = 1; + em_check_for_link(&sc->hw); + em_print_link_status(sc); + callout_reset(&sc->timer, hz, em_local_timer, sc); } - } - em_process_receive_interrupts(adapter, count); - em_clean_transmit_interrupts(adapter); + } + em_rxeof(sc, count); + em_txeof(sc); if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp); @@ -1103,12 +1065,12 @@ em_poll_locked(struct ifnet *ifp, enum poll_cmd cmd, int count) static void em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) { - struct adapter *adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; - EM_LOCK(adapter); + EM_LOCK(sc); if (ifp->if_drv_flags & IFF_DRV_RUNNING) em_poll_locked(ifp, cmd, count); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } #endif /* DEVICE_POLLING */ @@ -1116,48 +1078,46 @@ em_poll(struct ifnet *ifp, enum poll_cmd cmd, int count) static void em_handle_link(void *context, int pending) { - struct adapter *adapter = context; + struct em_softc *sc = context; struct ifnet *ifp; - ifp = adapter->ifp; + ifp = sc->ifp; - EM_LOCK(adapter); + EM_LOCK(sc); - callout_stop(&adapter->timer); - adapter->hw.get_link_status = 1; - em_check_for_link(&adapter->hw); - em_print_link_status(adapter); - callout_reset(&adapter->timer, hz, em_local_timer, - adapter); - EM_UNLOCK(adapter); + callout_stop(&sc->timer); + sc->hw.get_link_status = 1; + em_check_for_link(&sc->hw); + em_print_link_status(sc); + callout_reset(&sc->timer, hz, em_local_timer, sc); + EM_UNLOCK(sc); } static void em_handle_rxtx(void *context, int pending) { - struct adapter *adapter = context; + struct em_softc *sc = context; struct ifnet *ifp; NET_LOCK_GIANT(); - ifp = adapter->ifp; + ifp = sc->ifp; /* * TODO: * It should be possible to run the tx clean loop without the lock. */ if (ifp->if_drv_flags & IFF_DRV_RUNNING) { - if (em_process_receive_interrupts(adapter, - adapter->rx_process_limit) != 0) - taskqueue_enqueue(adapter->tq, &adapter->rxtx_task); - EM_LOCK(adapter); - em_clean_transmit_interrupts(adapter); + if (em_rxeof(sc, sc->rx_process_limit) != 0) + taskqueue_enqueue(sc->tq, &sc->rxtx_task); + EM_LOCK(sc); + em_txeof(sc); if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } - em_enable_intr(adapter); + em_enable_intr(sc); NET_UNLOCK_GIANT(); } #endif @@ -1171,19 +1131,18 @@ em_handle_rxtx(void *context, int pending) static void em_intr_fast(void *arg) { - struct adapter *adapter = arg; + struct em_softc *sc = arg; struct ifnet *ifp; uint32_t reg_icr; - ifp = adapter->ifp; + ifp = sc->ifp; #ifdef DEVICE_POLLING - if (ifp->if_capenable & IFCAP_POLLING) { + if (ifp->if_capenable & IFCAP_POLLING) return; - } #endif /* DEVICE_POLLING */ - reg_icr = E1000_READ_REG(&adapter->hw, ICR); + reg_icr = E1000_READ_REG(&sc->hw, ICR); /* Hot eject? */ if (reg_icr == 0xffffffff) @@ -1197,7 +1156,7 @@ em_intr_fast(void *arg) * Starting with the 82571 chip, bit 31 should be used to * determine whether the interrupt belongs to us. */ - if (adapter->hw.mac_type >= em_82571 && + if (sc->hw.mac_type >= em_82571 && (reg_icr & E1000_ICR_INT_ASSERTED) == 0) return; @@ -1206,42 +1165,40 @@ em_intr_fast(void *arg) * cheap, just assume that it is needed. This also works around the * MSI message reordering errata on certain systems. */ - em_disable_intr(adapter); - taskqueue_enqueue(adapter->tq, &adapter->rxtx_task); + em_disable_intr(sc); + taskqueue_enqueue(sc->tq, &sc->rxtx_task); /* Link status change */ if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) - taskqueue_enqueue(taskqueue_fast, &adapter->link_task); + taskqueue_enqueue(taskqueue_fast, &sc->link_task); - if (reg_icr & E1000_ICR_RXO) { - adapter->rx_overruns++; - } - return; + if (reg_icr & E1000_ICR_RXO) + sc->rx_overruns++; } #endif static void em_intr(void *arg) { - struct adapter *adapter = arg; + struct em_softc *sc = arg; struct ifnet *ifp; uint32_t reg_icr; int wantinit = 0; - EM_LOCK(adapter); + EM_LOCK(sc); - ifp = adapter->ifp; + ifp = sc->ifp; #ifdef DEVICE_POLLING if (ifp->if_capenable & IFCAP_POLLING) { - EM_UNLOCK(adapter); + EM_UNLOCK(sc); return; } #endif for (;;) { - reg_icr = E1000_READ_REG(&adapter->hw, ICR); - if (adapter->hw.mac_type >= em_82571 && + reg_icr = E1000_READ_REG(&sc->hw, ICR); + if (sc->hw.mac_type >= em_82571 && (reg_icr & E1000_ICR_INT_ASSERTED) == 0) break; else if (reg_icr == 0) @@ -1257,34 +1214,33 @@ em_intr(void *arg) break; if (ifp->if_drv_flags & IFF_DRV_RUNNING) { - em_process_receive_interrupts(adapter, -1); - em_clean_transmit_interrupts(adapter); + em_rxeof(sc, -1); + em_txeof(sc); } /* Link status change */ if (reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { - callout_stop(&adapter->timer); - adapter->hw.get_link_status = 1; - em_check_for_link(&adapter->hw); - em_print_link_status(adapter); - callout_reset(&adapter->timer, hz, em_local_timer, - adapter); + callout_stop(&sc->timer); + sc->hw.get_link_status = 1; + em_check_for_link(&sc->hw); + em_print_link_status(sc); + callout_reset(&sc->timer, hz, em_local_timer, sc); } if (reg_icr & E1000_ICR_RXO) { - adapter->rx_overruns++; + sc->rx_overruns++; wantinit = 1; } } #if 0 if (wantinit) - em_init_locked(adapter); + em_init_locked(sc); #endif if (ifp->if_drv_flags & IFF_DRV_RUNNING && !IFQ_DRV_IS_EMPTY(&ifp->if_snd)) em_start_locked(ifp); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } /********************************************************************* @@ -1298,38 +1254,37 @@ em_intr(void *arg) static void em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) { - struct adapter * adapter = ifp->if_softc; + struct em_softc *sc = ifp->if_softc; INIT_DEBUGOUT("em_media_status: begin"); - em_check_for_link(&adapter->hw); - if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { - if (adapter->link_active == 0) { - em_get_speed_and_duplex(&adapter->hw, - &adapter->link_speed, - &adapter->link_duplex); - adapter->link_active = 1; + em_check_for_link(&sc->hw); + if (E1000_READ_REG(&sc->hw, STATUS) & E1000_STATUS_LU) { + if (sc->link_active == 0) { + em_get_speed_and_duplex(&sc->hw, &sc->link_speed, + &sc->link_duplex); + sc->link_active = 1; } } else { - if (adapter->link_active == 1) { - adapter->link_speed = 0; - adapter->link_duplex = 0; - adapter->link_active = 0; + if (sc->link_active == 1) { + sc->link_speed = 0; + sc->link_duplex = 0; + sc->link_active = 0; } } ifmr->ifm_status = IFM_AVALID; ifmr->ifm_active = IFM_ETHER; - if (!adapter->link_active) + if (!sc->link_active) return; ifmr->ifm_status |= IFM_ACTIVE; - if (adapter->hw.media_type == em_media_type_fiber) { + if (sc->hw.media_type == em_media_type_fiber) { ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; } else { - switch (adapter->link_speed) { + switch (sc->link_speed) { case 10: ifmr->ifm_active |= IFM_10_T; break; @@ -1340,12 +1295,11 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) ifmr->ifm_active |= IFM_1000_T; break; } - if (adapter->link_duplex == FULL_DUPLEX) + if (sc->link_duplex == FULL_DUPLEX) ifmr->ifm_active |= IFM_FDX; else ifmr->ifm_active |= IFM_HDX; } - return; } /********************************************************************* @@ -1359,52 +1313,52 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) static int em_media_change(struct ifnet *ifp) { - struct adapter * adapter = ifp->if_softc; - struct ifmedia *ifm = &adapter->media; + struct em_softc *sc = ifp->if_softc; + struct ifmedia *ifm = &sc->media; INIT_DEBUGOUT("em_media_change: begin"); if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER) - return(EINVAL); + return (EINVAL); switch (IFM_SUBTYPE(ifm->ifm_media)) { case IFM_AUTO: - adapter->hw.autoneg = DO_AUTO_NEG; - adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; + sc->hw.autoneg = DO_AUTO_NEG; + sc->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; break; case IFM_1000_SX: case IFM_1000_T: - adapter->hw.autoneg = DO_AUTO_NEG; - adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; + sc->hw.autoneg = DO_AUTO_NEG; + sc->hw.autoneg_advertised = ADVERTISE_1000_FULL; break; case IFM_100_TX: - adapter->hw.autoneg = FALSE; - adapter->hw.autoneg_advertised = 0; + sc->hw.autoneg = FALSE; + sc->hw.autoneg_advertised = 0; if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) - adapter->hw.forced_speed_duplex = em_100_full; + sc->hw.forced_speed_duplex = em_100_full; else - adapter->hw.forced_speed_duplex = em_100_half; + sc->hw.forced_speed_duplex = em_100_half; break; case IFM_10_T: - adapter->hw.autoneg = FALSE; - adapter->hw.autoneg_advertised = 0; + sc->hw.autoneg = FALSE; + sc->hw.autoneg_advertised = 0; if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) - adapter->hw.forced_speed_duplex = em_10_full; + sc->hw.forced_speed_duplex = em_10_full; else - adapter->hw.forced_speed_duplex = em_10_half; + sc->hw.forced_speed_duplex = em_10_half; break; default: - printf("em%d: Unsupported media type\n", adapter->unit); + device_printf(sc->dev, "Unsupported media type\n"); } /* As the speed/duplex settings my have changed we need to * reset the PHY. */ - adapter->hw.phy_reset_disable = FALSE; + sc->hw.phy_reset_disable = FALSE; - em_init(adapter); + em_init(sc); - return(0); + return (0); } /********************************************************************* @@ -1414,15 +1368,15 @@ em_media_change(struct ifnet *ifp) * return 0 on success, positive on failure **********************************************************************/ static int -em_encap(struct adapter *adapter, struct mbuf **m_headp) +em_encap(struct em_softc *sc, struct mbuf **m_headp) { - struct ifnet *ifp = adapter->ifp; + struct ifnet *ifp = sc->ifp; bus_dma_segment_t segs[EM_MAX_SCATTER]; bus_dmamap_t map; - struct em_buffer *tx_buffer; - struct em_tx_desc *current_tx_desc; + struct em_buffer *tx_buffer; + struct em_tx_desc *current_tx_desc; struct mbuf *m_head; - struct m_tag *mtag; + struct m_tag *mtag; uint32_t txd_upper, txd_lower, txd_used, txd_saved; int nsegs, i, j; int error = 0; @@ -1435,37 +1389,36 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) * Force a cleanup if number of TX descriptors * available hits the threshold. */ - if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { - em_clean_transmit_interrupts(adapter); - if (adapter->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { - adapter->no_tx_desc_avail1++; - return(ENOBUFS); + if (sc->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { + em_txeof(sc); + if (sc->num_tx_desc_avail <= EM_TX_CLEANUP_THRESHOLD) { + sc->no_tx_desc_avail1++; + return (ENOBUFS); } } /* * Map the packet for DMA. */ - tx_buffer = &adapter->tx_buffer_area[adapter->next_avail_tx_desc]; - error = bus_dmamap_load_mbuf_sg(adapter->txtag, tx_buffer->map, m_head, + tx_buffer = &sc->tx_buffer_area[sc->next_avail_tx_desc]; + error = bus_dmamap_load_mbuf_sg(sc->txtag, tx_buffer->map, m_head, segs, &nsegs, BUS_DMA_NOWAIT); map = tx_buffer->map; if (error != 0) { - adapter->no_tx_dma_setup++; + sc->no_tx_dma_setup++; return (error); } KASSERT(nsegs != 0, ("em_encap: empty packet")); - if (nsegs > adapter->num_tx_desc_avail) { - adapter->no_tx_desc_avail2++; + if (nsegs > sc->num_tx_desc_avail) { + sc->no_tx_desc_avail2++; error = ENOBUFS; goto encap_fail; } - if (ifp->if_hwassist > 0) { - em_transmit_checksum_setup(adapter, m_head, &txd_upper, - &txd_lower); - } else + if (ifp->if_hwassist > 0) + em_transmit_checksum_setup(sc, m_head, &txd_upper, &txd_lower); + else txd_upper = txd_lower = 0; /* Find out if we are in vlan mode. */ @@ -1477,7 +1430,7 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) * encapsulation in the driver, since it will have come down from the * VLAN layer with a tag instead of a VLAN header. */ - if (mtag != NULL && adapter->em_insert_vlan_header) { + if (mtag != NULL && sc->em_insert_vlan_header) { struct ether_vlan_header *evl; struct ether_header eh; @@ -1510,14 +1463,14 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) *m_headp = m_head; } - i = adapter->next_avail_tx_desc; - if (adapter->pcix_82544) { + i = sc->next_avail_tx_desc; + if (sc->pcix_82544) { txd_saved = i; txd_used = 0; } for (j = 0; j < nsegs; j++) { /* If adapter is 82544 and on PCIX bus. */ - if(adapter->pcix_82544) { + if(sc->pcix_82544) { DESC_ARRAY desc_array; uint32_t array_elements, counter; @@ -1528,47 +1481,47 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) array_elements = em_fill_descriptors(segs[j].ds_addr, segs[j].ds_len, &desc_array); for (counter = 0; counter < array_elements; counter++) { - if (txd_used == adapter->num_tx_desc_avail) { - adapter->next_avail_tx_desc = txd_saved; - adapter->no_tx_desc_avail2++; + if (txd_used == sc->num_tx_desc_avail) { + sc->next_avail_tx_desc = txd_saved; + sc->no_tx_desc_avail2++; error = ENOBUFS; goto encap_fail; } - tx_buffer = &adapter->tx_buffer_area[i]; - current_tx_desc = &adapter->tx_desc_base[i]; + tx_buffer = &sc->tx_buffer_area[i]; + current_tx_desc = &sc->tx_desc_base[i]; current_tx_desc->buffer_addr = htole64( desc_array.descriptor[counter].address); current_tx_desc->lower.data = htole32( - (adapter->txd_cmd | txd_lower | + (sc->txd_cmd | txd_lower | (uint16_t)desc_array.descriptor[counter].length)); current_tx_desc->upper.data = htole32((txd_upper)); - if (++i == adapter->num_tx_desc) + if (++i == sc->num_tx_desc) i = 0; tx_buffer->m_head = NULL; txd_used++; } } else { - tx_buffer = &adapter->tx_buffer_area[i]; - current_tx_desc = &adapter->tx_desc_base[i]; + tx_buffer = &sc->tx_buffer_area[i]; + current_tx_desc = &sc->tx_desc_base[i]; current_tx_desc->buffer_addr = htole64(segs[j].ds_addr); current_tx_desc->lower.data = htole32( - adapter->txd_cmd | txd_lower | segs[j].ds_len); + sc->txd_cmd | txd_lower | segs[j].ds_len); current_tx_desc->upper.data = htole32(txd_upper); - if (++i == adapter->num_tx_desc) + if (++i == sc->num_tx_desc) i = 0; tx_buffer->m_head = NULL; } } - adapter->next_avail_tx_desc = i; - if (adapter->pcix_82544) - adapter->num_tx_desc_avail -= txd_used; + sc->next_avail_tx_desc = i; + if (sc->pcix_82544) + sc->num_tx_desc_avail -= txd_used; else - adapter->num_tx_desc_avail -= nsegs; + sc->num_tx_desc_avail -= nsegs; if (mtag != NULL) { /* Set the vlan id. */ @@ -1580,7 +1533,7 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) } tx_buffer->m_head = m_head; - bus_dmamap_sync(adapter->txtag, map, BUS_DMASYNC_PREWRITE); + bus_dmamap_sync(sc->txtag, map, BUS_DMASYNC_PREWRITE); /* * Last Descriptor of Packet needs End Of Packet (EOP). @@ -1591,22 +1544,20 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 * that this frame is available to transmit. */ - bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, - BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); - if (adapter->hw.mac_type == em_82547 && - adapter->link_duplex == HALF_DUPLEX) { - em_82547_move_tail_locked(adapter); - } else { - E1000_WRITE_REG(&adapter->hw, TDT, i); - if (adapter->hw.mac_type == em_82547) { - em_82547_update_fifo_head(adapter, m_head->m_pkthdr.len); - } + bus_dmamap_sync(sc->txdma.dma_tag, sc->txdma.dma_map, + BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); + if (sc->hw.mac_type == em_82547 && sc->link_duplex == HALF_DUPLEX) + em_82547_move_tail_locked(sc); + else { + E1000_WRITE_REG(&sc->hw, TDT, i); + if (sc->hw.mac_type == em_82547) + em_82547_update_fifo_head(sc, m_head->m_pkthdr.len); } - return(0); + return (0); encap_fail: - bus_dmamap_unload(adapter->txtag, tx_buffer->map); + bus_dmamap_unload(sc->txtag, tx_buffer->map); return (error); } @@ -1619,7 +1570,7 @@ em_encap(struct adapter *adapter, struct mbuf **m_headp) * **********************************************************************/ static void -em_82547_move_tail_locked(struct adapter *adapter) +em_82547_move_tail_locked(struct em_softc *sc) { uint16_t hw_tdt; uint16_t sw_tdt; @@ -1627,158 +1578,152 @@ em_82547_move_tail_locked(struct adapter *adapter) uint16_t length = 0; boolean_t eop = 0; - EM_LOCK_ASSERT(adapter); + EM_LOCK_ASSERT(sc); - hw_tdt = E1000_READ_REG(&adapter->hw, TDT); - sw_tdt = adapter->next_avail_tx_desc; + hw_tdt = E1000_READ_REG(&sc->hw, TDT); + sw_tdt = sc->next_avail_tx_desc; while (hw_tdt != sw_tdt) { - tx_desc = &adapter->tx_desc_base[hw_tdt]; + tx_desc = &sc->tx_desc_base[hw_tdt]; length += tx_desc->lower.flags.length; eop = tx_desc->lower.data & E1000_TXD_CMD_EOP; - if(++hw_tdt == adapter->num_tx_desc) + if(++hw_tdt == sc->num_tx_desc) hw_tdt = 0; - if(eop) { - if (em_82547_fifo_workaround(adapter, length)) { - adapter->tx_fifo_wrk_cnt++; - callout_reset(&adapter->tx_fifo_timer, 1, - em_82547_move_tail, adapter); + if (eop) { + if (em_82547_fifo_workaround(sc, length)) { + sc->tx_fifo_wrk_cnt++; + callout_reset(&sc->tx_fifo_timer, 1, + em_82547_move_tail, sc); break; } - E1000_WRITE_REG(&adapter->hw, TDT, hw_tdt); - em_82547_update_fifo_head(adapter, length); + E1000_WRITE_REG(&sc->hw, TDT, hw_tdt); + em_82547_update_fifo_head(sc, length); length = 0; } } - return; } static void em_82547_move_tail(void *arg) { - struct adapter *adapter = arg; + struct em_softc *sc = arg; - EM_LOCK(adapter); - em_82547_move_tail_locked(adapter); - EM_UNLOCK(adapter); + EM_LOCK(sc); + em_82547_move_tail_locked(sc); + EM_UNLOCK(sc); } static int -em_82547_fifo_workaround(struct adapter *adapter, int len) +em_82547_fifo_workaround(struct em_softc *sc, int len) { int fifo_space, fifo_pkt_len; fifo_pkt_len = roundup2(len + EM_FIFO_HDR, EM_FIFO_HDR); - if (adapter->link_duplex == HALF_DUPLEX) { - fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head; + if (sc->link_duplex == HALF_DUPLEX) { + fifo_space = sc->tx_fifo_size - sc->tx_fifo_head; if (fifo_pkt_len >= (EM_82547_PKT_THRESH + fifo_space)) { - if (em_82547_tx_fifo_reset(adapter)) - return(0); + if (em_82547_tx_fifo_reset(sc)) + return (0); else - return(1); + return (1); } } - return(0); + return (0); } static void -em_82547_update_fifo_head(struct adapter *adapter, int len) +em_82547_update_fifo_head(struct em_softc *sc, int len) { int fifo_pkt_len = roundup2(len + EM_FIFO_HDR, EM_FIFO_HDR); /* tx_fifo_head is always 16 byte aligned */ - adapter->tx_fifo_head += fifo_pkt_len; - if (adapter->tx_fifo_head >= adapter->tx_fifo_size) { - adapter->tx_fifo_head -= adapter->tx_fifo_size; + sc->tx_fifo_head += fifo_pkt_len; + if (sc->tx_fifo_head >= sc->tx_fifo_size) { + sc->tx_fifo_head -= sc->tx_fifo_size; } - - return; } static int -em_82547_tx_fifo_reset(struct adapter *adapter) +em_82547_tx_fifo_reset(struct em_softc *sc) { uint32_t tctl; - if ( (E1000_READ_REG(&adapter->hw, TDT) == - E1000_READ_REG(&adapter->hw, TDH)) && - (E1000_READ_REG(&adapter->hw, TDFT) == - E1000_READ_REG(&adapter->hw, TDFH)) && - (E1000_READ_REG(&adapter->hw, TDFTS) == - E1000_READ_REG(&adapter->hw, TDFHS)) && - (E1000_READ_REG(&adapter->hw, TDFPC) == 0)) { + if ((E1000_READ_REG(&sc->hw, TDT) == E1000_READ_REG(&sc->hw, TDH)) && + (E1000_READ_REG(&sc->hw, TDFT) == E1000_READ_REG(&sc->hw, TDFH)) && + (E1000_READ_REG(&sc->hw, TDFTS) == E1000_READ_REG(&sc->hw, TDFHS))&& + (E1000_READ_REG(&sc->hw, TDFPC) == 0)) { /* Disable TX unit */ - tctl = E1000_READ_REG(&adapter->hw, TCTL); - E1000_WRITE_REG(&adapter->hw, TCTL, tctl & ~E1000_TCTL_EN); + tctl = E1000_READ_REG(&sc->hw, TCTL); + E1000_WRITE_REG(&sc->hw, TCTL, tctl & ~E1000_TCTL_EN); /* Reset FIFO pointers */ - E1000_WRITE_REG(&adapter->hw, TDFT, adapter->tx_head_addr); - E1000_WRITE_REG(&adapter->hw, TDFH, adapter->tx_head_addr); - E1000_WRITE_REG(&adapter->hw, TDFTS, adapter->tx_head_addr); - E1000_WRITE_REG(&adapter->hw, TDFHS, adapter->tx_head_addr); + E1000_WRITE_REG(&sc->hw, TDFT, sc->tx_head_addr); + E1000_WRITE_REG(&sc->hw, TDFH, sc->tx_head_addr); + E1000_WRITE_REG(&sc->hw, TDFTS, sc->tx_head_addr); + E1000_WRITE_REG(&sc->hw, TDFHS, sc->tx_head_addr); /* Re-enable TX unit */ - E1000_WRITE_REG(&adapter->hw, TCTL, tctl); - E1000_WRITE_FLUSH(&adapter->hw); + E1000_WRITE_REG(&sc->hw, TCTL, tctl); + E1000_WRITE_FLUSH(&sc->hw); - adapter->tx_fifo_head = 0; - adapter->tx_fifo_reset_cnt++; + sc->tx_fifo_head = 0; + sc->tx_fifo_reset_cnt++; - return(TRUE); + return (TRUE); } else { - return(FALSE); + return (FALSE); } } static void -em_set_promisc(struct adapter * adapter) +em_set_promisc(struct em_softc *sc) { - struct ifnet *ifp = adapter->ifp; + struct ifnet *ifp = sc->ifp; uint32_t reg_rctl; - reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); + reg_rctl = E1000_READ_REG(&sc->hw, RCTL); if (ifp->if_flags & IFF_PROMISC) { reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); /* Disable VLAN stripping in promiscous mode * This enables bridging of vlan tagged frames to occur * and also allows vlan tags to be seen in tcpdump */ if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) - em_disable_vlans(adapter); - adapter->em_insert_vlan_header = 1; + em_disable_vlans(sc); + sc->em_insert_vlan_header = 1; } else if (ifp->if_flags & IFF_ALLMULTI) { reg_rctl |= E1000_RCTL_MPE; reg_rctl &= ~E1000_RCTL_UPE; - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); - adapter->em_insert_vlan_header = 0; + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); + sc->em_insert_vlan_header = 0; } else - adapter->em_insert_vlan_header = 0; + sc->em_insert_vlan_header = 0; } static void -em_disable_promisc(struct adapter * adapter) +em_disable_promisc(struct em_softc *sc) { - struct ifnet *ifp = adapter->ifp; + struct ifnet *ifp = sc->ifp; uint32_t reg_rctl; - reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); + reg_rctl = E1000_READ_REG(&sc->hw, RCTL); reg_rctl &= (~E1000_RCTL_UPE); reg_rctl &= (~E1000_RCTL_MPE); - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING) - em_enable_vlans(adapter); - adapter->em_insert_vlan_header = 0; + em_enable_vlans(sc); + sc->em_insert_vlan_header = 0; } @@ -1790,27 +1735,27 @@ em_disable_promisc(struct adapter * adapter) **********************************************************************/ static void -em_set_multi(struct adapter * adapter) +em_set_multi(struct em_softc *sc) { - struct ifnet *ifp = adapter->ifp; - struct ifmultiaddr *ifma; - uint32_t reg_rctl = 0; - uint8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; - int mcnt = 0; + struct ifnet *ifp = sc->ifp; + struct ifmultiaddr *ifma; + uint32_t reg_rctl = 0; + uint8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; + int mcnt = 0; IOCTL_DEBUGOUT("em_set_multi: begin"); - if (adapter->hw.mac_type == em_82542_rev2_0) { - reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); - if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) - em_pci_clear_mwi(&adapter->hw); + if (sc->hw.mac_type == em_82542_rev2_0) { + reg_rctl = E1000_READ_REG(&sc->hw, RCTL); + if (sc->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) + em_pci_clear_mwi(&sc->hw); reg_rctl |= E1000_RCTL_RST; - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); msec_delay(5); } IF_ADDR_LOCK(ifp); - TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { + TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { if (ifma->ifma_addr->sa_family != AF_LINK) continue; @@ -1824,19 +1769,19 @@ em_set_multi(struct adapter * adapter) IF_ADDR_UNLOCK(ifp); if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) { - reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); + reg_rctl = E1000_READ_REG(&sc->hw, RCTL); reg_rctl |= E1000_RCTL_MPE; - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); } else - em_mc_addr_list_update(&adapter->hw, mta, mcnt, 0, 1); + em_mc_addr_list_update(&sc->hw, mta, mcnt, 0, 1); - if (adapter->hw.mac_type == em_82542_rev2_0) { - reg_rctl = E1000_READ_REG(&adapter->hw, RCTL); + if (sc->hw.mac_type == em_82542_rev2_0) { + reg_rctl = E1000_READ_REG(&sc->hw, RCTL); reg_rctl &= ~E1000_RCTL_RST; - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); msec_delay(5); - if (adapter->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) - em_pci_set_mwi(&adapter->hw); + if (sc->hw.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) + em_pci_set_mwi(&sc->hw); } } @@ -1851,50 +1796,49 @@ em_set_multi(struct adapter * adapter) static void em_local_timer(void *arg) { - struct adapter *adapter = arg; - struct ifnet *ifp = adapter->ifp; + struct em_softc *sc = arg; + struct ifnet *ifp = sc->ifp; - EM_LOCK(adapter); + EM_LOCK(sc); - em_check_for_link(&adapter->hw); - em_print_link_status(adapter); - em_update_stats_counters(adapter); + em_check_for_link(&sc->hw); + em_print_link_status(sc); + em_update_stats_counters(sc); if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING) - em_print_hw_stats(adapter); - em_smartspeed(adapter); + em_print_hw_stats(sc); + em_smartspeed(sc); - callout_reset(&adapter->timer, hz, em_local_timer, adapter); + callout_reset(&sc->timer, hz, em_local_timer, sc); - EM_UNLOCK(adapter); + EM_UNLOCK(sc); } static void -em_print_link_status(struct adapter * adapter) +em_print_link_status(struct em_softc *sc) { - struct ifnet *ifp = adapter->ifp; + struct ifnet *ifp = sc->ifp; + device_t dev = sc->dev; - if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) { - if (adapter->link_active == 0) { - em_get_speed_and_duplex(&adapter->hw, - &adapter->link_speed, - &adapter->link_duplex); + if (E1000_READ_REG(&sc->hw, STATUS) & E1000_STATUS_LU) { + if (sc->link_active == 0) { + em_get_speed_and_duplex(&sc->hw, &sc->link_speed, + &sc->link_duplex); if (bootverbose) - printf("em%d: Link is up %d Mbps %s\n", - adapter->unit, - adapter->link_speed, - ((adapter->link_duplex == FULL_DUPLEX) ? + device_printf(dev, "Link is up %d Mbps %s\n", + sc->link_speed, + ((sc->link_duplex == FULL_DUPLEX) ? "Full Duplex" : "Half Duplex")); - adapter->link_active = 1; - adapter->smartspeed = 0; + sc->link_active = 1; + sc->smartspeed = 0; if_link_state_change(ifp, LINK_STATE_UP); } } else { - if (adapter->link_active == 1) { - adapter->link_speed = 0; - adapter->link_duplex = 0; + if (sc->link_active == 1) { + sc->link_speed = 0; + sc->link_duplex = 0; if (bootverbose) - printf("em%d: Link is Down\n", adapter->unit); - adapter->link_active = 0; + device_printf(dev, "Link is Down\n"); + sc->link_active = 0; if_link_state_change(ifp, LINK_STATE_DOWN); } } @@ -1910,19 +1854,19 @@ em_print_link_status(struct adapter * adapter) static void em_stop(void *arg) { - struct adapter *adapter = arg; - struct ifnet *ifp = adapter->ifp; + struct em_softc *sc = arg; + struct ifnet *ifp = sc->ifp; - EM_LOCK_ASSERT(adapter); + EM_LOCK_ASSERT(sc); INIT_DEBUGOUT("em_stop: begin"); - em_disable_intr(adapter); - em_reset_hw(&adapter->hw); - callout_stop(&adapter->timer); - callout_stop(&adapter->tx_fifo_timer); - em_free_transmit_structures(adapter); - em_free_receive_structures(adapter); + em_disable_intr(sc); + em_reset_hw(&sc->hw); + callout_stop(&sc->timer); + callout_stop(&sc->tx_fifo_timer); + em_free_transmit_structures(sc); + em_free_receive_structures(sc); /* Tell the stack that the interface is no longer active */ ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); @@ -1935,68 +1879,61 @@ em_stop(void *arg) * **********************************************************************/ static void -em_identify_hardware(struct adapter * adapter) +em_identify_hardware(struct em_softc *sc) { - device_t dev = adapter->dev; + device_t dev = sc->dev; /* Make sure our PCI config space has the necessary stuff set */ - adapter->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); - if (!((adapter->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && - (adapter->hw.pci_cmd_word & PCIM_CMD_MEMEN))) { - printf("em%d: Memory Access and/or Bus Master bits were not set!\n", - adapter->unit); - adapter->hw.pci_cmd_word |= + sc->hw.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); + if ((sc->hw.pci_cmd_word & PCIM_CMD_BUSMASTEREN) == 0 && + (sc->hw.pci_cmd_word & PCIM_CMD_MEMEN)) { + device_printf(dev, "Memory Access and/or Bus Master bits " + "were not set!\n"); + sc->hw.pci_cmd_word |= (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); - pci_write_config(dev, PCIR_COMMAND, adapter->hw.pci_cmd_word, 2); + pci_write_config(dev, PCIR_COMMAND, sc->hw.pci_cmd_word, 2); } /* Save off the information about this board */ - adapter->hw.vendor_id = pci_get_vendor(dev); - adapter->hw.device_id = pci_get_device(dev); - adapter->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); - adapter->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); - adapter->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); + sc->hw.vendor_id = pci_get_vendor(dev); + sc->hw.device_id = pci_get_device(dev); + sc->hw.revision_id = pci_read_config(dev, PCIR_REVID, 1); + sc->hw.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); + sc->hw.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); /* Identify the MAC */ - if (em_set_mac_type(&adapter->hw)) - printf("em%d: Unknown MAC Type\n", adapter->unit); + if (em_set_mac_type(&sc->hw)) + device_printf(dev, "Unknown MAC Type\n"); - if(adapter->hw.mac_type == em_82541 || - adapter->hw.mac_type == em_82541_rev_2 || - adapter->hw.mac_type == em_82547 || - adapter->hw.mac_type == em_82547_rev_2) - adapter->hw.phy_init_script = TRUE; - - return; + if(sc->hw.mac_type == em_82541 || sc->hw.mac_type == em_82541_rev_2 || + sc->hw.mac_type == em_82547 || sc->hw.mac_type == em_82547_rev_2) + sc->hw.phy_init_script = TRUE; } static int -em_allocate_pci_resources(struct adapter * adapter) +em_allocate_pci_resources(struct em_softc *sc) { - int val, rid; - device_t dev = adapter->dev; + device_t dev = sc->dev; + int val, rid; rid = PCIR_BAR(0); - adapter->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY, - &rid, RF_ACTIVE); - if (!(adapter->res_memory)) { - printf("em%d: Unable to allocate bus resource: memory\n", - adapter->unit); - return(ENXIO); + sc->res_memory = bus_alloc_resource_any(dev, SYS_RES_MEMORY, + &rid, RF_ACTIVE); + if (sc->res_memory == NULL) { + device_printf(dev, "Unable to allocate bus resource: memory\n"); + return (ENXIO); } - adapter->osdep.mem_bus_space_tag = - rman_get_bustag(adapter->res_memory); - adapter->osdep.mem_bus_space_handle = - rman_get_bushandle(adapter->res_memory); - adapter->hw.hw_addr = (uint8_t *)&adapter->osdep.mem_bus_space_handle; + sc->osdep.mem_bus_space_tag = + rman_get_bustag(sc->res_memory); + sc->osdep.mem_bus_space_handle = rman_get_bushandle(sc->res_memory); + sc->hw.hw_addr = (uint8_t *)&sc->osdep.mem_bus_space_handle; - - if (adapter->hw.mac_type > em_82543) { + if (sc->hw.mac_type > em_82543) { /* Figure our where our IO BAR is ? */ for (rid = PCIR_BAR(0); rid < PCIR_CIS;) { val = pci_read_config(dev, rid, 4); if (E1000_BAR_TYPE(val) == E1000_BAR_TYPE_IO) { - adapter->io_rid = rid; + sc->io_rid = rid; break; } rid += 4; @@ -2005,47 +1942,44 @@ em_allocate_pci_resources(struct adapter * adapter) rid += 4; } if (rid >= PCIR_CIS) { - printf("em%d: Unable to locate IO BAR\n", adapter->unit); + device_printf(dev, "Unable to locate IO BAR\n"); return (ENXIO); } - adapter->res_ioport = bus_alloc_resource_any(dev, - SYS_RES_IOPORT, - &adapter->io_rid, - RF_ACTIVE); - if (!(adapter->res_ioport)) { - printf("em%d: Unable to allocate bus resource: ioport\n", - adapter->unit); - return(ENXIO); + sc->res_ioport = bus_alloc_resource_any(dev, SYS_RES_IOPORT, + &sc->io_rid, RF_ACTIVE); + if (sc->res_ioport == NULL) { + device_printf(dev, "Unable to allocate bus resource: " + "ioport\n"); + return (ENXIO); } - adapter->hw.io_base = 0; - adapter->osdep.io_bus_space_tag = - rman_get_bustag(adapter->res_ioport); - adapter->osdep.io_bus_space_handle = - rman_get_bushandle(adapter->res_ioport); + sc->hw.io_base = 0; + sc->osdep.io_bus_space_tag = rman_get_bustag(sc->res_ioport); + sc->osdep.io_bus_space_handle = + rman_get_bushandle(sc->res_ioport); } rid = 0x0; - adapter->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, - RF_SHAREABLE | - RF_ACTIVE); - if (!(adapter->res_interrupt)) { - printf("em%d: Unable to allocate bus resource: interrupt\n", - adapter->unit); - return(ENXIO); + sc->res_interrupt = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, + RF_SHAREABLE | RF_ACTIVE); + if (sc->res_interrupt == NULL) { + device_printf(dev, "Unable to allocate bus resource: " + "interrupt\n"); + return (ENXIO); } - adapter->hw.back = &adapter->osdep; + sc->hw.back = &sc->osdep; - return(0); + return (0); } int -em_allocate_intr(struct adapter *adapter) +em_allocate_intr(struct em_softc *sc) { - device_t dev = adapter->dev; + device_t dev = sc->dev; + int error; /* Manually turn off all interrupts */ - E1000_WRITE_REG(&adapter->hw, IMC, 0xffffffff); + E1000_WRITE_REG(&sc->hw, IMC, 0xffffffff); /* * Try allocating a fast interrupt and the associated deferred @@ -2054,71 +1988,64 @@ em_allocate_intr(struct adapter *adapter) */ #ifndef NO_EM_FASTINTR /* Init the deferred processing contexts. */ - TASK_INIT(&adapter->rxtx_task, 0, em_handle_rxtx, adapter); - TASK_INIT(&adapter->link_task, 0, em_handle_link, adapter); - adapter->tq = taskqueue_create_fast("em_taskq", M_NOWAIT, - taskqueue_thread_enqueue, &adapter->tq); - taskqueue_start_threads(&adapter->tq, 1, PI_NET, "%s taskq", - device_get_nameunit(adapter->dev)); - if (bus_setup_intr(dev, adapter->res_interrupt, - INTR_TYPE_NET | INTR_FAST, em_intr_fast, adapter, - &adapter->int_handler_tag) != 0) { - taskqueue_free(adapter->tq); - adapter->tq = NULL; + TASK_INIT(&sc->rxtx_task, 0, em_handle_rxtx, sc); + TASK_INIT(&sc->link_task, 0, em_handle_link, sc); + sc->tq = taskqueue_create_fast("em_taskq", M_NOWAIT, + taskqueue_thread_enqueue, &sc->tq); + taskqueue_start_threads(&sc->tq, 1, PI_NET, "%s taskq", + device_get_nameunit(sc->dev)); + if ((error = bus_setup_intr(dev, sc->res_interrupt, + INTR_TYPE_NET | INTR_FAST, em_intr_fast, sc, + &sc->int_handler_tag)) != 0) { + device_printf(dev, "Failed to register fast interrupt " + "handler: %d\n", error); + taskqueue_free(sc->tq); + sc->tq = NULL; } #endif - if (adapter->int_handler_tag == NULL) { - if (bus_setup_intr(dev, adapter->res_interrupt, - INTR_TYPE_NET | INTR_MPSAFE, - em_intr, adapter, - &adapter->int_handler_tag)) { - printf("em%d: Error registering interrupt handler!\n", - adapter->unit); - return(ENXIO); - } + if (sc->int_handler_tag == NULL && (error = bus_setup_intr(dev, + sc->res_interrupt, INTR_TYPE_NET | INTR_MPSAFE, em_intr, sc, + &sc->int_handler_tag)) != 0) { + device_printf(dev, "Failed to register interrupt handler"); + return (error); } - em_enable_intr(adapter); + em_enable_intr(sc); return (0); } static void -em_free_intr(struct adapter *adapter) +em_free_intr(struct em_softc *sc) { - device_t dev = adapter->dev; + device_t dev = sc->dev; - if (adapter->res_interrupt != NULL) { - bus_teardown_intr(dev, adapter->res_interrupt, - adapter->int_handler_tag); - adapter->int_handler_tag = NULL; + if (sc->res_interrupt != NULL) { + bus_teardown_intr(dev, sc->res_interrupt, sc->int_handler_tag); + sc->int_handler_tag = NULL; } - if (adapter->tq != NULL) { - taskqueue_drain(adapter->tq, &adapter->rxtx_task); - taskqueue_drain(taskqueue_fast, &adapter->link_task); - taskqueue_free(adapter->tq); - adapter->tq = NULL; + if (sc->tq != NULL) { + taskqueue_drain(sc->tq, &sc->rxtx_task); + taskqueue_drain(taskqueue_fast, &sc->link_task); + taskqueue_free(sc->tq); + sc->tq = NULL; } } static void -em_free_pci_resources(struct adapter * adapter) +em_free_pci_resources(struct em_softc *sc) { - device_t dev = adapter->dev; + device_t dev = sc->dev; - if (adapter->res_interrupt != NULL) { - bus_release_resource(dev, SYS_RES_IRQ, 0, - adapter->res_interrupt); - } - if (adapter->res_memory != NULL) { + if (sc->res_interrupt != NULL) + bus_release_resource(dev, SYS_RES_IRQ, 0, sc->res_interrupt); + + if (sc->res_memory != NULL) bus_release_resource(dev, SYS_RES_MEMORY, PCIR_BAR(0), - adapter->res_memory); - } + sc->res_memory); - if (adapter->res_ioport != NULL) { - bus_release_resource(dev, SYS_RES_IOPORT, adapter->io_rid, - adapter->res_ioport); - } - return; + if (sc->res_ioport != NULL) + bus_release_resource(dev, SYS_RES_IOPORT, sc->io_rid, + sc->res_ioport); } /********************************************************************* @@ -2130,28 +2057,28 @@ em_free_pci_resources(struct adapter * adapter) * **********************************************************************/ static int -em_hardware_init(struct adapter * adapter) +em_hardware_init(struct em_softc *sc) { + device_t dev = sc->dev; uint16_t rx_buffer_size; - INIT_DEBUGOUT("em_hardware_init: begin"); + INIT_DEBUGOUT("em_hardware_init: begin"); /* Issue a global reset */ - em_reset_hw(&adapter->hw); + em_reset_hw(&sc->hw); /* When hardware is reset, fifo_head is also reset */ - adapter->tx_fifo_head = 0; + sc->tx_fifo_head = 0; /* Make sure we have a good EEPROM before we read from it */ - if (em_validate_eeprom_checksum(&adapter->hw) < 0) { - printf("em%d: The EEPROM Checksum Is Not Valid\n", - adapter->unit); - return(EIO); + if (em_validate_eeprom_checksum(&sc->hw) < 0) { + device_printf(dev, "The EEPROM Checksum Is Not Valid\n"); + return (EIO); } - if (em_read_part_num(&adapter->hw, &(adapter->part_num)) < 0) { - printf("em%d: EEPROM read error while reading part number\n", - adapter->unit); - return(EIO); + if (em_read_part_num(&sc->hw, &(sc->part_num)) < 0) { + device_printf(dev, "EEPROM read error while reading part " + "number\n"); + return (EIO); } /* @@ -2160,44 +2087,41 @@ em_hardware_init(struct adapter * adapter) * - High water mark should allow for at least two frames to be * received after sending an XOFF. * - Low water mark works best when it is very near the high water mark. - * This allows the receiver to restart by sending XON when it has drained - * a bit. Here we use an arbitary value of 1500 which will restart after - * one full frame is pulled from the buffer. There could be several smaller - * frames in the buffer and if so they will not trigger the XON until their - * total number reduces the buffer by 1500. + * This allows the receiver to restart by sending XON when it has + * drained a bit. Here we use an arbitary value of 1500 which will + * restart after one full frame is pulled from the buffer. There + * could be several smaller frames in the buffer and if so they will + * not trigger the XON until their total number reduces the buffer + * by 1500. * - The pause time is fairly large at 1000 x 512ns = 512 usec. */ - rx_buffer_size = ((E1000_READ_REG(&adapter->hw, PBA) & 0xffff) << 10 ); + rx_buffer_size = ((E1000_READ_REG(&sc->hw, PBA) & 0xffff) << 10 ); - adapter->hw.fc_high_water = rx_buffer_size - - roundup2(adapter->hw.max_frame_size, 1024); - adapter->hw.fc_low_water = adapter->hw.fc_high_water - 1500; - adapter->hw.fc_pause_time = 0x1000; - adapter->hw.fc_send_xon = TRUE; - adapter->hw.fc = em_fc_full; + sc->hw.fc_high_water = rx_buffer_size - + roundup2(sc->hw.max_frame_size, 1024); + sc->hw.fc_low_water = sc->hw.fc_high_water - 1500; + sc->hw.fc_pause_time = 0x1000; + sc->hw.fc_send_xon = TRUE; + sc->hw.fc = em_fc_full; - if (em_init_hw(&adapter->hw) < 0) { - printf("em%d: Hardware Initialization Failed", - adapter->unit); - return(EIO); + if (em_init_hw(&sc->hw) < 0) { + device_printf(dev, "Hardware Initialization Failed"); + return (EIO); } - em_check_for_link(&adapter->hw); - if (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU) - adapter->link_active = 1; + em_check_for_link(&sc->hw); + if (E1000_READ_REG(&sc->hw, STATUS) & E1000_STATUS_LU) + sc->link_active = 1; else - adapter->link_active = 0; + sc->link_active = 0; - if (adapter->link_active) { - em_get_speed_and_duplex(&adapter->hw, - &adapter->link_speed, - &adapter->link_duplex); - } else { - adapter->link_speed = 0; - adapter->link_duplex = 0; - } + if (sc->link_active) + em_get_speed_and_duplex(&sc->hw, &sc->link_speed, + &sc->link_duplex); + else + sc->link_speed = sc->link_duplex = 0; - return(0); + return (0); } /********************************************************************* @@ -2206,32 +2130,32 @@ em_hardware_init(struct adapter * adapter) * **********************************************************************/ static void -em_setup_interface(device_t dev, struct adapter * adapter) +em_setup_interface(device_t dev, struct em_softc *sc) { struct ifnet *ifp; INIT_DEBUGOUT("em_setup_interface: begin"); - ifp = adapter->ifp = if_alloc(IFT_ETHER); + ifp = sc->ifp = if_alloc(IFT_ETHER); if (ifp == NULL) panic("%s: can not if_alloc()", device_get_nameunit(dev)); if_initname(ifp, device_get_name(dev), device_get_unit(dev)); ifp->if_mtu = ETHERMTU; ifp->if_baudrate = 1000000000; ifp->if_init = em_init; - ifp->if_softc = adapter; + ifp->if_softc = sc; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = em_ioctl; ifp->if_start = em_start; ifp->if_watchdog = em_watchdog; - IFQ_SET_MAXLEN(&ifp->if_snd, adapter->num_tx_desc - 1); - ifp->if_snd.ifq_drv_maxlen = adapter->num_tx_desc - 1; + IFQ_SET_MAXLEN(&ifp->if_snd, sc->num_tx_desc - 1); + ifp->if_snd.ifq_drv_maxlen = sc->num_tx_desc - 1; IFQ_SET_READY(&ifp->if_snd); - ether_ifattach(ifp, adapter->hw.mac_addr); + ether_ifattach(ifp, sc->hw.mac_addr); ifp->if_capabilities = ifp->if_capenable = 0; - if (adapter->hw.mac_type >= em_82543) { + if (sc->hw.mac_type >= em_82543) { ifp->if_capabilities |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM; ifp->if_capenable |= IFCAP_HWCSUM | IFCAP_VLAN_HWCSUM; } @@ -2251,29 +2175,26 @@ em_setup_interface(device_t dev, struct adapter * adapter) * Specify the media types supported by this adapter and register * callbacks to update media and link information */ - ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, - em_media_status); - if (adapter->hw.media_type == em_media_type_fiber) { - ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, + ifmedia_init(&sc->media, IFM_IMASK, em_media_change, em_media_status); + if (sc->hw.media_type == em_media_type_fiber) { + ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX, + ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_SX, 0, NULL); } else { - ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, + ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T, 0, NULL); + ifmedia_add(&sc->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, + ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, + ifmedia_add(&sc->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T | IFM_FDX, + ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T | IFM_FDX, 0, NULL); - ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_T, 0, NULL); + ifmedia_add(&sc->media, IFM_ETHER | IFM_1000_T, 0, NULL); } - ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); - ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); - - return; + ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL); + ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO); } @@ -2283,58 +2204,57 @@ em_setup_interface(device_t dev, struct adapter * adapter) * **********************************************************************/ static void -em_smartspeed(struct adapter *adapter) +em_smartspeed(struct em_softc *sc) { - uint16_t phy_tmp; + uint16_t phy_tmp; - if(adapter->link_active || (adapter->hw.phy_type != em_phy_igp) || - !adapter->hw.autoneg || !(adapter->hw.autoneg_advertised & ADVERTISE_1000_FULL)) + if (sc->link_active || (sc->hw.phy_type != em_phy_igp) || + sc->hw.autoneg == 0 || + (sc->hw.autoneg_advertised & ADVERTISE_1000_FULL) == 0) return; - if(adapter->smartspeed == 0) { - /* If Master/Slave config fault is asserted twice, - * we assume back-to-back */ - em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); - if(!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) return; - em_read_phy_reg(&adapter->hw, PHY_1000T_STATUS, &phy_tmp); - if(phy_tmp & SR_1000T_MS_CONFIG_FAULT) { - em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, - &phy_tmp); - if(phy_tmp & CR_1000T_MS_ENABLE) { - phy_tmp &= ~CR_1000T_MS_ENABLE; - em_write_phy_reg(&adapter->hw, - PHY_1000T_CTRL, phy_tmp); - adapter->smartspeed++; - if(adapter->hw.autoneg && - !em_phy_setup_autoneg(&adapter->hw) && - !em_read_phy_reg(&adapter->hw, PHY_CTRL, - &phy_tmp)) { - phy_tmp |= (MII_CR_AUTO_NEG_EN | - MII_CR_RESTART_AUTO_NEG); - em_write_phy_reg(&adapter->hw, - PHY_CTRL, phy_tmp); - } - } - } - return; - } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { - /* If still no link, perhaps using 2/3 pair cable */ - em_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp); - phy_tmp |= CR_1000T_MS_ENABLE; - em_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp); - if(adapter->hw.autoneg && - !em_phy_setup_autoneg(&adapter->hw) && - !em_read_phy_reg(&adapter->hw, PHY_CTRL, &phy_tmp)) { - phy_tmp |= (MII_CR_AUTO_NEG_EN | - MII_CR_RESTART_AUTO_NEG); - em_write_phy_reg(&adapter->hw, PHY_CTRL, phy_tmp); - } - } - /* Restart process after EM_SMARTSPEED_MAX iterations */ - if(adapter->smartspeed++ == EM_SMARTSPEED_MAX) - adapter->smartspeed = 0; - - return; + if (sc->smartspeed == 0) { + /* If Master/Slave config fault is asserted twice, + * we assume back-to-back */ + em_read_phy_reg(&sc->hw, PHY_1000T_STATUS, &phy_tmp); + if (!(phy_tmp & SR_1000T_MS_CONFIG_FAULT)) + return; + em_read_phy_reg(&sc->hw, PHY_1000T_STATUS, &phy_tmp); + if (phy_tmp & SR_1000T_MS_CONFIG_FAULT) { + em_read_phy_reg(&sc->hw, PHY_1000T_CTRL, &phy_tmp); + if(phy_tmp & CR_1000T_MS_ENABLE) { + phy_tmp &= ~CR_1000T_MS_ENABLE; + em_write_phy_reg(&sc->hw, PHY_1000T_CTRL, + phy_tmp); + sc->smartspeed++; + if(sc->hw.autoneg && + !em_phy_setup_autoneg(&sc->hw) && + !em_read_phy_reg(&sc->hw, PHY_CTRL, + &phy_tmp)) { + phy_tmp |= (MII_CR_AUTO_NEG_EN | + MII_CR_RESTART_AUTO_NEG); + em_write_phy_reg(&sc->hw, PHY_CTRL, + phy_tmp); + } + } + } + return; + } else if(sc->smartspeed == EM_SMARTSPEED_DOWNSHIFT) { + /* If still no link, perhaps using 2/3 pair cable */ + em_read_phy_reg(&sc->hw, PHY_1000T_CTRL, &phy_tmp); + phy_tmp |= CR_1000T_MS_ENABLE; + em_write_phy_reg(&sc->hw, PHY_1000T_CTRL, phy_tmp); + if(sc->hw.autoneg && + !em_phy_setup_autoneg(&sc->hw) && + !em_read_phy_reg(&sc->hw, PHY_CTRL, &phy_tmp)) { + phy_tmp |= (MII_CR_AUTO_NEG_EN | + MII_CR_RESTART_AUTO_NEG); + em_write_phy_reg(&sc->hw, PHY_CTRL, phy_tmp); + } + } + /* Restart process after EM_SMARTSPEED_MAX iterations */ + if(sc->smartspeed++ == EM_SMARTSPEED_MAX) + sc->smartspeed = 0; } @@ -2344,71 +2264,68 @@ em_smartspeed(struct adapter *adapter) static void em_dmamap_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error) { - if (error) - return; - *(bus_addr_t *) arg = segs[0].ds_addr; + if (error) + return; + *(bus_addr_t *) arg = segs[0].ds_addr; } static int -em_dma_malloc(struct adapter *adapter, bus_size_t size, - struct em_dma_alloc *dma, int mapflags) +em_dma_malloc(struct em_softc *sc, bus_size_t size, struct em_dma_alloc *dma, + int mapflags) { - int r; + int error; - r = bus_dma_tag_create(NULL, /* parent */ - E1000_DBA_ALIGN, 0, /* alignment, bounds */ - BUS_SPACE_MAXADDR, /* lowaddr */ - BUS_SPACE_MAXADDR, /* highaddr */ - NULL, NULL, /* filter, filterarg */ - size, /* maxsize */ - 1, /* nsegments */ - size, /* maxsegsize */ - 0, /* flags */ - NULL, /* lockfunc */ - NULL, /* lockarg */ - &dma->dma_tag); - if (r != 0) { - printf("em%d: em_dma_malloc: bus_dma_tag_create failed; " - "error %u\n", adapter->unit, r); - goto fail_0; - } + error = bus_dma_tag_create(NULL, /* parent */ + E1000_DBA_ALIGN, 0, /* alignment, bounds */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + size, /* maxsize */ + 1, /* nsegments */ + size, /* maxsegsize */ + 0, /* flags */ + NULL, /* lockfunc */ + NULL, /* lockarg */ + &dma->dma_tag); + if (error) { + device_printf(sc->dev, "%s: bus_dma_tag_create failed: %d\n", + __func__, error); + goto fail_0; + } - r = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, - BUS_DMA_NOWAIT, &dma->dma_map); - if (r != 0) { - printf("em%d: em_dma_malloc: bus_dmammem_alloc failed; " - "size %ju, error %d\n", adapter->unit, - (uintmax_t)size, r); - goto fail_2; - } + error = bus_dmamem_alloc(dma->dma_tag, (void**) &dma->dma_vaddr, + BUS_DMA_NOWAIT, &dma->dma_map); + if (error) { + device_printf(sc->dev, "%s: bus_dmamem_alloc(%ju) failed: %d\n", + __func__, (uintmax_t)size, error); + goto fail_2; + } dma->dma_paddr = 0; - r = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, - size, - em_dmamap_cb, - &dma->dma_paddr, - mapflags | BUS_DMA_NOWAIT); - if (r != 0 || dma->dma_paddr == 0) { - printf("em%d: em_dma_malloc: bus_dmamap_load failed; " - "error %u\n", adapter->unit, r); - goto fail_3; - } + error = bus_dmamap_load(dma->dma_tag, dma->dma_map, dma->dma_vaddr, + size, em_dmamap_cb, &dma->dma_paddr, mapflags | BUS_DMA_NOWAIT); + if (error || dma->dma_paddr == 0) { + device_printf(sc->dev, "%s: bus_dmamap_load failed: %d\n", + __func__, error); + goto fail_3; + } - return (0); + return (0); fail_3: - bus_dmamap_unload(dma->dma_tag, dma->dma_map); + bus_dmamap_unload(dma->dma_tag, dma->dma_map); fail_2: - bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); - bus_dma_tag_destroy(dma->dma_tag); + bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); + bus_dma_tag_destroy(dma->dma_tag); fail_0: - dma->dma_map = NULL; - dma->dma_tag = NULL; - return (r); + dma->dma_map = NULL; + dma->dma_tag = NULL; + + return (error); } static void -em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) +em_dma_free(struct em_softc *sc, struct em_dma_alloc *dma) { if (dma->dma_tag == NULL) return; @@ -2419,7 +2336,7 @@ em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) bus_dmamem_free(dma->dma_tag, dma->dma_vaddr, dma->dma_map); dma->dma_map = NULL; } - bus_dma_tag_destroy(dma->dma_tag); + bus_dma_tag_destroy(dma->dma_tag); dma->dma_tag = NULL; } @@ -2431,21 +2348,18 @@ em_dma_free(struct adapter *adapter, struct em_dma_alloc *dma) * **********************************************************************/ static int -em_allocate_transmit_structures(struct adapter * adapter) +em_allocate_transmit_structures(struct em_softc *sc) { - if (!(adapter->tx_buffer_area = - (struct em_buffer *) malloc(sizeof(struct em_buffer) * - adapter->num_tx_desc, M_DEVBUF, - M_NOWAIT))) { - printf("em%d: Unable to allocate tx_buffer memory\n", - adapter->unit); - return ENOMEM; + sc->tx_buffer_area = malloc(sizeof(struct em_buffer) * + sc->num_tx_desc, M_DEVBUF, M_NOWAIT); + if (sc->tx_buffer_area == NULL) { + device_printf(sc->dev, "Unable to allocate tx_buffer memory\n"); + return (ENOMEM); } - bzero(adapter->tx_buffer_area, - sizeof(struct em_buffer) * adapter->num_tx_desc); + bzero(sc->tx_buffer_area, sizeof(struct em_buffer) * sc->num_tx_desc); - return 0; + return (0); } /********************************************************************* @@ -2454,63 +2368,62 @@ em_allocate_transmit_structures(struct adapter * adapter) * **********************************************************************/ static int -em_setup_transmit_structures(struct adapter * adapter) +em_setup_transmit_structures(struct em_softc *sc) { + device_t dev = sc->dev; struct em_buffer *tx_buffer; bus_size_t size; int error, i; - /* - * Setup DMA descriptor areas. - */ - size = roundup2(adapter->hw.max_frame_size, MCLBYTES); - if ((error = bus_dma_tag_create(NULL, /* parent */ - 1, 0, /* alignment, bounds */ - BUS_SPACE_MAXADDR, /* lowaddr */ - BUS_SPACE_MAXADDR, /* highaddr */ - NULL, NULL, /* filter, filterarg */ - size, /* maxsize */ - EM_MAX_SCATTER, /* nsegments */ - size, /* maxsegsize */ - 0, /* flags */ - NULL, /* lockfunc */ - NULL, /* lockarg */ - &adapter->txtag)) != 0) { - printf("em%d: Unable to allocate TX DMA tag\n", adapter->unit); + /* + * Setup DMA descriptor areas. + */ + size = roundup2(sc->hw.max_frame_size, MCLBYTES); + if ((error = bus_dma_tag_create(NULL, /* parent */ + 1, 0, /* alignment, bounds */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + size, /* maxsize */ + EM_MAX_SCATTER, /* nsegments */ + size, /* maxsegsize */ + 0, /* flags */ + NULL, /* lockfunc */ + NULL, /* lockarg */ + &sc->txtag)) != 0) { + device_printf(dev, "Unable to allocate TX DMA tag\n"); goto fail; - } + } - if ((error = em_allocate_transmit_structures(adapter)) != 0) + if ((error = em_allocate_transmit_structures(sc)) != 0) goto fail; - bzero((void *) adapter->tx_desc_base, - (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); - tx_buffer = adapter->tx_buffer_area; - for (i = 0; i < adapter->num_tx_desc; i++) { - error = bus_dmamap_create(adapter->txtag, 0, &tx_buffer->map); + bzero(sc->tx_desc_base, (sizeof(struct em_tx_desc)) * sc->num_tx_desc); + tx_buffer = sc->tx_buffer_area; + for (i = 0; i < sc->num_tx_desc; i++) { + error = bus_dmamap_create(sc->txtag, 0, &tx_buffer->map); if (error != 0) { - printf("em%d: Unable to create TX DMA map\n", - adapter->unit); + device_printf(dev, "Unable to create TX DMA map\n"); goto fail; } tx_buffer++; } - adapter->next_avail_tx_desc = 0; - adapter->oldest_used_tx_desc = 0; + sc->next_avail_tx_desc = 0; + sc->oldest_used_tx_desc = 0; - /* Set number of descriptors available */ - adapter->num_tx_desc_avail = adapter->num_tx_desc; + /* Set number of descriptors available */ + sc->num_tx_desc_avail = sc->num_tx_desc; - /* Set checksum context */ - adapter->active_checksum_context = OFFLOAD_NONE; - bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, + /* Set checksum context */ + sc->active_checksum_context = OFFLOAD_NONE; + bus_dmamap_sync(sc->txdma.dma_tag, sc->txdma.dma_map, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); - return (0); + return (0); fail: - em_free_transmit_structures(adapter); + em_free_transmit_structures(sc); return (error); } @@ -2520,72 +2433,67 @@ em_setup_transmit_structures(struct adapter * adapter) * **********************************************************************/ static void -em_initialize_transmit_unit(struct adapter * adapter) +em_initialize_transmit_unit(struct em_softc *sc) { - u_int32_t reg_tctl; - u_int32_t reg_tipg = 0; - u_int64_t bus_addr; + uint32_t reg_tctl; + uint32_t reg_tipg = 0; + uint64_t bus_addr; - INIT_DEBUGOUT("em_initialize_transmit_unit: begin"); + INIT_DEBUGOUT("em_initialize_transmit_unit: begin"); /* Setup the Base and Length of the Tx Descriptor Ring */ - bus_addr = adapter->txdma.dma_paddr; - E1000_WRITE_REG(&adapter->hw, TDBAL, (u_int32_t)bus_addr); - E1000_WRITE_REG(&adapter->hw, TDBAH, (u_int32_t)(bus_addr >> 32)); - E1000_WRITE_REG(&adapter->hw, TDLEN, - adapter->num_tx_desc * - sizeof(struct em_tx_desc)); + bus_addr = sc->txdma.dma_paddr; + E1000_WRITE_REG(&sc->hw, TDBAL, (uint32_t)bus_addr); + E1000_WRITE_REG(&sc->hw, TDBAH, (uint32_t)(bus_addr >> 32)); + E1000_WRITE_REG(&sc->hw, TDLEN, + sc->num_tx_desc * sizeof(struct em_tx_desc)); /* Setup the HW Tx Head and Tail descriptor pointers */ - E1000_WRITE_REG(&adapter->hw, TDH, 0); - E1000_WRITE_REG(&adapter->hw, TDT, 0); + E1000_WRITE_REG(&sc->hw, TDH, 0); + E1000_WRITE_REG(&sc->hw, TDT, 0); - HW_DEBUGOUT2("Base = %x, Length = %x\n", - E1000_READ_REG(&adapter->hw, TDBAL), - E1000_READ_REG(&adapter->hw, TDLEN)); + HW_DEBUGOUT2("Base = %x, Length = %x\n", E1000_READ_REG(&sc->hw, TDBAL), + E1000_READ_REG(&sc->hw, TDLEN)); /* Set the default values for the Tx Inter Packet Gap timer */ - switch (adapter->hw.mac_type) { + switch (sc->hw.mac_type) { case em_82542_rev2_0: - case em_82542_rev2_1: - reg_tipg = DEFAULT_82542_TIPG_IPGT; - reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; - reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; - break; - default: - if (adapter->hw.media_type == em_media_type_fiber) - reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; - else - reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; - reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; - reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; - } + case em_82542_rev2_1: + reg_tipg = DEFAULT_82542_TIPG_IPGT; + reg_tipg |= DEFAULT_82542_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; + reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; + break; + default: + if (sc->hw.media_type == em_media_type_fiber) + reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; + else + reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; + reg_tipg |= DEFAULT_82543_TIPG_IPGR1 << E1000_TIPG_IPGR1_SHIFT; + reg_tipg |= DEFAULT_82543_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; + } - E1000_WRITE_REG(&adapter->hw, TIPG, reg_tipg); - E1000_WRITE_REG(&adapter->hw, TIDV, adapter->tx_int_delay.value); - if(adapter->hw.mac_type >= em_82540) - E1000_WRITE_REG(&adapter->hw, TADV, - adapter->tx_abs_int_delay.value); + E1000_WRITE_REG(&sc->hw, TIPG, reg_tipg); + E1000_WRITE_REG(&sc->hw, TIDV, sc->tx_int_delay.value); + if(sc->hw.mac_type >= em_82540) + E1000_WRITE_REG(&sc->hw, TADV, sc->tx_abs_int_delay.value); /* Program the Transmit Control Register */ reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); - if (adapter->hw.mac_type >= em_82571) + if (sc->hw.mac_type >= em_82571) reg_tctl |= E1000_TCTL_MULR; - if (adapter->link_duplex == 1) { + if (sc->link_duplex == 1) { reg_tctl |= E1000_FDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; } else { reg_tctl |= E1000_HDX_COLLISION_DISTANCE << E1000_COLD_SHIFT; } - E1000_WRITE_REG(&adapter->hw, TCTL, reg_tctl); + E1000_WRITE_REG(&sc->hw, TCTL, reg_tctl); /* Setup Transmit Descriptor Settings for this adapter */ - adapter->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; + sc->txd_cmd = E1000_TXD_CMD_IFCS | E1000_TXD_CMD_RS; - if (adapter->tx_int_delay.value > 0) - adapter->txd_cmd |= E1000_TXD_CMD_IDE; - - return; + if (sc->tx_int_delay.value > 0) + sc->txd_cmd |= E1000_TXD_CMD_IDE; } /********************************************************************* @@ -2594,42 +2502,41 @@ em_initialize_transmit_unit(struct adapter * adapter) * **********************************************************************/ static void -em_free_transmit_structures(struct adapter * adapter) +em_free_transmit_structures(struct em_softc *sc) { - struct em_buffer *tx_buffer; - int i; + struct em_buffer *tx_buffer; + int i; - INIT_DEBUGOUT("free_transmit_structures: begin"); + INIT_DEBUGOUT("free_transmit_structures: begin"); - if (adapter->tx_buffer_area != NULL) { - tx_buffer = adapter->tx_buffer_area; - for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { - if (tx_buffer->m_head != NULL) { - bus_dmamap_sync(adapter->txtag, tx_buffer->map, + if (sc->tx_buffer_area != NULL) { + tx_buffer = sc->tx_buffer_area; + for (i = 0; i < sc->num_tx_desc; i++, tx_buffer++) { + if (tx_buffer->m_head != NULL) { + bus_dmamap_sync(sc->txtag, tx_buffer->map, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(adapter->txtag, + bus_dmamap_unload(sc->txtag, tx_buffer->map); - m_freem(tx_buffer->m_head); + m_freem(tx_buffer->m_head); tx_buffer->m_head = NULL; - } else if (tx_buffer->map != NULL) - bus_dmamap_unload(adapter->txtag, + } else if (tx_buffer->map != NULL) + bus_dmamap_unload(sc->txtag, tx_buffer->map); if (tx_buffer->map != NULL) { - bus_dmamap_destroy(adapter->txtag, + bus_dmamap_destroy(sc->txtag, tx_buffer->map); tx_buffer->map = NULL; } - } - } - if (adapter->tx_buffer_area != NULL) { - free(adapter->tx_buffer_area, M_DEVBUF); - adapter->tx_buffer_area = NULL; - } - if (adapter->txtag != NULL) { - bus_dma_tag_destroy(adapter->txtag); - adapter->txtag = NULL; - } - return; + } + } + if (sc->tx_buffer_area != NULL) { + free(sc->tx_buffer_area, M_DEVBUF); + sc->tx_buffer_area = NULL; + } + if (sc->txtag != NULL) { + bus_dma_tag_destroy(sc->txtag); + sc->txtag = NULL; + } } /********************************************************************* @@ -2640,10 +2547,8 @@ em_free_transmit_structures(struct adapter * adapter) * **********************************************************************/ static void -em_transmit_checksum_setup(struct adapter * adapter, - struct mbuf *mp, - u_int32_t *txd_upper, - u_int32_t *txd_lower) +em_transmit_checksum_setup(struct em_softc *sc, struct mbuf *mp, + uint32_t *txd_upper, uint32_t *txd_lower) { struct em_context_desc *TXD; struct em_buffer *tx_buffer; @@ -2654,18 +2559,18 @@ em_transmit_checksum_setup(struct adapter * adapter, if (mp->m_pkthdr.csum_flags & CSUM_TCP) { *txd_upper = E1000_TXD_POPTS_TXSM << 8; *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; - if (adapter->active_checksum_context == OFFLOAD_TCP_IP) + if (sc->active_checksum_context == OFFLOAD_TCP_IP) return; else - adapter->active_checksum_context = OFFLOAD_TCP_IP; + sc->active_checksum_context = OFFLOAD_TCP_IP; } else if (mp->m_pkthdr.csum_flags & CSUM_UDP) { *txd_upper = E1000_TXD_POPTS_TXSM << 8; *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; - if (adapter->active_checksum_context == OFFLOAD_UDP_IP) + if (sc->active_checksum_context == OFFLOAD_UDP_IP) return; else - adapter->active_checksum_context = OFFLOAD_UDP_IP; + sc->active_checksum_context = OFFLOAD_UDP_IP; } else { *txd_upper = 0; *txd_lower = 0; @@ -2680,9 +2585,9 @@ em_transmit_checksum_setup(struct adapter * adapter, /* If we reach this point, the checksum offload context * needs to be reset. */ - curr_txd = adapter->next_avail_tx_desc; - tx_buffer = &adapter->tx_buffer_area[curr_txd]; - TXD = (struct em_context_desc *) &adapter->tx_desc_base[curr_txd]; + curr_txd = sc->next_avail_tx_desc; + tx_buffer = &sc->tx_buffer_area[curr_txd]; + TXD = (struct em_context_desc *) &sc->tx_desc_base[curr_txd]; TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; TXD->lower_setup.ip_fields.ipcso = @@ -2694,28 +2599,26 @@ em_transmit_checksum_setup(struct adapter * adapter, ETHER_HDR_LEN + sizeof(struct ip); TXD->upper_setup.tcp_fields.tucse = htole16(0); - if (adapter->active_checksum_context == OFFLOAD_TCP_IP) { + if (sc->active_checksum_context == OFFLOAD_TCP_IP) { TXD->upper_setup.tcp_fields.tucso = ETHER_HDR_LEN + sizeof(struct ip) + offsetof(struct tcphdr, th_sum); - } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { + } else if (sc->active_checksum_context == OFFLOAD_UDP_IP) { TXD->upper_setup.tcp_fields.tucso = ETHER_HDR_LEN + sizeof(struct ip) + offsetof(struct udphdr, uh_sum); } TXD->tcp_seg_setup.data = htole32(0); - TXD->cmd_and_length = htole32(adapter->txd_cmd | E1000_TXD_CMD_DEXT); + TXD->cmd_and_length = htole32(sc->txd_cmd | E1000_TXD_CMD_DEXT); tx_buffer->m_head = NULL; - if (++curr_txd == adapter->num_tx_desc) + if (++curr_txd == sc->num_tx_desc) curr_txd = 0; - adapter->num_tx_desc_avail--; - adapter->next_avail_tx_desc = curr_txd; - - return; + sc->num_tx_desc_avail--; + sc->next_avail_tx_desc = curr_txd; } /********************************************************************** @@ -2726,67 +2629,66 @@ em_transmit_checksum_setup(struct adapter * adapter, * **********************************************************************/ static void -em_clean_transmit_interrupts(struct adapter * adapter) +em_txeof(struct em_softc *sc) { - int i, num_avail; - struct em_buffer *tx_buffer; - struct em_tx_desc *tx_desc; - struct ifnet *ifp = adapter->ifp; + int i, num_avail; + struct em_buffer *tx_buffer; + struct em_tx_desc *tx_desc; + struct ifnet *ifp = sc->ifp; - mtx_assert(&adapter->mtx, MA_OWNED); + EM_LOCK_ASSERT(sc); - if (adapter->num_tx_desc_avail == adapter->num_tx_desc) - return; + if (sc->num_tx_desc_avail == sc->num_tx_desc) + return; - num_avail = adapter->num_tx_desc_avail; - i = adapter->oldest_used_tx_desc; + num_avail = sc->num_tx_desc_avail; + i = sc->oldest_used_tx_desc; - tx_buffer = &adapter->tx_buffer_area[i]; - tx_desc = &adapter->tx_desc_base[i]; + tx_buffer = &sc->tx_buffer_area[i]; + tx_desc = &sc->tx_desc_base[i]; - bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, - BUS_DMASYNC_POSTREAD); - while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { + bus_dmamap_sync(sc->txdma.dma_tag, sc->txdma.dma_map, + BUS_DMASYNC_POSTREAD); + while (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { - tx_desc->upper.data = 0; - num_avail++; + tx_desc->upper.data = 0; + num_avail++; - if (tx_buffer->m_head) { + if (tx_buffer->m_head) { ifp->if_opackets++; - bus_dmamap_sync(adapter->txtag, tx_buffer->map, + bus_dmamap_sync(sc->txtag, tx_buffer->map, BUS_DMASYNC_POSTWRITE); - bus_dmamap_unload(adapter->txtag, tx_buffer->map); + bus_dmamap_unload(sc->txtag, tx_buffer->map); - m_freem(tx_buffer->m_head); - tx_buffer->m_head = NULL; - } + m_freem(tx_buffer->m_head); + tx_buffer->m_head = NULL; + } - if (++i == adapter->num_tx_desc) - i = 0; + if (++i == sc->num_tx_desc) + i = 0; - tx_buffer = &adapter->tx_buffer_area[i]; - tx_desc = &adapter->tx_desc_base[i]; - } - bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map, - BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); + tx_buffer = &sc->tx_buffer_area[i]; + tx_desc = &sc->tx_desc_base[i]; + } + bus_dmamap_sync(sc->txdma.dma_tag, sc->txdma.dma_map, + BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); - adapter->oldest_used_tx_desc = i; + sc->oldest_used_tx_desc = i; - /* - * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack - * that it is OK to send packets. - * If there are no pending descriptors, clear the timeout. Otherwise, - * if some descriptors have been freed, restart the timeout. - */ - if (num_avail > EM_TX_CLEANUP_THRESHOLD) { - ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; - if (num_avail == adapter->num_tx_desc) - ifp->if_timer = 0; - else if (num_avail != adapter->num_tx_desc_avail) - ifp->if_timer = EM_TX_TIMEOUT; - } - adapter->num_tx_desc_avail = num_avail; - return; + /* + * If we have enough room, clear IFF_DRV_OACTIVE to tell the stack + * that it is OK to send packets. + * If there are no pending descriptors, clear the timeout. Otherwise, + * if some descriptors have been freed, restart the timeout. + */ + if (num_avail > EM_TX_CLEANUP_THRESHOLD) { + ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; + if (num_avail == sc->num_tx_desc) + ifp->if_timer = 0; + else if (num_avail != sc->num_tx_desc_avail) + ifp->if_timer = EM_TX_TIMEOUT; + } + sc->num_tx_desc_avail = num_avail; } /********************************************************************* @@ -2795,9 +2697,9 @@ em_clean_transmit_interrupts(struct adapter * adapter) * **********************************************************************/ static int -em_get_buf(int i, struct adapter *adapter, struct mbuf *mp) +em_get_buf(int i, struct em_softc *sc, struct mbuf *mp) { - struct ifnet *ifp = adapter->ifp; + struct ifnet *ifp = sc->ifp; bus_dma_segment_t segs[1]; struct em_buffer *rx_buffer; int error, nsegs; @@ -2805,8 +2707,8 @@ em_get_buf(int i, struct adapter *adapter, struct mbuf *mp) if (mp == NULL) { mp = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); if (mp == NULL) { - adapter->mbuf_cluster_failed++; - return(ENOBUFS); + sc->mbuf_cluster_failed++; + return (ENOBUFS); } mp->m_len = mp->m_pkthdr.len = MCLBYTES; } else { @@ -2816,15 +2718,15 @@ em_get_buf(int i, struct adapter *adapter, struct mbuf *mp) } if (ifp->if_mtu <= ETHERMTU) - m_adj(mp, ETHER_ALIGN); + m_adj(mp, ETHER_ALIGN); - rx_buffer = &adapter->rx_buffer_area[i]; + rx_buffer = &sc->rx_buffer_area[i]; /* * Using memory from the mbuf cluster pool, invoke the * bus_dma machinery to arrange the memory mapping. */ - error = bus_dmamap_load_mbuf_sg(adapter->rxtag, rx_buffer->map, + error = bus_dmamap_load_mbuf_sg(sc->rxtag, rx_buffer->map, mp, segs, &nsegs, 0); if (error != 0) { m_free(mp); @@ -2833,10 +2735,10 @@ em_get_buf(int i, struct adapter *adapter, struct mbuf *mp) /* If nsegs is wrong then the stack is corrupt. */ KASSERT(nsegs == 1, ("Too many segments returned!")); rx_buffer->m_head = mp; - adapter->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr); - bus_dmamap_sync(adapter->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); + sc->rx_desc_base[i].buffer_addr = htole64(segs[0].ds_addr); + bus_dmamap_sync(sc->rxtag, rx_buffer->map, BUS_DMASYNC_PREREAD); - return(0); + return (0); } /********************************************************************* @@ -2848,67 +2750,63 @@ em_get_buf(int i, struct adapter *adapter, struct mbuf *mp) * **********************************************************************/ static int -em_allocate_receive_structures(struct adapter * adapter) +em_allocate_receive_structures(struct em_softc *sc) { - int i, error; - struct em_buffer *rx_buffer; + device_t dev = sc->dev; + struct em_buffer *rx_buffer; + int i, error; - if (!(adapter->rx_buffer_area = - (struct em_buffer *) malloc(sizeof(struct em_buffer) * - adapter->num_rx_desc, M_DEVBUF, - M_NOWAIT))) { - printf("em%d: Unable to allocate rx_buffer memory\n", - adapter->unit); - return(ENOMEM); - } + sc->rx_buffer_area = malloc(sizeof(struct em_buffer) * sc->num_rx_desc, + M_DEVBUF, M_NOWAIT); + if (sc->rx_buffer_area == NULL) { + device_printf(dev, "Unable to allocate rx_buffer memory\n"); + return (ENOMEM); + } - bzero(adapter->rx_buffer_area, - sizeof(struct em_buffer) * adapter->num_rx_desc); + bzero(sc->rx_buffer_area, sizeof(struct em_buffer) * sc->num_rx_desc); - error = bus_dma_tag_create(NULL, /* parent */ - 1, 0, /* alignment, bounds */ - BUS_SPACE_MAXADDR, /* lowaddr */ - BUS_SPACE_MAXADDR, /* highaddr */ - NULL, NULL, /* filter, filterarg */ - MCLBYTES, /* maxsize */ - 1, /* nsegments */ - MCLBYTES, /* maxsegsize */ - BUS_DMA_ALLOCNOW, /* flags */ - NULL, /* lockfunc */ - NULL, /* lockarg */ - &adapter->rxtag); - if (error != 0) { - printf("em%d: em_allocate_receive_structures: " - "bus_dma_tag_create failed; error %u\n", - adapter->unit, error); - goto fail; - } + error = bus_dma_tag_create(NULL, /* parent */ + 1, 0, /* alignment, bounds */ + BUS_SPACE_MAXADDR, /* lowaddr */ + BUS_SPACE_MAXADDR, /* highaddr */ + NULL, NULL, /* filter, filterarg */ + MCLBYTES, /* maxsize */ + 1, /* nsegments */ + MCLBYTES, /* maxsegsize */ + BUS_DMA_ALLOCNOW, /* flags */ + NULL, /* lockfunc */ + NULL, /* lockarg */ + &sc->rxtag); + if (error) { + device_printf(dev, "%s: bus_dma_tag_create failed %d\n", + __func__, error); + goto fail; + } - rx_buffer = adapter->rx_buffer_area; - for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { - error = bus_dmamap_create(adapter->rxtag, BUS_DMA_NOWAIT, - &rx_buffer->map); - if (error != 0) { - printf("em%d: em_allocate_receive_structures: " - "bus_dmamap_create failed; error %u\n", - adapter->unit, error); - goto fail; - } - } - - for (i = 0; i < adapter->num_rx_desc; i++) { - error = em_get_buf(i, adapter, NULL); - if (error != 0) + rx_buffer = sc->rx_buffer_area; + for (i = 0; i < sc->num_rx_desc; i++, rx_buffer++) { + error = bus_dmamap_create(sc->rxtag, BUS_DMA_NOWAIT, + &rx_buffer->map); + if (error) { + device_printf(dev, "%s: bus_dmamap_create failed: %d\n", + __func__, error); goto fail; - } - bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, - BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); + } + } - return(0); + for (i = 0; i < sc->num_rx_desc; i++) { + error = em_get_buf(i, sc, NULL); + if (error) + goto fail; + } + bus_dmamap_sync(sc->rxdma.dma_tag, sc->rxdma.dma_map, + BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); + + return (0); fail: - em_free_receive_structures(adapter); - return (error); + em_free_receive_structures(sc); + return (error); } /********************************************************************* @@ -2917,17 +2815,19 @@ em_allocate_receive_structures(struct adapter * adapter) * **********************************************************************/ static int -em_setup_receive_structures(struct adapter * adapter) +em_setup_receive_structures(struct em_softc *sc) { - bzero((void *) adapter->rx_desc_base, - (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); + int error; - if (em_allocate_receive_structures(adapter)) - return ENOMEM; + bzero(sc->rx_desc_base, (sizeof(struct em_rx_desc)) * sc->num_rx_desc); + + if ((error = em_allocate_receive_structures(sc)) != 0) + return (error); /* Setup our descriptor pointers */ - adapter->next_rx_desc_to_check = 0; - return(0); + sc->next_rx_desc_to_check = 0; + + return (0); } /********************************************************************* @@ -2936,55 +2836,57 @@ em_setup_receive_structures(struct adapter * adapter) * **********************************************************************/ static void -em_initialize_receive_unit(struct adapter * adapter) +em_initialize_receive_unit(struct em_softc *sc) { - u_int32_t reg_rctl; - u_int32_t reg_rxcsum; - struct ifnet *ifp; - u_int64_t bus_addr; + struct ifnet *ifp = sc->ifp; + uint64_t bus_addr; + uint32_t reg_rctl; + uint32_t reg_rxcsum; - INIT_DEBUGOUT("em_initialize_receive_unit: begin"); - ifp = adapter->ifp; + INIT_DEBUGOUT("em_initialize_receive_unit: begin"); - /* Make sure receives are disabled while setting up the descriptor ring */ - E1000_WRITE_REG(&adapter->hw, RCTL, 0); + /* + * Make sure receives are disabled while setting + * up the descriptor ring + */ + E1000_WRITE_REG(&sc->hw, RCTL, 0); /* Set the Receive Delay Timer Register */ - E1000_WRITE_REG(&adapter->hw, RDTR, - adapter->rx_int_delay.value | E1000_RDT_FPDB); + E1000_WRITE_REG(&sc->hw, RDTR, sc->rx_int_delay.value | E1000_RDT_FPDB); - if(adapter->hw.mac_type >= em_82540) { - E1000_WRITE_REG(&adapter->hw, RADV, - adapter->rx_abs_int_delay.value); + if(sc->hw.mac_type >= em_82540) { + E1000_WRITE_REG(&sc->hw, RADV, sc->rx_abs_int_delay.value); - /* Set the interrupt throttling rate. Value is calculated - * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) */ -#define MAX_INTS_PER_SEC 8000 -#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) - E1000_WRITE_REG(&adapter->hw, ITR, DEFAULT_ITR); - } + /* + * Set the interrupt throttling rate. Value is calculated + * as DEFAULT_ITR = 1/(MAX_INTS_PER_SEC * 256ns) + */ +#define MAX_INTS_PER_SEC 8000 +#define DEFAULT_ITR 1000000000/(MAX_INTS_PER_SEC * 256) + E1000_WRITE_REG(&sc->hw, ITR, DEFAULT_ITR); + } /* Setup the Base and Length of the Rx Descriptor Ring */ - bus_addr = adapter->rxdma.dma_paddr; - E1000_WRITE_REG(&adapter->hw, RDBAL, (u_int32_t)bus_addr); - E1000_WRITE_REG(&adapter->hw, RDBAH, (u_int32_t)(bus_addr >> 32)); - E1000_WRITE_REG(&adapter->hw, RDLEN, adapter->num_rx_desc * + bus_addr = sc->rxdma.dma_paddr; + E1000_WRITE_REG(&sc->hw, RDBAL, (uint32_t)bus_addr); + E1000_WRITE_REG(&sc->hw, RDBAH, (uint32_t)(bus_addr >> 32)); + E1000_WRITE_REG(&sc->hw, RDLEN, sc->num_rx_desc * sizeof(struct em_rx_desc)); /* Setup the HW Rx Head and Tail Descriptor Pointers */ - E1000_WRITE_REG(&adapter->hw, RDH, 0); - E1000_WRITE_REG(&adapter->hw, RDT, adapter->num_rx_desc - 1); + E1000_WRITE_REG(&sc->hw, RDH, 0); + E1000_WRITE_REG(&sc->hw, RDT, sc->num_rx_desc - 1); /* Setup the Receive Control Register */ reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | - (adapter->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); + (sc->hw.mc_filter_type << E1000_RCTL_MO_SHIFT); - if (adapter->hw.tbi_compatibility_on == TRUE) + if (sc->hw.tbi_compatibility_on == TRUE) reg_rctl |= E1000_RCTL_SBP; - switch (adapter->rx_buffer_len) { + switch (sc->rx_buffer_len) { default: case EM_RXBUFFER_2048: reg_rctl |= E1000_RCTL_SZ_2048; @@ -3004,17 +2906,15 @@ em_initialize_receive_unit(struct adapter * adapter) reg_rctl |= E1000_RCTL_LPE; /* Enable 82543 Receive Checksum Offload for TCP and UDP */ - if ((adapter->hw.mac_type >= em_82543) && + if ((sc->hw.mac_type >= em_82543) && (ifp->if_capenable & IFCAP_RXCSUM)) { - reg_rxcsum = E1000_READ_REG(&adapter->hw, RXCSUM); + reg_rxcsum = E1000_READ_REG(&sc->hw, RXCSUM); reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); - E1000_WRITE_REG(&adapter->hw, RXCSUM, reg_rxcsum); + E1000_WRITE_REG(&sc->hw, RXCSUM, reg_rxcsum); } /* Enable Receives */ - E1000_WRITE_REG(&adapter->hw, RCTL, reg_rctl); - - return; + E1000_WRITE_REG(&sc->hw, RCTL, reg_rctl); } /********************************************************************* @@ -3023,42 +2923,41 @@ em_initialize_receive_unit(struct adapter * adapter) * **********************************************************************/ static void -em_free_receive_structures(struct adapter *adapter) +em_free_receive_structures(struct em_softc *sc) { - struct em_buffer *rx_buffer; - int i; + struct em_buffer *rx_buffer; + int i; - INIT_DEBUGOUT("free_receive_structures: begin"); + INIT_DEBUGOUT("free_receive_structures: begin"); - if (adapter->rx_buffer_area != NULL) { - rx_buffer = adapter->rx_buffer_area; - for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { + if (sc->rx_buffer_area != NULL) { + rx_buffer = sc->rx_buffer_area; + for (i = 0; i < sc->num_rx_desc; i++, rx_buffer++) { if (rx_buffer->m_head != NULL) { - bus_dmamap_sync(adapter->rxtag, rx_buffer->map, + bus_dmamap_sync(sc->rxtag, rx_buffer->map, BUS_DMASYNC_POSTREAD); - bus_dmamap_unload(adapter->rxtag, + bus_dmamap_unload(sc->rxtag, rx_buffer->map); m_freem(rx_buffer->m_head); rx_buffer->m_head = NULL; } else if (rx_buffer->map != NULL) - bus_dmamap_unload(adapter->rxtag, + bus_dmamap_unload(sc->rxtag, rx_buffer->map); - if (rx_buffer->map != NULL) { - bus_dmamap_destroy(adapter->rxtag, + if (rx_buffer->map != NULL) { + bus_dmamap_destroy(sc->rxtag, rx_buffer->map); rx_buffer->map = NULL; } - } - } - if (adapter->rx_buffer_area != NULL) { - free(adapter->rx_buffer_area, M_DEVBUF); - adapter->rx_buffer_area = NULL; - } - if (adapter->rxtag != NULL) { - bus_dma_tag_destroy(adapter->rxtag); - adapter->rxtag = NULL; - } - return; + } + } + if (sc->rx_buffer_area != NULL) { + free(sc->rx_buffer_area, M_DEVBUF); + sc->rx_buffer_area = NULL; + } + if (sc->rxtag != NULL) { + bus_dma_tag_destroy(sc->rxtag); + sc->rxtag = NULL; + } } /********************************************************************* @@ -3072,7 +2971,7 @@ em_free_receive_structures(struct adapter *adapter) * *********************************************************************/ static int -em_process_receive_interrupts(struct adapter * adapter, int count) +em_rxeof(struct em_softc *sc, int count) { struct ifnet *ifp; struct mbuf *mp; @@ -3084,10 +2983,10 @@ em_process_receive_interrupts(struct adapter * adapter, int count) /* Pointer to the receive descriptor being examined. */ struct em_rx_desc *current_desc; - ifp = adapter->ifp; - i = adapter->next_rx_desc_to_check; - current_desc = &adapter->rx_desc_base[i]; - bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, + ifp = sc->ifp; + i = sc->next_rx_desc_to_check; + current_desc = &sc->rx_desc_base[i]; + bus_dmamap_sync(sc->rxdma.dma_tag, sc->rxdma.dma_map, BUS_DMASYNC_POSTREAD); if (!((current_desc->status) & E1000_RXD_STAT_DD)) @@ -3098,11 +2997,11 @@ em_process_receive_interrupts(struct adapter * adapter, int count) (ifp->if_drv_flags & IFF_DRV_RUNNING)) { struct mbuf *m = NULL; - mp = adapter->rx_buffer_area[i].m_head; - bus_dmamap_sync(adapter->rxtag, adapter->rx_buffer_area[i].map, + mp = sc->rx_buffer_area[i].m_head; + bus_dmamap_sync(sc->rxtag, sc->rx_buffer_area[i].map, BUS_DMASYNC_POSTREAD); - bus_dmamap_unload(adapter->rxtag, - adapter->rx_buffer_area[i].map); + bus_dmamap_unload(sc->rxtag, + sc->rx_buffer_area[i].map); accept_frame = 1; prev_len_adj = 0; @@ -3124,16 +3023,16 @@ em_process_receive_interrupts(struct adapter * adapter, int count) uint8_t last_byte; uint32_t pkt_len = desc_len; - if (adapter->fmp != NULL) - pkt_len += adapter->fmp->m_pkthdr.len; + if (sc->fmp != NULL) + pkt_len += sc->fmp->m_pkthdr.len; last_byte = *(mtod(mp, caddr_t) + desc_len - 1); - if (TBI_ACCEPT(&adapter->hw, current_desc->status, + if (TBI_ACCEPT(&sc->hw, current_desc->status, current_desc->errors, pkt_len, last_byte)) { - em_tbi_adjust_stats(&adapter->hw, - &adapter->stats, pkt_len, - adapter->hw.mac_addr); + em_tbi_adjust_stats(&sc->hw, + &sc->stats, pkt_len, + sc->hw.mac_addr); if (len > 0) len--; } else @@ -3141,23 +3040,23 @@ em_process_receive_interrupts(struct adapter * adapter, int count) } if (accept_frame) { - if (em_get_buf(i, adapter, NULL) == ENOBUFS) { - adapter->dropped_pkts++; - em_get_buf(i, adapter, mp); - if (adapter->fmp != NULL) - m_freem(adapter->fmp); - adapter->fmp = NULL; - adapter->lmp = NULL; + if (em_get_buf(i, sc, NULL) == ENOBUFS) { + sc->dropped_pkts++; + em_get_buf(i, sc, mp); + if (sc->fmp != NULL) + m_freem(sc->fmp); + sc->fmp = NULL; + sc->lmp = NULL; break; } /* Assign correct length to the current fragment */ mp->m_len = len; - if (adapter->fmp == NULL) { + if (sc->fmp == NULL) { mp->m_pkthdr.len = len; - adapter->fmp = mp; /* Store the first mbuf */ - adapter->lmp = mp; + sc->fmp = mp; /* Store the first mbuf */ + sc->lmp = mp; } else { /* Chain mbuf's together */ mp->m_flags &= ~M_PKTHDR; @@ -3167,66 +3066,66 @@ em_process_receive_interrupts(struct adapter * adapter, int count) * descriptor. */ if (prev_len_adj > 0) { - adapter->lmp->m_len -= prev_len_adj; - adapter->fmp->m_pkthdr.len -= + sc->lmp->m_len -= prev_len_adj; + sc->fmp->m_pkthdr.len -= prev_len_adj; } - adapter->lmp->m_next = mp; - adapter->lmp = adapter->lmp->m_next; - adapter->fmp->m_pkthdr.len += len; + sc->lmp->m_next = mp; + sc->lmp = sc->lmp->m_next; + sc->fmp->m_pkthdr.len += len; } if (eop) { - adapter->fmp->m_pkthdr.rcvif = ifp; + sc->fmp->m_pkthdr.rcvif = ifp; ifp->if_ipackets++; - em_receive_checksum(adapter, current_desc, - adapter->fmp); + em_receive_checksum(sc, current_desc, + sc->fmp); #ifndef __NO_STRICT_ALIGNMENT if (ifp->if_mtu > ETHERMTU && - em_fixup_rx(adapter) != 0) + em_fixup_rx(sc) != 0) goto skip; #endif if (current_desc->status & E1000_RXD_STAT_VP) - VLAN_INPUT_TAG(ifp, adapter->fmp, + VLAN_INPUT_TAG(ifp, sc->fmp, (le16toh(current_desc->special) & E1000_RXD_SPC_VLAN_MASK)); #ifndef __NO_STRICT_ALIGNMENT skip: #endif - m = adapter->fmp; - adapter->fmp = NULL; - adapter->lmp = NULL; + m = sc->fmp; + sc->fmp = NULL; + sc->lmp = NULL; } } else { - adapter->dropped_pkts++; - em_get_buf(i, adapter, mp); - if (adapter->fmp != NULL) - m_freem(adapter->fmp); - adapter->fmp = NULL; - adapter->lmp = NULL; + sc->dropped_pkts++; + em_get_buf(i, sc, mp); + if (sc->fmp != NULL) + m_freem(sc->fmp); + sc->fmp = NULL; + sc->lmp = NULL; } /* Zero out the receive descriptors status. */ current_desc->status = 0; - bus_dmamap_sync(adapter->rxdma.dma_tag, adapter->rxdma.dma_map, + bus_dmamap_sync(sc->rxdma.dma_tag, sc->rxdma.dma_map, BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE); /* Advance our pointers to the next descriptor. */ - if (++i == adapter->num_rx_desc) + if (++i == sc->num_rx_desc) i = 0; if (m != NULL) { - adapter->next_rx_desc_to_check = i; + sc->next_rx_desc_to_check = i; (*ifp->if_input)(ifp, m); - i = adapter->next_rx_desc_to_check; + i = sc->next_rx_desc_to_check; } - current_desc = &adapter->rx_desc_base[i]; + current_desc = &sc->rx_desc_base[i]; } - adapter->next_rx_desc_to_check = i; + sc->next_rx_desc_to_check = i; /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ if (--i < 0) - i = adapter->num_rx_desc - 1; - E1000_WRITE_REG(&adapter->hw, RDT, i); + i = sc->num_rx_desc - 1; + E1000_WRITE_REG(&sc->hw, RDT, i); if (!((current_desc->status) & E1000_RXD_STAT_DD)) return (0); @@ -3249,13 +3148,13 @@ em_process_receive_interrupts(struct adapter * adapter, int count) * not used at all on architectures with strict alignment. */ static int -em_fixup_rx(struct adapter *adapter) +em_fixup_rx(struct em_softc *sc) { struct mbuf *m, *n; int error; error = 0; - m = adapter->fmp; + m = sc->fmp; if (m->m_len <= (MCLBYTES - ETHER_HDR_LEN)) { bcopy(m->m_data, m->m_data + ETHER_HDR_LEN, m->m_len); m->m_data += ETHER_HDR_LEN; @@ -3268,11 +3167,11 @@ em_fixup_rx(struct adapter *adapter) n->m_len = ETHER_HDR_LEN; M_MOVE_PKTHDR(n, m); n->m_next = m; - adapter->fmp = n; + sc->fmp = n; } else { - adapter->dropped_pkts++; - m_freem(adapter->fmp); - adapter->fmp = NULL; + sc->dropped_pkts++; + m_freem(sc->fmp); + sc->fmp = NULL; error = ENOMEM; } } @@ -3289,12 +3188,11 @@ em_fixup_rx(struct adapter *adapter) * *********************************************************************/ static void -em_receive_checksum(struct adapter *adapter, - struct em_rx_desc *rx_desc, +em_receive_checksum(struct em_softc *sc, struct em_rx_desc *rx_desc, struct mbuf *mp) { /* 82543 or newer only */ - if ((adapter->hw.mac_type < em_82543) || + if ((sc->hw.mac_type < em_82543) || /* Ignore Checksum bit is set */ (rx_desc->status & E1000_RXD_STAT_IXSM)) { mp->m_pkthdr.csum_flags = 0; @@ -3321,46 +3219,39 @@ em_receive_checksum(struct adapter *adapter, mp->m_pkthdr.csum_data = htons(0xffff); } } - - return; } static void -em_enable_vlans(struct adapter *adapter) +em_enable_vlans(struct em_softc *sc) { uint32_t ctrl; - E1000_WRITE_REG(&adapter->hw, VET, ETHERTYPE_VLAN); + E1000_WRITE_REG(&sc->hw, VET, ETHERTYPE_VLAN); - ctrl = E1000_READ_REG(&adapter->hw, CTRL); + ctrl = E1000_READ_REG(&sc->hw, CTRL); ctrl |= E1000_CTRL_VME; - E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); - - return; + E1000_WRITE_REG(&sc->hw, CTRL, ctrl); } static void -em_disable_vlans(struct adapter *adapter) +em_disable_vlans(struct em_softc *sc) { uint32_t ctrl; - ctrl = E1000_READ_REG(&adapter->hw, CTRL); + ctrl = E1000_READ_REG(&sc->hw, CTRL); ctrl &= ~E1000_CTRL_VME; - E1000_WRITE_REG(&adapter->hw, CTRL, ctrl); - - return; + E1000_WRITE_REG(&sc->hw, CTRL, ctrl); } static void -em_enable_intr(struct adapter * adapter) +em_enable_intr(struct em_softc *sc) { - E1000_WRITE_REG(&adapter->hw, IMS, (IMS_ENABLE_MASK)); - return; + E1000_WRITE_REG(&sc->hw, IMS, (IMS_ENABLE_MASK)); } static void -em_disable_intr(struct adapter *adapter) +em_disable_intr(struct em_softc *sc) { /* * The first version of 82542 had an errata where when link was forced @@ -3371,61 +3262,50 @@ em_disable_intr(struct adapter *adapter) * all the time. */ - if (adapter->hw.mac_type == em_82542_rev2_0) - E1000_WRITE_REG(&adapter->hw, IMC, - (0xffffffff & ~E1000_IMC_RXSEQ)); + if (sc->hw.mac_type == em_82542_rev2_0) + E1000_WRITE_REG(&sc->hw, IMC, + (0xffffffff & ~E1000_IMC_RXSEQ)); else - E1000_WRITE_REG(&adapter->hw, IMC, - 0xffffffff); - return; + E1000_WRITE_REG(&sc->hw, IMC, + 0xffffffff); } static int -em_is_valid_ether_addr(u_int8_t *addr) +em_is_valid_ether_addr(uint8_t *addr) { - char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; + char zero_addr[6] = { 0, 0, 0, 0, 0, 0 }; - if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { - return (FALSE); - } + if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) { + return (FALSE); + } - return(TRUE); + return (TRUE); } void -em_write_pci_cfg(struct em_hw *hw, - uint32_t reg, - uint16_t *value) +em_write_pci_cfg(struct em_hw *hw, uint32_t reg, uint16_t *value) { - pci_write_config(((struct em_osdep *)hw->back)->dev, reg, - *value, 2); + pci_write_config(((struct em_osdep *)hw->back)->dev, reg, *value, 2); } void -em_read_pci_cfg(struct em_hw *hw, uint32_t reg, - uint16_t *value) +em_read_pci_cfg(struct em_hw *hw, uint32_t reg, uint16_t *value) { - *value = pci_read_config(((struct em_osdep *)hw->back)->dev, - reg, 2); - return; + *value = pci_read_config(((struct em_osdep *)hw->back)->dev, reg, 2); } void em_pci_set_mwi(struct em_hw *hw) { - pci_write_config(((struct em_osdep *)hw->back)->dev, - PCIR_COMMAND, - (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); - return; + pci_write_config(((struct em_osdep *)hw->back)->dev, PCIR_COMMAND, + (hw->pci_cmd_word | CMD_MEM_WRT_INVALIDATE), 2); } void em_pci_clear_mwi(struct em_hw *hw) { - pci_write_config(((struct em_osdep *)hw->back)->dev, - PCIR_COMMAND, - (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); - return; + pci_write_config(((struct em_osdep *)hw->back)->dev, PCIR_COMMAND, + (hw->pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE), 2); } /********************************************************************* @@ -3433,52 +3313,51 @@ em_pci_clear_mwi(struct em_hw *hw) * There are 2 issues. * 1. Transmit Hang issue. * To detect this issue, following equation can be used... -* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. -* If SUM[3:0] is in between 1 to 4, we will have this issue. +* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. +* If SUM[3:0] is in between 1 to 4, we will have this issue. * * 2. DAC issue. * To detect this issue, following equation can be used... -* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. -* If SUM[3:0] is in between 9 to c, we will have this issue. +* SIZE[3:0] + ADDR[2:0] = SUM[3:0]. +* If SUM[3:0] is in between 9 to c, we will have this issue. * * * WORKAROUND: -* Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC) +* Make sure we do not have ending address as 1,2,3,4(Hang) or 9,a,b,c (DAC) * *** *********************************************************************/ -static u_int32_t -em_fill_descriptors (bus_addr_t address, - u_int32_t length, - PDESC_ARRAY desc_array) +static uint32_t +em_fill_descriptors (bus_addr_t address, uint32_t length, + PDESC_ARRAY desc_array) { - /* Since issue is sensitive to length and address.*/ - /* Let us first check the address...*/ - u_int32_t safe_terminator; - if (length <= 4) { - desc_array->descriptor[0].address = address; - desc_array->descriptor[0].length = length; - desc_array->elements = 1; - return desc_array->elements; - } - safe_terminator = (u_int32_t)((((u_int32_t)address & 0x7) + (length & 0xF)) & 0xF); - /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */ - if (safe_terminator == 0 || - (safe_terminator > 4 && - safe_terminator < 9) || - (safe_terminator > 0xC && - safe_terminator <= 0xF)) { - desc_array->descriptor[0].address = address; - desc_array->descriptor[0].length = length; - desc_array->elements = 1; - return desc_array->elements; - } + /* Since issue is sensitive to length and address.*/ + /* Let us first check the address...*/ + uint32_t safe_terminator; + if (length <= 4) { + desc_array->descriptor[0].address = address; + desc_array->descriptor[0].length = length; + desc_array->elements = 1; + return (desc_array->elements); + } + safe_terminator = (uint32_t)((((uint32_t)address & 0x7) + (length & 0xF)) & 0xF); + /* if it does not fall between 0x1 to 0x4 and 0x9 to 0xC then return */ + if (safe_terminator == 0 || + (safe_terminator > 4 && + safe_terminator < 9) || + (safe_terminator > 0xC && + safe_terminator <= 0xF)) { + desc_array->descriptor[0].address = address; + desc_array->descriptor[0].length = length; + desc_array->elements = 1; + return (desc_array->elements); + } - desc_array->descriptor[0].address = address; - desc_array->descriptor[0].length = length - 4; - desc_array->descriptor[1].address = address + (length - 4); - desc_array->descriptor[1].length = 4; - desc_array->elements = 2; - return desc_array->elements; + desc_array->descriptor[0].address = address; + desc_array->descriptor[0].length = length - 4; + desc_array->descriptor[1].address = address + (length - 4); + desc_array->descriptor[1].length = 4; + desc_array->elements = 2; + return (desc_array->elements); } /********************************************************************** @@ -3487,102 +3366,91 @@ em_fill_descriptors (bus_addr_t address, * **********************************************************************/ static void -em_update_stats_counters(struct adapter *adapter) +em_update_stats_counters(struct em_softc *sc) { struct ifnet *ifp; - if(adapter->hw.media_type == em_media_type_copper || - (E1000_READ_REG(&adapter->hw, STATUS) & E1000_STATUS_LU)) { - adapter->stats.symerrs += E1000_READ_REG(&adapter->hw, SYMERRS); - adapter->stats.sec += E1000_READ_REG(&adapter->hw, SEC); + if(sc->hw.media_type == em_media_type_copper || + (E1000_READ_REG(&sc->hw, STATUS) & E1000_STATUS_LU)) { + sc->stats.symerrs += E1000_READ_REG(&sc->hw, SYMERRS); + sc->stats.sec += E1000_READ_REG(&sc->hw, SEC); } - adapter->stats.crcerrs += E1000_READ_REG(&adapter->hw, CRCERRS); - adapter->stats.mpc += E1000_READ_REG(&adapter->hw, MPC); - adapter->stats.scc += E1000_READ_REG(&adapter->hw, SCC); - adapter->stats.ecol += E1000_READ_REG(&adapter->hw, ECOL); + sc->stats.crcerrs += E1000_READ_REG(&sc->hw, CRCERRS); + sc->stats.mpc += E1000_READ_REG(&sc->hw, MPC); + sc->stats.scc += E1000_READ_REG(&sc->hw, SCC); + sc->stats.ecol += E1000_READ_REG(&sc->hw, ECOL); - adapter->stats.mcc += E1000_READ_REG(&adapter->hw, MCC); - adapter->stats.latecol += E1000_READ_REG(&adapter->hw, LATECOL); - adapter->stats.colc += E1000_READ_REG(&adapter->hw, COLC); - adapter->stats.dc += E1000_READ_REG(&adapter->hw, DC); - adapter->stats.rlec += E1000_READ_REG(&adapter->hw, RLEC); - adapter->stats.xonrxc += E1000_READ_REG(&adapter->hw, XONRXC); - adapter->stats.xontxc += E1000_READ_REG(&adapter->hw, XONTXC); - adapter->stats.xoffrxc += E1000_READ_REG(&adapter->hw, XOFFRXC); - adapter->stats.xofftxc += E1000_READ_REG(&adapter->hw, XOFFTXC); - adapter->stats.fcruc += E1000_READ_REG(&adapter->hw, FCRUC); - adapter->stats.prc64 += E1000_READ_REG(&adapter->hw, PRC64); - adapter->stats.prc127 += E1000_READ_REG(&adapter->hw, PRC127); - adapter->stats.prc255 += E1000_READ_REG(&adapter->hw, PRC255); - adapter->stats.prc511 += E1000_READ_REG(&adapter->hw, PRC511); - adapter->stats.prc1023 += E1000_READ_REG(&adapter->hw, PRC1023); - adapter->stats.prc1522 += E1000_READ_REG(&adapter->hw, PRC1522); - adapter->stats.gprc += E1000_READ_REG(&adapter->hw, GPRC); - adapter->stats.bprc += E1000_READ_REG(&adapter->hw, BPRC); - adapter->stats.mprc += E1000_READ_REG(&adapter->hw, MPRC); - adapter->stats.gptc += E1000_READ_REG(&adapter->hw, GPTC); + sc->stats.mcc += E1000_READ_REG(&sc->hw, MCC); + sc->stats.latecol += E1000_READ_REG(&sc->hw, LATECOL); + sc->stats.colc += E1000_READ_REG(&sc->hw, COLC); + sc->stats.dc += E1000_READ_REG(&sc->hw, DC); + sc->stats.rlec += E1000_READ_REG(&sc->hw, RLEC); + sc->stats.xonrxc += E1000_READ_REG(&sc->hw, XONRXC); + sc->stats.xontxc += E1000_READ_REG(&sc->hw, XONTXC); + sc->stats.xoffrxc += E1000_READ_REG(&sc->hw, XOFFRXC); + sc->stats.xofftxc += E1000_READ_REG(&sc->hw, XOFFTXC); + sc->stats.fcruc += E1000_READ_REG(&sc->hw, FCRUC); + sc->stats.prc64 += E1000_READ_REG(&sc->hw, PRC64); + sc->stats.prc127 += E1000_READ_REG(&sc->hw, PRC127); + sc->stats.prc255 += E1000_READ_REG(&sc->hw, PRC255); + sc->stats.prc511 += E1000_READ_REG(&sc->hw, PRC511); + sc->stats.prc1023 += E1000_READ_REG(&sc->hw, PRC1023); + sc->stats.prc1522 += E1000_READ_REG(&sc->hw, PRC1522); + sc->stats.gprc += E1000_READ_REG(&sc->hw, GPRC); + sc->stats.bprc += E1000_READ_REG(&sc->hw, BPRC); + sc->stats.mprc += E1000_READ_REG(&sc->hw, MPRC); + sc->stats.gptc += E1000_READ_REG(&sc->hw, GPTC); /* For the 64-bit byte counters the low dword must be read first. */ /* Both registers clear on the read of the high dword */ - adapter->stats.gorcl += E1000_READ_REG(&adapter->hw, GORCL); - adapter->stats.gorch += E1000_READ_REG(&adapter->hw, GORCH); - adapter->stats.gotcl += E1000_READ_REG(&adapter->hw, GOTCL); - adapter->stats.gotch += E1000_READ_REG(&adapter->hw, GOTCH); + sc->stats.gorcl += E1000_READ_REG(&sc->hw, GORCL); + sc->stats.gorch += E1000_READ_REG(&sc->hw, GORCH); + sc->stats.gotcl += E1000_READ_REG(&sc->hw, GOTCL); + sc->stats.gotch += E1000_READ_REG(&sc->hw, GOTCH); - adapter->stats.rnbc += E1000_READ_REG(&adapter->hw, RNBC); - adapter->stats.ruc += E1000_READ_REG(&adapter->hw, RUC); - adapter->stats.rfc += E1000_READ_REG(&adapter->hw, RFC); - adapter->stats.roc += E1000_READ_REG(&adapter->hw, ROC); - adapter->stats.rjc += E1000_READ_REG(&adapter->hw, RJC); + sc->stats.rnbc += E1000_READ_REG(&sc->hw, RNBC); + sc->stats.ruc += E1000_READ_REG(&sc->hw, RUC); + sc->stats.rfc += E1000_READ_REG(&sc->hw, RFC); + sc->stats.roc += E1000_READ_REG(&sc->hw, ROC); + sc->stats.rjc += E1000_READ_REG(&sc->hw, RJC); - adapter->stats.torl += E1000_READ_REG(&adapter->hw, TORL); - adapter->stats.torh += E1000_READ_REG(&adapter->hw, TORH); - adapter->stats.totl += E1000_READ_REG(&adapter->hw, TOTL); - adapter->stats.toth += E1000_READ_REG(&adapter->hw, TOTH); + sc->stats.torl += E1000_READ_REG(&sc->hw, TORL); + sc->stats.torh += E1000_READ_REG(&sc->hw, TORH); + sc->stats.totl += E1000_READ_REG(&sc->hw, TOTL); + sc->stats.toth += E1000_READ_REG(&sc->hw, TOTH); - adapter->stats.tpr += E1000_READ_REG(&adapter->hw, TPR); - adapter->stats.tpt += E1000_READ_REG(&adapter->hw, TPT); - adapter->stats.ptc64 += E1000_READ_REG(&adapter->hw, PTC64); - adapter->stats.ptc127 += E1000_READ_REG(&adapter->hw, PTC127); - adapter->stats.ptc255 += E1000_READ_REG(&adapter->hw, PTC255); - adapter->stats.ptc511 += E1000_READ_REG(&adapter->hw, PTC511); - adapter->stats.ptc1023 += E1000_READ_REG(&adapter->hw, PTC1023); - adapter->stats.ptc1522 += E1000_READ_REG(&adapter->hw, PTC1522); - adapter->stats.mptc += E1000_READ_REG(&adapter->hw, MPTC); - adapter->stats.bptc += E1000_READ_REG(&adapter->hw, BPTC); + sc->stats.tpr += E1000_READ_REG(&sc->hw, TPR); + sc->stats.tpt += E1000_READ_REG(&sc->hw, TPT); + sc->stats.ptc64 += E1000_READ_REG(&sc->hw, PTC64); + sc->stats.ptc127 += E1000_READ_REG(&sc->hw, PTC127); + sc->stats.ptc255 += E1000_READ_REG(&sc->hw, PTC255); + sc->stats.ptc511 += E1000_READ_REG(&sc->hw, PTC511); + sc->stats.ptc1023 += E1000_READ_REG(&sc->hw, PTC1023); + sc->stats.ptc1522 += E1000_READ_REG(&sc->hw, PTC1522); + sc->stats.mptc += E1000_READ_REG(&sc->hw, MPTC); + sc->stats.bptc += E1000_READ_REG(&sc->hw, BPTC); - if (adapter->hw.mac_type >= em_82543) { - adapter->stats.algnerrc += - E1000_READ_REG(&adapter->hw, ALGNERRC); - adapter->stats.rxerrc += - E1000_READ_REG(&adapter->hw, RXERRC); - adapter->stats.tncrs += - E1000_READ_REG(&adapter->hw, TNCRS); - adapter->stats.cexterr += - E1000_READ_REG(&adapter->hw, CEXTERR); - adapter->stats.tsctc += - E1000_READ_REG(&adapter->hw, TSCTC); - adapter->stats.tsctfc += - E1000_READ_REG(&adapter->hw, TSCTFC); + if (sc->hw.mac_type >= em_82543) { + sc->stats.algnerrc += E1000_READ_REG(&sc->hw, ALGNERRC); + sc->stats.rxerrc += E1000_READ_REG(&sc->hw, RXERRC); + sc->stats.tncrs += E1000_READ_REG(&sc->hw, TNCRS); + sc->stats.cexterr += E1000_READ_REG(&sc->hw, CEXTERR); + sc->stats.tsctc += E1000_READ_REG(&sc->hw, TSCTC); + sc->stats.tsctfc += E1000_READ_REG(&sc->hw, TSCTFC); } - ifp = adapter->ifp; + ifp = sc->ifp; - ifp->if_collisions = adapter->stats.colc; + ifp->if_collisions = sc->stats.colc; /* Rx Errors */ - ifp->if_ierrors = - adapter->dropped_pkts + - adapter->stats.rxerrc + - adapter->stats.crcerrs + - adapter->stats.algnerrc + - adapter->stats.rlec + - adapter->stats.mpc + adapter->stats.cexterr; + ifp->if_ierrors = sc->dropped_pkts + sc->stats.rxerrc + + sc->stats.crcerrs + sc->stats.algnerrc + sc->stats.rlec + + sc->stats.mpc + sc->stats.cexterr; /* Tx Errors */ - ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol + - adapter->watchdog_events; - + ifp->if_oerrors = sc->stats.ecol + sc->stats.latecol + + sc->watchdog_events; } @@ -3594,147 +3462,135 @@ em_update_stats_counters(struct adapter *adapter) * **********************************************************************/ static void -em_print_debug_info(struct adapter *adapter) +em_print_debug_info(struct em_softc *sc) { - int unit = adapter->unit; - uint8_t *hw_addr = adapter->hw.hw_addr; + device_t dev = sc->dev; + uint8_t *hw_addr = sc->hw.hw_addr; - printf("em%d: Adapter hardware address = %p \n", unit, hw_addr); - printf("em%d: CTRL = 0x%x RCTL = 0x%x \n", unit, - E1000_READ_REG(&adapter->hw, CTRL), - E1000_READ_REG(&adapter->hw, RCTL)); - printf("em%d: Packet buffer = Tx=%dk Rx=%dk \n", unit, - ((E1000_READ_REG(&adapter->hw, PBA) & 0xffff0000) >> 16),\ - (E1000_READ_REG(&adapter->hw, PBA) & 0xffff) ); - printf("em%d: Flow control watermarks high = %d low = %d\n", unit, - adapter->hw.fc_high_water, - adapter->hw.fc_low_water); - printf("em%d: tx_int_delay = %d, tx_abs_int_delay = %d\n", unit, - E1000_READ_REG(&adapter->hw, TIDV), - E1000_READ_REG(&adapter->hw, TADV)); - printf("em%d: rx_int_delay = %d, rx_abs_int_delay = %d\n", unit, - E1000_READ_REG(&adapter->hw, RDTR), - E1000_READ_REG(&adapter->hw, RADV)); - printf("em%d: fifo workaround = %lld, fifo_reset_count = %lld\n", - unit, (long long)adapter->tx_fifo_wrk_cnt, - (long long)adapter->tx_fifo_reset_cnt); - printf("em%d: hw tdh = %d, hw tdt = %d\n", unit, - E1000_READ_REG(&adapter->hw, TDH), - E1000_READ_REG(&adapter->hw, TDT)); - printf("em%d: Num Tx descriptors avail = %d\n", unit, - adapter->num_tx_desc_avail); - printf("em%d: Tx Descriptors not avail1 = %ld\n", unit, - adapter->no_tx_desc_avail1); - printf("em%d: Tx Descriptors not avail2 = %ld\n", unit, - adapter->no_tx_desc_avail2); - printf("em%d: Std mbuf failed = %ld\n", unit, - adapter->mbuf_alloc_failed); - printf("em%d: Std mbuf cluster failed = %ld\n", unit, - adapter->mbuf_cluster_failed); - printf("em%d: Driver dropped packets = %ld\n", unit, - adapter->dropped_pkts); - - return; + device_printf(dev, "Adapter hardware address = %p \n", hw_addr); + device_printf(dev, "CTRL = 0x%x RCTL = 0x%x \n", + E1000_READ_REG(&sc->hw, CTRL), + E1000_READ_REG(&sc->hw, RCTL)); + device_printf(dev, "Packet buffer = Tx=%dk Rx=%dk \n", + ((E1000_READ_REG(&sc->hw, PBA) & 0xffff0000) >> 16),\ + (E1000_READ_REG(&sc->hw, PBA) & 0xffff) ); + device_printf(dev, "Flow control watermarks high = %d low = %d\n", + sc->hw.fc_high_water, + sc->hw.fc_low_water); + device_printf(dev, "tx_int_delay = %d, tx_abs_int_delay = %d\n", + E1000_READ_REG(&sc->hw, TIDV), + E1000_READ_REG(&sc->hw, TADV)); + device_printf(dev, "rx_int_delay = %d, rx_abs_int_delay = %d\n", + E1000_READ_REG(&sc->hw, RDTR), + E1000_READ_REG(&sc->hw, RADV)); + device_printf(dev, "fifo workaround = %lld, fifo_reset_count = %lld\n", + (long long)sc->tx_fifo_wrk_cnt, + (long long)sc->tx_fifo_reset_cnt); + device_printf(dev, "hw tdh = %d, hw tdt = %d\n", + E1000_READ_REG(&sc->hw, TDH), + E1000_READ_REG(&sc->hw, TDT)); + device_printf(dev, "Num Tx descriptors avail = %d\n", + sc->num_tx_desc_avail); + device_printf(dev, "Tx Descriptors not avail1 = %ld\n", + sc->no_tx_desc_avail1); + device_printf(dev, "Tx Descriptors not avail2 = %ld\n", + sc->no_tx_desc_avail2); + device_printf(dev, "Std mbuf failed = %ld\n", + sc->mbuf_alloc_failed); + device_printf(dev, "Std mbuf cluster failed = %ld\n", + sc->mbuf_cluster_failed); + device_printf(dev, "Driver dropped packets = %ld\n", + sc->dropped_pkts); } static void -em_print_hw_stats(struct adapter *adapter) +em_print_hw_stats(struct em_softc *sc) { - int unit = adapter->unit; + device_t dev = sc->dev; - printf("em%d: Excessive collisions = %lld\n", unit, - (long long)adapter->stats.ecol); - printf("em%d: Symbol errors = %lld\n", unit, - (long long)adapter->stats.symerrs); - printf("em%d: Sequence errors = %lld\n", unit, - (long long)adapter->stats.sec); - printf("em%d: Defer count = %lld\n", unit, - (long long)adapter->stats.dc); + device_printf(dev, "Excessive collisions = %lld\n", + (long long)sc->stats.ecol); + device_printf(dev, "Symbol errors = %lld\n", + (long long)sc->stats.symerrs); + device_printf(dev, "Sequence errors = %lld\n", + (long long)sc->stats.sec); + device_printf(dev, "Defer count = %lld\n", (long long)sc->stats.dc); - printf("em%d: Missed Packets = %lld\n", unit, - (long long)adapter->stats.mpc); - printf("em%d: Receive No Buffers = %lld\n", unit, - (long long)adapter->stats.rnbc); - printf("em%d: Receive length errors = %lld\n", unit, - (long long)adapter->stats.rlec); - printf("em%d: Receive errors = %lld\n", unit, - (long long)adapter->stats.rxerrc); - printf("em%d: Crc errors = %lld\n", unit, - (long long)adapter->stats.crcerrs); - printf("em%d: Alignment errors = %lld\n", unit, - (long long)adapter->stats.algnerrc); - printf("em%d: Carrier extension errors = %lld\n", unit, - (long long)adapter->stats.cexterr); - printf("em%d: RX overruns = %ld\n", unit, adapter->rx_overruns); - printf("em%d: watchdog timeouts = %ld\n", unit, - adapter->watchdog_events); + device_printf(dev, "Missed Packets = %lld\n", (long long)sc->stats.mpc); + device_printf(dev, "Receive No Buffers = %lld\n", + (long long)sc->stats.rnbc); + device_printf(dev, "Receive length errors = %lld\n", + (long long)sc->stats.rlec); + device_printf(dev, "Receive errors = %lld\n", + (long long)sc->stats.rxerrc); + device_printf(dev, "Crc errors = %lld\n", (long long)sc->stats.crcerrs); + device_printf(dev, "Alignment errors = %lld\n", + (long long)sc->stats.algnerrc); + device_printf(dev, "Carrier extension errors = %lld\n", + (long long)sc->stats.cexterr); + device_printf(dev, "RX overruns = %ld\n", sc->rx_overruns); + device_printf(dev, "watchdog timeouts = %ld\n", sc->watchdog_events); - printf("em%d: XON Rcvd = %lld\n", unit, - (long long)adapter->stats.xonrxc); - printf("em%d: XON Xmtd = %lld\n", unit, - (long long)adapter->stats.xontxc); - printf("em%d: XOFF Rcvd = %lld\n", unit, - (long long)adapter->stats.xoffrxc); - printf("em%d: XOFF Xmtd = %lld\n", unit, - (long long)adapter->stats.xofftxc); + device_printf(dev, "XON Rcvd = %lld\n", (long long)sc->stats.xonrxc); + device_printf(dev, "XON Xmtd = %lld\n", (long long)sc->stats.xontxc); + device_printf(dev, "XOFF Rcvd = %lld\n", (long long)sc->stats.xoffrxc); + device_printf(dev, "XOFF Xmtd = %lld\n", (long long)sc->stats.xofftxc); - printf("em%d: Good Packets Rcvd = %lld\n", unit, - (long long)adapter->stats.gprc); - printf("em%d: Good Packets Xmtd = %lld\n", unit, - (long long)adapter->stats.gptc); - - return; + device_printf(dev, "Good Packets Rcvd = %lld\n", + (long long)sc->stats.gprc); + device_printf(dev, "Good Packets Xmtd = %lld\n", + (long long)sc->stats.gptc); } static int em_sysctl_debug_info(SYSCTL_HANDLER_ARGS) { - int error; - int result; - struct adapter *adapter; + struct em_softc *sc; + int error; + int result; - result = -1; - error = sysctl_handle_int(oidp, &result, 0, req); + result = -1; + error = sysctl_handle_int(oidp, &result, 0, req); - if (error || !req->newptr) - return (error); + if (error || !req->newptr) + return (error); - if (result == 1) { - adapter = (struct adapter *)arg1; - em_print_debug_info(adapter); - } + if (result == 1) { + sc = (struct em_softc *)arg1; + em_print_debug_info(sc); + } - return error; + return (error); } static int em_sysctl_stats(SYSCTL_HANDLER_ARGS) { - int error; - int result; - struct adapter *adapter; + struct em_softc *sc; + int error; + int result; - result = -1; - error = sysctl_handle_int(oidp, &result, 0, req); + result = -1; + error = sysctl_handle_int(oidp, &result, 0, req); - if (error || !req->newptr) - return (error); + if (error || !req->newptr) + return (error); - if (result == 1) { - adapter = (struct adapter *)arg1; - em_print_hw_stats(adapter); - } + if (result == 1) { + sc = (struct em_softc *)arg1; + em_print_hw_stats(sc); + } - return error; + return (error); } static int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) { struct em_int_delay_info *info; - struct adapter *adapter; - u_int32_t regval; + struct em_softc *sc; + uint32_t regval; int error; int usecs; int ticks; @@ -3743,16 +3599,16 @@ em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) usecs = info->value; error = sysctl_handle_int(oidp, &usecs, 0, req); if (error != 0 || req->newptr == NULL) - return error; + return (error); if (usecs < 0 || usecs > E1000_TICKS_TO_USECS(65535)) - return EINVAL; + return (EINVAL); info->value = usecs; ticks = E1000_USECS_TO_TICKS(usecs); - adapter = info->adapter; + sc = info->sc; - EM_LOCK(adapter); - regval = E1000_READ_OFFSET(&adapter->hw, info->offset); + EM_LOCK(sc); + regval = E1000_READ_OFFSET(&sc->hw, info->offset); regval = (regval & ~0xffff) | (ticks & 0xffff); /* Handle a few special cases. */ switch (info->offset) { @@ -3763,40 +3619,40 @@ em_sysctl_int_delay(SYSCTL_HANDLER_ARGS) case E1000_TIDV: case E1000_82542_TIDV: if (ticks == 0) { - adapter->txd_cmd &= ~E1000_TXD_CMD_IDE; + sc->txd_cmd &= ~E1000_TXD_CMD_IDE; /* Don't write 0 into the TIDV register. */ regval++; } else - adapter->txd_cmd |= E1000_TXD_CMD_IDE; + sc->txd_cmd |= E1000_TXD_CMD_IDE; break; } - E1000_WRITE_OFFSET(&adapter->hw, info->offset, regval); - EM_UNLOCK(adapter); - return 0; + E1000_WRITE_OFFSET(&sc->hw, info->offset, regval); + EM_UNLOCK(sc); + return (0); } static void -em_add_int_delay_sysctl(struct adapter *adapter, const char *name, - const char *description, struct em_int_delay_info *info, - int offset, int value) +em_add_int_delay_sysctl(struct em_softc *sc, const char *name, + const char *description, struct em_int_delay_info *info, + int offset, int value) { - info->adapter = adapter; + info->sc = sc; info->offset = offset; info->value = value; - SYSCTL_ADD_PROC(device_get_sysctl_ctx(adapter->dev), - SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), + SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, info, 0, em_sysctl_int_delay, "I", description); } #ifndef NO_EM_FASTINTR static void -em_add_int_process_limit(struct adapter *adapter, const char *name, - const char *description, int *limit, int value) +em_add_int_process_limit(struct em_softc *sc, const char *name, + const char *description, int *limit, int value) { *limit = value; - SYSCTL_ADD_INT(device_get_sysctl_ctx(adapter->dev), - SYSCTL_CHILDREN(device_get_sysctl_tree(adapter->dev)), + SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev), + SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)), OID_AUTO, name, CTLTYPE_INT|CTLFLAG_RW, limit, value, description); } #endif diff --git a/sys/dev/em/if_em.h b/sys/dev/em/if_em.h index f52292d7e6f7..d36de52b6f2b 100644 --- a/sys/dev/em/if_em.h +++ b/sys/dev/em/if_em.h @@ -146,7 +146,7 @@ POSSIBILITY OF SUCH DAMAGE. * This parameter controls when the driver calls the routine to reclaim * transmit descriptors. */ -#define EM_TX_CLEANUP_THRESHOLD (adapter->num_tx_desc / 8) +#define EM_TX_CLEANUP_THRESHOLD (sc->num_tx_desc / 8) /* * This parameter controls whether or not autonegotation is enabled. @@ -217,6 +217,140 @@ POSSIBILITY OF SUCH DAMAGE. #define EM_MAX_SCATTER 64 +typedef enum _XSUM_CONTEXT_T { + OFFLOAD_NONE, + OFFLOAD_TCP_IP, + OFFLOAD_UDP_IP +} XSUM_CONTEXT_T; + +struct em_softc sc; /* XXX: ugly forward declaration */ +struct em_int_delay_info { + struct em_softc *sc; /* XXX: ugly pointer */ + int offset; /* Register offset to read/write */ + int value; /* Current value in usecs */ +}; + +/* + * Bus dma allocation structure used by + * em_dma_malloc() and em_dma_free(). + */ +struct em_dma_alloc { + bus_addr_t dma_paddr; + caddr_t dma_vaddr; + bus_dma_tag_t dma_tag; + bus_dmamap_t dma_map; + bus_dma_segment_t dma_seg; + int dma_nseg; +}; + +/* Driver softc. */ +struct em_softc { + struct ifnet *ifp; + struct em_hw hw; + + /* FreeBSD operating-system-specific structures. */ + struct em_osdep osdep; + struct device *dev; + struct resource *res_memory; + struct resource *res_ioport; + struct resource *res_interrupt; + void *int_handler_tag; + struct ifmedia media; + struct callout timer; + struct callout tx_fifo_timer; + int io_rid; + struct mtx mtx; + int em_insert_vlan_header; + struct task link_task; + struct task rxtx_task; + struct taskqueue *tq; /* private task queue */ + + /* Info about the board itself */ + uint32_t part_num; + uint8_t link_active; + uint16_t link_speed; + uint16_t link_duplex; + uint32_t smartspeed; + struct em_int_delay_info tx_int_delay; + struct em_int_delay_info tx_abs_int_delay; + struct em_int_delay_info rx_int_delay; + struct em_int_delay_info rx_abs_int_delay; + + XSUM_CONTEXT_T active_checksum_context; + + /* + * Transmit definitions + * + * We have an array of num_tx_desc descriptors (handled + * by the controller) paired with an array of tx_buffers + * (at tx_buffer_area). + * The index of the next available descriptor is next_avail_tx_desc. + * The number of remaining tx_desc is num_tx_desc_avail. + */ + struct em_dma_alloc txdma; /* bus_dma glue for tx desc */ + struct em_tx_desc *tx_desc_base; + uint32_t next_avail_tx_desc; + uint32_t oldest_used_tx_desc; + volatile uint16_t num_tx_desc_avail; + uint16_t num_tx_desc; + uint32_t txd_cmd; + struct em_buffer *tx_buffer_area; + bus_dma_tag_t txtag; /* dma tag for tx */ + + /* + * Receive definitions + * + * we have an array of num_rx_desc rx_desc (handled by the + * controller), and paired with an array of rx_buffers + * (at rx_buffer_area). + * The next pair to check on receive is at offset next_rx_desc_to_check + */ + struct em_dma_alloc rxdma; /* bus_dma glue for rx desc */ + struct em_rx_desc *rx_desc_base; + uint32_t next_rx_desc_to_check; + uint32_t rx_buffer_len; + uint16_t num_rx_desc; + int rx_process_limit; + struct em_buffer *rx_buffer_area; + bus_dma_tag_t rxtag; + + /* First/last mbuf pointers, for collecting multisegment RX packets. */ + struct mbuf *fmp; + struct mbuf *lmp; + + /* Misc stats maintained by the driver */ + unsigned long dropped_pkts; + unsigned long mbuf_alloc_failed; + unsigned long mbuf_cluster_failed; + unsigned long no_tx_desc_avail1; + unsigned long no_tx_desc_avail2; + unsigned long no_tx_map_avail; + unsigned long no_tx_dma_setup; + unsigned long watchdog_events; + unsigned long rx_overruns; + + /* Used in for 82547 10Mb Half workaround */ + #define EM_PBA_BYTES_SHIFT 0xA + #define EM_TX_HEAD_ADDR_SHIFT 7 + #define EM_PBA_TX_MASK 0xFFFF0000 + #define EM_FIFO_HDR 0x10 + + #define EM_82547_PKT_THRESH 0x3e0 + + uint32_t tx_fifo_size; + uint32_t tx_fifo_head; + uint32_t tx_fifo_head_addr; + uint64_t tx_fifo_reset_cnt; + uint64_t tx_fifo_wrk_cnt; + uint32_t tx_head_addr; + + /* For 82544 PCIX Workaround */ + boolean_t pcix_82544; + boolean_t in_detach; + + struct em_hw_stats stats; +}; + /* ****************************************************************************** * vendor_info_array * @@ -238,32 +372,6 @@ struct em_buffer { bus_dmamap_t map; /* bus_dma map for packet */ }; -/* - * Bus dma allocation structure used by - * em_dma_malloc and em_dma_free. - */ -struct em_dma_alloc { - bus_addr_t dma_paddr; - caddr_t dma_vaddr; - bus_dma_tag_t dma_tag; - bus_dmamap_t dma_map; - bus_dma_segment_t dma_seg; - int dma_nseg; -}; - -typedef enum _XSUM_CONTEXT_T { - OFFLOAD_NONE, - OFFLOAD_TCP_IP, - OFFLOAD_UDP_IP -} XSUM_CONTEXT_T; - -struct adapter; -struct em_int_delay_info { - struct adapter *adapter; /* Back-pointer to the adapter struct */ - int offset; /* Register offset to read/write */ - int value; /* Current value in usecs */ -}; - /* For 82544 PCIX Workaround */ typedef struct _ADDRESS_LENGTH_PAIR { @@ -277,115 +385,6 @@ typedef struct _DESCRIPTOR_PAIR u_int32_t elements; } DESC_ARRAY, *PDESC_ARRAY; -/* Our adapter structure */ -struct adapter { - struct ifnet *ifp; - struct em_hw hw; - - /* FreeBSD operating-system-specific structures */ - struct em_osdep osdep; - struct device *dev; - struct resource *res_memory; - struct resource *res_ioport; - struct resource *res_interrupt; - void *int_handler_tag; - struct ifmedia media; - struct callout timer; - struct callout tx_fifo_timer; - int io_rid; - u_int8_t unit; - struct mtx mtx; - int em_insert_vlan_header; - struct task link_task; - struct task rxtx_task; - struct taskqueue *tq; /* private task queue */ - - /* Info about the board itself */ - u_int32_t part_num; - u_int8_t link_active; - u_int16_t link_speed; - u_int16_t link_duplex; - u_int32_t smartspeed; - struct em_int_delay_info tx_int_delay; - struct em_int_delay_info tx_abs_int_delay; - struct em_int_delay_info rx_int_delay; - struct em_int_delay_info rx_abs_int_delay; - - XSUM_CONTEXT_T active_checksum_context; - - /* - * Transmit definitions - * - * We have an array of num_tx_desc descriptors (handled - * by the controller) paired with an array of tx_buffers - * (at tx_buffer_area). - * The index of the next available descriptor is next_avail_tx_desc. - * The number of remaining tx_desc is num_tx_desc_avail. - */ - struct em_dma_alloc txdma; /* bus_dma glue for tx desc */ - struct em_tx_desc *tx_desc_base; - u_int32_t next_avail_tx_desc; - u_int32_t oldest_used_tx_desc; - volatile u_int16_t num_tx_desc_avail; - u_int16_t num_tx_desc; - u_int32_t txd_cmd; - struct em_buffer *tx_buffer_area; - bus_dma_tag_t txtag; /* dma tag for tx */ - - /* - * Receive definitions - * - * we have an array of num_rx_desc rx_desc (handled by the - * controller), and paired with an array of rx_buffers - * (at rx_buffer_area). - * The next pair to check on receive is at offset next_rx_desc_to_check - */ - struct em_dma_alloc rxdma; /* bus_dma glue for rx desc */ - struct em_rx_desc *rx_desc_base; - u_int32_t next_rx_desc_to_check; - u_int32_t rx_buffer_len; - u_int16_t num_rx_desc; - int rx_process_limit; - struct em_buffer *rx_buffer_area; - bus_dma_tag_t rxtag; - - /* Jumbo frame */ - struct mbuf *fmp; - struct mbuf *lmp; - - /* Misc stats maintained by the driver */ - unsigned long dropped_pkts; - unsigned long mbuf_alloc_failed; - unsigned long mbuf_cluster_failed; - unsigned long no_tx_desc_avail1; - unsigned long no_tx_desc_avail2; - unsigned long no_tx_map_avail; - unsigned long no_tx_dma_setup; - unsigned long watchdog_events; - unsigned long rx_overruns; - - /* Used in for 82547 10Mb Half workaround */ - #define EM_PBA_BYTES_SHIFT 0xA - #define EM_TX_HEAD_ADDR_SHIFT 7 - #define EM_PBA_TX_MASK 0xFFFF0000 - #define EM_FIFO_HDR 0x10 - - #define EM_82547_PKT_THRESH 0x3e0 - - u_int32_t tx_fifo_size; - u_int32_t tx_fifo_head; - u_int32_t tx_fifo_head_addr; - u_int64_t tx_fifo_reset_cnt; - u_int64_t tx_fifo_wrk_cnt; - u_int32_t tx_head_addr; - - /* For 82544 PCIX Workaround */ - boolean_t pcix_82544; - boolean_t in_detach; - - struct em_hw_stats stats; -}; - #define EM_LOCK_INIT(_sc, _name) \ mtx_init(&(_sc)->mtx, _name, MTX_NETWORK_LOCK, MTX_DEF) #define EM_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->mtx) @@ -393,4 +392,4 @@ struct adapter { #define EM_UNLOCK(_sc) mtx_unlock(&(_sc)->mtx) #define EM_LOCK_ASSERT(_sc) mtx_assert(&(_sc)->mtx, MA_OWNED) -#endif /* _EM_H_DEFINED_ */ +#endif /* _EM_H_DEFINED_ */ diff --git a/sys/dev/em/if_em_osdep.h b/sys/dev/em/if_em_osdep.h index 7c5e41b01835..2ec57ca2ed9f 100644 --- a/sys/dev/em/if_em_osdep.h +++ b/sys/dev/em/if_em_osdep.h @@ -82,7 +82,7 @@ struct em_osdep bus_space_handle_t mem_bus_space_handle; bus_space_tag_t io_bus_space_tag; bus_space_handle_t io_bus_space_handle; - struct device *dev; + device_t dev; }; #define E1000_WRITE_FLUSH(hw) E1000_READ_REG(hw, STATUS)