summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--share/man/man4/Makefile4
-rw-r--r--share/man/man4/urndis.479
-rw-r--r--share/man/man4/usb.46
-rw-r--r--sys/dev/usb/files.usb8
-rw-r--r--sys/dev/usb/if_urndis.c1668
-rw-r--r--sys/dev/usb/if_urndisreg.h334
-rw-r--r--sys/dev/usb/usb.h3
7 files changed, 2095 insertions, 7 deletions
diff --git a/share/man/man4/Makefile b/share/man/man4/Makefile
index 4ab55c385e2..0433022c819 100644
--- a/share/man/man4/Makefile
+++ b/share/man/man4/Makefile
@@ -1,4 +1,4 @@
-# $OpenBSD: Makefile,v 1.503 2010/03/01 07:59:16 yuo Exp $
+# $OpenBSD: Makefile,v 1.504 2010/03/01 23:35:56 mk Exp $
MAN= aac.4 ac97.4 acphy.4 \
acpi.4 acpiac.4 acpiasus.4 acpibat.4 acpibtn.4 acpicpu.4 acpidock.4 \
@@ -58,7 +58,7 @@ MAN= aac.4 ac97.4 acphy.4 \
uipaq.4 uk.4 ukbd.4 \
ukphy.4 ulpt.4 umass.4 umbg.4 umct.4 umidi.4 umodem.4 ums.4 umsm.4 \
unix.4 uow.4 upgt.4 upl.4 uplcom.4 ural.4 urio.4 url.4 urlphy.4 \
- urtw.4 usb.4 usbf.4 uscanner.4 uslcom.4 usscanner.4 uthum.4 \
+ urndis.4 urtw.4 usb.4 usbf.4 uscanner.4 uslcom.4 usscanner.4 uthum.4 \
uticom.4 utrh.4 uts.4 uvideo.4 uvisor.4 uvscom.4 uyap.4 uyurex.4 \
vether.4 vga.4 vgafb.4 vge.4 \
viaenv.4 viapm.4 viasio.4 vic.4 video.4 vlan.4 vmt.4 vnd.4 vr.4 \
diff --git a/share/man/man4/urndis.4 b/share/man/man4/urndis.4
new file mode 100644
index 00000000000..be0df559bb6
--- /dev/null
+++ b/share/man/man4/urndis.4
@@ -0,0 +1,79 @@
+.\" Copyright (c) 2010 Michael Knudsen <mk@openbsd.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:
+.\"
+.\" - Redistributions of source code must retain the above copyright
+.\" notice, this list of conditions and the following disclaimer.
+.\" - 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 COPYRIGHT HOLDERS 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
+.\" COPYRIGHT HOLDERS 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.
+.\"
+.\" $OpenBSD: urndis.4,v 1.1 2010/03/01 23:35:56 mk Exp $
+.\"
+.Dd $Mdocdate: March 1 2010 $
+.Dt URNDIS 4
+.Os
+.Sh NAME
+.Nm urndis
+.Nd USB Remote NDIS Ethernet
+.Sh SYNOPSIS
+.Cd "urndis* at uhub?"
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for Ethernet access over Remote NDIS.
+The
+.Nm
+driver should work with all USB RNDIS devices, but the following devices are
+known to work:
+.Pp
+.Bl -bullet -compact -offset indent
+.It
+HTC Hero
+.It
+HTC Magic
+.El
+.Pp
+The
+.Nm
+driver does not support different media types or options.
+For more information on configuring this device, see
+.Xr ifconfig 8 .
+.Sh SEE ALSO
+.Xr arp 4 ,
+.Xr intro 4 ,
+.Xr netintro 4 ,
+.Xr usb 4 ,
+.Xr hostname.if 5 ,
+.Xr ifconfig 8
+.Sh HISTORY
+The
+.Nm
+device driver first appeared in
+.Ox 4.7 .
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Jonathan Armani Aq dbd@asystant.net ,
+.An Michael Knudsen Aq mk@openbsd.org ,
+and
+.An Fabien Romano Aq fromano@asystant.net .
diff --git a/share/man/man4/usb.4 b/share/man/man4/usb.4
index ec5610b9ff3..7c7a0d4db06 100644
--- a/share/man/man4/usb.4
+++ b/share/man/man4/usb.4
@@ -1,4 +1,4 @@
-.\" $OpenBSD: usb.4,v 1.117 2009/12/18 05:58:15 jmc Exp $
+.\" $OpenBSD: usb.4,v 1.118 2010/03/01 23:35:56 mk Exp $
.\" $NetBSD: usb.4,v 1.15 1999/07/29 14:20:32 augustss Exp $
.\"
.\" Copyright (c) 1999 The NetBSD Foundation, Inc.
@@ -28,7 +28,7 @@
.\" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
.\" POSSIBILITY OF SUCH DAMAGE.
.\"
-.Dd $Mdocdate: December 18 2009 $
+.Dd $Mdocdate: March 1 2010 $
.Dt USB 4
.Os
.Sh NAME
@@ -137,6 +137,8 @@ Davicom DM9601 10/100 USB Ethernet device
Analog Devices Eagle ADSL modems
.It Xr url 4
Realtek RTL8150L 10/100 USB Ethernet device
+.It Xr urndis 4
+Remote NDIS Ethernet device
.El
.Ss Wireless network interfaces
.Bl -tag -width 12n -offset ind -compact
diff --git a/sys/dev/usb/files.usb b/sys/dev/usb/files.usb
index b30224b9eb3..ac4d5416ae7 100644
--- a/sys/dev/usb/files.usb
+++ b/sys/dev/usb/files.usb
@@ -1,4 +1,4 @@
-# $OpenBSD: files.usb,v 1.88 2010/03/01 07:56:47 yuo Exp $
+# $OpenBSD: files.usb,v 1.89 2010/03/01 23:35:56 mk Exp $
# $NetBSD: files.usb,v 1.16 2000/02/14 20:29:54 augustss Exp $
#
# Config file and device description for machine-independent USB code.
@@ -191,6 +191,11 @@ device cdce: ether, ifnet, ifmedia
attach cdce at uhub
file dev/usb/if_cdce.c cdce
+# RNDIS
+device urndis: ether, ifnet, ifmedia
+attach urndis at uhub
+file dev/usb/if_urndis.c urndis
+
# Moschip MCS7x30 Ethernet
device mos: ether, ifnet, mii, ifmedia
attach mos at uhub
@@ -356,7 +361,6 @@ device cdcef {}
attach cdcef at usbf
file dev/usb/if_cdcef.c cdcef
-
# Atheros AR5005UG/AR5005UX
device uath: ether, ifnet, ifmedia, wlan, firmload
attach uath at uhub
diff --git a/sys/dev/usb/if_urndis.c b/sys/dev/usb/if_urndis.c
new file mode 100644
index 00000000000..bb086aee738
--- /dev/null
+++ b/sys/dev/usb/if_urndis.c
@@ -0,0 +1,1668 @@
+/* $OpenBSD: if_urndis.c,v 1.1 2010/03/01 23:35:56 mk Exp $ */
+
+/*
+ * Copyright (c) 2010 Jonathan Armani <dbd@asystant.net>
+ * Copyright (c) 2010 Fabien Romano <fromano@asystant.net>
+ * Copyright (c) 2010 Michael Knudsen <mk@openbsd.org>
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <sys/cdefs.h>
+
+#include "bpfilter.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/sockio.h>
+#include <sys/rwlock.h>
+#include <sys/mbuf.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+
+#include <sys/device.h>
+
+#include <machine/bus.h>
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/if_media.h>
+
+#if NBPFILTER > 0
+#include <net/bpf.h>
+#endif
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/if_ether.h>
+#endif
+
+#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/usbcdc.h>
+
+#include <dev/usb/if_urndisreg.h>
+
+#ifdef RNDIS_DEBUG
+#define DPRINTF(x) do { printf x; } while (0)
+#else
+#define DPRINTF(x)
+#endif
+
+#define DEVNAME(sc) ((sc)->sc_dev.dv_xname)
+
+int urndis_newbuf(struct urndis_softc *, struct urndis_chain *, struct mbuf *);
+
+void urndis_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
+int urndis_ioctl(struct ifnet *, u_long, caddr_t);
+void urndis_watchdog(struct ifnet *);
+
+void urndis_start(struct ifnet *);
+void urndis_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+void urndis_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
+int urndis_rx_list_init(struct urndis_softc *);
+int urndis_tx_list_init(struct urndis_softc *);
+
+void urndis_init(struct urndis_softc *);
+void urndis_stop(struct urndis_softc *);
+
+usbd_status urndis_ctrl_msg(struct urndis_softc *, uint8_t, uint8_t,
+ uint16_t, uint16_t, void *, size_t);
+usbd_status urndis_ctrl_send(struct urndis_softc *, void *, size_t);
+struct urndis_comp_hdr *urndis_ctrl_recv(struct urndis_softc *);
+
+urndis_status urndis_ctrl_handle(struct urndis_softc *,
+ struct urndis_comp_hdr *, void **, size_t *);
+urndis_status urndis_ctrl_handle_init(struct urndis_softc *,
+ const struct urndis_comp_hdr *);
+urndis_status urndis_ctrl_handle_query(struct urndis_softc *,
+ const struct urndis_comp_hdr *, void **, size_t *);
+urndis_status urndis_ctrl_handle_reset(struct urndis_softc *,
+ const struct urndis_comp_hdr *);
+
+urndis_status urndis_ctrl_init(struct urndis_softc *);
+urndis_status urndis_ctrl_halt(struct urndis_softc *);
+urndis_status urndis_ctrl_query(struct urndis_softc *, urndis_oid, void *, size_t,
+ void **, size_t *);
+urndis_status urndis_ctrl_set(struct urndis_softc *, urndis_oid, void *, size_t);
+urndis_status urndis_ctrl_set_param(struct urndis_softc *, const char *, u_int32_t,
+ void *, size_t);
+urndis_status urndis_ctrl_reset(struct urndis_softc *);
+urndis_status urndis_ctrl_keepalive(struct urndis_softc *);
+
+int urndis_encap(struct urndis_softc *, struct mbuf *, int);
+void urndis_decap(struct urndis_softc *, struct urndis_chain *, size_t);
+
+int urndis_match(struct device *, void *, void *);
+void urndis_attach(struct device *, struct device *, void *);
+int urndis_detach(struct device *, int);
+int urndis_activate(struct device *, int);
+
+struct cfdriver urndis_cd = {
+ NULL, "urndis", DV_IFNET
+};
+
+struct cfattach urndis_ca = {
+ sizeof(struct urndis_softc),
+ urndis_match,
+ urndis_attach,
+ urndis_detach,
+ urndis_activate,
+};
+
+usbd_status
+urndis_ctrl_msg(struct urndis_softc *sc, uint8_t rt, uint8_t r,
+ uint16_t index, uint16_t value, void *buf, size_t buflen)
+{
+ usb_device_request_t req;
+
+ req.bmRequestType = rt;
+ req.bRequest = r;
+ USETW(req.wValue, value);
+ USETW(req.wIndex, index);
+ USETW(req.wLength, buflen);
+
+ return usbd_do_request(sc->sc_udev, &req, buf);
+}
+
+usbd_status
+urndis_ctrl_send(struct urndis_softc *sc, void *buf, size_t len)
+{
+ usbd_status err;
+
+ if (sc->sc_dying)
+ return(0);
+
+ err = urndis_ctrl_msg(sc, UT_WRITE_CLASS_INTERFACE, UR_GET_STATUS,
+ sc->sc_ifaceno_ctl, 0, buf, len);
+
+ if (err != USBD_NORMAL_COMPLETION)
+ printf("%s: %s\n", DEVNAME(sc), usbd_errstr(err));
+
+ return err;
+}
+
+struct urndis_comp_hdr *
+urndis_ctrl_recv(struct urndis_softc *sc)
+{
+#define RNDIS_RESPONSE_LEN 0x400 /* XXX seriously? */
+ struct urndis_comp_hdr *hdr, *pkt;
+ char *buf;
+ usbd_status err;
+
+ buf = malloc(RNDIS_RESPONSE_LEN, M_TEMP, M_WAITOK | M_CANFAIL);
+ if (buf == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return NULL;
+ }
+
+ err = urndis_ctrl_msg(sc, UT_READ_CLASS_INTERFACE, UR_CLEAR_FEATURE,
+ sc->sc_ifaceno_ctl, 0, buf, RNDIS_RESPONSE_LEN);
+
+ if (err != USBD_NORMAL_COMPLETION && err != USBD_SHORT_XFER) {
+ printf("%s: %s\n", DEVNAME(sc), usbd_errstr(err));
+ free(buf, M_TEMP);
+ return NULL;
+ }
+
+ hdr = (struct urndis_comp_hdr *)buf;
+ DPRINTF(("%s: urndis_ctrl_recv: type 0x%x len %u\n",
+ DEVNAME(sc),
+ letoh32(hdr->rm_type),
+ letoh32(hdr->rm_len)));
+
+ if (letoh32(hdr->rm_len) > RNDIS_RESPONSE_LEN) {
+ printf("%s: ctrl message error: wrong size %u > %u\n",
+ DEVNAME(sc),
+ letoh32(hdr->rm_len),
+ RNDIS_RESPONSE_LEN);
+ free(buf, M_TEMP);
+ return NULL;
+ }
+
+ if (letoh32(hdr->rm_len) < 128) {
+ pkt = malloc(letoh32(hdr->rm_len),
+ M_TEMP, M_WAITOK | M_CANFAIL);
+ if (pkt == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ /* XXX just use buf? */
+ free(buf, M_TEMP);
+ } else {
+ memcpy(pkt, hdr, letoh32(hdr->rm_len));
+ free(buf, M_TEMP);
+ }
+ } else {
+ pkt = hdr;
+ }
+
+ return pkt;
+}
+
+urndis_status
+urndis_ctrl_handle(struct urndis_softc *sc, struct urndis_comp_hdr *hdr,
+ void **buf, size_t *bufsz)
+{
+ urndis_status rval;
+
+ DPRINTF(("%s: urndis_ctrl_handle\n", DEVNAME(sc)));
+
+ if (buf && bufsz) {
+ *buf = NULL;
+ *bufsz = 0;
+ }
+
+ switch (letoh32(hdr->rm_type)) {
+ case REMOTE_NDIS_INITIALIZE_CMPLT:
+ rval = urndis_ctrl_handle_init(sc, hdr);
+ break;
+
+ case REMOTE_NDIS_QUERY_CMPLT:
+ rval = urndis_ctrl_handle_query(sc, hdr, buf, bufsz);
+ break;
+
+ case REMOTE_NDIS_RESET_CMPLT:
+ rval = urndis_ctrl_handle_reset(sc, hdr);
+ break;
+
+ case REMOTE_NDIS_KEEPALIVE_CMPLT:
+ case REMOTE_NDIS_SET_CMPLT:
+ rval = letoh32(hdr->rm_status);
+ break;
+
+ default:
+ printf("%s: ctrl message error: unknown event 0x%x\n",
+ DEVNAME(sc), letoh32(hdr->rm_type));
+ rval = RNDIS_STATUS_FAILURE;
+ }
+
+ free(hdr, M_TEMP);
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_handle_init(struct urndis_softc *sc, const struct urndis_comp_hdr *hdr)
+{
+ const struct urndis_init_comp *msg;
+
+ msg = (struct urndis_init_comp *) hdr;
+
+ DPRINTF(("%s: urndis_ctrl_handle_init: len %u rid %u status 0x%x "
+ "ver_major %u ver_minor %u devflags 0x%x medium 0x%x pktmaxcnt %u "
+ "pktmaxsz %u align %u aflistoffset %u aflistsz %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid),
+ letoh32(msg->rm_status),
+ letoh32(msg->rm_ver_major),
+ letoh32(msg->rm_ver_minor),
+ letoh32(msg->rm_devflags),
+ letoh32(msg->rm_medium),
+ letoh32(msg->rm_pktmaxcnt),
+ letoh32(msg->rm_pktmaxsz),
+ letoh32(msg->rm_align),
+ letoh32(msg->rm_aflistoffset),
+ letoh32(msg->rm_aflistsz)));
+
+ if (letoh32(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
+ printf("%s: init failed 0x%x\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_status));
+
+ return letoh32(msg->rm_status);
+ }
+
+ if (letoh32(msg->rm_devflags) != RNDIS_DF_CONNECTIONLESS) {
+ printf("%s: wrong device type (current type: 0x%x)\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_devflags));
+
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ if (letoh32(msg->rm_medium) != RNDIS_MEDIUM_802_3) {
+ printf("%s: medium not 802.3 (current medium: 0x%x)\n",
+ DEVNAME(sc), letoh32(msg->rm_medium));
+
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ sc->sc_lim_pktcnt = letoh32(msg->rm_pktmaxcnt);
+ sc->sc_lim_pktsz = letoh32(msg->rm_pktmaxsz);
+ sc->sc_pktalign = letoh32(msg->rm_align);
+
+ return letoh32(msg->rm_status);
+}
+
+urndis_status
+urndis_ctrl_handle_query(struct urndis_softc *sc,
+ const struct urndis_comp_hdr *hdr, void **buf, size_t *bufsz)
+{
+ const struct urndis_query_comp *msg;
+
+ msg = (struct urndis_query_comp *) hdr;
+
+ DPRINTF(("%s: urndis_ctrl_handle_query: len %u rid %u status 0x%x "
+ "buflen %u bufoff %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid),
+ letoh32(msg->rm_status),
+ letoh32(msg->rm_infobuflen),
+ letoh32(msg->rm_infobufoffset)));
+
+ if (buf && bufsz) {
+ *buf = NULL;
+ *bufsz = 0;
+ }
+
+ if (letoh32(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
+ printf("%s: query failed 0x%x\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_status));
+
+ return letoh32(msg->rm_status);
+ }
+ /* XXX : 8 -> rid offset in struct */
+ if (letoh32(msg->rm_infobuflen) + letoh32(msg->rm_infobufoffset) +
+ 8 > letoh32(msg->rm_len)) {
+ printf("%s: ctrl message error: invalid query info "
+ "len/offset/end_position(%d/%d/%d) -> "
+ "go out of buffer limit %d\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_infobuflen),
+ letoh32(msg->rm_infobufoffset),
+ letoh32(msg->rm_infobuflen) +
+ letoh32(msg->rm_infobufoffset) + 8,
+ letoh32(msg->rm_len));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ if (buf && bufsz) {
+ *buf = malloc(letoh32(msg->rm_infobuflen),
+ M_TEMP, M_WAITOK | M_CANFAIL);
+ if (*buf == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ } else {
+ char *p;
+ *bufsz = letoh32(msg->rm_infobuflen);
+
+ p = (char *)&msg->rm_rid;
+ p += letoh32(msg->rm_infobufoffset);
+ memcpy(*buf, p, letoh32(msg->rm_infobuflen));
+ }
+ }
+
+ return letoh32(msg->rm_status);
+}
+
+urndis_status
+urndis_ctrl_handle_reset(struct urndis_softc *sc,
+ const struct urndis_comp_hdr *hdr)
+{
+ const struct urndis_reset_comp *msg;
+ urndis_status rval;
+
+ msg = (struct urndis_reset_comp *) hdr;
+
+ rval = letoh32(msg->rm_status);
+
+ DPRINTF(("%s: urndis_ctrl_handle_reset: len %u status 0x%x "
+ "adrreset %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ rval,
+ letoh32(msg->rm_adrreset)));
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: reset failed 0x%x\n", DEVNAME(sc), rval);
+ return rval;
+ }
+
+ if (letoh32(msg->rm_adrreset) != 0) {
+ u_int32_t filter;
+
+ filter = htole32(sc->sc_filter);
+ rval = urndis_ctrl_set(sc, OID_GEN_CURRENT_PACKET_FILTER,
+ &filter, sizeof(filter));
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: unable to reset data filters\n",
+ DEVNAME(sc));
+ return rval;
+ }
+ }
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_init(struct urndis_softc *sc)
+{
+ struct urndis_init_req *msg;
+ urndis_status rval;
+ struct urndis_comp_hdr *hdr;
+
+ msg = malloc(sizeof(*msg), M_TEMP, M_WAITOK);
+ if (msg == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ msg->rm_type = htole32(REMOTE_NDIS_INITIALIZE_MSG);
+ msg->rm_len = htole32(sizeof(*msg));
+ msg->rm_rid = htole32(0);
+ msg->rm_ver_major = htole32(1);
+ msg->rm_ver_minor = htole32(1);
+ msg->rm_max_xfersz = htole32(RNDIS_BUFSZ);
+
+ DPRINTF(("%s: urndis_ctrl_init send: type %u len %u rid %u ver_major %u "
+ "ver_minor %u max_xfersz %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid),
+ letoh32(msg->rm_ver_major),
+ letoh32(msg->rm_ver_minor),
+ letoh32(msg->rm_max_xfersz)));
+
+ rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
+ free(msg, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: init failed\n", DEVNAME(sc));
+ return rval;
+ }
+
+ if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
+ printf("%s: unable to get init response\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+ rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_halt(struct urndis_softc *sc)
+{
+ struct urndis_halt_req *msg;
+ urndis_status rval;
+
+ msg = malloc(sizeof(*msg), M_TEMP, M_WAITOK);
+ if (msg == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ msg->rm_type = htole32(REMOTE_NDIS_HALT_MSG);
+ msg->rm_len = htole32(sizeof(*msg));
+ msg->rm_rid = 0;
+
+ DPRINTF(("%s: urndis_ctrl_halt send: type %u len %u rid %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid)));
+
+ rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
+ free(msg, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS)
+ printf("%s: halt failed\n", DEVNAME(sc));
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_query(struct urndis_softc *sc, urndis_oid oid,
+ void *qbuf, size_t qlen,
+ void **rbuf, size_t *rbufsz)
+{
+ struct urndis_query_req *msg;
+ urndis_status rval;
+ struct urndis_comp_hdr *hdr;
+
+ msg = malloc(sizeof(*msg) + qlen, M_TEMP, M_WAITOK);
+ if (msg == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ msg->rm_type = htole32(REMOTE_NDIS_QUERY_MSG);
+ msg->rm_len = htole32(sizeof(*msg) + qlen);
+ msg->rm_rid = 0; /* XXX */
+ msg->rm_oid = htole32(oid);
+ msg->rm_infobuflen = htole32(qlen);
+ if (qlen != 0) {
+ msg->rm_infobufoffset = htole32(20);
+ memcpy((char*)msg + 20, qbuf, qlen);
+ } else
+ msg->rm_infobufoffset = 0;
+ msg->rm_devicevchdl = 0;
+
+ DPRINTF(("%s: urndis_ctrl_query send: type %u len %u rid %u oid 0x%x "
+ "infobuflen %u infobufoffset %u devicevchdl %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid),
+ letoh32(msg->rm_oid),
+ letoh32(msg->rm_infobuflen),
+ letoh32(msg->rm_infobufoffset),
+ letoh32(msg->rm_devicevchdl)));
+
+ rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
+ free(msg, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: query failed\n", DEVNAME(sc));
+ return rval;
+ }
+
+ if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
+ printf("%s: unable to get query response\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+ rval = urndis_ctrl_handle(sc, hdr, rbuf, rbufsz);
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_set(struct urndis_softc *sc, urndis_oid oid, void *buf, size_t len)
+{
+ struct urndis_set_req *msg;
+ urndis_status rval;
+ struct urndis_comp_hdr *hdr;
+
+ msg = malloc(sizeof(*msg) + len, M_TEMP, M_WAITOK);
+ if (msg == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ msg->rm_type = htole32(REMOTE_NDIS_SET_MSG);
+ msg->rm_len = htole32(sizeof(*msg) + len);
+ msg->rm_rid = 0; /* XXX */
+ msg->rm_oid = htole32(oid);
+ msg->rm_infobuflen = htole32(len);
+ if (len != 0) {
+ msg->rm_infobufoffset = htole32(20);
+ memcpy((char*)msg + 20, buf, len);
+ } else
+ msg->rm_infobufoffset = 0;
+ msg->rm_devicevchdl = 0;
+
+ DPRINTF(("%s: urndis_ctrl_set send: type %u len %u rid %u oid 0x%x "
+ "infobuflen %u infobufoffset %u devicevchdl %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_rid),
+ letoh32(msg->rm_oid),
+ letoh32(msg->rm_infobuflen),
+ letoh32(msg->rm_infobufoffset),
+ letoh32(msg->rm_devicevchdl)));
+
+ rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
+ free(msg, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: set failed\n", DEVNAME(sc));
+ return rval;
+ }
+
+ if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
+ printf("%s: unable to get set response\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+ rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
+ if (rval != RNDIS_STATUS_SUCCESS)
+ printf("%s: set failed 0x%x\n", DEVNAME(sc), rval);
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_set_param(struct urndis_softc *sc, const char *name, u_int32_t type,
+ void *buf, size_t len)
+{
+ struct urndis_set_parameter *param;
+ urndis_status rval;
+ size_t namelen, tlen;
+
+ if (name)
+ namelen = strlen(name);
+ else
+ namelen = 0;
+ tlen = sizeof(*param) + len + namelen;
+ param = malloc(tlen, M_TEMP, M_WAITOK);
+ if (param == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ param->rm_namelen = htole32(namelen);
+ param->rm_valuelen = htole32(len);
+ param->rm_type = htole32(type);
+ if (namelen != 0) {
+ param->rm_nameoffset = htole32(20);
+ memcpy(param + 20, name, namelen);
+ } else
+ param->rm_nameoffset = 0;
+ if (len != 0) {
+ param->rm_valueoffset = htole32(20 + namelen);
+ memcpy(param + 20 + namelen, buf, len);
+ } else
+ param->rm_valueoffset = 0;
+
+ DPRINTF(("%s: urndis_ctrl_set_param send: nameoffset %u namelen %u "
+ "type 0x%x valueoffset %u valuelen %u\n",
+ DEVNAME(sc),
+ letoh32(param->rm_nameoffset),
+ letoh32(param->rm_namelen),
+ letoh32(param->rm_type),
+ letoh32(param->rm_valueoffset),
+ letoh32(param->rm_valuelen)));
+
+ rval = urndis_ctrl_set(sc, OID_GEN_RNDIS_CONFIG_PARAMETER, param, tlen);
+ free(param, M_TEMP);
+ if (rval != RNDIS_STATUS_SUCCESS)
+ printf("%s: set param failed 0x%x\n", DEVNAME(sc), rval);
+
+ return rval;
+}
+
+/* XXX : adrreset, get it from response */
+urndis_status
+urndis_ctrl_reset(struct urndis_softc *sc)
+{
+ struct urndis_reset_req *reset;
+ urndis_status rval;
+ struct urndis_comp_hdr *hdr;
+
+ reset = malloc(sizeof(*reset), M_TEMP, M_WAITOK);
+ if (reset == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ reset->rm_type = htole32(REMOTE_NDIS_RESET_MSG);
+ reset->rm_len = htole32(sizeof(*reset));
+ reset->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
+
+ DPRINTF(("%s: urndis_ctrl_reset send: type %u len %u rid %u\n",
+ DEVNAME(sc),
+ letoh32(reset->rm_type),
+ letoh32(reset->rm_len),
+ letoh32(reset->rm_rid)));
+
+ rval = urndis_ctrl_send(sc, reset, sizeof(*reset));
+ free(reset, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: reset failed\n", DEVNAME(sc));
+ return rval;
+ }
+
+ if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
+ printf("%s: unable to get reset response\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+ rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
+
+ return rval;
+}
+
+urndis_status
+urndis_ctrl_keepalive(struct urndis_softc *sc)
+{
+ struct urndis_keepalive_req *keep;
+ urndis_status rval;
+ struct urndis_comp_hdr *hdr;
+
+ keep = malloc(sizeof(*keep), M_TEMP, M_WAITOK);
+ if (keep == NULL) {
+ printf("%s: out of memory\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+
+ keep->rm_type = htole32(REMOTE_NDIS_KEEPALIVE_MSG);
+ keep->rm_len = htole32(sizeof(*keep));
+ keep->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
+
+ DPRINTF(("%s: urndis_ctrl_reset send: type %u len %u rid %u\n",
+ DEVNAME(sc),
+ letoh32(keep->rm_type),
+ letoh32(keep->rm_len),
+ letoh32(keep->rm_rid)));
+
+ rval = urndis_ctrl_send(sc, keep, sizeof(*keep));
+ free(keep, M_TEMP);
+
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: keepalive failed\n", DEVNAME(sc));
+ return rval;
+ }
+
+ if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
+ printf("%s: unable to get keepalive response\n", DEVNAME(sc));
+ return RNDIS_STATUS_FAILURE;
+ }
+ rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
+ if (rval != RNDIS_STATUS_SUCCESS) {
+ printf("%s: keepalive failed 0x%x\n", DEVNAME(sc), rval);
+ urndis_ctrl_reset(sc);
+ }
+
+ return rval;
+}
+
+int
+urndis_encap(struct urndis_softc *sc, struct mbuf *m, int idx)
+{
+ struct urndis_chain *c;
+ usbd_status err;
+ struct urndis_packet_msg *msg;
+
+ c = &sc->sc_data.sc_tx_chain[idx];
+
+ msg = (struct urndis_packet_msg *)c->sc_buf;
+
+ memset(msg, 0, sizeof(*msg));
+ msg->rm_type = htole32(REMOTE_NDIS_PACKET_MSG);
+ msg->rm_len = htole32(sizeof(*msg) + m->m_pkthdr.len);
+
+ /* XXX : 36 -> dataoffset corresponding in this struct */
+ msg->rm_dataoffset = htole32(36);
+ msg->rm_datalen = htole32(m->m_pkthdr.len);
+
+ /* XXX : 8 -> dataoffset offset in struct */
+ m_copydata(m, 0, m->m_pkthdr.len,
+ ((char*)msg + 36 + 8));
+
+ DPRINTF(("%s: urndis_encap type 0x%x len %u data(off %u len %u)\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_dataoffset),
+ letoh32(msg->rm_datalen)));
+
+ c->sc_mbuf = m;
+
+ usbd_setup_xfer(c->sc_xfer, sc->sc_bulkout_pipe, c, c->sc_buf,
+ letoh32(msg->rm_len), USBD_FORCE_SHORT_XFER | USBD_NO_COPY, 10000,
+ urndis_txeof);
+
+ /* Transmit */
+ err = usbd_transfer(c->sc_xfer);
+ if (err != USBD_IN_PROGRESS) {
+ urndis_stop(sc);
+ return(EIO);
+ }
+
+ sc->sc_data.sc_tx_cnt++;
+
+ return(0);
+}
+
+/* XXX draft, must implement Multi-Packets Transfer ... :( */
+void
+urndis_decap(struct urndis_softc *sc, struct urndis_chain *c, size_t len)
+{
+ struct mbuf *m;
+ struct urndis_packet_msg *msg;
+ struct ifnet *ifp;
+ int s;
+ int offset;
+
+ ifp = GET_IFP(sc);
+ offset = 0;
+
+ while (len > 0) {
+ msg = (struct urndis_packet_msg *)((char*)c->sc_buf + offset);
+ m = c->sc_mbuf;
+
+ DPRINTF(("%s: urndis_decap buffer size left %u\n", DEVNAME(sc),
+ (int)len));
+
+ DPRINTF(("%s: urndis_decap len %u data(off:%u len:%u) "
+ "oobdata(off:%u len:%u nb:%u) perpacket(off:%u len:%u)\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ letoh32(msg->rm_dataoffset),
+ letoh32(msg->rm_datalen),
+ letoh32(msg->rm_oobdataoffset),
+ letoh32(msg->rm_oobdatalen),
+ letoh32(msg->rm_oobdataelements),
+ letoh32(msg->rm_pktinfooffset),
+ letoh32(msg->rm_pktinfooffset)));
+
+ if (len < sizeof(*msg)) {
+ printf("%s: urndis_decap invalid buffer len %u < "
+ "minimum header %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ sizeof(*msg));
+ return;
+ }
+ if (letoh32(msg->rm_type) != REMOTE_NDIS_PACKET_MSG) {
+ printf("%s: urndis_decap invalid type 0x%x != 0x%x\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_type),
+ REMOTE_NDIS_PACKET_MSG);
+ return;
+ }
+ if (letoh32(msg->rm_len) < sizeof(*msg)) {
+ printf("%s: urndis_decap invalid msg len %u < %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ sizeof(*msg));
+ return;
+ }
+ if (letoh32(msg->rm_len) > len) {
+ printf("%s: urndis_decap invalid msg len %u > buffer "
+ "len %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_len),
+ len);
+ return;
+ }
+ /* XXX : 8 -> dataoffset offset in struct */
+ if (letoh32(msg->rm_dataoffset) +
+ letoh32(msg->rm_datalen) + 8 > letoh32(msg->rm_len)) {
+ printf("%s: urndis_decap invalid data "
+ "len/offset/end_position(%u/%u/%u) -> "
+ "go out of receive buffer limit %u\n",
+ DEVNAME(sc),
+ letoh32(msg->rm_datalen),
+ letoh32(msg->rm_dataoffset),
+ letoh32(msg->rm_dataoffset) +
+ letoh32(msg->rm_datalen) + 8,
+ letoh32(msg->rm_len));
+ return;
+ }
+
+ memcpy(mtod(m, char*),
+ ((char*)&msg->rm_dataoffset + letoh32(msg->rm_dataoffset)),
+ letoh32(msg->rm_datalen));
+ m->m_pkthdr.len = m->m_len = letoh32(msg->rm_datalen);
+
+ if (m->m_len < sizeof(struct ether_header)) {
+ ifp->if_ierrors++;
+ printf("%s: urndis_decap invalid ethernet size "
+ "%d < %d\n",
+ DEVNAME(sc),
+ m->m_len,
+ sizeof(struct ether_header));
+ return;
+ }
+ ifp->if_ipackets++;
+ m->m_pkthdr.rcvif = ifp;
+
+ s = splnet();
+
+ if (urndis_newbuf(sc, c, NULL) == ENOBUFS) {
+ ifp->if_ierrors++;
+ } else {
+
+#if NBPFILTER > 0
+ if (ifp->if_bpf)
+ bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
+#endif
+
+ ether_input_mbuf(ifp, m);
+
+ }
+ splx(s);
+
+ offset += letoh32(msg->rm_len);
+ len -= letoh32(msg->rm_len);
+ }
+}
+
+int
+urndis_newbuf(struct urndis_softc *sc, struct urndis_chain *c, struct mbuf *m)
+{
+ struct mbuf *m_new = NULL;
+
+ if (m == NULL) {
+ MGETHDR(m_new, M_DONTWAIT, MT_DATA);
+ if (m_new == NULL) {
+ printf("%s: no memory for rx list "
+ "-- packet dropped!\n",
+ DEVNAME(sc));
+ return (ENOBUFS);
+ }
+ MCLGET(m_new, M_DONTWAIT);
+ if (!(m_new->m_flags & M_EXT)) {
+ printf("%s: no memory for rx list "
+ "-- packet dropped!\n",
+ DEVNAME(sc));
+ 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->sc_mbuf = m_new;
+ return (0);
+}
+
+int
+urndis_rx_list_init(struct urndis_softc *sc)
+{
+ struct urndis_cdata *cd;
+ struct urndis_chain *c;
+ int i;
+
+ cd = &sc->sc_data;
+ for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
+ c = &cd->sc_rx_chain[i];
+ c->sc_sc = sc;
+ c->sc_idx = i;
+
+ if (urndis_newbuf(sc, c, NULL) == ENOBUFS)
+ return (ENOBUFS);
+
+ if (c->sc_xfer == NULL) {
+ c->sc_xfer = usbd_alloc_xfer(sc->sc_udev);
+ if (c->sc_xfer == NULL)
+ return (ENOBUFS);
+ c->sc_buf = usbd_alloc_buffer(c->sc_xfer,
+ RNDIS_BUFSZ);
+ if (c->sc_buf == NULL)
+ return (ENOBUFS);
+ }
+ }
+
+ return (0);
+}
+
+int
+urndis_tx_list_init(struct urndis_softc *sc)
+{
+ struct urndis_cdata *cd;
+ struct urndis_chain *c;
+ int i;
+
+ cd = &sc->sc_data;
+ for (i = 0; i < RNDIS_TX_LIST_CNT; i++) {
+ c = &cd->sc_tx_chain[i];
+ c->sc_sc = sc;
+ c->sc_idx = i;
+ c->sc_mbuf = NULL;
+ if (c->sc_xfer == NULL) {
+ c->sc_xfer = usbd_alloc_xfer(sc->sc_udev);
+ if (c->sc_xfer == NULL)
+ return (ENOBUFS);
+ c->sc_buf = usbd_alloc_buffer(c->sc_xfer,
+ RNDIS_BUFSZ);
+ if (c->sc_buf == NULL)
+ return (ENOBUFS);
+ }
+ }
+ return (0);
+}
+
+void
+urndis_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+ struct urndis_softc *sc;
+ u_int32_t count;
+
+ sc = (struct urndis_softc *)priv;
+
+ if (status == USBD_CANCELLED || sc->sc_dying)
+ return;
+
+ if (status != USBD_NORMAL_COMPLETION) {
+ DPRINTF(("urndis_intr: status=%d\n", status));
+ if (status == USBD_STALLED)
+ usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
+ return;
+ }
+
+ usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
+
+ if (count != sizeof(sc->sc_intr_buf)) {
+ printf("%s: intr input failure: %u bytes\n", DEVNAME(sc),
+ count);
+ return;
+ }
+
+ sc->sc_intr_buf.notification = UGETDW(&sc->sc_intr_buf.notification);
+ switch (sc->sc_intr_buf.notification) {
+ case 0x1:
+ DPRINTF(("%s: RESPONSE_AVAILABLE\n", DEVNAME(sc)));
+ break;
+
+ default:
+ printf("%s: intr input failure: notification 0x%04x\n",
+ DEVNAME(sc), sc->sc_intr_buf.notification);
+ break;
+ }
+}
+
+int
+urndis_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
+{
+ struct urndis_softc *sc;
+ struct ifaddr *ifa;
+ int s, error;
+
+ sc = ifp->if_softc;
+ ifa = (struct ifaddr *)data;
+ error = 0;
+
+ if (sc->sc_dying)
+ return (EIO);
+
+ s = splnet();
+
+ switch(command) {
+ case SIOCSIFADDR:
+ ifp->if_flags |= IFF_UP;
+ urndis_init(sc);
+
+ switch (ifa->ifa_addr->sa_family) {
+ case AF_INET:
+ arp_ifinit(&sc->sc_arpcom, ifa);
+ break;
+ }
+ break;
+
+ case SIOCSIFFLAGS:
+ if (ifp->if_flags & IFF_UP) {
+ if (!(ifp->if_flags & IFF_RUNNING))
+ urndis_init(sc);
+ } else {
+ if (ifp->if_flags & IFF_RUNNING)
+ urndis_stop(sc);
+ }
+ error = 0;
+ break;
+
+ default:
+ error = ether_ioctl(ifp, &sc->sc_arpcom, command, data);
+ break;
+ }
+
+ if (error == ENETRESET)
+ error = 0;
+
+ splx(s);
+ return (error);
+}
+
+void
+urndis_watchdog(struct ifnet *ifp)
+{
+ struct urndis_softc *sc;
+
+ sc = ifp->if_softc;
+
+ if (sc->sc_dying)
+ return;
+
+ ifp->if_oerrors++;
+ printf("%s: watchdog timeout\n", DEVNAME(sc));
+
+ urndis_ctrl_keepalive(sc);
+}
+
+void
+urndis_init(struct urndis_softc *sc)
+{
+ struct ifnet *ifp;
+ int i, s;
+ usbd_status err;
+
+
+ ifp = GET_IFP(sc);
+ if (ifp->if_flags & IFF_RUNNING)
+ return;
+
+ if (urndis_ctrl_init(sc) != RNDIS_STATUS_SUCCESS)
+ return;
+
+ s = splnet();
+
+ if (sc->sc_intr_no != -1 && sc->sc_intr_pipe == NULL) {
+ usbd_status err;
+
+ DPRINTF(("urndis_init: establish interrupt pipe\n"));
+ err = usbd_open_pipe_intr(sc->sc_iface_ctl,
+ sc->sc_intr_no,
+ USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,
+ &sc->sc_intr_buf, sizeof(sc->sc_intr_buf),
+ urndis_intr, USBD_DEFAULT_INTERVAL);
+ if (err) {
+ printf("%s: open interrupt pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ splx(s);
+ return;
+ }
+ }
+
+ if (urndis_tx_list_init(sc) == ENOBUFS) {
+ printf("%s: tx list init failed\n",
+ DEVNAME(sc));
+ splx(s);
+ return;
+ }
+
+ if (urndis_rx_list_init(sc) == ENOBUFS) {
+ printf("%s: rx list init failed\n",
+ DEVNAME(sc));
+ splx(s);
+ return;
+ }
+
+ err = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkin_no,
+ USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
+ if (err) {
+ printf("%s: open rx pipe failed: %s\n", DEVNAME(sc),
+ usbd_errstr(err));
+ splx(s);
+ return;
+ }
+
+ err = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkout_no,
+ USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
+ if (err) {
+ printf("%s: open tx pipe failed: %s\n", DEVNAME(sc),
+ usbd_errstr(err));
+ splx(s);
+ return;
+ }
+
+ for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
+ struct urndis_chain *c;
+
+ c = &sc->sc_data.sc_rx_chain[i];
+ usbd_setup_xfer(c->sc_xfer, sc->sc_bulkin_pipe, c,
+ c->sc_buf, RNDIS_BUFSZ,
+ USBD_SHORT_XFER_OK | USBD_NO_COPY,
+ USBD_NO_TIMEOUT, urndis_rxeof);
+ usbd_transfer(c->sc_xfer);
+ }
+
+ ifp->if_flags |= IFF_RUNNING;
+ ifp->if_flags &= ~IFF_OACTIVE;
+
+ splx(s);
+}
+
+void
+urndis_stop(struct urndis_softc *sc)
+{
+ usbd_status err;
+ struct ifnet *ifp;
+ int i;
+
+ ifp = GET_IFP(sc);
+ ifp->if_timer = 0;
+ ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
+
+ if (sc->sc_bulkin_pipe != NULL) {
+ err = usbd_abort_pipe(sc->sc_bulkin_pipe);
+ if (err)
+ printf("%s: abort rx pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ err = usbd_close_pipe(sc->sc_bulkin_pipe);
+ if (err)
+ printf("%s: close rx pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ sc->sc_bulkin_pipe = NULL;
+ }
+
+ if (sc->sc_bulkout_pipe != NULL) {
+ err = usbd_abort_pipe(sc->sc_bulkout_pipe);
+ if (err)
+ printf("%s: abort tx pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ err = usbd_close_pipe(sc->sc_bulkout_pipe);
+ if (err)
+ printf("%s: close tx pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ sc->sc_bulkout_pipe = NULL;
+ }
+
+ if (sc->sc_intr_pipe != NULL) {
+ err = usbd_abort_pipe(sc->sc_intr_pipe);
+ if (err)
+ printf("%s: abort interrupt pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ err = usbd_close_pipe(sc->sc_intr_pipe);
+ if (err)
+ printf("%s: close interrupt pipe failed: %s\n",
+ DEVNAME(sc), usbd_errstr(err));
+ sc->sc_intr_pipe = NULL;
+ }
+
+ for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
+ if (sc->sc_data.sc_rx_chain[i].sc_mbuf != NULL) {
+ m_freem(sc->sc_data.sc_rx_chain[i].sc_mbuf);
+ sc->sc_data.sc_rx_chain[i].sc_mbuf = NULL;
+ }
+ if (sc->sc_data.sc_rx_chain[i].sc_xfer != NULL) {
+ usbd_free_xfer(sc->sc_data.sc_rx_chain[i].sc_xfer);
+ sc->sc_data.sc_rx_chain[i].sc_xfer = NULL;
+ }
+ }
+
+ for (i = 0; i < RNDIS_TX_LIST_CNT; i++) {
+ if (sc->sc_data.sc_tx_chain[i].sc_mbuf != NULL) {
+ m_freem(sc->sc_data.sc_tx_chain[i].sc_mbuf);
+ sc->sc_data.sc_tx_chain[i].sc_mbuf = NULL;
+ }
+ if (sc->sc_data.sc_tx_chain[i].sc_xfer != NULL) {
+ usbd_free_xfer(sc->sc_data.sc_tx_chain[i].sc_xfer);
+ sc->sc_data.sc_tx_chain[i].sc_xfer = NULL;
+ }
+ }
+}
+
+void
+urndis_start(struct ifnet *ifp)
+{
+ struct urndis_softc *sc;
+ struct mbuf *m_head = NULL;
+
+ sc = ifp->if_softc;
+
+ if (sc->sc_dying || (ifp->if_flags & IFF_OACTIVE))
+ return;
+
+ IFQ_POLL(&ifp->if_snd, m_head);
+ if (m_head == NULL)
+ return;
+
+ if (urndis_encap(sc, m_head, 0)) {
+ ifp->if_flags |= IFF_OACTIVE;
+ return;
+ }
+ IFQ_DEQUEUE(&ifp->if_snd, m_head);
+
+ /*
+ * If there's a BPF listener, bounce a copy of this frame
+ * to him.
+ */
+#if NBPFILTER > 0
+ if (ifp->if_bpf)
+ bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
+#endif
+
+ ifp->if_flags |= IFF_OACTIVE;
+
+ /*
+ * Set a timeout in case the chip goes out to lunch.
+ */
+ ifp->if_timer = 5;
+
+ return;
+}
+
+void
+urndis_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+ struct urndis_chain *c;
+ struct urndis_softc *sc;
+ struct ifnet *ifp;
+ size_t total_len;
+
+ c = priv;
+ sc = c->sc_sc;
+ ifp = GET_IFP(sc);
+ total_len = 0;
+
+ if (sc->sc_dying || !(ifp->if_flags & IFF_RUNNING))
+ return;
+
+ if (status != USBD_NORMAL_COMPLETION) {
+ if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
+ return;
+#if 0
+ if (sc->sc_rxeof_errors == 0)
+ printf("%s: usb error on rx: %s\n", DEVNAME(sc),
+ usbd_errstr(status));
+#endif
+ if (status == USBD_STALLED)
+ usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
+
+#if 0
+ DELAY(sc->sc_rxeof_errors * 10000);
+ if (sc->sc_rxeof_errors++ > 10) {
+ printf("%s: too many errors, disabling\n",
+ DEVNAME(sc));
+ sc->sc_dying = 1;
+ return;
+ }
+#endif
+ goto done;
+ }
+
+#if 0
+ sc->sc_rxeof_errors = 0;
+#endif
+
+ usbd_get_xfer_status(xfer, NULL, NULL, (u_int32_t*)&total_len, NULL);
+ urndis_decap(sc, c, total_len);
+
+done:
+ /* Setup new transfer. */
+ usbd_setup_xfer(c->sc_xfer, sc->sc_bulkin_pipe, c, c->sc_buf,
+ RNDIS_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
+ urndis_rxeof);
+ usbd_transfer(c->sc_xfer);
+}
+
+void
+urndis_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
+{
+ struct urndis_chain *c;
+ struct urndis_softc *sc;
+ struct ifnet *ifp;
+ usbd_status err;
+ int s;
+
+ c = priv;
+ sc = c->sc_sc;
+ ifp = GET_IFP(sc);
+
+ DPRINTF(("%s: urndis_txeof\n", DEVNAME(sc)));
+
+ if (sc->sc_dying)
+ return;
+
+ s = splnet();
+
+ ifp->if_timer = 0;
+ ifp->if_flags &= ~IFF_OACTIVE;
+
+ if (status != USBD_NORMAL_COMPLETION) {
+ if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
+ splx(s);
+ return;
+ }
+ ifp->if_oerrors++;
+ printf("%s: usb error on tx: %s\n", DEVNAME(sc),
+ usbd_errstr(status));
+ if (status == USBD_STALLED)
+ usbd_clear_endpoint_stall_async(sc->sc_bulkout_pipe);
+ splx(s);
+ return;
+ }
+
+ usbd_get_xfer_status(c->sc_xfer, NULL, NULL, NULL, &err);
+
+ if (c->sc_mbuf != NULL) {
+ m_freem(c->sc_mbuf);
+ c->sc_mbuf = NULL;
+ }
+
+ if (err)
+ ifp->if_oerrors++;
+ else
+ ifp->if_opackets++;
+
+ if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
+ urndis_start(ifp);
+
+ splx(s);
+}
+
+int
+urndis_match(struct device *parent, void *match, void *aux)
+{
+ struct usb_attach_arg *uaa;
+ usb_interface_descriptor_t *id;
+
+ uaa = aux;
+
+ if (!uaa->iface)
+ return (UMATCH_NONE);
+
+ id = usbd_get_interface_descriptor(uaa->iface);
+ if (id == NULL)
+ return (UMATCH_NONE);
+
+ if (id->bInterfaceClass == UICLASS_WIRELESS &&
+ id->bInterfaceSubClass == UISUBCLASS_RF &&
+ id->bInterfaceProtocol == UIPROTO_RNDIS)
+ return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
+
+ /* XXX Hack for HTC Hero for now */
+ if (id->bInterfaceClass == UICLASS_CDC &&
+ id->bInterfaceSubClass == UISUBCLASS_ABSTRACT_CONTROL_MODEL)
+ return (UMATCH_IFACECLASS_GENERIC);
+
+
+ return (UMATCH_NONE);
+}
+
+void
+urndis_attach(struct device *parent, struct device *self, void *aux)
+{
+ struct urndis_softc *sc;
+ struct usb_attach_arg *uaa;
+ struct ifnet *ifp;
+ usb_interface_descriptor_t *id;
+ usb_endpoint_descriptor_t *ed;
+ usb_config_descriptor_t *cd;
+ usb_cdc_union_descriptor_t *ud;
+ const usb_descriptor_t *desc;
+ usbd_desc_iter_t iter;
+ int if_ctl, if_data;
+ int i, j, altcnt;
+ int s;
+ u_char eaddr[ETHER_ADDR_LEN];
+ void *buf;
+ size_t bufsz;
+ u_int32_t filter;
+
+ sc = (void *)self;
+ uaa = aux;
+
+ sc->sc_udev = uaa->device;
+ sc->sc_iface_ctl = uaa->iface;
+ id = usbd_get_interface_descriptor(sc->sc_iface_ctl);
+ if_ctl = id->bInterfaceNumber;
+ sc->sc_ifaceno_ctl = if_ctl;
+ if_data = -1;
+
+ usb_desc_iter_init(sc->sc_udev, &iter);
+ while ((desc = usb_desc_iter_next(&iter)) != NULL) {
+
+ if (desc->bDescriptorType != UDESC_CS_INTERFACE) {
+ continue;
+ }
+ switch (desc->bDescriptorSubtype) {
+ case UDESCSUB_CDC_UNION:
+ ud = (usb_cdc_union_descriptor_t *)desc;
+ /* XXX bail out when found first? */
+ if (if_data == -1)
+ if_data = ud->bSlaveInterface[0];
+ break;
+ }
+ }
+
+ if (if_data == -1) {
+ DPRINTF(("urndis_attach: no union interface\n"));
+ sc->sc_iface_data = sc->sc_iface_ctl;
+ } else {
+ DPRINTF(("urndis_attach: union interface: ctl %u, data %u\n",
+ if_ctl, if_data));
+ for (i = 0; i < uaa->nifaces; i++) {
+ if (uaa->ifaces[i] == NULL)
+ continue;
+ id = usbd_get_interface_descriptor(uaa->ifaces[i]);
+ if (id && id->bInterfaceNumber == if_data) {
+ sc->sc_iface_data = uaa->ifaces[i];
+ uaa->ifaces[i] = NULL;
+ }
+ }
+ }
+
+ if (sc->sc_iface_data == NULL) {
+ printf("%s: no data interface\n", DEVNAME(sc));
+ return;
+ }
+
+ id = usbd_get_interface_descriptor(sc->sc_iface_ctl);
+ sc->sc_intr_no = -1;
+ for (i = 0; i < id->bNumEndpoints && sc->sc_intr_no == -1; i++) {
+ ed = usbd_interface2endpoint_descriptor(sc->sc_iface_ctl, i);
+ if (!ed) {
+ printf("%s: no descriptor for interrupt endpoint %u\n",
+ DEVNAME(sc));
+ return;
+ }
+
+ if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+ UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
+ sc->sc_intr_no = ed->bEndpointAddress;
+ break;
+ }
+ }
+ DPRINTF(("%s: found intr endpoint %u\n", DEVNAME(sc),
+ sc->sc_intr_no));
+
+ id = usbd_get_interface_descriptor(sc->sc_iface_data);
+ cd = usbd_get_config_descriptor(sc->sc_udev);
+ altcnt = usbd_get_no_alts(cd, id->bInterfaceNumber);
+
+ for (j = 0; j < altcnt; j++) {
+ if (usbd_set_interface(sc->sc_iface_data, j)) {
+ printf("%s: interface alternate setting %u failed\n",
+ DEVNAME(sc), j);
+ return;
+ }
+ /* Find endpoints. */
+ id = usbd_get_interface_descriptor(sc->sc_iface_data);
+ sc->sc_bulkin_no = sc->sc_bulkout_no = -1;
+ for (i = 0; i < id->bNumEndpoints; i++) {
+ ed = usbd_interface2endpoint_descriptor(
+ sc->sc_iface_data, i);
+ if (!ed) {
+ printf("%s: no descriptor for bulk endpoint "
+ "%u\n", DEVNAME(sc), i);
+ return;
+ }
+ if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
+ UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+ sc->sc_bulkin_no = ed->bEndpointAddress;
+ }
+ else if (
+ UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
+ UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
+ sc->sc_bulkout_no = ed->bEndpointAddress;
+ }
+ }
+
+ if (sc->sc_bulkin_no != -1 && sc->sc_bulkout_no != -1) {
+ DPRINTF(("%s: intr=0x%x, in=0x%x, out=0x%x\n",
+ DEVNAME(sc),
+ sc->sc_intr_no, sc->sc_bulkin_no,
+ sc->sc_bulkout_no));
+ goto found;
+ }
+ }
+
+ if (sc->sc_bulkin_no == -1)
+ printf("%s: could not find data bulk in\n", DEVNAME(sc));
+ if (sc->sc_bulkout_no == -1 )
+ printf("%s: could not find data bulk out\n", DEVNAME(sc));
+ return;
+
+ found:
+
+ urndis_init(sc);
+
+ s = splnet();
+
+ if (urndis_ctrl_query(sc, OID_802_3_PERMANENT_ADDRESS, NULL, 0,
+ &buf, &bufsz) != RNDIS_STATUS_SUCCESS) {
+ printf("%s: unable to get hardware address\n", DEVNAME(sc));
+ return;
+ }
+
+ if (bufsz == ETHER_ADDR_LEN) {
+ memcpy(eaddr, buf, ETHER_ADDR_LEN);
+ printf("%s: address %s\n", DEVNAME(sc), ether_sprintf(eaddr));
+ free(buf, M_TEMP);
+ } else {
+ printf("%s: invalid address\n", DEVNAME(sc));
+ free(buf, M_TEMP);
+ return;
+ }
+
+ /* Initialize packet filter */
+ sc->sc_filter = RNDIS_PACKET_TYPE_BROADCAST;
+ sc->sc_filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
+ filter = htole32(sc->sc_filter);
+ if (urndis_ctrl_set(sc, OID_GEN_CURRENT_PACKET_FILTER, &filter,
+ sizeof(filter)) != RNDIS_STATUS_SUCCESS) {
+ printf("%s: unable to set data filters\n", DEVNAME(sc));
+ return;
+ }
+
+ bcopy(eaddr, (char *)&sc->sc_arpcom.ac_enaddr, ETHER_ADDR_LEN);
+
+
+ ifp = GET_IFP(sc);
+ ifp->if_softc = sc;
+ ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
+ ifp->if_flags |= IFF_RUNNING;
+ ifp->if_flags &= ~IFF_OACTIVE;
+ ifp->if_start = urndis_start;
+ ifp->if_ioctl = urndis_ioctl;
+#if 0
+ ifp->if_watchdog = urndis_watchdog;
+#endif
+
+ strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
+
+ IFQ_SET_READY(&ifp->if_snd);
+
+ if_attach(ifp);
+ ether_ifattach(ifp);
+
+ splx(s);
+
+ usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, &sc->sc_dev);
+}
+
+int
+urndis_detach(struct device *self, int flags)
+{
+ struct urndis_softc *sc;
+ struct ifnet *ifp;
+ int s;
+
+ sc = (void*)self;
+ s = splusb();
+
+ DPRINTF(("urndis_detach: %s flags %u\n", DEVNAME(sc),
+ flags));
+
+ sc->sc_dying = 1;
+
+ ifp = GET_IFP(sc);
+
+ ether_ifdetach(ifp);
+ if_detach(ifp);
+
+ urndis_stop(sc);
+
+ splx(s);
+
+ usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
+ &sc->sc_dev);
+
+ return 0;
+}
+
+int
+urndis_activate(struct device *self, int devact)
+{
+ struct urndis_softc *sc;
+
+ sc = (struct urndis_softc *)self;
+
+ switch (devact) {
+ case DVACT_ACTIVATE:
+ break;
+
+ case DVACT_DEACTIVATE:
+ sc->sc_dying = 1;
+ break;
+ }
+
+ return 0;
+}
diff --git a/sys/dev/usb/if_urndisreg.h b/sys/dev/usb/if_urndisreg.h
new file mode 100644
index 00000000000..9e02d0a3706
--- /dev/null
+++ b/sys/dev/usb/if_urndisreg.h
@@ -0,0 +1,334 @@
+/* $OpenBSD: if_urndisreg.h,v 1.1 2010/03/01 23:35:56 mk Exp $ */
+
+/*
+ * Copyright (c) 2010 Jonathan Armani <dbd@asystant.net>
+ * Copyright (c) 2010 Fabien Romano <fromano@asystant.net>
+ * Copyright (c) 2010 Michael Knudsen <mk@openbsd.org>
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#define RNDIS_RX_LIST_CNT 1
+#define RNDIS_TX_LIST_CNT 1
+#define RNDIS_BUFSZ 1542
+
+struct urndis_notification {
+ u_int32_t notification;
+ u_int32_t reserved;
+};
+
+struct urndis_chain {
+ struct urndis_softc *sc_sc;
+ usbd_xfer_handle sc_xfer;
+ char *sc_buf;
+ struct mbuf *sc_mbuf;
+ int sc_accum;
+ int sc_idx;
+};
+
+struct urndis_cdata {
+ struct urndis_chain sc_rx_chain[RNDIS_RX_LIST_CNT];
+ struct urndis_chain sc_tx_chain[RNDIS_TX_LIST_CNT];
+ int sc_tx_prod;
+ int sc_tx_cons;
+ int sc_tx_cnt;
+ int sc_rx_prod;
+};
+
+#define GET_IFP(sc) (&(sc)->sc_arpcom.ac_if)
+struct urndis_softc {
+ struct device sc_dev;
+
+ int sc_dying;
+ struct arpcom sc_arpcom;
+
+ /* RNDIS device info */
+ u_int32_t sc_lim_pktcnt;
+ u_int32_t sc_lim_pktsz;
+ u_int32_t sc_pktalign;
+ u_int32_t sc_filter;
+
+ /* USB goo */
+ usbd_device_handle sc_udev;
+ int sc_ifaceno_ctl;
+ usbd_interface_handle sc_iface_ctl;
+ usbd_interface_handle sc_iface_data;
+
+ int sc_intr_no;
+ usbd_pipe_handle sc_intr_pipe;
+ int sc_intr_size;
+ struct urndis_notification sc_intr_buf;
+
+ int sc_bulkin_no;
+ usbd_pipe_handle sc_bulkin_pipe;
+ int sc_bulkout_no;
+ usbd_pipe_handle sc_bulkout_pipe;
+
+ struct urndis_cdata sc_data;
+};
+
+typedef u_int32_t urndis_status;
+
+#define RNDIS_STATUS_BUFFER_OVERFLOW 0x80000005L
+#define RNDIS_STATUS_FAILURE 0xC0000001L
+#define RNDIS_STATUS_INVALID_DATA 0xC0010015L
+#define RNDIS_STATUS_MEDIA_CONNECT 0x4001000BL
+#define RNDIS_STATUS_MEDIA_DISCONNECT 0x4001000CL
+#define RNDIS_STATUS_NOT_SUPPORTED 0xC00000BBL
+#define RNDIS_STATUS_PENDING STATUS_PENDING /* XXX */
+#define RNDIS_STATUS_RESOURCES 0xC000009AL
+#define RNDIS_STATUS_SUCCESS 0x00000000L
+
+typedef u_int32_t urndis_req_id; /* seq nr. */
+
+typedef u_int32_t urndis_oid;
+
+#define OID_GEN_SUPPORTED_LIST 0x00010101
+#define OID_GEN_HARDWARE_STATUS 0x00010102
+#define OID_GEN_MEDIA_SUPPORTED 0x00010103
+#define OID_GEN_MEDIA_IN_USE 0x00010104
+#define OID_GEN_MAXIMUM_LOOKAHEAD 0x00010105
+#define OID_GEN_MAXIMUM_FRAME_SIZE 0x00010106
+#define OID_GEN_LINK_SPEED 0x00010107
+#define OID_GEN_TRANSMIT_BUFFER_SPACE 0x00010108
+#define OID_GEN_RECEIVE_BUFFER_SPACE 0x00010109
+#define OID_GEN_TRANSMIT_BLOCK_SIZE 0x0001010A
+#define OID_GEN_RECEIVE_BLOCK_SIZE 0x0001010B
+#define OID_GEN_VENDOR_ID 0x0001010C
+#define OID_GEN_VENDOR_DESCRIPTION 0x0001010D
+#define OID_GEN_CURRENT_PACKET_FILTER 0x0001010E
+#define OID_GEN_CURRENT_LOOKAHEAD 0x0001010F
+#define OID_GEN_DRIVER_VERSION 0x00010110
+#define OID_GEN_MAXIMUM_TOTAL_SIZE 0x00010111
+#define OID_GEN_PROTOCOL_OPTIONS 0x00010112
+#define OID_GEN_MAC_OPTIONS 0x00010113
+#define OID_GEN_MEDIA_CONNECT_STATUS 0x00010114
+#define OID_GEN_MAXIMUM_SEND_PACKETS 0x00010115
+#define OID_GEN_VENDOR_DRIVER_VERSION 0x00010116
+#define OID_GEN_SUPPORTED_GUIDS 0x00010117
+#define OID_GEN_NETWORK_LAYER_ADDRESSES 0x00010118
+#define OID_GEN_TRANSPORT_HEADER_OFFSET 0x00010119
+#define OID_GEN_MACHINE_NAME 0x0001021A
+#define OID_GEN_RNDIS_CONFIG_PARAMETER 0x0001021B
+#define OID_GEN_VLAN_ID 0x0001021C
+
+
+#define OID_802_3_PERMANENT_ADDRESS 0x01010101
+#define OID_802_3_CURRENT_ADDRESS 0x01010102
+#define OID_802_3_MULTICAST_LIST 0x01010103
+#define OID_802_3_MAXIMUM_LIST_SIZE 0x01010104
+#define OID_802_3_MAC_OPTIONS 0x01010105
+#define OID_802_3_RCV_ERROR_ALIGNMENT 0x01020101
+#define OID_802_3_XMIT_ONE_COLLISION 0x01020102
+#define OID_802_3_XMIT_MORE_COLLISIONS 0x01020103
+#define OID_802_3_XMIT_DEFERRED 0x01020201
+#define OID_802_3_XMIT_MAX_COLLISIONS 0x01020202
+#define OID_802_3_RCV_OVERRUN 0x01020203
+#define OID_802_3_XMIT_UNDERRUN 0x01020204
+#define OID_802_3_XMIT_HEARTBEAT_FAILURE 0x01020205
+#define OID_802_3_XMIT_TIMES_CRS_LOST 0x01020206
+#define OID_802_3_XMIT_LATE_COLLISIONS 0x01020207
+
+typedef u_int32_t urndis_medium;
+#define RNDIS_MEDIUM_802_3 0x00000000
+
+/* Device flags */
+#define RNDIS_DF_CONNECTIONLESS 0x00000001
+#define RNDIS_DF_CONNECTION_ORIENTED 0x00000002
+
+/*
+ * RNDIS data message
+ */
+#define REMOTE_NDIS_PACKET_MSG 0x00000001
+
+struct urndis_packet_msg {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ u_int32_t rm_dataoffset;
+ u_int32_t rm_datalen;
+ u_int32_t rm_oobdataoffset;
+ u_int32_t rm_oobdatalen;
+ u_int32_t rm_oobdataelements;
+ u_int32_t rm_pktinfooffset;
+ u_int32_t rm_pktinfolen;
+ u_int32_t rm_vchandle; /* XXX zero */
+ u_int32_t rm_reserved;
+};
+
+/*
+ * RNDIS control messages
+ */
+struct urndis_comp_hdr {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_status rm_status;
+};
+
+/* Initialize the device. */
+#define REMOTE_NDIS_INITIALIZE_MSG 0x00000002
+#define REMOTE_NDIS_INITIALIZE_CMPLT 0x80000002
+
+struct urndis_init_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ u_int32_t rm_ver_major;
+ u_int32_t rm_ver_minor;
+ u_int32_t rm_max_xfersz;
+};
+
+struct urndis_init_comp {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_status rm_status;
+ u_int32_t rm_ver_major;
+ u_int32_t rm_ver_minor;
+ u_int32_t rm_devflags;
+ urndis_medium rm_medium;
+ u_int32_t rm_pktmaxcnt;
+ u_int32_t rm_pktmaxsz;
+ u_int32_t rm_align;
+ u_int32_t rm_aflistoffset;
+ u_int32_t rm_aflistsz;
+};
+
+/* Halt the device. No response sent. */
+#define REMOTE_NDIS_HALT_MSG 0x00000003
+
+struct urndis_halt_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+};
+
+/* Send a query object. */
+#define REMOTE_NDIS_QUERY_MSG 0x00000004
+#define REMOTE_NDIS_QUERY_CMPLT 0x80000004
+
+struct urndis_query_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_oid rm_oid;
+ u_int32_t rm_infobuflen;
+ u_int32_t rm_infobufoffset;
+ u_int32_t rm_devicevchdl; /* XXX DeviceVcHandle */
+};
+
+struct urndis_query_comp {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_status rm_status;
+ u_int32_t rm_infobuflen;
+ u_int32_t rm_infobufoffset;
+};
+
+/* Send a set object request. */
+#define REMOTE_NDIS_SET_MSG 0x00000005
+#define REMOTE_NDIS_SET_CMPLT 0x80000005
+
+struct urndis_set_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_oid rm_oid;
+ u_int32_t rm_infobuflen;
+ u_int32_t rm_infobufoffset;
+ u_int32_t rm_devicevchdl; /* XXX DeviceVcHandle */
+};
+
+struct urndis_set_comp {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_status rm_status;
+};
+
+#define REMOTE_NDIS_SET_PARAM_NUMERIC 0x00000000
+#define REMOTE_NDIS_SET_PARAM_STRING 0x00000002
+
+struct urndis_set_parameter {
+ u_int32_t rm_nameoffset;
+ u_int32_t rm_namelen;
+ u_int32_t rm_type;
+ u_int32_t rm_valueoffset;
+ u_int32_t rm_valuelen;
+};
+
+/* Perform a soft reset on the device. */
+#define REMOTE_NDIS_RESET_MSG 0x00000006
+#define REMOTE_NDIS_RESET_CMPLT 0x80000006
+
+struct urndis_reset_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+};
+
+struct urndis_reset_comp {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_status rm_status;
+ u_int32_t rm_adrreset;
+};
+
+/* 802.3 link-state or undefined message error. */
+#define REMOTE_NDIS_INDICATE_STATUS_MSG 0x00000007
+
+struct urndis_status_msg { /* XXX unhappy about the name */
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_status rm_status;
+ u_int32_t rm_statusbuflen;
+ u_int32_t rm_statusbufoffset;
+ urndis_status rm_diagstatus;
+ u_int32_t rm_erroroffset;
+#if 0
+ (RNDIS_MESSAGE) Message; /* XXX */
+#endif
+};
+
+/* Keepalive messsage. May be sent by device. */
+#define REMOTE_NDIS_KEEPALIVE_MSG 0x00000008
+#define REMOTE_NDIS_KEEPALIVE_CMPLT 0x80000008
+
+struct urndis_keepalive_req {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+};
+
+struct urndis_keepalive_comp {
+ u_int32_t rm_type;
+ u_int32_t rm_len;
+ urndis_req_id rm_rid;
+ urndis_status rm_status;
+};
+
+/* packet filter bits used by OID_GEN_CURRENT_PACKET_FILTER */
+#define RNDIS_PACKET_TYPE_DIRECTED 0x00000001
+#define RNDIS_PACKET_TYPE_MULTICAST 0x00000002
+#define RNDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004
+#define RNDIS_PACKET_TYPE_BROADCAST 0x00000008
+#define RNDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010
+#define RNDIS_PACKET_TYPE_PROMISCUOUS 0x00000020
+#define RNDIS_PACKET_TYPE_SMT 0x00000040
+#define RNDIS_PACKET_TYPE_ALL_LOCAL 0x00000080
+#define RNDIS_PACKET_TYPE_GROUP 0x00001000
+#define RNDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00002000
+#define RNDIS_PACKET_TYPE_FUNCTIONAL 0x00004000
+#define RNDIS_PACKET_TYPE_MAC_FRAME 0x00008000
diff --git a/sys/dev/usb/usb.h b/sys/dev/usb/usb.h
index d6207c678ec..c2131b20ca3 100644
--- a/sys/dev/usb/usb.h
+++ b/sys/dev/usb/usb.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: usb.h,v 1.34 2008/12/09 03:08:07 yuo Exp $ */
+/* $OpenBSD: usb.h,v 1.35 2010/03/01 23:35:56 mk Exp $ */
/* $NetBSD: usb.h,v 1.69 2002/09/22 23:20:50 augustss Exp $ */
/* $FreeBSD: src/sys/dev/usb/usb.h,v 1.14 1999/11/17 22:33:46 n_hibma Exp $ */
@@ -478,6 +478,7 @@ typedef struct {
#define UICLASS_WIRELESS 0xe0
#define UISUBCLASS_RF 0x01
#define UIPROTO_BLUETOOTH 0x01
+#define UIPROTO_RNDIS 0x03
#define UICLASS_APPL_SPEC 0xfe
#define UISUBCLASS_FIRMWARE_DOWNLOAD 1
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 17:45:04 +0000