Deleted Added
sdiff udiff text old ( 197078 ) new ( 200243 )
full compact
if_em.c (197078) if_em.c (200243)
1/******************************************************************************
2
3 Copyright (c) 2001-2009, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8

--- 16 unchanged lines hidden (view full) ---

25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32******************************************************************************/
1/******************************************************************************
2
3 Copyright (c) 2001-2009, Intel Corporation
4 All rights reserved.
5
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
8

--- 16 unchanged lines hidden (view full) ---

25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
31
32******************************************************************************/
33/*$FreeBSD: head/sys/dev/e1000/if_em.c 197078 2009-09-10 21:14:55Z jfv $*/
33/*$FreeBSD: head/sys/dev/e1000/if_em.c 200243 2009-12-08 01:07:44Z jfv $*/
34
35#ifdef HAVE_KERNEL_OPTION_HEADERS
36#include "opt_device_polling.h"
37#include "opt_inet.h"
38#endif
39
40#include <sys/param.h>
41#include <sys/systm.h>

--- 47 unchanged lines hidden (view full) ---

89/*********************************************************************
90 * Set this to one to display debug statistics
91 *********************************************************************/
92int em_display_debug_stats = 0;
93
94/*********************************************************************
95 * Driver version:
96 *********************************************************************/
34
35#ifdef HAVE_KERNEL_OPTION_HEADERS
36#include "opt_device_polling.h"
37#include "opt_inet.h"
38#endif
39
40#include <sys/param.h>
41#include <sys/systm.h>

--- 47 unchanged lines hidden (view full) ---

89/*********************************************************************
90 * Set this to one to display debug statistics
91 *********************************************************************/
92int em_display_debug_stats = 0;
93
94/*********************************************************************
95 * Driver version:
96 *********************************************************************/
97char em_driver_version[] = "6.9.14";
97char em_driver_version[] = "6.9.24";
98
99
100/*********************************************************************
101 * PCI Device ID Table
102 *
103 * Used by probe to select devices to load on
104 * Last field stores an index into e1000_strings
105 * Last entry must be all 0s

--- 83 unchanged lines hidden (view full) ---

189 PCI_ANY_ID, PCI_ANY_ID, 0},
190 { 0x8086, E1000_DEV_ID_ICH8_IGP_M_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
191 { 0x8086, E1000_DEV_ID_ICH8_IGP_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
192 { 0x8086, E1000_DEV_ID_ICH8_IGP_C, PCI_ANY_ID, PCI_ANY_ID, 0},
193 { 0x8086, E1000_DEV_ID_ICH8_IFE, PCI_ANY_ID, PCI_ANY_ID, 0},
194 { 0x8086, E1000_DEV_ID_ICH8_IFE_GT, PCI_ANY_ID, PCI_ANY_ID, 0},
195 { 0x8086, E1000_DEV_ID_ICH8_IFE_G, PCI_ANY_ID, PCI_ANY_ID, 0},
196 { 0x8086, E1000_DEV_ID_ICH8_IGP_M, PCI_ANY_ID, PCI_ANY_ID, 0},
98
99
100/*********************************************************************
101 * PCI Device ID Table
102 *
103 * Used by probe to select devices to load on
104 * Last field stores an index into e1000_strings
105 * Last entry must be all 0s

--- 83 unchanged lines hidden (view full) ---

189 PCI_ANY_ID, PCI_ANY_ID, 0},
190 { 0x8086, E1000_DEV_ID_ICH8_IGP_M_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
191 { 0x8086, E1000_DEV_ID_ICH8_IGP_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
192 { 0x8086, E1000_DEV_ID_ICH8_IGP_C, PCI_ANY_ID, PCI_ANY_ID, 0},
193 { 0x8086, E1000_DEV_ID_ICH8_IFE, PCI_ANY_ID, PCI_ANY_ID, 0},
194 { 0x8086, E1000_DEV_ID_ICH8_IFE_GT, PCI_ANY_ID, PCI_ANY_ID, 0},
195 { 0x8086, E1000_DEV_ID_ICH8_IFE_G, PCI_ANY_ID, PCI_ANY_ID, 0},
196 { 0x8086, E1000_DEV_ID_ICH8_IGP_M, PCI_ANY_ID, PCI_ANY_ID, 0},
197
197 { 0x8086, E1000_DEV_ID_ICH8_82567V_3, PCI_ANY_ID, PCI_ANY_ID, 0},
198 { 0x8086, E1000_DEV_ID_ICH9_IGP_M_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
199 { 0x8086, E1000_DEV_ID_ICH9_IGP_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
200 { 0x8086, E1000_DEV_ID_ICH9_IGP_C, PCI_ANY_ID, PCI_ANY_ID, 0},
201 { 0x8086, E1000_DEV_ID_ICH9_IGP_M, PCI_ANY_ID, PCI_ANY_ID, 0},
202 { 0x8086, E1000_DEV_ID_ICH9_IGP_M_V, PCI_ANY_ID, PCI_ANY_ID, 0},
203 { 0x8086, E1000_DEV_ID_ICH9_IFE, PCI_ANY_ID, PCI_ANY_ID, 0},
204 { 0x8086, E1000_DEV_ID_ICH9_IFE_GT, PCI_ANY_ID, PCI_ANY_ID, 0},
205 { 0x8086, E1000_DEV_ID_ICH9_IFE_G, PCI_ANY_ID, PCI_ANY_ID, 0},
206 { 0x8086, E1000_DEV_ID_ICH9_BM, PCI_ANY_ID, PCI_ANY_ID, 0},
207 { 0x8086, E1000_DEV_ID_82574L, PCI_ANY_ID, PCI_ANY_ID, 0},
208 { 0x8086, E1000_DEV_ID_82574LA, PCI_ANY_ID, PCI_ANY_ID, 0},
209 { 0x8086, E1000_DEV_ID_ICH10_R_BM_LM, PCI_ANY_ID, PCI_ANY_ID, 0},
210 { 0x8086, E1000_DEV_ID_ICH10_R_BM_LF, PCI_ANY_ID, PCI_ANY_ID, 0},
211 { 0x8086, E1000_DEV_ID_ICH10_R_BM_V, PCI_ANY_ID, PCI_ANY_ID, 0},
212 { 0x8086, E1000_DEV_ID_ICH10_D_BM_LM, PCI_ANY_ID, PCI_ANY_ID, 0},
213 { 0x8086, E1000_DEV_ID_ICH10_D_BM_LF, PCI_ANY_ID, PCI_ANY_ID, 0},
198 { 0x8086, E1000_DEV_ID_ICH9_IGP_M_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
199 { 0x8086, E1000_DEV_ID_ICH9_IGP_AMT, PCI_ANY_ID, PCI_ANY_ID, 0},
200 { 0x8086, E1000_DEV_ID_ICH9_IGP_C, PCI_ANY_ID, PCI_ANY_ID, 0},
201 { 0x8086, E1000_DEV_ID_ICH9_IGP_M, PCI_ANY_ID, PCI_ANY_ID, 0},
202 { 0x8086, E1000_DEV_ID_ICH9_IGP_M_V, PCI_ANY_ID, PCI_ANY_ID, 0},
203 { 0x8086, E1000_DEV_ID_ICH9_IFE, PCI_ANY_ID, PCI_ANY_ID, 0},
204 { 0x8086, E1000_DEV_ID_ICH9_IFE_GT, PCI_ANY_ID, PCI_ANY_ID, 0},
205 { 0x8086, E1000_DEV_ID_ICH9_IFE_G, PCI_ANY_ID, PCI_ANY_ID, 0},
206 { 0x8086, E1000_DEV_ID_ICH9_BM, PCI_ANY_ID, PCI_ANY_ID, 0},
207 { 0x8086, E1000_DEV_ID_82574L, PCI_ANY_ID, PCI_ANY_ID, 0},
208 { 0x8086, E1000_DEV_ID_82574LA, PCI_ANY_ID, PCI_ANY_ID, 0},
209 { 0x8086, E1000_DEV_ID_ICH10_R_BM_LM, PCI_ANY_ID, PCI_ANY_ID, 0},
210 { 0x8086, E1000_DEV_ID_ICH10_R_BM_LF, PCI_ANY_ID, PCI_ANY_ID, 0},
211 { 0x8086, E1000_DEV_ID_ICH10_R_BM_V, PCI_ANY_ID, PCI_ANY_ID, 0},
212 { 0x8086, E1000_DEV_ID_ICH10_D_BM_LM, PCI_ANY_ID, PCI_ANY_ID, 0},
213 { 0x8086, E1000_DEV_ID_ICH10_D_BM_LF, PCI_ANY_ID, PCI_ANY_ID, 0},
214 { 0x8086, E1000_DEV_ID_PCH_M_HV_LM, PCI_ANY_ID, PCI_ANY_ID, 0},
215 { 0x8086, E1000_DEV_ID_PCH_M_HV_LC, PCI_ANY_ID, PCI_ANY_ID, 0},
216 { 0x8086, E1000_DEV_ID_PCH_D_HV_DM, PCI_ANY_ID, PCI_ANY_ID, 0},
217 { 0x8086, E1000_DEV_ID_PCH_D_HV_DC, PCI_ANY_ID, PCI_ANY_ID, 0},
214 /* required last entry */
215 { 0, 0, 0, 0, 0}
216};
217
218/*********************************************************************
219 * Table of branding strings for all supported NICs.
220 *********************************************************************/
221

--- 13 unchanged lines hidden (view full) ---

235static void em_start(struct ifnet *);
236static void em_start_locked(struct ifnet *ifp);
237#if __FreeBSD_version >= 800000
238static int em_mq_start(struct ifnet *, struct mbuf *);
239static int em_mq_start_locked(struct ifnet *, struct mbuf *);
240static void em_qflush(struct ifnet *);
241#endif
242static int em_ioctl(struct ifnet *, u_long, caddr_t);
218 /* required last entry */
219 { 0, 0, 0, 0, 0}
220};
221
222/*********************************************************************
223 * Table of branding strings for all supported NICs.
224 *********************************************************************/
225

--- 13 unchanged lines hidden (view full) ---

239static void em_start(struct ifnet *);
240static void em_start_locked(struct ifnet *ifp);
241#if __FreeBSD_version >= 800000
242static int em_mq_start(struct ifnet *, struct mbuf *);
243static int em_mq_start_locked(struct ifnet *, struct mbuf *);
244static void em_qflush(struct ifnet *);
245#endif
246static int em_ioctl(struct ifnet *, u_long, caddr_t);
243static void em_watchdog(struct adapter *);
244static void em_init(void *);
245static void em_init_locked(struct adapter *);
246static void em_stop(void *);
247static void em_media_status(struct ifnet *, struct ifmediareq *);
248static int em_media_change(struct ifnet *);
249static void em_identify_hardware(struct adapter *);
250static int em_allocate_pci_resources(struct adapter *);
251static int em_allocate_legacy(struct adapter *adapter);

