Add USB Communication Device Class Ethernet driver. Originally written for

FreeBSD based on aue(4) it was picked by OpenBSD, then from OpenBSD ported
to NetBSD and finally NetBSD version merged with original one goes into
FreeBSD.

Obtained from:  http://www.gank.org/freebsd/cdce/
                NetBSD
                OpenBSD

14 files changed, 937 insertions, 0 deletions

diff --git a/sys/alpha/conf/GENERIC b/sys/alpha/conf/GENERIC
index 3cf6b6e..3cef689 100644
--- a/sys/alpha/conf/GENERIC
+++ b/sys/alpha/conf/GENERIC
@@ -206,6 +206,7 @@ device		ums		# Mouse
 # USB Ethernet, requires miibus
 device		aue		# ADMtek USB Ethernet
 device		axe		# ASIX Electronics USB Ethernet
+device		cdce		# Generic USB over Ethernet
 device		cue		# CATC USB Ethernet
 device		kue		# Kawasaki LSI USB Ethernet
 device		rue		# RealTek RTL8150 USB Ethernet
diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC
index 54a2c82..e8463fd 100644
--- a/sys/amd64/conf/GENERIC
+++ b/sys/amd64/conf/GENERIC
@@ -259,6 +259,7 @@ device		uscanner	# Scanners
 # USB Ethernet, requires miibus
 device		aue		# ADMtek USB Ethernet
 device		axe		# ASIX Electronics USB Ethernet
+device		cdce		# Generic USB over Ethernet
 device		cue		# CATC USB Ethernet
 device		kue		# Kawasaki LSI USB Ethernet
 device		rue		# RealTek RTL8150 USB Ethernet
diff --git a/sys/conf/NOTES b/sys/conf/NOTES
index 80f160b..d151c41 100644
--- a/sys/conf/NOTES
+++ b/sys/conf/NOTES
@@ -2327,6 +2327,11 @@ device		aue
 device		axe
 
 #
+# Devices which communicate using Ethernet over USB, particularly
+# Communication Device Class (CDC) Ethernet specification. Supports
+# Sharp Zaurus PDAs, some DOCSIS cable modems and so on.
+device		cdce
+#
 # CATC USB-EL1201A USB ethernet. Supports the CATC Netmate
 # and Netmate II, and the Belkin F5U111.
 device		cue
diff --git a/sys/conf/files b/sys/conf/files
index 2226997..c734acc 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -830,6 +830,7 @@ dev/usb/ehci_pci.c		optional ehci pci
 dev/usb/hid.c			optional usb
 dev/usb/if_aue.c		optional aue
 dev/usb/if_axe.c		optional axe
+dev/usb/if_cdce.c		optional cdce
 dev/usb/if_cue.c		optional cue
 dev/usb/if_kue.c		optional kue
 dev/usb/if_rue.c		optional rue
