Add RealTek RTL8150 USB to fast Ethernet controller driver.

This driver now supports the Melco LUA-KTX and the GREEN HOUSE
GH-USB100B.

Reviewed by:	imp
MFC after:	2 weeks

14 files changed, 2213 insertions, 2 deletions

diff --git a/etc/devd.conf b/etc/devd.conf
index 017330e..6e7ba86 100644
--- a/etc/devd.conf
+++ b/etc/devd.conf
@@ -19,7 +19,7 @@ options {
 	# Setup some shorthand for regex that we use later in the file.
 	set ethernet-nic-regex 
 		"(an|ar|ath|aue|awi|bge|cm|cnw|cs|cue|dc|de|ed|el|em|ep|ex|\
-		fe|fxp|gem|gx|hme|ie|kue|lge|lnc|my|nge|pcn|ray|rl|\
+		fe|fxp|gem|gx|hme|ie|kue|lge|lnc|my|nge|pcn|ray|rl|rue|\
 		sf|sis|sk|sn|snc|ste|ti|tl|tx|txp|vr|vx|wb|wi|xe|xl)[0-9]+";
 	set scsi-controller-regex
 		"(adv|advw|aic|aha|ahb|ahc|ahd|bt|ct|iir|isp|mly|mpt|ncv|nsp|\
diff --git a/etc/usbd.conf b/etc/usbd.conf
index 550bd26..03c3f4f 100644
--- a/etc/usbd.conf
+++ b/etc/usbd.conf
@@ -27,7 +27,7 @@ device "Entrega Serial with UART"
 # it shouldn't be too big a deal :-)
 #
 device "USB ethernet"
-	devname "[ack]ue[0-9]+"
+	devname "[ackr]ue[0-9]+"
 	attach  "/etc/pccard_ether ${DEVNAME} start"
 	detach  "/etc/pccard_ether ${DEVNAME} stop"
 
diff --git a/share/man/man4/Makefile b/share/man/man4/Makefile
index cab4b58..346d198 100644
--- a/share/man/man4/Makefile
+++ b/share/man/man4/Makefile
@@ -185,6 +185,7 @@ MAN=	aac.4 \
 	rndtest.4 \
 	route.4 \
 	rp.4 \
+	rue.4 \
 	sa.4 \
 	sbc.4 \
 	sbp.4 \
diff --git a/share/man/man4/rue.4 b/share/man/man4/rue.4
new file mode 100644
index 0000000..3b69068
--- /dev/null
+++ b/share/man/man4/rue.4
@@ -0,0 +1,128 @@
+.\" 
+.\" Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
+.\" All rights reserved.
+.\" 
+.\" 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
+.\"    notice, this list of conditions and the following disclaimer in the
+.\"    documentation and/or other materials provided with the distribution.
+.\" 
+.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+.\" SUCH DAMAGE.
+.\" 
+.\" $FreeBSD$
+.\" 
+.Dd May 3, 2003
+.Dt RUE 4
+.Os FreeBSD
+.Sh NAME
+.Nm rue
+.Nd
+RealTek RTL8150 USB To Fast Ethernet controller driver
+.Sh SYNOPSIS
+.Cd "device uhci"
+.Cd "device ohci"
+.Cd "device usb"
+.Cd "device miibus"
+.Cd "device rue"
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for USB Ethernet adapters based on the RealTek
+RTL8150 USB to Fast Ethernet controller chip.
+This includes the Melco Inc. LUA-KTX and the GREEN HOUSE GH-USB100B.
+.Pp
+The RTL8150 contains a integrated Fast Ethernet MAC, which supports
+both 10 and 100Mbps speeds in either full or half duplex.
+Although designed to interface with
+100Mbps peripheral, the existing USB standard specifies a maximum
+transfer speed of 12Mbps.
+Users should therefore not expect to actually
+achieve 100Mbps speeds with this device.
+.Pp
+The
+.Nm
+driver supports the following media types:
+.Pp
+.Bl -tag -width xxxxxxxxxxxxxxxx
+.It autoselect
+Enable auto selection of the media type and options.
+The user can manually override
+the auto selected mode by adding media options to the
+.Pa /etc/rc.conf
+file.
+.It 10baseT/UTP
+Set 10Mbps operation.
+The
+.Ar mediaopt
+option can also be used to select either
+.Ar full-duplex
+or
+.Ar half-duplex
+modes.
+.It 100baseTX
+Set 100Mbps (Fast Ethernet) operation.
+The
+.Ar mediaopt
+option can also be used to select either
+.Ar full-duplex
+or
+.Ar half-duplex
+modes.
+.El
+.Pp
+The
+.Nm
+driver supports the following media options:
+.Pp
+.Bl -tag -width xxxxxxxxxxxxxxxx
+.It full-duplex
+Force full duplex operation.
+.It half-duplex
+Force half duplex operation.
+.El
+.Pp
+For more information on configuring this device, see
+.Xr ifconfig 8 .
+.Sh DIAGNOSTICS
+.Bl -diag
+.It "rue%d: watchdog timeout"
+A packet was queued for transmission and a transmit command was
+issued, however the device failed to acknowledge the transmission
+before a timeout expired.
+.It "rue%d: rx list init failed"
+The driver failed to allocate an mbuf for the transmitter ring.
+.It "rue%d: no memory for rx list"
+The driver failed to allocate an mbuf for the receiver ring.
+.Sh SEE ALSO
+.Xr arp 4 ,
+.Xr netintro 4 , 
+.Xr ng_ether 4 ,
+.Xr ifconfig 8
+.Rs
+.%T ReakTek RTL8150 data sheet
+.%O ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/
+.Re
+.Sh HISTORY
+The
+.Nm
+device driver first appeared in
+.Fx 5.1 .
+.Sh AUTHORS
+The
+.Nm
+driver was written by
+.An Shunsuke Akiyama Aq akiyama@FreeBSD.org .
diff --git a/sys/conf/NOTES b/sys/conf/NOTES
index 26be71e..a3c57f0 100644
--- a/sys/conf/NOTES
+++ b/sys/conf/NOTES
@@ -2131,6 +2131,10 @@ device		cue
 # the Netgear EA101, the D-Link DSB-650, the SMC 2102USB
 # and 2104USB, and the Corega USB-T.
 device		kue
+#
+# RealTek RTL8150 USB to fast ethernet. Supports the Melco LUA-KTX
+# and the GREEN HOUSE GH-USB100B.
+device		rue
 
 # debugging options for the USB subsystem
 #
diff --git a/sys/conf/files b/sys/conf/files
index 90c4664..bb3c4bf 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -498,6 +498,7 @@ dev/mii/nsgphy.c	optional miibus
 dev/mii/pnphy.c		optional miibus
 dev/mii/pnaphy.c	optional miibus
 dev/mii/rlphy.c		optional miibus
+dev/mii/ruephy.c	optional miibus
 dev/mii/tdkphy.c	optional miibus
 dev/mii/tlphy.c		optional miibus
 dev/mii/ukphy.c		optional miibus
@@ -760,6 +761,7 @@ dev/usb/if_aue.c	optional aue
 dev/usb/if_axe.c	optional axe
 dev/usb/if_cue.c	optional cue
 dev/usb/if_kue.c	optional kue
+dev/usb/if_rue.c	optional rue
 dev/usb/ehci.c		optional ehci
 dev/usb/ehci_pci.c	optional ehci pci
 dev/usb/ohci.c		optional ohci
diff --git a/sys/dev/mii/ruephy.c b/sys/dev/mii/ruephy.c
new file mode 100644
index 0000000..5e876af
--- /dev/null
+++ b/sys/dev/mii/ruephy.c
@@ -0,0 +1,297 @@
+/*-
+ * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
+ * All rights reserved.
+ *
+ * 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
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * driver for RealTek RTL8150 internal PHY
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/socket.h>
+#include <sys/bus.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/if_media.h>
+
+#include <dev/mii/mii.h>
+#include <dev/mii/miivar.h>
+#include "miidevs.h"
+
+#include <machine/bus.h>
+#include <dev/mii/ruephyreg.h>
+
+#include "miibus_if.h"
+
+static int ruephy_probe(device_t);
+static int ruephy_attach(device_t);
+
+static device_method_t ruephy_methods[] = {
+	/* device interface */
+	DEVMETHOD(device_probe,		ruephy_probe),
+	DEVMETHOD(device_attach,	ruephy_attach),
+	DEVMETHOD(device_detach,	mii_phy_detach),
+	DEVMETHOD(device_shutdown,	bus_generic_shutdown),
+	{ 0, 0 }
+};
+
+static devclass_t ruephy_devclass;
+
+static driver_t ruephy_driver = {
+	"ruephy",
+	ruephy_methods,
+	sizeof(struct mii_softc)
+};
+
+DRIVER_MODULE(ruephy, miibus, ruephy_driver, ruephy_devclass, 0, 0);
+
+static int ruephy_service(struct mii_softc *, struct mii_data *, int);
+static void ruephy_reset(struct mii_softc *);
+static void ruephy_status(struct mii_softc *);
+
+static int
+ruephy_probe(device_t dev)
+{
+	struct mii_attach_args *ma;
+	device_t		parent;
+
+	ma = device_get_ivars(dev);
+	parent = device_get_parent(device_get_parent(dev));
+
+	/*
+	 * RealTek RTL8150 PHY doesn't have vendor/device ID registers:
+	 * the rue driver fakes up a return value of all zeros.
+	 */
+	if (MII_OUI(ma->mii_id1, ma->mii_id2) != 0 ||
+	    MII_MODEL(ma->mii_id2) != 0)
+		return (ENXIO);
+
+	/*
+	 * Make sure the parent is an 'rue'.
+	 */
+	if (strcmp(device_get_name(parent), "rue") != 0)
+		return (ENXIO);
+
+	device_set_desc(dev, "RealTek RTL8150 internal media interface");
+
+	return (0);
+}
+
+static int
+ruephy_attach(device_t dev)
+{
+	struct mii_softc	*sc;
+	struct mii_attach_args	*ma;
+	struct mii_data		*mii;
+
+	sc = device_get_softc(dev);
+	ma = device_get_ivars(dev);
+	sc->mii_dev = device_get_parent(dev);
+	mii = device_get_softc(sc->mii_dev);
+
+	/*
+	 * The RealTek PHY can never be isolated, so never allow non-zero
+	 * instances!
+	 */
+	if (mii->mii_instance != 0) {
+		device_printf(dev, "ignoring this PHY, non-zero instance\n");
+		return (ENXIO);
+	}
+
+	LIST_INSERT_HEAD(&mii->mii_phys, sc, mii_list);
+
+	sc->mii_inst = mii->mii_instance;
+	sc->mii_phy = ma->mii_phyno;
+	sc->mii_service = ruephy_service;
+	sc->mii_pdata = mii;
+	mii->mii_instance++;
+
+	sc->mii_flags |= MIIF_NOISOLATE;
+
+#define	ADD(m, c)	ifmedia_add(&mii->mii_media, (m), (c), NULL)
+
+	ruephy_reset(sc);
+
+	sc->mii_capabilities =
+	    PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
+	device_printf(dev, " ");
+	mii_phy_add_media(sc);
+	printf("\n");
+#undef ADD
+
+	MIIBUS_MEDIAINIT(sc->mii_dev);
+	return (0);
+}
+
+static int
+ruephy_service(struct mii_softc *sc, struct mii_data *mii, int cmd)
+{
+	struct ifmedia_entry *ife = mii->mii_media.ifm_cur;
+	int reg;
+
+	/*
+	 * We can't isolate the RealTek RTL8150 PHY,
+	 * so it has to be the only one!
+	 */
+	if (IFM_INST(ife->ifm_media) != sc->mii_inst)
+		panic("ruephy_service: can't isolate RealTek RTL8150 PHY");
+
+	switch (cmd) {
+	case MII_POLLSTAT:
+		break;
+
+	case MII_MEDIACHG:
+		/*
+		 * If the interface is not up, don't do anything.
+		 */
+		if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
+			break;
+
+		switch (IFM_SUBTYPE(ife->ifm_media)) {
+		case IFM_AUTO:
+			/*
+			 * If we're already in auto mode, just return.
+			 */
+			if (PHY_READ(sc, MII_BMCR) & BMCR_AUTOEN)
+				return (0);
+			(void) mii_phy_auto(sc);
+			break;
+		case IFM_100_T4:
+			/*
+			 * XXX Not supported as a manual setting right now.
+			 */
+			return (EINVAL);
+		default:
+			/*
+			 * BMCR data is stored in the ifmedia entry.
+			 */
+			PHY_WRITE(sc, MII_ANAR,
+			    mii_anar(ife->ifm_media));
+			PHY_WRITE(sc, MII_BMCR, ife->ifm_data);
+		}
+		break;
+
+	case MII_TICK:
+		/*
+		 * Is the interface even up?
+		 */
+		if ((mii->mii_ifp->if_flags & IFF_UP) == 0)
+			return (0);
+
+		/*
+		 * Only used for autonegotiation.
+		 */
+		if (IFM_SUBTYPE(ife->ifm_media) != IFM_AUTO)
+			break;
+
+		/*
+		 * Check to see if we have link.  If we do, we don't
+		 * need to restart the autonegotiation process.  Read
+		 * the MSR twice in case it's latched.
+		 */
+		reg = PHY_READ(sc, RUEPHY_MII_MSR) |
+		      PHY_READ(sc, RUEPHY_MII_MSR);
+		if (reg & RUEPHY_MSR_LINK)
+			break;
+
+		/*
+		 * Only retry autonegotiation every 5 seconds.
+		 */
+		if (++sc->mii_ticks != 5)
+			return (0);
+
+		sc->mii_ticks = 0;
+		ruephy_reset(sc);
+		if (mii_phy_auto(sc) == EJUSTRETURN)
+			return (0);
+		break;
+	}
+
+	/* Update the media status. */
+	ruephy_status(sc);
+
+	/* Callback if something changed. */
+	mii_phy_update(sc, cmd);
+
+	return (0);
+}
+
+static void
+ruephy_reset(struct mii_softc *sc)
+{
+
+	mii_phy_reset(sc);
+
+	/*
+	 * XXX RealTek RTL8150 PHY doesn't set the BMCR properly after
+	 * XXX reset, which breaks autonegotiation.
+	 */
+	PHY_WRITE(sc, MII_BMCR, (BMCR_S100 | BMCR_AUTOEN | BMCR_FDX));
+}
+
+static void
+ruephy_status(struct mii_softc *phy)
+{
+	struct mii_data *mii = phy->mii_pdata;
+	int bmsr, bmcr, msr;
+
+	mii->mii_media_status = IFM_AVALID;
+	mii->mii_media_active = IFM_ETHER;
+
+	msr = PHY_READ(phy, RUEPHY_MII_MSR) | PHY_READ(phy, RUEPHY_MII_MSR);
+	if (msr & RUEPHY_MSR_LINK)
+		mii->mii_media_status |= IFM_ACTIVE;
+
+	bmcr = PHY_READ(phy, MII_BMCR);
+	if (bmcr & BMCR_ISO) {
+		mii->mii_media_active |= IFM_NONE;
+		mii->mii_media_status = 0;
+		return;
+	}
+
+	bmsr = PHY_READ(phy, MII_BMSR) | PHY_READ(phy, MII_BMSR);
+
+	if (bmcr & BMCR_AUTOEN) {
+		if ((bmsr & BMSR_ACOMP) == 0) {
+			/* Erg, still trying, I guess... */
+			mii->mii_media_active |= IFM_NONE;
+			return;
+		}
+
+		if (msr & RUEPHY_MSR_SPEED100)
+			mii->mii_media_active |= IFM_100_TX;
+		else
+			mii->mii_media_active |= IFM_10_T;
+
+		if (msr & RUEPHY_MSR_DUPLEX)
+			mii->mii_media_active |= IFM_FDX;
+	} else
+		mii->mii_media_active = mii_media_from_bmcr(bmcr);
+}
diff --git a/sys/dev/mii/ruephyreg.h b/sys/dev/mii/ruephyreg.h
new file mode 100644
index 0000000..5f3911b
--- /dev/null
+++ b/sys/dev/mii/ruephyreg.h
@@ -0,0 +1,38 @@
+/*-
+ * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
+ * All rights reserved.
+ *
+ * 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
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _RUEPHYREG_H_
+#define _RUEPHYREG_H_
+
+#define RUEPHY_MII_MSR		0x0137	/* B, R/W */
+#define RUEPHY_MSR_RXFCE	0x40
+#define RUEPHY_MSR_DUPLEX	0x10
+#define RUEPHY_MSR_SPEED100	0x08
+#define RUEPHY_MSR_LINK		0x04
+
+#endif	/* _RUEPHYREG_H_ */
diff --git a/sys/dev/usb/if_rue.c b/sys/dev/usb/if_rue.c
new file mode 100644
index 0000000..9a6c15b
--- /dev/null
+++ b/sys/dev/usb/if_rue.c
@@ -0,0 +1,1477 @@
+/*-
+ * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
+ * All rights reserved.
+ *
+ * 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
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * RealTek RTL8150 USB to fast ethernet controller driver.
+ * Datasheet is available from
+ * ftp://ftp.realtek.com.tw/lancard/data_sheet/8150/.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/sockio.h>
+#include <sys/mbuf.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/socket.h>
+#include <sys/sysctl.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/ethernet.h>
+#include <net/if_dl.h>
+#include <net/if_media.h>
+
+#include <net/bpf.h>
+
+#include <sys/bus.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usbdivar.h>
+#include <dev/usb/usbdevs.h>
+#include <dev/usb/usb_ethersubr.h>
+
+#include <dev/mii/mii.h>
+#include <dev/mii/miivar.h>
+
+#include <dev/usb/if_ruereg.h>
+
+/* "controller miibus0" required.  See GENERIC if you get errors here. */
+#include "miibus_if.h"
+
+#ifdef USB_DEBUG
+static int	ruedebug = 0;
+SYSCTL_NODE(_hw_usb, OID_AUTO, rue, CTLFLAG_RW, 0, "USB rue");
+SYSCTL_INT(_hw_usb_rue, OID_AUTO, debug, CTLFLAG_RW,
+	   &ruedebug, 0, "rue debug level");
+
+#define DPRINTFN(n, x)	do { \
+				if (ruedebug > (n)) \
+					logprintf x; \
+			} while (0);
+#else
+#define DPRINTFN(n, x)
+#endif
+#define DPRINTF(x)	DPRINTFN(0, x)
+
+/*
+ * Various supported device vendors/products.
+ */
+
+Static struct rue_type rue_devs[] = {
+	{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAKTX },
+	{ USB_VENDOR_REALTEK, USB_PRODUCT_REALTEK_USBKR100 },
+	{ 0, 0 }
+};
+
+Static struct usb_qdat rue_qdat;
+
+Static int rue_match(device_ptr_t);
+Static int rue_attach(device_ptr_t);
+Static int rue_detach(device_ptr_t);
+
+Static int rue_tx_list_init(struct rue_softc *);
+Static int rue_rx_list_init(struct rue_softc *);
+Static int rue_newbuf(struct rue_softc *, struct rue_chain *, struct mbuf *);
+Static int rue_encap(struct rue_softc *, struct mbuf *, int);
+#ifdef RUE_INTR_PIPE
+Static void rue_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
+#endif
+Static void rue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+Static void rue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+Static void rue_tick(void *);
+Static void rue_rxstart(struct ifnet *);
+Static void rue_start(struct ifnet *);
+Static int rue_ioctl(struct ifnet *, u_long, caddr_t);
+Static void rue_init(void *);
+Static void rue_stop(struct rue_softc *);
+Static void rue_watchdog(struct ifnet *);
+Static void rue_shutdown(device_ptr_t);
+Static int rue_ifmedia_upd(struct ifnet *);
+Static void rue_ifmedia_sts(struct ifnet *, struct ifmediareq *);
+
+Static int rue_miibus_readreg(device_ptr_t, int, int);
+Static int rue_miibus_writereg(device_ptr_t, int, int, int);
+Static void rue_miibus_statchg(device_ptr_t);
+
+static u_int8_t rue_calchash(caddr_t);
+Static void rue_setmulti(struct rue_softc *);
+Static void rue_reset(struct rue_softc *);
+
+Static int rue_read_mem(struct rue_softc *, u_int16_t, void *, u_int16_t);
+Static int rue_write_mem(struct rue_softc *, u_int16_t, void *, u_int16_t);
+Static int rue_csr_read_1(struct rue_softc *, int);
+Static int rue_csr_write_1(struct rue_softc *, int, u_int8_t);
+Static int rue_csr_read_2(struct rue_softc *, int);
+Static int rue_csr_write_2(struct rue_softc *, int, u_int16_t);
+Static int rue_csr_write_4(struct rue_softc *, int, u_int32_t);
+
+Static device_method_t rue_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe, rue_match),
+	DEVMETHOD(device_attach, rue_attach),
+	DEVMETHOD(device_detach, rue_detach),
+	DEVMETHOD(device_shutdown, rue_shutdown),
+
+	/* Bus interface */
+	DEVMETHOD(bus_print_child, bus_generic_print_child),
+	DEVMETHOD(bus_driver_added, bus_generic_driver_added),
+
+	/* MII interface */
+	DEVMETHOD(miibus_readreg, rue_miibus_readreg),
+	DEVMETHOD(miibus_writereg, rue_miibus_writereg),
+	DEVMETHOD(miibus_statchg, rue_miibus_statchg),
+
+	{ 0, 0 }
+};
+
+Static driver_t rue_driver = {
+	"rue",
+	rue_methods,
+	sizeof(struct rue_softc)
+};
+
+Static devclass_t rue_devclass;
+
+DRIVER_MODULE(rue, uhub, rue_driver, rue_devclass, usbd_driver_load, 0);
+DRIVER_MODULE(miibus, rue, miibus_driver, miibus_devclass, 0, 0);
+MODULE_DEPEND(rue, usb, 1, 1, 1);
+MODULE_DEPEND(rue, ether, 1, 1, 1);
+MODULE_DEPEND(rue, miibus, 1, 1, 1);
+
+#define RUE_SETBIT(sc, reg, x) \
+	rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) | (x))
+
+#define RUE_CLRBIT(sc, reg, x) \
+	rue_csr_write_1(sc, reg, rue_csr_read_1(sc, reg) & ~(x))
+
+#define RUE_SETBIT_2(sc, reg, x) \
+	rue_csr_write_2(sc, reg, rue_csr_read_2(sc, reg) | (x))
+
+#define RUE_CLRBIT_2(sc, reg, x) \
+	rue_csr_write_2(sc, reg, rue_csr_read_2(sc, reg) & ~(x))
+
+Static int
+rue_read_mem(struct rue_softc *sc, u_int16_t addr, void *buf, u_int16_t len)
+{
+	usb_device_request_t	req;
+	usbd_status		err;
+
+	if (sc->rue_dying)
+		return (0);
+
+	RUE_LOCK(sc);
+
+	req.bmRequestType = UT_READ_VENDOR_DEVICE;
+	req.bRequest = UR_SET_ADDRESS;
+	USETW(req.wValue, addr);
+	USETW(req.wIndex, 0);
+	USETW(req.wLength, len);
+
+	err = usbd_do_request(sc->rue_udev, &req, buf);
+
+	RUE_UNLOCK(sc);
+
+	if (err) {
+		printf("rue%d: control pipe read failed: %s\n",
+		       sc->rue_unit, usbd_errstr(err));
+		return (-1);
+	}
+
+	return (0);
+}
+
+Static int
+rue_write_mem(struct rue_softc *sc, u_int16_t addr, void *buf, u_int16_t len)
+{
+	usb_device_request_t	req;
+	usbd_status		err;
+
+	if (sc->rue_dying)
+		return (0);
+
+	RUE_LOCK(sc);
+
+	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
+	req.bRequest = UR_SET_ADDRESS;
+	USETW(req.wValue, addr);
+	USETW(req.wIndex, 0);
+	USETW(req.wLength, len);
+
+	err = usbd_do_request(sc->rue_udev, &req, buf);
+
+	RUE_UNLOCK(sc);
+
+	if (err) {
+		printf("rue%d: control pipe write failed: %s\n",
+		       sc->rue_unit, usbd_errstr(err));
+		return (-1);
+	}
+
+	return (0);
+}
+
+Static int
+rue_csr_read_1(struct rue_softc *sc, int reg)
+{
+	int		err;
+	u_int8_t	val = 0;
+
+	err = rue_read_mem(sc, reg, &val, 1);
+
+	if (err)
+		return (0);
+
+	return (val);
+}
+
+Static int
+rue_csr_read_2(struct rue_softc *sc, int reg)
+{
+	int		err;
+	u_int16_t	val = 0;
+	uWord		w;
+
+	USETW(w, val);
+	err = rue_read_mem(sc, reg, &w, 2);
+	val = UGETW(w);
+
+	if (err)
+		return (0);
+
+	return (val);
+}
+
+Static int
+rue_csr_write_1(struct rue_softc *sc, int reg, u_int8_t val)
+{
+	int	err;
+
+	err = rue_write_mem(sc, reg, &val, 1);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+Static int
+rue_csr_write_2(struct rue_softc *sc, int reg, u_int16_t val)
+{
+	int	err;
+	uWord	w;
+
+	USETW(w, val);
+	err = rue_write_mem(sc, reg, &w, 2);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+Static int
+rue_csr_write_4(struct rue_softc *sc, int reg, u_int32_t val)
+{
+	int	err;
+	uDWord	dw;
+
+	USETDW(dw, val);
+	err = rue_write_mem(sc, reg, &dw, 4);
+
+	if (err)
+		return (-1);
+
+	return (0);
+}
+
+Static int
+rue_miibus_readreg(device_ptr_t dev, int phy, int reg)
+{
+	struct rue_softc	*sc = USBGETSOFTC(dev);
+	int			rval;
+	int			ruereg;
+
+	if (phy != 0)		/* RTL8150 supports PHY == 0, only */
+		return (0);
+
+	switch (reg) {
+	case MII_BMCR:
+		ruereg = RUE_BMCR;
+		break;
+	case MII_BMSR:
+		ruereg = RUE_BMSR;
+		break;
+	case MII_ANAR:
+		ruereg = RUE_ANAR;
+		break;
+	case MII_ANER:
+		ruereg = RUE_AER;
+		break;
+	case MII_ANLPAR:
+		ruereg = RUE_ANLP;
+		break;
+	case MII_PHYIDR1:
+	case MII_PHYIDR2:
+		return (0);
+		break;
+	default:
+		if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) {
+			rval = rue_csr_read_1(sc, reg);
+			return (rval);
+		}
+		printf("rue%d: bad phy register\n", sc->rue_unit);
+		return (0);
+	}
+
+	rval = rue_csr_read_2(sc, ruereg);
+
+	return (rval);
+}
+
+Static int
+rue_miibus_writereg(device_ptr_t dev, int phy, int reg, int data)
+{
+	struct rue_softc	*sc = USBGETSOFTC(dev);
+	int			ruereg;
+
+	if (phy != 0)		/* RTL8150 supports PHY == 0, only */
+		return (0);
+
+	switch (reg) {
+	case MII_BMCR:
+		ruereg = RUE_BMCR;
+		break;
+	case MII_BMSR:
+		ruereg = RUE_BMSR;
+		break;
+	case MII_ANAR:
+		ruereg = RUE_ANAR;
+		break;
+	case MII_ANER:
+		ruereg = RUE_AER;
+		break;
+	case MII_ANLPAR:
+		ruereg = RUE_ANLP;
+		break;
+	case MII_PHYIDR1:
+	case MII_PHYIDR2:
+		return (0);
+		break;
+	default:
+		if (RUE_REG_MIN <= reg && reg <= RUE_REG_MAX) {
+			rue_csr_write_1(sc, reg, data);
+			return (0);
+		}
+		printf("rue%d: bad phy register\n", sc->rue_unit);
+		return (0);
+	}
+	rue_csr_write_2(sc, ruereg, data);
+
+	return (0);
+}
+
+Static void
+rue_miibus_statchg(device_ptr_t dev)
+{
+	struct rue_softc	*sc = USBGETSOFTC(dev);
+	struct mii_data		*mii = GET_MII(sc);
+	int			bmcr;
+
+	RUE_CLRBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE));
+
+	bmcr = rue_csr_read_2(sc, RUE_BMCR);
+
+	if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX)
+		bmcr |= RUE_BMCR_SPD_SET;
+	else
+		bmcr &= ~RUE_BMCR_SPD_SET;
+
+	if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
+		bmcr |= RUE_BMCR_DUPLEX;
+	else
+		bmcr &= ~RUE_BMCR_DUPLEX;
+
+	rue_csr_write_2(sc, RUE_BMCR, bmcr);
+
+	RUE_SETBIT(sc, RUE_CR, (RUE_CR_RE | RUE_CR_TE));
+}
+
+/*
+ * Calculate CRC of a multicast group address, return the upper 6 bits.
+ */
+
+static u_int8_t
+rue_calchash(caddr_t addr)
+{
+	u_int32_t	crc, carry;
+	int		i, j;
+	u_int8_t	c;
+
+	/* Compute CRC for the address value. */
+	crc = 0xFFFFFFFF;	/* initial value */
+
+	for (i = 0; i < 6; i++) {
+		c = *(addr + i);
+		for (j = 0; j < 8; j++) {
+			carry = ((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01);
+			crc <<= 1;
+			c >>= 1;
+			if (carry)
+				crc = (crc ^ 0x04c11db6) | carry;
+		}
+	}
+
+	/* return the filter bit position */
+	return (crc >> 26);
+}
+
+/*
+ * Program the 64-bit multicast hash filter.
+ */
+
+Static void
+rue_setmulti(struct rue_softc *sc)
+{
+	struct ifnet		*ifp;
+	int			h = 0;
+	u_int32_t		hashes[2] = { 0, 0 };
+	struct ifmultiaddr	*ifma;
+	u_int32_t		rxcfg;
+	int			mcnt = 0;
+
+	ifp = &sc->arpcom.ac_if;
+
+	rxcfg = rue_csr_read_2(sc, RUE_RCR);
+
+	if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
+		rxcfg |= (RUE_RCR_AAM | RUE_RCR_AAP);
+		rxcfg &= ~RUE_RCR_AM;
+		rue_csr_write_2(sc, RUE_RCR, rxcfg);
+		rue_csr_write_4(sc, RUE_MAR0, 0xFFFFFFFF);
+		rue_csr_write_4(sc, RUE_MAR4, 0xFFFFFFFF);
+		return;
+	}
+
+	/* first, zot all the existing hash bits */
+	rue_csr_write_4(sc, RUE_MAR0, 0);
+	rue_csr_write_4(sc, RUE_MAR4, 0);
+
+	/* now program new ones */
+	TAILQ_FOREACH (ifma, &ifp->if_multiaddrs, ifma_link) {
+		if (ifma->ifma_addr->sa_family != AF_LINK)
+			continue;
+		h = rue_calchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
+		if (h < 32)
+			hashes[0] |= (1 << h);
+		else
+			hashes[1] |= (1 << (h - 32));
+		mcnt++;
+	}
+
+	if (mcnt)
+		rxcfg |= RUE_RCR_AM;
+	else
+		rxcfg &= ~RUE_RCR_AM;
+
+	rxcfg &= ~(RUE_RCR_AAM | RUE_RCR_AAP);
+
+	rue_csr_write_2(sc, RUE_RCR, rxcfg);
+	rue_csr_write_4(sc, RUE_MAR0, hashes[0]);
+	rue_csr_write_4(sc, RUE_MAR4, hashes[1]);
+}
+
+Static void
+rue_reset(struct rue_softc *sc)
+{
+	int	i;
+
+	rue_csr_write_1(sc, RUE_CR, RUE_CR_SOFT_RST);
+
+	for (i = 0; i < RUE_TIMEOUT; i++) {
+		DELAY(500);
+		if (!(rue_csr_read_1(sc, RUE_CR) & RUE_CR_SOFT_RST))
+			break;
+	}
+	if (i == RUE_TIMEOUT)
+		printf("rue%d: reset never completed!\n", sc->rue_unit);
+
+	DELAY(10000);
+}
+
+/*
+ * Probe for a RTL8150 chip.
+ */
+
+USB_MATCH(rue)
+{
+	USB_MATCH_START(rue, uaa);
+	struct rue_type	*t;
+
+	if (uaa->iface == NULL)
+		return (UMATCH_NONE);
+
+	t = rue_devs;
+	while (t->rue_vid) {
+		if (uaa->vendor == t->rue_vid &&
+		    uaa->product == t->rue_did) {
+			return (UMATCH_VENDOR_PRODUCT);
+		}
+		t++;
+	}
+
+	return (UMATCH_NONE);
+}
+
+/*
+ * Attach the interface. Allocate softc structures, do ifmedia
+ * setup and ethernet/BPF attach.
+ */
+
+USB_ATTACH(rue)
+{
+	USB_ATTACH_START(rue, sc, uaa);
+	char				*devinfo;
+	u_char				eaddr[ETHER_ADDR_LEN];
+	struct ifnet			*ifp;
+	usbd_interface_handle		iface;
+	usbd_status			err;
+	usb_interface_descriptor_t	*id;
+	usb_endpoint_descriptor_t	*ed;
+	int				i;
+	struct rue_type			*t;
+
+	devinfo = malloc(1024, M_USBDEV, M_WAITOK);
+
+	bzero(sc, sizeof (struct rue_softc));
+	usbd_devinfo(uaa->device, 0, devinfo);
+
+	sc->rue_udev = uaa->device;
+	sc->rue_unit = device_get_unit(self);
+
+	if (usbd_set_config_no(sc->rue_udev, RUE_CONFIG_NO, 0)) {
+		printf("rue%d: getting interface handle failed\n",
+			sc->rue_unit);
+		goto error;
+	}
+
+	err = usbd_device2interface_handle(uaa->device, RUE_IFACE_IDX, &iface);
+	if (err) {
+		printf("rue%d: getting interface handle failed\n",
+		       sc->rue_unit);
+		goto error;
+	}
+
+	sc->rue_iface = iface;
+
+	t = rue_devs;
+	while (t->rue_vid) {
+		if (uaa->vendor == t->rue_vid &&
+		    uaa->product == t->rue_did) {
+			sc->rue_info = t;
+			break;
+		}
+		t++;
+	}
+
+	id = usbd_get_interface_descriptor(sc->rue_iface);
+
+	usbd_devinfo(uaa->device, 0, devinfo);
+	device_set_desc_copy(self, devinfo);
+	printf("%s: %s\n", USBDEVNAME(self), devinfo);
+
+	/* Find endpoints */
+	for (i = 0; i < id->bNumEndpoints; i++) {
+		ed = usbd_interface2endpoint_descriptor(iface, i);
+		if (ed == NULL) {
+			printf("rue%d: couldn't get ep %d\n", sc->rue_unit, i);
+			goto error;
+		}
+		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+			sc->rue_ed[RUE_ENDPT_RX] = ed->bEndpointAddress;
+		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
+			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+			sc->rue_ed[RUE_ENDPT_TX] = ed->bEndpointAddress;
+		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
+			sc->rue_ed[RUE_ENDPT_INTR] = ed->bEndpointAddress;
+		}
+	}
+
+	mtx_init(&sc->rue_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK,
+		 MTX_DEF | MTX_RECURSE);
+	RUE_LOCK(sc);
+
+	/* Reset the adapter */
+	rue_reset(sc);
+
+	/* Get station address from the EEPROM */
+	err = rue_read_mem(sc, RUE_EEPROM_IDR0,
+			   (caddr_t)&eaddr, ETHER_ADDR_LEN);
+	if (err) {
+		printf("rue%d: couldn't get station address\n", sc->rue_unit);
+		goto error1;
+	}
+
+	/* RealTek RTL8150 was detected */
+	printf("rue%d: Ethernet address: %6D\n", sc->rue_unit, eaddr, ":");
+
+	bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
+
+	ifp = &sc->arpcom.ac_if;
+	ifp->if_softc = sc;
+	ifp->if_unit = sc->rue_unit;
+	ifp->if_name = "rue";
+	ifp->if_mtu = ETHERMTU;
+	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
+	ifp->if_ioctl = rue_ioctl;
+	ifp->if_output = ether_output;
+	ifp->if_start = rue_start;
+	ifp->if_watchdog = rue_watchdog;
+	ifp->if_init = rue_init;
+	ifp->if_baudrate = 10000000;
+	ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
+
+	/* MII setup */
+	if (mii_phy_probe(self, &sc->rue_miibus,
+			  rue_ifmedia_upd, rue_ifmedia_sts)) {
+		printf("rue%d: MII without any PHY!\n", sc->rue_unit);
+		goto error1;
+	}
+
+	rue_qdat.ifp = ifp;
+	rue_qdat.if_rxstart = rue_rxstart;
+
+	/* Call MI attach routine */
+	ether_ifattach(ifp, eaddr);
+	callout_handle_init(&sc->rue_stat_ch);
+	usb_register_netisr();
+	sc->rue_dying = 0;
+
+	RUE_UNLOCK(sc);
+	free(devinfo, M_USBDEV);
+	USB_ATTACH_SUCCESS_RETURN;
+
+    error1:
+	RUE_UNLOCK(sc);
+	mtx_destroy(&sc->rue_mtx);
+    error:
+	free(devinfo, M_USBDEV);
+	USB_ATTACH_ERROR_RETURN;
+}
+
+Static int
+rue_detach(device_ptr_t dev)
+{
+	struct rue_softc	*sc;
+	struct ifnet		*ifp;
+
+	sc = device_get_softc(dev);
+	RUE_LOCK(sc);
+	ifp = &sc->arpcom.ac_if;
+
+	sc->rue_dying = 1;
+	untimeout(rue_tick, sc, sc->rue_stat_ch);
+	ether_ifdetach(ifp);
+
+	if (sc->rue_ep[RUE_ENDPT_TX] != NULL)
+		usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_TX]);
+	if (sc->rue_ep[RUE_ENDPT_RX] != NULL)
+		usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_RX]);
+#ifdef RUE_INTR_PIPE
+	if (sc->rue_ep[RUE_ENDPT_INTR] != NULL)
+		usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
+#endif
+
+	RUE_UNLOCK(sc);
+	mtx_destroy(&sc->rue_mtx);
+
+	return (0);
+}
+
+/*
+ * Initialize an RX descriptor and attach an MBUF cluster.
+ */
+
+Static int
+rue_newbuf(struct rue_softc *sc, struct rue_chain *c, struct mbuf *m)
+{
+	struct mbuf	*m_new = NULL;
+
+	if (m == NULL) {
+		MGETHDR(m_new, M_NOWAIT, MT_DATA);
+		if (m_new == NULL) {
+			printf("rue%d: no memory for rx list "
+				"-- packet dropped!\n", sc->rue_unit);
+			return (ENOBUFS);
+		}
+
+		MCLGET(m_new, M_NOWAIT);
+		if (!(m_new->m_flags & M_EXT)) {
+			printf("rue%d: no memory for rx list "
+				"-- packet dropped!\n", sc->rue_unit);
+			m_freem(m_new);
+			return (ENOBUFS);
+		}
+		m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
+	} else {
+		m_new = m;
+		m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
+		m_new->m_data = m_new->m_ext.ext_buf;
+	}
+
+	m_adj(m_new, ETHER_ALIGN);
+	c->rue_mbuf = m_new;
+
+	return (0);
+}
+
+Static int
+rue_rx_list_init(struct rue_softc *sc)
+{
+	struct rue_cdata	*cd;
+	struct rue_chain	*c;
+	int			i;
+
+	cd = &sc->rue_cdata;
+	for (i = 0; i < RUE_RX_LIST_CNT; i++) {
+		c = &cd->rue_rx_chain[i];
+		c->rue_sc = sc;
+		c->rue_idx = i;
+		if (rue_newbuf(sc, c, NULL) == ENOBUFS)
+			return (ENOBUFS);
+		if (c->rue_xfer == NULL) {
+			c->rue_xfer = usbd_alloc_xfer(sc->rue_udev);
+			if (c->rue_xfer == NULL)
+				return (ENOBUFS);
+		}
+	}
+
+	return (0);
+}
+
+Static int
+rue_tx_list_init(struct rue_softc *sc)
+{
+	struct rue_cdata	*cd;
+	struct rue_chain	*c;
+	int			i;
+
+	cd = &sc->rue_cdata;
+	for (i = 0; i < RUE_TX_LIST_CNT; i++) {
+		c = &cd->rue_tx_chain[i];
+		c->rue_sc = sc;
+		c->rue_idx = i;
+		c->rue_mbuf = NULL;
+		if (c->rue_xfer == NULL) {
+			c->rue_xfer = usbd_alloc_xfer(sc->rue_udev);
+			if (c->rue_xfer == NULL)
+				return (ENOBUFS);
+		}
+		c->rue_buf = malloc(RUE_BUFSZ, M_USBDEV, M_NOWAIT);
+		if (c->rue_buf == NULL)
+			return (ENOBUFS);
+	}
+
+	return (0);
+}
+
+#ifdef RUE_INTR_PIPE
+Static void
+rue_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+	struct rue_softc	*sc = priv;
+	struct ifnet		*ifp;
+	struct rue_intrpkt	*p;
+
+	RUE_LOCK(sc);
+	ifp = &sc->arpcom.ac_if;
+
+	if (!(ifp->if_flags & IFF_RUNNING)) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	if (status != USBD_NORMAL_COMPLETION) {
+		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+			RUE_UNLOCK(sc);
+			return;
+		}
+		printf("rue%d: usb error on intr: %s\n", sc->rue_unit,
+			usbd_errstr(status));
+		if (status == USBD_STALLED)
+			usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_INTR]);
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	usbd_get_xfer_status(xfer, NULL, (void **)&p, NULL, NULL);
+
+	ifp->if_ierrors += p->rue_rxlost_cnt;
+	ifp->if_ierrors += p->rue_crcerr_cnt;
+	ifp->if_collisions += p->rue_col_cnt;
+
+	RUE_UNLOCK(sc);
+}
+#endif
+
+Static void
+rue_rxstart(struct ifnet *ifp)
+{
+	struct rue_softc	*sc;
+	struct rue_chain	*c;
+
+	sc = ifp->if_softc;
+	RUE_LOCK(sc);
+	c = &sc->rue_cdata.rue_rx_chain[sc->rue_cdata.rue_rx_prod];
+
+	if (rue_newbuf(sc, c, NULL) == ENOBUFS) {
+		ifp->if_ierrors++;
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	/* Setup new transfer. */
+	usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_RX],
+		c, mtod(c->rue_mbuf, char *), RUE_BUFSZ, USBD_SHORT_XFER_OK,
+		USBD_NO_TIMEOUT, rue_rxeof);
+	usbd_transfer(c->rue_xfer);
+
+	RUE_UNLOCK(sc);
+}
+
+/*
+ * A frame has been uploaded: pass the resulting mbuf chain up to
+ * the higher level protocols.
+ */
+
+Static void
+rue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+	struct rue_chain	*c = priv;
+	struct rue_softc	*sc = c->rue_sc;
+	struct mbuf		*m;
+	struct ifnet		*ifp;
+	int			total_len = 0;
+	struct rue_rxpkt	r;
+
+	if (sc->rue_dying)
+		return;
+	RUE_LOCK(sc);
+	ifp = &sc->arpcom.ac_if;
+
+	if (!(ifp->if_flags & IFF_RUNNING)) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	if (status != USBD_NORMAL_COMPLETION) {
+		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+			RUE_UNLOCK(sc);
+			return;
+		}
+		if (usbd_ratecheck(&sc->rue_rx_notice))
+			printf("rue%d: usb error on rx: %s\n", sc->rue_unit,
+			       usbd_errstr(status));
+		if (status == USBD_STALLED)
+			usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_RX]);
+		goto done;
+	}
+
+	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
+
+	if (total_len <= ETHER_CRC_LEN) {
+		ifp->if_ierrors++;
+		goto done;
+	}
+
+	m = c->rue_mbuf;
+	bcopy(mtod(m, char *) + total_len - 4, (char *)&r, sizeof (r));
+
+	/* Check recieve packet was valid or not */
+	if ((r.rue_rxstat & RUE_RXSTAT_VALID) == 0) {
+		ifp->if_ierrors++;
+		goto done;
+	}
+
+	/* No errors; receive the packet. */
+	total_len -= ETHER_CRC_LEN;
+
+	ifp->if_ipackets++;
+	m->m_pkthdr.rcvif = (struct ifnet *)&rue_qdat;
+	m->m_pkthdr.len = m->m_len = total_len;
+
+	/* Put the packet on the special USB input queue. */
+	usb_ether_input(m);
+
+	RUE_UNLOCK(sc);
+	return;
+
+    done:
+	/* Setup new transfer. */
+	usbd_setup_xfer(xfer, sc->rue_ep[RUE_ENDPT_RX],
+			c, mtod(c->rue_mbuf, char *), RUE_BUFSZ,
+			USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, rue_rxeof);
+	usbd_transfer(xfer);
+	RUE_UNLOCK(sc);
+}
+
+/*
+ * A frame was downloaded to the chip. It's safe for us to clean up
+ * the list buffers.
+ */
+
+Static void
+rue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+	struct rue_chain	*c = priv;
+	struct rue_softc	*sc = c->rue_sc;
+	struct ifnet		*ifp;
+	usbd_status		err;
+
+	RUE_LOCK(sc);
+
+	ifp = &sc->arpcom.ac_if;
+
+	if (status != USBD_NORMAL_COMPLETION) {
+		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+			RUE_UNLOCK(sc);
+			return;
+		}
+		printf("rue%d: usb error on tx: %s\n", sc->rue_unit,
+			usbd_errstr(status));
+		if (status == USBD_STALLED)
+			usbd_clear_endpoint_stall(sc->rue_ep[RUE_ENDPT_TX]);
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	ifp->if_timer = 0;
+	ifp->if_flags &= ~IFF_OACTIVE;
+	usbd_get_xfer_status(c->rue_xfer, NULL, NULL, NULL, &err);
+
+	if (c->rue_mbuf != NULL) {
+		c->rue_mbuf->m_pkthdr.rcvif = ifp;
+		usb_tx_done(c->rue_mbuf);
+		c->rue_mbuf = NULL;
+	}
+
+	if (err)
+		ifp->if_oerrors++;
+	else
+		ifp->if_opackets++;
+
+	RUE_UNLOCK(sc);
+}
+
+Static void
+rue_tick(void *xsc)
+{
+	struct rue_softc	*sc = xsc;
+	struct ifnet		*ifp;
+	struct mii_data		*mii;
+
+	if (sc == NULL)
+		return;
+
+	RUE_LOCK(sc);
+
+	ifp = &sc->arpcom.ac_if;
+	mii = GET_MII(sc);
+	if (mii == NULL) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	mii_tick(mii);
+	if (!sc->rue_link && mii->mii_media_status & IFM_ACTIVE &&
+	    IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
+		sc->rue_link++;
+		if (ifp->if_snd.ifq_head != NULL)
+			rue_start(ifp);
+	}
+
+	sc->rue_stat_ch = timeout(rue_tick, sc, hz);
+
+	RUE_UNLOCK(sc);
+}
+
+Static int
+rue_encap(struct rue_softc *sc, struct mbuf *m, int idx)
+{
+	int			total_len;
+	struct rue_chain	*c;
+	usbd_status		err;
+
+	c = &sc->rue_cdata.rue_tx_chain[idx];
+
+	/*
+	 * Copy the mbuf data into a contiguous buffer
+	 */
+	m_copydata(m, 0, m->m_pkthdr.len, c->rue_buf);
+	c->rue_mbuf = m;
+
+	total_len = m->m_pkthdr.len;
+
+	/*
+	 * This is an undocumented behavior.
+	 * RTL8150 chip doesn't send frame length smaller than
+	 * RUE_MIN_FRAMELEN (60) byte packet.
+	 */
+	if (total_len < RUE_MIN_FRAMELEN)
+		total_len = RUE_MIN_FRAMELEN;
+
+	usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_TX],
+			c, c->rue_buf, total_len, USBD_FORCE_SHORT_XFER,
+			10000, rue_txeof);
+
+	/* Transmit */
+	err = usbd_transfer(c->rue_xfer);
+	if (err != USBD_IN_PROGRESS) {
+		rue_stop(sc);
+		return (EIO);
+	}
+
+	sc->rue_cdata.rue_tx_cnt++;
+
+	return (0);
+}
+
+Static void
+rue_start(struct ifnet *ifp)
+{
+	struct rue_softc	*sc = ifp->if_softc;
+	struct mbuf		*m_head = NULL;
+
+	RUE_LOCK(sc);
+
+	if (!sc->rue_link) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	if (ifp->if_flags & IFF_OACTIVE) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	IF_DEQUEUE(&ifp->if_snd, m_head);
+	if (m_head == NULL) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	if (rue_encap(sc, m_head, 0)) {
+		IF_PREPEND(&ifp->if_snd, m_head);
+		ifp->if_flags |= IFF_OACTIVE;
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	/*
+	 * If there's a BPF listener, bounce a copy of this frame
+	 * to him.
+	 */
+	BPF_MTAP(ifp, m_head);
+
+	ifp->if_flags |= IFF_OACTIVE;
+
+	/*
+	 * Set a timeout in case the chip goes out to lunch.
+	 */
+	ifp->if_timer = 5;
+
+	RUE_UNLOCK(sc);
+}
+
+Static void
+rue_init(void *xsc)
+{
+	struct rue_softc	*sc = xsc;
+	struct ifnet		*ifp = &sc->arpcom.ac_if;
+	struct mii_data		*mii = GET_MII(sc);
+	struct rue_chain	*c;
+	usbd_status		err;
+	int			i;
+	int			rxcfg;
+
+	RUE_LOCK(sc);
+
+	if (ifp->if_flags & IFF_RUNNING) {
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	/*
+	 * Cancel pending I/O and free all RX/TX buffers.
+	 */
+	rue_reset(sc);
+
+	/* Set MAC address */
+	rue_write_mem(sc, RUE_IDR0, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
+
+	/* Init TX ring. */
+	if (rue_tx_list_init(sc) == ENOBUFS) {
+		printf("rue%d: tx list init failed\n", sc->rue_unit);
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+	/* Init RX ring. */
+	if (rue_rx_list_init(sc) == ENOBUFS) {
+		printf("rue%d: rx list init failed\n", sc->rue_unit);
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+#ifdef RUE_INTR_PIPE
+	sc->rue_cdata.rue_ibuf = malloc(RUE_INTR_PKTLEN, M_USBDEV, M_NOWAIT);
+#endif
+
+	/*
+	 * Set the initial TX and RX configuration.
+	 */
+	rue_csr_write_1(sc, RUE_TCR, RUE_TCR_CONFIG);
+
+	rxcfg = RUE_RCR_CONFIG;
+
+	/* Set capture broadcast bit to capture broadcast frames. */
+	if (ifp->if_flags & IFF_BROADCAST)
+		rxcfg |= RUE_RCR_AB;
+	else
+		rxcfg &= ~RUE_RCR_AB;
+
+	/* If we want promiscuous mode, set the allframes bit. */
+	if (ifp->if_flags & IFF_PROMISC)
+		rxcfg |= RUE_RCR_AAP;
+	else
+		rxcfg &= ~RUE_RCR_AAP;
+
+	rue_csr_write_2(sc, RUE_RCR, rxcfg);
+
+	/* Load the multicast filter. */
+	rue_setmulti(sc);
+
+	/* Enable RX and TX */
+	rue_csr_write_1(sc, RUE_CR, (RUE_CR_TE | RUE_CR_RE | RUE_CR_EP3CLREN));
+
+	mii_mediachg(mii);
+
+	/* Open RX and TX pipes. */
+	err = usbd_open_pipe(sc->rue_iface, sc->rue_ed[RUE_ENDPT_RX],
+			     USBD_EXCLUSIVE_USE, &sc->rue_ep[RUE_ENDPT_RX]);
+	if (err) {
+		printf("rue%d: open rx pipe failed: %s\n",
+			sc->rue_unit, usbd_errstr(err));
+		RUE_UNLOCK(sc);
+		return;
+	}
+	err = usbd_open_pipe(sc->rue_iface, sc->rue_ed[RUE_ENDPT_TX],
+			     USBD_EXCLUSIVE_USE, &sc->rue_ep[RUE_ENDPT_TX]);
+	if (err) {
+		printf("rue%d: open tx pipe failed: %s\n",
+			sc->rue_unit, usbd_errstr(err));
+		RUE_UNLOCK(sc);
+		return;
+	}
+
+#ifdef RUE_INTR_PIPE
+	err = usbd_open_pipe_intr(sc->rue_iface, sc->rue_ed[RUE_ENDPT_INTR],
+				  USBD_SHORT_XFER_OK,
+				  &sc->rue_ep[RUE_ENDPT_INTR], sc,
+				  sc->rue_cdata.rue_ibuf, RUE_INTR_PKTLEN,
+				  rue_intr, RUE_INTR_INTERVAL);
+	if (err) {
+		printf("rue%d: open intr pipe failed: %s\n",
+			sc->rue_unit, usbd_errstr(err));
+		RUE_UNLOCK(sc);
+		return;
+	}
+#endif
+
+	/* Start up the receive pipe. */
+	for (i = 0; i < RUE_RX_LIST_CNT; i++) {
+		c = &sc->rue_cdata.rue_rx_chain[i];
+		usbd_setup_xfer(c->rue_xfer, sc->rue_ep[RUE_ENDPT_RX],
+				c, mtod(c->rue_mbuf, char *), RUE_BUFSZ,
+				USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, rue_rxeof);
+		usbd_transfer(c->rue_xfer);
+	}
+
+	ifp->if_flags |= IFF_RUNNING;
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+	sc->rue_stat_ch = timeout(rue_tick, sc, hz);
+
+	RUE_UNLOCK(sc);
+}
+
+/*
+ * Set media options.
+ */
+
+Static int
+rue_ifmedia_upd(struct ifnet *ifp)
+{
+	struct rue_softc	*sc = ifp->if_softc;
+	struct mii_data		*mii = GET_MII(sc);
+
+	sc->rue_link = 0;
+	if (mii->mii_instance) {
+		struct mii_softc	*miisc;
+		LIST_FOREACH (miisc, &mii->mii_phys, mii_list)
+			mii_phy_reset(miisc);
+	}
+	mii_mediachg(mii);
+
+	return (0);
+}
+
+/*
+ * Report current media status.
+ */
+
+Static void
+rue_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
+{
+	struct rue_softc	*sc = ifp->if_softc;
+	struct mii_data		*mii = GET_MII(sc);
+
+	mii_pollstat(mii);
+	ifmr->ifm_active = mii->mii_media_active;
+	ifmr->ifm_status = mii->mii_media_status;
+}
+
+Static int
+rue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
+{
+	struct rue_softc	*sc = ifp->if_softc;
+	struct ifreq		*ifr = (struct ifreq *)data;
+	struct mii_data		*mii;
+	int			error = 0;
+
+	RUE_LOCK(sc);
+
+	switch (command) {
+	case SIOCSIFFLAGS:
+		if (ifp->if_flags & IFF_UP) {
+			if (ifp->if_flags & IFF_RUNNING &&
+			    ifp->if_flags & IFF_PROMISC &&
+			    !(sc->rue_if_flags & IFF_PROMISC)) {
+				RUE_SETBIT_2(sc, RUE_RCR,
+					     (RUE_RCR_AAM | RUE_RCR_AAP));
+				rue_setmulti(sc);
+			} else if (ifp->if_flags & IFF_RUNNING &&
+				   !(ifp->if_flags & IFF_PROMISC) &&
+				   sc->rue_if_flags & IFF_PROMISC) {
+				RUE_CLRBIT_2(sc, RUE_RCR,
+					     (RUE_RCR_AAM | RUE_RCR_AAP));
+				rue_setmulti(sc);
+			} else if (!(ifp->if_flags & IFF_RUNNING))
+				rue_init(sc);
+		} else {
+			if (ifp->if_flags & IFF_RUNNING)
+				rue_stop(sc);
+		}
+		sc->rue_if_flags = ifp->if_flags;
+		error = 0;
+		break;
+	case SIOCADDMULTI:
+	case SIOCDELMULTI:
+		rue_setmulti(sc);
+		error = 0;
+		break;
+	case SIOCGIFMEDIA:
+	case SIOCSIFMEDIA:
+		mii = GET_MII(sc);
+		error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, command);
+		break;
+	default:
+		error = ether_ioctl(ifp, command, data);
+		break;
+	}
+
+	RUE_UNLOCK(sc);
+
+	return (error);
+}
+
+Static void
+rue_watchdog(struct ifnet *ifp)
+{
+	struct rue_softc	*sc = ifp->if_softc;
+	struct rue_chain	*c;
+	usbd_status		stat;
+
+	RUE_LOCK(sc);
+
+	ifp->if_oerrors++;
+	printf("rue%d: watchdog timeout\n", sc->rue_unit);
+
+	c = &sc->rue_cdata.rue_tx_chain[0];
+	usbd_get_xfer_status(c->rue_xfer, NULL, NULL, NULL, &stat);
+	rue_txeof(c->rue_xfer, c, stat);
+
+	if (ifp->if_snd.ifq_head != NULL)
+		rue_start(ifp);
+
+	RUE_UNLOCK(sc);
+}
+
+/*
+ * Stop the adapter and free any mbufs allocated to the
+ * RX and TX lists.
+ */
+
+Static void
+rue_stop(struct rue_softc *sc)
+{
+	usbd_status	err;
+	struct ifnet	*ifp;
+	int		i;
+
+	RUE_LOCK(sc);
+
+	ifp = &sc->arpcom.ac_if;
+	ifp->if_timer = 0;
+
+	rue_csr_write_1(sc, RUE_CR, 0x00);
+	rue_reset(sc);
+
+	untimeout(rue_tick, sc, sc->rue_stat_ch);
+
+	/* Stop transfers. */
+	if (sc->rue_ep[RUE_ENDPT_RX] != NULL) {
+		err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_RX]);
+		if (err) {
+			printf("rue%d: abort rx pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_RX]);
+		if (err) {
+			printf("rue%d: close rx pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		sc->rue_ep[RUE_ENDPT_RX] = NULL;
+	}
+
+	if (sc->rue_ep[RUE_ENDPT_TX] != NULL) {
+		err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_TX]);
+		if (err) {
+			printf("rue%d: abort tx pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_TX]);
+		if (err) {
+			printf("rue%d: close tx pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		sc->rue_ep[RUE_ENDPT_TX] = NULL;
+	}
+
+#ifdef RUE_INTR_PIPE
+	if (sc->rue_ep[RUE_ENDPT_INTR] != NULL) {
+		err = usbd_abort_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
+		if (err) {
+			printf("rue%d: abort intr pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		err = usbd_close_pipe(sc->rue_ep[RUE_ENDPT_INTR]);
+		if (err) {
+			printf("rue%d: close intr pipe failed: %s\n",
+			       sc->rue_unit, usbd_errstr(err));
+		}
+		sc->rue_ep[RUE_ENDPT_INTR] = NULL;
+	}
+#endif
+
+	/* Free RX resources. */
+	for (i = 0; i < RUE_RX_LIST_CNT; i++) {
+		if (sc->rue_cdata.rue_rx_chain[i].rue_buf != NULL) {
+			free(sc->rue_cdata.rue_rx_chain[i].rue_buf, M_USBDEV);
+			sc->rue_cdata.rue_rx_chain[i].rue_buf = NULL;
+		}
+		if (sc->rue_cdata.rue_rx_chain[i].rue_mbuf != NULL) {
+			m_freem(sc->rue_cdata.rue_rx_chain[i].rue_mbuf);
+			sc->rue_cdata.rue_rx_chain[i].rue_mbuf = NULL;
+		}
+		if (sc->rue_cdata.rue_rx_chain[i].rue_xfer != NULL) {
+			usbd_free_xfer(sc->rue_cdata.rue_rx_chain[i].rue_xfer);
+			sc->rue_cdata.rue_rx_chain[i].rue_xfer = NULL;
+		}
+	}
+
+	/* Free TX resources. */
+	for (i = 0; i < RUE_TX_LIST_CNT; i++) {
+		if (sc->rue_cdata.rue_tx_chain[i].rue_buf != NULL) {
+			free(sc->rue_cdata.rue_tx_chain[i].rue_buf, M_USBDEV);
+			sc->rue_cdata.rue_tx_chain[i].rue_buf = NULL;
+		}
+		if (sc->rue_cdata.rue_tx_chain[i].rue_mbuf != NULL) {
+			m_freem(sc->rue_cdata.rue_tx_chain[i].rue_mbuf);
+			sc->rue_cdata.rue_tx_chain[i].rue_mbuf = NULL;
+		}
+		if (sc->rue_cdata.rue_tx_chain[i].rue_xfer != NULL) {
+			usbd_free_xfer(sc->rue_cdata.rue_tx_chain[i].rue_xfer);
+			sc->rue_cdata.rue_tx_chain[i].rue_xfer = NULL;
+		}
+	}
+
+#ifdef RUE_INTR_PIPE
+	free(sc->rue_cdata.rue_ibuf, M_USBDEV);
+	sc->rue_cdata.rue_ibuf = NULL;
+#endif
+
+	sc->rue_link = 0;
+
+	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+
+	RUE_UNLOCK(sc);
+}
+
+/*
+ * Stop all chip I/O so that the kernel's probe routines don't
+ * get confused by errant DMAs when rebooting.
+ */
+
+Static void
+rue_shutdown(device_ptr_t dev)
+{
+	struct rue_softc	*sc;
+
+	sc = device_get_softc(dev);
+
+	sc->rue_dying++;
+	RUE_LOCK(sc);
+	rue_reset(sc);
+	rue_stop(sc);
+	RUE_UNLOCK(sc);
+}
diff --git a/sys/dev/usb/if_ruereg.h b/sys/dev/usb/if_ruereg.h
new file mode 100644
index 0000000..ec8b0e6
--- /dev/null
+++ b/sys/dev/usb/if_ruereg.h
@@ -0,0 +1,247 @@
+/*-
+ * Copyright (c) 2001-2003, Shunsuke Akiyama <akiyama@FreeBSD.org>.
+ * All rights reserved.
+ *
+ * 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
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _IF_RUEREG_H_
+#define _IF_RUEREG_H_
+
+#define RUE_INTR_PIPE		1	/* Use INTR PIPE */
+
+#define RUE_CONFIG_NO		1
+#define RUE_IFACE_IDX		0
+
+#define RUE_ENDPT_RX		0x0
+#define RUE_ENDPT_TX		0x1
+#define RUE_ENDPT_INTR		0x2
+#define RUE_ENDPT_MAX		0x3
+
+#define RUE_INTR_PKTLEN		0x8
+
+#define RUE_TIMEOUT		1000
+#define	ETHER_ALIGN		2
+#define RUE_BUFSZ		1536
+#define RUE_MIN_FRAMELEN	60
+#define	RUE_INTR_INTERVAL	100	/* ms */
+
+/*
+ * Registers
+ */
+
+#define RUE_IDR0		0x0120
+#define RUE_IDR1		0x0121
+#define RUE_IDR2		0x0122
+#define RUE_IDR3		0x0123
+#define RUE_IDR4		0x0124
+#define RUE_IDR5		0x0125
+
+#define RUE_MAR0		0x0126
+#define RUE_MAR1		0x0127
+#define RUE_MAR2		0x0128
+#define RUE_MAR3		0x0129
+#define RUE_MAR4		0x012A
+#define RUE_MAR5		0x012B
+#define RUE_MAR6		0x012C
+#define RUE_MAR7		0x012D
+
+#define RUE_CR			0x012E		/* B, R/W */
+#define RUE_CR_SOFT_RST		0x10
+#define RUE_CR_RE		0x08
+#define RUE_CR_TE		0x04
+#define RUE_CR_EP3CLREN		0x02
+
+#define RUE_TCR			0x012F		/* B, R/W */
+#define RUE_TCR_TXRR1		0x80
+#define RUE_TCR_TXRR0		0x40
+#define RUE_TCR_IFG1		0x10
+#define RUE_TCR_IFG0		0x08
+#define RUE_TCR_NOCRC		0x01
+#define RUE_TCR_CONFIG		(RUE_TCR_TXRR1|RUE_TCR_TXRR0|RUE_TCR_IFG1|RUE_TCR_IFG0)
+
+#define RUE_RCR			0x0130		/* W, R/W */
+#define RUE_RCR_TAIL		0x80
+#define RUE_RCR_AER		0x40
+#define RUE_RCR_AR		0x20
+#define RUE_RCR_AM		0x10
+#define RUE_RCR_AB		0x08
+#define RUE_RCR_AD		0x04
+#define RUE_RCR_AAM		0x02
+#define RUE_RCR_AAP		0x01
+#define RUE_RCR_CONFIG		(RUE_RCR_TAIL|RUE_RCR_AD)
+
+#define RUE_TSR			0x0132
+#define RUE_RSR			0x0133
+#define RUE_CON0		0x0135
+#define RUE_CON1		0x0136
+#define RUE_MSR			0x0137
+#define RUE_PHYADD		0x0138
+#define RUE_PHYDAT		0x0139
+
+#define RUE_PHYCNT		0x013B		/* B, R/W */
+#define RUE_PHYCNT_PHYOWN	0x40
+#define RUE_PHYCNT_RWCR		0x20
+
+#define RUE_GPPC		0x013D
+#define RUE_WAKECNT		0x013E
+
+#define RUE_BMCR		0x0140
+#define RUE_BMCR_SPD_SET	0x2000
+#define RUE_BMCR_DUPLEX		0x0100
+
+#define RUE_BMSR		0x0142
+
+#define RUE_ANAR		0x0144		/* W, R/W */
+#define RUE_ANAR_PAUSE		0x0400
+
+#define RUE_ANLP		0x0146		/* W, R/O */
+#define RUE_ANLP_PAUSE		0x0400
+
+#define RUE_AER			0x0148
+
+#define RUE_NWAYT		0x014A
+#define RUE_CSCR		0x014C
+
+#define RUE_CRC0		0x014E
+#define RUE_CRC1		0x0150
+#define RUE_CRC2		0x0152
+#define RUE_CRC3		0x0154
+#define RUE_CRC4		0x0156
+
+#define RUE_BYTEMASK0		0x0158
+#define RUE_BYTEMASK1		0x0160
+#define RUE_BYTEMASK2		0x0168
+#define RUE_BYTEMASK3		0x0170
+#define RUE_BYTEMASK4		0x0178
+
+#define RUE_PHY1		0x0180
+#define RUE_PHY2		0x0184
+
+#define RUE_TW1			0x0186
+
+#define RUE_REG_MIN		0x0120
+#define RUE_REG_MAX		0x0189
+
+/*
+ * EEPROM address declarations
+ */
+
+#define RUE_EEPROM_BASE		0x1200
+
+#define RUE_EEPROM_IDR0		(RUE_EEPROM_BASE + 0x02)
+#define RUE_EEPROM_IDR1		(RUE_EEPROM_BASE + 0x03)
+#define RUE_EEPROM_IDR2		(RUE_EEPROM_BASE + 0x03)
+#define RUE_EEPROM_IDR3		(RUE_EEPROM_BASE + 0x03)
+#define RUE_EEPROM_IDR4		(RUE_EEPROM_BASE + 0x03)
+#define RUE_EEPROM_IDR5		(RUE_EEPROM_BASE + 0x03)
+
+#define RUE_EEPROM_INTERVAL	(RUE_EEPROM_BASE + 0x17)
+
+struct rue_intrpkt {
+	u_int8_t		rue_tsr;
+	u_int8_t		rue_rsr;
+	u_int8_t		rue_gep_msr;
+	u_int8_t		rue_waksr;
+	u_int8_t		rue_txok_cnt;
+	u_int8_t		rue_rxlost_cnt;
+	u_int8_t		rue_crcerr_cnt;
+	u_int8_t		rue_col_cnt;
+};
+
+struct rue_rxpkt {
+	u_int16_t		rue_pktlen : 12;
+	u_int16_t		rue_rxstat : 4;
+};
+
+#define RUE_RXSTAT_VALID	0x01
+#define RUE_RXSTAT_RUNT		0x02
+#define RUE_RXSTAT_PMATCH	0x04
+#define RUE_RXSTAT_MCAST	0x08
+
+#define RUE_RXSTAT_MASK		RUE_RXSTAT_VALID
+
+struct rue_type {
+	u_int16_t		rue_vid;
+	u_int16_t		rue_did;
+};
+
+#define RUE_TX_LIST_CNT		1
+#define RUE_RX_LIST_CNT		1
+
+struct rue_softc;
+
+struct rue_chain {
+	struct rue_softc	*rue_sc;
+	usbd_xfer_handle	rue_xfer;
+	char			*rue_buf;
+	struct mbuf		*rue_mbuf;
+	int			rue_idx;
+};
+
+struct rue_cdata {
+	struct rue_chain	rue_tx_chain[RUE_TX_LIST_CNT];
+	struct rue_chain	rue_rx_chain[RUE_RX_LIST_CNT];
+	struct rue_intrpkt	*rue_ibuf;
+	int			rue_tx_prod;
+	int			rue_tx_cons;
+	int			rue_tx_cnt;
+	int			rue_rx_prod;
+};
+
+struct rue_softc {
+	struct arpcom		arpcom;
+	device_t		rue_miibus;
+	usbd_device_handle	rue_udev;
+	usbd_interface_handle	rue_iface;
+	struct rue_type		*rue_info;
+	int			rue_ed[RUE_ENDPT_MAX];
+	usbd_pipe_handle	rue_ep[RUE_ENDPT_MAX];
+	int			rue_unit;
+	u_int8_t		rue_link;
+	int			rue_if_flags;
+	struct rue_cdata	rue_cdata;
+	struct callout_handle	rue_stat_ch;
+	struct mtx		rue_mtx;
+	char			rue_dying;
+	struct timeval		rue_rx_notice;
+};
+
+#if defined(__FreeBSD__)
+#define GET_MII(sc)	(device_get_softc((sc)->rue_miibus))
+#elif defined(__NetBSD__)
+#define GET_MII(sc)	(&(sc)->rue_mii)
+#elif defined(__OpenBSD__)
+#define GET_MII(sc)	(&(sc)->rue_mii)
+#endif
+
+#if 0
+#define RUE_LOCK(_sc)		mtx_lock(&(_sc)->rue_mtx)
+#define RUE_UNLOCK(_sc)		mtx_unlock(&(_sc)->rue_mtx)
+#else
+#define RUE_LOCK(_sc)
+#define RUE_UNLOCK(_sc)
+#endif
+
+#endif /* _IF_RUEREG_H_ */
diff --git a/sys/dev/usb/usbdevs b/sys/dev/usb/usbdevs
index 162c99f..92fc93c 100644
--- a/sys/dev/usb/usbdevs
+++ b/sys/dev/usb/usbdevs
@@ -335,6 +335,7 @@ vendor TODOS		0x0b0c	Todos Data System
 vendor NEC2		0x0b62	NEC
 vendor ATI2		0x0b6f	ATI
 vendor ASIX		0x0b95	ASIX Electronics
+vendor REALTEK		0x0bda	RealTek
 vendor AGATE		0x0c08	Agate Technologies
 vendor DMI		0x0c0b	DMI
 vendor LUWEN		0x0c76	Luwen
@@ -823,6 +824,7 @@ product MCT SITECOM_USB232	0x0230	Sitecom USB-232 Products
 product MELCO LUATX1		0x0001	LUA-TX Ethernet
 product MELCO LUATX5		0x0005	LUA-TX Ethernet
 product MELCO LUA2TX5		0x0009	LUA2-TX Ethernet
+product MELCO LUAKTX		0x0012	LUA-KTX Ethernet
 product	MELCO DUBPXXG		0x001c	USB-IDE Bridge: DUB-PxxG
 
 /* Metricom products */
@@ -985,6 +987,9 @@ product QUICKSHOT STRIKEPAD	0x6238	USB StrikePad
 /* Rainbow Technologies products */
 product	RAINBOW IKEY2000	0x1200	i-Key 2000  
 
+/* ReakTek products */
+product REALTEK USBKR100	0x8150	USBKR100 USB Ethernet (GREEN HOUSE)
+
 /* Roland products */
 product	ROLAND UM1		0x0009	UM-1 MIDI I/F
 product	ROLAND UM880N		0x0014	EDIROL UM-880 MIDI I/F (native)
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index 59a0cdf..746d740 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -96,6 +96,7 @@ SUBDIR=	accf_data \
 	rc4 \
 	rl \
 	rp \
+	rue \
 	sbsh \
 	sf \
 	sis \
diff --git a/sys/modules/mii/Makefile b/sys/modules/mii/Makefile
index 67da740..dfebd60 100644
--- a/sys/modules/mii/Makefile
+++ b/sys/modules/mii/Makefile
@@ -7,6 +7,7 @@ SRCS=	mii.c mii_physubr.c ukphy.c ukphy_subr.c bus_if.h pci_if.h
 SRCS+=	miibus_if.h miidevs.h device_if.h miibus_if.c e1000phy.c exphy.c nsphy.c
 SRCS+=	mlphy.c tlphy.c rlphy.c amphy.c dcphy.c pnphy.c inphy.c
 SRCS+=	bmtphy.c brgphy.c xmphy.c pnaphy.c lxtphy.c qsphy.c acphy.c nsgphy.c
+SRCS+=	ruephy.c
 
 EXPORT_SYMS=	mii_mediachg	\
 		mii_tick	\
diff --git a/sys/modules/rue/Makefile b/sys/modules/rue/Makefile
new file mode 100644
index 0000000..92456e5
--- /dev/null
+++ b/sys/modules/rue/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+S=	${.CURDIR}/../..
+.PATH: $S/dev/usb
+
+KMOD=	if_rue
+SRCS=	if_rue.c opt_bdg.h opt_usb.h device_if.h bus_if.h
+SRCS+=	miibus_if.h
+
+.include <bsd.kmod.mk>