--- 58 unchanged lines hidden (view full) ---

310static int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
311static void em_add_int_delay_sysctl(struct adapter *, const char *,
312 const char *, struct em_int_delay_info *, int, int);
313/* Management and WOL Support */
314static void em_init_manageability(struct adapter *);
315static void em_release_manageability(struct adapter *);
316static void em_get_hw_control(struct adapter *);
317static void em_release_hw_control(struct adapter *);
247static void em_init(void *);
248static void em_init_locked(struct adapter *);
249static void em_stop(void *);
250static void em_media_status(struct ifnet *, struct ifmediareq *);
251static int em_media_change(struct ifnet *);
252static void em_identify_hardware(struct adapter *);
253static int em_allocate_pci_resources(struct adapter *);
254static int em_allocate_legacy(struct adapter *adapter);

--- 58 unchanged lines hidden (view full) ---

313static int em_sysctl_int_delay(SYSCTL_HANDLER_ARGS);
314static void em_add_int_delay_sysctl(struct adapter *, const char *,
315 const char *, struct em_int_delay_info *, int, int);
316/* Management and WOL Support */
317static void em_init_manageability(struct adapter *);
318static void em_release_manageability(struct adapter *);
319static void em_get_hw_control(struct adapter *);
320static void em_release_hw_control(struct adapter *);
321static void em_get_wakeup(device_t);
318static void em_enable_wakeup(device_t);
322static void em_enable_wakeup(device_t);
323static int em_enable_phy_wakeup(struct adapter *);
319
320#ifdef EM_LEGACY_IRQ
321static void em_intr(void *);
322#else /* FAST IRQ */
323#if __FreeBSD_version < 700000
324static void em_irq_fast(void *);
325#else
326static int em_irq_fast(void *);

--- 158 unchanged lines hidden (view full) ---

