From 8bdd5df5b297cde65ff380fea4bc07f8a83305db Mon Sep 17 00:00:00 2001 From: pdeuskar Date: Sat, 6 Apr 2002 00:36:53 +0000 Subject: Added support for 82540EM based cards. Cosmetic changes to make code more unix-like. MFC after: 1 week --- sys/dev/em/if_em.c | 1505 +++++++++++++++++++++++----------------------- sys/dev/em/if_em.h | 125 ++-- sys/dev/em/if_em_fxhw.c | 196 +++--- sys/dev/em/if_em_fxhw.h | 204 +++++-- sys/dev/em/if_em_osdep.h | 2 +- sys/dev/em/if_em_phy.c | 60 +- sys/dev/em/if_em_phy.h | 26 +- 7 files changed, 1107 insertions(+), 1011 deletions(-) (limited to 'sys') diff --git a/sys/dev/em/if_em.c b/sys/dev/em/if_em.c index a666dd4..e641037 100644 --- a/sys/dev/em/if_em.c +++ b/sys/dev/em/if_em.c @@ -1,6 +1,6 @@ /************************************************************************** -Copyright (c) 2001 Intel Corporation +Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -53,7 +53,7 @@ struct adapter *em_adapter_list = NULL; * Driver version *********************************************************************/ -char em_driver_version[] = "1.1.10"; +char em_driver_version[] = "1.2.7"; /********************************************************************* @@ -75,6 +75,7 @@ static em_vendor_info_t em_vendor_info_array[] = { 0x8086, 0x1009, PCI_ANY_ID, PCI_ANY_ID, 0 }, { 0x8086, 0x100C, PCI_ANY_ID, PCI_ANY_ID, 0 }, { 0x8086, 0x100D, PCI_ANY_ID, PCI_ANY_ID, 0 }, + { 0x8086, 0x100E, PCI_ANY_ID, PCI_ANY_ID, 0 }, /* required last entry */ { 0, 0, 0, 0, 0} }; @@ -91,52 +92,53 @@ 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_probe(device_t); +static int em_attach(device_t); +static int em_detach(device_t); +static int em_shutdown(device_t); static void em_intr(void *); static void em_start(struct ifnet *); -static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t); +static int em_ioctl(struct ifnet *, IOCTL_CMD_TYPE, caddr_t); static void em_watchdog(struct ifnet *); static void em_init(void *); static void em_stop(void *); static void em_media_status(struct ifnet *, struct ifmediareq *); -static int em_media_change(struct ifnet *); +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_pci_resources(struct adapter *); static void em_free_pci_resources(struct adapter *); static void em_local_timer(void *); -static int em_hardware_init(struct adapter *); +static int em_hardware_init(struct adapter *); static void em_read_mac_address(struct adapter *, u_int8_t *); static void em_setup_interface(device_t, struct adapter *); -static int em_setup_transmit_structures(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 int em_setup_receive_structures(struct adapter *); static void em_initialize_receive_unit(struct adapter *); -static void EnableInterrupts(struct adapter *); -static void DisableInterrupts(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_allocate_receive_structures(struct adapter *); +static int em_allocate_transmit_structures(struct adapter *); static void em_process_receive_interrupts(struct adapter *); static void em_receive_checksum(struct adapter *, - struct em_rx_desc * RxDescriptor, - struct mbuf *); + struct em_rx_desc * rx_desc, + struct mbuf *); static void em_transmit_checksum_setup(struct adapter *, - struct mbuf *, - struct em_tx_buffer *, - u_int32_t *, - u_int32_t *); + struct mbuf *, + struct em_tx_buffer *, + 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(struct em_rx_buffer *, struct adapter *, struct mbuf *); +static int em_get_buf(struct em_rx_buffer *, struct adapter *, + struct mbuf *); /********************************************************************* * FreeBSD Device Interface Entry Points *********************************************************************/ @@ -223,128 +225,128 @@ em_probe(device_t dev) static int em_attach(device_t dev) { - struct adapter * Adapter; + struct adapter * adapter; int s; int tsize, rsize; INIT_DEBUGOUT("em_attach: begin"); s = splimp(); - /* Allocate, clear, and link in our Adapter structure */ - if (!(Adapter = device_get_softc(dev))) { - printf("em: Adapter structure allocation failed\n"); + /* Allocate, clear, and link in our adapter structure */ + if (!(adapter = device_get_softc(dev))) { + printf("em: adapter structure allocation failed\n"); splx(s); return(ENOMEM); } - bzero(Adapter, sizeof(struct adapter )); - Adapter->dev = dev; - Adapter->osdep.dev = dev; - Adapter->unit = device_get_unit(dev); + bzero(adapter, sizeof(struct adapter )); + adapter->dev = dev; + adapter->osdep.dev = dev; + adapter->unit = device_get_unit(dev); if (em_adapter_list != NULL) - em_adapter_list->prev = Adapter; - Adapter->next = em_adapter_list; - em_adapter_list = Adapter; + em_adapter_list->prev = adapter; + adapter->next = em_adapter_list; + em_adapter_list = adapter; - callout_handle_init(&Adapter->timer_handle); + callout_handle_init(&adapter->timer_handle); /* Determine hardware revision */ - em_identify_hardware(Adapter); + em_identify_hardware(adapter); /* Parameters (to be read from user) */ - Adapter->NumTxDescriptors = MAX_TXD; - Adapter->NumRxDescriptors = MAX_RXD; - Adapter->TxIntDelay = TIDV; - Adapter->RxIntDelay = RIDV; - Adapter->shared.autoneg = DO_AUTO_NEG; - Adapter->shared.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; - Adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT; - Adapter->shared.tbi_compatibility_en = TRUE; - Adapter->RxBufferLen = EM_RXBUFFER_2048; - Adapter->RxChecksum = EM_ENABLE_RXCSUM_OFFLOAD; + adapter->num_tx_desc = MAX_TXD; + adapter->num_rx_desc = MAX_RXD; + adapter->tx_int_delay = TIDV; + adapter->rx_int_delay = RIDV; + adapter->shared.autoneg = DO_AUTO_NEG; + adapter->shared.wait_autoneg_complete = WAIT_FOR_AUTO_NEG_DEFAULT; + adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT; + adapter->shared.tbi_compatibility_en = TRUE; + adapter->rx_buffer_len = EM_RXBUFFER_2048; + adapter->rx_checksum = EM_ENABLE_RXCSUM_OFFLOAD; - Adapter->shared.fc_high_water = FC_DEFAULT_HI_THRESH; - Adapter->shared.fc_low_water = FC_DEFAULT_LO_THRESH; - Adapter->shared.fc_pause_time = FC_DEFAULT_TX_TIMER; - Adapter->shared.fc_send_xon = TRUE; - Adapter->shared.fc = em_fc_full; - + adapter->shared.fc_high_water = FC_DEFAULT_HI_THRESH; + adapter->shared.fc_low_water = FC_DEFAULT_LO_THRESH; + adapter->shared.fc_pause_time = FC_DEFAULT_TX_TIMER; + adapter->shared.fc_send_xon = TRUE; + adapter->shared.fc = em_fc_full; /* Set the max frame size assuming standard ethernet sized frames */ - Adapter->shared.max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; + adapter->shared.max_frame_size = ETHERMTU + ETHER_HDR_LEN + ETHER_CRC_LEN; + adapter->shared.min_frame_size = MINIMUM_ETHERNET_PACKET_SIZE + ETHER_CRC_LEN; /* This controls when hardware reports transmit completion status. */ if ((EM_REPORT_TX_EARLY == 0) || (EM_REPORT_TX_EARLY == 1)) { - Adapter->shared.report_tx_early = EM_REPORT_TX_EARLY; + adapter->shared.report_tx_early = EM_REPORT_TX_EARLY; } else { - if(Adapter->shared.mac_type < em_82543) { - Adapter->shared.report_tx_early = 0; + if(adapter->shared.mac_type < em_82543) { + adapter->shared.report_tx_early = 0; } else { - Adapter->shared.report_tx_early = 1; + adapter->shared.report_tx_early = 1; } } - if (em_allocate_pci_resources(Adapter)) { - printf("em%d: Allocation of PCI resources failed\n", Adapter->unit); - em_free_pci_resources(Adapter); + if (em_allocate_pci_resources(adapter)) { + printf("em%d: Allocation of PCI resources failed\n", adapter->unit); + em_free_pci_resources(adapter); splx(s); return(ENXIO); } - tsize = EM_ROUNDUP(Adapter->NumTxDescriptors * + tsize = EM_ROUNDUP(adapter->num_tx_desc * sizeof(struct em_tx_desc), 4096); /* Allocate Transmit Descriptor ring */ - if (!(Adapter->TxDescBase = (struct em_tx_desc *) + if (!(adapter->tx_desc_base = (struct em_tx_desc *) contigmalloc(tsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { - printf("em%d: Unable to allocate TxDescriptor memory\n", Adapter->unit); - em_free_pci_resources(Adapter); + printf("em%d: Unable to allocate TxDescriptor memory\n", adapter->unit); + em_free_pci_resources(adapter); splx(s); return(ENOMEM); } - rsize = EM_ROUNDUP(Adapter->NumRxDescriptors * + rsize = EM_ROUNDUP(adapter->num_rx_desc * sizeof(struct em_rx_desc), 4096); /* Allocate Receive Descriptor ring */ - if (!(Adapter->RxDescBase = (struct em_rx_desc *) + if (!(adapter->rx_desc_base = (struct em_rx_desc *) contigmalloc(rsize, M_DEVBUF, M_NOWAIT, 0, ~0, PAGE_SIZE, 0))) { - printf("em%d: Unable to allocate RxDescriptor memory\n", Adapter->unit); - em_free_pci_resources(Adapter); - contigfree(Adapter->TxDescBase, tsize, M_DEVBUF); + printf("em%d: Unable to allocate rx_desc memory\n", adapter->unit); + em_free_pci_resources(adapter); + contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); splx(s); return(ENOMEM); } /* Initialize the hardware */ - if (em_hardware_init(Adapter)) { - printf("em%d: Unable to initialize the hardware\n",Adapter->unit); - em_free_pci_resources(Adapter); - contigfree(Adapter->TxDescBase, tsize, M_DEVBUF); - contigfree(Adapter->RxDescBase, rsize, M_DEVBUF); + if (em_hardware_init(adapter)) { + printf("em%d: Unable to initialize the hardware\n",adapter->unit); + em_free_pci_resources(adapter); + contigfree(adapter->tx_desc_base, tsize, M_DEVBUF); + contigfree(adapter->rx_desc_base, rsize, M_DEVBUF); splx(s); return(EIO); } /* Setup OS specific network interface */ - em_setup_interface(dev, Adapter); + em_setup_interface(dev, adapter); /* Initialize statistics */ - em_clear_hw_cntrs(&Adapter->shared); - em_update_stats_counters(Adapter); - Adapter->shared.get_link_status = 1; - em_check_for_link(&Adapter->shared); + em_clear_hw_cntrs(&adapter->shared); + em_update_stats_counters(adapter); + adapter->shared.get_link_status = 1; + em_check_for_link(&adapter->shared); /* Print the link status */ - if (Adapter->LinkIsActive == 1) { - em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex); + if (adapter->link_active == 1) { + em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex); printf("em%d: Speed:%d Mbps Duplex:%s\n", - Adapter->unit, - Adapter->LineSpeed, - Adapter->FullDuplex == FULL_DUPLEX ? "Full" : "Half"); + adapter->unit, + adapter->link_speed, + adapter->link_duplex == FULL_DUPLEX ? "Full" : "Half"); } else - printf("em%d: Speed:N/A Duplex:N/A\n", Adapter->unit); + printf("em%d: Speed:N/A Duplex:N/A\n", adapter->unit); INIT_DEBUGOUT("em_attach: end"); @@ -365,44 +367,44 @@ em_attach(device_t dev) static int em_detach(device_t dev) { - struct adapter * Adapter = device_get_softc(dev); - struct ifnet *ifp = &Adapter->interface_data.ac_if; + struct adapter * adapter = device_get_softc(dev); + struct ifnet *ifp = &adapter->interface_data.ac_if; int s; int size; INIT_DEBUGOUT("em_detach: begin"); s = splimp(); - em_stop(Adapter); - em_phy_hw_reset(&Adapter->shared); - ether_ifdetach(&Adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED); - em_free_pci_resources(Adapter); + em_stop(adapter); + em_phy_hw_reset(&adapter->shared); + ether_ifdetach(&adapter->interface_data.ac_if, ETHER_BPF_SUPPORTED); + em_free_pci_resources(adapter); - size = EM_ROUNDUP(Adapter->NumTxDescriptors * + size = EM_ROUNDUP(adapter->num_tx_desc * sizeof(struct em_tx_desc), 4096); /* Free Transmit Descriptor ring */ - if (Adapter->TxDescBase) { - contigfree(Adapter->TxDescBase, size, M_DEVBUF); - Adapter->TxDescBase = NULL; + if (adapter->tx_desc_base) { + contigfree(adapter->tx_desc_base, size, M_DEVBUF); + adapter->tx_desc_base = NULL; } - size = EM_ROUNDUP(Adapter->NumRxDescriptors * + size = EM_ROUNDUP(adapter->num_rx_desc * sizeof(struct em_rx_desc), 4096); /* Free Receive Descriptor ring */ - if (Adapter->RxDescBase) { - contigfree(Adapter->RxDescBase, size, M_DEVBUF); - Adapter->RxDescBase = NULL; + if (adapter->rx_desc_base) { + contigfree(adapter->rx_desc_base, size, M_DEVBUF); + adapter->rx_desc_base = NULL; } /* Remove from the adapter list */ - if(em_adapter_list == Adapter) - em_adapter_list = Adapter->next; - if(Adapter->next != NULL) - Adapter->next->prev = Adapter->prev; - if(Adapter->prev != NULL) - Adapter->prev->next = Adapter->next; + if(em_adapter_list == adapter) + em_adapter_list = adapter->next; + if(adapter->next != NULL) + adapter->next->prev = adapter->prev; + if(adapter->prev != NULL) + adapter->prev->next = adapter->next; ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); ifp->if_timer = 0; @@ -414,10 +416,10 @@ em_detach(device_t dev) static int em_shutdown(device_t dev) { - struct adapter * Adapter = device_get_softc(dev); + struct adapter * adapter = device_get_softc(dev); /* Issue a global reset */ - em_adapter_stop(&Adapter->shared); + em_adapter_stop(&adapter->shared); return(0); } @@ -436,18 +438,15 @@ static void em_start(struct ifnet *ifp) { int s; - struct em_tx_buffer *tx_buffer; - struct mbuf *m_head; - struct mbuf *mp; - vm_offset_t VirtualAddress; + struct mbuf *m_head, *mp; + vm_offset_t virtual_addr; u_int32_t txd_upper; u_int32_t txd_lower; - struct em_tx_desc * CurrentTxDescriptor = NULL; - struct adapter * Adapter = ifp->if_softc; - - TXRX_DEBUGOUT("em_start: begin"); + struct em_tx_buffer *tx_buffer; + struct em_tx_desc *current_tx_desc = NULL; + struct adapter * adapter = ifp->if_softc; - if (!Adapter->LinkIsActive) + if (!adapter->link_active) return; s = splimp(); @@ -457,45 +456,41 @@ em_start(struct ifnet *ifp) if(m_head == NULL) break; - if (Adapter->NumTxDescriptorsAvail <= TX_CLEANUP_THRESHOLD) - em_clean_transmit_interrupts(Adapter); + if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD) + em_clean_transmit_interrupts(adapter); - if (Adapter->NumTxDescriptorsAvail <= TX_CLEANUP_THRESHOLD) { + if (adapter->num_tx_desc_avail <= TX_CLEANUP_THRESHOLD) { ifp->if_flags |= IFF_OACTIVE; IF_PREPEND(&ifp->if_snd, m_head); -#ifdef DBG_STATS - Adapter->NoTxDescAvail++; -#endif + adapter->no_tx_desc_avail++; break; } - tx_buffer = STAILQ_FIRST(&Adapter->FreeSwTxPacketList); + tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list); if (!tx_buffer) { -#ifdef DBG_STATS - Adapter->NoTxBufferAvail1++; -#endif + adapter->no_tx_buffer_avail1++; + /* * OK so we should not get here but I've seen it so lets try to * clean up and then try to get a SwPacket again and only break * if we still don't get one */ - em_clean_transmit_interrupts(Adapter); - tx_buffer = STAILQ_FIRST(&Adapter->FreeSwTxPacketList); + em_clean_transmit_interrupts(adapter); + tx_buffer = STAILQ_FIRST(&adapter->free_tx_buffer_list); if (!tx_buffer) { ifp->if_flags |= IFF_OACTIVE; IF_PREPEND(&ifp->if_snd, m_head); -#ifdef DBG_STATS - Adapter->NoTxBufferAvail2++; -#endif + adapter->no_tx_buffer_avail2++; break; } } - STAILQ_REMOVE_HEAD(&Adapter->FreeSwTxPacketList, em_tx_entry); - tx_buffer->NumTxDescriptorsUsed = 0; - tx_buffer->Packet = m_head; + STAILQ_REMOVE_HEAD(&adapter->free_tx_buffer_list, em_tx_entry); + + tx_buffer->num_tx_desc_used = 0; + tx_buffer->m_head = m_head; if (ifp->if_hwassist > 0) { - em_transmit_checksum_setup(Adapter, m_head, tx_buffer, &txd_upper, &txd_lower); + em_transmit_checksum_setup(adapter, m_head, tx_buffer, &txd_upper, &txd_lower); } else { txd_upper = 0; txd_lower = 0; @@ -504,30 +499,31 @@ em_start(struct ifnet *ifp) for (mp = m_head; mp != NULL; mp = mp->m_next) { if (mp->m_len == 0) continue; - CurrentTxDescriptor = Adapter->NextAvailTxDescriptor; - VirtualAddress = mtod(mp, vm_offset_t); - CurrentTxDescriptor->buffer_addr = vtophys(VirtualAddress); - - CurrentTxDescriptor->lower.data = (txd_lower | mp->m_len); - CurrentTxDescriptor->upper.data = (txd_upper); + current_tx_desc = adapter->next_avail_tx_desc; + virtual_addr = mtod(mp, vm_offset_t); + current_tx_desc->buffer_addr = vtophys(virtual_addr); + + current_tx_desc->lower.data = (txd_lower | mp->m_len); + current_tx_desc->upper.data = (txd_upper); - if (CurrentTxDescriptor == Adapter->LastTxDescriptor) - Adapter->NextAvailTxDescriptor = - Adapter->FirstTxDescriptor; + if (current_tx_desc == adapter->last_tx_desc) + adapter->next_avail_tx_desc = + adapter->first_tx_desc; else - Adapter->NextAvailTxDescriptor++; + adapter->next_avail_tx_desc++; - Adapter->NumTxDescriptorsAvail--; - tx_buffer->NumTxDescriptorsUsed++; + adapter->num_tx_desc_avail--; + tx_buffer->num_tx_desc_used++; } + /* Put this tx_buffer at the end in the "in use" list */ - STAILQ_INSERT_TAIL(&Adapter->UsedSwTxPacketList, tx_buffer, em_tx_entry); + STAILQ_INSERT_TAIL(&adapter->used_tx_buffer_list, tx_buffer, em_tx_entry); /* * Last Descriptor of Packet needs End Of Packet (EOP), Report Status * (RS) and append Ethernet CRC (IFCS) bits set. */ - CurrentTxDescriptor->lower.data |= (Adapter->TxdCmd | E1000_TXD_CMD_EOP); + current_tx_desc->lower.data |= (adapter->txd_cmd | E1000_TXD_CMD_EOP); /* Send a copy of the frame to the BPF listener */ if (ifp->if_bpf) @@ -536,8 +532,8 @@ em_start(struct ifnet *ifp) * Advance the Transmit Descriptor Tail (Tdt), this tells the E1000 * that this frame is available to transmit. */ - E1000_WRITE_REG(&Adapter->shared, TDT, (((u_int32_t) Adapter->NextAvailTxDescriptor - - (u_int32_t) Adapter->FirstTxDescriptor) >> 4)); + E1000_WRITE_REG(&adapter->shared, TDT, (((u_int32_t) adapter->next_avail_tx_desc - + (u_int32_t) adapter->first_tx_desc) >> 4)); } /* end of while loop */ splx(s); @@ -560,10 +556,9 @@ em_start(struct ifnet *ifp) static int em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) { - int s, - error = 0; + int s, mask, error = 0; struct ifreq *ifr = (struct ifreq *) data; - struct adapter * Adapter = ifp->if_softc; + struct adapter * adapter = ifp->if_softc; s = splimp(); switch (command) { @@ -578,8 +573,8 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) error = EINVAL; } else { ifp->if_mtu = ifr->ifr_mtu; - Adapter->shared.max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; - em_init(Adapter); + adapter->shared.max_frame_size = ifp->if_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN; + em_init(adapter); } break; case SIOCSIFFLAGS: @@ -587,15 +582,15 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) if (ifp->if_flags & IFF_UP) { if (ifp->if_flags & IFF_RUNNING && ifp->if_flags & IFF_PROMISC) { - em_set_promisc(Adapter); + em_set_promisc(adapter); } else if (ifp->if_flags & IFF_RUNNING && !(ifp->if_flags & IFF_PROMISC)) { - em_disable_promisc(Adapter); + em_disable_promisc(adapter); } else - em_init(Adapter); + em_init(adapter); } else { if (ifp->if_flags & IFF_RUNNING) { - em_stop(Adapter); + em_stop(adapter); } } break; @@ -603,17 +598,29 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) case SIOCDELMULTI: IOCTL_DEBUGOUT("ioctl rcv'd: SIOC(ADD|DEL)MULTI"); if (ifp->if_flags & IFF_RUNNING) { - DisableInterrupts(Adapter); - em_set_multi(Adapter); - if(Adapter->shared.mac_type == em_82542_rev2_0) - em_initialize_receive_unit(Adapter); - EnableInterrupts(Adapter); + em_disable_intr(adapter); + em_set_multi(adapter); + if(adapter->shared.mac_type == em_82542_rev2_0) + em_initialize_receive_unit(adapter); + em_enable_intr(adapter); } 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, &adapter->media, command); + break; + case SIOCSIFCAP: + IOCTL_DEBUGOUT("ioctl rcv'd: SIOCSIFCAP (Set Capabilities)"); + mask = ifr->ifr_reqcap ^ ifp->if_capenable; + if (mask & IFCAP_HWCSUM) { + if (IFCAP_HWCSUM & ifp->if_capenable) + ifp->if_capenable &= ~IFCAP_HWCSUM; + else + ifp->if_capenable |= IFCAP_HWCSUM; + if (ifp->if_flags & IFF_RUNNING) + em_init(adapter); + } break; default: IOCTL_DEBUGOUT1("ioctl received: UNKNOWN (0x%d)\n", (int)command); @@ -625,37 +632,37 @@ em_ioctl(struct ifnet *ifp, IOCTL_CMD_TYPE command, caddr_t data) } static void -em_set_promisc(struct adapter * Adapter) +em_set_promisc(struct adapter * adapter) { u_int32_t reg_rctl; - struct ifnet *ifp = &Adapter->interface_data.ac_if; + struct ifnet *ifp = &adapter->interface_data.ac_if; - reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL); + reg_rctl = E1000_READ_REG(&adapter->shared, RCTL); if(ifp->if_flags & IFF_PROMISC) { reg_rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE); - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); } else if (ifp->if_flags & IFF_ALLMULTI) { reg_rctl |= E1000_RCTL_MPE; reg_rctl &= ~E1000_RCTL_UPE; - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); } return; } static void -em_disable_promisc(struct adapter * Adapter) +em_disable_promisc(struct adapter * adapter) { u_int32_t reg_rctl; - reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL); + reg_rctl = E1000_READ_REG(&adapter->shared, RCTL); reg_rctl &= (~E1000_RCTL_UPE); reg_rctl &= (~E1000_RCTL_MPE); - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); return; } @@ -669,25 +676,25 @@ em_disable_promisc(struct adapter * Adapter) **********************************************************************/ static void -em_set_multi(struct adapter * Adapter) +em_set_multi(struct adapter * adapter) { u_int32_t reg_rctl = 0; u_int8_t mta[MAX_NUM_MULTICAST_ADDRESSES * ETH_LENGTH_OF_ADDRESS]; - u_int16_t PciCommandWord; + u_int16_t pci_cmd_word; struct ifmultiaddr *ifma; int mcnt = 0; - struct ifnet *ifp = &Adapter->interface_data.ac_if; + struct ifnet *ifp = &adapter->interface_data.ac_if; IOCTL_DEBUGOUT("em_set_multi: begin"); - if(Adapter->shared.mac_type == em_82542_rev2_0) { - reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL); - if(Adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { - PciCommandWord = Adapter->shared.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE; - pci_write_config(Adapter->dev, PCIR_COMMAND, PciCommandWord, 2); + if(adapter->shared.mac_type == em_82542_rev2_0) { + reg_rctl = E1000_READ_REG(&adapter->shared, RCTL); + if(adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { + pci_cmd_word = adapter->shared.pci_cmd_word & ~CMD_MEM_WRT_INVALIDATE; + pci_write_config(adapter->dev, PCIR_COMMAND, pci_cmd_word, 2); } reg_rctl |= E1000_RCTL_RST; - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); msec_delay(5); } @@ -705,20 +712,20 @@ em_set_multi(struct adapter * Adapter) } if (mcnt > MAX_NUM_MULTICAST_ADDRESSES) { - reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL); + reg_rctl = E1000_READ_REG(&adapter->shared, RCTL); reg_rctl |= E1000_RCTL_MPE; - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); } else - em_mc_addr_list_update(&Adapter->shared, mta, mcnt, 0); + em_mc_addr_list_update(&adapter->shared, mta, mcnt, 0); - if(Adapter->shared.mac_type == em_82542_rev2_0) { - reg_rctl = E1000_READ_REG(&Adapter->shared, RCTL); + if(adapter->shared.mac_type == em_82542_rev2_0) { + reg_rctl = E1000_READ_REG(&adapter->shared, RCTL); reg_rctl &= ~E1000_RCTL_RST; - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); msec_delay(5); - if(Adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { - pci_write_config(Adapter->dev, PCIR_COMMAND, Adapter->shared.pci_cmd_word, 2); + if(adapter->shared.pci_cmd_word & CMD_MEM_WRT_INVALIDATE) { + pci_write_config(adapter->dev, PCIR_COMMAND, adapter->shared.pci_cmd_word, 2); } } @@ -735,23 +742,23 @@ em_set_multi(struct adapter * Adapter) static void em_watchdog(struct ifnet *ifp) { - struct adapter * Adapter; - Adapter = ifp->if_softc; + struct adapter * adapter; + adapter = ifp->if_softc; /* If we are in this routine because of pause frames, then * don't reset the hardware. */ - if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_TXOFF) { + if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_TXOFF) { ifp->if_timer = EM_TX_TIMEOUT; return; } - printf("em%d: watchdog timeout -- resetting\n", Adapter->unit); + printf("em%d: watchdog timeout -- resetting\n", adapter->unit); ifp->if_flags &= ~IFF_RUNNING; - em_stop(Adapter); - em_init(Adapter); + em_stop(adapter); + em_init(adapter); ifp->if_oerrors++; return; @@ -769,42 +776,42 @@ em_local_timer(void *arg) { int s; struct ifnet *ifp; - struct adapter * Adapter = arg; - ifp = &Adapter->interface_data.ac_if; + struct adapter * adapter = arg; + ifp = &adapter->interface_data.ac_if; s = splimp(); - em_check_for_link(&Adapter->shared); - em_print_link_status(Adapter); - em_update_stats_counters(Adapter); + em_check_for_link(&adapter->shared); + em_print_link_status(adapter); + em_update_stats_counters(adapter); if(em_display_debug_stats && ifp->if_flags & IFF_RUNNING) { - em_print_hw_stats(Adapter); + em_print_hw_stats(adapter); } - Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz); + adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); splx(s); return; } static void -em_print_link_status(struct adapter * Adapter) +em_print_link_status(struct adapter * adapter) { - if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU) { - if(Adapter->LinkIsActive == 0) { - em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex); + if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) { + if(adapter->link_active == 0) { + em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex); printf("em%d: Link is up %d Mbps %s\n", - Adapter->unit, - Adapter->LineSpeed, - ((Adapter->FullDuplex == FULL_DUPLEX) ? + adapter->unit, + adapter->link_speed, + ((adapter->link_duplex == FULL_DUPLEX) ? "Full Duplex" : "Half Duplex")); - Adapter->LinkIsActive = 1; + adapter->link_active = 1; } } else { - if(Adapter->LinkIsActive == 1) { - Adapter->LineSpeed = 0; - Adapter->FullDuplex = 0; - printf("em%d: Link is Down\n", Adapter->unit); - Adapter->LinkIsActive = 0; + if(adapter->link_active == 1) { + adapter->link_speed = 0; + adapter->link_duplex = 0; + printf("em%d: Link is Down\n", adapter->unit); + adapter->link_active = 0; } } @@ -827,53 +834,55 @@ em_init(void *arg) { int s; struct ifnet *ifp; - struct adapter * Adapter = arg; + struct adapter * adapter = arg; INIT_DEBUGOUT("em_init: begin"); s = splimp(); - em_stop(Adapter); + em_stop(adapter); /* Initialize the hardware */ - if (em_hardware_init(Adapter)) { - printf("em%d: Unable to initialize the hardware\n", Adapter->unit); + if (em_hardware_init(adapter)) { + printf("em%d: Unable to initialize the hardware\n", adapter->unit); splx(s); return; } - Adapter->shared.adapter_stopped = FALSE; + adapter->shared.adapter_stopped = FALSE; /* 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(adapter)) { + printf("em%d: Could not setup transmit structures\n", adapter->unit); + em_stop(adapter); splx(s); return; } - em_initialize_transmit_unit(Adapter); + em_initialize_transmit_unit(adapter); /* Setup Multicast table */ - em_set_multi(Adapter); + em_set_multi(adapter); /* 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(adapter)) { + printf("em%d: Could not setup receive structures\n", adapter->unit); + em_stop(adapter); splx(s); return; } - em_initialize_receive_unit(Adapter); + em_initialize_receive_unit(adapter); - ifp = &Adapter->interface_data.ac_if; + ifp = &adapter->interface_data.ac_if; ifp->if_flags |= IFF_RUNNING; ifp->if_flags &= ~IFF_OACTIVE; - if(Adapter->shared.mac_type >= em_82543) - ifp->if_hwassist = EM_CHECKSUM_FEATURES; + if(adapter->shared.mac_type >= em_82543) { + if (ifp->if_capenable & IFCAP_TXCSUM) + ifp->if_hwassist = EM_CHECKSUM_FEATURES; + } - Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz); - em_clear_hw_cntrs(&Adapter->shared); - EnableInterrupts(Adapter); + adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); + em_clear_hw_cntrs(&adapter->shared); + em_enable_intr(adapter); splx(s); return; @@ -891,15 +900,15 @@ static void em_stop(void *arg) { struct ifnet *ifp; - struct adapter * Adapter = arg; - ifp = &Adapter->interface_data.ac_if; + struct adapter * adapter = arg; + ifp = &adapter->interface_data.ac_if; INIT_DEBUGOUT("em_stop: begin\n"); - DisableInterrupts(Adapter); - em_adapter_stop(&Adapter->shared); - untimeout(em_local_timer, Adapter, Adapter->timer_handle); - em_free_transmit_structures(Adapter); - em_free_receive_structures(Adapter); + em_disable_intr(adapter); + em_adapter_stop(&adapter->shared); + untimeout(em_local_timer, adapter, adapter->timer_handle); + em_free_transmit_structures(adapter); + em_free_receive_structures(adapter); /* Tell the stack that the interface is no longer active */ @@ -917,33 +926,33 @@ em_stop(void *arg) static void em_intr(void *arg) { - u_int32_t ProcessCount = EM_MAX_INTR; - u_int32_t IcrContents; - struct ifnet *ifp; - struct adapter *Adapter = arg; + u_int32_t loop_cnt = EM_MAX_INTR; + u_int32_t reg_icr; + struct ifnet *ifp; + struct adapter *adapter = arg; - ifp = &Adapter->interface_data.ac_if; + ifp = &adapter->interface_data.ac_if; - DisableInterrupts(Adapter); - while(ProcessCount > 0 && (IcrContents = E1000_READ_REG(&Adapter->shared, ICR)) != 0) { + em_disable_intr(adapter); + while(loop_cnt > 0 && (reg_icr = E1000_READ_REG(&adapter->shared, ICR)) != 0) { /* Link status change */ - if(IcrContents & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { - untimeout(em_local_timer, Adapter, Adapter->timer_handle); - Adapter->shared.get_link_status = 1; - em_check_for_link(&Adapter->shared); - em_print_link_status(Adapter); - Adapter->timer_handle = timeout(em_local_timer, Adapter, 2*hz); + if(reg_icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC)) { + untimeout(em_local_timer, adapter, adapter->timer_handle); + adapter->shared.get_link_status = 1; + em_check_for_link(&adapter->shared); + em_print_link_status(adapter); + adapter->timer_handle = timeout(em_local_timer, adapter, 2*hz); } if (ifp->if_flags & IFF_RUNNING) { - em_process_receive_interrupts(Adapter); - em_clean_transmit_interrupts(Adapter); + em_process_receive_interrupts(adapter); + em_clean_transmit_interrupts(adapter); } - ProcessCount--; + loop_cnt--; } - EnableInterrupts(Adapter); + em_enable_intr(adapter); if(ifp->if_flags & IFF_RUNNING && ifp->if_snd.ifq_head != NULL) em_start(ifp); @@ -963,37 +972,37 @@ em_intr(void *arg) static void em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) { - struct adapter * Adapter = ifp->if_softc; + struct adapter * adapter = ifp->if_softc; INIT_DEBUGOUT("em_media_status: begin"); - em_check_for_link(&Adapter->shared); - if(E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU) { - if(Adapter->LinkIsActive == 0) { - em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex); - Adapter->LinkIsActive = 1; + em_check_for_link(&adapter->shared); + if(E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) { + if(adapter->link_active == 0) { + em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex); + adapter->link_active = 1; } } else { - if(Adapter->LinkIsActive == 1) { - Adapter->LineSpeed = 0; - Adapter->FullDuplex = 0; - Adapter->LinkIsActive = 0; + if(adapter->link_active == 1) { + adapter->link_speed = 0; + adapter->link_duplex = 0; + adapter->link_active = 0; } } ifmr->ifm_status = IFM_AVALID; ifmr->ifm_active = IFM_ETHER; - if (!Adapter->LinkIsActive) + if (!adapter->link_active) return; ifmr->ifm_status |= IFM_ACTIVE; - if (Adapter->shared.media_type == em_media_type_fiber) { + if (adapter->shared.media_type == em_media_type_fiber) { ifmr->ifm_active |= IFM_1000_SX | IFM_FDX; } else { - switch (Adapter->LineSpeed) { + switch (adapter->link_speed) { case 10: ifmr->ifm_active |= IFM_10_T; break; @@ -1004,7 +1013,7 @@ em_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) ifmr->ifm_active |= IFM_1000_TX; break; } - if (Adapter->FullDuplex == FULL_DUPLEX) + if (adapter->link_duplex == FULL_DUPLEX) ifmr->ifm_active |= IFM_FDX; else ifmr->ifm_active |= IFM_HDX; @@ -1023,8 +1032,8 @@ 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 adapter * adapter = ifp->if_softc; + struct ifmedia *ifm = &adapter->media; INIT_DEBUGOUT("em_media_change: begin"); @@ -1033,39 +1042,39 @@ em_media_change(struct ifnet *ifp) switch(IFM_SUBTYPE(ifm->ifm_media)) { case IFM_AUTO: - if (Adapter->shared.autoneg) + if (adapter->shared.autoneg) return 0; else { - Adapter->shared.autoneg = DO_AUTO_NEG; - Adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT; + adapter->shared.autoneg = DO_AUTO_NEG; + adapter->shared.autoneg_advertised = AUTONEG_ADV_DEFAULT; } break; case IFM_1000_SX: case IFM_1000_TX: - Adapter->shared.autoneg = DO_AUTO_NEG; - Adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL; + adapter->shared.autoneg = DO_AUTO_NEG; + adapter->shared.autoneg_advertised = ADVERTISE_1000_FULL; break; case IFM_100_TX: - Adapter->shared.autoneg = FALSE; - Adapter->shared.autoneg_advertised = 0; + adapter->shared.autoneg = FALSE; + adapter->shared.autoneg_advertised = 0; if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) - Adapter->shared.forced_speed_duplex = em_100_full; + adapter->shared.forced_speed_duplex = em_100_full; else - Adapter->shared.forced_speed_duplex = em_100_half; + adapter->shared.forced_speed_duplex = em_100_half; break; case IFM_10_T: - Adapter->shared.autoneg = FALSE; - Adapter->shared.autoneg_advertised = 0; + adapter->shared.autoneg = FALSE; + adapter->shared.autoneg_advertised = 0; if ((ifm->ifm_media & IFM_GMASK) == IFM_FDX) - Adapter->shared.forced_speed_duplex = em_10_full; + adapter->shared.forced_speed_duplex = em_10_full; else - Adapter->shared.forced_speed_duplex = em_10_half; + adapter->shared.forced_speed_duplex = em_10_half; break; default: - printf("em%d: Unsupported media type\n", Adapter->unit); + printf("em%d: Unsupported media type\n", adapter->unit); } - em_init(Adapter); + em_init(adapter); return(0); } @@ -1078,99 +1087,100 @@ em_media_change(struct ifnet *ifp) * **********************************************************************/ static void -em_identify_hardware(struct adapter * Adapter) +em_identify_hardware(struct adapter * adapter) { - device_t dev = Adapter->dev; + device_t dev = adapter->dev; /* Make sure our PCI config space has the necessary stuff set */ - Adapter->shared.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); - if (!((Adapter->shared.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && - (Adapter->shared.pci_cmd_word & PCIM_CMD_MEMEN))) { + adapter->shared.pci_cmd_word = pci_read_config(dev, PCIR_COMMAND, 2); + if (!((adapter->shared.pci_cmd_word & PCIM_CMD_BUSMASTEREN) && + (adapter->shared.pci_cmd_word & PCIM_CMD_MEMEN))) { printf("em%d: Memory Access and/or Bus Master bits were not set!\n", - Adapter->unit); - Adapter->shared.pci_cmd_word |= (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); - pci_write_config(dev, PCIR_COMMAND, Adapter->shared.pci_cmd_word, 2); + adapter->unit); + adapter->shared.pci_cmd_word |= (PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN); + pci_write_config(dev, PCIR_COMMAND, adapter->shared.pci_cmd_word, 2); } /* Save off the information about this board */ - Adapter->VendorId = pci_get_vendor(dev); - Adapter->DeviceId = pci_get_device(dev); - Adapter->RevId = pci_read_config(dev, PCIR_REVID, 1); - Adapter->SubVendorId = pci_read_config(dev, PCIR_SUBVEND_0, 2); - Adapter->SubSystemId = pci_read_config(dev, PCIR_SUBDEV_0, 2); + adapter->shared.vendor_id = pci_get_vendor(dev); + adapter->shared.device_id = pci_get_device(dev); + adapter->shared.revision_id = pci_read_config(dev, PCIR_REVID, 1); + adapter->shared.subsystem_vendor_id = pci_read_config(dev, PCIR_SUBVEND_0, 2); + adapter->shared.subsystem_id = pci_read_config(dev, PCIR_SUBDEV_0, 2); - INIT_DEBUGOUT2("device id = 0x%x, Revid = 0x%x", Adapter->DeviceId, Adapter->RevId); /* Set MacType, etc. based on this PCI info */ - switch (Adapter->DeviceId) { - case PCI_DEVICE_ID_82542: - Adapter->shared.mac_type = (Adapter->RevId == 3) ? + switch (adapter->shared.device_id) { + case E1000_DEV_ID_82542: + adapter->shared.mac_type = (adapter->shared.revision_id == 3) ? em_82542_rev2_1 : em_82542_rev2_0; break; - case PCI_DEVICE_ID_82543GC_FIBER: - case PCI_DEVICE_ID_82543GC_COPPER: - Adapter->shared.mac_type = em_82543; + case E1000_DEV_ID_82543GC_FIBER: + case E1000_DEV_ID_82543GC_COPPER: + adapter->shared.mac_type = em_82543; break; - case PCI_DEVICE_ID_82544EI_FIBER: - case PCI_DEVICE_ID_82544EI_COPPER: - case PCI_DEVICE_ID_82544GC_COPPER: - case PCI_DEVICE_ID_82544GC_STRG: - Adapter->shared.mac_type = em_82544; + case E1000_DEV_ID_82544EI_FIBER: + case E1000_DEV_ID_82544EI_COPPER: + case E1000_DEV_ID_82544GC_COPPER: + case E1000_DEV_ID_82544GC_LOM: + adapter->shared.mac_type = em_82544; break; + case E1000_DEV_ID_82540EM: + adapter->shared.mac_type = em_82540; default: - INIT_DEBUGOUT1("Unknown device id 0x%x", Adapter->DeviceId); + INIT_DEBUGOUT1("Unknown device id 0x%x", adapter->shared.device_id); } return; } static int -em_allocate_pci_resources(struct adapter * Adapter) +em_allocate_pci_resources(struct adapter * adapter) { int resource_id = EM_MMBA; - device_t dev = Adapter->dev; + device_t dev = adapter->dev; - Adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, + adapter->res_memory = bus_alloc_resource(dev, SYS_RES_MEMORY, &resource_id, 0, ~0, 1, RF_ACTIVE); - if (!(Adapter->res_memory)) { - printf("em%d: Unable to allocate bus resource: memory\n", Adapter->unit); + if (!(adapter->res_memory)) { + printf("em%d: Unable to allocate bus resource: memory\n", adapter->unit); return(ENXIO); } - Adapter->osdep.bus_space_tag = rman_get_bustag(Adapter->res_memory); - Adapter->osdep.bus_space_handle = rman_get_bushandle(Adapter->res_memory); - Adapter->shared.hw_addr = (uint8_t *)Adapter->osdep.bus_space_handle; + adapter->osdep.bus_space_tag = rman_get_bustag(adapter->res_memory); + adapter->osdep.bus_space_handle = rman_get_bushandle(adapter->res_memory); + adapter->shared.hw_addr = (uint8_t *)adapter->osdep.bus_space_handle; resource_id = 0x0; - Adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, + adapter->res_interrupt = bus_alloc_resource(dev, SYS_RES_IRQ, &resource_id, 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE); - if (!(Adapter->res_interrupt)) { - printf("em%d: Unable to allocate bus resource: interrupt\n", Adapter->unit); + if (!(adapter->res_interrupt)) { + printf("em%d: Unable to allocate bus resource: interrupt\n", adapter->unit); return(ENXIO); } - if (bus_setup_intr(dev, Adapter->res_interrupt, INTR_TYPE_NET, - (void (*)(void *)) em_intr, Adapter, - &Adapter->int_handler_tag)) { - printf("em%d: Error registering interrupt handler!\n", Adapter->unit); + if (bus_setup_intr(dev, adapter->res_interrupt, INTR_TYPE_NET, + (void (*)(void *)) em_intr, adapter, + &adapter->int_handler_tag)) { + printf("em%d: Error registering interrupt handler!\n", adapter->unit); return(ENXIO); } - Adapter->shared.back = &Adapter->osdep; + adapter->shared.back = &adapter->osdep; return(0); } static void -em_free_pci_resources(struct adapter * Adapter) +em_free_pci_resources(struct adapter * adapter) { - device_t dev = Adapter->dev; + device_t dev = adapter->dev; - if(Adapter->res_interrupt != NULL) { - bus_teardown_intr(dev, Adapter->res_interrupt, Adapter->int_handler_tag); - bus_release_resource(dev, SYS_RES_IRQ, 0, Adapter->res_interrupt); + if(adapter->res_interrupt != NULL) { + bus_teardown_intr(dev, adapter->res_interrupt, adapter->int_handler_tag); + bus_release_resource(dev, SYS_RES_IRQ, 0, adapter->res_interrupt); } - if (Adapter->res_memory != NULL) { - bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, Adapter->res_memory); + if (adapter->res_memory != NULL) { + bus_release_resource(dev, SYS_RES_MEMORY, EM_MMBA, adapter->res_memory); } return; } @@ -1178,60 +1188,60 @@ em_free_pci_resources(struct adapter * Adapter) /********************************************************************* * * Initialize the hardware to a configuration as specified by the - * Adapter structure. The controller is reset, the EEPROM is + * adapter structure. The controller is reset, the EEPROM is * verified, the MAC address is set, then the shared initialization * routines are called. * **********************************************************************/ static int -em_hardware_init(struct adapter * Adapter) +em_hardware_init(struct adapter * adapter) { /* Issue a global reset */ - Adapter->shared.adapter_stopped = FALSE; - em_adapter_stop(&Adapter->shared); - Adapter->shared.adapter_stopped = FALSE; + adapter->shared.adapter_stopped = FALSE; + em_adapter_stop(&adapter->shared); + adapter->shared.adapter_stopped = FALSE; /* Make sure we have a good EEPROM before we read from it */ - if (!em_validate_eeprom_checksum(&Adapter->shared)) { - printf("em%d: The EEPROM Checksum Is Not Valid\n", Adapter->unit); + if (!em_validate_eeprom_checksum(&adapter->shared)) { + printf("em%d: The EEPROM Checksum Is Not Valid\n", adapter->unit); return EIO; } /* Copy the permanent MAC address and part number out of the EEPROM */ - em_read_mac_address(Adapter, Adapter->interface_data.ac_enaddr); - memcpy(Adapter->shared.mac_addr, Adapter->interface_data.ac_enaddr, + em_read_mac_address(adapter, adapter->interface_data.ac_enaddr); + memcpy(adapter->shared.mac_addr, adapter->interface_data.ac_enaddr, ETH_LENGTH_OF_ADDRESS); - em_read_part_num(&Adapter->shared, &(Adapter->PartNumber)); + em_read_part_num(&adapter->shared, &(adapter->part_num)); - if (!em_init_hw(&Adapter->shared)) { - printf("em%d: Hardware Initialization Failed", Adapter->unit); + if (!em_init_hw(&adapter->shared)) { + printf("em%d: Hardware Initialization Failed", adapter->unit); return EIO; } - em_check_for_link(&Adapter->shared); - if (E1000_READ_REG(&Adapter->shared, STATUS) & E1000_STATUS_LU) - Adapter->LinkIsActive = 1; + em_check_for_link(&adapter->shared); + if (E1000_READ_REG(&adapter->shared, STATUS) & E1000_STATUS_LU) + adapter->link_active = 1; else - Adapter->LinkIsActive = 0; + adapter->link_active = 0; - if (Adapter->LinkIsActive) { - em_get_speed_and_duplex(&Adapter->shared, &Adapter->LineSpeed, &Adapter->FullDuplex); + if (adapter->link_active) { + em_get_speed_and_duplex(&adapter->shared, &adapter->link_speed, &adapter->link_duplex); } else { - Adapter->LineSpeed = 0; - Adapter->FullDuplex = 0; + adapter->link_speed = 0; + adapter->link_duplex = 0; } return 0; } static void -em_read_mac_address(struct adapter * Adapter, u_int8_t * NodeAddress) +em_read_mac_address(struct adapter * adapter, u_int8_t * NodeAddress) { u_int16_t EepromWordValue; int i; for (i = 0; i < NODE_ADDRESS_SIZE; i += 2) { EepromWordValue = - em_read_eeprom(&Adapter->shared, EEPROM_NODE_ADDRESS_BYTE_0 + (i / 2)); + em_read_eeprom(&adapter->shared, EEPROM_NODE_ADDRESS_BYTE_0 + (i / 2)); NodeAddress[i] = (uint8_t) (EepromWordValue & 0x00FF); NodeAddress[i + 1] = (uint8_t) (EepromWordValue >> 8); } @@ -1245,51 +1255,55 @@ em_read_mac_address(struct adapter * Adapter, u_int8_t * NodeAddress) * **********************************************************************/ static void -em_setup_interface(device_t dev, struct adapter * Adapter) +em_setup_interface(device_t dev, struct adapter * adapter) { struct ifnet *ifp; INIT_DEBUGOUT("em_setup_interface: begin"); - ifp = &Adapter->interface_data.ac_if; - ifp->if_unit = Adapter->unit; + ifp = &adapter->interface_data.ac_if; + ifp->if_unit = adapter->unit; ifp->if_name = "em"; ifp->if_mtu = ETHERMTU; ifp->if_output = ether_output; ifp->if_baudrate = 1000000000; ifp->if_init = em_init; - ifp->if_softc = Adapter; + ifp->if_softc = adapter; ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; ifp->if_ioctl = em_ioctl; ifp->if_start = em_start; ifp->if_watchdog = em_watchdog; - ifp->if_snd.ifq_maxlen = Adapter->NumTxDescriptors - 1; + ifp->if_snd.ifq_maxlen = adapter->num_tx_desc - 1; ether_ifattach(ifp, ETHER_BPF_SUPPORTED); + if (adapter->shared.mac_type >= em_82543) { + ifp->if_capabilities = IFCAP_HWCSUM; + ifp->if_capenable = ifp->if_capabilities; + } + /* * 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, + ifmedia_init(&adapter->media, IFM_IMASK, em_media_change, em_media_status); - if (Adapter->shared.media_type == em_media_type_fiber) { - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 0, + if (adapter->shared.media_type == em_media_type_fiber) { + ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_SX | IFM_FDX, 0, NULL); - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_SX , 0, NULL); + ifmedia_add(&adapter->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, 0, + ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T, 0, NULL); + ifmedia_add(&adapter->media, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL); - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_100_TX, 0, NULL); - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, + ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX, 0, NULL); + ifmedia_add(&adapter->media, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL); - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 0, + ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX | IFM_FDX, 0, NULL); - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); + ifmedia_add(&adapter->media, IFM_ETHER | IFM_1000_TX, 0, NULL); } - ifmedia_add(&Adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); - ifmedia_set(&Adapter->media, IFM_ETHER | IFM_AUTO); + ifmedia_add(&adapter->media, IFM_ETHER | IFM_AUTO, 0, NULL); + ifmedia_set(&adapter->media, IFM_ETHER | IFM_AUTO); - INIT_DEBUGOUT("em_setup_interface: end"); return; } @@ -1301,18 +1315,18 @@ em_setup_interface(device_t dev, struct adapter * Adapter) * **********************************************************************/ static int -em_allocate_transmit_structures(struct adapter * Adapter) +em_allocate_transmit_structures(struct adapter * adapter) { - if (!(Adapter->tx_buffer_area = + if (!(adapter->tx_buffer_area = (struct em_tx_buffer *) malloc(sizeof(struct em_tx_buffer) * - Adapter->NumTxDescriptors, M_DEVBUF, + adapter->num_tx_desc, M_DEVBUF, M_NOWAIT))) { - printf("em%d: Unable to allocate tx_buffer memory\n", Adapter->unit); + printf("em%d: Unable to allocate tx_buffer memory\n", adapter->unit); return ENOMEM; } - bzero(Adapter->tx_buffer_area, - sizeof(struct em_tx_buffer) * Adapter->NumTxDescriptors); + bzero(adapter->tx_buffer_area, + sizeof(struct em_tx_buffer) * adapter->num_tx_desc); return 0; } @@ -1323,42 +1337,42 @@ em_allocate_transmit_structures(struct adapter * Adapter) * **********************************************************************/ static int -em_setup_transmit_structures(struct adapter * Adapter) +em_setup_transmit_structures(struct adapter * adapter) { struct em_tx_buffer *tx_buffer; int i; - if (em_allocate_transmit_structures(Adapter)) + if (em_allocate_transmit_structures(adapter)) return ENOMEM; - Adapter->FirstTxDescriptor = Adapter->TxDescBase; - Adapter->LastTxDescriptor = - Adapter->FirstTxDescriptor + (Adapter->NumTxDescriptors - 1); + adapter->first_tx_desc = adapter->tx_desc_base; + adapter->last_tx_desc = + adapter->first_tx_desc + (adapter->num_tx_desc - 1); - STAILQ_INIT(&Adapter->FreeSwTxPacketList); - STAILQ_INIT(&Adapter->UsedSwTxPacketList); + STAILQ_INIT(&adapter->free_tx_buffer_list); + STAILQ_INIT(&adapter->used_tx_buffer_list); - tx_buffer = Adapter->tx_buffer_area; + tx_buffer = adapter->tx_buffer_area; /* Setup the linked list of the tx_buffer's */ - for (i = 0; i < Adapter->NumTxDescriptors; i++, tx_buffer++) { + for (i = 0; i < adapter->num_tx_desc; i++, tx_buffer++) { bzero((void *) tx_buffer, sizeof(struct em_tx_buffer)); - STAILQ_INSERT_TAIL(&Adapter->FreeSwTxPacketList, tx_buffer, em_tx_entry); + STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, tx_buffer, em_tx_entry); } - bzero((void *) Adapter->FirstTxDescriptor, - (sizeof(struct em_tx_desc)) * Adapter->NumTxDescriptors); + bzero((void *) adapter->first_tx_desc, + (sizeof(struct em_tx_desc)) * adapter->num_tx_desc); /* Setup TX descriptor pointers */ - Adapter->NextAvailTxDescriptor = Adapter->FirstTxDescriptor; - Adapter->OldestUsedTxDescriptor = Adapter->FirstTxDescriptor; + adapter->next_avail_tx_desc = adapter->first_tx_desc; + adapter->oldest_used_tx_desc = adapter->first_tx_desc; /* Set number of descriptors available */ - Adapter->NumTxDescriptorsAvail = Adapter->NumTxDescriptors; + adapter->num_tx_desc_avail = adapter->num_tx_desc; /* Set checksum context */ - Adapter->ActiveChecksumContext = OFFLOAD_NONE; + adapter->active_checksum_context = OFFLOAD_NONE; return 0; } @@ -1369,31 +1383,32 @@ em_setup_transmit_structures(struct adapter * Adapter) * **********************************************************************/ static void -em_initialize_transmit_unit(struct adapter * Adapter) +em_initialize_transmit_unit(struct adapter * adapter) { u_int32_t reg_tctl; u_int32_t reg_tipg = 0; /* Setup the Base and Length of the Tx Descriptor Ring */ - E1000_WRITE_REG(&Adapter->shared, TDBAL, vtophys((vm_offset_t) Adapter->TxDescBase)); - E1000_WRITE_REG(&Adapter->shared, TDBAH, 0); - E1000_WRITE_REG(&Adapter->shared, TDLEN, Adapter->NumTxDescriptors * + E1000_WRITE_REG(&adapter->shared, TDBAL, vtophys((vm_offset_t) adapter->tx_desc_base)); + E1000_WRITE_REG(&adapter->shared, TDBAH, 0); + E1000_WRITE_REG(&adapter->shared, TDLEN, adapter->num_tx_desc * sizeof(struct em_tx_desc)); /* Setup the HW Tx Head and Tail descriptor pointers */ - E1000_WRITE_REG(&Adapter->shared, TDH, 0); - E1000_WRITE_REG(&Adapter->shared, TDT, 0); + E1000_WRITE_REG(&adapter->shared, TDH, 0); + E1000_WRITE_REG(&adapter->shared, TDT, 0); - HW_DEBUGOUT2("Base = %x, Length = %x\n", E1000_READ_REG(&Adapter->shared, TDBAL), - E1000_READ_REG(&Adapter->shared, TDLEN)); + HW_DEBUGOUT2("Base = %x, Length = %x\n", E1000_READ_REG(&adapter->shared, TDBAL), + E1000_READ_REG(&adapter->shared, TDLEN)); /* Set the default values for the Tx Inter Packet Gap timer */ - switch (Adapter->shared.mac_type) { + switch (adapter->shared.mac_type) { case em_82543: case em_82544: - if (Adapter->shared.media_type == em_media_type_fiber) + case em_82540: + if (adapter->shared.media_type == em_media_type_fiber) reg_tipg = DEFAULT_82543_TIPG_IPGT_FIBER; else reg_tipg = DEFAULT_82543_TIPG_IPGT_COPPER; @@ -1407,31 +1422,31 @@ em_initialize_transmit_unit(struct adapter * Adapter) reg_tipg |= DEFAULT_82542_TIPG_IPGR2 << E1000_TIPG_IPGR2_SHIFT; break; default: - printf("em%d: Invalid mac type detected\n", Adapter->unit); + printf("em%d: Invalid mac type detected\n", adapter->unit); } - E1000_WRITE_REG(&Adapter->shared, TIPG, reg_tipg); - E1000_WRITE_REG(&Adapter->shared, TIDV, Adapter->TxIntDelay); + E1000_WRITE_REG(&adapter->shared, TIPG, reg_tipg); + E1000_WRITE_REG(&adapter->shared, TIDV, adapter->tx_int_delay); /* Program the Transmit Control Register */ reg_tctl = E1000_TCTL_PSP | E1000_TCTL_EN | (E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT); - if (Adapter->FullDuplex == 1) { + if (adapter->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->shared, TCTL, reg_tctl); + E1000_WRITE_REG(&adapter->shared, TCTL, reg_tctl); /* Setup Transmit Descriptor Settings for this adapter */ - Adapter->TxdCmd = E1000_TXD_CMD_IFCS; + adapter->txd_cmd = E1000_TXD_CMD_IFCS; - if(Adapter->TxIntDelay > 0) - Adapter->TxdCmd |= E1000_TXD_CMD_IDE; + if(adapter->tx_int_delay > 0) + adapter->txd_cmd |= E1000_TXD_CMD_IDE; - if(Adapter->shared.report_tx_early == 1) - Adapter->TxdCmd |= E1000_TXD_CMD_RS; + if(adapter->shared.report_tx_early == 1) + adapter->txd_cmd |= E1000_TXD_CMD_RS; else - Adapter->TxdCmd |= E1000_TXD_CMD_RPS; + adapter->txd_cmd |= E1000_TXD_CMD_RPS; return; } @@ -1442,24 +1457,24 @@ em_initialize_transmit_unit(struct adapter * Adapter) * **********************************************************************/ static void -em_free_transmit_structures(struct adapter * Adapter) +em_free_transmit_structures(struct adapter * adapter) { struct em_tx_buffer *tx_buffer; int i; INIT_DEBUGOUT("free_transmit_structures: begin"); - if (Adapter->tx_buffer_area != NULL) { - tx_buffer = Adapter->tx_buffer_area; - for (i = 0; i < Adapter->NumTxDescriptors; i++, tx_buffer++) { - if (tx_buffer->Packet != NULL) - m_freem(tx_buffer->Packet); - tx_buffer->Packet = NULL; + 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) + m_freem(tx_buffer->m_head); + tx_buffer->m_head = NULL; } } - if (Adapter->tx_buffer_area != NULL) { - free(Adapter->tx_buffer_area, M_DEVBUF); - Adapter->tx_buffer_area = NULL; + if (adapter->tx_buffer_area != NULL) { + free(adapter->tx_buffer_area, M_DEVBUF); + adapter->tx_buffer_area = NULL; } return; } @@ -1472,43 +1487,39 @@ em_free_transmit_structures(struct adapter * Adapter) * **********************************************************************/ static void -em_transmit_checksum_setup(struct adapter * Adapter, +em_transmit_checksum_setup(struct adapter * adapter, struct mbuf *mp, struct em_tx_buffer *tx_buffer, u_int32_t *txd_upper, u_int32_t *txd_lower) { struct em_context_desc *TXD; - struct em_tx_desc * CurrentTxDescriptor; + struct em_tx_desc * current_tx_desc; if (mp->m_pkthdr.csum_flags) { if(mp->m_pkthdr.csum_flags & CSUM_TCP) { - TXCSUM_DEBUGOUT("Checksum TCP"); *txd_upper = E1000_TXD_POPTS_TXSM << 8; *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; - if(Adapter->ActiveChecksumContext == OFFLOAD_TCP_IP) + if(adapter->active_checksum_context == OFFLOAD_TCP_IP) return; else - Adapter->ActiveChecksumContext = OFFLOAD_TCP_IP; + adapter->active_checksum_context = OFFLOAD_TCP_IP; } else if(mp->m_pkthdr.csum_flags & CSUM_UDP) { - TXCSUM_DEBUGOUT("Checksum UDP"); *txd_upper = E1000_TXD_POPTS_TXSM << 8; *txd_lower = E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D; - if(Adapter->ActiveChecksumContext == OFFLOAD_UDP_IP) + if(adapter->active_checksum_context == OFFLOAD_UDP_IP) return; else - Adapter->ActiveChecksumContext = OFFLOAD_UDP_IP; + adapter->active_checksum_context = OFFLOAD_UDP_IP; } else { - TXCSUM_DEBUGOUT("Invalid protocol for checksum calculation\n"); *txd_upper = 0; *txd_lower = 0; return; } } else { - TXCSUM_DEBUGOUT("No checksum detected\n"); *txd_upper = 0; *txd_lower = 0; return; @@ -1517,8 +1528,8 @@ em_transmit_checksum_setup(struct adapter * Adapter, /* If we reach this point, the checksum offload context * needs to be reset. */ - CurrentTxDescriptor = Adapter->NextAvailTxDescriptor; - TXD = (struct em_context_desc *)CurrentTxDescriptor; + current_tx_desc = adapter->next_avail_tx_desc; + TXD = (struct em_context_desc *)current_tx_desc; TXD->lower_setup.ip_fields.ipcss = ETHER_HDR_LEN; TXD->lower_setup.ip_fields.ipcso = ETHER_HDR_LEN + offsetof(struct ip, ip_sum); @@ -1527,10 +1538,10 @@ em_transmit_checksum_setup(struct adapter * Adapter, TXD->upper_setup.tcp_fields.tucss = ETHER_HDR_LEN + sizeof(struct ip); TXD->upper_setup.tcp_fields.tucse = 0; - if(Adapter->ActiveChecksumContext == OFFLOAD_TCP_IP) { + if(adapter->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->ActiveChecksumContext == OFFLOAD_UDP_IP) { + } else if (adapter->active_checksum_context == OFFLOAD_UDP_IP) { TXD->upper_setup.tcp_fields.tucso = ETHER_HDR_LEN + sizeof(struct ip) + offsetof(struct udphdr, uh_sum); } @@ -1538,14 +1549,14 @@ em_transmit_checksum_setup(struct adapter * Adapter, TXD->tcp_seg_setup.data = 0; TXD->cmd_and_length = E1000_TXD_CMD_DEXT; - if (CurrentTxDescriptor == Adapter->LastTxDescriptor) - Adapter->NextAvailTxDescriptor = Adapter->FirstTxDescriptor; + if (current_tx_desc == adapter->last_tx_desc) + adapter->next_avail_tx_desc = adapter->first_tx_desc; else - Adapter->NextAvailTxDescriptor++; + adapter->next_avail_tx_desc++; - Adapter->NumTxDescriptorsAvail--; + adapter->num_tx_desc_avail--; - tx_buffer->NumTxDescriptorsUsed++; + tx_buffer->num_tx_desc_used++; return; } @@ -1556,26 +1567,24 @@ em_transmit_checksum_setup(struct adapter * Adapter, * **********************************************************************/ static int -em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter, +em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *adapter, struct mbuf *mp) { struct mbuf *nmp; struct ifnet *ifp; - ifp = &Adapter->interface_data.ac_if; + ifp = &adapter->interface_data.ac_if; if (mp == NULL) { MGETHDR(nmp, M_DONTWAIT, MT_DATA); if (nmp == NULL) { - printf("em%d: Mbuf allocation failed\n", Adapter->unit); - Adapter->StdMbufFailed++; + adapter->mbuf_alloc_failed++; return (ENOBUFS); } MCLGET(nmp, M_DONTWAIT); if ((nmp->m_flags & M_EXT) == 0) { m_freem(nmp); - printf("em%d: Mbuf cluster allocation failed\n", Adapter->unit); - Adapter->StdClusterFailed++; + adapter->mbuf_cluster_failed++; return (ENOBUFS); } nmp->m_len = nmp->m_pkthdr.len = MCLBYTES; @@ -1590,9 +1599,8 @@ em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter, m_adj(nmp, ETHER_ALIGN); } - rx_buffer->Packet = nmp; - rx_buffer->LowPhysicalAddress = vtophys(mtod(nmp, vm_offset_t)); - rx_buffer->HighPhysicalAddress = 0; + rx_buffer->m_head = nmp; + rx_buffer->buffer_addr = vtophys(mtod(nmp, vm_offset_t)); return (0); } @@ -1606,27 +1614,27 @@ em_get_buf(struct em_rx_buffer *rx_buffer, struct adapter *Adapter, * **********************************************************************/ static int -em_allocate_receive_structures(struct adapter * Adapter) +em_allocate_receive_structures(struct adapter * adapter) { int i; struct em_rx_buffer *rx_buffer; - if (!(Adapter->rx_buffer_area = + if (!(adapter->rx_buffer_area = (struct em_rx_buffer *) malloc(sizeof(struct em_rx_buffer) * - Adapter->NumRxDescriptors, M_DEVBUF, + adapter->num_rx_desc, M_DEVBUF, M_NOWAIT))) { - printf("em%d: Unable to allocate rx_buffer memory\n", Adapter->unit); + printf("em%d: Unable to allocate rx_buffer memory\n", adapter->unit); return (ENOMEM); } - bzero(Adapter->rx_buffer_area, - sizeof(struct em_rx_buffer) * Adapter->NumRxDescriptors); + bzero(adapter->rx_buffer_area, + sizeof(struct em_rx_buffer) * adapter->num_rx_desc); - for (i = 0, rx_buffer = Adapter->rx_buffer_area; - i < Adapter->NumRxDescriptors; i++, rx_buffer++) { + for (i = 0, rx_buffer = adapter->rx_buffer_area; + i < adapter->num_rx_desc; i++, rx_buffer++) { - if (em_get_buf(rx_buffer, Adapter, NULL) == ENOBUFS) { - rx_buffer->Packet = NULL; + if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) { + rx_buffer->m_head = NULL; return (ENOBUFS); } } @@ -1640,41 +1648,41 @@ em_allocate_receive_structures(struct adapter * Adapter) * **********************************************************************/ static int -em_setup_receive_structures(struct adapter * Adapter) +em_setup_receive_structures(struct adapter * adapter) { struct em_rx_buffer *rx_buffer; - struct em_rx_desc * RxDescriptorPtr; + struct em_rx_desc *rx_desc; int i; - if(em_allocate_receive_structures(Adapter)) + if(em_allocate_receive_structures(adapter)) return ENOMEM; - STAILQ_INIT(&Adapter->RxSwPacketList); + STAILQ_INIT(&adapter->rx_buffer_list); - Adapter->FirstRxDescriptor = - (struct em_rx_desc *) Adapter->RxDescBase; - Adapter->LastRxDescriptor = - Adapter->FirstRxDescriptor + (Adapter->NumRxDescriptors - 1); + adapter->first_rx_desc = + (struct em_rx_desc *) adapter->rx_desc_base; + adapter->last_rx_desc = + adapter->first_rx_desc + (adapter->num_rx_desc - 1); - rx_buffer = (struct em_rx_buffer *) Adapter->rx_buffer_area; + rx_buffer = (struct em_rx_buffer *) adapter->rx_buffer_area; - bzero((void *) Adapter->FirstRxDescriptor, - (sizeof(struct em_rx_desc)) * Adapter->NumRxDescriptors); + bzero((void *) adapter->first_rx_desc, + (sizeof(struct em_rx_desc)) * adapter->num_rx_desc); /* Build a linked list of rx_buffer's */ - for (i = 0, RxDescriptorPtr = Adapter->FirstRxDescriptor; - i < Adapter->NumRxDescriptors; - i++, rx_buffer++, RxDescriptorPtr++) { - if (rx_buffer->Packet == NULL) - printf("em%d: Receive buffer memory not allocated", Adapter->unit); + for (i = 0, rx_desc = adapter->first_rx_desc; + i < adapter->num_rx_desc; + i++, rx_buffer++, rx_desc++) { + if (rx_buffer->m_head == NULL) + printf("em%d: Receive buffer memory not allocated", adapter->unit); else { - RxDescriptorPtr->buffer_addr = rx_buffer->LowPhysicalAddress; - STAILQ_INSERT_TAIL(&Adapter->RxSwPacketList, rx_buffer, em_rx_entry); + rx_desc->buffer_addr = rx_buffer->buffer_addr; + STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, rx_buffer, em_rx_entry); } } /* Setup our descriptor pointers */ - Adapter->NextRxDescriptorToCheck = Adapter->FirstRxDescriptor; + adapter->next_rx_desc_to_check = adapter->first_rx_desc; return(0); } @@ -1685,39 +1693,42 @@ em_setup_receive_structures(struct adapter * Adapter) * **********************************************************************/ static void -em_initialize_receive_unit(struct adapter * Adapter) +em_initialize_receive_unit(struct adapter * adapter) { u_int32_t reg_rctl; u_int32_t reg_rxcsum; + struct ifnet *ifp; + + ifp = &adapter->interface_data.ac_if; /* Make sure receives are disabled while setting up the descriptor ring */ - E1000_WRITE_REG(&Adapter->shared, RCTL, 0); + E1000_WRITE_REG(&adapter->shared, RCTL, 0); /* Set the Receive Delay Timer Register */ - E1000_WRITE_REG(&Adapter->shared, RDTR, Adapter->RxIntDelay | E1000_RDT_FPDB); + E1000_WRITE_REG(&adapter->shared, RDTR, adapter->rx_int_delay | E1000_RDT_FPDB); /* Setup the Base and Length of the Rx Descriptor Ring */ - E1000_WRITE_REG(&Adapter->shared, RDBAL, vtophys((vm_offset_t) Adapter->RxDescBase)); - E1000_WRITE_REG(&Adapter->shared, RDBAH, 0); - E1000_WRITE_REG(&Adapter->shared, RDLEN, Adapter->NumRxDescriptors * + E1000_WRITE_REG(&adapter->shared, RDBAL, vtophys((vm_offset_t) adapter->rx_desc_base)); + E1000_WRITE_REG(&adapter->shared, RDBAH, 0); + E1000_WRITE_REG(&adapter->shared, RDLEN, adapter->num_rx_desc * sizeof(struct em_rx_desc)); /* Setup the HW Rx Head and Tail Descriptor Pointers */ - E1000_WRITE_REG(&Adapter->shared, RDH, 0); - E1000_WRITE_REG(&Adapter->shared, RDT, - (((u_int32_t) Adapter->LastRxDescriptor - - (u_int32_t) Adapter->FirstRxDescriptor) >> 4)); + E1000_WRITE_REG(&adapter->shared, RDH, 0); + E1000_WRITE_REG(&adapter->shared, RDT, + (((u_int32_t) adapter->last_rx_desc - + (u_int32_t) adapter->first_rx_desc) >> 4)); /* Setup the Receive Control Register */ reg_rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF | - (Adapter->shared.mc_filter_type << E1000_RCTL_MO_SHIFT); + (adapter->shared.mc_filter_type << E1000_RCTL_MO_SHIFT); - if (Adapter->shared.tbi_compatibility_on == TRUE) + if (adapter->shared.tbi_compatibility_on == TRUE) reg_rctl |= E1000_RCTL_SBP; - switch (Adapter->RxBufferLen) { + switch (adapter->rx_buffer_len) { case EM_RXBUFFER_2048: reg_rctl |= E1000_RCTL_SZ_2048 | E1000_RCTL_LPE; break; @@ -1735,14 +1746,14 @@ em_initialize_receive_unit(struct adapter * Adapter) } /* Enable 82543 Receive Checksum Offload for TCP and UDP */ - if((Adapter->shared.mac_type >= em_82543) && (Adapter->RxChecksum == 1)) { - reg_rxcsum = E1000_READ_REG(&Adapter->shared, RXCSUM); + if((adapter->shared.mac_type >= em_82543) && (ifp->if_capenable & IFCAP_RXCSUM)) { + reg_rxcsum = E1000_READ_REG(&adapter->shared, RXCSUM); reg_rxcsum |= (E1000_RXCSUM_IPOFL | E1000_RXCSUM_TUOFL); - E1000_WRITE_REG(&Adapter->shared, RXCSUM, reg_rxcsum); + E1000_WRITE_REG(&adapter->shared, RXCSUM, reg_rxcsum); } /* Enable Receives */ - E1000_WRITE_REG(&Adapter->shared, RCTL, reg_rctl); + E1000_WRITE_REG(&adapter->shared, RCTL, reg_rctl); return; } @@ -1753,24 +1764,24 @@ em_initialize_receive_unit(struct adapter * Adapter) * **********************************************************************/ static void -em_free_receive_structures(struct adapter * Adapter) +em_free_receive_structures(struct adapter * adapter) { struct em_rx_buffer *rx_buffer; int i; INIT_DEBUGOUT("free_receive_structures: begin"); - if (Adapter->rx_buffer_area != NULL) { - rx_buffer = Adapter->rx_buffer_area; - for (i = 0; i < Adapter->NumRxDescriptors; i++, rx_buffer++) { - if (rx_buffer->Packet != NULL) - m_freem(rx_buffer->Packet); - rx_buffer->Packet = NULL; + if (adapter->rx_buffer_area != NULL) { + rx_buffer = adapter->rx_buffer_area; + for (i = 0; i < adapter->num_rx_desc; i++, rx_buffer++) { + if (rx_buffer->m_head != NULL) + m_freem(rx_buffer->m_head); + rx_buffer->m_head = NULL; } } - if (Adapter->rx_buffer_area != NULL) { - free(Adapter->rx_buffer_area, M_DEVBUF); - Adapter->rx_buffer_area = NULL; + if (adapter->rx_buffer_area != NULL) { + free(adapter->rx_buffer_area, M_DEVBUF); + adapter->rx_buffer_area = NULL; } return; } @@ -1783,148 +1794,147 @@ em_free_receive_structures(struct adapter * Adapter) * *********************************************************************/ static void -em_process_receive_interrupts(struct adapter * Adapter) +em_process_receive_interrupts(struct adapter * adapter) { struct mbuf *mp; struct ifnet *ifp; struct ether_header *eh; - u_int16_t Length; - u_int8_t LastByte; - u_int8_t AcceptFrame = 0; - u_int8_t EndOfPacket = 0; - u_int32_t PacketLength = 0; + u_int16_t len; + u_int8_t last_byte; + u_int8_t accept_frame = 0; + u_int8_t eop = 0; + u_int32_t pkt_len = 0; /* Pointer to the receive descriptor being examined. */ - struct em_rx_desc * CurrentDescriptor; - struct em_rx_desc * LastDescriptorProcessed; - struct em_rx_buffer *rx_buffer; + struct em_rx_desc *current_desc; + struct em_rx_desc *last_desc_processed; + struct em_rx_buffer *rx_buffer; - TXRX_DEBUGOUT("em_process_receive_interrupts: begin"); + ifp = &adapter->interface_data.ac_if; + current_desc = adapter->next_rx_desc_to_check; - ifp = &Adapter->interface_data.ac_if; - CurrentDescriptor = Adapter->NextRxDescriptorToCheck; - - if (!((CurrentDescriptor->status) & E1000_RXD_STAT_DD)) { + if (!((current_desc->status) & E1000_RXD_STAT_DD)) { #ifdef DBG_STATS - Adapter->NoPacketsAvail++; + adapter->no_pkts_avail++; #endif return; } - while (CurrentDescriptor->status & E1000_RXD_STAT_DD) { + while (current_desc->status & E1000_RXD_STAT_DD) { /* Get a pointer to the actual receive buffer */ - rx_buffer = STAILQ_FIRST(&Adapter->RxSwPacketList); + rx_buffer = STAILQ_FIRST(&adapter->rx_buffer_list); if(rx_buffer == NULL) { - printf("em%d: Found null rx_buffer\n", Adapter->unit); + printf("em%d: Found null rx_buffer\n", adapter->unit); return; } - mp = rx_buffer->Packet; - AcceptFrame = 1; + mp = rx_buffer->m_head; + accept_frame = 1; - if (CurrentDescriptor->status & E1000_RXD_STAT_EOP) { - EndOfPacket = 1; - Length = CurrentDescriptor->length - ETHER_CRC_LEN; + if (current_desc->status & E1000_RXD_STAT_EOP) { + eop = 1; + len = current_desc->length - ETHER_CRC_LEN; } else { - EndOfPacket = 0; - Length = CurrentDescriptor->length; + eop = 0; + len = current_desc->length; } - if(CurrentDescriptor->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { + if(current_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK) { /* Compute packet length for tbi_accept macro */ - PacketLength = CurrentDescriptor->length; - if (Adapter->fmp != NULL) { - PacketLength += Adapter->fmp->m_pkthdr.len; + pkt_len = current_desc->length; + if (adapter->fmp != NULL) { + pkt_len += adapter->fmp->m_pkthdr.len; } - LastByte = *(mtod(rx_buffer->Packet,caddr_t) + CurrentDescriptor->length - 1); + last_byte = *(mtod(rx_buffer->m_head,caddr_t) + current_desc->length - 1); - if (TBI_ACCEPT(&Adapter->shared, 0, CurrentDescriptor->errors, - PacketLength, LastByte)) { - PacketLength = em_tbi_adjust_stats(&Adapter->shared, &Adapter->stats, - PacketLength, Adapter->shared.mac_addr); - Length--; + if (TBI_ACCEPT(&adapter->shared, current_desc->status, + current_desc->errors, + pkt_len, last_byte)) { + pkt_len = em_tbi_adjust_stats(&adapter->shared, &adapter->stats, + pkt_len, adapter->shared.mac_addr); + len--; } else { - AcceptFrame = 0; + accept_frame = 0; } } - if (AcceptFrame) { + if (accept_frame) { - if (em_get_buf(rx_buffer, Adapter, NULL) == ENOBUFS) { - Adapter->DroppedPackets++; - em_get_buf(rx_buffer, Adapter, mp); - if(Adapter->fmp != NULL) m_freem(Adapter->fmp); - Adapter->fmp = NULL; - Adapter->lmp = NULL; + if (em_get_buf(rx_buffer, adapter, NULL) == ENOBUFS) { + adapter->dropped_pkts++; + em_get_buf(rx_buffer, adapter, mp); + if(adapter->fmp != NULL) m_freem(adapter->fmp); + adapter->fmp = NULL; + adapter->lmp = NULL; break; } /* Assign correct length to the current fragment */ - mp->m_len = Length; + mp->m_len = len; - if(Adapter->fmp == NULL) { - mp->m_pkthdr.len = Length; - Adapter->fmp = mp; /* Store the first mbuf */ - Adapter->lmp = mp; + if(adapter->fmp == NULL) { + mp->m_pkthdr.len = len; + adapter->fmp = mp; /* Store the first mbuf */ + adapter->lmp = mp; } else { /* Chain mbuf's together */ mp->m_flags &= ~M_PKTHDR; - Adapter->lmp->m_next = mp; - Adapter->lmp = Adapter->lmp->m_next; - Adapter->fmp->m_pkthdr.len += Length; + adapter->lmp->m_next = mp; + adapter->lmp = adapter->lmp->m_next; + adapter->fmp->m_pkthdr.len += len; } - if (EndOfPacket) { - Adapter->fmp->m_pkthdr.rcvif = ifp; + if (eop) { + adapter->fmp->m_pkthdr.rcvif = ifp; - eh = mtod(Adapter->fmp, struct ether_header *); + eh = mtod(adapter->fmp, struct ether_header *); /* Remove ethernet header from mbuf */ - m_adj(Adapter->fmp, sizeof(struct ether_header)); - em_receive_checksum(Adapter, CurrentDescriptor, Adapter->fmp); - ether_input(ifp, eh, Adapter->fmp); + m_adj(adapter->fmp, sizeof(struct ether_header)); + em_receive_checksum(adapter, current_desc, adapter->fmp); + ether_input(ifp, eh, adapter->fmp); - Adapter->fmp = NULL; - Adapter->lmp = NULL; + adapter->fmp = NULL; + adapter->lmp = NULL; } } else { - Adapter->DroppedPackets++; - em_get_buf(rx_buffer, Adapter, mp); - if(Adapter->fmp != NULL) m_freem(Adapter->fmp); - Adapter->fmp = NULL; - Adapter->lmp = NULL; + adapter->dropped_pkts++; + em_get_buf(rx_buffer, adapter, mp); + if(adapter->fmp != NULL) m_freem(adapter->fmp); + adapter->fmp = NULL; + adapter->lmp = NULL; } /* Zero out the receive descriptors status */ - CurrentDescriptor->status = 0; + current_desc->status = 0; - if (rx_buffer->Packet != NULL) { - CurrentDescriptor->buffer_addr = rx_buffer->LowPhysicalAddress; + if (rx_buffer->m_head != NULL) { + current_desc->buffer_addr = rx_buffer->buffer_addr; } /* Advance our pointers to the next descriptor (checking for wrap). */ - if (CurrentDescriptor == Adapter->LastRxDescriptor) - Adapter->NextRxDescriptorToCheck = Adapter->FirstRxDescriptor; + if (current_desc == adapter->last_rx_desc) + adapter->next_rx_desc_to_check = adapter->first_rx_desc; else - ((Adapter)->NextRxDescriptorToCheck)++; + ((adapter)->next_rx_desc_to_check)++; - LastDescriptorProcessed = CurrentDescriptor; - CurrentDescriptor = Adapter->NextRxDescriptorToCheck; + last_desc_processed = current_desc; + current_desc = adapter->next_rx_desc_to_check; /* * Put the buffer that we just indicated back at the end of our list */ - STAILQ_REMOVE_HEAD(&Adapter->RxSwPacketList, em_rx_entry); - STAILQ_INSERT_TAIL(&Adapter->RxSwPacketList, rx_buffer, em_rx_entry); + STAILQ_REMOVE_HEAD(&adapter->rx_buffer_list, em_rx_entry); + STAILQ_INSERT_TAIL(&adapter->rx_buffer_list, rx_buffer, em_rx_entry); /* Advance the E1000's Receive Queue #0 "Tail Pointer". */ - E1000_WRITE_REG(&Adapter->shared, RDT, (((u_int32_t) LastDescriptorProcessed - - (u_int32_t) Adapter->FirstRxDescriptor) >> 4)); + E1000_WRITE_REG(&adapter->shared, RDT, (((u_int32_t) last_desc_processed - + (u_int32_t) adapter->first_rx_desc) >> 4)); } return; } @@ -1937,76 +1947,62 @@ em_process_receive_interrupts(struct adapter * Adapter) * *********************************************************************/ static void -em_receive_checksum(struct adapter * Adapter, - struct em_rx_desc * RxDescriptor, - struct mbuf *mp) +em_receive_checksum(struct adapter *adapter, + struct em_rx_desc *rx_desc, + struct mbuf *mp) { /* 82543 or newer only */ - if((Adapter->shared.mac_type < em_82543) || + if((adapter->shared.mac_type < em_82543) || /* Ignore Checksum bit is set */ - (RxDescriptor->status & E1000_RXD_STAT_IXSM)) { - RXCSUM_DEBUGOUT("Ignoring checksum"); + (rx_desc->status & E1000_RXD_STAT_IXSM)) { mp->m_pkthdr.csum_flags = 0; return; } - if (RxDescriptor->status & E1000_RXD_STAT_IPCS) { + if (rx_desc->status & E1000_RXD_STAT_IPCS) { /* Did it pass? */ - if (!(RxDescriptor->errors & E1000_RXD_ERR_IPE)) { + if (!(rx_desc->errors & E1000_RXD_ERR_IPE)) { /* IP Checksum Good */ - RXCSUM_DEBUGOUT("Good IP checksum"); mp->m_pkthdr.csum_flags = CSUM_IP_CHECKED; mp->m_pkthdr.csum_flags |= CSUM_IP_VALID; } else { - RXCSUM_DEBUGOUT("Bad IP checksum"); mp->m_pkthdr.csum_flags = 0; } } - else { - RXCSUM_DEBUGOUT("IP Checksum not verified"); - } - if (RxDescriptor->status & E1000_RXD_STAT_TCPCS) { + if (rx_desc->status & E1000_RXD_STAT_TCPCS) { /* Did it pass? */ - if (!(RxDescriptor->errors & E1000_RXD_ERR_TCPE)) { - RXCSUM_DEBUGOUT("Good TCP/UDP checksum"); + if (!(rx_desc->errors & E1000_RXD_ERR_TCPE)) { mp->m_pkthdr.csum_flags |= (CSUM_DATA_VALID | CSUM_PSEUDO_HDR); mp->m_pkthdr.csum_data = htons(0xffff); } - else { - RXCSUM_DEBUGOUT("Bad TCP/UDP checksum"); - } - } - else { - RXCSUM_DEBUGOUT("TCP/UDP checksum not verified"); } - return; } static void -EnableInterrupts(struct adapter * Adapter) +em_enable_intr(struct adapter * adapter) { - E1000_WRITE_REG(&Adapter->shared, IMS, (IMS_ENABLE_MASK)); + E1000_WRITE_REG(&adapter->shared, IMS, (IMS_ENABLE_MASK)); return; } static void -DisableInterrupts(struct adapter * Adapter) +em_disable_intr(struct adapter * adapter) { - E1000_WRITE_REG(&Adapter->shared, IMC, (0xffffffff & ~E1000_IMC_RXSEQ)); + E1000_WRITE_REG(&adapter->shared, IMC, (0xffffffff & ~E1000_IMC_RXSEQ)); return; } -void em_write_pci_cfg(struct em_shared_adapter *Adapter, +void em_write_pci_cfg(struct em_shared_adapter *adapter, uint32_t reg, uint16_t * value) { - pci_write_config(((struct em_osdep *)Adapter->back)->dev, reg, *value, 2); + pci_write_config(((struct em_osdep *)adapter->back)->dev, reg, *value, 2); } @@ -2016,96 +2012,96 @@ void em_write_pci_cfg(struct em_shared_adapter *Adapter, * **********************************************************************/ static void -em_update_stats_counters(struct adapter * Adapter) +em_update_stats_counters(struct adapter * adapter) { struct ifnet *ifp; - Adapter->stats.crcerrs += E1000_READ_REG(&Adapter->shared, CRCERRS); - Adapter->stats.symerrs += E1000_READ_REG(&Adapter->shared, SYMERRS); - Adapter->stats.mpc += E1000_READ_REG(&Adapter->shared, MPC); - Adapter->stats.scc += E1000_READ_REG(&Adapter->shared, SCC); - Adapter->stats.ecol += E1000_READ_REG(&Adapter->shared, ECOL); - Adapter->stats.mcc += E1000_READ_REG(&Adapter->shared, MCC); - Adapter->stats.latecol += E1000_READ_REG(&Adapter->shared, LATECOL); - Adapter->stats.colc += E1000_READ_REG(&Adapter->shared, COLC); - Adapter->stats.dc += E1000_READ_REG(&Adapter->shared, DC); - Adapter->stats.sec += E1000_READ_REG(&Adapter->shared, SEC); - Adapter->stats.rlec += E1000_READ_REG(&Adapter->shared, RLEC); - Adapter->stats.xonrxc += E1000_READ_REG(&Adapter->shared, XONRXC); - Adapter->stats.xontxc += E1000_READ_REG(&Adapter->shared, XONTXC); - Adapter->stats.xoffrxc += E1000_READ_REG(&Adapter->shared, XOFFRXC); - Adapter->stats.xofftxc += E1000_READ_REG(&Adapter->shared, XOFFTXC); - Adapter->stats.fcruc += E1000_READ_REG(&Adapter->shared, FCRUC); - Adapter->stats.prc64 += E1000_READ_REG(&Adapter->shared, PRC64); - Adapter->stats.prc127 += E1000_READ_REG(&Adapter->shared, PRC127); - Adapter->stats.prc255 += E1000_READ_REG(&Adapter->shared, PRC255); - Adapter->stats.prc511 += E1000_READ_REG(&Adapter->shared, PRC511); - Adapter->stats.prc1023 += E1000_READ_REG(&Adapter->shared, PRC1023); - Adapter->stats.prc1522 += E1000_READ_REG(&Adapter->shared, PRC1522); - Adapter->stats.gprc += E1000_READ_REG(&Adapter->shared, GPRC); - Adapter->stats.bprc += E1000_READ_REG(&Adapter->shared, BPRC); - Adapter->stats.mprc += E1000_READ_REG(&Adapter->shared, MPRC); - Adapter->stats.gptc += E1000_READ_REG(&Adapter->shared, GPTC); + adapter->stats.crcerrs += E1000_READ_REG(&adapter->shared, CRCERRS); + adapter->stats.symerrs += E1000_READ_REG(&adapter->shared, SYMERRS); + adapter->stats.mpc += E1000_READ_REG(&adapter->shared, MPC); + adapter->stats.scc += E1000_READ_REG(&adapter->shared, SCC); + adapter->stats.ecol += E1000_READ_REG(&adapter->shared, ECOL); + adapter->stats.mcc += E1000_READ_REG(&adapter->shared, MCC); + adapter->stats.latecol += E1000_READ_REG(&adapter->shared, LATECOL); + adapter->stats.colc += E1000_READ_REG(&adapter->shared, COLC); + adapter->stats.dc += E1000_READ_REG(&adapter->shared, DC); + adapter->stats.sec += E1000_READ_REG(&adapter->shared, SEC); + adapter->stats.rlec += E1000_READ_REG(&adapter->shared, RLEC); + adapter->stats.xonrxc += E1000_READ_REG(&adapter->shared, XONRXC); + adapter->stats.xontxc += E1000_READ_REG(&adapter->shared, XONTXC); + adapter->stats.xoffrxc += E1000_READ_REG(&adapter->shared, XOFFRXC); + adapter->stats.xofftxc += E1000_READ_REG(&adapter->shared, XOFFTXC); + adapter->stats.fcruc += E1000_READ_REG(&adapter->shared, FCRUC); + adapter->stats.prc64 += E1000_READ_REG(&adapter->shared, PRC64); + adapter->stats.prc127 += E1000_READ_REG(&adapter->shared, PRC127); + adapter->stats.prc255 += E1000_READ_REG(&adapter->shared, PRC255); + adapter->stats.prc511 += E1000_READ_REG(&adapter->shared, PRC511); + adapter->stats.prc1023 += E1000_READ_REG(&adapter->shared, PRC1023); + adapter->stats.prc1522 += E1000_READ_REG(&adapter->shared, PRC1522); + adapter->stats.gprc += E1000_READ_REG(&adapter->shared, GPRC); + adapter->stats.bprc += E1000_READ_REG(&adapter->shared, BPRC); + adapter->stats.mprc += E1000_READ_REG(&adapter->shared, MPRC); + adapter->stats.gptc += E1000_READ_REG(&adapter->shared, 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->shared, GORCL); - Adapter->stats.gorch += E1000_READ_REG(&Adapter->shared, GORCH); - Adapter->stats.gotcl += E1000_READ_REG(&Adapter->shared, GOTCL); - Adapter->stats.gotch += E1000_READ_REG(&Adapter->shared, GOTCH); - - Adapter->stats.rnbc += E1000_READ_REG(&Adapter->shared, RNBC); - Adapter->stats.ruc += E1000_READ_REG(&Adapter->shared, RUC); - Adapter->stats.rfc += E1000_READ_REG(&Adapter->shared, RFC); - Adapter->stats.roc += E1000_READ_REG(&Adapter->shared, ROC); - Adapter->stats.rjc += E1000_READ_REG(&Adapter->shared, RJC); - - Adapter->stats.torl += E1000_READ_REG(&Adapter->shared, TORL); - Adapter->stats.torh += E1000_READ_REG(&Adapter->shared, TORH); - Adapter->stats.totl += E1000_READ_REG(&Adapter->shared, TOTL); - Adapter->stats.toth += E1000_READ_REG(&Adapter->shared, TOTH); - - Adapter->stats.tpr += E1000_READ_REG(&Adapter->shared, TPR); - Adapter->stats.tpt += E1000_READ_REG(&Adapter->shared, TPT); - Adapter->stats.ptc64 += E1000_READ_REG(&Adapter->shared, PTC64); - Adapter->stats.ptc127 += E1000_READ_REG(&Adapter->shared, PTC127); - Adapter->stats.ptc255 += E1000_READ_REG(&Adapter->shared, PTC255); - Adapter->stats.ptc511 += E1000_READ_REG(&Adapter->shared, PTC511); - Adapter->stats.ptc1023 += E1000_READ_REG(&Adapter->shared, PTC1023); - Adapter->stats.ptc1522 += E1000_READ_REG(&Adapter->shared, PTC1522); - Adapter->stats.mptc += E1000_READ_REG(&Adapter->shared, MPTC); - Adapter->stats.bptc += E1000_READ_REG(&Adapter->shared, BPTC); - - if (Adapter->shared.mac_type >= em_82543) { - Adapter->stats.algnerrc += E1000_READ_REG(&Adapter->shared, ALGNERRC); - Adapter->stats.rxerrc += E1000_READ_REG(&Adapter->shared, RXERRC); - Adapter->stats.tncrs += E1000_READ_REG(&Adapter->shared, TNCRS); - Adapter->stats.cexterr += E1000_READ_REG(&Adapter->shared, CEXTERR); - Adapter->stats.tsctc += E1000_READ_REG(&Adapter->shared, TSCTC); - Adapter->stats.tsctfc += E1000_READ_REG(&Adapter->shared, TSCTFC); + adapter->stats.gorcl += E1000_READ_REG(&adapter->shared, GORCL); + adapter->stats.gorch += E1000_READ_REG(&adapter->shared, GORCH); + adapter->stats.gotcl += E1000_READ_REG(&adapter->shared, GOTCL); + adapter->stats.gotch += E1000_READ_REG(&adapter->shared, GOTCH); + + adapter->stats.rnbc += E1000_READ_REG(&adapter->shared, RNBC); + adapter->stats.ruc += E1000_READ_REG(&adapter->shared, RUC); + adapter->stats.rfc += E1000_READ_REG(&adapter->shared, RFC); + adapter->stats.roc += E1000_READ_REG(&adapter->shared, ROC); + adapter->stats.rjc += E1000_READ_REG(&adapter->shared, RJC); + + adapter->stats.torl += E1000_READ_REG(&adapter->shared, TORL); + adapter->stats.torh += E1000_READ_REG(&adapter->shared, TORH); + adapter->stats.totl += E1000_READ_REG(&adapter->shared, TOTL); + adapter->stats.toth += E1000_READ_REG(&adapter->shared, TOTH); + + adapter->stats.tpr += E1000_READ_REG(&adapter->shared, TPR); + adapter->stats.tpt += E1000_READ_REG(&adapter->shared, TPT); + adapter->stats.ptc64 += E1000_READ_REG(&adapter->shared, PTC64); + adapter->stats.ptc127 += E1000_READ_REG(&adapter->shared, PTC127); + adapter->stats.ptc255 += E1000_READ_REG(&adapter->shared, PTC255); + adapter->stats.ptc511 += E1000_READ_REG(&adapter->shared, PTC511); + adapter->stats.ptc1023 += E1000_READ_REG(&adapter->shared, PTC1023); + adapter->stats.ptc1522 += E1000_READ_REG(&adapter->shared, PTC1522); + adapter->stats.mptc += E1000_READ_REG(&adapter->shared, MPTC); + adapter->stats.bptc += E1000_READ_REG(&adapter->shared, BPTC); + + if (adapter->shared.mac_type >= em_82543) { + adapter->stats.algnerrc += E1000_READ_REG(&adapter->shared, ALGNERRC); + adapter->stats.rxerrc += E1000_READ_REG(&adapter->shared, RXERRC); + adapter->stats.tncrs += E1000_READ_REG(&adapter->shared, TNCRS); + adapter->stats.cexterr += E1000_READ_REG(&adapter->shared, CEXTERR); + adapter->stats.tsctc += E1000_READ_REG(&adapter->shared, TSCTC); + adapter->stats.tsctfc += E1000_READ_REG(&adapter->shared, TSCTFC); } - ifp = &Adapter->interface_data.ac_if; + ifp = &adapter->interface_data.ac_if; /* Fill out the OS statistics structure */ - ifp->if_ipackets = Adapter->stats.gprc; - ifp->if_opackets = Adapter->stats.gptc; - ifp->if_ibytes = Adapter->stats.gorcl; - ifp->if_obytes = Adapter->stats.gotcl; - ifp->if_imcasts = Adapter->stats.mprc; - ifp->if_collisions = Adapter->stats.colc; + ifp->if_ipackets = adapter->stats.gprc; + ifp->if_opackets = adapter->stats.gptc; + ifp->if_ibytes = adapter->stats.gorcl; + ifp->if_obytes = adapter->stats.gotcl; + ifp->if_imcasts = adapter->stats.mprc; + ifp->if_collisions = adapter->stats.colc; /* Rx Errors */ ifp->if_ierrors = - Adapter->DroppedPackets + - Adapter->stats.rxerrc + - Adapter->stats.crcerrs + - Adapter->stats.algnerrc + - Adapter->stats.rlec + Adapter->stats.rnbc + - Adapter->stats.mpc + Adapter->stats.cexterr; + adapter->dropped_pkts + + adapter->stats.rxerrc + + adapter->stats.crcerrs + + adapter->stats.algnerrc + + adapter->stats.rlec + adapter->stats.rnbc + + adapter->stats.mpc + adapter->stats.cexterr; /* Tx Errors */ - ifp->if_oerrors = Adapter->stats.ecol + Adapter->stats.latecol; + ifp->if_oerrors = adapter->stats.ecol + adapter->stats.latecol; } @@ -2118,43 +2114,42 @@ em_update_stats_counters(struct adapter * Adapter) * **********************************************************************/ static void -em_print_hw_stats(struct adapter * Adapter) +em_print_hw_stats(struct adapter * adapter) { - int unit = Adapter->unit; + int unit = adapter->unit; #ifdef DBG_STATS - printf("em%d: Tx Descriptors not Avail = %ld\n", unit, Adapter->NoTxDescAvail); - printf("em%d: Packets not Avail = %ld\n", unit, Adapter->NoPacketsAvail); - printf("em%d: CleanTxInterrupts = %ld\n", unit, Adapter->CleanTxInterrupts); - printf("em%d: Tx Buffer not avail1 = %ld\n", unit, Adapter->NoTxBufferAvail1); - printf("em%d: Tx Buffer not avail2 = %ld\n", unit, Adapter->NoTxBufferAvail2); + printf("em%d: Packets not Avail = %ld\n", unit, adapter->no_pkts_avail); + printf("em%d: clean_tx_interrupts = %ld\n", unit, adapter->clean_tx_interrupts); #endif - printf("em%d: No Jumbo Buffer Avail = %ld\n",unit, Adapter->NoJumboBufAvail); - printf("em%d: Jumbo Mbuf Failed = %ld\n",unit, Adapter->JumboMbufFailed); - printf("em%d: Jumbo Cluster Failed = %ld\n",unit, Adapter->JumboClusterFailed); - printf("em%d: Std Mbuf Failed = %ld\n",unit, Adapter->StdMbufFailed); - printf("em%d: Std Cluster Failed = %ld\n",unit, Adapter->StdClusterFailed); - - printf("em%d: Symbol errors = %lld\n", unit, Adapter->stats.symerrs); - printf("em%d: Sequence errors = %lld\n", unit, Adapter->stats.sec); - printf("em%d: Defer count = %lld\n", unit, Adapter->stats.dc); - - printf("em%d: Missed Packets = %lld\n", unit, Adapter->stats.mpc); - printf("em%d: Receive No Buffers = %lld\n", unit, Adapter->stats.rnbc); - printf("em%d: Receive length errors = %lld\n", unit, Adapter->stats.rlec); - printf("em%d: Receive errors = %lld\n", unit, Adapter->stats.rxerrc); - printf("em%d: Crc errors = %lld\n", unit, Adapter->stats.crcerrs); - printf("em%d: Alignment errors = %lld\n", unit, Adapter->stats.algnerrc); - printf("em%d: Carrier extension errors = %lld\n", unit, Adapter->stats.cexterr); - printf("em%d: Driver dropped packets = %ld\n", unit, Adapter->DroppedPackets); - - printf("em%d: XON Rcvd = %lld\n", unit, Adapter->stats.xonrxc); - printf("em%d: XON Xmtd = %lld\n", unit, Adapter->stats.xontxc); - printf("em%d: XOFF Rcvd = %lld\n", unit, Adapter->stats.xoffrxc); - printf("em%d: XOFF Xmtd = %lld\n", unit, Adapter->stats.xofftxc); - - printf("em%d: Good Packets Rcvd = %lld\n", unit, Adapter->stats.gprc); - printf("em%d: Good Packets Xmtd = %lld\n", unit, Adapter->stats.gptc); + + printf("em%d: Tx Descriptors not Avail = %ld\n", unit, adapter->no_tx_desc_avail); + printf("em%d: Tx Buffer not avail1 = %ld\n", unit, adapter->no_tx_buffer_avail1); + printf("em%d: Tx Buffer not avail2 = %ld\n", unit, adapter->no_tx_buffer_avail2); + printf("em%d: Std Mbuf Failed = %ld\n",unit, adapter->mbuf_alloc_failed); + printf("em%d: Std Cluster Failed = %ld\n",unit, adapter->mbuf_cluster_failed); + printf("em%d: Xmit Pullup = %ld\n",unit, adapter->xmit_pullup); + + printf("em%d: Symbol errors = %lld\n", unit, adapter->stats.symerrs); + printf("em%d: Sequence errors = %lld\n", unit, adapter->stats.sec); + printf("em%d: Defer count = %lld\n", unit, adapter->stats.dc); + + printf("em%d: Missed Packets = %lld\n", unit, adapter->stats.mpc); + printf("em%d: Receive No Buffers = %lld\n", unit, adapter->stats.rnbc); + printf("em%d: Receive length errors = %lld\n", unit, adapter->stats.rlec); + printf("em%d: Receive errors = %lld\n", unit, adapter->stats.rxerrc); + printf("em%d: Crc errors = %lld\n", unit, adapter->stats.crcerrs); + printf("em%d: Alignment errors = %lld\n", unit, adapter->stats.algnerrc); + printf("em%d: Carrier extension errors = %lld\n", unit, adapter->stats.cexterr); + printf("em%d: Driver dropped packets = %ld\n", unit, adapter->dropped_pkts); + + printf("em%d: XON Rcvd = %lld\n", unit, adapter->stats.xonrxc); + printf("em%d: XON Xmtd = %lld\n", unit, adapter->stats.xontxc); + printf("em%d: XOFF Rcvd = %lld\n", unit, adapter->stats.xoffrxc); + printf("em%d: XOFF Xmtd = %lld\n", unit, adapter->stats.xofftxc); + + printf("em%d: Good Packets Rcvd = %lld\n", unit, adapter->stats.gprc); + printf("em%d: Good Packets Xmtd = %lld\n", unit, adapter->stats.gptc); } @@ -2166,21 +2161,21 @@ em_print_hw_stats(struct adapter * Adapter) * **********************************************************************/ static void -em_clean_transmit_interrupts(struct adapter * Adapter) +em_clean_transmit_interrupts(struct adapter * adapter) { struct em_tx_buffer *tx_buffer; - struct em_tx_desc *TransmitDescriptor; + struct em_tx_desc *tx_desc; int s; struct ifnet *ifp; s = splimp(); #ifdef DBG_STATS - Adapter->CleanTxInterrupts++; + adapter->clean_tx_interrupts++; #endif - for (tx_buffer = STAILQ_FIRST(&Adapter->UsedSwTxPacketList); + for (tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list); tx_buffer; - tx_buffer = STAILQ_FIRST(&Adapter->UsedSwTxPacketList)) { + tx_buffer = STAILQ_FIRST(&adapter->used_tx_buffer_list)) { /* * Get hold of the next descriptor that the em will report status @@ -2190,41 +2185,41 @@ em_clean_transmit_interrupts(struct adapter * Adapter) * last one then it is done with all of them. */ - TransmitDescriptor = Adapter->OldestUsedTxDescriptor + - (tx_buffer->NumTxDescriptorsUsed - 1); + tx_desc = adapter->oldest_used_tx_desc + + (tx_buffer->num_tx_desc_used - 1); /* Check for wrap case */ - if (TransmitDescriptor > Adapter->LastTxDescriptor) - TransmitDescriptor -= Adapter->NumTxDescriptors; + if (tx_desc > adapter->last_tx_desc) + tx_desc -= adapter->num_tx_desc; /* * If the descriptor done bit is set free tx_buffer and associated * resources */ - if (TransmitDescriptor->upper.fields.status & + if (tx_desc->upper.fields.status & E1000_TXD_STAT_DD) { - STAILQ_REMOVE_HEAD(&Adapter->UsedSwTxPacketList, em_tx_entry); + STAILQ_REMOVE_HEAD(&adapter->used_tx_buffer_list, em_tx_entry); - if ((TransmitDescriptor == Adapter->LastTxDescriptor)) - Adapter->OldestUsedTxDescriptor = - Adapter->FirstTxDescriptor; + if ((tx_desc == adapter->last_tx_desc)) + adapter->oldest_used_tx_desc = + adapter->first_tx_desc; else - Adapter->OldestUsedTxDescriptor = (TransmitDescriptor + 1); + adapter->oldest_used_tx_desc = (tx_desc + 1); /* Make available the descriptors that were previously used */ - Adapter->NumTxDescriptorsAvail += - tx_buffer->NumTxDescriptorsUsed; + adapter->num_tx_desc_avail += + tx_buffer->num_tx_desc_used; - tx_buffer->NumTxDescriptorsUsed = 0; + tx_buffer->num_tx_desc_used = 0; - if (tx_buffer->Packet) { - m_freem(tx_buffer->Packet); - tx_buffer->Packet = NULL; + if (tx_buffer->m_head) { + m_freem(tx_buffer->m_head); + tx_buffer->m_head = NULL; } /* Return this "Software packet" back to the "free" list */ - STAILQ_INSERT_TAIL(&Adapter->FreeSwTxPacketList, tx_buffer, em_tx_entry); + STAILQ_INSERT_TAIL(&adapter->free_tx_buffer_list, tx_buffer, em_tx_entry); } else { /* * Found a tx_buffer that the em is not done with then there is @@ -2234,10 +2229,10 @@ em_clean_transmit_interrupts(struct adapter * Adapter) } } /* end for each tx_buffer */ - ifp = &Adapter->interface_data.ac_if; + ifp = &adapter->interface_data.ac_if; /* Tell the stack that it is OK to send packets */ - if (Adapter->NumTxDescriptorsAvail > TX_CLEANUP_THRESHOLD) { + if (adapter->num_tx_desc_avail > TX_CLEANUP_THRESHOLD) { ifp->if_timer = 0; ifp->if_flags &= ~IFF_OACTIVE; } diff --git a/sys/dev/em/if_em.h b/sys/dev/em/if_em.h index f840183..f3859bd 100644 --- a/sys/dev/em/if_em.h +++ b/sys/dev/em/if_em.h @@ -1,6 +1,6 @@ /************************************************************************** -Copyright (c) 2001 Intel Corporation +Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -70,7 +70,6 @@ SUCH DAMAGE. #include #include #include - #include "opt_bdg.h" #include @@ -109,9 +108,6 @@ SUCH DAMAGE. #define DEBUG_INIT 0 #define DEBUG_IOCTL 0 #define DEBUG_HW 0 -#define DEBUG_TXRX 0 -#define DEBUG_RXCSUM 0 -#define DEBUG_TXCSUM 0 #define INIT_DEBUGOUT(S) if (DEBUG_INIT) printf(S "\n") #define INIT_DEBUGOUT1(S, A) if (DEBUG_INIT) printf(S "\n", A) @@ -122,24 +118,7 @@ SUCH DAMAGE. #define HW_DEBUGOUT(S) if (DEBUG_HW) printf(S "\n") #define HW_DEBUGOUT1(S, A) if (DEBUG_HW) printf(S "\n", A) #define HW_DEBUGOUT2(S, A, B) if (DEBUG_HW) printf(S "\n", A, B) -#define TXRX_DEBUGOUT(S) if (DEBUG_TXRX) printf(S "\n") -#define TXRX_DEBUGOUT1(S, A) if (DEBUG_TXRX) printf(S "\n", A) -#define TXRX_DEBUGOUT2(S, A, B) if (DEBUG_TXRX) printf(S "\n", A, B) -#define RXCSUM_DEBUGOUT(S) if (DEBUG_RXCSUM) printf(S "\n") -#define RXCSUM_DEBUGOUT1(S, A) if (DEBUG_RXCSUM) printf(S "\n", A) -#define RXCSUM_DEBUGOUT2(S, A, B) if (DEBUG_RXCSUM) printf(S "\n", A, B) -#define TXCSUM_DEBUGOUT(S) if (DEBUG_TXCSUM) printf(S "\n") -#define TXCSUM_DEBUGOUT1(S, A) if (DEBUG_TXCSUM) printf(S "\n", A) -#define TXCSUM_DEBUGOUT2(S, A, B) if (DEBUG_TXCSUM) printf(S "\n", A, B) - -/* Device ID defines */ -#define PCI_DEVICE_ID_82542 0x1000 -#define PCI_DEVICE_ID_82543GC_FIBER 0x1001 -#define PCI_DEVICE_ID_82543GC_COPPER 0x1004 -#define PCI_DEVICE_ID_82544EI_FIBER 0x1009 -#define PCI_DEVICE_ID_82544EI_COPPER 0x1008 -#define PCI_DEVICE_ID_82544GC_STRG 0x100C -#define PCI_DEVICE_ID_82544GC_COPPER 0x100D + /* Supported RX Buffer Sizes */ #define EM_RXBUFFER_2048 2048 @@ -147,6 +126,10 @@ SUCH DAMAGE. #define EM_RXBUFFER_8192 8192 #define EM_RXBUFFER_16384 16384 +#ifdef __alpha__ +#undef vtophys +#define vtophys(va) alpha_XXX_dmamap((vm_offset_t)(va)) +#endif /* __alpha__ */ /* ****************************************************************************** * vendor_info_array @@ -167,8 +150,8 @@ typedef struct _em_vendor_info_t struct em_tx_buffer { STAILQ_ENTRY(em_tx_buffer) em_tx_entry; - struct mbuf *Packet; - u_int32_t NumTxDescriptorsUsed; + struct mbuf *m_head; + u_int32_t num_tx_desc_used; }; @@ -178,9 +161,8 @@ struct em_tx_buffer { * ******************************************************************************/ struct em_rx_buffer { STAILQ_ENTRY(em_rx_buffer) em_rx_entry; - struct mbuf *Packet; - u_int32_t LowPhysicalAddress; - u_int32_t HighPhysicalAddress; + struct mbuf *m_head; + u_int64_t buffer_addr; }; typedef enum _XSUM_CONTEXT_T { @@ -206,53 +188,39 @@ struct adapter { struct callout_handle timer_handle; u_int8_t unit; - /* PCI Info */ - u_int16_t VendorId; - u_int16_t DeviceId; - u_int8_t RevId; - u_int16_t SubVendorId; - u_int16_t SubSystemId; - - /* Info about the board itself */ - uint8_t PermNetAddress[ETH_LENGTH_OF_ADDRESS]; - u_int32_t PartNumber; - - u_int8_t MulticastAddressList[MAX_NUM_MULTICAST_ADDRESSES][ETH_LENGTH_OF_ADDRESS]; - u_int8_t LinkStatusChanged; - u_int8_t LinkIsActive; - u_int16_t LineSpeed; - u_int16_t FullDuplex; - u_int32_t TxIntDelay; - u_int32_t RxIntDelay; + u_int32_t part_num; + u_int8_t link_active; + u_int16_t link_speed; + u_int16_t link_duplex; + u_int32_t tx_int_delay; + u_int32_t rx_int_delay; - u_int8_t RxChecksum; - XSUM_CONTEXT_T ActiveChecksumContext; + u_int8_t rx_checksum; + XSUM_CONTEXT_T active_checksum_context; /* Transmit definitions */ - struct em_tx_desc *FirstTxDescriptor; - struct em_tx_desc *LastTxDescriptor; - struct em_tx_desc *NextAvailTxDescriptor; - struct em_tx_desc *OldestUsedTxDescriptor; - struct em_tx_desc *TxDescBase; - volatile u_int16_t NumTxDescriptorsAvail; - u_int16_t NumTxDescriptors; - u_int32_t TxdCmd; + struct em_tx_desc *first_tx_desc; + struct em_tx_desc *last_tx_desc; + struct em_tx_desc *next_avail_tx_desc; + struct em_tx_desc *oldest_used_tx_desc; + struct em_tx_desc *tx_desc_base; + volatile u_int16_t num_tx_desc_avail; + u_int16_t num_tx_desc; + u_int32_t txd_cmd; struct em_tx_buffer *tx_buffer_area; - STAILQ_HEAD(__em_tx_buffer_free, em_tx_buffer) FreeSwTxPacketList; - STAILQ_HEAD(__em_tx_buffer_used, em_tx_buffer) UsedSwTxPacketList; + STAILQ_HEAD(__em_tx_buffer_free, em_tx_buffer) free_tx_buffer_list; + STAILQ_HEAD(__em_tx_buffer_used, em_tx_buffer) used_tx_buffer_list; /* Receive definitions */ - struct em_rx_desc *FirstRxDescriptor; - struct em_rx_desc *LastRxDescriptor; - struct em_rx_desc *NextRxDescriptorToCheck; - struct em_rx_desc *RxDescBase; - u_int16_t NumRxDescriptors; - u_int16_t NumRxDescriptorsEmpty; - u_int16_t NextRxDescriptorToFill; - u_int32_t RxBufferLen; + struct em_rx_desc *first_rx_desc; + struct em_rx_desc *last_rx_desc; + struct em_rx_desc *next_rx_desc_to_check; + struct em_rx_desc *rx_desc_base; + u_int16_t num_rx_desc; + u_int32_t rx_buffer_len; struct em_rx_buffer *rx_buffer_area; - STAILQ_HEAD(__em_rx_buffer, em_rx_buffer) RxSwPacketList; + STAILQ_HEAD(__em_rx_buffer, em_rx_buffer) rx_buffer_list; /* Jumbo frame */ struct mbuf *fmp; @@ -260,18 +228,17 @@ struct adapter { /* Misc stats maintained by the driver */ - unsigned long DroppedPackets; - unsigned long NoJumboBufAvail; - unsigned long JumboMbufFailed; - unsigned long JumboClusterFailed; - unsigned long StdMbufFailed; - unsigned long StdClusterFailed; -#ifdef DBG_STATS - unsigned long NoTxDescAvail; - unsigned long NoPacketsAvail; - unsigned long CleanTxInterrupts; - unsigned long NoTxBufferAvail1; - unsigned long NoTxBufferAvail2; + unsigned long dropped_pkts; + unsigned long mbuf_alloc_failed; + unsigned long mbuf_cluster_failed; + unsigned long xmit_pullup; + unsigned long no_tx_desc_avail; + unsigned long no_tx_buffer_avail1; + unsigned long no_tx_buffer_avail2; +#ifdef DBG_STATS + unsigned long no_pkts_avail; + unsigned long clean_tx_interrupts; + #endif struct em_shared_stats stats; diff --git a/sys/dev/em/if_em_fxhw.c b/sys/dev/em/if_em_fxhw.c index 04b6a72..71b7942 100644 --- a/sys/dev/em/if_em_fxhw.c +++ b/sys/dev/em/if_em_fxhw.c @@ -1,6 +1,6 @@ /******************************************************************************* - Copyright (c) 2001 Intel Corporation + Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -52,7 +52,7 @@ em_raise_clock(struct em_shared_adapter *shared, uint32_t *eecd_reg) { /* Raise the clock input to the EEPROM (by setting the SK bit), and then - * wait 50 microseconds. + * wait 50 microseconds. */ *eecd_reg = *eecd_reg | E1000_EECD_SK; E1000_WRITE_REG(shared, EECD, *eecd_reg); @@ -184,11 +184,11 @@ em_setup_eeprom(struct em_shared_adapter *shared) eecd_reg = E1000_READ_REG(shared, EECD); - /* Clear SK and DI */ + /* Clear SK and DI */ eecd_reg &= ~(E1000_EECD_SK | E1000_EECD_DI); E1000_WRITE_REG(shared, EECD, eecd_reg); - /* Set CS */ + /* Set CS */ eecd_reg |= E1000_EECD_CS; E1000_WRITE_REG(shared, EECD, eecd_reg); return; @@ -206,22 +206,22 @@ em_standby_eeprom(struct em_shared_adapter *shared) eecd_reg = E1000_READ_REG(shared, EECD); - /* Deselct EEPROM */ + /* Deselct EEPROM */ eecd_reg &= ~(E1000_EECD_CS | E1000_EECD_SK); E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); - /* Clock high */ + /* Clock high */ eecd_reg |= E1000_EECD_SK; E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); - /* Select EEPROM */ + /* Select EEPROM */ eecd_reg |= E1000_EECD_CS; E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); - /* Clock low */ + /* Clock low */ eecd_reg &= ~E1000_EECD_SK; E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); @@ -240,12 +240,12 @@ em_clock_eeprom(struct em_shared_adapter *shared) eecd_reg = E1000_READ_REG(shared, EECD); - /* Rising edge of clock */ + /* Rising edge of clock */ eecd_reg |= E1000_EECD_SK; E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); - /* Falling edge of clock */ + /* Falling edge of clock */ eecd_reg &= ~E1000_EECD_SK; E1000_WRITE_REG(shared, EECD, eecd_reg); usec_delay(50); @@ -347,33 +347,23 @@ em_force_mac_fc(struct em_shared_adapter *shared) */ switch (shared->fc) { - case em_fc_none: /* 0 */ - + case em_fc_none: ctrl_reg &= (~(E1000_CTRL_TFCE | E1000_CTRL_RFCE)); break; - - case em_fc_rx_pause: /* 1 */ - + case em_fc_rx_pause: ctrl_reg &= (~E1000_CTRL_TFCE); ctrl_reg |= E1000_CTRL_RFCE; break; - - case em_fc_tx_pause: /* 2 */ - + case em_fc_tx_pause: ctrl_reg &= (~E1000_CTRL_RFCE); ctrl_reg |= E1000_CTRL_TFCE; break; - - case em_fc_full: /* 3 */ - + case em_fc_full: ctrl_reg |= (E1000_CTRL_TFCE | E1000_CTRL_RFCE); break; - default: - DEBUGOUT("Flow control param set incorrectly\n"); ASSERT(0); - break; } @@ -397,6 +387,7 @@ em_adapter_stop(struct em_shared_adapter *shared) #if DBG uint32_t ctrl_reg; #endif + uint32_t ctrl_ext_reg; uint32_t icr_reg; uint16_t pci_cmd_word; @@ -435,7 +426,7 @@ em_adapter_stop(struct em_shared_adapter *shared) * the global reset. */ E1000_WRITE_REG(shared, RCTL, 0); - E1000_WRITE_REG(shared, TCTL, 0); + E1000_WRITE_REG(shared, TCTL, E1000_TCTL_PSP); /* The tbi_compatibility_on Flag must be cleared when Rctl is cleared. */ shared->tbi_compatibility_on = FALSE; @@ -460,6 +451,12 @@ em_adapter_stop(struct em_shared_adapter *shared) ASSERT(!(ctrl_reg & E1000_CTRL_RST)); #endif + /* Force a reload from the EEPROM */ + ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT); + ctrl_ext_reg |= E1000_CTRL_EXT_EE_RST; + E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg); + msec_delay(2); + /* Clear interrupt mask to stop board from generating interrupts */ DEBUGOUT("Masking off all interrupts\n"); E1000_WRITE_REG(shared, IMC, 0xffffffff); @@ -567,12 +564,11 @@ em_init_hw(struct em_shared_adapter *shared) * is no link. */ em_clear_hw_cntrs(shared); - - shared->large_eeprom = FALSE; + shared->low_profile = FALSE; if(shared->mac_type == em_82544) { - i = em_read_eeprom(shared, E1000_EEPROM_LED_LOGIC); - if(i & E1000_EEPROM_SWDPIN0) + if(em_read_eeprom(shared, E1000_EEPROM_LED_LOGIC) & + E1000_EEPROM_SWDPIN0) shared->low_profile = TRUE; } @@ -920,10 +916,10 @@ em_setup_fc_and_link(struct em_shared_adapter *shared) * signal detection. So this should be done before em_setup_pcs_link() * or em_phy_setup() is called. */ - if(shared->mac_type >= em_82543) { + if(shared->mac_type == em_82543) { ctrl_ext_reg = ((eecd_reg & EEPROM_WORD0F_SWPDIO_EXT) << SWDPIO__EXT_SHIFT); - E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg); + E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg); } /* Call the necessary subroutine to configure the link. */ @@ -954,9 +950,9 @@ em_setup_fc_and_link(struct em_shared_adapter *shared) E1000_WRITE_REG(shared, FCRTL, 0); E1000_WRITE_REG(shared, FCRTH, 0); } else { - /* We need to set up the Receive Threshold high and low water - * marks as well as (optionally) enabling the transmission of XON frames. - */ + /* We need to set up the Receive Threshold high and low water marks + * as well as (optionally) enabling the transmission of XON frames. + */ if(shared->fc_send_xon) { E1000_WRITE_REG(shared, FCRTL, (shared->fc_low_water | E1000_FCRTL_XONE)); @@ -1351,25 +1347,26 @@ em_check_for_link(struct em_shared_adapter *shared) case M88E1000_12_PHY_ID: case M88E1000_14_PHY_ID: case M88E1000_I_PHY_ID: - /* We have a M88E1000 PHY and Auto-Neg is enabled. If we - * have Si on board that is 82544 or newer, Auto - * Speed Detection takes care of MAC speed/duplex - * configuration. So we only need to configure Collision - * Distance in the MAC. Otherwise, we need to force - * speed/duplex on the MAC to the current PHY speed/duplex - * settings. - */ + case M88E1011_I_PHY_ID: + /* We have a M88E1000 PHY and Auto-Neg is enabled. If we + * have Si on board that is 82544 or newer, Auto + * Speed Detection takes care of MAC speed/duplex + * configuration. So we only need to configure Collision + * Distance in the MAC. Otherwise, we need to force + * speed/duplex on the MAC to the current PHY speed/duplex + * settings. + */ if(shared->mac_type >= em_82544) { DEBUGOUT("CFL - Auto-Neg complete."); DEBUGOUT("Configuring Collision Distance."); em_config_collision_dist(shared); } else { - /* Read the Phy Specific Status register to get the - * resolved speed/duplex settings. Then call - * em_config_mac_to_phy which will retrieve - * PHY register information and configure the MAC to - * equal the negotiated speed/duplex. - */ + /* Read the Phy Specific Status register to get the + * resolved speed/duplex settings. Then call + * em_config_mac_to_phy which will retrieve + * PHY register information and configure the MAC to + * equal the negotiated speed/duplex. + */ phy_data = em_read_phy_reg(shared, M88E1000_PHY_SPEC_STATUS); @@ -1378,18 +1375,18 @@ em_check_for_link(struct em_shared_adapter *shared) em_config_mac_to_phy(shared, phy_data); } - /* Configure Flow Control now that Auto-Neg has completed. - * We need to first restore the users desired Flow - * Control setting since we may have had to re-autoneg - * with a different link partner. - */ + /* Configure Flow Control now that Auto-Neg has completed. + * We need to first restore the users desired Flow + * Control setting since we may have had to re-autoneg + * with a different link partner. + */ em_config_fc_after_link_up(shared); break; default: DEBUGOUT("CFL - Invalid PHY detected.\r\n"); - } /* end switch statement */ + } /* end switch statement */ /* At this point we know that we are on copper, link is up, * and we are auto-neg'd. These are pre-conditions for checking @@ -1484,7 +1481,7 @@ em_check_for_link(struct em_shared_adapter *shared) } return; -} /* CheckForLink */ +} /****************************************************************************** * Clears all hardware statistics counters. @@ -1621,7 +1618,8 @@ em_get_speed_and_duplex(struct em_shared_adapter *shared, #if DBG if(shared->phy_id == M88E1000_12_PHY_ID || shared->phy_id == M88E1000_14_PHY_ID || - shared->phy_id == M88E1000_I_PHY_ID) { + shared->phy_id == M88E1000_I_PHY_ID || + shared->phy_id == M88E1011_I_PHY_ID) { /* read the phy specific status register */ phy_data = em_read_phy_reg(shared, M88E1000_PHY_SPEC_STATUS); DEBUGOUT1("M88E1000 Phy Specific Status Reg contents = %x\n", phy_data); @@ -1629,7 +1627,6 @@ em_get_speed_and_duplex(struct em_shared_adapter *shared, DEBUGOUT1("Phy MII Status Reg contents = %x\n", phy_data); DEBUGOUT1("Device Status Reg contents = %x\n", E1000_READ_REG(shared, STATUS)); - /* DisplayMiiContents(Adapter, (uint8_t)Adapter->PhyAddress); */ } #endif return; @@ -1645,9 +1642,26 @@ uint16_t em_read_eeprom(struct em_shared_adapter *shared, uint16_t offset) { + boolean_t large_eeprom = FALSE; uint16_t data; + uint32_t eecd_reg; + uint32_t tmp = 0; + if((shared->mac_type > em_82544) && + (E1000_READ_REG(shared, EECD) & E1000_EECD_SIZE)) large_eeprom = TRUE; + /* Request EEPROM Access */ + if(shared->mac_type > em_82544) { + E1000_WRITE_REG(shared, EECD, (uint32_t) E1000_EECD_REQ); + eecd_reg = E1000_READ_REG(shared, EECD); + while((!(eecd_reg & E1000_EECD_GNT)) && (tmp < 100)) { + tmp++; + usec_delay(5); + eecd_reg = E1000_READ_REG(shared, EECD); + } + if(!(eecd_reg & E1000_EECD_GNT)) return(FALSE); + } + /* Prepare the EEPROM for reading */ em_setup_eeprom(shared); @@ -1656,17 +1670,21 @@ em_read_eeprom(struct em_shared_adapter *shared, /* If we have a 256 word EEPROM, there are 8 address bits * if we have a 64 word EEPROM, there are 6 address bits */ - if(shared->large_eeprom) + if(large_eeprom) em_shift_out_bits(shared, offset, 8); else em_shift_out_bits(shared, offset, 6); - /* Read the data */ + /* Read the data */ data = em_shift_in_bits(shared); - /* End this read operation */ + /* End this read operation */ em_standby_eeprom(shared); + /* Stop requestiong EEPROM access */ + if(shared->mac_type > em_82544) + E1000_WRITE_REG(shared, EECD, (uint32_t) 0); + return (data); } @@ -1732,47 +1750,75 @@ em_write_eeprom(struct em_shared_adapter *shared, uint16_t offset, uint16_t data) { + boolean_t large_eeprom = FALSE; + uint32_t eecd_reg; + uint32_t tmp = 0; + + if((shared->mac_type > em_82544) && + (E1000_READ_REG(shared, EECD) & E1000_EECD_SIZE)) large_eeprom = TRUE; + + /* Request EEPROM Access */ + if(shared->mac_type > em_82544) { + E1000_WRITE_REG(shared, EECD, (uint32_t) E1000_EECD_REQ); + eecd_reg = E1000_READ_REG(shared, EECD); + while((!(eecd_reg & E1000_EECD_GNT)) && (tmp < 100)) { + tmp++; + usec_delay(5); + eecd_reg = E1000_READ_REG(shared, EECD); + } + if(!(eecd_reg & E1000_EECD_GNT)) return(FALSE); + } - /* Prepare the EEPROM for writing */ + /* Prepare the EEPROM for writing */ em_setup_eeprom(shared); - /* Send the 9-bit EWEN (write enable) command to the EEPROM (5-bit opcode - * plus 4-bit dummy). This puts the EEPROM into write/erase mode. + /* Send the 9-bit (or 11-bit on large EEPROM) EWEN (write enable) + * command to the EEPROM (5-bit opcode plus 4/6-bit dummy). + * This puts the EEPROM into write/erase mode. */ em_shift_out_bits(shared, EEPROM_EWEN_OPCODE, 5); - em_shift_out_bits(shared, 0, 4); + if(large_eeprom) + em_shift_out_bits(shared, 0, 6); + else + em_shift_out_bits(shared, 0, 4); - /* Prepare the EEPROM */ + /* Prepare the EEPROM */ em_standby_eeprom(shared); - /* Send the Write command (3-bit opcode + addr) */ + /* Send the Write command (3-bit opcode + addr) */ em_shift_out_bits(shared, EEPROM_WRITE_OPCODE, 3); /* If we have a 256 word EEPROM, there are 8 address bits * if we have a 64 word EEPROM, there are 6 address bits */ - if(shared->large_eeprom) + if(large_eeprom) em_shift_out_bits(shared, offset, 8); else em_shift_out_bits(shared, offset, 6); - /* Send the data */ + /* Send the data */ em_shift_out_bits(shared, data, 16); - em_wait_eeprom_command(shared); - /* Recover from write */ + /* Recover from write */ em_standby_eeprom(shared); - /* Send the 9-bit EWDS (write disable) command to the EEPROM (5-bit - * opcode plus 4-bit dummy). This takes the EEPROM out of write/erase - * mode. + /* Send the 9-bit (or 11-bit on large EEPROM) EWDS (write disable) + * command to the EEPROM (5-bit opcode plus 4/6-bit dummy). + * This takes the EEPROM out of write/erase mode. */ em_shift_out_bits(shared, EEPROM_EWDS_OPCODE, 5); - em_shift_out_bits(shared, 0, 4); + if(large_eeprom) + em_shift_out_bits(shared, 0, 6); + else + em_shift_out_bits(shared, 0, 4); - /* Done with writing */ + /* Done with writing */ em_cleanup_eeprom(shared); + /* Stop requestiong EEPROM access */ + if(shared->mac_type > em_82544) + E1000_WRITE_REG(shared, EECD, (uint32_t) 0); + return (TRUE); } diff --git a/sys/dev/em/if_em_fxhw.h b/sys/dev/em/if_em_fxhw.h index e31f3a6..15fb162 100644 --- a/sys/dev/em/if_em_fxhw.h +++ b/sys/dev/em/if_em_fxhw.h @@ -1,6 +1,6 @@ /******************************************************************************* - Copyright (c) 2001 Intel Corporation + Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -54,6 +54,7 @@ typedef enum { em_82542_rev2_1, em_82543, em_82544, + em_82540, em_num_macs } em_mac_type; @@ -113,56 +114,36 @@ boolean_t em_init_hw(struct em_shared_adapter *shared); void em_init_rx_addrs(struct em_shared_adapter *shared); /* Filters (multicast, vlan, receive) */ -void em_mc_addr_list_update(struct em_shared_adapter *shared, - uint8_t * mc_addr_list, - uint32_t mc_addr_count, - uint32_t pad); -uint32_t em_hash_mc_addr(struct em_shared_adapter *shared, - uint8_t * mc_addr); -void em_mta_set(struct em_shared_adapter *shared, - uint32_t hash_value); -void em_rar_set(struct em_shared_adapter *shared, - uint8_t * mc_addr, - uint32_t rar_index); -void em_write_vfta(struct em_shared_adapter *shared, - uint32_t offset, - uint32_t value); +void em_mc_addr_list_update(struct em_shared_adapter *shared, uint8_t * mc_addr_list, uint32_t mc_addr_count, uint32_t pad); +uint32_t em_hash_mc_addr(struct em_shared_adapter *shared, uint8_t * mc_addr); +void em_mta_set(struct em_shared_adapter *shared, uint32_t hash_value); +void em_rar_set(struct em_shared_adapter *shared, uint8_t * mc_addr, uint32_t rar_index); +void em_write_vfta(struct em_shared_adapter *shared, uint32_t offset, uint32_t value); void em_clear_vfta(struct em_shared_adapter *shared); /* Link layer setup functions */ boolean_t em_setup_fc_and_link(struct em_shared_adapter *shared); -boolean_t em_setup_pcs_link(struct em_shared_adapter *shared, - uint32_t dev_ctrl_reg); +boolean_t em_setup_pcs_link(struct em_shared_adapter *shared, uint32_t dev_ctrl_reg); void em_config_fc_after_link_up(struct em_shared_adapter *shared); void em_check_for_link(struct em_shared_adapter *shared); -void em_get_speed_and_duplex(struct em_shared_adapter *shared, - uint16_t * speed, - uint16_t * duplex); +void em_get_speed_and_duplex(struct em_shared_adapter *shared, uint16_t * speed, uint16_t * duplex); /* EEPROM Functions */ -uint16_t em_read_eeprom(struct em_shared_adapter *shared, - uint16_t reg); +uint16_t em_read_eeprom(struct em_shared_adapter *shared, uint16_t reg); boolean_t em_validate_eeprom_checksum(struct em_shared_adapter *shared); void em_update_eeprom_checksum(struct em_shared_adapter *shared); -boolean_t em_write_eeprom(struct em_shared_adapter *shared, - uint16_t reg, - uint16_t data); +boolean_t em_write_eeprom(struct em_shared_adapter *shared, uint16_t reg, uint16_t data); /* Everything else */ void em_clear_hw_cntrs(struct em_shared_adapter *shared); -boolean_t em_read_part_num(struct em_shared_adapter *shared, - uint32_t * part_num); +boolean_t em_read_part_num(struct em_shared_adapter *shared, uint32_t * part_num); void em_led_on(struct em_shared_adapter *shared); void em_led_off(struct em_shared_adapter *shared); void em_get_bus_info(struct em_shared_adapter *shared); -uint32_t em_tbi_adjust_stats(struct em_shared_adapter *shared, - struct em_shared_stats *stats, - uint32_t frame_len, - uint8_t * mac_addr); -void em_write_pci_cfg(struct em_shared_adapter *shared, - uint32_t reg, - uint16_t * value); +uint32_t em_tbi_adjust_stats(struct em_shared_adapter *shared, struct em_shared_stats *stats, uint32_t frame_len, uint8_t * mac_addr); +void em_write_pci_cfg(struct em_shared_adapter *shared, uint32_t reg, uint16_t * value); +/* PCI Device IDs */ #define E1000_DEV_ID_82542 0x1000 #define E1000_DEV_ID_82543GC_FIBER 0x1001 #define E1000_DEV_ID_82543GC_COPPER 0x1004 @@ -170,6 +151,8 @@ void em_write_pci_cfg(struct em_shared_adapter *shared, #define E1000_DEV_ID_82544EI_FIBER 0x1009 #define E1000_DEV_ID_82544GC_COPPER 0x100C #define E1000_DEV_ID_82544GC_LOM 0x100D +#define E1000_DEV_ID_82540EM 0x100E +#define NUM_DEV_IDS 8 #define NODE_ADDRESS_SIZE 6 #define ETH_LENGTH_OF_ADDRESS 6 @@ -446,13 +429,15 @@ struct em_ffvt_entry { #define E1000_CTRL 0x00000 /* Device Control - RW */ #define E1000_STATUS 0x00008 /* Device Status - RO */ #define E1000_EECD 0x00010 /* EEPROM/Flash Control - RW */ -#define E1000_CTRLEXT 0x00018 /* Extended Device Control - RW */ +#define E1000_EERD 0x00014 /* EEPROM Read - RW */ +#define E1000_CTRL_EXT 0x00018 /* Extended Device Control - RW */ #define E1000_MDIC 0x00020 /* MDI Control - RW */ #define E1000_FCAL 0x00028 /* Flow Control Address Low - RW */ #define E1000_FCAH 0x0002C /* Flow Control Address High -RW */ #define E1000_FCT 0x00030 /* Flow Control Type - RW */ #define E1000_VET 0x00038 /* VLAN Ether Type - RW */ #define E1000_ICR 0x000C0 /* Interrupt Cause Read - R/clr */ +#define E1000_ITR 0x000C4 /* Interrupt Throttling Rate - RW */ #define E1000_ICS 0x000C8 /* Interrupt Cause Set - WO */ #define E1000_IMS 0x000D0 /* Interrupt Mask Set - RW */ #define E1000_IMC 0x000D8 /* Interrupt Mask Clear - WO */ @@ -463,6 +448,7 @@ struct em_ffvt_entry { #define E1000_TCTL 0x00400 /* TX Control - RW */ #define E1000_TIPG 0x00410 /* TX Inter-packet gap -RW */ #define E1000_TBT 0x00448 /* TX Burst Timer - RW */ +#define E1000_LEDCTL 0x00E00 /* LED Control - RW */ #define E1000_PBA 0x01000 /* Packet Buffer Allocation - RW */ #define E1000_FCRTL 0x02160 /* Flow Control Receive Threshold Low - RW */ #define E1000_FCRTH 0x02168 /* Flow Control Receive Threshold High - RW */ @@ -473,6 +459,8 @@ struct em_ffvt_entry { #define E1000_RDT 0x02818 /* RX Descriptor Tail - RW */ #define E1000_RDTR 0x02820 /* RX Delay Timer - RW */ #define E1000_RXDCTL 0x02828 /* RX Descriptor Control - RW */ +#define E1000_RADV 0x0282C /* RX Interrupt Absolute Delay Timer - RW */ +#define E1000_RSRPD 0x02C00 /* RX Small Packet Detect - RW */ #define E1000_TXDMAC 0x03000 /* TX DMA Control - RW */ #define E1000_TDBAL 0x03800 /* TX Descriptor Base Address Low - RW */ #define E1000_TDBAH 0x03804 /* TX Descriptor Base Address High - RW */ @@ -481,6 +469,7 @@ struct em_ffvt_entry { #define E1000_TDT 0x03818 /* TX Descripotr Tail - RW */ #define E1000_TIDV 0x03820 /* TX Interrupt Delay Value - RW */ #define E1000_TXDCTL 0x03828 /* TX Descriptor Control - RW */ +#define E1000_TADV 0x0382C /* TX Interrupt Absolute Delay Val - RW */ #define E1000_TSPMT 0x03830 /* TCP Segmentation PAD & Min Threshold - RW */ #define E1000_CRCERRS 0x04000 /* CRC Error Count - R/clr */ #define E1000_ALGNERRC 0x04004 /* Alignment Error Count - R/clr */ @@ -521,6 +510,9 @@ struct em_ffvt_entry { #define E1000_RFC 0x040A8 /* RX Fragment Count - R/clr */ #define E1000_ROC 0x040AC /* RX Oversize Count - R/clr */ #define E1000_RJC 0x040B0 /* RX Jabber Count - R/clr */ +#define E1000_MGTPRC 0x040B4 /* Management Packets RX Count - R/clr */ +#define E1000_MGTPDC 0x040B8 /* Management Packets Dropped Count - R/clr */ +#define E1000_MGTPTC 0x040BC /* Management Packets TX Count - R/clr */ #define E1000_TORL 0x040C0 /* Total Octets RX Low - R/clr */ #define E1000_TORH 0x040C4 /* Total Octets RX High - R/clr */ #define E1000_TOTL 0x040C8 /* Total Octets TX Low - R/clr */ @@ -544,8 +536,10 @@ struct em_ffvt_entry { #define E1000_WUC 0x05800 /* Wakeup Control - RW */ #define E1000_WUFC 0x05808 /* Wakeup Filter Control - RW */ #define E1000_WUS 0x05810 /* Wakeup Status - RO */ +#define E1000_MANC 0x05820 /* Management Control - RW */ #define E1000_IPAV 0x05838 /* IP Address Valid - RW */ #define E1000_IP4AT 0x05840 /* IPv4 Address Table - RW Array */ +#define E1000_IP6AT 0x05880 /* IPv6 Address Table - RW Array */ #define E1000_WUPL 0x05900 /* Wakeup Packet Length - RW */ #define E1000_WUPM 0x05A00 /* Wakeup Packet Memory - RO A */ #define E1000_FFLT 0x05F00 /* Flexible Filter Length Table - RW Array */ @@ -561,7 +555,8 @@ struct em_ffvt_entry { #define E1000_82542_CTRL E1000_CTRL #define E1000_82542_STATUS E1000_STATUS #define E1000_82542_EECD E1000_EECD -#define E1000_82542_CTRLEXT E1000_CTRLEXT +#define E1000_82542_EERD E1000_EERD +#define E1000_82542_CTRL_EXT E1000_CTRL_EXT #define E1000_82542_MDIC E1000_MDIC #define E1000_82542_FCAL E1000_FCAL #define E1000_82542_FCAH E1000_FCAH @@ -569,6 +564,7 @@ struct em_ffvt_entry { #define E1000_82542_VET E1000_VET #define E1000_82542_RA 0x00040 #define E1000_82542_ICR E1000_ICR +#define E1000_82542_ITR E1000_ITR #define E1000_82542_ICS E1000_ICS #define E1000_82542_IMS E1000_IMS #define E1000_82542_IMC E1000_IMC @@ -595,10 +591,14 @@ struct em_ffvt_entry { #define E1000_82542_TIDV 0x00440 #define E1000_82542_TBT E1000_TBT #define E1000_82542_VFTA 0x00600 +#define E1000_82542_LEDCTL E1000_LEDCTL #define E1000_82542_PBA E1000_PBA #define E1000_82542_RXDCTL E1000_RXDCTL +#define E1000_82542_RADV E1000_RADV +#define E1000_82542_RSRPD E1000_RSRPD #define E1000_82542_TXDMAC E1000_TXDMAC #define E1000_82542_TXDCTL E1000_TXDCTL +#define E1000_82542_TADV E1000_TADV #define E1000_82542_TSPMT E1000_TSPMT #define E1000_82542_CRCERRS E1000_CRCERRS #define E1000_82542_ALGNERRC E1000_ALGNERRC @@ -639,6 +639,9 @@ struct em_ffvt_entry { #define E1000_82542_RFC E1000_RFC #define E1000_82542_ROC E1000_ROC #define E1000_82542_RJC E1000_RJC +#define E1000_82542_MGTPRC E1000_MGTPRC +#define E1000_82542_MGTPDC E1000_MGTPDC +#define E1000_82542_MGTPTC E1000_MGTPTC #define E1000_82542_TORL E1000_TORL #define E1000_82542_TORH E1000_TORH #define E1000_82542_TOTL E1000_TOTL @@ -659,8 +662,10 @@ struct em_ffvt_entry { #define E1000_82542_WUC E1000_WUC #define E1000_82542_WUFC E1000_WUFC #define E1000_82542_WUS E1000_WUS +#define E1000_82542_MANC E1000_MANC #define E1000_82542_IPAV E1000_IPAV #define E1000_82542_IP4AT E1000_IP4AT +#define E1000_82542_IP6AT E1000_IP6AT #define E1000_82542_WUPL E1000_WUPL #define E1000_82542_WUPM E1000_WUPM #define E1000_82542_FFLT E1000_FFLT @@ -747,6 +752,7 @@ struct em_shared_adapter { uint32_t txcw_reg; uint32_t autoneg_failed; uint32_t max_frame_size; + uint32_t min_frame_size; uint32_t mc_filter_type; uint32_t num_mc_addrs; uint16_t autoneg_advertised; @@ -754,6 +760,11 @@ struct em_shared_adapter { uint16_t fc_high_water; uint16_t fc_low_water; uint16_t fc_pause_time; + uint16_t device_id; + uint16_t vendor_id; + uint16_t subsystem_id; + uint16_t subsystem_vendor_id; + uint8_t revision_id; boolean_t disable_polarity_correction; boolean_t get_link_status; boolean_t tbi_compatibility_en; @@ -762,7 +773,6 @@ struct em_shared_adapter { boolean_t fc_send_xon; boolean_t report_tx_early; boolean_t low_profile; - boolean_t large_eeprom; uint8_t autoneg; uint8_t mdix; uint8_t forced_speed_duplex; @@ -772,7 +782,7 @@ struct em_shared_adapter { }; -#define E1000_EEPROM_SWDPIN0 0x00000001 /* SWDPIN 0 EEPROM Value */ +#define E1000_EEPROM_SWDPIN0 0x0001 /* SWDPIN 0 EEPROM Value */ #define E1000_EEPROM_LED_LOGIC 0x0020 /* Led Logic Word */ /* Register Bit Masks */ @@ -811,6 +821,9 @@ struct em_shared_adapter { /* Device Status */ #define E1000_STATUS_FD 0x00000001 /* Full duplex.0=half,1=full */ #define E1000_STATUS_LU 0x00000002 /* Link up.0=no,1=link */ +#define E1000_STATUS_FUNC_MASK 0x0000000C /* PCI Function Mask */ +#define E1000_STATUS_FUNC_0 0x00000000 /* Function 0 */ +#define E1000_STATUS_FUNC_1 0x00000004 /* Function 1 */ #define E1000_STATUS_TXOFF 0x00000010 /* transmission paused */ #define E1000_STATUS_TBIMODE 0x00000020 /* TBI mode */ #define E1000_STATUS_SPEED_MASK 0x000000C0 @@ -839,6 +852,17 @@ struct em_shared_adapter { #define E1000_EECD_FWE_EN 0x00000020 /* Enable FLASH writes */ #define E1000_EECD_FWE_SHIFT 4 #define E1000_EECD_SIZE 0x00000200 /* EEPROM Size (0=64 word 1=256 word) */ +#define E1000_EECD_REQ 0x00000040 /* EEPROM Access Request */ +#define E1000_EECD_GNT 0x00000080 /* EEPROM Access Grant */ +#define E1000_EECD_PRES 0x00000100 /* EEPROM Present */ + +/* EEPROM Read */ +#define E1000_EERD_START 0x00000001 /* Start Read */ +#define E1000_EERD_DONE 0x00000010 /* Read Done */ +#define E1000_EERD_ADDR_SHIFT 8 +#define E1000_EERD_ADDR_MASK 0x0000FF00 /* Read Address */ +#define E1000_EERD_DATA_SHIFT 16 +#define E1000_EERD_DATA_MASK 0xFFFF0000 /* Read Data */ /* Extended Device Control */ #define E1000_CTRL_EXT_GPI0_EN 0x00000001 /* Maps SDP4 to GPI0 */ @@ -859,6 +883,14 @@ struct em_shared_adapter { #define E1000_CTRL_EXT_EE_RST 0x00002000 /* Reinitialize from EEPROM */ #define E1000_CTRL_EXT_IPS 0x00004000 /* Invert Power State */ #define E1000_CTRL_EXT_SPD_BYPS 0x00008000 /* Speed Select Bypass */ +#define E1000_CTRL_EXT_LINK_MODE_MASK 0x00C00000 +#define E1000_CTRL_EXT_LINK_MODE_GMII 0x00000000 +#define E1000_CTRL_EXT_LINK_MODE_TBI 0x00C00000 +#define E1000_CTRL_EXT_WR_WMARK_MASK 0x03000000 +#define E1000_CTRL_EXT_WR_WMARK_256 0x00000000 +#define E1000_CTRL_EXT_WR_WMARK_320 0x01000000 +#define E1000_CTRL_EXT_WR_WMARK_384 0x02000000 +#define E1000_CTRL_EXT_WR_WMARK_448 0x03000000 /* MDI Control */ #define E1000_MDIC_DATA_MASK 0x0000FFFF @@ -872,6 +904,40 @@ struct em_shared_adapter { #define E1000_MDIC_INT_EN 0x20000000 #define E1000_MDIC_ERROR 0x40000000 +/* LED Control */ +#define E1000_LEDCTL_LED0_MODE_MASK 0x0000000F +#define E1000_LEDCTL_LED0_MODE_SHIFT 0 +#define E1000_LEDCTL_LED0_IVRT 0x00000040 +#define E1000_LEDCTL_LED0_BLINK 0x00000080 +#define E1000_LEDCTL_LED1_MODE_MASK 0x00000F00 +#define E1000_LEDCTL_LED1_MODE_SHIFT 8 +#define E1000_LEDCTL_LED1_IVRT 0x00004000 +#define E1000_LEDCTL_LED1_BLINK 0x00008000 +#define E1000_LEDCTL_LED2_MODE_MASK 0x000F0000 +#define E1000_LEDCTL_LED2_MODE_SHIFT 16 +#define E1000_LEDCTL_LED2_IVRT 0x00400000 +#define E1000_LEDCTL_LED2_BLINK 0x00800000 +#define E1000_LEDCTL_LED3_MODE_MASK 0x0F000000 +#define E1000_LEDCTL_LED3_MODE_SHIFT 24 +#define E1000_LEDCTL_LED3_IVRT 0x40000000 +#define E1000_LEDCTL_LED3_BLINK 0x80000000 + +#define E1000_LEDCTL_MODE_LINK_10_1000 0x0 +#define E1000_LEDCTL_MODE_LINK_100_1000 0x1 +#define E1000_LEDCTL_MODE_LINK_UP 0x2 +#define E1000_LEDCTL_MODE_ACTIVITY 0x3 +#define E1000_LEDCTL_MODE_LINK_ACTIVITY 0x4 +#define E1000_LEDCTL_MODE_LINK_10 0x5 +#define E1000_LEDCTL_MODE_LINK_100 0x6 +#define E1000_LEDCTL_MODE_LINK_1000 0x7 +#define E1000_LEDCTL_MODE_PCIX_MODE 0x8 +#define E1000_LEDCTL_MODE_FULL_DUPLEX 0x9 +#define E1000_LEDCTL_MODE_COLLISION 0xA +#define E1000_LEDCTL_MODE_BUS_SPEED 0xB +#define E1000_LEDCTL_MODE_BUS_SIZE 0xC +#define E1000_LEDCTL_MODE_PAUSED 0xD +#define E1000_LEDCTL_MODE_LED_ON 0xE +#define E1000_LEDCTL_MODE_LED_OFF 0xF /* Receive Address */ #define E1000_RAH_AV 0x80000000 /* Receive descriptor valid */ @@ -890,6 +956,8 @@ struct em_shared_adapter { #define E1000_ICR_GPI_EN1 0x00001000 /* GP Int 1 */ #define E1000_ICR_GPI_EN2 0x00002000 /* GP Int 2 */ #define E1000_ICR_GPI_EN3 0x00004000 /* GP Int 3 */ +#define E1000_ICR_TXD_LOW 0x00008000 +#define E1000_ICR_SRPD 0x00010000 /* Interrupt Cause Set */ #define E1000_ICS_TXDW E1000_ICR_TXDW /* Transmit desc written back */ @@ -905,6 +973,8 @@ struct em_shared_adapter { #define E1000_ICS_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ #define E1000_ICS_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ #define E1000_ICS_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_ICS_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_ICS_SRPD E1000_ICR_SRPD /* Interrupt Mask Set */ #define E1000_IMS_TXDW E1000_ICR_TXDW /* Transmit desc written back */ @@ -920,6 +990,8 @@ struct em_shared_adapter { #define E1000_IMS_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ #define E1000_IMS_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ #define E1000_IMS_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_IMS_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_IMS_SRPD E1000_ICR_SRPD /* Interrupt Mask Clear */ #define E1000_IMC_TXDW E1000_ICR_TXDW /* Transmit desc written back */ @@ -935,6 +1007,8 @@ struct em_shared_adapter { #define E1000_IMC_GPI_EN1 E1000_ICR_GPI_EN1 /* GP Int 1 */ #define E1000_IMC_GPI_EN2 E1000_ICR_GPI_EN2 /* GP Int 2 */ #define E1000_IMC_GPI_EN3 E1000_ICR_GPI_EN3 /* GP Int 3 */ +#define E1000_IMC_TXD_LOW E1000_ICR_TXD_LOW +#define E1000_IMC_SRPD E1000_ICR_SRPD /* Receive Control */ #define E1000_RCTL_RST 0x00000001 /* Software reset */ @@ -997,6 +1071,7 @@ struct em_shared_adapter { #define E1000_TXDCTL_HTHRESH 0x0000FF00 /* TXDCTL Host Threshold */ #define E1000_TXDCTL_WTHRESH 0x00FF0000 /* TXDCTL Writeback Threshold */ #define E1000_TXDCTL_GRAN 0x01000000 /* TXDCTL Granularity */ +#define E1000_TXDCTL_LWTHRESH 0xFE000000 /* TXDCTL Low Threshold */ /* Transmit Configuration Word */ #define E1000_TXCW_FD 0x00000020 /* TXCW full duplex */ @@ -1035,6 +1110,7 @@ struct em_shared_adapter { #define E1000_RXCSUM_PCSS_MASK 0x000000FF /* Packet Checksum Start */ #define E1000_RXCSUM_IPOFL 0x00000100 /* IPv4 checksum offload */ #define E1000_RXCSUM_TUOFL 0x00000200 /* TCP / UDP checksum offload */ +#define E1000_RXCSUM_IPV6OFL 0x00000400 /* IPv6 checksum offload */ /* Definitions for power management and wakeup registers */ /* Wake Up Control */ @@ -1051,6 +1127,7 @@ struct em_shared_adapter { #define E1000_WUFC_BC 0x00000010 /* Broadcast Wakeup Enable */ #define E1000_WUFC_ARP 0x00000020 /* ARP Request Packet Wakeup Enable */ #define E1000_WUFC_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Enable */ +#define E1000_WUFC_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Enable */ #define E1000_WUFC_FLX0 0x00010000 /* Flexible Filter 0 Enable */ #define E1000_WUFC_FLX1 0x00020000 /* Flexible Filter 1 Enable */ #define E1000_WUFC_FLX2 0x00040000 /* Flexible Filter 2 Enable */ @@ -1067,12 +1144,37 @@ struct em_shared_adapter { #define E1000_WUS_BC 0x00000010 /* Broadcast Received */ #define E1000_WUS_ARP 0x00000020 /* ARP Request Packet Received */ #define E1000_WUS_IPV4 0x00000040 /* Directed IPv4 Packet Wakeup Received */ +#define E1000_WUS_IPV6 0x00000080 /* Directed IPv6 Packet Wakeup Received */ #define E1000_WUS_FLX0 0x00010000 /* Flexible Filter 0 Match */ #define E1000_WUS_FLX1 0x00020000 /* Flexible Filter 1 Match */ #define E1000_WUS_FLX2 0x00040000 /* Flexible Filter 2 Match */ #define E1000_WUS_FLX3 0x00080000 /* Flexible Filter 3 Match */ #define E1000_WUS_FLX_FILTERS 0x000F0000 /* Mask for the 4 flexible filters */ +/* Management Control */ +#define E1000_MANC_SMBUS_EN 0x00000001 /* SMBus Enabled - RO */ +#define E1000_MANC_ASF_EN 0x00000002 /* ASF Enabled - RO */ +#define E1000_MANC_R_ON_FORCE 0x00000004 /* Reset on Force TCO - RO */ +#define E1000_MANC_RMCP_EN 0x00000100 /* Enable RCMP 026Fh Filtering */ +#define E1000_MANC_0298_EN 0x00000200 /* Enable RCMP 0298h Filtering */ +#define E1000_MANC_IPV4_EN 0x00000400 /* Enable IPv4 */ +#define E1000_MANC_IPV6_EN 0x00000800 /* Enable IPv6 */ +#define E1000_MANC_SNAP_EN 0x00001000 /* Accept LLC/SNAP */ +#define E1000_MANC_ARP_EN 0x00002000 /* Enable ARP Request Filtering */ +#define E1000_MANC_NEIGHBOR_EN 0x00004000 /* Enable Neighbor Discovery + * Filtering */ +#define E1000_MANC_TCO_RESET 0x00010000 /* TCO Reset Occurred */ +#define E1000_MANC_RCV_TCO_EN 0x00020000 /* Receive TCO Packets Enabled */ +#define E1000_MANC_REPORT_STATUS 0x00040000 /* Status Reporting Enabled */ +#define E1000_MANC_SMB_REQ 0x01000000 /* SMBus Request */ +#define E1000_MANC_SMB_GNT 0x02000000 /* SMBus Grant */ +#define E1000_MANC_SMB_CLK_IN 0x04000000 /* SMBus Clock In */ +#define E1000_MANC_SMB_DATA_IN 0x08000000 /* SMBus Data In */ +#define E1000_MANC_SMB_DATA_OUT 0x10000000 /* SMBus Data Out */ +#define E1000_MANC_SMB_CLK_OUT 0x20000000 /* SMBus Clock Out */ + +#define E1000_MANC_SMB_DATA_OUT_SHIFT 28 /* SMBus Data Out Shift */ +#define E1000_MANC_SMB_CLK_OUT_SHIFT 29 /* SMBus Clock Out Shift */ /* Wake Up Packet Length */ #define E1000_WUPL_LENGTH_MASK 0x0FFF /* Only the lower 12 bits are valid */ @@ -1130,7 +1232,7 @@ struct em_shared_adapter { /* Default values for the transmit IPG register */ #define DEFAULT_82542_TIPG_IPGT 10 -#define DEFAULT_82543_TIPG_IPGT_FIBER 6 +#define DEFAULT_82543_TIPG_IPGT_FIBER 9 #define DEFAULT_82543_TIPG_IPGT_COPPER 8 #define E1000_TIPG_IPGT_MASK 0x000003FF @@ -1202,23 +1304,15 @@ struct em_shared_adapter { /* TBI_ACCEPT macro definition: * - * If Tbi Compatibility mode is turned-on, then we should accept frames with - * receive errors if and only if: - * 1) errors is equal to the CRC error bit. - * 2) The last byte is a Carrier extension (0x0F). - * 3) The frame length (as reported by Hardware) is greater than 64 (60 - * if a VLAN tag was stripped from the frame. - * 4) " " " " " " " <= max_frame_size+1. - * * This macro requires: * adapter = a pointer to struct em_shared_adapter - * special = the 16 bit special field of the RX descriptor with EOP set + * status = the 8 bit status field of the RX descriptor with EOP set * error = the 8 bit error field of the RX descriptor with EOP set * length = the sum of all the length fields of the RX descriptors that * make up the current frame * last_byte = the last byte of the frame DMAed by the hardware * max_frame_length = the maximum frame length we want to accept. - * THIS INCLUDES THE 4 BYTE ETHERNET CRC! + * min_frame_length = the minimum frame length we want to accept. * * This macro is a conditional that should be used in the interrupt * handler's Rx processing routine when RxErrors have been detected. @@ -1235,15 +1329,15 @@ struct em_shared_adapter { * ... */ -#define TBI_ACCEPT(adapter, special, errors, length, last_byte) \ +#define TBI_ACCEPT(adapter, status, errors, length, last_byte) \ ((adapter)->tbi_compatibility_on && \ (((errors) & E1000_RXD_ERR_FRAME_ERR_MASK) == E1000_RXD_ERR_CE) && \ ((last_byte) == CARRIER_EXTENSION) && \ - ((special == 0x0000) ? \ - ((length <= ((adapter)->max_frame_size + 1)) && \ - (length > 64)) : \ - ((length <= ((adapter)->max_frame_size - 3)) && \ - (length > 60)))) + (((status) & E1000_RXD_STAT_VP) ? \ + (((length) > ((adapter)->min_frame_size - VLAN_TAG_SIZE)) && \ + ((length) <= ((adapter)->max_frame_size + 1))) : \ + (((length) > (adapter)->min_frame_size) && \ + ((length) <= ((adapter)->max_frame_size + VLAN_TAG_SIZE + 1))))) #endif /* _EM_MAC_H_ */ diff --git a/sys/dev/em/if_em_osdep.h b/sys/dev/em/if_em_osdep.h index 9d4b923..55c6da1 100644 --- a/sys/dev/em/if_em_osdep.h +++ b/sys/dev/em/if_em_osdep.h @@ -1,6 +1,6 @@ /************************************************************************** -Copyright (c) 2001 Intel Corporation +Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or diff --git a/sys/dev/em/if_em_phy.c b/sys/dev/em/if_em_phy.c index d359b28..76ffaae 100644 --- a/sys/dev/em/if_em_phy.c +++ b/sys/dev/em/if_em_phy.c @@ -1,6 +1,6 @@ /******************************************************************************* - Copyright (c) 2001 Intel Corporation + Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -234,7 +234,7 @@ em_phy_force_speed_duplex(struct em_shared_adapter *shared) /* Read the MII Control Register. */ mii_ctrl_reg = em_read_phy_reg(shared, PHY_CTRL); - /* We need to disable Autoneg in order to force link and duplex. */ + /* We need to disable autoneg in order to force link and duplex. */ mii_ctrl_reg &= ~MII_CR_AUTO_NEG_EN; @@ -337,11 +337,11 @@ em_phy_force_speed_duplex(struct em_shared_adapter *shared) * the default. */ if(shared->wait_autoneg_complete) { - /* We will wait for AutoNeg to complete. */ + /* We will wait for autoneg to complete. */ DEBUGOUT("Waiting for forced speed/duplex link.\n"); mii_status_reg = 0; - /* We will wait for AutoNeg to complete or 4.5 seconds to expire. */ + /* We will wait for autoneg to complete or 4.5 seconds to expire. */ for(i = PHY_FORCE_TIME; i > 0; i--) { /* Read the MII Status Register and wait for Auto-Neg * Complete bit to be set. @@ -414,8 +414,6 @@ em_read_phy_reg(struct em_shared_adapter *shared, uint32_t data = 0; uint32_t command = 0; - DEBUGFUNC("em_read_phy_reg"); - ASSERT(reg_addr <= MAX_PHY_REG_ADDRESS); if(shared->mac_type > em_82543) { @@ -428,7 +426,6 @@ em_read_phy_reg(struct em_shared_adapter *shared, (shared->phy_addr << E1000_MDIC_PHY_SHIFT) | (E1000_MDIC_OP_READ)); - DEBUGOUT1("Writing 0x%X to MDIC\n", command); E1000_WRITE_REG(shared, MDIC, command); /* Check every 10 usec to see if the read completed. The read @@ -440,7 +437,6 @@ em_read_phy_reg(struct em_shared_adapter *shared, data = E1000_READ_REG(shared, MDIC); - DEBUGOUT1("Read 0x%X from MDIC\n", data); if(data & E1000_MDIC_READY) break; } @@ -587,30 +583,30 @@ em_phy_hw_reset(struct em_shared_adapter *shared) /* Read the Extended Device Control Register, assert the * PHY_RESET_DIR bit. Then clock it out to the PHY. */ - ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT); + ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT); ctrl_ext_reg |= E1000_CTRL_PHY_RESET_DIR4; - E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg); + E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg); msec_delay(20); /* Set the reset bit in the device control register and clock * it out to the PHY. */ - ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT); + ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT); ctrl_ext_reg &= ~E1000_CTRL_PHY_RESET4; - E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg); + E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg); msec_delay(20); - ctrl_ext_reg = E1000_READ_REG(shared, CTRLEXT); + ctrl_ext_reg = E1000_READ_REG(shared, CTRL_EXT); ctrl_ext_reg |= E1000_CTRL_PHY_RESET4; - E1000_WRITE_REG(shared, CTRLEXT, ctrl_ext_reg); + E1000_WRITE_REG(shared, CTRL_EXT, ctrl_ext_reg); msec_delay(20); } @@ -696,7 +692,7 @@ em_phy_setup(struct em_shared_adapter *shared, * on the PHY to take it out of reset. */ if(shared->mac_type >= em_82544) { - ctrl_reg |= (E1000_CTRL_ASDE | E1000_CTRL_SLU); + ctrl_reg |= E1000_CTRL_SLU; E1000_WRITE_REG(shared, CTRL, ctrl_reg); } else { ctrl_reg |= (E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX | E1000_CTRL_SLU); @@ -768,7 +764,7 @@ em_phy_setup(struct em_shared_adapter *shared, /* Read the MII Auto-Neg Advertisement Register (Address 4). */ mii_autoneg_adv_reg = em_read_phy_reg(shared, PHY_AUTONEG_ADV); - /* Shift left to put 10T-Half bit in bit 0 + /* Shift right to put 10T-Half bit in bit 0 * Isolate the four bits for 100/10 Full/Half. */ autoneg_hw_setting = (mii_autoneg_adv_reg >> 5) & 0xF; @@ -892,13 +888,11 @@ em_phy_setup(struct em_shared_adapter *shared, * depending on value parsed from forced_speed_duplex. */ - /* Is AutoNeg enabled? This is enabled by default or by software - * override. If so, - * call PhySetupAutoNegAdvertisement routine to parse the - * autoneg_advertised and fc options. - * If AutoNeg is NOT enabled, then the user should have provided - * a Speed/Duplex override. If so, then call the - * PhyForceSpeedAndDuplex to parse and set this up. Otherwise, + /* Is autoneg enabled? This is enabled by default or by software override. + * If so, call em_phy_setup_autoneg routine to parse the + * autoneg_advertised and fc options. If autoneg is NOT enabled, then the + * user should have provided a speed/duplex override. If so, then call + * em_phy_force_speed_duplex to parse and set this up. Otherwise, * we are in an error situation and need to bail. */ if(shared->autoneg) { @@ -1057,8 +1051,7 @@ em_phy_setup_autoneg(struct em_shared_adapter *shared) * setup the PHY advertisement registers accordingly. If * auto-negotiation is enabled, then software will have to set the * "PAUSE" bits to the correct value in the Auto-Negotiation - * Advertisement Register (PHY_AUTONEG_ADVERTISEMENT) and re-start - * auto-negotiation. + * Advertisement Register (PHY_AUTONEG_ADV) and re-start auto-negotiation. * * The possible values of the "fc" parameter are: * 0: Flow control is completely disabled @@ -1291,7 +1284,7 @@ em_display_mii(struct em_shared_adapter *shared) DEBUGFUNC("em_display_mii"); - DEBUGOUT1("adapter Base Address = %p\n", shared->hw_addr); + DEBUGOUT1("adapter Base Address = %x\n", shared->hw_addr); /* This will read each PHY Reg address and display its contents. */ @@ -1389,7 +1382,8 @@ em_detect_gig_phy(struct em_shared_adapter *shared) if(shared->phy_id == M88E1000_12_PHY_ID || shared->phy_id == M88E1000_14_PHY_ID || - shared->phy_id == M88E1000_I_PHY_ID) { + shared->phy_id == M88E1000_I_PHY_ID || + shared->phy_id == M88E1011_I_PHY_ID) { DEBUGOUT2("phy_id 0x%x detected at address 0x%x\n", shared->phy_id, shared->phy_addr); @@ -1428,11 +1422,11 @@ em_wait_autoneg(struct em_shared_adapter *shared) DEBUGFUNC("em_wait_autoneg"); - /* We will wait for AutoNeg to complete. */ + /* We will wait for autoneg to complete. */ DEBUGOUT("Waiting for Auto-Neg to complete.\n"); mii_status_reg = 0; - /* We will wait for AutoNeg to complete or 4.5 seconds to expire. */ + /* We will wait for autoneg to complete or 4.5 seconds to expire. */ for(i = PHY_AUTO_NEG_TIME; i > 0; i--) { /* Read the MII Status Register and wait for Auto-Neg @@ -1462,7 +1456,7 @@ boolean_t em_phy_get_info(struct em_shared_adapter *shared, struct em_phy_info *phy_status_info) { - uint16_t phy_mii_shatus_reg; + uint16_t phy_mii_status_reg; uint16_t phy_specific_ctrl_reg; uint16_t phy_specific_status_reg; uint16_t phy_specific_ext_ctrl_reg; @@ -1485,9 +1479,9 @@ em_phy_get_info(struct em_shared_adapter *shared, /* PHY info only valid for LINK UP. Read MII status reg * back-to-back to get link status. */ - phy_mii_shatus_reg = em_read_phy_reg(shared, PHY_STATUS); - phy_mii_shatus_reg = em_read_phy_reg(shared, PHY_STATUS); - if((phy_mii_shatus_reg & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) + phy_mii_status_reg = em_read_phy_reg(shared, PHY_STATUS); + phy_mii_status_reg = em_read_phy_reg(shared, PHY_STATUS); + if((phy_mii_status_reg & MII_SR_LINK_STATUS) != MII_SR_LINK_STATUS) return FALSE; /* Read various PHY registers to get the PHY info. */ diff --git a/sys/dev/em/if_em_phy.h b/sys/dev/em/if_em_phy.h index f2cc25f..b1cc365 100644 --- a/sys/dev/em/if_em_phy.h +++ b/sys/dev/em/if_em_phy.h @@ -1,6 +1,6 @@ /******************************************************************************* - Copyright (c) 2001 Intel Corporation + Copyright (c) 2001-2002 Intel Corporation All rights reserved. Redistribution and use in source and binary forms of the Software, with or @@ -102,27 +102,26 @@ struct em_phy_info { em_1000t_rx_status remote_rx; }; +struct em_phy_stats { + uint32_t idle_errors; + uint32_t receive_errors; +}; + /* Function Prototypes */ -uint16_t em_read_phy_reg(struct em_shared_adapter *shared, - uint32_t reg_addr); -void em_write_phy_reg(struct em_shared_adapter *shared, - uint32_t reg_addr, - uint16_t data); +uint16_t em_read_phy_reg(struct em_shared_adapter *shared, uint32_t reg_addr); +void em_write_phy_reg(struct em_shared_adapter *shared, uint32_t reg_addr, uint16_t data); void em_phy_hw_reset(struct em_shared_adapter *shared); boolean_t em_phy_reset(struct em_shared_adapter *shared); -boolean_t em_phy_setup(struct em_shared_adapter *shared, - uint32_t ctrl_reg); +boolean_t em_phy_setup(struct em_shared_adapter *shared, uint32_t ctrl_reg); boolean_t em_phy_setup_autoneg(struct em_shared_adapter *shared); -void em_config_mac_to_phy(struct em_shared_adapter *shared, - uint16_t mii_reg); +void em_config_mac_to_phy(struct em_shared_adapter *shared, uint16_t mii_reg); void em_config_collision_dist(struct em_shared_adapter *shared); void em_display_mii(struct em_shared_adapter *shared); boolean_t em_detect_gig_phy(struct em_shared_adapter *shared); void em_phy_reset_dsp(struct em_shared_adapter *shared); boolean_t em_wait_autoneg(struct em_shared_adapter *shared); -boolean_t em_phy_get_info(struct em_shared_adapter *shared, - struct em_phy_info *phy_status_info); -boolean_t em_validate_mdi_setting(struct em_shared_adapter * shared); +boolean_t em_phy_get_info(struct em_shared_adapter *shared, struct em_phy_info *phy_status_info); +boolean_t em_validate_mdi_setting(struct em_shared_adapter *shared); /* Bit definitions for the Management Data IO (MDIO) and Management Data * Clock (MDC) pins in the Device Control Register. @@ -357,6 +356,7 @@ boolean_t em_validate_mdi_setting(struct em_shared_adapter * shared); #define M88E1000_12_PHY_ID 0x01410C50 #define M88E1000_14_PHY_ID 0x01410C40 #define M88E1000_I_PHY_ID 0x01410C30 +#define M88E1011_I_PHY_ID 0x01410C20 /* Miscellaneous PHY bit definitions. */ #define PHY_PREAMBLE 0xFFFFFFFF -- cgit v1.1