 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_wm.c,v 1.359 2015/10/13 08:17:15 knakahara Exp $	*/
+/*	$NetBSD: if_wm.c,v 1.360 2015/10/13 08:20:02 knakahara Exp $	*/
 /*
  * Copyright (c) 2001, 2002, 2003, 2004 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -73,27 +73,27 @@
  * TODO (in order of importance):
+ *
  *	- Check XXX'ed comments
  *	- EEE (Energy Efficiency Ethernet)
  *	- Multi queue
  *	- Image Unique ID
  *	- LPLU other than PCH*
  *	- Virtual Function
  *	- Set LED correctly (based on contents in EEPROM)
  *	- Rework how parameters are loaded from the EEPROM.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_wm.c,v 1.359 2015/10/13 08:17:15 knakahara Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_wm.c,v 1.360 2015/10/13 08:20:02 knakahara Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_net_mpsafe.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/mbuf.h>
 #include <sys/malloc.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 @@ -603,26 +603,28 @@ static void	wm_start_locked(struct ifnet
 static int	wm_nq_tx_offload(struct wm_softc *, struct wm_txsoft *,
     uint32_t *, uint32_t *, bool *);
 static void	wm_nq_start(struct ifnet *);
 static void	wm_nq_start_locked(struct ifnet *);
 /* Interrupt */
 static int	wm_txeof(struct wm_softc *);
 static void	wm_rxeof(struct wm_softc *);
 static void	wm_linkintr_gmii(struct wm_softc *, uint32_t);
 static void	wm_linkintr_tbi(struct wm_softc *, uint32_t);
 static void	wm_linkintr_serdes(struct wm_softc *, uint32_t);
 static void	wm_linkintr(struct wm_softc *, uint32_t);
 static int	wm_intr_legacy(void *);
 #ifdef WM_MSI_MSIX
 static int	wm_setup_legacy(struct wm_softc *);
 static int	wm_setup_msix(struct wm_softc *);
 static int	wm_txintr_msix(void *);
 static int	wm_rxintr_msix(void *);
 static int	wm_linkintr_msix(void *);
 #endif
 /*
  * Media related.
  * GMII, SGMII, TBI, SERDES and SFP.
  */
 /* Common */
 static void	wm_tbi_serdes_set_linkled(struct wm_softc *);
 /* GMII related */
 static void	wm_gmii_reset(struct wm_softc *);
 @@ -751,40 +753,26 @@ static void	wm_set_eee_i350(struct wm_so
  * Basically, PHY's workarounds are in the PHY drivers.
  */
 static void	wm_kmrn_lock_loss_workaround_ich8lan(struct wm_softc *);
 static void	wm_gig_downshift_workaround_ich8lan(struct wm_softc *);
 static void	wm_hv_phy_workaround_ich8lan(struct wm_softc *);
 static void	wm_lv_phy_workaround_ich8lan(struct wm_softc *);
 static void	wm_k1_gig_workaround_hv(struct wm_softc *, int);
 static void	wm_set_mdio_slow_mode_hv(struct wm_softc *);
 static void	wm_configure_k1_ich8lan(struct wm_softc *, int);
 static void	wm_reset_init_script_82575(struct wm_softc *);
 static void	wm_reset_mdicnfg_82580(struct wm_softc *);
 static void	wm_pll_workaround_i210(struct wm_softc *);
 #ifdef WM_MSI_MSIX
 struct _msix_matrix {
 	const char *intrname;
 	int(*func)(void *);
 	int intridx;
 	int cpuid;
 } msix_matrix[WM_MSIX_NINTR] = {
 	{ "TX", wm_txintr_msix, WM_MSIX_TXINTR_IDX, WM_MSIX_TXINTR_CPUID },
 	{ "RX", wm_rxintr_msix, WM_MSIX_RXINTR_IDX, WM_MSIX_RXINTR_CPUID },
 	{ "LINK", wm_linkintr_msix, WM_MSIX_LINKINTR_IDX,
 	  WM_MSIX_LINKINTR_CPUID },
 };
 #endif
 CFATTACH_DECL3_NEW(wm, sizeof(struct wm_softc),
     wm_match, wm_attach, wm_detach, NULL, NULL, NULL, DVF_DETACH_SHUTDOWN);
 /*
  * Devices supported by this driver.
  */
 static const struct wm_product {
 	pci_vendor_id_t		wmp_vendor;
 	pci_product_id_t	wmp_product;
 	const char		*wmp_name;
 	wm_chip_type		wmp_type;
 	uint32_t		wmp_flags;
 #define	WMP_F_UNKNOWN		WM_MEDIATYPE_UNKNOWN
 @@ -1459,48 +1447,48 @@ wm_match(device_t parent, cfdata_t cf, v
+}
 /* The attach function (ca_attach) */
 static void
 wm_attach(device_t parent, device_t self, void *aux)
+{
 	struct wm_softc *sc = device_private(self);
 	struct pci_attach_args *pa = aux;
 	prop_dictionary_t dict;
 	struct ifnet *ifp = &sc->sc_ethercom.ec_if;
 	pci_chipset_tag_t pc = pa->pa_pc;
 #ifndef WM_MSI_MSIX
 	pci_intr_handle_t ih;
 	const char *intrstr = NULL;
 	char intrbuf[PCI_INTRSTR_LEN];
 #else
 	int counts[PCI_INTR_TYPE_SIZE];
 	pci_intr_type_t max_type;
 #endif
 	const char *intrstr = NULL;
 	const char *eetype, *xname;
 	bus_space_tag_t memt;
 	bus_space_handle_t memh;
 	bus_size_t memsize;
 	int memh_valid;
 	int i, error;
 	const struct wm_product *wmp;
 	prop_data_t ea;
 	prop_number_t pn;
 	uint8_t enaddr[ETHER_ADDR_LEN];
 	uint16_t cfg1, cfg2, swdpin, nvmword;
 	pcireg_t preg, memtype;
 	uint16_t eeprom_data, apme_mask;
 	bool force_clear_smbi;
 	uint32_t link_mode;
 	uint32_t reg;
 	char intrbuf[PCI_INTRSTR_LEN];
 	sc->sc_dev = self;
 	callout_init(&sc->sc_tick_ch, CALLOUT_FLAGS);
 	sc->sc_stopping = false;
 	wmp = wm_lookup(pa);
 #ifdef DIAGNOSTIC
 	if (wmp == NULL) {
 		printf("\n");
 		panic("wm_attach: impossible");
+	}
 #endif
 	sc->sc_mediatype = WMP_MEDIATYPE(wmp->wmp_flags);
 @@ -1673,114 +1661,55 @@ wm_attach(device_t parent, device_t self
 	/* Allocation settings */
 	max_type = PCI_INTR_TYPE_MSIX;
 	counts[PCI_INTR_TYPE_MSIX] = WM_MAX_NINTR;
 	counts[PCI_INTR_TYPE_MSI] = 1;
 	counts[PCI_INTR_TYPE_INTX] = 1;
 alloc_retry:
 	if (pci_intr_alloc(pa, &sc->sc_intrs, counts, max_type) != 0) {
 		aprint_error_dev(sc->sc_dev, "failed to allocate interrupt\n");
 		return;
+	}
 	if (pci_intr_type(sc->sc_intrs[0]) == PCI_INTR_TYPE_MSIX) {
-		void *vih;
+		error = wm_setup_msix(sc);
-		kcpuset_t *affinity;
+		if (error) {
-		char intr_xname[INTRDEVNAMEBUF];
+			pci_intr_release(pc, sc->sc_intrs,
 			    counts[PCI_INTR_TYPE_MSIX]);
 		kcpuset_create(&affinity, false);
 			/* Setup for MSI: Disable MSI-X */
-		for (i = 0; i < WM_MSIX_NINTR; i++) {
+			max_type = PCI_INTR_TYPE_MSI;
-			intrstr = pci_intr_string(pc,
+			counts[PCI_INTR_TYPE_MSI] = 1;
-			    sc->sc_intrs[msix_matrix[i].intridx], intrbuf,
+			counts[PCI_INTR_TYPE_INTX] = 1;
-			    sizeof(intrbuf));
+			goto alloc_retry;
 #ifdef WM_MPSAFE
 			pci_intr_setattr(pc,
 			    &sc->sc_intrs[msix_matrix[i].intridx],
 			    PCI_INTR_MPSAFE, true);
 #endif
 			memset(intr_xname, 0, sizeof(intr_xname));
 			strlcat(intr_xname, device_xname(sc->sc_dev),
 			    sizeof(intr_xname));
 			strlcat(intr_xname, msix_matrix[i].intrname,
 			    sizeof(intr_xname));
 			vih = pci_intr_establish_xname(pc,
 			    sc->sc_intrs[msix_matrix[i].intridx], IPL_NET,
 			    msix_matrix[i].func, sc, intr_xname);
 			if (vih == NULL) {
 				aprint_error_dev(sc->sc_dev,
 				    "unable to establish MSI-X(for %s)%s%s\n",
 				    msix_matrix[i].intrname,
 				    intrstr ? " at " : "",
 				    intrstr ? intrstr : "");
 				pci_intr_release(sc->sc_pc, sc->sc_intrs,
 				    WM_MSIX_NINTR);
 				kcpuset_destroy(affinity);
 				/* Setup for MSI: Disable MSI-X */
 				max_type = PCI_INTR_TYPE_MSI;
 				counts[PCI_INTR_TYPE_MSI] = 1;
 				counts[PCI_INTR_TYPE_INTX] = 1;
 				goto alloc_retry;
 			kcpuset_zero(affinity);
 			/* Round-robin affinity */
 			kcpuset_set(affinity, msix_matrix[i].cpuid % ncpu);
 			error = interrupt_distribute(vih, affinity, NULL);
 			if (error == 0) {
 				aprint_normal_dev(sc->sc_dev,
 				    "for %s interrupting at %s affinity to %u\n",
 				    msix_matrix[i].intrname, intrstr,
 				    msix_matrix[i].cpuid % ncpu);
 			} else {
 				aprint_normal_dev(sc->sc_dev,
 				    "for %s interrupting at %s\n",
 				    msix_matrix[i].intrname, intrstr);
 			sc->sc_ihs[msix_matrix[i].intridx] = vih;
+		}
 	} else 	if (pci_intr_type(sc->sc_intrs[0]) == PCI_INTR_TYPE_MSI) {
 		error = wm_setup_legacy(sc);
 		if (error) {
 			pci_intr_release(sc->sc_pc, sc->sc_intrs,
 			    counts[PCI_INTR_TYPE_MSI]);
-		sc->sc_nintrs = WM_MSIX_NINTR;
+			/* The next try is for INTx: Disable MSI */
-		kcpuset_destroy(affinity);
+			max_type = PCI_INTR_TYPE_INTX;
 			counts[PCI_INTR_TYPE_INTX] = 1;
 			goto alloc_retry;
+		}
 	} else {
-		/* MSI or INTx */
+		error = wm_setup_legacy(sc);
-		intrstr = pci_intr_string(pc, sc->sc_intrs[0], intrbuf,
+		if (error) {
-		    sizeof(intrbuf));
+			pci_intr_release(sc->sc_pc, sc->sc_intrs,
-#ifdef WM_MPSAFE
+			    counts[PCI_INTR_TYPE_INTX]);
-		pci_intr_setattr(pc, &sc->sc_intrs[0], PCI_INTR_MPSAFE, true);
+			return;
 #endif
 		sc->sc_ihs[0] = pci_intr_establish_xname(pc, sc->sc_intrs[0],
 		    IPL_NET, wm_intr_legacy, sc, device_xname(sc->sc_dev));
 		if (sc->sc_ihs[0] == NULL) {
 			aprint_error_dev(sc->sc_dev,"unable to establish %s\n",
 			    (pci_intr_type(sc->sc_intrs[0])
 				== PCI_INTR_TYPE_MSI) ? "MSI" : "INTx");
 			pci_intr_release(sc->sc_pc, sc->sc_intrs, 1);
 			switch (pci_intr_type(sc->sc_intrs[0])) {
 			case PCI_INTR_TYPE_MSI:
 				/* The next try is for INTx: Disable MSI */
 				max_type = PCI_INTR_TYPE_INTX;
 				counts[PCI_INTR_TYPE_INTX] = 1;
 				goto alloc_retry;
 			case PCI_INTR_TYPE_INTX:
 			default:
 				return;
+		}
 		aprint_normal_dev(sc->sc_dev, "%s at %s\n",
 		    (pci_intr_type(sc->sc_intrs[0]) == PCI_INTR_TYPE_MSI)
 			? "MSI" : "interrupting", intrstr);
 		sc->sc_nintrs = 1;
+	}
 #endif /* WM_MSI_MSIX */
 	/*
 	 * Check the function ID (unit number of the chip).
 	 */
 	if ((sc->sc_type == WM_T_82546) || (sc->sc_type == WM_T_82546_3)
 	    || (sc->sc_type ==  WM_T_82571) || (sc->sc_type == WM_T_80003)
 	    || (sc->sc_type == WM_T_82575) || (sc->sc_type == WM_T_82576)
 	    || (sc->sc_type == WM_T_82580)
 	    || (sc->sc_type == WM_T_I350) || (sc->sc_type == WM_T_I354))
 		sc->sc_funcid = (CSR_READ(sc, WMREG_STATUS)
 		    >> STATUS_FUNCID_SHIFT) & STATUS_FUNCID_MASK;
 @@ -4094,26 +4023,132 @@ wm_rxdrain(struct wm_softc *sc)
 	KASSERT(WM_RX_LOCKED(rxq));
 	for (i = 0; i < WM_NRXDESC; i++) {
 		rxs = &rxq->rxq_soft[i];
 		if (rxs->rxs_mbuf != NULL) {
 			bus_dmamap_unload(sc->sc_dmat, rxs->rxs_dmamap);
 			m_freem(rxs->rxs_mbuf);
 			rxs->rxs_mbuf = NULL;
+		}
+	}
+}
 #ifdef WM_MSI_MSIX
 /*
  * Both single interrupt MSI and INTx can use this function.
  */
 static int
 wm_setup_legacy(struct wm_softc *sc)
+{
 	pci_chipset_tag_t pc = sc->sc_pc;
 	const char *intrstr = NULL;
 	char intrbuf[PCI_INTRSTR_LEN];
 	intrstr = pci_intr_string(pc, sc->sc_intrs[0], intrbuf,
 	    sizeof(intrbuf));
 #ifdef WM_MPSAFE
 	pci_intr_setattr(pc, &sc->sc_intrs[0], PCI_INTR_MPSAFE, true);
 #endif
 	sc->sc_ihs[0] = pci_intr_establish_xname(pc, sc->sc_intrs[0],
 	    IPL_NET, wm_intr_legacy, sc, device_xname(sc->sc_dev));
 	if (sc->sc_ihs[0] == NULL) {
 		aprint_error_dev(sc->sc_dev,"unable to establish %s\n",
 		    (pci_intr_type(sc->sc_intrs[0])
 			== PCI_INTR_TYPE_MSI) ? "MSI" : "INTx");
 		return ENOMEM;
+	}
 	aprint_normal_dev(sc->sc_dev, "interrupting at %s\n", intrstr);
 	sc->sc_nintrs = 1;
 	return 0;
+}
 struct _msix_matrix {
 	const char *intrname;
 	int(*func)(void *);
 	int intridx;
 	int cpuid;
 } msix_matrix[WM_MSIX_NINTR] = {
 	{ "TX", wm_txintr_msix, WM_MSIX_TXINTR_IDX, WM_MSIX_TXINTR_CPUID },
 	{ "RX", wm_rxintr_msix, WM_MSIX_RXINTR_IDX, WM_MSIX_RXINTR_CPUID },
 	{ "LINK", wm_linkintr_msix, WM_MSIX_LINKINTR_IDX,
 	  WM_MSIX_LINKINTR_CPUID },
 };
 static int
 wm_setup_msix(struct wm_softc *sc)
+{
 	void *vih;
 	kcpuset_t *affinity;
 	int i, error;
 	pci_chipset_tag_t pc = sc->sc_pc;
 	const char *intrstr = NULL;
 	char intrbuf[PCI_INTRSTR_LEN];
 	char intr_xname[INTRDEVNAMEBUF];
 	kcpuset_create(&affinity, false);
 	for (i = 0; i < WM_MSIX_NINTR; i++) {
 		intrstr = pci_intr_string(pc,
 		    sc->sc_intrs[msix_matrix[i].intridx], intrbuf,
 		    sizeof(intrbuf));
 #ifdef WM_MPSAFE
 		pci_intr_setattr(pc,
 		    &sc->sc_intrs[msix_matrix[i].intridx],
 		    PCI_INTR_MPSAFE, true);
 #endif
 		memset(intr_xname, 0, sizeof(intr_xname));
 		strlcat(intr_xname, device_xname(sc->sc_dev),
 		    sizeof(intr_xname));
 		strlcat(intr_xname, msix_matrix[i].intrname,
 		    sizeof(intr_xname));
 		vih = pci_intr_establish_xname(pc,
 		    sc->sc_intrs[msix_matrix[i].intridx], IPL_NET,
 		    msix_matrix[i].func, sc, intr_xname);
 		if (vih == NULL) {
 			aprint_error_dev(sc->sc_dev,
 			    "unable to establish MSI-X(for %s)%s%s\n",
 			    msix_matrix[i].intrname,
 			    intrstr ? " at " : "",
 			    intrstr ? intrstr : "");
 			kcpuset_destroy(affinity);
 			return ENOMEM;
+		}
 		kcpuset_zero(affinity);
 		/* Round-robin affinity */
 		kcpuset_set(affinity, msix_matrix[i].cpuid % ncpu);
 		error = interrupt_distribute(vih, affinity, NULL);
 		if (error == 0) {
 			aprint_normal_dev(sc->sc_dev,
 			    "for %s interrupting at %s affinity to %u\n",
 			    msix_matrix[i].intrname, intrstr,
 			    msix_matrix[i].cpuid % ncpu);
 		} else {
 			aprint_normal_dev(sc->sc_dev,
 			    "for %s interrupting at %s\n",
 			    msix_matrix[i].intrname, intrstr);
+		}
 		sc->sc_ihs[msix_matrix[i].intridx] = vih;
+	}
 	sc->sc_nintrs = WM_MSIX_NINTR;
 	kcpuset_destroy(affinity);
 	return 0;
+}
 #endif
 /*
  * wm_init:		[ifnet interface function]
+ *
  *	Initialize the interface.
  */
 static int
 wm_init(struct ifnet *ifp)
+{
 	struct wm_softc *sc = ifp->if_softc;
 	int ret;
 	WM_CORE_LOCK(sc);
 	ret = wm_init_locked(ifp);