485 *********************************************************************/
486
487static int
488em_attach(device_t dev)
489{
490 struct adapter *adapter;
491 int tsize, rsize;
492 int error = 0;
324
325#ifdef EM_LEGACY_IRQ
326static void em_intr(void *);
327#else /* FAST IRQ */
328#if __FreeBSD_version < 700000
329static void em_irq_fast(void *);
330#else
331static int em_irq_fast(void *);

--- 158 unchanged lines hidden (view full) ---

490 *********************************************************************/
491
492static int
493em_attach(device_t dev)
494{
495 struct adapter *adapter;
496 int tsize, rsize;
497 int error = 0;
493 u16 eeprom_data, device_id;
494
495 INIT_DEBUGOUT("em_attach: begin");
496
497 adapter = device_get_softc(dev);
498 adapter->dev = adapter->osdep.dev = dev;
499 EM_CORE_LOCK_INIT(adapter, device_get_nameunit(dev));
500 EM_TX_LOCK_INIT(adapter, device_get_nameunit(dev));
501 EM_RX_LOCK_INIT(adapter, device_get_nameunit(dev));

--- 24 unchanged lines hidden (view full) ---

526
527 /*
528 ** For ICH8 and family we need to
529 ** map the flash memory, and this
530 ** must happen after the MAC is
531 ** identified
532 */
533 if ((adapter->hw.mac.type == e1000_ich8lan) ||
498
499 INIT_DEBUGOUT("em_attach: begin");
500
501 adapter = device_get_softc(dev);
502 adapter->dev = adapter->osdep.dev = dev;
503 EM_CORE_LOCK_INIT(adapter, device_get_nameunit(dev));
504 EM_TX_LOCK_INIT(adapter, device_get_nameunit(dev));
505 EM_RX_LOCK_INIT(adapter, device_get_nameunit(dev));

--- 24 unchanged lines hidden (view full) ---

530
531 /*
532 ** For ICH8 and family we need to
533 ** map the flash memory, and this
534 ** must happen after the MAC is
535 ** identified
536 */
537 if ((adapter->hw.mac.type == e1000_ich8lan) ||
538 (adapter->hw.mac.type == e1000_pchlan) ||
534 (adapter->hw.mac.type == e1000_ich9lan) ||
535 (adapter->hw.mac.type == e1000_ich10lan)) {
536 int rid = EM_BAR_TYPE_FLASH;
537 adapter->flash = bus_alloc_resource_any(dev,
538 SYS_RES_MEMORY, &rid, RF_ACTIVE);
539 if (adapter->flash == NULL) {
540 device_printf(dev, "Mapping of Flash failed\n");
541 error = ENXIO;

--- 181 unchanged lines hidden (view full) ---

723 */
724 if (adapter->msi > 1) /* Do MSI/X */
725 error = em_allocate_msix(adapter);
726 else /* MSI or Legacy */
727 error = em_allocate_legacy(adapter);
728 if (error)
729 goto err_rx_struct;
730
539 (adapter->hw.mac.type == e1000_ich9lan) ||
540 (adapter->hw.mac.type == e1000_ich10lan)) {
541 int rid = EM_BAR_TYPE_FLASH;
542 adapter->flash = bus_alloc_resource_any(dev,
543 SYS_RES_MEMORY, &rid, RF_ACTIVE);
544 if (adapter->flash == NULL) {
545 device_printf(dev, "Mapping of Flash failed\n");
546 error = ENXIO;

--- 181 unchanged lines hidden (view full) ---

728 */
729 if (adapter->msi > 1) /* Do MSI/X */
730 error = em_allocate_msix(adapter);
731 else /* MSI or Legacy */
732 error = em_allocate_legacy(adapter);
733 if (error)
734 goto err_rx_struct;
735
736 /*
737 * Get Wake-on-Lan and Management info for later use
738 */
739 em_get_wakeup(dev);
740
731 /* Setup OS specific network interface */
732 em_setup_interface(dev, adapter);
733
734 /* Initialize statistics */
735 em_update_stats_counters(adapter);
736
737 adapter->hw.mac.get_link_status = 1;
738 em_update_link_status(adapter);
739
740 /* Indicate SOL/IDER usage */
741 if (e1000_check_reset_block(&adapter->hw))
742 device_printf(dev,
743 "PHY reset is blocked due to SOL/IDER session.\n");
744
741 /* Setup OS specific network interface */
742 em_setup_interface(dev, adapter);
743
744 /* Initialize statistics */
745 em_update_stats_counters(adapter);
746
747 adapter->hw.mac.get_link_status = 1;
748 em_update_link_status(adapter);
749
750 /* Indicate SOL/IDER usage */
751 if (e1000_check_reset_block(&adapter->hw))
752 device_printf(dev,
753 "PHY reset is blocked due to SOL/IDER session.\n");
754
745 /* Determine if we have to control management hardware */
746 adapter->has_manage = e1000_enable_mng_pass_thru(&adapter->hw);
747
748 /*
749 * Setup Wake-on-Lan
750 */
751 switch (adapter->hw.mac.type) {
752
753 case e1000_82542:
754 case e1000_82543:
755 break;
756 case e1000_82546:
757 case e1000_82546_rev_3:
758 case e1000_82571:
759 case e1000_80003es2lan:
760 if (adapter->hw.bus.func == 1)
761 e1000_read_nvm(&adapter->hw,
762 NVM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
763 else
764 e1000_read_nvm(&adapter->hw,
765 NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
766 eeprom_data &= EM_EEPROM_APME;
767 break;
768 default:
769 /* APME bit in EEPROM is mapped to WUC.APME */
770 eeprom_data = E1000_READ_REG(&adapter->hw, E1000_WUC) &
771 E1000_WUC_APME;
772 break;
773 }
774 if (eeprom_data)
775 adapter->wol = E1000_WUFC_MAG;
776 /*
777 * We have the eeprom settings, now apply the special cases
778 * where the eeprom may be wrong or the board won't support
779 * wake on lan on a particular port
780 */
781 device_id = pci_get_device(dev);
782 switch (device_id) {
783 case E1000_DEV_ID_82546GB_PCIE:
784 adapter->wol = 0;
785 break;
786 case E1000_DEV_ID_82546EB_FIBER:
787 case E1000_DEV_ID_82546GB_FIBER:
788 case E1000_DEV_ID_82571EB_FIBER:
789 /* Wake events only supported on port A for dual fiber
790 * regardless of eeprom setting */
791 if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
792 E1000_STATUS_FUNC_1)
793 adapter->wol = 0;
794 break;
795 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
796 case E1000_DEV_ID_82571EB_QUAD_COPPER:
797 case E1000_DEV_ID_82571EB_QUAD_FIBER:
798 case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:
799 /* if quad port adapter, disable WoL on all but port A */
800 if (global_quad_port_a != 0)
801 adapter->wol = 0;
802 /* Reset for multiple quad port adapters */
803 if (++global_quad_port_a == 4)
804 global_quad_port_a = 0;
805 break;
806 }
807
808 /* Do we need workaround for 82544 PCI-X adapter? */
809 if (adapter->hw.bus.type == e1000_bus_type_pcix &&
810 adapter->hw.mac.type == e1000_82544)
811 adapter->pcix_82544 = TRUE;
812 else
813 adapter->pcix_82544 = FALSE;
814
815#if __FreeBSD_version >= 700029
816 /* Register for VLAN events */
817 adapter->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
818 em_register_vlan, adapter, EVENTHANDLER_PRI_FIRST);
819 adapter->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
820 em_unregister_vlan, adapter, EVENTHANDLER_PRI_FIRST);
821#endif
822
755 /* Do we need workaround for 82544 PCI-X adapter? */
756 if (adapter->hw.bus.type == e1000_bus_type_pcix &&
757 adapter->hw.mac.type == e1000_82544)
758 adapter->pcix_82544 = TRUE;
759 else
760 adapter->pcix_82544 = FALSE;
761
762#if __FreeBSD_version >= 700029
763 /* Register for VLAN events */
764 adapter->vlan_attach = EVENTHANDLER_REGISTER(vlan_config,
765 em_register_vlan, adapter, EVENTHANDLER_PRI_FIRST);
766 adapter->vlan_detach = EVENTHANDLER_REGISTER(vlan_unconfig,
767 em_unregister_vlan, adapter, EVENTHANDLER_PRI_FIRST);
768#endif
769
770 /* Non-AMT based hardware can now take control from firmware */
771 if (adapter->has_manage && !adapter->has_amt)
772 em_get_hw_control(adapter);
773
823 /* Tell the stack that the interface is not active */
824 adapter->ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
825
826 INIT_DEBUGOUT("em_attach: end");
827
828 return (0);
829
830err_rx_struct:

--- 50 unchanged lines hidden (view full) ---

881 EM_CORE_LOCK(adapter);
882 EM_TX_LOCK(adapter);
883 adapter->in_detach = 1;
884 em_stop(adapter);
885 e1000_phy_hw_reset(&adapter->hw);
886
887 em_release_manageability(adapter);
888
774 /* Tell the stack that the interface is not active */
775 adapter->ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
776
777 INIT_DEBUGOUT("em_attach: end");
778
779 return (0);
780
781err_rx_struct:

--- 50 unchanged lines hidden (view full) ---

832 EM_CORE_LOCK(adapter);
833 EM_TX_LOCK(adapter);
834 adapter->in_detach = 1;
835 em_stop(adapter);
836 e1000_phy_hw_reset(&adapter->hw);
837
838 em_release_manageability(adapter);
839
889 if (((adapter->hw.mac.type == e1000_82573) ||
890 (adapter->hw.mac.type == e1000_82583) ||
891 (adapter->hw.mac.type == e1000_ich8lan) ||
892 (adapter->hw.mac.type == e1000_ich10lan) ||
893 (adapter->hw.mac.type == e1000_ich9lan)) &&
894 e1000_check_mng_mode(&adapter->hw))
895 em_release_hw_control(adapter);
896
897 if (adapter->wol) {
898 E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
899 E1000_WRITE_REG(&adapter->hw, E1000_WUFC, adapter->wol);
900 em_enable_wakeup(dev);
901 }
902
903 EM_TX_UNLOCK(adapter);
904 EM_CORE_UNLOCK(adapter);
905
906#if __FreeBSD_version >= 700029
907 /* Unregister VLAN events */
908 if (adapter->vlan_attach != NULL)
909 EVENTHANDLER_DEREGISTER(vlan_config, adapter->vlan_attach);
910 if (adapter->vlan_detach != NULL)

--- 18 unchanged lines hidden (view full) ---

929 }
930
931 /* Free Receive Descriptor ring */
932 if (adapter->rx_desc_base) {
933 em_dma_free(adapter, &adapter->rxdma);
934 adapter->rx_desc_base = NULL;
935 }
936
840 EM_TX_UNLOCK(adapter);
841 EM_CORE_UNLOCK(adapter);
842
843#if __FreeBSD_version >= 700029
844 /* Unregister VLAN events */
845 if (adapter->vlan_attach != NULL)
846 EVENTHANDLER_DEREGISTER(vlan_config, adapter->vlan_attach);
847 if (adapter->vlan_detach != NULL)

--- 18 unchanged lines hidden (view full) ---

866 }
867
868 /* Free Receive Descriptor ring */
869 if (adapter->rx_desc_base) {
870 em_dma_free(adapter, &adapter->rxdma);
871 adapter->rx_desc_base = NULL;
872 }
873
874 em_release_hw_control(adapter);
937 EM_TX_LOCK_DESTROY(adapter);
938 EM_RX_LOCK_DESTROY(adapter);
939 EM_CORE_LOCK_DESTROY(adapter);
940
941 return (0);
942}
943
944/*********************************************************************

--- 13 unchanged lines hidden (view full) ---

958 */
959static int
960em_suspend(device_t dev)
961{
962 struct adapter *adapter = device_get_softc(dev);
963
964 EM_CORE_LOCK(adapter);
965
875 EM_TX_LOCK_DESTROY(adapter);
876 EM_RX_LOCK_DESTROY(adapter);
877 EM_CORE_LOCK_DESTROY(adapter);
878
879 return (0);
880}
881
882/*********************************************************************

--- 13 unchanged lines hidden (view full) ---

896 */
897static int
898em_suspend(device_t dev)
899{
900 struct adapter *adapter = device_get_softc(dev);
901
902 EM_CORE_LOCK(adapter);
903
966 EM_TX_LOCK(adapter);
967 em_stop(adapter);
968 EM_TX_UNLOCK(adapter);
969
970 em_release_manageability(adapter);
904 em_release_manageability(adapter);
905 em_release_hw_control(adapter);
906 em_enable_wakeup(dev);
971
907
972 if (((adapter->hw.mac.type == e1000_82573) ||
973 (adapter->hw.mac.type == e1000_82583) ||
974 (adapter->hw.mac.type == e1000_ich8lan) ||
975 (adapter->hw.mac.type == e1000_ich10lan) ||
976 (adapter->hw.mac.type == e1000_ich9lan)) &&
977 e1000_check_mng_mode(&adapter->hw))
978 em_release_hw_control(adapter);
979
980 if (adapter->wol) {
981 E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
982 E1000_WRITE_REG(&adapter->hw, E1000_WUFC, adapter->wol);
983 em_enable_wakeup(dev);
984 }
985
986 EM_CORE_UNLOCK(adapter);
987
988 return bus_generic_suspend(dev);
989}
990
991static int
992em_resume(device_t dev)
993{

--- 36 unchanged lines hidden (view full) ---

1030 if (((ifp->if_drv_flags & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) !=
1031 IFF_DRV_RUNNING)
1032 || (!adapter->link_active)) {
1033 error = drbr_enqueue(ifp, adapter->br, m);
1034 return (error);
1035 } else if (drbr_empty(ifp, adapter->br) &&
1036 (adapter->num_tx_desc_avail > EM_TX_OP_THRESHOLD)) {
1037 if ((error = em_xmit(adapter, &m)) != 0) {
908 EM_CORE_UNLOCK(adapter);
909
910 return bus_generic_suspend(dev);
911}
912
913static int
914em_resume(device_t dev)
915{

--- 36 unchanged lines hidden (view full) ---

952 if (((ifp->if_drv_flags & (IFF_DRV_RUNNING|IFF_DRV_OACTIVE)) !=
953 IFF_DRV_RUNNING)
954 || (!adapter->link_active)) {
955 error = drbr_enqueue(ifp, adapter->br, m);
956 return (error);
957 } else if (drbr_empty(ifp, adapter->br) &&
958 (adapter->num_tx_desc_avail > EM_TX_OP_THRESHOLD)) {
959 if ((error = em_xmit(adapter, &m)) != 0) {
1038 if (m != NULL)
960 if (m)
1039 error = drbr_enqueue(ifp, adapter->br, m);
1040 return (error);
1041 } else {
1042 /*
1043 * We've bypassed the buf ring so we need to update
1044 * ifp directly
1045 */
1046 drbr_stats_update(ifp, m->m_pkthdr.len, m->m_flags);
1047 /*
1048 ** Send a copy of the frame to the BPF
1049 ** listener and set the watchdog on.
1050 */
1051 ETHER_BPF_MTAP(ifp, m);
961 error = drbr_enqueue(ifp, adapter->br, m);
962 return (error);
963 } else {
964 /*
965 * We've bypassed the buf ring so we need to update
966 * ifp directly
967 */
968 drbr_stats_update(ifp, m->m_pkthdr.len, m->m_flags);
969 /*
970 ** Send a copy of the frame to the BPF
971 ** listener and set the watchdog on.
972 */
973 ETHER_BPF_MTAP(ifp, m);
1052 adapter->watchdog_timer = EM_TX_TIMEOUT;
974 adapter->watchdog_check = TRUE;
1053 }
1054 } else if ((error = drbr_enqueue(ifp, adapter->br, m)) != 0)
1055 return (error);
1056
1057process:
1058 if (drbr_empty(ifp, adapter->br))
1059 return(error);
1060 /* Process the queue */

--- 6 unchanged lines hidden (view full) ---

1067 if ((error = em_xmit(adapter, &next)) != 0) {
1068 if (next != NULL)
1069 error = drbr_enqueue(ifp, adapter->br, next);
1070 break;
1071 }
1072 drbr_stats_update(ifp, next->m_pkthdr.len, next->m_flags);
1073 ETHER_BPF_MTAP(ifp, next);
1074 /* Set the watchdog */
975 }
976 } else if ((error = drbr_enqueue(ifp, adapter->br, m)) != 0)
977 return (error);
978
979process:
980 if (drbr_empty(ifp, adapter->br))
981 return(error);
982 /* Process the queue */

--- 6 unchanged lines hidden (view full) ---

989 if ((error = em_xmit(adapter, &next)) != 0) {
990 if (next != NULL)
991 error = drbr_enqueue(ifp, adapter->br, next);
992 break;
993 }
994 drbr_stats_update(ifp, next->m_pkthdr.len, next->m_flags);
995 ETHER_BPF_MTAP(ifp, next);
996 /* Set the watchdog */
1075 adapter->watchdog_timer = EM_TX_TIMEOUT;
997 adapter->watchdog_check = TRUE;
1076 }
1077
1078 if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD)
1079 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1080
1081 return (error);
1082}
1083

--- 62 unchanged lines hidden (view full) ---

1146 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
1147 break;
1148 }
1149
1150 /* Send a copy of the frame to the BPF listener */
1151 ETHER_BPF_MTAP(ifp, m_head);
1152
1153 /* Set timeout in case hardware has problems transmitting. */
998 }
999
1000 if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD)
1001 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1002
1003 return (error);
1004}
1005

--- 62 unchanged lines hidden (view full) ---

1068 IFQ_DRV_PREPEND(&ifp->if_snd, m_head);
1069 break;
1070 }
1071
1072 /* Send a copy of the frame to the BPF listener */
1073 ETHER_BPF_MTAP(ifp, m_head);
1074
1075 /* Set timeout in case hardware has problems transmitting. */
1154 adapter->watchdog_timer = EM_TX_TIMEOUT;
1076 adapter->watchdog_check = TRUE;
1155 }
1156 if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD)
1157 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1158
1159 return;
1160}
1161
1162static void

--- 41 unchanged lines hidden (view full) ---

1204 * required.
1205 */
1206 ifp->if_flags |= IFF_UP;
1207 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1208 EM_CORE_LOCK(adapter);
1209 em_init_locked(adapter);
1210 EM_CORE_UNLOCK(adapter);
1211 }
1077 }
1078 if (adapter->num_tx_desc_avail <= EM_TX_OP_THRESHOLD)
1079 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1080
1081 return;
1082}
1083
1084static void

--- 41 unchanged lines hidden (view full) ---