diff --git a/sys/dev/usb/if_cdce.c b/sys/dev/usb/if_cdce.c
new file mode 100644
index 0000000..f4efa4e
--- /dev/null
+++ b/sys/dev/usb/if_cdce.c
@@ -0,0 +1,807 @@
+/*	$NetBSD: if_cdce.c,v 1.4 2004/10/24 12:50:54 augustss Exp $ */
+
+/*
+ * Copyright (c) 1997, 1998, 1999, 2000-2003 Bill Paul <wpaul@windriver.com>
+ * Copyright (c) 2003-2005 Craig Boston
+ * Copyright (c) 2004 Daniel Hartmeier
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Bill Paul.
+ * 4. Neither the name of the author nor the names of any co-contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Bill Paul 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 Bill Paul, THE VOICES IN HIS HEAD OR
+ * THE 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.
+ */
+
+/*
+ * USB Communication Device Class (Ethernet Networking Control Model)
+ * http://www.usb.org/developers/devclass_docs/usbcdc11.pdf
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#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/module.h>
+#include <sys/socket.h>
+
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <net/ethernet.h>
+
+#include <net/bpf.h>
+
+#include <sys/bus.h>
+#include <machine/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/usb_ethersubr.h>
+
+#include <dev/usb/usbcdc.h>
+#include "usbdevs.h"
+#include <dev/usb/if_cdcereg.h>
+
+Static device_shutdown_t cdce_shutdown;
+USB_DECLARE_DRIVER_INIT(cdce,
+	DEVMETHOD(device_probe, cdce_match),
+	DEVMETHOD(device_attach, cdce_attach),
+	DEVMETHOD(device_detach, cdce_detach),
+	DEVMETHOD(device_shutdown, cdce_shutdown)
+	);
+DRIVER_MODULE(cdce, uhub, cdce_driver, cdce_devclass, usbd_driver_load, 0);
+MODULE_VERSION(cdce, 0);
+
+Static int	 cdce_tx_list_init(struct cdce_softc *);
+Static int	 cdce_rx_list_init(struct cdce_softc *);
+Static int	 cdce_newbuf(struct cdce_softc *, struct cdce_chain *,
+		    struct mbuf *);
+Static int	 cdce_encap(struct cdce_softc *, struct mbuf *, int);
+Static void	 cdce_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+Static void	 cdce_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+Static void	 cdce_start(struct ifnet *);
+Static int	 cdce_ioctl(struct ifnet *, u_long, caddr_t);
+Static void	 cdce_init(void *);
+Static void	 cdce_reset(struct cdce_softc *);
+Static void	 cdce_stop(struct cdce_softc *);
+Static void	 cdce_rxstart(struct ifnet *);
+
+Static const struct cdce_type cdce_devs[] = {
+  {{ USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2501 }, CDCE_NO_UNION },
+  {{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_SL5500 }, CDCE_ZAURUS },
+  {{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_SLA300 }, CDCE_ZAURUS | CDCE_NO_UNION },
+  {{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_SL5600 }, CDCE_ZAURUS | CDCE_NO_UNION },
+  {{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_SLC700 }, CDCE_ZAURUS | CDCE_NO_UNION },
+  {{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_SLC750 }, CDCE_ZAURUS | CDCE_NO_UNION },
+  {{ USB_VENDOR_GMATE, USB_PRODUCT_GMATE_YP3X00 }, CDCE_NO_UNION },
+};
+#define cdce_lookup(v, p) ((const struct cdce_type *)usb_lookup(cdce_devs, v, p))
+
+USB_MATCH(cdce)
+{
+	USB_MATCH_START(cdce, uaa);
+	usb_interface_descriptor_t *id;
+
+	if (uaa->iface == NULL)
+		return (UMATCH_NONE);
+
+	id = usbd_get_interface_descriptor(uaa->iface);
+	if (id == NULL)
+		return (UMATCH_NONE);
+
+	if (cdce_lookup(uaa->vendor, uaa->product) != NULL)
+		return (UMATCH_VENDOR_PRODUCT);
+
+	if (id->bInterfaceClass == UICLASS_CDC && id->bInterfaceSubClass ==
+	    UISUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL)
+		return (UMATCH_IFACECLASS_GENERIC);
+
+	return (UMATCH_NONE);
+}
+
+USB_ATTACH(cdce)
+{
+	USB_ATTACH_START(cdce, sc, uaa);
+	struct ifnet			*ifp;
+	usbd_device_handle		 dev = uaa->device;
+	const struct cdce_type		*t;
+	usb_interface_descriptor_t	*id;
+	usb_endpoint_descriptor_t	*ed;
+	const usb_cdc_union_descriptor_t *ud;
+	usb_config_descriptor_t		*cd;
+	int				 data_ifcno;
+	int				 i, j, numalts;
+	u_char				 eaddr[ETHER_ADDR_LEN];
+	const usb_cdc_ethernet_descriptor_t *ue;
+	char				 eaddr_str[USB_MAX_STRING_LEN];
+
+	bzero(sc, sizeof(struct cdce_softc));
+	sc->cdce_dev = self;
+	usbd_devinfo(dev, 0, sc->devinfo);
+	device_set_desc_copy(self, sc->devinfo);
+	printf("%s: %s\n", USBDEVNAME(sc->cdce_dev), sc->devinfo);
+
+	sc->cdce_udev = uaa->device;
+	sc->cdce_unit = device_get_unit(self);
+
+	t = cdce_lookup(uaa->vendor, uaa->product);
+	if (t)
+		sc->cdce_flags = t->cdce_flags;
+
+	if (sc->cdce_flags & CDCE_NO_UNION)
+		sc->cdce_data_iface = uaa->iface;
+	else {
+		ud = (const usb_cdc_union_descriptor_t *)usb_find_desc(sc->cdce_udev,
+		    UDESC_CS_INTERFACE, UDESCSUB_CDC_UNION);
+		if (ud == NULL) {
+			printf("%s: no union descriptor\n",
+			    USBDEVNAME(sc->cdce_dev));
+			USB_ATTACH_ERROR_RETURN;
+		}
+		data_ifcno = ud->bSlaveInterface[0];
+
+		for (i = 0; i < uaa->nifaces; i++) {
+			if (uaa->ifaces[i] != NULL) {
+				id = usbd_get_interface_descriptor(
+				    uaa->ifaces[i]);
+				if (id != NULL && id->bInterfaceNumber ==
+				    data_ifcno) {
+					sc->cdce_data_iface = uaa->ifaces[i];
+					uaa->ifaces[i] = NULL;
+				}
+			}
+		}
+	}
+
+	if (sc->cdce_data_iface == NULL) {
+		printf("%s: no data interface\n", USBDEVNAME(sc->cdce_dev));
+		USB_ATTACH_ERROR_RETURN;
+	}
+
+	/*
+	 * <quote>
+	 *  The Data Class interface of a networking device shall have a minimum
+	 *  of two interface settings. The first setting (the default interface
+	 *  setting) includes no endpoints and therefore no networking traffic is
+	 *  exchanged whenever the default interface setting is selected. One or
+	 *  more additional interface settings are used for normal operation, and
+	 *  therefore each includes a pair of endpoints (one IN, and one OUT) to
+	 *  exchange network traffic. Select an alternate interface setting to
+	 *  initialize the network aspects of the device and to enable the
+	 *  exchange of network traffic.
+	 * </quote>
+	 *
+	 * Some devices, most notably cable modems, include interface settings
+	 * that have no IN or OUT endpoint, therefore loop through the list of all
+	 * available interface settings looking for one with both IN and OUT
+	 * endpoints.
+	 */
+	id = usbd_get_interface_descriptor(sc->cdce_data_iface);
+	cd = usbd_get_config_descriptor(sc->cdce_udev);
+	numalts = usbd_get_no_alts(cd, id->bInterfaceNumber);
+
+	for (j = 0; j < numalts; j++) {
+		if (usbd_set_interface(sc->cdce_data_iface, j)) {
+			printf("%s: setting alternate interface failed\n",
+			    USBDEVNAME(sc->cdce_dev));
+			USB_ATTACH_ERROR_RETURN;
+		}
+		/* Find endpoints. */
+		id = usbd_get_interface_descriptor(sc->cdce_data_iface);
+		sc->cdce_bulkin_no = sc->cdce_bulkout_no = -1;
+		for (i = 0; i < id->bNumEndpoints; i++) {
+			ed = usbd_interface2endpoint_descriptor(sc->cdce_data_iface, i);
+			if (!ed) {
+				printf("%s: could not read endpoint descriptor\n",
+				    USBDEVNAME(sc->cdce_dev));
+				USB_ATTACH_ERROR_RETURN;
+			}
+			if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+				sc->cdce_bulkin_no = ed->bEndpointAddress;
+			} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
+			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+				sc->cdce_bulkout_no = ed->bEndpointAddress;
+			} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+			    UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
+				/* XXX: CDC spec defines an interrupt pipe, but it is not
+				 * needed for simple host-to-host applications. */
+			} else {
+				printf("%s: unexpected endpoint\n",
+				    USBDEVNAME(sc->cdce_dev));
+			}
+		}
+		/* If we found something, try and use it... */
+		if ((sc->cdce_bulkin_no != -1) && (sc->cdce_bulkout_no != -1))
+			break;
+	}
+
+	if (sc->cdce_bulkin_no == -1) {
+		printf("%s: could not find data bulk in\n",
+		    USBDEVNAME(sc->cdce_dev));
+		USB_ATTACH_ERROR_RETURN;
+	}
+	if (sc->cdce_bulkout_no == -1 ) {
+		printf("%s: could not find data bulk out\n",
+		    USBDEVNAME(sc->cdce_dev));
+		USB_ATTACH_ERROR_RETURN;
+	}
+
+	mtx_init(&sc->cdce_mtx, USBDEVNAME(sc->cdce_dev), MTX_NETWORK_LOCK,
+	    MTX_DEF | MTX_RECURSE);
+	CDCE_LOCK(sc);
+
+	ue = (const usb_cdc_ethernet_descriptor_t *)usb_find_desc(dev,
+	    UDESC_INTERFACE, UDESCSUB_CDC_ENF);
+	if (!ue || usbd_get_string(dev, ue->iMacAddress, eaddr_str)) {
+		/* Fake MAC address */
+		printf("%s: faking MAC address\n", USBDEVNAME(sc->cdce_dev));
+		eaddr[0]= 0x2a;
+		memcpy(&eaddr[1], &ticks, sizeof(u_int32_t));
+		eaddr[5] = (u_int8_t)(sc->cdce_unit);
+	} else {
+		int i;
+
+		memset(eaddr, 0, ETHER_ADDR_LEN);
+		for (i = 0; i < ETHER_ADDR_LEN * 2; i++) {
+			int c = eaddr_str[i];
+
+			if ('0' <= c && c <= '9')
+				c -= '0';
+			else
+				c -= 'A' - 10;
+			c &= 0xf;
+			if (c % 2 == 0)
+				c <<= 4;
+			eaddr[i / 2] |= c;
+		}
+	}
+
+	bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
+
+	ifp = GET_IFP(sc);
+	ifp->if_softc = sc;
+	if_initname(ifp, "cdce", sc->cdce_unit);
+	ifp->if_mtu = ETHERMTU;
+	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST |
+		IFF_NEEDSGIANT;
+	ifp->if_ioctl = cdce_ioctl;
+	ifp->if_output = ether_output;
+	ifp->if_start = cdce_start;
+	ifp->if_init = cdce_init;
+	ifp->if_baudrate = 11000000;
+	ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
+
+	sc->q.ifp = ifp;
+	sc->q.if_rxstart = cdce_rxstart;
+
+	ether_ifattach(ifp, eaddr);
+	usb_register_netisr();
+
+	CDCE_UNLOCK(sc);
+
+	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->cdce_udev,
+	    USBDEV(sc->cdce_dev));
+
+	USB_ATTACH_SUCCESS_RETURN;
+}
+
+USB_DETACH(cdce)
+{
+	USB_DETACH_START(cdce, sc);
+	struct ifnet	*ifp;
+
+	CDCE_LOCK(sc);
+	sc->cdce_dying = 1;
+	ifp = GET_IFP(sc);
+	if (ifp->if_flags & IFF_RUNNING)
+		cdce_shutdown(sc->cdce_dev);
+
+	ether_ifdetach(ifp);
+	CDCE_UNLOCK(sc);
+	mtx_destroy(&sc->cdce_mtx);
+
+	return (0);
+}
+
+Static void
+cdce_start(struct ifnet *ifp)
+{
+	struct cdce_softc	*sc;
+	struct mbuf		*m_head = NULL;
+
+	sc = ifp->if_softc;
+	CDCE_LOCK(sc);
+
+
+	if (sc->cdce_dying ||
+		ifp->if_flags & IFF_OACTIVE ||
+		!(ifp->if_flags & IFF_RUNNING)) {
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	IF_DEQUEUE(&ifp->if_snd, m_head);
+	if (m_head == NULL) {
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	if (cdce_encap(sc, m_head, 0)) {
+		IF_PREPEND(&ifp->if_snd, m_head);
+		ifp->if_flags |= IFF_OACTIVE;
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	BPF_MTAP(ifp, m_head);
+
+	ifp->if_flags |= IFF_OACTIVE;
+
+	CDCE_UNLOCK(sc);
+
+	return;
+}
+
+Static int
+cdce_encap(struct cdce_softc *sc, struct mbuf *m, int idx)
+{
+	struct cdce_chain	*c;
+	usbd_status		 err;
+	int			 extra = 0;
+
+	c = &sc->cdce_cdata.cdce_tx_chain[idx];
+
+	m_copydata(m, 0, m->m_pkthdr.len, c->cdce_buf);
+	if (sc->cdce_flags & CDCE_ZAURUS) {
+		/* Zaurus wants a 32-bit CRC appended to every frame */
+		u_int32_t crc;
+
+		crc = crc32(c->cdce_buf, m->m_pkthdr.len);
+		bcopy(&crc, c->cdce_buf + m->m_pkthdr.len, 4);
+		extra = 4;
+	}
+	c->cdce_mbuf = m;
+
+	usbd_setup_xfer(c->cdce_xfer, sc->cdce_bulkout_pipe, c, c->cdce_buf,
+	    m->m_pkthdr.len + extra, 0, 10000, cdce_txeof);
+	err = usbd_transfer(c->cdce_xfer);
+	if (err != USBD_IN_PROGRESS) {
+		cdce_stop(sc);
+		return (EIO);
+	}
+
+	sc->cdce_cdata.cdce_tx_cnt++;
+
+	return (0);
+}
+
+Static void
+cdce_stop(struct cdce_softc *sc)
+{
+	usbd_status	 err;
+	struct ifnet	*ifp;
+	int		 i;
+
+	CDCE_LOCK(sc);
+
+	cdce_reset(sc);
+
+	ifp = GET_IFP(sc);
+	ifp->if_timer = 0;
+
+	if (sc->cdce_bulkin_pipe != NULL) {
+		err = usbd_abort_pipe(sc->cdce_bulkin_pipe);
+		if (err)
+			printf("%s: abort rx pipe failed: %s\n",
+			    USBDEVNAME(sc->cdce_dev), usbd_errstr(err));
+		err = usbd_close_pipe(sc->cdce_bulkin_pipe);
+		if (err)
+			printf("%s: close rx pipe failed: %s\n",
+			    USBDEVNAME(sc->cdce_dev), usbd_errstr(err));
+		sc->cdce_bulkin_pipe = NULL;
+	}
+
+	if (sc->cdce_bulkout_pipe != NULL) {
+		err = usbd_abort_pipe(sc->cdce_bulkout_pipe);
+		if (err)
+			printf("%s: abort tx pipe failed: %s\n",
+			    USBDEVNAME(sc->cdce_dev), usbd_errstr(err));
+		err = usbd_close_pipe(sc->cdce_bulkout_pipe);
+		if (err)
+			printf("%s: close tx pipe failed: %s\n",
+			    USBDEVNAME(sc->cdce_dev), usbd_errstr(err));
+		sc->cdce_bulkout_pipe = NULL;
+	}
+
+	for (i = 0; i < CDCE_RX_LIST_CNT; i++) {
+		if (sc->cdce_cdata.cdce_rx_chain[i].cdce_mbuf != NULL) {
+			m_freem(sc->cdce_cdata.cdce_rx_chain[i].cdce_mbuf);
+			sc->cdce_cdata.cdce_rx_chain[i].cdce_mbuf = NULL;
+		}
+		if (sc->cdce_cdata.cdce_rx_chain[i].cdce_xfer != NULL) {
+			usbd_free_xfer(sc->cdce_cdata.cdce_rx_chain[i].cdce_xfer);
+			sc->cdce_cdata.cdce_rx_chain[i].cdce_xfer = NULL;
+		}
+	}
+
+	for (i = 0; i < CDCE_TX_LIST_CNT; i++) {
+		if (sc->cdce_cdata.cdce_tx_chain[i].cdce_mbuf != NULL) {
+			m_freem(sc->cdce_cdata.cdce_tx_chain[i].cdce_mbuf);
+			sc->cdce_cdata.cdce_tx_chain[i].cdce_mbuf = NULL;
+		}
+		if (sc->cdce_cdata.cdce_tx_chain[i].cdce_xfer != NULL) {
+			usbd_free_xfer(sc->cdce_cdata.cdce_tx_chain[i].cdce_xfer);
+			sc->cdce_cdata.cdce_tx_chain[i].cdce_xfer = NULL;
+		}
+	}
+
+	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+	CDCE_UNLOCK(sc);
+
+	return;
+}
+
+Static int
+cdce_shutdown(device_ptr_t dev)
+{
+	struct cdce_softc *sc;
+
+	sc = device_get_softc(dev);
+	cdce_stop(sc);
+
+	return (0);
+}
+
+Static int
+cdce_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
+{
+	struct cdce_softc	*sc = ifp->if_softc;
+	int			 error = 0;
+
+	if (sc->cdce_dying)
+		return (ENXIO);
+
+	switch(command) {
+	case SIOCSIFFLAGS:
+		if (ifp->if_flags & IFF_UP) {
+			if (!(ifp->if_flags & IFF_RUNNING))
+				cdce_init(sc);
+		} else {
+			if (ifp->if_flags & IFF_RUNNING)
+				cdce_stop(sc);
+		}
+		error = 0;
+		break;
+
+	default:
+		error = ether_ioctl(ifp, command, data);
+		break;
+	}
+
+	return (error);
+}
+
+Static void
+cdce_reset(struct cdce_softc *sc)
+{
+	/* XXX Maybe reset the bulk pipes here? */
+	return;
+}
+
+Static void
+cdce_init(void *xsc)
+{
+	struct cdce_softc	*sc = xsc;
+	struct ifnet		*ifp = GET_IFP(sc);
+	struct cdce_chain	*c;
+	usbd_status		 err;
+	int			 i;
+
+	if (ifp->if_flags & IFF_RUNNING)
+		return;
+
+	CDCE_LOCK(sc);
+	cdce_reset(sc);
+
+	if (cdce_tx_list_init(sc) == ENOBUFS) {
+		printf("%s: tx list init failed\n", USBDEVNAME(sc->cdce_dev));
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	if (cdce_rx_list_init(sc) == ENOBUFS) {
+		printf("%s: rx list init failed\n", USBDEVNAME(sc->cdce_dev));
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	/* Maybe set multicast / broadcast here??? */
+
+	err = usbd_open_pipe(sc->cdce_data_iface, sc->cdce_bulkin_no,
+	    USBD_EXCLUSIVE_USE, &sc->cdce_bulkin_pipe);
+	if (err) {
+		printf("%s: open rx pipe failed: %s\n", USBDEVNAME(sc->cdce_dev),
+		    usbd_errstr(err));
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	err = usbd_open_pipe(sc->cdce_data_iface, sc->cdce_bulkout_no,
+	    USBD_EXCLUSIVE_USE, &sc->cdce_bulkout_pipe);
+	if (err) {
+		printf("%s: open tx pipe failed: %s\n", USBDEVNAME(sc->cdce_dev),
+		    usbd_errstr(err));
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	for (i = 0; i < CDCE_RX_LIST_CNT; i++) {
+		c = &sc->cdce_cdata.cdce_rx_chain[i];
+		usbd_setup_xfer(c->cdce_xfer, sc->cdce_bulkin_pipe, c,
+		    mtod(c->cdce_mbuf, char *), CDCE_BUFSZ, USBD_SHORT_XFER_OK,
+		    USBD_NO_TIMEOUT, cdce_rxeof);
+		usbd_transfer(c->cdce_xfer);
+	}
+
+	ifp->if_flags |= IFF_RUNNING;
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+	CDCE_UNLOCK(sc);
+
+	return;
+}
+
+Static int
+cdce_newbuf(struct cdce_softc *sc, struct cdce_chain *c, struct mbuf *m)
+{
+	struct mbuf	*m_new = NULL;
+
+	if (m == NULL) {
+		m_new = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
+		if (m_new == NULL) {
+			printf("%s: no memory for rx list "
+			    "-- packet dropped!\n", USBDEVNAME(sc->cdce_dev));
+			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->cdce_mbuf = m_new;
+	return (0);
+}
+
+Static int
+cdce_rx_list_init(struct cdce_softc *sc)
+{
+	struct cdce_cdata	*cd;
+	struct cdce_chain	*c;
+	int			 i;
+
+	cd = &sc->cdce_cdata;
+	for (i = 0; i < CDCE_RX_LIST_CNT; i++) {
+		c = &cd->cdce_rx_chain[i];
+		c->cdce_sc = sc;
+		c->cdce_idx = i;
+		if (cdce_newbuf(sc, c, NULL) == ENOBUFS)
+			return (ENOBUFS);
+		if (c->cdce_xfer == NULL) {
+			c->cdce_xfer = usbd_alloc_xfer(sc->cdce_udev);
+			if (c->cdce_xfer == NULL)
+				return (ENOBUFS);
+			c->cdce_buf = usbd_alloc_buffer(c->cdce_xfer, CDCE_BUFSZ);
+			if (c->cdce_buf == NULL)
+				return (ENOBUFS);
+		}
+	}
+
+	return (0);
+}
+
+Static int
+cdce_tx_list_init(struct cdce_softc *sc)
+{
+	struct cdce_cdata	*cd;
+	struct cdce_chain	*c;
+	int			 i;
+
+	cd = &sc->cdce_cdata;
+	for (i = 0; i < CDCE_TX_LIST_CNT; i++) {
+		c = &cd->cdce_tx_chain[i];
+		c->cdce_sc = sc;
+		c->cdce_idx = i;
+		c->cdce_mbuf = NULL;
+		if (c->cdce_xfer == NULL) {
+			c->cdce_xfer = usbd_alloc_xfer(sc->cdce_udev);
+			if (c->cdce_xfer == NULL)
+				return (ENOBUFS);
+			c->cdce_buf = usbd_alloc_buffer(c->cdce_xfer, CDCE_BUFSZ);
+			if (c->cdce_buf == NULL)
+				return (ENOBUFS);
+		}
+	}
+
+	return (0);
+}
+
+Static void
+cdce_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+	struct cdce_chain	*c = priv;
+	struct cdce_softc	*sc = c->cdce_sc;
+	struct ifnet		*ifp;
+	struct mbuf		*m;
+	int			 total_len = 0;
+
+	CDCE_LOCK(sc);
+	ifp = GET_IFP(sc);
+
+	if (sc->cdce_dying || !(ifp->if_flags & IFF_RUNNING)) {
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	if (status != USBD_NORMAL_COMPLETION) {
+		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+			CDCE_UNLOCK(sc);
+			return;
+		}
+		if (sc->cdce_rxeof_errors == 0)
+			printf("%s: usb error on rx: %s\n",
+			    USBDEVNAME(sc->cdce_dev), usbd_errstr(status));
+		if (status == USBD_STALLED)
+			usbd_clear_endpoint_stall(sc->cdce_bulkin_pipe);
+		DELAY(sc->cdce_rxeof_errors * 10000);
+		sc->cdce_rxeof_errors++;
+		goto done;
+	}
+
+	sc->cdce_rxeof_errors = 0;
+
+	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
+
+	if (sc->cdce_flags & CDCE_ZAURUS)
+		total_len -= 4;	/* Strip off CRC added by Zaurus */
+
+	m = c->cdce_mbuf;
+
+	if (total_len < sizeof(struct ether_header)) {
+		ifp->if_ierrors++;
+		goto done;
+	}
+
+	ifp->if_ipackets++;
+	m->m_pkthdr.rcvif = (struct ifnet *)&sc->q;
+	m->m_pkthdr.len = m->m_len = total_len;
+
+	/* Put the packet on the special USB input queue. */
+	usb_ether_input(m);
+	CDCE_UNLOCK(sc);
+
+	return;
+
+done:
+	/* Setup new transfer. */
+	usbd_setup_xfer(c->cdce_xfer, sc->cdce_bulkin_pipe, c,
+	    mtod(c->cdce_mbuf, char *),
+	    CDCE_BUFSZ, USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT,
+	    cdce_rxeof);
+	usbd_transfer(c->cdce_xfer);
+	CDCE_UNLOCK(sc);
+
+	return;
+}
+
+Static void
+cdce_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+	struct cdce_chain	*c = priv;
+	struct cdce_softc	*sc = c->cdce_sc;
+	struct ifnet		*ifp;
+	usbd_status		 err;
+
+	CDCE_LOCK(sc);
+	ifp = GET_IFP(sc);
+
+	if (sc->cdce_dying ||
+		!(ifp->if_flags & IFF_RUNNING)) {
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	if (status != USBD_NORMAL_COMPLETION) {
+		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+			CDCE_UNLOCK(sc);
+			return;
+		}
+		ifp->if_oerrors++;
+		printf("%s: usb error on tx: %s\n", USBDEVNAME(sc->cdce_dev),
+		    usbd_errstr(status));
+		if (status == USBD_STALLED)
+			usbd_clear_endpoint_stall(sc->cdce_bulkout_pipe);
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	ifp->if_flags &= ~IFF_OACTIVE;
+	usbd_get_xfer_status(c->cdce_xfer, NULL, NULL, NULL, &err);
+
+	if (c->cdce_mbuf != NULL) {
+		c->cdce_mbuf->m_pkthdr.rcvif = ifp;
+		usb_tx_done(c->cdce_mbuf);
+		c->cdce_mbuf = NULL;
+	}
+
+	if (err)
+		ifp->if_oerrors++;
+	else
+		ifp->if_opackets++;
+
+	CDCE_UNLOCK(sc);
+
+	return;
+}
+
+Static void
+cdce_rxstart(struct ifnet *ifp)
+{
+	struct cdce_softc   *sc;
+	struct cdce_chain   *c;
+
+	sc = ifp->if_softc;
+	CDCE_LOCK(sc);
+
+	    if (sc->cdce_dying || !(ifp->if_flags & IFF_RUNNING)) {
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	c = &sc->cdce_cdata.cdce_rx_chain[sc->cdce_cdata.cdce_rx_prod];
+
+	if (cdce_newbuf(sc, c, NULL) == ENOBUFS) {
+		ifp->if_ierrors++;
+		CDCE_UNLOCK(sc);
+		return;
+	}
+
+	usbd_setup_xfer(c->cdce_xfer, sc->cdce_bulkin_pipe, c,
+	    mtod(c->cdce_mbuf, char *), CDCE_BUFSZ, USBD_SHORT_XFER_OK,
+	    USBD_NO_TIMEOUT, cdce_rxeof);
+	usbd_transfer(c->cdce_xfer);
+
+	CDCE_UNLOCK(sc);
+	return;
+}
diff --git a/sys/dev/usb/if_cdcereg.h b/sys/dev/usb/if_cdcereg.h
new file mode 100644
index 0000000..86d790d
--- /dev/null
+++ b/sys/dev/usb/if_cdcereg.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2003-2005 Craig Boston
+ * 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.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Bill Paul.
+ * 4. Neither the name of the author nor the names of any co-contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY Bill Paul 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 Bill Paul, THE VOICES IN HIS HEAD OR
+ * THE 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 _USB_IF_CDCEREG_H_
+#define _USB_IF_CDCEREG_H_
+
+#define CDCE_RX_LIST_CNT	1
+#define CDCE_TX_LIST_CNT	1
+#define CDCE_BUFSZ		1542
+
+struct cdce_type {
+	struct usb_devno	 cdce_dev;
+	u_int16_t		 cdce_flags;
+#define CDCE_ZAURUS	1
+#define CDCE_NO_UNION	2
+};
+
+struct cdce_softc;
+
+struct cdce_chain {
+	struct cdce_softc	*cdce_sc;
+	usbd_xfer_handle	 cdce_xfer;
+	char			*cdce_buf;
+	struct mbuf		*cdce_mbuf;
+	int			 cdce_accum;
+	int			 cdce_idx;
+};
+
+struct cdce_cdata {
+	struct cdce_chain	 cdce_tx_chain[CDCE_TX_LIST_CNT];
+	struct cdce_chain	 cdce_rx_chain[CDCE_TX_LIST_CNT];
+	int			 cdce_tx_prod;
+	int			 cdce_tx_cons;
+	int			 cdce_tx_cnt;
+	int			 cdce_rx_prod;
+};
+
+struct cdce_softc {
+	struct arpcom		 arpcom;
+#define GET_IFP(sc) (&(sc)->arpcom.ac_if)
+
+	usbd_device_handle	 cdce_udev;
+	usbd_interface_handle	 cdce_data_iface;
+	int			 cdce_bulkin_no;
+	usbd_pipe_handle	 cdce_bulkin_pipe;
+	int			 cdce_bulkout_no;
+	usbd_pipe_handle	 cdce_bulkout_pipe;
+	char			 cdce_dying;
+	device_t		 cdce_dev;
+	int			 cdce_unit;
+
+	struct cdce_cdata	 cdce_cdata;
+	struct timeval		 cdce_rx_notice;
+	int			 cdce_rxeof_errors;
+
+	u_int16_t		 cdce_flags;
+
+	struct mtx		 cdce_mtx;
+
+	struct usb_qdat		 q;
+
+	char			 devinfo[1024];
+};
+
+/* We are still under Giant */
+#if 0
+#define CDCE_LOCK(_sc)           mtx_lock(&(_sc)->cdce_mtx)
+#define CDCE_UNLOCK(_sc)         mtx_unlock(&(_sc)->cdce_mtx)
+#else
+#define CDCE_LOCK(_sc)
+#define CDCE_UNLOCK(_sc)
+#endif
+
+#endif
diff --git a/sys/i386/conf/GENERIC b/sys/i386/conf/GENERIC
index 6d61b6e..59ae8ab 100644
--- a/sys/i386/conf/GENERIC
+++ b/sys/i386/conf/GENERIC
@@ -281,6 +281,7 @@ device		uscanner	# Scanners
 # USB Ethernet, requires miibus
 device		aue		# ADMtek USB Ethernet
 device		axe		# ASIX Electronics USB Ethernet
+device		cdce		# Generic USB over Ethernet
 device		cue		# CATC USB Ethernet
 device		kue		# Kawasaki LSI USB Ethernet
 device		rue		# RealTek RTL8150 USB Ethernet
diff --git a/sys/i386/conf/PAE b/sys/i386/conf/PAE
index da73cd1..fd552b0 100644
--- a/sys/i386/conf/PAE
+++ b/sys/i386/conf/PAE
@@ -94,6 +94,7 @@ nodevice	urio
 nodevice	uscanner
 nodevice	aue
 nodevice	axe
+nodevice	cdce
 nodevice	cue
 nodevice	kue
 nodevice	rue
diff --git a/sys/ia64/conf/GENERIC b/sys/ia64/conf/GENERIC
index 88a8f6c..1f8426c 100644
--- a/sys/ia64/conf/GENERIC
+++ b/sys/ia64/conf/GENERIC
@@ -127,6 +127,7 @@ device		xl		# 3Com 3c90x ("Boomerang", "Cyclone")
 
 # USB Ethernet
 device		aue		# ADMtek USB Ethernet
+device		cdce		# Generic USB over Ethernet
 device		cue		# CATC USB Ethernet
 device		kue		# Kawasaki LSI USB Ethernet
 
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
index 3ae7346..a196b78 100644
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -44,6 +44,7 @@ SUBDIR=	${_3dfx} \
 	${_cbb} \
 	cd9660 \
 	cd9660_iconv \
+	cdce \
 	${_ciss} \
 	${_cm} \
 	coda \
diff --git a/sys/modules/cdce/Makefile b/sys/modules/cdce/Makefile
new file mode 100644
index 0000000..c82754d
--- /dev/null
+++ b/sys/modules/cdce/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+S=	${.CURDIR}/../..
+.PATH: $S/dev/usb
+
+KMOD=	if_cdce
+SRCS=	if_cdce.c opt_bdg.h opt_usb.h device_if.h bus_if.h
+SRCS+=	usbdevs.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/pc98/conf/GENERIC b/sys/pc98/conf/GENERIC
index 1c44694..94a5098 100644
--- a/sys/pc98/conf/GENERIC
+++ b/sys/pc98/conf/GENERIC
@@ -246,6 +246,7 @@ device		bpf		# Berkeley packet filter
 # USB Ethernet, requires miibus
 #device		aue		# ADMtek USB Ethernet
 #device		axe		# ASIX Electronics USB Ethernet
+#device		cdce		# Generic USB over Ethernet
 #device		cue		# CATC USB Ethernet
 #device		kue		# Kawasaki LSI USB Ethernet
 #device		rue		# RealTek RTL8150 USB Ethernet
diff --git a/sys/powerpc/conf/GENERIC b/sys/powerpc/conf/GENERIC
index 67bb092..8beb9f0 100644
--- a/sys/powerpc/conf/GENERIC
+++ b/sys/powerpc/conf/GENERIC
@@ -134,6 +134,7 @@ device		uscanner	# Scanners
 # USB Ethernet
 device		aue		# ADMtek USB Ethernet
 device		axe		# ASIX Electronics USB Ethernet
+device		cdce		# Generic USB over Ethernet
 device		cue		# CATC USB Ethernet
 device		kue		# Kawasaki LSI USB Ethernet
 
diff --git a/sys/sparc64/conf/GENERIC b/sys/sparc64/conf/GENERIC
index 1e642e4..7d2fe9e 100644
--- a/sys/sparc64/conf/GENERIC
+++ b/sys/sparc64/conf/GENERIC
@@ -212,6 +212,7 @@ device		bpf		# Berkeley packet filter
 # USB Ethernet, requires mii
 #device		aue		# ADMtek USB Ethernet
 #device		axe		# ASIX Electronics USB Ethernet
+#device		cdce		# Generic USB over Ethernet
 #device		cue		# CATC USB Ethernet
 #device		kue		# Kawasaki LSI USB Ethernet
 #device		rue		# RealTek RTL8150 USB Ethernet