1126 * required.
1127 */
1128 ifp->if_flags |= IFF_UP;
1129 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
1130 EM_CORE_LOCK(adapter);
1131 em_init_locked(adapter);
1132 EM_CORE_UNLOCK(adapter);
1133 }
1212 if (!(ifp->if_flags & IFF_NOARP))
1213 arp_ifinit(ifp, ifa);
1134 arp_ifinit(ifp, ifa);
1214 } else
1215#endif
1216 error = ether_ioctl(ifp, command, data);
1217 break;
1218 case SIOCSIFMTU:
1219 {
1220 int max_frame_size;
1221 u16 eeprom_data = 0;

--- 17 unchanged lines hidden (view full) ---

1239 case e1000_82571:
1240 case e1000_82572:
1241 case e1000_ich9lan:
1242 case e1000_ich10lan:
1243 case e1000_82574:
1244 case e1000_80003es2lan: /* Limit Jumbo Frame size */
1245 max_frame_size = 9234;
1246 break;
1135 } else
1136#endif
1137 error = ether_ioctl(ifp, command, data);
1138 break;
1139 case SIOCSIFMTU:
1140 {
1141 int max_frame_size;
1142 u16 eeprom_data = 0;

--- 17 unchanged lines hidden (view full) ---

1160 case e1000_82571:
1161 case e1000_82572:
1162 case e1000_ich9lan:
1163 case e1000_ich10lan:
1164 case e1000_82574:
1165 case e1000_80003es2lan: /* Limit Jumbo Frame size */
1166 max_frame_size = 9234;
1167 break;
1168 case e1000_pchlan:
1169 max_frame_size = 4096;
1170 break;
1247 /* Adapters that do not support jumbo frames */
1248 case e1000_82542:
1249 case e1000_82583:
1250 case e1000_ich8lan:
1251 max_frame_size = ETHER_MAX_LEN;
1252 break;
1253 default:
1254 max_frame_size = MAX_JUMBO_FRAME_SIZE;

--- 99 unchanged lines hidden (view full) ---

1354 reinit = 1;
1355 }
1356#if __FreeBSD_version >= 700000
1357 if (mask & IFCAP_TSO4) {
1358 ifp->if_capenable ^= IFCAP_TSO4;
1359 reinit = 1;
1360 }
1361#endif
1171 /* Adapters that do not support jumbo frames */
1172 case e1000_82542:
1173 case e1000_82583:
1174 case e1000_ich8lan:
1175 max_frame_size = ETHER_MAX_LEN;
1176 break;
1177 default:
1178 max_frame_size = MAX_JUMBO_FRAME_SIZE;

--- 99 unchanged lines hidden (view full) ---

1278 reinit = 1;
1279 }
1280#if __FreeBSD_version >= 700000
1281 if (mask & IFCAP_TSO4) {
1282 ifp->if_capenable ^= IFCAP_TSO4;
1283 reinit = 1;
1284 }
1285#endif
1362
1363 if (mask & IFCAP_VLAN_HWTAGGING) {
1364 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
1365 reinit = 1;
1366 }
1286 if (mask & IFCAP_VLAN_HWTAGGING) {
1287 ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
1288 reinit = 1;
1289 }
1290 if ((mask & IFCAP_WOL) &&
1291 (ifp->if_capabilities & IFCAP_WOL) != 0) {
1292 if (mask & IFCAP_WOL_MCAST)
1293 ifp->if_capenable ^= IFCAP_WOL_MCAST;
1294 if (mask & IFCAP_WOL_MAGIC)
1295 ifp->if_capenable ^= IFCAP_WOL_MAGIC;
1296 }
1367 if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING))
1368 em_init(adapter);
1369#if __FreeBSD_version >= 700000
1370 VLAN_CAPABILITIES(ifp);
1371#endif
1372 break;
1373 }
1374
1375 default:
1376 error = ether_ioctl(ifp, command, data);
1377 break;
1378 }
1379
1380 return (error);
1381}
1382
1297 if (reinit && (ifp->if_drv_flags & IFF_DRV_RUNNING))
1298 em_init(adapter);
1299#if __FreeBSD_version >= 700000
1300 VLAN_CAPABILITIES(ifp);
1301#endif
1302 break;
1303 }
1304
1305 default:
1306 error = ether_ioctl(ifp, command, data);
1307 break;
1308 }
1309
1310 return (error);
1311}
1312
1383/*********************************************************************
1384 * Watchdog timer:
1385 *
1386 * This routine is called from the local timer every second.
1387 * As long as transmit descriptors are being cleaned the value
1388 * is non-zero and we do nothing. Reaching 0 indicates a tx hang
1389 * and we then reset the device.
1390 *
1391 **********************************************************************/
1392
1313
1393static void
1394em_watchdog(struct adapter *adapter)
1395{
1396
1397 EM_CORE_LOCK_ASSERT(adapter);
1398
1399 /*
1400 ** The timer is set to 5 every time start queues a packet.
1401 ** Then txeof keeps resetting it as long as it cleans at
1402 ** least one descriptor.
1403 ** Finally, anytime all descriptors are clean the timer is
1404 ** set to 0.
1405 */
1406 EM_TX_LOCK(adapter);
1407 if ((adapter->watchdog_timer == 0) || (--adapter->watchdog_timer)) {
1408 EM_TX_UNLOCK(adapter);
1409 return;
1410 }
1411
1412 /* If we are in this routine because of pause frames, then
1413 * don't reset the hardware.
1414 */
1415 if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
1416 E1000_STATUS_TXOFF) {
1417 adapter->watchdog_timer = EM_TX_TIMEOUT;
1418 EM_TX_UNLOCK(adapter);
1419 return;
1420 }
1421
1422 if (e1000_check_for_link(&adapter->hw) == 0)
1423 device_printf(adapter->dev, "watchdog timeout -- resetting\n");
1424 adapter->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1425 adapter->watchdog_events++;
1426 EM_TX_UNLOCK(adapter);
1427
1428 em_init_locked(adapter);
1429}
1430
1431/*********************************************************************
1432 * Init entry point
1433 *
1434 * This routine is used in two ways. It is used by the stack as
1435 * init entry point in network interface structure. It is also used
1436 * by the driver as a hw/sw initialization routine to get to a
1437 * consistent state.
1438 *

--- 48 unchanged lines hidden (view full) ---

1487 pba = E1000_PBA_12K; /* 12K for Rx, 20K for Tx */
1488 break;
1489 case e1000_82574:
1490 case e1000_82583:
1491 pba = E1000_PBA_20K; /* 20K for Rx, 20K for Tx */
1492 break;
1493 case e1000_ich9lan:
1494 case e1000_ich10lan:
1314/*********************************************************************
1315 * Init entry point
1316 *
1317 * This routine is used in two ways. It is used by the stack as
1318 * init entry point in network interface structure. It is also used
1319 * by the driver as a hw/sw initialization routine to get to a
1320 * consistent state.
1321 *

--- 48 unchanged lines hidden (view full) ---

1370 pba = E1000_PBA_12K; /* 12K for Rx, 20K for Tx */
1371 break;
1372 case e1000_82574:
1373 case e1000_82583:
1374 pba = E1000_PBA_20K; /* 20K for Rx, 20K for Tx */
1375 break;
1376 case e1000_ich9lan:
1377 case e1000_ich10lan:
1378 case e1000_pchlan:
1379 pba = E1000_PBA_10K;
1380 break;
1495 case e1000_ich8lan:
1496 pba = E1000_PBA_8K;
1497 break;
1498 default:
1499 /* Devices before 82547 had a Packet Buffer of 64K. */
1500 if (adapter->max_frame_size > 8192)
1501 pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
1502 else

--- 106 unchanged lines hidden (view full) ---

1609 * they are off otherwise.
1610 */
1611 if (ifp->if_capenable & IFCAP_POLLING)
1612 em_disable_intr(adapter);
1613 else
1614#endif /* DEVICE_POLLING */
1615 em_enable_intr(adapter);
1616
1381 case e1000_ich8lan:
1382 pba = E1000_PBA_8K;
1383 break;
1384 default:
1385 /* Devices before 82547 had a Packet Buffer of 64K. */
1386 if (adapter->max_frame_size > 8192)
1387 pba = E1000_PBA_40K; /* 40K for Rx, 24K for Tx */
1388 else

--- 106 unchanged lines hidden (view full) ---

1495 * they are off otherwise.
1496 */
1497 if (ifp->if_capenable & IFCAP_POLLING)
1498 em_disable_intr(adapter);
1499 else
1500#endif /* DEVICE_POLLING */
1501 em_enable_intr(adapter);
1502
1503 /* AMT based hardware can now take control from firmware */
1504 if (adapter->has_manage && adapter->has_amt)
1505 em_get_hw_control(adapter);
1506
1617 /* Don't reset the phy next time init gets called */
1618 adapter->hw.phy.reset_disable = TRUE;
1619}
1620
1621static void
1622em_init(void *arg)
1623{
1624 struct adapter *adapter = arg;

--- 37 unchanged lines hidden (view full) ---

1662 rx_done = em_rxeof(adapter, count);
1663
1664 EM_TX_LOCK(adapter);
1665 em_txeof(adapter);
1666#if __FreeBSD_version >= 800000
1667 if (!drbr_empty(ifp, adapter->br))
1668 em_mq_start_locked(ifp, NULL);
1669#else
1507 /* Don't reset the phy next time init gets called */
1508 adapter->hw.phy.reset_disable = TRUE;
1509}
1510
1511static void
1512em_init(void *arg)
1513{
1514 struct adapter *adapter = arg;

--- 37 unchanged lines hidden (view full) ---

1552 rx_done = em_rxeof(adapter, count);
1553
1554 EM_TX_LOCK(adapter);
1555 em_txeof(adapter);
1556#if __FreeBSD_version >= 800000
1557 if (!drbr_empty(ifp, adapter->br))
1558 em_mq_start_locked(ifp, NULL);
1559#else
1670 if (!IFQ_DRV_IS_EMPTY(&ifp->snd))
1560 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1671 em_start_locked(ifp);
1672#endif
1673 EM_TX_UNLOCK(adapter);
1674 return (rx_done);
1675}
1676#endif /* DEVICE_POLLING */
1677
1678#ifdef EM_LEGACY_IRQ

--- 85 unchanged lines hidden (view full) ---

1764 taskqueue_enqueue(adapter->tq, &adapter->rxtx_task);
1765 EM_TX_LOCK(adapter);
1766 em_txeof(adapter);
1767
1768#if __FreeBSD_version >= 800000
1769 if (!drbr_empty(ifp, adapter->br))
1770 em_mq_start_locked(ifp, NULL);
1771#else
1561 em_start_locked(ifp);
1562#endif
1563 EM_TX_UNLOCK(adapter);
1564 return (rx_done);
1565}
1566#endif /* DEVICE_POLLING */
1567
1568#ifdef EM_LEGACY_IRQ

--- 85 unchanged lines hidden (view full) ---

1654 taskqueue_enqueue(adapter->tq, &adapter->rxtx_task);
1655 EM_TX_LOCK(adapter);
1656 em_txeof(adapter);
1657
1658#if __FreeBSD_version >= 800000
1659 if (!drbr_empty(ifp, adapter->br))
1660 em_mq_start_locked(ifp, NULL);
1661#else
1772 if (!IFQ_DRV_IS_EMPTY(&ifp->snd))
1662 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1773 em_start_locked(ifp);
1774#endif
1775 EM_TX_UNLOCK(adapter);
1776 }
1777
1778 em_enable_intr(adapter);
1779}
1780

--- 147 unchanged lines hidden (view full) ---

1928 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1929 if (!EM_TX_TRYLOCK(adapter))
1930 return;
1931 em_txeof(adapter);
1932#if __FreeBSD_version >= 800000
1933 if (!drbr_empty(ifp, adapter->br))
1934 em_mq_start_locked(ifp, NULL);
1935#else
1663 em_start_locked(ifp);
1664#endif
1665 EM_TX_UNLOCK(adapter);
1666 }
1667
1668 em_enable_intr(adapter);
1669}
1670

--- 147 unchanged lines hidden (view full) ---

1818 if (ifp->if_drv_flags & IFF_DRV_RUNNING) {
1819 if (!EM_TX_TRYLOCK(adapter))
1820 return;
1821 em_txeof(adapter);
1822#if __FreeBSD_version >= 800000
1823 if (!drbr_empty(ifp, adapter->br))
1824 em_mq_start_locked(ifp, NULL);
1825#else
1936 if (!IFQ_DRV_IS_EMPTY(&ifp->snd))
1826 if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
1937 em_start_locked(ifp);
1938#endif
1939 EM_TX_UNLOCK(adapter);
1940 }
1941}
1942#endif /* EM_FAST_IRQ */
1943
1944/*********************************************************************

--- 591 unchanged lines hidden (view full) ---

2536
2537 /* Allocate temporary memory to setup array */
2538 mta = malloc(sizeof(u8) *
2539 (ETH_ADDR_LEN * MAX_NUM_MULTICAST_ADDRESSES),
2540 M_DEVBUF, M_NOWAIT | M_ZERO);
2541 if (mta == NULL)
2542 panic("em_set_multi memory failure\n");
2543
1827 em_start_locked(ifp);
1828#endif
1829 EM_TX_UNLOCK(adapter);
1830 }
1831}
1832#endif /* EM_FAST_IRQ */
1833
1834/*********************************************************************

--- 591 unchanged lines hidden (view full) ---

2426
2427 /* Allocate temporary memory to setup array */
2428 mta = malloc(sizeof(u8) *
2429 (ETH_ADDR_LEN * MAX_NUM_MULTICAST_ADDRESSES),
2430 M_DEVBUF, M_NOWAIT | M_ZERO);
2431 if (mta == NULL)
2432 panic("em_set_multi memory failure\n");
2433
2434#if __FreeBSD_version < 800000
2435 IF_ADDR_LOCK(ifp);
2436#else
2544 if_maddr_rlock(ifp);
2437 if_maddr_rlock(ifp);
2438#endif
2545 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
2546 if (ifma->ifma_addr->sa_family != AF_LINK)
2547 continue;
2548
2549 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
2550 break;
2551
2552 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
2553 &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
2554 mcnt++;
2555 }
2439 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
2440 if (ifma->ifma_addr->sa_family != AF_LINK)
2441 continue;
2442
2443 if (mcnt == MAX_NUM_MULTICAST_ADDRESSES)
2444 break;
2445
2446 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
2447 &mta[mcnt * ETH_ADDR_LEN], ETH_ADDR_LEN);
2448 mcnt++;
2449 }
2450#if __FreeBSD_version < 800000
2451 IF_ADDR_UNLOCK(ifp);
2452#else
2556 if_maddr_runlock(ifp);
2453 if_maddr_runlock(ifp);
2557
2454#endif
2558 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
2559 reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2560 reg_rctl |= E1000_RCTL_MPE;
2561 E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2562 } else
2563 e1000_update_mc_addr_list(&adapter->hw, mta, mcnt);
2564
2565 if (adapter->hw.mac.type == e1000_82542 &&

--- 34 unchanged lines hidden (view full) ---

2600 e1000_rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
2601
2602 if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING)
2603 em_print_hw_stats(adapter);
2604
2605 em_smartspeed(adapter);
2606
2607 /*
2455 if (mcnt >= MAX_NUM_MULTICAST_ADDRESSES) {
2456 reg_rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
2457 reg_rctl |= E1000_RCTL_MPE;
2458 E1000_WRITE_REG(&adapter->hw, E1000_RCTL, reg_rctl);
2459 } else
2460 e1000_update_mc_addr_list(&adapter->hw, mta, mcnt);
2461
2462 if (adapter->hw.mac.type == e1000_82542 &&

--- 34 unchanged lines hidden (view full) ---

2497 e1000_rar_set(&adapter->hw, adapter->hw.mac.addr, 0);
2498
2499 if (em_display_debug_stats && ifp->if_drv_flags & IFF_DRV_RUNNING)
2500 em_print_hw_stats(adapter);
2501
2502 em_smartspeed(adapter);
2503
2504 /*
2608 * Each second we check the watchdog to
2609 * protect against hardware hangs.
2505 * We check the watchdog: the time since
2506 * the last TX descriptor was cleaned.
2507 * This implies a functional TX engine.
2610 */
2508 */
2611 em_watchdog(adapter);
2509 if ((adapter->watchdog_check == TRUE) &&
2510 (ticks - adapter->watchdog_time > EM_WATCHDOG))
2511 goto hung;
2612
2613 callout_reset(&adapter->timer, hz, em_local_timer, adapter);
2512
2513 callout_reset(&adapter->timer, hz, em_local_timer, adapter);
2614
2514 return;
2515hung:
2516 device_printf(adapter->dev, "Watchdog timeout -- resetting\n");
2517 adapter->ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
2518 adapter->watchdog_events++;
2519 em_init_locked(adapter);
2615}
2616
2617static void
2618em_update_link_status(struct adapter *adapter)
2619{
2620 struct e1000_hw *hw = &adapter->hw;
2621 struct ifnet *ifp = adapter->ifp;
2622 device_t dev = adapter->dev;

--- 49 unchanged lines hidden (view full) ---

2672 if_link_state_change(ifp, LINK_STATE_UP);
2673 } else if (!link_check && (adapter->link_active == 1)) {
2674 ifp->if_baudrate = adapter->link_speed = 0;
2675 adapter->link_duplex = 0;
2676 if (bootverbose)
2677 device_printf(dev, "Link is Down\n");
2678 adapter->link_active = 0;
2679 /* Link down, disable watchdog */
2520}
2521
2522static void
2523em_update_link_status(struct adapter *adapter)
2524{
2525 struct e1000_hw *hw = &adapter->hw;
2526 struct ifnet *ifp = adapter->ifp;
2527 device_t dev = adapter->dev;

--- 49 unchanged lines hidden (view full) ---

2577 if_link_state_change(ifp, LINK_STATE_UP);
2578 } else if (!link_check && (adapter->link_active == 1)) {
2579 ifp->if_baudrate = adapter->link_speed = 0;
2580 adapter->link_duplex = 0;
2581 if (bootverbose)
2582 device_printf(dev, "Link is Down\n");
2583 adapter->link_active = 0;
2584 /* Link down, disable watchdog */
2680 adapter->watchdog_timer = FALSE;
2585 adapter->watchdog_check = FALSE;
2681 if_link_state_change(ifp, LINK_STATE_DOWN);
2682 }
2683}
2684
2685/*********************************************************************
2686 *
2687 * This routine disables all traffic on the adapter by issuing a
2688 * global reset on the MAC and deallocates TX/RX buffers.

--- 399 unchanged lines hidden (view full) ---

3088 device_t dev = adapter->dev;
3089 u16 rx_buffer_size;
3090
3091 INIT_DEBUGOUT("em_hardware_init: begin");
3092
3093 /* Issue a global reset */
3094 e1000_reset_hw(&adapter->hw);
3095
2586 if_link_state_change(ifp, LINK_STATE_DOWN);
2587 }
2588}
2589
2590/*********************************************************************
2591 *
2592 * This routine disables all traffic on the adapter by issuing a
2593 * global reset on the MAC and deallocates TX/RX buffers.

--- 399 unchanged lines hidden (view full) ---

2993 device_t dev = adapter->dev;
2994 u16 rx_buffer_size;
2995
2996 INIT_DEBUGOUT("em_hardware_init: begin");
2997
2998 /* Issue a global reset */
2999 e1000_reset_hw(&adapter->hw);
3000
3096 /* Get control from any management/hw control */
3097 if (((adapter->hw.mac.type == e1000_82573) ||
3098 (adapter->hw.mac.type == e1000_82583) ||
3099 (adapter->hw.mac.type == e1000_ich8lan) ||
3100 (adapter->hw.mac.type == e1000_ich10lan) ||
3101 (adapter->hw.mac.type == e1000_ich9lan)) &&
3102 e1000_check_mng_mode(&adapter->hw))
3103 em_get_hw_control(adapter);
3104
3105 /* When hardware is reset, fifo_head is also reset */
3106 adapter->tx_fifo_head = 0;
3107
3108 /* Set up smart power down as default off on newer adapters. */
3109 if (!em_smart_pwr_down && (adapter->hw.mac.type == e1000_82571 ||
3110 adapter->hw.mac.type == e1000_82572)) {
3111 u16 phy_tmp = 0;
3112

--- 33 unchanged lines hidden (view full) ---

3146 adapter->hw.fc.send_xon = TRUE;
3147
3148 /* Set Flow control, use the tunable location if sane */
3149 if ((em_fc_setting >= 0) || (em_fc_setting < 4))
3150 adapter->hw.fc.requested_mode = em_fc_setting;
3151 else
3152 adapter->hw.fc.requested_mode = e1000_fc_none;
3153
3001 /* When hardware is reset, fifo_head is also reset */
3002 adapter->tx_fifo_head = 0;
3003
3004 /* Set up smart power down as default off on newer adapters. */
3005 if (!em_smart_pwr_down && (adapter->hw.mac.type == e1000_82571 ||
3006 adapter->hw.mac.type == e1000_82572)) {
3007 u16 phy_tmp = 0;
3008

--- 33 unchanged lines hidden (view full) ---

3042 adapter->hw.fc.send_xon = TRUE;
3043
3044 /* Set Flow control, use the tunable location if sane */
3045 if ((em_fc_setting >= 0) || (em_fc_setting < 4))
3046 adapter->hw.fc.requested_mode = em_fc_setting;
3047 else
3048 adapter->hw.fc.requested_mode = e1000_fc_none;
3049
3050 /* Override - workaround for PCHLAN issue */
3051 if (adapter->hw.mac.type == e1000_pchlan)
3052 adapter->hw.fc.requested_mode = e1000_fc_rx_pause;
3154
3155 if (e1000_init_hw(&adapter->hw) < 0) {
3156 device_printf(dev, "Hardware Initialization Failed\n");
3157 return (EIO);
3158 }
3159
3160 e1000_check_for_link(&adapter->hw);
3161

--- 66 unchanged lines hidden (view full) ---

3228 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
3229 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
3230 ifp->if_capenable |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
3231
3232#ifdef DEVICE_POLLING
3233 ifp->if_capabilities |= IFCAP_POLLING;
3234#endif
3235
3053
3054 if (e1000_init_hw(&adapter->hw) < 0) {
3055 device_printf(dev, "Hardware Initialization Failed\n");
3056 return (EIO);
3057 }
3058
3059 e1000_check_for_link(&adapter->hw);
3060

--- 66 unchanged lines hidden (view full) ---

3127 ifp->if_data.ifi_hdrlen = sizeof(struct ether_vlan_header);
3128 ifp->if_capabilities |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
3129 ifp->if_capenable |= IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_MTU;
3130
3131#ifdef DEVICE_POLLING
3132 ifp->if_capabilities |= IFCAP_POLLING;
3133#endif
3134
3135 /* Enable All WOL methods by default */
3136 if (adapter->wol) {
3137 ifp->if_capabilities |= IFCAP_WOL;
3138 ifp->if_capenable |= IFCAP_WOL;
3139 }
3140
3236 /*
3237 * Specify the media types supported by this adapter and register
3238 * callbacks to update media and link information
3239 */
3240 ifmedia_init(&adapter->media, IFM_IMASK,
3241 em_media_change, em_media_status);
3242 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) ||
3243 (adapter->hw.phy.media_type == e1000_media_type_internal_serdes)) {

--- 50 unchanged lines hidden (view full) ---

3294 e1000_read_phy_reg(&adapter->hw,
3295 PHY_1000T_CTRL, &phy_tmp);
3296 if(phy_tmp & CR_1000T_MS_ENABLE) {
3297 phy_tmp &= ~CR_1000T_MS_ENABLE;
3298 e1000_write_phy_reg(&adapter->hw,
3299 PHY_1000T_CTRL, phy_tmp);
3300 adapter->smartspeed++;
3301 if(adapter->hw.mac.autoneg &&
3141 /*
3142 * Specify the media types supported by this adapter and register
3143 * callbacks to update media and link information
3144 */
3145 ifmedia_init(&adapter->media, IFM_IMASK,
3146 em_media_change, em_media_status);
3147 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) ||
3148 (adapter->hw.phy.media_type == e1000_media_type_internal_serdes)) {

--- 50 unchanged lines hidden (view full) ---

3199 e1000_read_phy_reg(&adapter->hw,
3200 PHY_1000T_CTRL, &phy_tmp);
3201 if(phy_tmp & CR_1000T_MS_ENABLE) {
3202 phy_tmp &= ~CR_1000T_MS_ENABLE;
3203 e1000_write_phy_reg(&adapter->hw,
3204 PHY_1000T_CTRL, phy_tmp);
3205 adapter->smartspeed++;
3206 if(adapter->hw.mac.autoneg &&
3302 !e1000_phy_setup_autoneg(&adapter->hw) &&
3207 !e1000_copper_link_autoneg(&adapter->hw) &&
3303 !e1000_read_phy_reg(&adapter->hw,
3304 PHY_CONTROL, &phy_tmp)) {
3305 phy_tmp |= (MII_CR_AUTO_NEG_EN |
3306 MII_CR_RESTART_AUTO_NEG);
3307 e1000_write_phy_reg(&adapter->hw,
3308 PHY_CONTROL, phy_tmp);
3309 }
3310 }
3311 }
3312 return;
3313 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
3314 /* If still no link, perhaps using 2/3 pair cable */
3315 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3316 phy_tmp |= CR_1000T_MS_ENABLE;
3317 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
3318 if(adapter->hw.mac.autoneg &&
3208 !e1000_read_phy_reg(&adapter->hw,
3209 PHY_CONTROL, &phy_tmp)) {
3210 phy_tmp |= (MII_CR_AUTO_NEG_EN |
3211 MII_CR_RESTART_AUTO_NEG);
3212 e1000_write_phy_reg(&adapter->hw,
3213 PHY_CONTROL, phy_tmp);
3214 }
3215 }
3216 }
3217 return;
3218 } else if(adapter->smartspeed == EM_SMARTSPEED_DOWNSHIFT) {
3219 /* If still no link, perhaps using 2/3 pair cable */
3220 e1000_read_phy_reg(&adapter->hw, PHY_1000T_CTRL, &phy_tmp);
3221 phy_tmp |= CR_1000T_MS_ENABLE;
3222 e1000_write_phy_reg(&adapter->hw, PHY_1000T_CTRL, phy_tmp);
3223 if(adapter->hw.mac.autoneg &&
3319 !e1000_phy_setup_autoneg(&adapter->hw) &&
3224 !e1000_copper_link_autoneg(&adapter->hw) &&
3320 !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL, &phy_tmp)) {
3321 phy_tmp |= (MII_CR_AUTO_NEG_EN |
3322 MII_CR_RESTART_AUTO_NEG);
3323 e1000_write_phy_reg(&adapter->hw, PHY_CONTROL, phy_tmp);
3324 }
3325 }
3326 /* Restart process after EM_SMARTSPEED_MAX iterations */
3327 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)

--- 642 unchanged lines hidden (view full) ---

3970 * processing the packet then free associated resources. The
3971 * tx_buffer is put back on the free queue.
3972 *
3973 **********************************************************************/
3974static void
3975em_txeof(struct adapter *adapter)
3976{
3977 int first, last, done, num_avail;
3225 !e1000_read_phy_reg(&adapter->hw, PHY_CONTROL, &phy_tmp)) {
3226 phy_tmp |= (MII_CR_AUTO_NEG_EN |
3227 MII_CR_RESTART_AUTO_NEG);
3228 e1000_write_phy_reg(&adapter->hw, PHY_CONTROL, phy_tmp);
3229 }
3230 }
3231 /* Restart process after EM_SMARTSPEED_MAX iterations */
3232 if(adapter->smartspeed++ == EM_SMARTSPEED_MAX)

--- 642 unchanged lines hidden (view full) ---

3875 * processing the packet then free associated resources. The
3876 * tx_buffer is put back on the free queue.
3877 *
3878 **********************************************************************/
3879static void
3880em_txeof(struct adapter *adapter)
3881{
3882 int first, last, done, num_avail;
3978 u32 cleaned = 0;
3979 struct em_buffer *tx_buffer;
3980 struct e1000_tx_desc *tx_desc, *eop_desc;
3981 struct ifnet *ifp = adapter->ifp;
3982
3983 EM_TX_LOCK_ASSERT(adapter);
3984
3985 if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
3986 return;

--- 19 unchanged lines hidden (view full) ---

4006 BUS_DMASYNC_POSTREAD);
4007
4008 while (eop_desc->upper.fields.status & E1000_TXD_STAT_DD) {
4009 /* We clean the range of the packet */
4010 while (first != done) {
4011 tx_desc->upper.data = 0;
4012 tx_desc->lower.data = 0;
4013 tx_desc->buffer_addr = 0;
3883 struct em_buffer *tx_buffer;
3884 struct e1000_tx_desc *tx_desc, *eop_desc;
3885 struct ifnet *ifp = adapter->ifp;
3886
3887 EM_TX_LOCK_ASSERT(adapter);
3888
3889 if (adapter->num_tx_desc_avail == adapter->num_tx_desc)
3890 return;

--- 19 unchanged lines hidden (view full) ---

3910 BUS_DMASYNC_POSTREAD);
3911
3912 while (eop_desc->upper.fields.status & E1000_TXD_STAT_DD) {
3913 /* We clean the range of the packet */
3914 while (first != done) {
3915 tx_desc->upper.data = 0;
3916 tx_desc->lower.data = 0;
3917 tx_desc->buffer_addr = 0;
4014 ++num_avail; ++cleaned;
3918 ++num_avail;
4015
4016 if (tx_buffer->m_head) {
4017 ifp->if_opackets++;
4018 bus_dmamap_sync(adapter->txtag,
4019 tx_buffer->map,
4020 BUS_DMASYNC_POSTWRITE);
4021 bus_dmamap_unload(adapter->txtag,
4022 tx_buffer->map);
4023
4024 m_freem(tx_buffer->m_head);
4025 tx_buffer->m_head = NULL;
4026 }
4027 tx_buffer->next_eop = -1;
3919
3920 if (tx_buffer->m_head) {
3921 ifp->if_opackets++;
3922 bus_dmamap_sync(adapter->txtag,
3923 tx_buffer->map,
3924 BUS_DMASYNC_POSTWRITE);
3925 bus_dmamap_unload(adapter->txtag,
3926 tx_buffer->map);
3927
3928 m_freem(tx_buffer->m_head);
3929 tx_buffer->m_head = NULL;
3930 }
3931 tx_buffer->next_eop = -1;
3932 adapter->watchdog_time = ticks;
4028
4029 if (++first == adapter->num_tx_desc)
4030 first = 0;
4031
4032 tx_buffer = &adapter->tx_buffer_area[first];
4033 tx_desc = &adapter->tx_desc_base[first];
4034 }
4035 /* See if we can continue to the next packet */

--- 9 unchanged lines hidden (view full) ---

4045 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
4046 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
4047
4048 adapter->next_tx_to_clean = first;
4049
4050 /*
4051 * If we have enough room, clear IFF_DRV_OACTIVE to
4052 * tell the stack that it is OK to send packets.
3933
3934 if (++first == adapter->num_tx_desc)
3935 first = 0;
3936
3937 tx_buffer = &adapter->tx_buffer_area[first];
3938 tx_desc = &adapter->tx_desc_base[first];
3939 }
3940 /* See if we can continue to the next packet */

--- 9 unchanged lines hidden (view full) ---

3950 bus_dmamap_sync(adapter->txdma.dma_tag, adapter->txdma.dma_map,
3951 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
3952
3953 adapter->next_tx_to_clean = first;
3954
3955 /*
3956 * If we have enough room, clear IFF_DRV_OACTIVE to
3957 * tell the stack that it is OK to send packets.
4053 * If there are no pending descriptors, clear the timeout.
3958 * If there are no pending descriptors, clear the watchdog.
4054 */
4055 if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
4056 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4057 if (num_avail == adapter->num_tx_desc) {
3959 */
3960 if (num_avail > EM_TX_CLEANUP_THRESHOLD) {
3961 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
3962 if (num_avail == adapter->num_tx_desc) {
4058 adapter->watchdog_timer = 0;
3963 adapter->watchdog_check = FALSE;
4059 adapter->num_tx_desc_avail = num_avail;
4060 return;
4061 }
4062 }
4063
3964 adapter->num_tx_desc_avail = num_avail;
3965 return;
3966 }
3967 }
3968
4064 /* If any descriptors cleaned, reset the watchdog */
4065 if (cleaned)
4066 adapter->watchdog_timer = EM_TX_TIMEOUT;
4067 adapter->num_tx_desc_avail = num_avail;
4068 return;
4069}
4070
4071/*********************************************************************
4072 *
4073 * When Link is lost sometimes there is work still in the TX ring
3969 adapter->num_tx_desc_avail = num_avail;
3970 return;
3971}
3972
3973/*********************************************************************
3974 *
3975 * When Link is lost sometimes there is work still in the TX ring
4074 * which will result in a watchdog, rather than allow that do an
3976 * which may result in a watchdog, rather than allow that we do an
4075 * attempted cleanup and then reinit here. Note that this has been
4076 * seens mostly with fiber adapters.
4077 *
4078 **********************************************************************/
4079static void
4080em_tx_purge(struct adapter *adapter)
4081{
3977 * attempted cleanup and then reinit here. Note that this has been
3978 * seens mostly with fiber adapters.
3979 *
3980 **********************************************************************/
3981static void
3982em_tx_purge(struct adapter *adapter)
3983{
4082 if ((!adapter->link_active) && (adapter->watchdog_timer)) {
3984 if ((!adapter->link_active) && (adapter->watchdog_check)) {
4083 EM_TX_LOCK(adapter);
4084 em_txeof(adapter);
4085 EM_TX_UNLOCK(adapter);
3985 EM_TX_LOCK(adapter);
3986 em_txeof(adapter);
3987 EM_TX_UNLOCK(adapter);
4086 if (adapter->watchdog_timer) { /* Still not clean? */
4087 adapter->watchdog_timer = 0;
3988 if (adapter->watchdog_check) /* Still outstanding? */
4088 em_init_locked(adapter);
3989 em_init_locked(adapter);
4089 }
4090 }
4091}
4092
4093/*********************************************************************
4094 *
4095 * Get a buffer from system mbuf buffer pool.
4096 *
4097 **********************************************************************/

--- 774 unchanged lines hidden (view full) ---

4872 if (adapter->hw.mac.type >= e1000_82571)
4873 manc &= ~E1000_MANC_EN_MNG2HOST;
4874
4875 E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4876 }
4877}
4878
4879/*
3990 }
3991}
3992
3993/*********************************************************************
3994 *
3995 * Get a buffer from system mbuf buffer pool.
3996 *
3997 **********************************************************************/

--- 774 unchanged lines hidden (view full) ---

4772 if (adapter->hw.mac.type >= e1000_82571)
4773 manc &= ~E1000_MANC_EN_MNG2HOST;
4774
4775 E1000_WRITE_REG(&adapter->hw, E1000_MANC, manc);
4776 }
4777}
4778
4779/*
4880 * em_get_hw_control sets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4881 * For ASF and Pass Through versions of f/w this means that
4882 * the driver is loaded. For AMT version (only with 82573)
4883 * of the f/w this means that the network i/f is open.
4884 *
4780 * em_get_hw_control sets the {CTRL_EXT|FWSM}:DRV_LOAD bit.
4781 * For ASF and Pass Through versions of f/w this means
4782 * that the driver is loaded. For AMT version type f/w
4783 * this means that the network i/f is open.
4885 */
4886static void
4887em_get_hw_control(struct adapter *adapter)
4888{
4889 u32 ctrl_ext, swsm;
4890
4784 */
4785static void
4786em_get_hw_control(struct adapter *adapter)
4787{
4788 u32 ctrl_ext, swsm;
4789
4891 /* Let firmware know the driver has taken over */
4892 switch (adapter->hw.mac.type) {
4893 case e1000_82573:
4790 if (adapter->hw.mac.type == e1000_82573) {
4894 swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4895 E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4896 swsm | E1000_SWSM_DRV_LOAD);
4791 swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4792 E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4793 swsm | E1000_SWSM_DRV_LOAD);
4897 break;
4898 case e1000_82571:
4899 case e1000_82572:
4900 case e1000_80003es2lan:
4901 case e1000_ich8lan:
4902 case e1000_ich9lan:
4903 case e1000_ich10lan:
4904 ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4905 E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4906 ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
4907 break;
4908 default:
4909 break;
4794 return;
4910 }
4795 }
4796 /* else */
4797 ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4798 E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4799 ctrl_ext | E1000_CTRL_EXT_DRV_LOAD);
4800 return;
4911}
4912
4913/*
4914 * em_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4801}
4802
4803/*
4804 * em_release_hw_control resets {CTRL_EXT|FWSM}:DRV_LOAD bit.
4915 * For ASF and Pass Through versions of f/w this means that the
4916 * driver is no longer loaded. For AMT version (only with 82573) i
4917 * of the f/w this means that the network i/f is closed.
4918 *
4805 * For ASF and Pass Through versions of f/w this means that
4806 * the driver is no longer loaded. For AMT versions of the
4807 * f/w this means that the network i/f is closed.
4919 */
4920static void
4921em_release_hw_control(struct adapter *adapter)
4922{
4923 u32 ctrl_ext, swsm;
4924
4808 */
4809static void
4810em_release_hw_control(struct adapter *adapter)
4811{
4812 u32 ctrl_ext, swsm;
4813
4925 /* Let firmware taken over control of h/w */
4926 switch (adapter->hw.mac.type) {
4927 case e1000_82573:
4814 if (!adapter->has_manage)
4815 return;
4816
4817 if (adapter->hw.mac.type == e1000_82573) {
4928 swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4929 E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4930 swsm & ~E1000_SWSM_DRV_LOAD);
4818 swsm = E1000_READ_REG(&adapter->hw, E1000_SWSM);
4819 E1000_WRITE_REG(&adapter->hw, E1000_SWSM,
4820 swsm & ~E1000_SWSM_DRV_LOAD);
4931 break;
4932 case e1000_82571:
4933 case e1000_82572:
4934 case e1000_80003es2lan:
4935 case e1000_ich8lan:
4936 case e1000_ich9lan:
4937 case e1000_ich10lan:
4938 ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4939 E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4940 ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
4941 break;
4942 default:
4943 break;
4944
4821 return;
4945 }
4822 }
4823 /* else */
4824 ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4825 E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT,
4826 ctrl_ext & ~E1000_CTRL_EXT_DRV_LOAD);
4827 return;
4946}
4947
4948static int
4949em_is_valid_ether_addr(u8 *addr)
4950{
4951 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
4952
4953 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
4954 return (FALSE);
4955 }
4956
4957 return (TRUE);
4958}
4959
4960/*
4828}
4829
4830static int
4831em_is_valid_ether_addr(u8 *addr)
4832{
4833 char zero_addr[6] = { 0, 0, 0, 0, 0, 0 };
4834
4835 if ((addr[0] & 1) || (!bcmp(addr, zero_addr, ETHER_ADDR_LEN))) {
4836 return (FALSE);
4837 }
4838
4839 return (TRUE);
4840}
4841
4842/*
4843** Parse the interface capabilities with regard
4844** to both system management and wake-on-lan for
4845** later use.
4846*/
4847static void
4848em_get_wakeup(device_t dev)
4849{
4850 struct adapter *adapter = device_get_softc(dev);
4851 u16 eeprom_data = 0, device_id, apme_mask;
4852
4853 adapter->has_manage = e1000_enable_mng_pass_thru(&adapter->hw);
4854 apme_mask = EM_EEPROM_APME;
4855
4856 switch (adapter->hw.mac.type) {
4857 case e1000_82542:
4858 case e1000_82543:
4859 break;
4860 case e1000_82544:
4861 e1000_read_nvm(&adapter->hw,
4862 NVM_INIT_CONTROL2_REG, 1, &eeprom_data);
4863 apme_mask = EM_82544_APME;
4864 break;
4865 case e1000_82573:
4866 case e1000_82583:
4867 adapter->has_amt = TRUE;
4868 /* Falls thru */
4869 case e1000_82546:
4870 case e1000_82546_rev_3:
4871 case e1000_82571:
4872 case e1000_82572:
4873 case e1000_80003es2lan:
4874 if (adapter->hw.bus.func == 1) {
4875 e1000_read_nvm(&adapter->hw,
4876 NVM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
4877 break;
4878 } else
4879 e1000_read_nvm(&adapter->hw,
4880 NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
4881 break;
4882 case e1000_ich8lan:
4883 case e1000_ich9lan:
4884 case e1000_ich10lan:
4885 case e1000_pchlan:
4886 apme_mask = E1000_WUC_APME;
4887 adapter->has_amt = TRUE;
4888 eeprom_data = E1000_READ_REG(&adapter->hw, E1000_WUC);
4889 break;
4890 default:
4891 e1000_read_nvm(&adapter->hw,
4892 NVM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
4893 break;
4894 }
4895 if (eeprom_data & apme_mask)
4896 adapter->wol = (E1000_WUFC_MAG | E1000_WUFC_MC);
4897 /*
4898 * We have the eeprom settings, now apply the special cases
4899 * where the eeprom may be wrong or the board won't support
4900 * wake on lan on a particular port
4901 */
4902 device_id = pci_get_device(dev);
4903 switch (device_id) {
4904 case E1000_DEV_ID_82546GB_PCIE:
4905 adapter->wol = 0;
4906 break;
4907 case E1000_DEV_ID_82546EB_FIBER:
4908 case E1000_DEV_ID_82546GB_FIBER:
4909 case E1000_DEV_ID_82571EB_FIBER:
4910 /* Wake events only supported on port A for dual fiber
4911 * regardless of eeprom setting */
4912 if (E1000_READ_REG(&adapter->hw, E1000_STATUS) &
4913 E1000_STATUS_FUNC_1)
4914 adapter->wol = 0;
4915 break;
4916 case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
4917 case E1000_DEV_ID_82571EB_QUAD_COPPER:
4918 case E1000_DEV_ID_82571EB_QUAD_FIBER:
4919 case E1000_DEV_ID_82571EB_QUAD_COPPER_LP:
4920 /* if quad port adapter, disable WoL on all but port A */
4921 if (global_quad_port_a != 0)
4922 adapter->wol = 0;
4923 /* Reset for multiple quad port adapters */
4924 if (++global_quad_port_a == 4)
4925 global_quad_port_a = 0;
4926 break;
4927 }
4928 return;
4929}
4930
4931
4932/*
4961 * Enable PCI Wake On Lan capability
4962 */
4963void
4964em_enable_wakeup(device_t dev)
4965{
4933 * Enable PCI Wake On Lan capability
4934 */
4935void
4936em_enable_wakeup(device_t dev)
4937{
4966 u16 cap, status;
4967 u8 id;
4938 struct adapter *adapter = device_get_softc(dev);
4939 struct ifnet *ifp = adapter->ifp;
4940 u32 pmc, ctrl, ctrl_ext, rctl;
4941 u16 status;
4968
4942
4969 /* First find the capabilities pointer*/
4970 cap = pci_read_config(dev, PCIR_CAP_PTR, 2);
4971 /* Read the PM Capabilities */
4972 id = pci_read_config(dev, cap, 1);
4973 if (id != PCIY_PMG) /* Something wrong */
4943 if ((pci_find_extcap(dev, PCIY_PMG, &pmc) != 0))
4974 return;
4944 return;
4975 /* OK, we have the power capabilities, so
4976 now get the status register */
4977 cap += PCIR_POWER_STATUS;
4978 status = pci_read_config(dev, cap, 2);
4979 status |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
4980 pci_write_config(dev, cap, status, 2);
4945
4946 /* Advertise the wakeup capability */
4947 ctrl = E1000_READ_REG(&adapter->hw, E1000_CTRL);
4948 ctrl |= (E1000_CTRL_SWDPIN2 | E1000_CTRL_SWDPIN3);
4949 E1000_WRITE_REG(&adapter->hw, E1000_CTRL, ctrl);
4950 E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
4951
4952 /* ICH workaround code */
4953 if ((adapter->hw.mac.type == e1000_ich8lan) ||
4954 (adapter->hw.mac.type == e1000_pchlan) ||
4955 (adapter->hw.mac.type == e1000_ich9lan) ||
4956 (adapter->hw.mac.type == e1000_ich10lan)) {
4957 e1000_disable_gig_wol_ich8lan(&adapter->hw);
4958 e1000_hv_phy_powerdown_workaround_ich8lan(&adapter->hw);
4959 }
4960
4961 /* Keep the laser running on Fiber adapters */
4962 if (adapter->hw.phy.media_type == e1000_media_type_fiber ||
4963 adapter->hw.phy.media_type == e1000_media_type_internal_serdes) {
4964 ctrl_ext = E1000_READ_REG(&adapter->hw, E1000_CTRL_EXT);
4965 ctrl_ext |= E1000_CTRL_EXT_SDP3_DATA;
4966 E1000_WRITE_REG(&adapter->hw, E1000_CTRL_EXT, ctrl_ext);
4967 }
4968
4969 /*
4970 ** Determine type of Wakeup: note that wol
4971 ** is set with all bits on by default.
4972 */
4973 if ((ifp->if_capenable & IFCAP_WOL_MAGIC) == 0)
4974 adapter->wol &= ~E1000_WUFC_MAG;
4975
4976 if ((ifp->if_capenable & IFCAP_WOL_MCAST) == 0)
4977 adapter->wol &= ~E1000_WUFC_MC;
4978 else {
4979 rctl = E1000_READ_REG(&adapter->hw, E1000_RCTL);
4980 rctl |= E1000_RCTL_MPE;
4981 E1000_WRITE_REG(&adapter->hw, E1000_RCTL, rctl);
4982 }
4983
4984 if (adapter->hw.mac.type == e1000_pchlan) {
4985 if (em_enable_phy_wakeup(adapter))
4986 return;
4987 } else {
4988 E1000_WRITE_REG(&adapter->hw, E1000_WUC, E1000_WUC_PME_EN);
4989 E1000_WRITE_REG(&adapter->hw, E1000_WUFC, adapter->wol);
4990 }
4991
4992 if (adapter->hw.phy.type == e1000_phy_igp_3)
4993 e1000_igp3_phy_powerdown_workaround_ich8lan(&adapter->hw);
4994
4995 /* Request PME */
4996 status = pci_read_config(dev, pmc + PCIR_POWER_STATUS, 2);
4997 status &= ~(PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE);
4998 if (ifp->if_capenable & IFCAP_WOL)
4999 status |= PCIM_PSTAT_PME | PCIM_PSTAT_PMEENABLE;
5000 pci_write_config(dev, pmc + PCIR_POWER_STATUS, status, 2);
5001
4981 return;
4982}
4983
5002 return;
5003}
5004
5005/*
5006** WOL in the newer chipset interfaces (pchlan)
5007** require thing to be copied into the phy
5008*/
5009static int
5010em_enable_phy_wakeup(struct adapter *adapter)
5011{
5012 struct e1000_hw *hw = &adapter->hw;
5013 u32 mreg, ret = 0;
5014 u16 preg;
4984
5015
5016 /* copy MAC RARs to PHY RARs */
5017 for (int i = 0; i < adapter->hw.mac.rar_entry_count; i++) {
5018 mreg = E1000_READ_REG(hw, E1000_RAL(i));
5019 e1000_write_phy_reg(hw, BM_RAR_L(i), (u16)(mreg & 0xFFFF));
5020 e1000_write_phy_reg(hw, BM_RAR_M(i),
5021 (u16)((mreg >> 16) & 0xFFFF));
5022 mreg = E1000_READ_REG(hw, E1000_RAH(i));
5023 e1000_write_phy_reg(hw, BM_RAR_H(i), (u16)(mreg & 0xFFFF));
5024 e1000_write_phy_reg(hw, BM_RAR_CTRL(i),
5025 (u16)((mreg >> 16) & 0xFFFF));
5026 }
5027
5028 /* copy MAC MTA to PHY MTA */
5029 for (int i = 0; i < adapter->hw.mac.mta_reg_count; i++) {
5030 mreg = E1000_READ_REG_ARRAY(hw, E1000_MTA, i);
5031 e1000_write_phy_reg(hw, BM_MTA(i), (u16)(mreg & 0xFFFF));
5032 e1000_write_phy_reg(hw, BM_MTA(i) + 1,
5033 (u16)((mreg >> 16) & 0xFFFF));
5034 }
5035
5036 /* configure PHY Rx Control register */
5037 e1000_read_phy_reg(&adapter->hw, BM_RCTL, &preg);
5038 mreg = E1000_READ_REG(hw, E1000_RCTL);
5039 if (mreg & E1000_RCTL_UPE)
5040 preg |= BM_RCTL_UPE;
5041 if (mreg & E1000_RCTL_MPE)
5042 preg |= BM_RCTL_MPE;
5043 preg &= ~(BM_RCTL_MO_MASK);
5044 if (mreg & E1000_RCTL_MO_3)
5045 preg |= (((mreg & E1000_RCTL_MO_3) >> E1000_RCTL_MO_SHIFT)
5046 << BM_RCTL_MO_SHIFT);
5047 if (mreg & E1000_RCTL_BAM)
5048 preg |= BM_RCTL_BAM;
5049 if (mreg & E1000_RCTL_PMCF)
5050 preg |= BM_RCTL_PMCF;
5051 mreg = E1000_READ_REG(hw, E1000_CTRL);
5052 if (mreg & E1000_CTRL_RFCE)
5053 preg |= BM_RCTL_RFCE;
5054 e1000_write_phy_reg(&adapter->hw, BM_RCTL, preg);
5055
5056 /* enable PHY wakeup in MAC register */
5057 E1000_WRITE_REG(hw, E1000_WUC,
5058 E1000_WUC_PHY_WAKE | E1000_WUC_PME_EN);
5059 E1000_WRITE_REG(hw, E1000_WUFC, adapter->wol);
5060
5061 /* configure and enable PHY wakeup in PHY registers */
5062 e1000_write_phy_reg(&adapter->hw, BM_WUFC, adapter->wol);
5063 e1000_write_phy_reg(&adapter->hw, BM_WUC, E1000_WUC_PME_EN);
5064
5065 /* activate PHY wakeup */
5066 ret = hw->phy.ops.acquire(hw);
5067 if (ret) {
5068 printf("Could not acquire PHY\n");
5069 return ret;
5070 }
5071 e1000_write_phy_reg_mdic(hw, IGP01E1000_PHY_PAGE_SELECT,
5072 (BM_WUC_ENABLE_PAGE << IGP_PAGE_SHIFT));
5073 ret = e1000_read_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, &preg);
5074 if (ret) {
5075 printf("Could not read PHY page 769\n");
5076 goto out;
5077 }
5078 preg |= BM_WUC_ENABLE_BIT | BM_WUC_HOST_WU_BIT;
5079 ret = e1000_write_phy_reg_mdic(hw, BM_WUC_ENABLE_REG, preg);
5080 if (ret)
5081 printf("Could not set PHY Host Wakeup bit\n");
5082out:
5083 hw->phy.ops.release(hw);
5084
5085 return ret;
5086}
5087
5088
4985/*********************************************************************
4986* 82544 Coexistence issue workaround.
4987* There are 2 issues.
4988* 1. Transmit Hang issue.
4989* To detect this issue, following equation can be used...
4990* SIZE[3:0] + ADDR[2:0] = SUM[3:0].
4991* If SUM[3:0] is in between 1 to 4, we will have this issue.
4992*

--- 401 unchanged lines hidden --- 		5089/*********************************************************************
5090* 82544 Coexistence issue workaround.
5091* There are 2 issues.
5092* 1. Transmit Hang issue.
5093* To detect this issue, following equation can be used...
5094* SIZE[3:0] + ADDR[2:0] = SUM[3:0].
5095* If SUM[3:0] is in between 1 to 4, we will have this issue.
5096*

--- 401 unchanged lines hidden ---