Check in the known good version of the wi driver, with prism/symbol

support stripped out and minimally renamed to owi.  This driver
attaches to lucent cards only.  This is designed to aid in the testing
of fixes to the wi driver for lucent cards.  It is supported only as a
module (you cannot compile it into your kernel).  You cannot have the
wi driver in your kernel (or loaded as a moudle) to use the owi
module.

I've not connected it to build, as this module is currently for
debugging purposes.  This is for developers only at the present time.
If we can't get lucent support fixed by 5.2 code freeze, then we'll
re-evaulate this support level.  Please use this to fix the lucent
support in dev/wi.  This will be removed from the system when lucent
support has been fixed in dev/wi.

Note to developers: Do not connect this to the build, make it possible
to build into the kernel or otherwise 'integrate' this into system
without checking with me first.  This is for debugging purposes only.

If this doesn't work for you, I don't want to hear about it unless you
are fixing the wi driver :-)

6 files changed, 3715 insertions, 0 deletions

diff --git a/sys/dev/owi/if_ieee80211.h b/sys/dev/owi/if_ieee80211.h
new file mode 100644
index 0000000..0e67c58
--- /dev/null
+++ b/sys/dev/owi/if_ieee80211.h
@@ -0,0 +1,273 @@
+/*	$NetBSD: if_ieee80211.h,v 1.5 2000/07/21 04:47:40 onoe Exp $	*/
+/* $FreeBSD$ */
+
+#ifndef _NET_IF_IEEE80211_H_
+#define _NET_IF_IEEE80211_H_
+
+/*
+ * generic definitions for IEEE 802.11 frames
+ */
+struct ieee80211_frame {
+	u_int8_t	i_fc[2];
+	u_int8_t	i_dur[2];
+	u_int8_t	i_addr1[ETHER_ADDR_LEN];
+	u_int8_t	i_addr2[ETHER_ADDR_LEN];
+	u_int8_t	i_addr3[ETHER_ADDR_LEN];
+	u_int8_t	i_seq[2];
+	/* possibly followed by addr4[ETHER_ADDR_LEN]; */
+};
+
+#define	IEEE80211_FC0_VERSION_MASK		0x03
+#define	IEEE80211_FC0_VERSION_0			0x00
+#define	IEEE80211_FC0_TYPE_MASK			0x0c
+#define	IEEE80211_FC0_TYPE_MGT			0x00
+#define	IEEE80211_FC0_TYPE_CTL			0x04
+#define	IEEE80211_FC0_TYPE_DATA			0x08
+
+#define	IEEE80211_FC0_SUBTYPE_MASK		0xf0
+/* for TYPE_MGT */
+#define	IEEE80211_FC0_SUBTYPE_ASSOC_REQ		0x00
+#define	IEEE80211_FC0_SUBTYPE_ASSOC_RESP	0x10
+#define	IEEE80211_FC0_SUBTYPE_REASSOC_REQ	0x20
+#define	IEEE80211_FC0_SUBTYPE_REASSOC_RESP	0x30
+#define	IEEE80211_FC0_SUBTYPE_PROBE_REQ		0x40
+#define	IEEE80211_FC0_SUBTYPE_PROBE_RESP	0x50
+#define	IEEE80211_FC0_SUBTYPE_BEACON		0x80
+#define	IEEE80211_FC0_SUBTYPE_ATIM		0x90
+#define	IEEE80211_FC0_SUBTYPE_DISASSOC		0xa0
+#define	IEEE80211_FC0_SUBTYPE_AUTH		0xb0
+#define	IEEE80211_FC0_SUBTYPE_DEAUTH		0xc0
+/* for TYPE_CTL */
+#define	IEEE80211_FC0_SUBTYPE_PS_POLL		0xa0
+#define	IEEE80211_FC0_SUBTYPE_RTS		0xb0
+#define	IEEE80211_FC0_SUBTYPE_CTS		0xc0
+#define	IEEE80211_FC0_SUBTYPE_ACK		0xd0
+#define	IEEE80211_FC0_SUBTYPE_CF_END		0xe0
+#define	IEEE80211_FC0_SUBTYPE_CF_END_ACK	0xf0
+/* for TYPE_DATA (bit combination) */
+#define IEEE80211_FC0_SUBTYPE_DATA		0x00
+#define	IEEE80211_FC0_SUBTYPE_CF_ACK		0x10
+#define	IEEE80211_FC0_SUBTYPE_CF_POLL		0x20
+#define	IEEE80211_FC0_SUBTYPE_CF_ACPL		0x30
+#define	IEEE80211_FC0_SUBTYPE_NODATA		0x40
+#define	IEEE80211_FC0_SUBTYPE_CFACK		0x50
+#define	IEEE80211_FC0_SUBTYPE_CFPOLL		0x60
+#define	IEEE80211_FC0_SUBTYPE_CF_ACK_CF_ACK	0x70
+
+#define	IEEE80211_FC1_DIR_MASK			0x03
+#define	IEEE80211_FC1_DIR_NODS			0x00	/* STA->STA */
+#define	IEEE80211_FC1_DIR_TODS			0x01	/* STA->AP  */
+#define	IEEE80211_FC1_DIR_FROMDS		0x02	/* AP ->STA */
+#define	IEEE80211_FC1_DIR_DSTODS		0x03	/* AP ->AP  */
+
+#define	IEEE80211_FC1_MORE_FRAG			0x04
+#define	IEEE80211_FC1_RETRY			0x08
+#define	IEEE80211_FC1_PWR_MGT			0x10
+#define	IEEE80211_FC1_MORE_DATA			0x20
+#define	IEEE80211_FC1_WEP			0x40
+#define	IEEE80211_FC1_ORDER			0x80
+
+#define	IEEE80211_NWID_LEN			32
+
+/*
+ * BEACON management packets
+ *
+ *	octect timestamp[8]
+ *	octect beacon interval[2]
+ *	octect capability information[2]
+ *	information element
+ *		octect elemid
+ *		octect length
+ *		octect information[length[
+ */
+typedef u_int8_t *	ieee80211_mgt_beacon_t;
+
+#define IEEE80211_BEACON_INTERVAL(beacon) \
+	(beacon[8] + (beacon[9] << 8))
+#define IEEE80211_BEACON_CAPABILITY(beacon) \
+	(beacon[10] + (beacon[11] << 8))
+
+#define	IEEE80211_CAPINFO_ESS			0x01
+#define	IEEE80211_CAPINFO_IBSS			0x02
+#define	IEEE80211_CAPINFO_CF_POLLABLE		0x04
+#define	IEEE80211_CAPINFO_CF_POLLREQ		0x08
+#define	IEEE80211_CAPINFO_PRIVACY		0x10
+#define	IEEE80211_CAPINFO_BITS	"\20\01ESS\02IBSS\03POLLABLE\04POLLREQ\5PRIVACY"
+
+/*
+ * Management information elements
+ */
+struct ieee80211_information {
+	char	ssid[IEEE80211_NWID_LEN+1];
+	struct rates {
+		u_int8_t 	*p;
+	} rates;
+	struct fh {
+		u_int16_t 	dwell;
+		u_int8_t 	set;
+		u_int8_t 	pattern;
+		u_int8_t 	index;
+	} fh;
+	struct ds {
+		u_int8_t	channel;
+	} ds;
+	struct cf {
+		u_int8_t	count;
+		u_int8_t	period;
+		u_int8_t	maxdur[2];
+		u_int8_t	dur[2];
+	} cf;
+	struct tim {
+		u_int8_t 	count;
+		u_int8_t 	period;
+		u_int8_t 	bitctl;
+		/* u_int8_t 	pvt[251]; The driver never needs to use this */
+	} tim;
+	struct ibss {
+	    	u_int16_t	atim;
+	} ibss;
+	struct challenge {
+		u_int8_t 	*p;
+		u_int8_t	len;
+	} challenge;
+};
+
+#define	IEEE80211_ELEMID_SSID			0
+#define	IEEE80211_ELEMID_RATES			1
+#define	IEEE80211_ELEMID_FHPARMS		2
+#define	IEEE80211_ELEMID_DSPARMS		3
+#define	IEEE80211_ELEMID_CFPARMS		4
+#define	IEEE80211_ELEMID_TIM			5
+#define	IEEE80211_ELEMID_IBSSPARMS		6
+#define	IEEE80211_ELEMID_CHALLENGE		16
+
+/*
+ * AUTH management packets
+ *
+ *	octect algo[2]
+ *	octect seq[2]
+ *	octect status[2]
+ *	octect chal.id
+ *	octect chal.length
+ *	octect chal.text[253]
+ */
+typedef u_int8_t *	ieee80211_mgt_auth_t;
+
+#define IEEE80211_AUTH_ALGORITHM(auth) \
+    (auth[0] + (auth[1] << 8))
+#define IEEE80211_AUTH_TRANSACTION(auth) \
+    (auth[2] + (auth[3] << 8))
+#define IEEE80211_AUTH_STATUS(auth) \
+    (auth[4] + (auth[5] << 8))
+
+#define	IEEE80211_AUTH_ALG_OPEN			0x0000
+#define	IEEE80211_AUTH_ALG_SHARED		0x0001
+
+#define IEEE80211_AUTH_OPEN_REQUEST		1
+#define IEEE80211_AUTH_OPEN_RESPONSE		2
+
+#define IEEE80211_AUTH_SHARED_REQUEST		1
+#define IEEE80211_AUTH_SHARED_CHALLENGE		2
+#define IEEE80211_AUTH_SHARED_RESPONSE		3
+#define IEEE80211_AUTH_SHARED_PASS		4
+
+/*
+ * Reason codes
+ *
+ * Unlisted codes are reserved
+ */
+#define	IEEE80211_REASON_UNSPECIFIED		1
+#define	IEEE80211_REASON_AUTH_EXPIRE		2
+#define	IEEE80211_REASON_AUTH_LEAVE		3
+#define	IEEE80211_REASON_ASSOC_EXPIRE		4
+#define	IEEE80211_REASON_ASSOC_TOOMANY		5
+#define	IEEE80211_REASON_NOT_AUTHED		6  
+#define	IEEE80211_REASON_NOT_ASSOCED		7
+#define	IEEE80211_REASON_ASSOC_LEAVE		8
+#define	IEEE80211_REASON_ASSOC_NOT_AUTHED	9
+
+/*
+ * Status code
+ *
+ * Unlisted codes are reserved
+ */
+#define IEEE80211_STATUS_SUCCESS		0x0000
+#define	IEEE80211_STATUS_UNSPECIFIED		1
+#define	IEEE80211_STATUS_CAPINFO		10
+#define	IEEE80211_STATUS_NOT_ASSOCED		11
+#define	IEEE80211_STATUS_OTHER			12
+#define	IEEE80211_STATUS_ALG			13
+#define	IEEE80211_STATUS_SEQUENCE		14
+#define	IEEE80211_STATUS_CHALLENGE		15
+#define	IEEE80211_STATUS_TIMEOUT		16
+#define	IEEE80211_STATUS_TOO_MANY_STATIONS	17
+#define	IEEE80211_STATUS_RATES			18
+
+#define	IEEE80211_WEP_KEYLEN			5	/* 40bit */
+#define	IEEE80211_WEP_IVLEN			3	/* 24bit */
+#define	IEEE80211_WEP_KIDLEN			1	/* 1 octet */
+#define	IEEE80211_WEP_CRCLEN			4	/* CRC-32 */
+#define	IEEE80211_WEP_NKID			4	/* number of key ids */
+
+/* nwid is pointed at by ifr.ifr_data */
+struct ieee80211_nwid {
+	u_int8_t	i_len;
+	u_int8_t	i_nwid[IEEE80211_NWID_LEN];
+};
+
+#define	SIOCS80211NWID		_IOWR('i', 230, struct ifreq)
+#define	SIOCG80211NWID		_IOWR('i', 231, struct ifreq)
+
+/* the first member must be matched with struct ifreq */
+struct ieee80211_nwkey {
+	char		i_name[IFNAMSIZ];	/* if_name, e.g. "wi0" */
+	int		i_wepon;		/* wep enabled flag */
+	int		i_defkid;		/* default encrypt key id */
+	struct {
+		int		i_keylen;
+		u_int8_t	*i_keydat;
+	}		i_key[IEEE80211_WEP_NKID];
+};
+#define	SIOCS80211NWKEY		 _IOW('i', 232, struct ieee80211_nwkey)
+#define	SIOCG80211NWKEY		_IOWR('i', 233, struct ieee80211_nwkey)
+
+#define IEEE80211_WEP_NOSUP	-1
+#define IEEE80211_WEP_OFF	0
+#define IEEE80211_WEP_ON	1
+#define IEEE80211_WEP_MIXED	2
+
+#define IEEE80211_AUTH_NONE	0
+#define IEEE80211_AUTH_OPEN	1
+#define IEEE80211_AUTH_SHARED	2
+
+#define IEEE80211_POWERSAVE_NOSUP	-1
+#define IEEE80211_POWERSAVE_OFF		0
+#define IEEE80211_POWERSAVE_CAM		1
+#define IEEE80211_POWERSAVE_PSP		2
+#define IEEE80211_POWERSAVE_PSP_CAM	3
+#define IEEE80211_POWERSAVE_ON		IEEE80211_POWERSAVE_CAM
+
+/* the first member must be matched with struct ifreq */
+struct ieee80211req {
+	char		i_name[IFNAMSIZ];	/* if_name, e.g. "wi0" */
+	u_int16_t	i_type;			/* req type */
+	int16_t		i_val;			/* Index or simple value */
+	int16_t		i_len;			/* Index or simple value */
+	void		*i_data;		/* Extra data */
+};
+#define	SIOCS80211		 _IOW('i', 234, struct ieee80211req)
+#define	SIOCG80211		_IOWR('i', 235, struct ieee80211req)
+
+#define IEEE80211_IOC_SSID		1
+#define IEEE80211_IOC_NUMSSIDS		2
+#define IEEE80211_IOC_WEP		3
+#define IEEE80211_IOC_WEPKEY		4
+#define IEEE80211_IOC_NUMWEPKEYS	5
+#define IEEE80211_IOC_WEPTXKEY		6
+#define IEEE80211_IOC_AUTHMODE		7
+#define IEEE80211_IOC_STATIONNAME	8
+#define IEEE80211_IOC_CHANNEL		9
+#define IEEE80211_IOC_POWERSAVE		10
+#define IEEE80211_IOC_POWERSAVESLEEP	11
+
+#endif /* !_NET_IF_IEEE80211_H_ */
diff --git a/sys/dev/owi/if_owi.c b/sys/dev/owi/if_owi.c
new file mode 100644
index 0000000..3092a61
--- /dev/null
+++ b/sys/dev/owi/if_owi.c
@@ -0,0 +1,2421 @@
+/*
+ * Copyright (c) 1997, 1998, 1999
+ *	Bill Paul <wpaul@ctr.columbia.edu>.  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 OR THE VOICES IN HIS HEAD
+ * 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.
+ */
+
+/*
+ * Lucent WaveLAN/IEEE 802.11 PCMCIA driver for FreeBSD.
+ *
+ * Written by Bill Paul <wpaul@ctr.columbia.edu>
+ * Electrical Engineering Department
+ * Columbia University, New York City
+ */
+
+/*
+ * The WaveLAN/IEEE adapter is the second generation of the WaveLAN
+ * from Lucent. Unlike the older cards, the new ones are programmed
+ * entirely via a firmware-driven controller called the Hermes.
+ * Unfortunately, Lucent will not release the Hermes programming manual
+ * without an NDA (if at all). What they do release is an API library
+ * called the HCF (Hardware Control Functions) which is supposed to
+ * do the device-specific operations of a device driver for you. The
+ * publically available version of the HCF library (the 'HCF Light') is 
+ * a) extremely gross, b) lacks certain features, particularly support
+ * for 802.11 frames, and c) is contaminated by the GNU Public License.
+ *
+ * This driver does not use the HCF or HCF Light at all. Instead, it
+ * programs the Hermes controller directly, using information gleaned
+ * from the HCF Light code and corresponding documentation.
+ *
+ * This driver supports the ISA, PCMCIA and PCI versions of the Lucent
+ * WaveLan cards (based on the Hermes chipset), as well as the newer
+ * Prism 2 chipsets with firmware from Intersil and Symbol.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/endian.h>
+#include <sys/sockio.h>
+#include <sys/mbuf.h>
+#include <sys/proc.h>
+#include <sys/kernel.h>
+#include <sys/socket.h>
+#include <sys/module.h>
+#include <sys/bus.h>
+#include <sys/random.h>
+#include <sys/syslog.h>
+#include <sys/sysctl.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <machine/clock.h>
+#include <sys/rman.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/if_types.h>
+#include <dev/owi/if_ieee80211.h>
+
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/if_ether.h>
+
+#include <net/bpf.h>
+
+#include <dev/wi/if_wavelan_ieee.h>
+#include <dev/owi/if_wivar.h>
+#include <dev/owi/if_wireg.h>
+
+#if !defined(lint)
+static const char rcsid[] =
+  "$FreeBSD$";
+#endif
+
+static void wi_intr(void *);
+static void wi_reset(struct wi_softc *);
+static int wi_ioctl(struct ifnet *, u_long, caddr_t);
+static void wi_init(void *);
+static void wi_start(struct ifnet *);
+static void wi_watchdog(struct ifnet *);
+static void wi_rxeof(struct wi_softc *);
+static void wi_txeof(struct wi_softc *, int);
+static void wi_update_stats(struct wi_softc *);
+static void wi_setmulti(struct wi_softc *);
+
+static int wi_cmd(struct wi_softc *, int, int, int, int);
+static int wi_read_record(struct wi_softc *, struct wi_ltv_gen *);
+static int wi_write_record(struct wi_softc *, struct wi_ltv_gen *);
+static int wi_read_data(struct wi_softc *, int, int, caddr_t, int);
+static int wi_write_data(struct wi_softc *, int, int, caddr_t, int);
+static int wi_seek(struct wi_softc *, int, int, int);
+static int wi_alloc_nicmem(struct wi_softc *, int, int *);
+static void wi_inquire(void *);
+static void wi_setdef(struct wi_softc *, struct wi_req *);
+
+#ifdef WICACHE
+static
+void wi_cache_store(struct wi_softc *, struct ether_header *,
+	struct mbuf *, unsigned short);
+#endif
+
+static int wi_get_cur_ssid(struct wi_softc *, char *, int *);
+static int wi_media_change(struct ifnet *);
+static void wi_media_status(struct ifnet *, struct ifmediareq *);
+
+devclass_t owi_devclass;
+
+struct wi_card_ident wi_card_ident[] = {
+	/* CARD_ID			CARD_NAME		FIRM_TYPE */
+	{ WI_NIC_LUCENT_ID,		WI_NIC_LUCENT_STR,	WI_LUCENT },
+	{ WI_NIC_SONY_ID,		WI_NIC_SONY_STR,	WI_LUCENT },
+	{ WI_NIC_LUCENT_EMB_ID,		WI_NIC_LUCENT_EMB_STR,	WI_LUCENT },
+	{ 0,	NULL,	0 },
+};
+
+int
+owi_generic_detach(dev)
+	device_t		dev;
+{
+	struct wi_softc		*sc;
+	struct ifnet		*ifp;
+	int			s;
+
+	sc = device_get_softc(dev);
+	WI_LOCK(sc, s);
+	ifp = &sc->arpcom.ac_if;
+
+	if (sc->wi_gone) {
+		device_printf(dev, "already unloaded\n");
+		WI_UNLOCK(sc, s);
+		return(ENODEV);
+	}
+	sc->wi_gone = !bus_child_present(dev);
+
+	owi_stop(sc);
+
+	/* Delete all remaining media. */
+	ifmedia_removeall(&sc->ifmedia);
+
+	ether_ifdetach(ifp);
+	bus_teardown_intr(dev, sc->irq, sc->wi_intrhand);
+	owi_free(dev);
+	sc->wi_gone = 1;
+
+	WI_UNLOCK(sc, s);
+	mtx_destroy(&sc->wi_mtx);
+
+	return(0);
+}
+
+int
+owi_generic_attach(device_t dev)
+{
+	struct wi_softc		*sc;
+	struct wi_ltv_macaddr	mac;
+	struct wi_ltv_gen	gen;
+	struct ifnet		*ifp;
+	int			error;
+	int			s;
+
+	/* XXX maybe we need the splimp stuff here XXX */
+	sc = device_get_softc(dev);
+	ifp = &sc->arpcom.ac_if;
+
+	error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET,
+	    wi_intr, sc, &sc->wi_intrhand);
+
+	if (error) {
+		device_printf(dev, "bus_setup_intr() failed! (%d)\n", error);
+		owi_free(dev);
+		return (error);
+	}
+
+	mtx_init(&sc->wi_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
+	    MTX_DEF | MTX_RECURSE);
+	WI_LOCK(sc, s);
+
+	/* Reset the NIC. */
+	wi_reset(sc);
+
+	/*
+	 * Read the station address.
+	 * And do it twice. I've seen PRISM-based cards that return
+	 * an error when trying to read it the first time, which causes
+	 * the probe to fail.
+	 */
+	mac.wi_type = WI_RID_MAC_NODE;
+	mac.wi_len = 4;
+	wi_read_record(sc, (struct wi_ltv_gen *)&mac);
+	if ((error = wi_read_record(sc, (struct wi_ltv_gen *)&mac)) != 0) {
+		device_printf(dev, "mac read failed %d\n", error);
+		owi_free(dev);
+		return (error);
+	}
+	bcopy((char *)&mac.wi_mac_addr,
+	   (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
+
+	device_printf(dev, "802.11 address: %6D\n", sc->arpcom.ac_enaddr, ":");
+
+	owi_get_id(sc);
+
+	ifp->if_softc = sc;
+	ifp->if_unit = sc->wi_unit;
+	ifp->if_name = "owi";
+	ifp->if_mtu = ETHERMTU;
+	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
+	ifp->if_ioctl = wi_ioctl;
+	ifp->if_output = ether_output;
+	ifp->if_start = wi_start;
+	ifp->if_watchdog = wi_watchdog;
+	ifp->if_init = wi_init;
+	ifp->if_baudrate = 10000000;
+	ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
+
+	bzero(sc->wi_node_name, sizeof(sc->wi_node_name));
+	bcopy(WI_DEFAULT_NODENAME, sc->wi_node_name,
+	    sizeof(WI_DEFAULT_NODENAME) - 1);
+
+	bzero(sc->wi_net_name, sizeof(sc->wi_net_name));
+	bcopy(WI_DEFAULT_NETNAME, sc->wi_net_name,
+	    sizeof(WI_DEFAULT_NETNAME) - 1);
+
+	bzero(sc->wi_ibss_name, sizeof(sc->wi_ibss_name));
+	bcopy(WI_DEFAULT_IBSS, sc->wi_ibss_name,
+	    sizeof(WI_DEFAULT_IBSS) - 1);
+
+	sc->wi_portnum = WI_DEFAULT_PORT;
+	sc->wi_ptype = WI_PORTTYPE_BSS;
+	sc->wi_ap_density = WI_DEFAULT_AP_DENSITY;
+	sc->wi_rts_thresh = WI_DEFAULT_RTS_THRESH;
+	sc->wi_tx_rate = WI_DEFAULT_TX_RATE;
+	sc->wi_max_data_len = WI_DEFAULT_DATALEN;
+	sc->wi_create_ibss = WI_DEFAULT_CREATE_IBSS;
+	sc->wi_pm_enabled = WI_DEFAULT_PM_ENABLED;
+	sc->wi_max_sleep = WI_DEFAULT_MAX_SLEEP;
+	sc->wi_roaming = WI_DEFAULT_ROAMING;
+	sc->wi_authtype = WI_DEFAULT_AUTHTYPE;
+	sc->wi_authmode = IEEE80211_AUTH_OPEN;
+
+	/*
+	 * Read the default channel from the NIC. This may vary
+	 * depending on the country where the NIC was purchased, so
+	 * we can't hard-code a default and expect it to work for
+	 * everyone.
+	 */
+	gen.wi_type = WI_RID_OWN_CHNL;
+	gen.wi_len = 2;
+	wi_read_record(sc, &gen);
+	sc->wi_channel = gen.wi_val;
+
+	/*
+	 * Set flags based on firmware version.
+	 */
+	switch (sc->sc_firmware_type) {
+	case WI_LUCENT:
+		sc->wi_flags |= WI_FLAGS_HAS_ROAMING;
+		if (sc->sc_sta_firmware_ver >= 60000)
+			sc->wi_flags |= WI_FLAGS_HAS_MOR;
+		if (sc->sc_sta_firmware_ver >= 60006) {
+			sc->wi_flags |= WI_FLAGS_HAS_IBSS;
+			sc->wi_flags |= WI_FLAGS_HAS_CREATE_IBSS;
+		}
+		sc->wi_ibss_port = htole16(1);
+		break;
+	}
+
+	/*
+	 * Find out if we support WEP on this card.
+	 */
+	gen.wi_type = WI_RID_WEP_AVAIL;
+	gen.wi_len = 2;
+	wi_read_record(sc, &gen);
+	sc->wi_has_wep = gen.wi_val;
+
+	if (bootverbose)
+		device_printf(sc->dev, "owi_has_wep = %d\n", sc->wi_has_wep);
+
+	/* 
+	 * Find supported rates.
+	 */
+	gen.wi_type = WI_RID_DATA_RATES;
+	gen.wi_len = 2;
+	if (wi_read_record(sc, &gen))
+		sc->wi_supprates = WI_SUPPRATES_1M | WI_SUPPRATES_2M |
+		    WI_SUPPRATES_5M | WI_SUPPRATES_11M;
+	else
+		sc->wi_supprates = gen.wi_val;
+
+	bzero((char *)&sc->wi_stats, sizeof(sc->wi_stats));
+
+	wi_init(sc);
+	owi_stop(sc);
+
+	ifmedia_init(&sc->ifmedia, 0, wi_media_change, wi_media_status);
+#define ADD(m, c)       ifmedia_add(&sc->ifmedia, (m), (c), NULL)
+	if (sc->wi_supprates & WI_SUPPRATES_1M) {
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1, 0, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
+		    IFM_IEEE80211_ADHOC, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
+			    IFM_IEEE80211_IBSS, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
+			    IFM_IEEE80211_IBSSMASTER, 0), 0);
+	}
+	if (sc->wi_supprates & WI_SUPPRATES_2M) {
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2, 0, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
+		    IFM_IEEE80211_ADHOC, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
+			    IFM_IEEE80211_IBSS, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
+			    IFM_IEEE80211_IBSSMASTER, 0), 0);
+	}
+	if (sc->wi_supprates & WI_SUPPRATES_5M) {
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5, 0, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
+		    IFM_IEEE80211_ADHOC, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
+			    IFM_IEEE80211_IBSS, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
+			    IFM_IEEE80211_IBSSMASTER, 0), 0);
+	}
+	if (sc->wi_supprates & WI_SUPPRATES_11M) {
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11, 0, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
+		    IFM_IEEE80211_ADHOC, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
+			    IFM_IEEE80211_IBSS, 0), 0);
+		if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
+			ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
+			    IFM_IEEE80211_IBSSMASTER, 0), 0);
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_MANUAL, 0, 0), 0);
+	}
+	ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, IFM_IEEE80211_ADHOC, 0), 0);
+	if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, IFM_IEEE80211_IBSS,
+		    0), 0);
+	if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
+		ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO,
+		    IFM_IEEE80211_IBSSMASTER, 0), 0);
+	ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 0, 0), 0);
+#undef ADD
+	ifmedia_set(&sc->ifmedia, IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 0, 0));
+
+	/*
+	 * Call MI attach routine.
+	 */
+	ether_ifattach(ifp, sc->arpcom.ac_enaddr);
+	callout_handle_init(&sc->wi_stat_ch);
+	WI_UNLOCK(sc, s);
+
+	return(0);
+}
+
+void
+owi_get_id(sc)
+	struct wi_softc *sc;
+{
+	struct wi_ltv_ver       ver;
+	struct wi_card_ident	*id;
+
+	/* getting chip identity */
+	memset(&ver, 0, sizeof(ver));
+	ver.wi_type = WI_RID_CARD_ID;
+	ver.wi_len = 5;
+	wi_read_record(sc, (struct wi_ltv_gen *)&ver);
+	device_printf(sc->dev, "using ");
+	sc->sc_firmware_type = WI_NOTYPE;
+	for (id = wi_card_ident; id->card_name != NULL; id++) {
+		if (le16toh(ver.wi_ver[0]) == id->card_id) {
+			printf("%s", id->card_name);
+			sc->sc_firmware_type = id->firm_type;
+			break;
+		}
+	}
+	if (sc->sc_firmware_type == WI_NOTYPE) {
+		if ((le16toh(ver.wi_ver[0]) & 0x8000) == 0) {
+			printf("Unknown Lucent chip");
+			sc->sc_firmware_type = WI_LUCENT;
+		}
+	}
+
+	if (sc->sc_firmware_type != WI_LUCENT)
+		return;
+
+	/* get station firmware version */
+	memset(&ver, 0, sizeof(ver));
+	ver.wi_type = WI_RID_STA_IDENTITY;
+	ver.wi_len = 5;
+	wi_read_record(sc, (struct wi_ltv_gen *)&ver);
+	ver.wi_ver[1] = le16toh(ver.wi_ver[1]);
+	ver.wi_ver[2] = le16toh(ver.wi_ver[2]);
+	ver.wi_ver[3] = le16toh(ver.wi_ver[3]);
+	sc->sc_sta_firmware_ver = ver.wi_ver[2] * 10000 +
+	    ver.wi_ver[3] * 100 + ver.wi_ver[1];
+	printf("\n");
+	device_printf(sc->dev, "Lucent Firmware: ");
+
+	printf("Station %u.%02u.%02u\n",
+	    sc->sc_sta_firmware_ver / 10000, (sc->sc_sta_firmware_ver % 10000) / 100,
+	    sc->sc_sta_firmware_ver % 100);
+	return;
+}
+
+static void
+wi_rxeof(sc)
+	struct wi_softc		*sc;
+{
+	struct ifnet		*ifp;
+	struct ether_header	*eh;
+	struct mbuf		*m;
+	int			id;
+
+	ifp = &sc->arpcom.ac_if;
+
+	id = CSR_READ_2(sc, WI_RX_FID);
+
+	/*
+	 * if we have the procframe flag set, disregard all this and just
+	 * read the data from the device.
+	 */
+	if (sc->wi_procframe || sc->wi_debug.wi_monitor) {
+		struct wi_frame		*rx_frame;
+		int			datlen, hdrlen;
+
+		/* first allocate mbuf for packet storage */
+		MGETHDR(m, M_DONTWAIT, MT_DATA);
+		if (m == NULL) {
+			ifp->if_ierrors++;
+			return;
+		}
+		MCLGET(m, M_DONTWAIT);
+		if (!(m->m_flags & M_EXT)) {
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		m->m_pkthdr.rcvif = ifp;
+
+		/* now read wi_frame first so we know how much data to read */
+		if (wi_read_data(sc, id, 0, mtod(m, caddr_t),
+		    sizeof(struct wi_frame))) {
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		rx_frame = mtod(m, struct wi_frame *);
+
+		switch ((rx_frame->wi_status & WI_STAT_MAC_PORT) >> 8) {
+		case 7:
+			switch (rx_frame->wi_frame_ctl & WI_FCTL_FTYPE) {
+			case WI_FTYPE_DATA:
+				hdrlen = WI_DATA_HDRLEN;
+				datlen = rx_frame->wi_dat_len + WI_FCS_LEN;
+				break;
+			case WI_FTYPE_MGMT:
+				hdrlen = WI_MGMT_HDRLEN;
+				datlen = rx_frame->wi_dat_len + WI_FCS_LEN;
+				break;
+			case WI_FTYPE_CTL:
+				/*
+				 * prism2 cards don't pass control packets
+				 * down properly or consistently, so we'll only
+				 * pass down the header.
+				 */
+				hdrlen = WI_CTL_HDRLEN;
+				datlen = 0;
+				break;
+			default:
+				device_printf(sc->dev, "received packet of "
+				    "unknown type on port 7\n");
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+			break;
+		case 0:
+			hdrlen = WI_DATA_HDRLEN;
+			datlen = rx_frame->wi_dat_len + WI_FCS_LEN;
+			break;
+		default:
+			device_printf(sc->dev, "received packet on invalid "
+			    "port (wi_status=0x%x)\n", rx_frame->wi_status);
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		if ((hdrlen + datlen + 2) > MCLBYTES) {
+			device_printf(sc->dev, "oversized packet received "
+			    "(wi_dat_len=%d, wi_status=0x%x)\n",
+			    datlen, rx_frame->wi_status);
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		if (wi_read_data(sc, id, hdrlen, mtod(m, caddr_t) + hdrlen,
+		    datlen + 2)) {
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		m->m_pkthdr.len = m->m_len = hdrlen + datlen;
+
+		ifp->if_ipackets++;
+
+		/* Handle BPF listeners. */
+		BPF_MTAP(ifp, m);
+
+		m_freem(m);
+	} else {
+		struct wi_frame		rx_frame;
+
+		/* First read in the frame header */
+		if (wi_read_data(sc, id, 0, (caddr_t)&rx_frame,
+		    sizeof(rx_frame))) {
+			ifp->if_ierrors++;
+			return;
+		}
+
+		if (rx_frame.wi_status & WI_STAT_ERRSTAT) {
+			ifp->if_ierrors++;
+			return;
+		}
+
+		MGETHDR(m, M_DONTWAIT, MT_DATA);
+		if (m == NULL) {
+			ifp->if_ierrors++;
+			return;
+		}
+		MCLGET(m, M_DONTWAIT);
+		if (!(m->m_flags & M_EXT)) {
+			m_freem(m);
+			ifp->if_ierrors++;
+			return;
+		}
+
+		eh = mtod(m, struct ether_header *);
+		m->m_pkthdr.rcvif = ifp;
+
+		if (rx_frame.wi_status == WI_STAT_1042 ||
+		    rx_frame.wi_status == WI_STAT_TUNNEL ||
+		    rx_frame.wi_status == WI_STAT_WMP_MSG) {
+			if((rx_frame.wi_dat_len + WI_SNAPHDR_LEN) > MCLBYTES) {
+				device_printf(sc->dev,
+				    "oversized packet received "
+				    "(wi_dat_len=%d, wi_status=0x%x)\n",
+				    rx_frame.wi_dat_len, rx_frame.wi_status);
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+			m->m_pkthdr.len = m->m_len =
+			    rx_frame.wi_dat_len + WI_SNAPHDR_LEN;
+
+#if 0
+			bcopy((char *)&rx_frame.wi_addr1,
+			    (char *)&eh->ether_dhost, ETHER_ADDR_LEN);
+			if (sc->wi_ptype == WI_PORTTYPE_ADHOC) {
+				bcopy((char *)&rx_frame.wi_addr2,
+				    (char *)&eh->ether_shost, ETHER_ADDR_LEN);
+			} else {
+				bcopy((char *)&rx_frame.wi_addr3,
+				    (char *)&eh->ether_shost, ETHER_ADDR_LEN);
+			}
+#else
+			bcopy((char *)&rx_frame.wi_dst_addr,
+				(char *)&eh->ether_dhost, ETHER_ADDR_LEN);
+			bcopy((char *)&rx_frame.wi_src_addr,
+				(char *)&eh->ether_shost, ETHER_ADDR_LEN);
+#endif
+
+			bcopy((char *)&rx_frame.wi_type,
+			    (char *)&eh->ether_type, ETHER_TYPE_LEN);
+
+			if (wi_read_data(sc, id, WI_802_11_OFFSET,
+			    mtod(m, caddr_t) + sizeof(struct ether_header),
+			    m->m_len + 2)) {
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+		} else {
+			if((rx_frame.wi_dat_len +
+			    sizeof(struct ether_header)) > MCLBYTES) {
+				device_printf(sc->dev,
+				    "oversized packet received "
+				    "(wi_dat_len=%d, wi_status=0x%x)\n",
+				    rx_frame.wi_dat_len, rx_frame.wi_status);
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+			m->m_pkthdr.len = m->m_len =
+			    rx_frame.wi_dat_len + sizeof(struct ether_header);
+
+			if (wi_read_data(sc, id, WI_802_3_OFFSET,
+			    mtod(m, caddr_t), m->m_len + 2)) {
+				m_freem(m);
+				ifp->if_ierrors++;
+				return;
+			}
+		}
+
+		ifp->if_ipackets++;
+
+		/* Receive packet. */
+#ifdef WICACHE
+		wi_cache_store(sc, eh, m, rx_frame.wi_q_info);
+#endif  
+		(*ifp->if_input)(ifp, m);
+	}
+}
+
+static void
+wi_txeof(sc, status)
+	struct wi_softc		*sc;
+	int			status;
+{
+	struct ifnet		*ifp;
+
+	ifp = &sc->arpcom.ac_if;
+
+	ifp->if_timer = 0;
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+	if (status & WI_EV_TX_EXC)
+		ifp->if_oerrors++;
+	else
+		ifp->if_opackets++;
+
+	return;
+}
+
+static void
+wi_inquire(xsc)
+	void			*xsc;
+{
+	struct wi_softc		*sc;
+	struct ifnet		*ifp;
+	int			s;
+
+	sc = xsc;
+	ifp = &sc->arpcom.ac_if;
+
+	sc->wi_stat_ch = timeout(wi_inquire, sc, hz * 60);
+
+	/* Don't do this while we're transmitting */
+	if (ifp->if_flags & IFF_OACTIVE)
+		return;
+
+	WI_LOCK(sc, s);
+	wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_COUNTERS, 0, 0);
+	WI_UNLOCK(sc, s);
+
+	return;
+}
+
+static void
+wi_update_stats(sc)
+	struct wi_softc		*sc;
+{
+	struct wi_ltv_gen	gen;
+	u_int16_t		id;
+	struct ifnet		*ifp;
+	u_int32_t		*ptr;
+	int			len, i;
+	u_int16_t		t;
+
+	ifp = &sc->arpcom.ac_if;
+
+	id = CSR_READ_2(sc, WI_INFO_FID);
+
+	wi_read_data(sc, id, 0, (char *)&gen, 4);
+
+	/*
+	 * if we just got our scan results, copy it over into the scan buffer
+	 * so we can return it to anyone that asks for it. (add a little
+	 * compatibility with the prism2 scanning mechanism)
+	 */
+	if (gen.wi_type == WI_INFO_SCAN_RESULTS)
+	{
+		sc->wi_scanbuf_len = gen.wi_len;
+		wi_read_data(sc, id, 4, (char *)sc->wi_scanbuf,
+		    sc->wi_scanbuf_len * 2);
+
+		return;
+	}
+	else if (gen.wi_type != WI_INFO_COUNTERS)
+		return;
+
+	len = (gen.wi_len - 1 < sizeof(sc->wi_stats) / 4) ?
+		gen.wi_len - 1 : sizeof(sc->wi_stats) / 4;
+	ptr = (u_int32_t *)&sc->wi_stats;
+
+	for (i = 0; i < len - 1; i++) {
+		t = CSR_READ_2(sc, WI_DATA1);
+#ifdef WI_HERMES_STATS_WAR
+		if (t > 0xF000)
+			t = ~t & 0xFFFF;
+#endif
+		ptr[i] += t;
+	}
+
+	ifp->if_collisions = sc->wi_stats.wi_tx_single_retries +
+	    sc->wi_stats.wi_tx_multi_retries +
+	    sc->wi_stats.wi_tx_retry_limit;
+
+	return;
+}
+
+static void
+wi_intr(xsc)
+	void		*xsc;
+{
+	struct wi_softc		*sc = xsc;
+	struct ifnet		*ifp;
+	u_int16_t		status;
+	int			s;
+
+	WI_LOCK(sc, s);
+
+	ifp = &sc->arpcom.ac_if;
+
+	if (sc->wi_gone || !(ifp->if_flags & IFF_UP)) {
+		CSR_WRITE_2(sc, WI_EVENT_ACK, 0xFFFF);
+		CSR_WRITE_2(sc, WI_INT_EN, 0);
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	/* Disable interrupts. */
+	CSR_WRITE_2(sc, WI_INT_EN, 0);
+
+	status = CSR_READ_2(sc, WI_EVENT_STAT);
+	CSR_WRITE_2(sc, WI_EVENT_ACK, ~WI_INTRS);
+
+	if (status & WI_EV_RX) {
+		wi_rxeof(sc);
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX);
+	}
+
+	if (status & WI_EV_TX) {
+		wi_txeof(sc, status);
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX);
+	}
+
+	if (status & WI_EV_ALLOC) {
+		int			id;
+
+		id = CSR_READ_2(sc, WI_ALLOC_FID);
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC);
+		if (id == sc->wi_tx_data_id)
+			wi_txeof(sc, status);
+	}
+
+	if (status & WI_EV_INFO) {
+		wi_update_stats(sc);
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO);
+	}
+
+	if (status & WI_EV_TX_EXC) {
+		wi_txeof(sc, status);
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX_EXC);
+	}
+
+	if (status & WI_EV_INFO_DROP) {
+		CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO_DROP);
+	}
+
+	/* Re-enable interrupts. */
+	CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS);
+
+	if (ifp->if_snd.ifq_head != NULL) {
+		wi_start(ifp);
+	}
+
+	WI_UNLOCK(sc, s);
+
+	return;
+}
+
+static int
+wi_cmd(sc, cmd, val0, val1, val2)
+	struct wi_softc		*sc;
+	int			cmd;
+	int			val0;
+	int			val1;
+	int			val2;
+{
+	int			i, s = 0;
+	static volatile int count  = 0;
+	
+	if (count > 1)
+		panic("Hey partner, hold on there!");
+	count++;
+
+	/* wait for the busy bit to clear */
+	for (i = 500; i > 0; i--) {	/* 5s */
+		if (!(CSR_READ_2(sc, WI_COMMAND) & WI_CMD_BUSY)) {
+			break;
+		}
+		DELAY(10*1000);	/* 10 m sec */
+	}
+	if (i == 0) {
+		device_printf(sc->dev, "owi_cmd: busy bit won't clear.\n" );
+		count--;
+		return(ETIMEDOUT);
+	}
+
+	CSR_WRITE_2(sc, WI_PARAM0, val0);
+	CSR_WRITE_2(sc, WI_PARAM1, val1);
+	CSR_WRITE_2(sc, WI_PARAM2, val2);
+	CSR_WRITE_2(sc, WI_COMMAND, cmd);
+
+	for (i = 0; i < WI_TIMEOUT; i++) {
+		/*
+		 * Wait for 'command complete' bit to be
+		 * set in the event status register.
+		 */
+		s = CSR_READ_2(sc, WI_EVENT_STAT);
+		if (s & WI_EV_CMD) {
+			/* Ack the event and read result code. */
+			s = CSR_READ_2(sc, WI_STATUS);
+			CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_CMD);
+#ifdef foo
+			if ((s & WI_CMD_CODE_MASK) != (cmd & WI_CMD_CODE_MASK))
+				return(EIO);
+#endif
+			if (s & WI_STAT_CMD_RESULT) {
+				count--;
+				return(EIO);
+			}
+			break;
+		}
+		DELAY(WI_DELAY);
+	}
+
+	count--;
+	if (i == WI_TIMEOUT) {
+		device_printf(sc->dev,
+		    "timeout in wi_cmd 0x%04x; event status 0x%04x\n", cmd, s);
+		return(ETIMEDOUT);
+	}
+	return(0);
+}
+
+static void
+wi_reset(sc)
+	struct wi_softc		*sc;
+{
+#define WI_INIT_TRIES 3
+	int i;
+	int tries;
+	
+	tries = WI_INIT_TRIES;
+	for (i = 0; i < tries; i++) {
+		if (wi_cmd(sc, WI_CMD_INI, 0, 0, 0) == 0)
+			break;
+		DELAY(WI_DELAY * 1000);
+	}
+	sc->sc_enabled = 1;
+
+	if (i == tries) {
+		device_printf(sc->dev, "init failed\n");
+		return;
+	}
+
+	CSR_WRITE_2(sc, WI_INT_EN, 0);
+	CSR_WRITE_2(sc, WI_EVENT_ACK, 0xFFFF);
+
+	/* Calibrate timer. */
+	WI_SETVAL(WI_RID_TICK_TIME, 8);
+
+	return;
+}
+
+/*
+ * Read an LTV record from the NIC.
+ */
+static int
+wi_read_record(sc, ltv)
+	struct wi_softc		*sc;
+	struct wi_ltv_gen	*ltv;
+{
+	u_int16_t		*ptr;
+	int			i, len, code;
+	struct wi_ltv_gen	*oltv;
+
+	oltv = ltv;
+
+	/* Tell the NIC to enter record read mode. */
+	if (wi_cmd(sc, WI_CMD_ACCESS|WI_ACCESS_READ, ltv->wi_type, 0, 0))
+		return(EIO);
+
+	/* Seek to the record. */
+	if (wi_seek(sc, ltv->wi_type, 0, WI_BAP1))
+		return(EIO);
+
+	/*
+	 * Read the length and record type and make sure they
+	 * match what we expect (this verifies that we have enough
+	 * room to hold all of the returned data).
+	 */
+	len = CSR_READ_2(sc, WI_DATA1);
+	if (len > ltv->wi_len)
+		return(ENOSPC);
+	code = CSR_READ_2(sc, WI_DATA1);
+	if (code != ltv->wi_type)
+		return(EIO);
+
+	ltv->wi_len = len;
+	ltv->wi_type = code;
+
+	/* Now read the data. */
+	ptr = &ltv->wi_val;
+	for (i = 0; i < ltv->wi_len - 1; i++)
+		ptr[i] = CSR_READ_2(sc, WI_DATA1);
+
+	if (ltv->wi_type == WI_RID_PORTTYPE && sc->wi_ptype == WI_PORTTYPE_IBSS
+	    && ltv->wi_val == sc->wi_ibss_port) {
+		/*
+		 * Convert vendor IBSS port type to WI_PORTTYPE_IBSS.
+		 * Since Lucent uses port type 1 for BSS *and* IBSS we
+		 * have to rely on wi_ptype to distinguish this for us.
+		 */
+		ltv->wi_val = htole16(WI_PORTTYPE_IBSS);
+	}
+
+	return(0);
+}
+
+/*
+ * Same as read, except we inject data instead of reading it.
+ */
+static int
+wi_write_record(sc, ltv)
+	struct wi_softc		*sc;
+	struct wi_ltv_gen	*ltv;
+{
+	uint16_t		*ptr;
+	int			i;
+	struct wi_ltv_gen	p2ltv;
+
+	if (ltv->wi_type == WI_RID_PORTTYPE &&
+	    le16toh(ltv->wi_val) == WI_PORTTYPE_IBSS) {
+		/* Convert WI_PORTTYPE_IBSS to vendor IBSS port type. */
+		p2ltv.wi_type = WI_RID_PORTTYPE;
+		p2ltv.wi_len = 2;
+		p2ltv.wi_val = sc->wi_ibss_port;
+		ltv = &p2ltv;
+	} else {
+		/* LUCENT */
+		switch (ltv->wi_type) {  
+		case WI_RID_TX_RATE:
+			switch (ltv->wi_val) {
+			case 1: ltv->wi_val = 1; break;  /* 1Mb/s fixed */
+			case 2: ltv->wi_val = 2; break;  /* 2Mb/s fixed */
+			case 3: ltv->wi_val = 3; break;  /* 11Mb/s auto */
+			case 5: ltv->wi_val = 4; break;  /* 5.5Mb/s fixed */
+			case 6: ltv->wi_val = 6; break;  /* 2Mb/s auto */
+			case 7: ltv->wi_val = 7; break;  /* 5.5Mb/s auto */
+			case 11: ltv->wi_val = 5; break; /* 11Mb/s fixed */
+			default: return EINVAL;
+			}
+		case WI_RID_TX_CRYPT_KEY:
+			if (ltv->wi_val > WI_NLTV_KEYS)
+				return (EINVAL);
+			break;
+		}
+	}
+
+	if (wi_seek(sc, ltv->wi_type, 0, WI_BAP1))
+		return(EIO);
+
+	CSR_WRITE_2(sc, WI_DATA1, ltv->wi_len);
+	CSR_WRITE_2(sc, WI_DATA1, ltv->wi_type);
+
+	ptr = &ltv->wi_val;
+	for (i = 0; i < ltv->wi_len - 1; i++)
+		CSR_WRITE_2(sc, WI_DATA1, ptr[i]);
+
+	if (wi_cmd(sc, WI_CMD_ACCESS|WI_ACCESS_WRITE, ltv->wi_type, 0, 0))
+		return(EIO);
+
+	return(0);
+}
+
+static int
+wi_seek(sc, id, off, chan)
+	struct wi_softc		*sc;
+	int			id, off, chan;
+{
+	int			i;
+	int			selreg, offreg;
+	int			status;
+
+	switch (chan) {
+	case WI_BAP0:
+		selreg = WI_SEL0;
+		offreg = WI_OFF0;
+		break;
+	case WI_BAP1:
+		selreg = WI_SEL1;
+		offreg = WI_OFF1;
+		break;
+	default:
+		device_printf(sc->dev, "invalid data path: %x\n", chan);
+		return(EIO);
+	}
+
+	CSR_WRITE_2(sc, selreg, id);
+	CSR_WRITE_2(sc, offreg, off);
+
+	for (i = 0; i < WI_TIMEOUT; i++) {
+		status = CSR_READ_2(sc, offreg);
+		if (!(status & (WI_OFF_BUSY|WI_OFF_ERR)))
+			break;
+		DELAY(WI_DELAY);
+	}
+
+	if (i == WI_TIMEOUT) {
+		device_printf(sc->dev, "timeout in wi_seek to %x/%x; last status %x\n",
+			id, off, status);
+		return(ETIMEDOUT);
+	}
+
+	return(0);
+}
+
+static int
+wi_read_data(sc, id, off, buf, len)
+	struct wi_softc		*sc;
+	int			id, off;
+	caddr_t			buf;
+	int			len;
+{
+	int			i;
+	u_int16_t		*ptr;
+
+	if (wi_seek(sc, id, off, WI_BAP1))
+		return(EIO);
+
+	ptr = (u_int16_t *)buf;
+	for (i = 0; i < len / 2; i++)
+		ptr[i] = CSR_READ_2(sc, WI_DATA1);
+
+	return(0);
+}
+
+/*
+ * According to the comments in the HCF Light code, there is a bug in
+ * the Hermes (or possibly in certain Hermes firmware revisions) where
+ * the chip's internal autoincrement counter gets thrown off during
+ * data writes: the autoincrement is missed, causing one data word to
+ * be overwritten and subsequent words to be written to the wrong memory
+ * locations. The end result is that we could end up transmitting bogus
+ * frames without realizing it. The workaround for this is to write a
+ * couple of extra guard words after the end of the transfer, then
+ * attempt to read then back. If we fail to locate the guard words where
+ * we expect them, we preform the transfer over again.
+ */
+static int
+wi_write_data(sc, id, off, buf, len)
+	struct wi_softc		*sc;
+	int			id, off;
+	caddr_t			buf;
+	int			len;
+{
+	int			i;
+	u_int16_t		*ptr;
+#ifdef WI_HERMES_AUTOINC_WAR
+	int			retries;
+
+	retries = 512;
+again:
+#endif
+
+	if (wi_seek(sc, id, off, WI_BAP0))
+		return(EIO);
+
+	ptr = (u_int16_t *)buf;
+	for (i = 0; i < (len / 2); i++)
+		CSR_WRITE_2(sc, WI_DATA0, ptr[i]);
+
+#ifdef WI_HERMES_AUTOINC_WAR
+	CSR_WRITE_2(sc, WI_DATA0, 0x1234);
+	CSR_WRITE_2(sc, WI_DATA0, 0x5678);
+
+	if (wi_seek(sc, id, off + len, WI_BAP0))
+		return(EIO);
+
+	if (CSR_READ_2(sc, WI_DATA0) != 0x1234 ||
+	    CSR_READ_2(sc, WI_DATA0) != 0x5678) {
+		if (--retries >= 0)
+			goto again;
+		device_printf(sc->dev, "owi_write_data device timeout\n");
+		return (EIO);
+	}
+#endif
+
+	return(0);
+}
+
+/*
+ * Allocate a region of memory inside the NIC and zero
+ * it out.
+ */
+static int
+wi_alloc_nicmem(sc, len, id)
+	struct wi_softc		*sc;
+	int			len;
+	int			*id;
+{
+	int			i;
+
+	if (wi_cmd(sc, WI_CMD_ALLOC_MEM, len, 0, 0)) {
+		device_printf(sc->dev,
+		    "failed to allocate %d bytes on NIC\n", len);
+		return(ENOMEM);
+	}
+
+	for (i = 0; i < WI_TIMEOUT; i++) {
+		if (CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_ALLOC)
+			break;
+		DELAY(WI_DELAY);
+	}
+
+	if (i == WI_TIMEOUT) {
+		device_printf(sc->dev, "time out allocating memory on card\n");
+		return(ETIMEDOUT);
+	}
+
+	CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC);
+	*id = CSR_READ_2(sc, WI_ALLOC_FID);
+
+	if (wi_seek(sc, *id, 0, WI_BAP0)) {
+		device_printf(sc->dev, "seek failed while allocating memory on card\n");
+		return(EIO);
+	}
+
+	for (i = 0; i < len / 2; i++)
+		CSR_WRITE_2(sc, WI_DATA0, 0);
+
+	return(0);
+}
+
+static void
+wi_setmulti(sc)
+	struct wi_softc		*sc;
+{
+	struct ifnet		*ifp;
+	int			i = 0;
+	struct ifmultiaddr	*ifma;
+	struct wi_ltv_mcast	mcast;
+
+	ifp = &sc->arpcom.ac_if;
+
+	bzero((char *)&mcast, sizeof(mcast));
+
+	mcast.wi_type = WI_RID_MCAST_LIST;
+	mcast.wi_len = (3 * 16) + 1;
+
+	if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
+		wi_write_record(sc, (struct wi_ltv_gen *)&mcast);
+		return;
+	}
+
+	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
+		if (ifma->ifma_addr->sa_family != AF_LINK)
+			continue;
+		if (i < 16) {
+			bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
+			    (char *)&mcast.wi_mcast[i], ETHER_ADDR_LEN);
+			i++;
+		} else {
+			bzero((char *)&mcast, sizeof(mcast));
+			break;
+		}
+	}
+
+	mcast.wi_len = (i * 3) + 1;
+	wi_write_record(sc, (struct wi_ltv_gen *)&mcast);
+
+	return;
+}
+
+static void
+wi_setdef(sc, wreq)
+	struct wi_softc		*sc;
+	struct wi_req		*wreq;
+{
+	struct sockaddr_dl	*sdl;
+	struct ifaddr		*ifa;
+	struct ifnet		*ifp;
+
+	ifp = &sc->arpcom.ac_if;
+
+	switch(wreq->wi_type) {
+	case WI_RID_MAC_NODE:
+		ifa = ifaddr_byindex(ifp->if_index);
+		sdl = (struct sockaddr_dl *)ifa->ifa_addr;
+		bcopy((char *)&wreq->wi_val, (char *)&sc->arpcom.ac_enaddr,
+		   ETHER_ADDR_LEN);
+		bcopy((char *)&wreq->wi_val, LLADDR(sdl), ETHER_ADDR_LEN);
+		break;
+	case WI_RID_PORTTYPE:
+		sc->wi_ptype = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_TX_RATE:
+		sc->wi_tx_rate = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_MAX_DATALEN:
+		sc->wi_max_data_len = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_RTS_THRESH:
+		sc->wi_rts_thresh = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_SYSTEM_SCALE:
+		sc->wi_ap_density = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_CREATE_IBSS:
+		sc->wi_create_ibss = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_OWN_CHNL:
+		sc->wi_channel = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_NODENAME:
+		bzero(sc->wi_node_name, sizeof(sc->wi_node_name));
+		bcopy((char *)&wreq->wi_val[1], sc->wi_node_name, 30);
+		break;
+	case WI_RID_DESIRED_SSID:
+		bzero(sc->wi_net_name, sizeof(sc->wi_net_name));
+		bcopy((char *)&wreq->wi_val[1], sc->wi_net_name, 30);
+		break;
+	case WI_RID_OWN_SSID:
+		bzero(sc->wi_ibss_name, sizeof(sc->wi_ibss_name));
+		bcopy((char *)&wreq->wi_val[1], sc->wi_ibss_name, 30);
+		break;
+	case WI_RID_PM_ENABLED:
+		sc->wi_pm_enabled = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_MICROWAVE_OVEN:
+		sc->wi_mor_enabled = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_MAX_SLEEP:
+		sc->wi_max_sleep = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_CNFAUTHMODE:
+		sc->wi_authtype = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_ROAMING_MODE:
+		sc->wi_roaming = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_ENCRYPTION:
+		sc->wi_use_wep = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_TX_CRYPT_KEY:
+		sc->wi_tx_key = le16toh(wreq->wi_val[0]);
+		break;
+	case WI_RID_DEFLT_CRYPT_KEYS:
+		bcopy((char *)wreq, (char *)&sc->wi_keys,
+		    sizeof(struct wi_ltv_keys));
+		break;
+	default:
+		break;
+	}
+
+	/* Reinitialize WaveLAN. */
+	wi_init(sc);
+
+	return;
+}
+
+static int
+wi_ioctl(ifp, command, data)
+	struct ifnet		*ifp;
+	u_long			command;
+	caddr_t			data;
+{
+	int			error = 0;
+	int			len;
+	int			s;
+	uint16_t		mif;
+	uint16_t		val;
+	u_int8_t		tmpkey[14];
+	char			tmpssid[IEEE80211_NWID_LEN];
+	struct wi_softc		*sc;
+	struct wi_req		wreq;
+	struct ifreq		*ifr;
+	struct ieee80211req	*ireq;
+	struct thread		*td = curthread;
+
+	sc = ifp->if_softc;
+	WI_LOCK(sc, s);
+	ifr = (struct ifreq *)data;
+	ireq = (struct ieee80211req *)data;
+
+	if (sc->wi_gone) {
+		error = ENODEV;
+		goto out;
+	}
+
+	switch(command) {
+	case SIOCSIFFLAGS:
+		/*
+		 * Can't do promisc and hostap at the same time.  If all that's
+		 * changing is the promisc flag, try to short-circuit a call to
+		 * wi_init() by just setting PROMISC in the hardware.
+		 */
+		if (ifp->if_flags & IFF_UP) {
+			if (ifp->if_flags & IFF_RUNNING) {
+				if (ifp->if_flags & IFF_PROMISC &&
+				    !(sc->wi_if_flags & IFF_PROMISC)) {
+					WI_SETVAL(WI_RID_PROMISC, 1);
+				} else if (!(ifp->if_flags & IFF_PROMISC) &&
+				    sc->wi_if_flags & IFF_PROMISC) {
+					WI_SETVAL(WI_RID_PROMISC, 0);
+				} else {
+					wi_init(sc);
+				}
+			} else {
+				wi_init(sc);
+			}
+		} else {
+			if (ifp->if_flags & IFF_RUNNING) {
+				owi_stop(sc);
+			}
+		}
+		sc->wi_if_flags = ifp->if_flags;
+		error = 0;
+		break;
+	case SIOCSIFMEDIA:
+	case SIOCGIFMEDIA:
+		error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
+		break;
+	case SIOCADDMULTI:
+	case SIOCDELMULTI:
+		wi_setmulti(sc);
+		error = 0;
+		break;
+	case SIOCGWAVELAN:
+		error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
+		if (error)
+			break;
+		if (wreq.wi_len > WI_MAX_DATALEN) {
+			error = EINVAL;
+			break;
+		}
+		/* Don't show WEP keys to non-root users. */
+		if (wreq.wi_type == WI_RID_DEFLT_CRYPT_KEYS && suser(td))
+			break;
+		if (wreq.wi_type == WI_RID_IFACE_STATS) {
+			bcopy((char *)&sc->wi_stats, (char *)&wreq.wi_val,
+			    sizeof(sc->wi_stats));
+			wreq.wi_len = (sizeof(sc->wi_stats) / 2) + 1;
+		} else if (wreq.wi_type == WI_RID_DEFLT_CRYPT_KEYS) {
+			bcopy((char *)&sc->wi_keys, (char *)&wreq,
+			    sizeof(struct wi_ltv_keys));
+		}
+#ifdef WICACHE
+		else if (wreq.wi_type == WI_RID_ZERO_CACHE) {
+			error = suser(td);
+			if (error)
+				break;
+			sc->wi_sigitems = sc->wi_nextitem = 0;
+		} else if (wreq.wi_type == WI_RID_READ_CACHE) {
+			char *pt = (char *)&wreq.wi_val;
+			bcopy((char *)&sc->wi_sigitems,
+			    (char *)pt, sizeof(int));
+			pt += (sizeof (int));
+			wreq.wi_len = sizeof(int) / 2;
+			bcopy((char *)&sc->wi_sigcache, (char *)pt,
+			    sizeof(struct wi_sigcache) * sc->wi_sigitems);
+			wreq.wi_len += ((sizeof(struct wi_sigcache) *
+			    sc->wi_sigitems) / 2) + 1;
+		}
+#endif
+		else if (wreq.wi_type == WI_RID_PROCFRAME) {
+			wreq.wi_len = 2;
+			wreq.wi_val[0] = sc->wi_procframe;
+		} else if (wreq.wi_type == WI_RID_SCAN_RES) {
+			memcpy((char *)wreq.wi_val, (char *)sc->wi_scanbuf,
+			    sc->wi_scanbuf_len * 2);
+			wreq.wi_len = sc->wi_scanbuf_len;
+		} else if (wreq.wi_type == WI_RID_MIF) {
+			mif = wreq.wi_val[0];
+			error = wi_cmd(sc, WI_CMD_READMIF, mif, 0, 0);
+			val = CSR_READ_2(sc, WI_RESP0);
+			wreq.wi_len = 2;
+			wreq.wi_val[0] = val;
+		} else {
+			if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq)) {
+				error = EINVAL;
+				break;
+			}
+		}
+		error = copyout(&wreq, ifr->ifr_data, sizeof(wreq));
+		break;
+	case SIOCSWAVELAN:
+		if ((error = suser(td)))
+			goto out;
+		error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
+		if (error)
+			break;
+		if (wreq.wi_len > WI_MAX_DATALEN) {
+			error = EINVAL;
+			break;
+		}
+		if (wreq.wi_type == WI_RID_IFACE_STATS) {
+			error = EINVAL;
+			break;
+		} else if (wreq.wi_type == WI_RID_PROCFRAME) {
+			sc->wi_procframe = wreq.wi_val[0];
+		/*
+		 * if we're getting a scan request from a wavelan card
+		 * (non-prism2), send out a cmd_inquire to the card to scan
+		 * results for the scan will be received through the info
+		 * interrupt handler. otherwise the scan request can be
+		 * directly handled by a prism2 card's rid interface.
+		 */
+		} else if (wreq.wi_type == WI_RID_SCAN_REQ) {
+			wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_SCAN_RESULTS, 0, 0);
+		} else if (wreq.wi_type == WI_RID_MIF) {
+			mif = wreq.wi_val[0];
+			val = wreq.wi_val[1];
+			error = wi_cmd(sc, WI_CMD_WRITEMIF, mif, val, 0);
+		} else {
+			error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
+			if (!error)
+				wi_setdef(sc, &wreq);
+		}
+		break;
+	case SIOCG80211:
+		switch(ireq->i_type) {
+		case IEEE80211_IOC_SSID:
+			if(ireq->i_val == -1) {
+				bzero(tmpssid, IEEE80211_NWID_LEN);
+				error = wi_get_cur_ssid(sc, tmpssid, &len);
+				if (error != 0)
+					break;
+				error = copyout(tmpssid, ireq->i_data,
+					IEEE80211_NWID_LEN);
+				ireq->i_len = len;
+			} else if (ireq->i_val == 0) {
+				error = copyout(sc->wi_net_name,
+				    ireq->i_data,
+				    IEEE80211_NWID_LEN);
+				ireq->i_len = IEEE80211_NWID_LEN;
+			} else
+				error = EINVAL;
+			break;
+		case IEEE80211_IOC_NUMSSIDS:
+			ireq->i_val = 1;
+			break;
+		case IEEE80211_IOC_WEP:
+			if(!sc->wi_has_wep) {
+				ireq->i_val = IEEE80211_WEP_NOSUP; 
+			} else {
+				if(sc->wi_use_wep) {
+					ireq->i_val =
+					    IEEE80211_WEP_MIXED;
+				} else {
+					ireq->i_val =
+					    IEEE80211_WEP_OFF;
+				}
+			}
+			break;
+		case IEEE80211_IOC_WEPKEY:
+			if(!sc->wi_has_wep ||
+			    ireq->i_val < 0 || ireq->i_val > 3) {
+				error = EINVAL;
+				break;
+			}
+			len = sc->wi_keys.wi_keys[ireq->i_val].wi_keylen;
+			if (suser(td))
+				bcopy(sc->wi_keys.wi_keys[ireq->i_val].wi_keydat,
+				    tmpkey, len);
+			else
+				bzero(tmpkey, len);
+
+			ireq->i_len = len;
+			error = copyout(tmpkey, ireq->i_data, len);
+
+			break;
+		case IEEE80211_IOC_NUMWEPKEYS:
+			if(!sc->wi_has_wep)
+				error = EINVAL;
+			else
+				ireq->i_val = 4;
+			break;
+		case IEEE80211_IOC_WEPTXKEY:
+			if(!sc->wi_has_wep)
+				error = EINVAL;
+			else
+				ireq->i_val = sc->wi_tx_key;
+			break;
+		case IEEE80211_IOC_AUTHMODE:
+			ireq->i_val = sc->wi_authmode;
+			break;
+		case IEEE80211_IOC_STATIONNAME:
+			error = copyout(sc->wi_node_name,
+			    ireq->i_data, IEEE80211_NWID_LEN);
+			ireq->i_len = IEEE80211_NWID_LEN;
+			break;
+		case IEEE80211_IOC_CHANNEL:
+			wreq.wi_type = WI_RID_CURRENT_CHAN;
+			wreq.wi_len = WI_MAX_DATALEN;
+			if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq))
+				error = EINVAL;
+			else {
+				ireq->i_val = wreq.wi_val[0];
+			}
+			break;
+		case IEEE80211_IOC_POWERSAVE:
+			if(sc->wi_pm_enabled)
+				ireq->i_val = IEEE80211_POWERSAVE_ON;
+			else
+				ireq->i_val = IEEE80211_POWERSAVE_OFF;
+			break;
+		case IEEE80211_IOC_POWERSAVESLEEP:
+			ireq->i_val = sc->wi_max_sleep;
+			break;
+		default:
+			error = EINVAL;
+		}
+		break;
+	case SIOCS80211:
+		if ((error = suser(td)))
+			goto out;
+		switch(ireq->i_type) {
+		case IEEE80211_IOC_SSID:
+			if (ireq->i_val != 0 ||
+			    ireq->i_len > IEEE80211_NWID_LEN) {
+				error = EINVAL;
+				break;
+			}
+			/* We set both of them */
+			bzero(sc->wi_net_name, IEEE80211_NWID_LEN);
+			error = copyin(ireq->i_data,
+			    sc->wi_net_name, ireq->i_len);
+			bcopy(sc->wi_net_name, sc->wi_ibss_name, IEEE80211_NWID_LEN);
+			break;
+		case IEEE80211_IOC_WEP:
+			/*
+			 * These cards only support one mode so
+			 * we just turn wep on what ever is
+			 * passed in if it's not OFF.
+			 */
+			if (ireq->i_val == IEEE80211_WEP_OFF) {
+				sc->wi_use_wep = 0;
+			} else {
+				sc->wi_use_wep = 1;
+			}
+			break;
+		case IEEE80211_IOC_WEPKEY:
+			if (ireq->i_val < 0 || ireq->i_val > 3 ||
+				ireq->i_len > 13) {
+				error = EINVAL;
+				break;
+			} 
+			bzero(sc->wi_keys.wi_keys[ireq->i_val].wi_keydat, 13);
+			error = copyin(ireq->i_data, 
+			    sc->wi_keys.wi_keys[ireq->i_val].wi_keydat,
+			    ireq->i_len);
+			if(error)
+				break;
+			sc->wi_keys.wi_keys[ireq->i_val].wi_keylen =
+				    ireq->i_len;
+			break;
+		case IEEE80211_IOC_WEPTXKEY:
+			if (ireq->i_val < 0 || ireq->i_val > 3) {
+				error = EINVAL;
+				break;
+			}
+			sc->wi_tx_key = ireq->i_val;
+			break;
+		case IEEE80211_IOC_AUTHMODE:
+			sc->wi_authmode = ireq->i_val;
+			break;
+		case IEEE80211_IOC_STATIONNAME:
+			if (ireq->i_len > 32) {
+				error = EINVAL;
+				break;
+			}
+			bzero(sc->wi_node_name, 32);
+			error = copyin(ireq->i_data,
+			    sc->wi_node_name, ireq->i_len);
+			break;
+		case IEEE80211_IOC_CHANNEL:
+			/*
+			 * The actual range is 1-14, but if you
+			 * set it to 0 you get the default. So
+			 * we let that work too.
+			 */
+			if (ireq->i_val < 0 || ireq->i_val > 14) {
+				error = EINVAL;
+				break;
+			}
+			sc->wi_channel = ireq->i_val;
+			break;
+		case IEEE80211_IOC_POWERSAVE:
+			switch (ireq->i_val) {
+			case IEEE80211_POWERSAVE_OFF:
+				sc->wi_pm_enabled = 0;
+				break;
+			case IEEE80211_POWERSAVE_ON:
+				sc->wi_pm_enabled = 1;
+				break;
+			default:
+				error = EINVAL;
+				break;
+			}
+			break;
+		case IEEE80211_IOC_POWERSAVESLEEP:
+			if (ireq->i_val < 0) {
+				error = EINVAL;
+				break;
+			}
+			sc->wi_max_sleep = ireq->i_val;
+			break;
+		default:
+			error = EINVAL;
+			break;
+		}
+
+		/* Reinitialize WaveLAN. */
+		wi_init(sc);
+
+	break;
+	default:
+		error = ether_ioctl(ifp, command, data);
+		break;
+	}
+out:
+	WI_UNLOCK(sc, s);
+
+	return(error);
+}
+
+static void
+wi_init(xsc)
+	void			*xsc;
+{
+	struct wi_softc		*sc = xsc;
+	struct ifnet		*ifp = &sc->arpcom.ac_if;
+	struct wi_ltv_macaddr	mac;
+	int			id = 0;
+	int			s;
+
+	WI_LOCK(sc, s);
+
+	if (sc->wi_gone) {
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	if (ifp->if_flags & IFF_RUNNING)
+		owi_stop(sc);
+
+	wi_reset(sc);
+
+	/* Program max data length. */
+	WI_SETVAL(WI_RID_MAX_DATALEN, sc->wi_max_data_len);
+
+	/* Set the port type. */
+	WI_SETVAL(WI_RID_PORTTYPE, sc->wi_ptype);
+
+	/* Enable/disable IBSS creation. */
+	WI_SETVAL(WI_RID_CREATE_IBSS, sc->wi_create_ibss);
+
+	/* Program the RTS/CTS threshold. */
+	WI_SETVAL(WI_RID_RTS_THRESH, sc->wi_rts_thresh);
+
+	/* Program the TX rate */
+	WI_SETVAL(WI_RID_TX_RATE, sc->wi_tx_rate);
+
+	/* Access point density */
+	WI_SETVAL(WI_RID_SYSTEM_SCALE, sc->wi_ap_density);
+
+	/* Power Management Enabled */
+	WI_SETVAL(WI_RID_PM_ENABLED, sc->wi_pm_enabled);
+
+	/* Power Managment Max Sleep */
+	WI_SETVAL(WI_RID_MAX_SLEEP, sc->wi_max_sleep);
+
+	/* Roaming type */
+	WI_SETVAL(WI_RID_ROAMING_MODE, sc->wi_roaming);
+
+	/* Specify the IBSS name */
+	WI_SETSTR(WI_RID_OWN_SSID, sc->wi_ibss_name);
+
+	/* Specify the network name */
+	WI_SETSTR(WI_RID_DESIRED_SSID, sc->wi_net_name);
+
+	/* Specify the frequency to use */
+	WI_SETVAL(WI_RID_OWN_CHNL, sc->wi_channel);
+
+	/* Program the nodename. */
+	WI_SETSTR(WI_RID_NODENAME, sc->wi_node_name);
+
+	/* Specify the authentication mode. */
+	WI_SETVAL(WI_RID_CNFAUTHMODE, sc->wi_authmode);
+
+	/* Set our MAC address. */
+	mac.wi_len = 4;
+	mac.wi_type = WI_RID_MAC_NODE;
+	bcopy((char *)&sc->arpcom.ac_enaddr,
+	   (char *)&mac.wi_mac_addr, ETHER_ADDR_LEN);
+	wi_write_record(sc, (struct wi_ltv_gen *)&mac);
+
+	/*
+	 * Initialize promisc mode.
+	 */
+	if (ifp->if_flags & IFF_PROMISC)
+		WI_SETVAL(WI_RID_PROMISC, 1);
+	else
+		WI_SETVAL(WI_RID_PROMISC, 0);
+
+	/* Configure WEP. */
+	if (sc->wi_has_wep) {
+		WI_SETVAL(WI_RID_ENCRYPTION, sc->wi_use_wep);
+		WI_SETVAL(WI_RID_TX_CRYPT_KEY, sc->wi_tx_key);
+		sc->wi_keys.wi_len = (sizeof(struct wi_ltv_keys) / 2) + 1;
+		sc->wi_keys.wi_type = WI_RID_DEFLT_CRYPT_KEYS;
+		wi_write_record(sc, (struct wi_ltv_gen *)&sc->wi_keys);
+	}
+
+	/* Set multicast filter. */
+	wi_setmulti(sc);
+
+	/* Enable desired port */
+	wi_cmd(sc, WI_CMD_ENABLE | sc->wi_portnum, 0, 0, 0);
+
+	if (wi_alloc_nicmem(sc, ETHER_MAX_LEN + sizeof(struct wi_frame) + 8, &id))
+		device_printf(sc->dev, "tx buffer allocation failed\n");
+	sc->wi_tx_data_id = id;
+
+	if (wi_alloc_nicmem(sc, ETHER_MAX_LEN + sizeof(struct wi_frame) + 8, &id))
+		device_printf(sc->dev, "mgmt. buffer allocation failed\n");
+	sc->wi_tx_mgmt_id = id;
+
+	/* enable interrupts */
+	CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS);
+
+	ifp->if_flags |= IFF_RUNNING;
+	ifp->if_flags &= ~IFF_OACTIVE;
+
+	sc->wi_stat_ch = timeout(wi_inquire, sc, hz * 60);
+	WI_UNLOCK(sc, s);
+
+	return;
+}
+
+static void
+wi_start(ifp)
+	struct ifnet		*ifp;
+{
+	struct wi_softc		*sc;
+	struct mbuf		*m0;
+	struct wi_frame		tx_frame;
+	struct ether_header	*eh;
+	int			id;
+	int			s;
+
+	sc = ifp->if_softc;
+	WI_LOCK(sc, s);
+
+	if (sc->wi_gone) {
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	if (ifp->if_flags & IFF_OACTIVE) {
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	IF_DEQUEUE(&ifp->if_snd, m0);
+	if (m0 == NULL) {
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	bzero((char *)&tx_frame, sizeof(tx_frame));
+	tx_frame.wi_frame_ctl = htole16(WI_FTYPE_DATA);
+	id = sc->wi_tx_data_id;
+	eh = mtod(m0, struct ether_header *);
+
+	/*
+	 * Use RFC1042 encoding for IP and ARP datagrams,
+	 * 802.3 for anything else.
+	 */
+	if (ntohs(eh->ether_type) > ETHER_MAX_LEN) {
+		bcopy((char *)&eh->ether_dhost,
+		    (char *)&tx_frame.wi_addr1, ETHER_ADDR_LEN);
+		bcopy((char *)&eh->ether_shost,
+		    (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
+		bcopy((char *)&eh->ether_dhost,
+		    (char *)&tx_frame.wi_dst_addr, ETHER_ADDR_LEN);
+		bcopy((char *)&eh->ether_shost,
+		    (char *)&tx_frame.wi_src_addr, ETHER_ADDR_LEN);
+
+		tx_frame.wi_dat_len = m0->m_pkthdr.len - WI_SNAPHDR_LEN;
+		tx_frame.wi_dat[0] = htons(WI_SNAP_WORD0);
+		tx_frame.wi_dat[1] = htons(WI_SNAP_WORD1);
+		tx_frame.wi_len = htons(m0->m_pkthdr.len - WI_SNAPHDR_LEN);
+		tx_frame.wi_type = eh->ether_type;
+
+		m_copydata(m0, sizeof(struct ether_header),
+		    m0->m_pkthdr.len - sizeof(struct ether_header),
+		    (caddr_t)&sc->wi_txbuf);
+		wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
+		    sizeof(struct wi_frame));
+		wi_write_data(sc, id, WI_802_11_OFFSET,
+		    (caddr_t)&sc->wi_txbuf, (m0->m_pkthdr.len -
+			sizeof(struct ether_header)) + 2);
+	} else {
+		tx_frame.wi_dat_len = m0->m_pkthdr.len;
+
+		eh->ether_type = htons(m0->m_pkthdr.len - WI_SNAPHDR_LEN);
+		m_copydata(m0, 0, m0->m_pkthdr.len, (caddr_t)&sc->wi_txbuf);
+		wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
+		    sizeof(struct wi_frame));
+		wi_write_data(sc, id, WI_802_3_OFFSET,
+		    (caddr_t)&sc->wi_txbuf, m0->m_pkthdr.len + 2);
+	}
+
+	/*
+	 * If there's a BPF listner, bounce a copy of
+ 	 * this frame to him. Also, don't send this to the bpf sniffer
+ 	 * if we're in procframe or monitor sniffing mode.
+	 */
+ 	if (!(sc->wi_procframe || sc->wi_debug.wi_monitor))
+		BPF_MTAP(ifp, m0);
+
+	m_freem(m0);
+
+	if (wi_cmd(sc, WI_CMD_TX|WI_RECLAIM, id, 0, 0))
+		device_printf(sc->dev, "xmit failed\n");
+
+	ifp->if_flags |= IFF_OACTIVE;
+
+	/*
+	 * Set a timeout in case the chip goes out to lunch.
+	 */
+	ifp->if_timer = 5;
+
+	WI_UNLOCK(sc, s);
+	return;
+}
+
+void
+owi_stop(sc)
+	struct wi_softc		*sc;
+{
+	struct ifnet		*ifp;
+	int			s;
+
+	WI_LOCK(sc, s);
+
+	if (sc->wi_gone) {
+		WI_UNLOCK(sc, s);
+		return;
+	}
+
+	ifp = &sc->arpcom.ac_if;
+
+	/*
+	 * If the card is gone and the memory port isn't mapped, we will
+	 * (hopefully) get 0xffff back from the status read, which is not
+	 * a valid status value.
+	 */
+	if (CSR_READ_2(sc, WI_STATUS) != 0xffff) {
+		CSR_WRITE_2(sc, WI_INT_EN, 0);
+		wi_cmd(sc, WI_CMD_DISABLE|sc->wi_portnum, 0, 0, 0);
+	}
+
+	untimeout(wi_inquire, sc, sc->wi_stat_ch);
+
+	ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
+
+	WI_UNLOCK(sc, s);
+	return;
+}
+
+static void
+wi_watchdog(ifp)
+	struct ifnet		*ifp;
+{
+	struct wi_softc		*sc;
+
+	sc = ifp->if_softc;
+
+	device_printf(sc->dev, "watchdog timeout\n");
+
+	wi_init(sc);
+
+	ifp->if_oerrors++;
+
+	return;
+}
+
+int
+owi_alloc(dev, rid)
+	device_t		dev;
+	int			rid;
+{
+	struct wi_softc		*sc = device_get_softc(dev);
+
+	if (sc->wi_bus_type != WI_BUS_PCI_NATIVE) {
+		sc->iobase_rid = rid;
+		sc->iobase = bus_alloc_resource(dev, SYS_RES_IOPORT,
+		    &sc->iobase_rid, 0, ~0, (1 << 6),
+		    rman_make_alignment_flags(1 << 6) | RF_ACTIVE);
+		if (!sc->iobase) {
+			device_printf(dev, "No I/O space?!\n");
+			return (ENXIO);
+		}
+
+		sc->wi_io_addr = rman_get_start(sc->iobase);
+		sc->wi_btag = rman_get_bustag(sc->iobase);
+		sc->wi_bhandle = rman_get_bushandle(sc->iobase);
+	} else {
+		sc->mem_rid = rid;
+		sc->mem = bus_alloc_resource(dev, SYS_RES_MEMORY,
+		    &sc->mem_rid, 0, ~0, 1, RF_ACTIVE);
+
+		if (!sc->mem) {
+			device_printf(dev, "No Mem space on prism2.5?\n");
+			return (ENXIO);
+		}
+
+		sc->wi_btag = rman_get_bustag(sc->mem);
+		sc->wi_bhandle = rman_get_bushandle(sc->mem);
+	}
+
+
+	sc->irq_rid = 0;
+	sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irq_rid,
+	    0, ~0, 1, RF_ACTIVE |
+	    ((sc->wi_bus_type == WI_BUS_PCCARD) ? 0 : RF_SHAREABLE));
+
+	if (!sc->irq) {
+		owi_free(dev);
+		device_printf(dev, "No irq?!\n");
+		return (ENXIO);
+	}
+
+	sc->dev = dev;
+	sc->wi_unit = device_get_unit(dev);
+
+	return (0);
+}
+
+void
+owi_free(dev)
+	device_t		dev;
+{
+	struct wi_softc		*sc = device_get_softc(dev);
+
+	if (sc->iobase != NULL) {
+		bus_release_resource(dev, SYS_RES_IOPORT, sc->iobase_rid, sc->iobase);
+		sc->iobase = NULL;
+	}
+	if (sc->irq != NULL) {
+		bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
+		sc->irq = NULL;
+	}
+	if (sc->mem != NULL) {
+		bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem);
+		sc->mem = NULL;
+	}
+
+	return;
+}
+
+void
+owi_shutdown(dev)
+	device_t		dev;
+{
+	struct wi_softc		*sc;
+
+	sc = device_get_softc(dev);
+	owi_stop(sc);
+
+	return;
+}
+
+#ifdef WICACHE
+/* wavelan signal strength cache code.
+ * store signal/noise/quality on per MAC src basis in
+ * a small fixed cache.  The cache wraps if > MAX slots
+ * used.  The cache may be zeroed out to start over.
+ * Two simple filters exist to reduce computation:
+ * 1. ip only (literally 0x800) which may be used
+ * to ignore some packets.  It defaults to ip only.
+ * it could be used to focus on broadcast, non-IP 802.11 beacons.
+ * 2. multicast/broadcast only.  This may be used to
+ * ignore unicast packets and only cache signal strength
+ * for multicast/broadcast packets (beacons); e.g., Mobile-IP
+ * beacons and not unicast traffic.
+ *
+ * The cache stores (MAC src(index), IP src (major clue), signal,
+ *	quality, noise)
+ *
+ * No apologies for storing IP src here.  It's easy and saves much
+ * trouble elsewhere.  The cache is assumed to be INET dependent, 
+ * although it need not be.
+ */
+
+#ifdef documentation
+
+int wi_sigitems;                                /* number of cached entries */
+struct wi_sigcache wi_sigcache[MAXWICACHE];  /*  array of cache entries */
+int wi_nextitem;                                /*  index/# of entries */
+
+
+#endif
+
+/* control variables for cache filtering.  Basic idea is
+ * to reduce cost (e.g., to only Mobile-IP agent beacons
+ * which are broadcast or multicast).  Still you might
+ * want to measure signal strength with unicast ping packets
+ * on a pt. to pt. ant. setup.
+ */
+/* set true if you want to limit cache items to broadcast/mcast 
+ * only packets (not unicast).  Useful for mobile-ip beacons which
+ * are broadcast/multicast at network layer.  Default is all packets
+ * so ping/unicast will work say with pt. to pt. antennae setup.
+ */
+static int wi_cache_mcastonly = 0;
+SYSCTL_INT(_machdep, OID_AUTO, wi_cache_mcastonly, CTLFLAG_RW, 
+	&wi_cache_mcastonly, 0, "");
+
+/* set true if you want to limit cache items to IP packets only
+*/
+static int wi_cache_iponly = 1;
+SYSCTL_INT(_machdep, OID_AUTO, wi_cache_iponly, CTLFLAG_RW, 
+	&wi_cache_iponly, 0, "");
+
+/*
+ * Original comments:
+ * -----------------
+ * wi_cache_store, per rx packet store signal
+ * strength in MAC (src) indexed cache.
+ *
+ * follows linux driver in how signal strength is computed.
+ * In ad hoc mode, we use the rx_quality field. 
+ * signal and noise are trimmed to fit in the range from 47..138.
+ * rx_quality field MSB is signal strength.
+ * rx_quality field LSB is noise.
+ * "quality" is (signal - noise) as is log value.
+ * note: quality CAN be negative.
+ * 
+ * In BSS mode, we use the RID for communication quality.
+ * TBD:  BSS mode is currently untested.
+ *
+ * Bill's comments:
+ * ---------------
+ * Actually, we use the rx_quality field all the time for both "ad-hoc"
+ * and BSS modes. Why? Because reading an RID is really, really expensive:
+ * there's a bunch of PIO operations that have to be done to read a record
+ * from the NIC, and reading the comms quality RID each time a packet is
+ * received can really hurt performance. We don't have to do this anyway:
+ * the comms quality field only reflects the values in the rx_quality field
+ * anyway. The comms quality RID is only meaningful in infrastructure mode,
+ * but the values it contains are updated based on the rx_quality from
+ * frames received from the access point.
+ *
+ * Also, according to Lucent, the signal strength and noise level values
+ * can be converted to dBms by subtracting 149, so I've modified the code
+ * to do that instead of the scaling it did originally.
+ */
+static void
+wi_cache_store(struct wi_softc *sc, struct ether_header *eh,
+                     struct mbuf *m, unsigned short rx_quality)
+{
+	struct ip *ip = 0; 
+	int i;
+	static int cache_slot = 0; 	/* use this cache entry */
+	static int wrapindex = 0;       /* next "free" cache entry */
+	int sig, noise;
+	int sawip=0;
+
+	/* 
+	 * filters:
+	 * 1. ip only
+	 * 2. configurable filter to throw out unicast packets,
+	 * keep multicast only.
+	 */
+ 
+	if ((ntohs(eh->ether_type) == ETHERTYPE_IP)) {
+		sawip = 1;
+	}
+
+	/* 
+	 * filter for ip packets only 
+	*/
+	if (wi_cache_iponly && !sawip) {
+		return;
+	}
+
+	/*
+	 *  filter for broadcast/multicast only
+	 */
+	if (wi_cache_mcastonly && ((eh->ether_dhost[0] & 1) == 0)) {
+		return;
+	}
+
+#ifdef SIGDEBUG
+	printf("owi%d: q value %x (MSB=0x%x, LSB=0x%x) \n", sc->wi_unit,
+	    rx_quality & 0xffff, rx_quality >> 8, rx_quality & 0xff);
+#endif
+
+	/*
+	 *  find the ip header.  we want to store the ip_src
+	 * address.  
+	 */
+	if (sawip)
+		ip = mtod(m, struct ip *);
+        
+	/*
+	 * do a linear search for a matching MAC address 
+	 * in the cache table
+	 * . MAC address is 6 bytes,
+	 * . var w_nextitem holds total number of entries already cached
+	 */
+	for(i = 0; i < sc->wi_nextitem; i++) {
+		if (! bcmp(eh->ether_shost , sc->wi_sigcache[i].macsrc,  6 )) {
+			/* 
+			 * Match!,
+			 * so we already have this entry,
+			 * update the data
+			 */
+			break;	
+		}
+	}
+
+	/*
+	 *  did we find a matching mac address?
+	 * if yes, then overwrite a previously existing cache entry
+	 */
+	if (i < sc->wi_nextitem )   {
+		cache_slot = i; 
+	}
+	/*
+	 * else, have a new address entry,so
+	 * add this new entry,
+	 * if table full, then we need to replace LRU entry
+	 */
+	else    {                          
+
+		/* 
+		 * check for space in cache table 
+		 * note: wi_nextitem also holds number of entries
+		 * added in the cache table 
+		 */
+		if ( sc->wi_nextitem < MAXWICACHE ) {
+			cache_slot = sc->wi_nextitem;
+			sc->wi_nextitem++;                 
+			sc->wi_sigitems = sc->wi_nextitem;
+		}
+        	/* no space found, so simply wrap with wrap index
+		 * and "zap" the next entry
+		 */
+		else {
+			if (wrapindex == MAXWICACHE) {
+				wrapindex = 0;
+			}
+			cache_slot = wrapindex++;
+		}
+	}
+
+	/* 
+	 * invariant: cache_slot now points at some slot
+	 * in cache.
+	 */
+	if (cache_slot < 0 || cache_slot >= MAXWICACHE) {
+		log(LOG_ERR, "owi_cache_store, bad index: %d of "
+		    "[0..%d], gross cache error\n",
+		    cache_slot, MAXWICACHE);
+		return;
+	}
+
+	/*
+	 *  store items in cache
+	 *  .ip source address
+	 *  .mac src
+	 *  .signal, etc.
+	 */
+	if (sawip)
+		sc->wi_sigcache[cache_slot].ipsrc = ip->ip_src.s_addr;
+	bcopy( eh->ether_shost, sc->wi_sigcache[cache_slot].macsrc,  6);
+
+	sig = (rx_quality >> 8) & 0xFF;
+	noise = rx_quality & 0xFF;
+
+	/*
+	 * -149 is Lucent specific to convert to dBm.  Prism2 cards do
+	 * things differently, sometimes don't have a noise measurement,
+	 * and is firmware dependent :-(
+	 */
+	sc->wi_sigcache[cache_slot].signal = sig - 149;
+	sc->wi_sigcache[cache_slot].noise = noise - 149;
+	sc->wi_sigcache[cache_slot].quality = sig - noise;
+
+	return;
+}
+#endif
+
+static int
+wi_get_cur_ssid(sc, ssid, len)
+	struct wi_softc		*sc;
+	char			*ssid;
+	int			*len;
+{
+	int			error = 0;
+	struct wi_req		wreq;
+
+	wreq.wi_len = WI_MAX_DATALEN;
+	switch (sc->wi_ptype) {
+	case WI_PORTTYPE_IBSS:
+	case WI_PORTTYPE_ADHOC:
+		wreq.wi_type = WI_RID_CURRENT_SSID;
+		error = wi_read_record(sc, (struct wi_ltv_gen *)&wreq);
+		if (error != 0)
+			break;
+		if (wreq.wi_val[0] > IEEE80211_NWID_LEN) {
+			error = EINVAL;
+			break;
+		}
+		*len = wreq.wi_val[0];
+		bcopy(&wreq.wi_val[1], ssid, IEEE80211_NWID_LEN);
+		break;
+	case WI_PORTTYPE_BSS:
+		wreq.wi_type = WI_RID_COMMQUAL;
+		error = wi_read_record(sc, (struct wi_ltv_gen *)&wreq);
+		if (error != 0)
+			break;
+		if (wreq.wi_val[0] != 0) /* associated */ {
+			wreq.wi_type = WI_RID_CURRENT_SSID;
+			wreq.wi_len = WI_MAX_DATALEN;
+			error = wi_read_record(sc, (struct wi_ltv_gen *)&wreq);
+			if (error != 0)
+				break;
+			if (wreq.wi_val[0] > IEEE80211_NWID_LEN) {
+				error = EINVAL;
+				break;
+			}
+			*len = wreq.wi_val[0];
+			bcopy(&wreq.wi_val[1], ssid, IEEE80211_NWID_LEN);
+		} else {
+			*len = IEEE80211_NWID_LEN;
+			bcopy(sc->wi_net_name, ssid, IEEE80211_NWID_LEN);
+		}
+		break;
+	default:
+		error = EINVAL;
+		break;
+	}
+
+	return error;
+}
+
+static int
+wi_media_change(ifp)
+	struct ifnet		*ifp;
+{
+	struct wi_softc		*sc = ifp->if_softc;
+	int			otype = sc->wi_ptype;
+	int			orate = sc->wi_tx_rate;
+	int			ocreate_ibss = sc->wi_create_ibss;
+
+	sc->wi_create_ibss = 0;
+
+	switch (sc->ifmedia.ifm_cur->ifm_media & IFM_OMASK) {
+	case 0:
+		sc->wi_ptype = WI_PORTTYPE_BSS;
+		break;
+	case IFM_IEEE80211_ADHOC:
+		sc->wi_ptype = WI_PORTTYPE_ADHOC;
+		break;
+	case IFM_IEEE80211_IBSSMASTER:
+	case IFM_IEEE80211_IBSSMASTER|IFM_IEEE80211_IBSS:
+		if (!(sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS))
+			return (EINVAL);
+		sc->wi_create_ibss = 1;
+		/* FALLTHROUGH */
+	case IFM_IEEE80211_IBSS:
+		sc->wi_ptype = WI_PORTTYPE_IBSS;
+		break;
+	default:
+		/* Invalid combination. */
+		return (EINVAL);
+	}
+
+	switch (IFM_SUBTYPE(sc->ifmedia.ifm_cur->ifm_media)) {
+	case IFM_IEEE80211_DS1:
+		sc->wi_tx_rate = 1;
+		break;
+	case IFM_IEEE80211_DS2:
+		sc->wi_tx_rate = 2;
+		break;
+	case IFM_IEEE80211_DS5:
+		sc->wi_tx_rate = 5;
+		break;
+	case IFM_IEEE80211_DS11:
+		sc->wi_tx_rate = 11;
+		break;
+	case IFM_AUTO:
+		sc->wi_tx_rate = 3;
+		break;
+	}
+
+	if (ocreate_ibss != sc->wi_create_ibss || otype != sc->wi_ptype ||
+	    orate != sc->wi_tx_rate)
+		wi_init(sc);
+
+	return(0);
+}
+
+static void
+wi_media_status(ifp, imr)
+	struct ifnet		*ifp;
+	struct ifmediareq	*imr;
+{
+	struct wi_req		wreq;
+	struct wi_softc		*sc = ifp->if_softc;
+
+	if (sc->wi_tx_rate == 3) {
+		imr->ifm_active = IFM_IEEE80211|IFM_AUTO;
+		if (sc->wi_ptype == WI_PORTTYPE_ADHOC)
+			imr->ifm_active |= IFM_IEEE80211_ADHOC;
+		else if (sc->wi_ptype == WI_PORTTYPE_IBSS) {
+			if (sc->wi_create_ibss)
+				imr->ifm_active |= IFM_IEEE80211_IBSSMASTER;
+			else
+				imr->ifm_active |= IFM_IEEE80211_IBSS;
+		}
+		wreq.wi_type = WI_RID_CUR_TX_RATE;
+		wreq.wi_len = WI_MAX_DATALEN;
+		if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0) {
+			switch(wreq.wi_val[0]) {
+			case 1:
+				imr->ifm_active |= IFM_IEEE80211_DS1;
+				break;
+			case 2:
+				imr->ifm_active |= IFM_IEEE80211_DS2;
+				break;
+			case 6:
+				imr->ifm_active |= IFM_IEEE80211_DS5;
+				break;
+			case 11:
+				imr->ifm_active |= IFM_IEEE80211_DS11;
+				break;
+				}
+		}
+	} else {
+		imr->ifm_active = sc->ifmedia.ifm_cur->ifm_media;
+	}
+
+	imr->ifm_status = IFM_AVALID;
+	if (sc->wi_ptype == WI_PORTTYPE_ADHOC ||
+	    sc->wi_ptype == WI_PORTTYPE_IBSS)
+		/*
+		 * XXX: It would be nice if we could give some actually
+		 * useful status like whether we joined another IBSS or
+		 * created one ourselves.
+		 */
+		imr->ifm_status |= IFM_ACTIVE;
+	else {
+		wreq.wi_type = WI_RID_COMMQUAL;
+		wreq.wi_len = WI_MAX_DATALEN;
+		if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0 &&
+		    wreq.wi_val[0] != 0)
+			imr->ifm_status |= IFM_ACTIVE;
+	}
+}
diff --git a/sys/dev/owi/if_owi_pccard.c b/sys/dev/owi/if_owi_pccard.c
new file mode 100644
index 0000000..549aff5
--- /dev/null
+++ b/sys/dev/owi/if_owi_pccard.c
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 1997, 1998, 1999
+ *	Bill Paul <wpaul@ctr.columbia.edu>.  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 OR THE VOICES IN HIS HEAD
+ * 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.
+ */
+
+/*
+ * Lucent WaveLAN/IEEE 802.11 PCMCIA driver for FreeBSD.
+ *
+ * Written by Bill Paul <wpaul@ctr.columbia.edu>
+ * Electrical Engineering Department
+ * Columbia University, New York City
+ */
+
+#include "opt_wi.h"
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/socket.h>
+#include <sys/systm.h>
+#include <sys/module.h>
+#include <sys/bus.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <sys/rman.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/if_types.h>
+#include <dev/owi/if_ieee80211.h>
+
+#include <dev/pccard/pccardvar.h>
+#include <dev/pccard/pccarddevs.h>
+
+#include <dev/wi/if_wavelan_ieee.h>
+#include <dev/owi/if_wivar.h>
+#include <dev/owi/if_wireg.h>
+
+#include "card_if.h"
+
+#if !defined(lint)
+static const char rcsid[] =
+  "$FreeBSD$";
+#endif
+
+static int wi_pccard_probe(device_t);
+static int wi_pccard_attach(device_t);
+static int wi_pccard_match(device_t);
+
+static device_method_t wi_pccard_methods[] = {
+	/* Device interface */
+	DEVMETHOD(device_probe,		pccard_compat_probe),
+	DEVMETHOD(device_attach,	pccard_compat_attach),
+	DEVMETHOD(device_detach,	owi_generic_detach),
+	DEVMETHOD(device_shutdown,	owi_shutdown),
+
+	/* Card interface */
+	DEVMETHOD(card_compat_match,	wi_pccard_match),
+	DEVMETHOD(card_compat_probe,	wi_pccard_probe),
+	DEVMETHOD(card_compat_attach,	wi_pccard_attach),
+
+	{ 0, 0 }
+};
+
+static driver_t wi_pccard_driver = {
+	"owi",
+	wi_pccard_methods,
+	sizeof(struct wi_softc)
+};
+
+DRIVER_MODULE(if_owi, pccard, wi_pccard_driver, owi_devclass, 0, 0);
+
+static const struct pccard_product wi_pccard_products[] = {
+	PCMCIA_CARD(3COM, 3CRWE737A, 0),
+	PCMCIA_CARD(3COM, 3CRWE777A, 0),
+	PCMCIA_CARD(ACTIONTEC, PRISM, 0),
+	PCMCIA_CARD(ADDTRON, AWP100, 0),
+	PCMCIA_CARD(BAY, EMOBILITY_11B, 0),
+	PCMCIA_CARD(BUFFALO, WLI_PCM_S11, 0),
+	PCMCIA_CARD(BUFFALO, WLI_CF_S11G, 0),
+	PCMCIA_CARD(COMPAQ, NC5004, 0),
+	PCMCIA_CARD(CONTEC, FX_DS110_PCC, 0),
+	PCMCIA_CARD(COREGA, WIRELESS_LAN_PCC_11, 0),
+	PCMCIA_CARD(COREGA, WIRELESS_LAN_PCCA_11, 0),
+	PCMCIA_CARD(COREGA, WIRELESS_LAN_PCCB_11, 0),
+	PCMCIA_CARD(ELSA, XI300_IEEE, 0),
+	PCMCIA_CARD(ELSA, XI325_IEEE, 0),
+	PCMCIA_CARD(ELSA, XI800_IEEE, 0),
+	PCMCIA_CARD(EMTAC, WLAN, 0),
+	PCMCIA_CARD(ERICSSON, WIRELESSLAN, 0),
+	PCMCIA_CARD(GEMTEK, WLAN, 0),
+	PCMCIA_CARD(HWN, AIRWAY80211, 0), 
+	PCMCIA_CARD(INTEL, PRO_WLAN_2011, 0),
+	PCMCIA_CARD(INTERSIL, MA401RA, 0),
+	PCMCIA_CARD(INTERSIL2, PRISM2, 0),
+	PCMCIA_CARD(IODATA2, WNB11PCM, 0),
+	PCMCIA_CARD(BROMAX, IWN, 0),
+	PCMCIA_CARD(BROMAX, IWN3, 0),
+	PCMCIA_CARD(BROMAX, WCF11, 0),
+	/* Now that we do PRISM detection, I don't think we need these - imp */
+	PCMCIA_CARD2(LUCENT, WAVELAN_IEEE, NANOSPEED_PRISM2, 0),
+	PCMCIA_CARD2(LUCENT, WAVELAN_IEEE, NEC_CMZ_RT_WP, 0),
+	PCMCIA_CARD2(LUCENT, WAVELAN_IEEE, NTT_ME_WLAN, 0),
+	PCMCIA_CARD2(LUCENT, WAVELAN_IEEE, SMC_2632W, 0),
+	/* Must be after other LUCENT ones because it is less specific */
+	PCMCIA_CARD(LUCENT, WAVELAN_IEEE, 0),
+	PCMCIA_CARD(NOKIA, C110_WLAN, 0),
+	PCMCIA_CARD(PLANEX_2, GWNS11H, 0),
+	PCMCIA_CARD(PROXIM, RANGELANDS_8430, 0),
+	PCMCIA_CARD(SAMSUNG, SWL_2000N, 0),
+	PCMCIA_CARD(SIMPLETECH, SPECTRUM24_ALT, 0),
+	PCMCIA_CARD(SOCKET, LP_WLAN_CF, 0),
+	PCMCIA_CARD(SYMBOL, LA4100, 0),
+	PCMCIA_CARD(TDK, LAK_CD011WL, 0),
+	{ NULL }
+};
+
+static int
+wi_pccard_match(dev)
+	device_t	dev;
+{
+	const struct pccard_product *pp;
+
+	if ((pp = pccard_product_lookup(dev, wi_pccard_products,
+	    sizeof(wi_pccard_products[0]), NULL)) != NULL) {
+		device_set_desc(dev, pp->pp_name);
+		return 0;
+	}
+	return ENXIO;
+}
+
+static int
+wi_pccard_probe(dev)
+	device_t	dev;
+{
+	struct wi_softc	*sc;
+	int		error;
+
+	sc = device_get_softc(dev);
+	sc->wi_gone = 0;
+	sc->wi_bus_type = WI_BUS_PCCARD;
+
+	error = owi_alloc(dev, 0);
+	if (error)
+		return (error);
+
+	owi_get_id(sc);
+
+	/* Make sure interrupts are disabled. */
+	CSR_WRITE_2(sc, WI_INT_EN, 0);
+	CSR_WRITE_2(sc, WI_EVENT_ACK, 0xFFFF);
+
+	owi_free(dev);
+
+	if (sc->sc_firmware_type != WI_LUCENT)
+		return ENXIO;
+	return (0);
+}
+
+static int
+wi_pccard_attach(device_t dev)
+{
+	struct wi_softc		*sc;
+	int			error;
+
+	sc = device_get_softc(dev);
+
+	error = owi_alloc(dev, 0);
+	if (error) {
+		device_printf(dev, "wi_alloc() failed! (%d)\n", error);
+		return (error);
+	}
+
+	return (owi_generic_attach(dev));
+}
diff --git a/sys/dev/owi/if_wireg.h b/sys/dev/owi/if_wireg.h
new file mode 100644
index 0000000..04de3b3
--- /dev/null
+++ b/sys/dev/owi/if_wireg.h
@@ -0,0 +1,618 @@
+/*
+ * Copyright (c) 1997, 1998, 1999
+ *	Bill Paul <wpaul@ctr.columbia.edu>.  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 OR THE VOICES IN HIS HEAD
+ * 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$
+ */
+
+#define WI_DELAY	5
+#define WI_TIMEOUT	(500000/WI_DELAY)	/* 500 ms */
+
+#define WI_PORT0	0
+#define WI_PORT1	1
+#define WI_PORT2	2
+#define WI_PORT3	3
+#define WI_PORT4	4
+#define WI_PORT5	5
+
+#define WI_PCI_LMEMRES	0x10	/* PCI Memory (native PCI implementations) */
+#define WI_PCI_LOCALRES	0x14	/* The PLX chip's local registers */
+#define WI_PCI_MEMRES	0x18	/* The PCCard's attribute memory */
+#define WI_PCI_IORES	0x1C	/* The PCCard's I/O space */
+
+#define WI_LOCAL_INTCSR		0x4c
+#define WI_LOCAL_INTEN		0x40
+
+/* Default port: 0 (only 0 exists on stations) */
+#define WI_DEFAULT_PORT	(WI_PORT0 << 8)
+
+/* Default TX rate: 2Mbps, auto fallback */
+#define WI_DEFAULT_TX_RATE	3
+
+/* Default network name: ANY */
+/*
+ * [sommerfeld 1999/07/15] Changed from "ANY" to ""; according to Bill Fenner,
+ * ANY is used in MS driver user interfaces, while "" is used over the
+ * wire..
+ */
+#define WI_DEFAULT_NETNAME	""
+
+#define WI_DEFAULT_AP_DENSITY	1
+
+#define WI_DEFAULT_RTS_THRESH	2347
+
+#define WI_DEFAULT_DATALEN	2304
+
+#define WI_DEFAULT_CREATE_IBSS	0
+
+#define WI_DEFAULT_PM_ENABLED	0
+
+#define WI_DEFAULT_MAX_SLEEP	100
+
+#define WI_DEFAULT_ROAMING	1
+
+#define WI_DEFAULT_AUTHTYPE	1
+
+#ifdef __NetBSD__
+#define OS_STRING_NAME	"NetBSD"
+#endif
+#ifdef __FreeBSD__
+#define OS_STRING_NAME	"FreeBSD"
+#endif
+#ifdef __OpenBSD__
+#define OS_STRING_NAME	"OpenBSD"
+#endif
+
+#define WI_DEFAULT_NODENAME	OS_STRING_NAME " WaveLAN/IEEE node"
+
+#define WI_DEFAULT_IBSS		OS_STRING_NAME " IBSS"
+
+#define WI_DEFAULT_CHAN		3
+
+#define WI_BUS_PCCARD		0	/* pccard device */
+#define WI_BUS_PCI_PLX		1	/* PCI card w/ PLX PCI/PCMICA bridge */
+#define WI_BUS_PCI_NATIVE	2	/* native PCI device (Prism 2.5) */
+
+/*
+ * register space access macros
+ */
+#define CSR_WRITE_4(sc, reg, val)				\
+	bus_space_write_4((sc)->wi_btag, (sc)->wi_bhandle, 	\
+	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg), val)
+#define CSR_WRITE_2(sc, reg, val)				\
+	bus_space_write_2((sc)->wi_btag, (sc)->wi_bhandle,	\
+ 	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg), val)
+#define CSR_WRITE_1(sc, reg, val)				\
+	bus_space_write_1((sc)->wi_btag, (sc)->wi_bhandle,	\
+ 	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg), val)
+
+#define CSR_READ_4(sc, reg)					\
+	bus_space_read_4((sc)->wi_btag, (sc)->wi_bhandle,	\
+ 	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg))
+#define CSR_READ_2(sc, reg)					\
+	bus_space_read_2((sc)->wi_btag, (sc)->wi_bhandle,	\
+ 	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg))
+#define CSR_READ_1(sc, reg)					\
+	bus_space_read_1((sc)->wi_btag, (sc)->wi_bhandle,	\
+ 	    (sc)->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg)*2 : (reg))
+
+#define CSM_WRITE_1(sc, off, val)	\
+	bus_space_write_1((sc)->wi_bmemtag, (sc)->wi_bmemhandle, off, val)
+
+#define CSM_READ_1(sc, off)		\
+	bus_space_read_1((sc)->wi_bmemtag, (sc)->wi_bmemhandle, off)
+
+#define CSR_WRITE_STREAM_2(sc, reg, val)	\
+	bus_space_write_stream_2(sc->wi_btag, sc->wi_bhandle,	\
+	    (sc->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg) * 2 : (reg)), val)
+#define CSR_WRITE_MULTI_STREAM_2(sc, reg, val, count)	\
+	bus_space_write_multi_stream_2(sc->wi_btag, sc->wi_bhandle,	\
+	    (sc->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg) * 2 : (reg)), val, count)
+#define CSR_READ_STREAM_2(sc, reg)		\
+	bus_space_read_stream_2(sc->wi_btag, sc->wi_bhandle,	\
+	    (sc->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg) * 2 : (reg)))
+#define CSR_READ_MULTI_STREAM_2(sc, reg, buf, count)		\
+	bus_space_read_multi_stream_2(sc->wi_btag, sc->wi_bhandle,	\
+	    (sc->wi_bus_type == WI_BUS_PCI_NATIVE ? (reg) * 2 : (reg)), buf, count)
+
+/*
+ * The WaveLAN/IEEE cards contain an 802.11 MAC controller which Lucent
+ * calls 'Hermes.' In typical fashion, getting documentation about this
+ * controller is about as easy as squeezing blood from a stone. Here
+ * is more or less what I know:
+ *
+ * - The Hermes controller is firmware driven, and the host interacts
+ *   with the Hermes via a firmware interface, which can change.
+ *
+ * - The Hermes is described in a document called: "Hermes Firmware
+ *   WaveLAN/IEEE Station Functions," document #010245, which of course
+ *   Lucent will not release without an NDA.
+ *
+ * - Lucent has created a library called HCF (Hardware Control Functions)
+ *   though which it wants developers to interact with the card. The HCF
+ *   is needlessly complex, ill conceived and badly documented. Actually,
+ *   the comments in the HCP code itself aren't bad, but the publically
+ *   available manual that comes with it is awful, probably due largely to
+ *   the fact that it has been emasculated in order to hide information
+ *   that Lucent wants to keep proprietary. The purpose of the HCF seems
+ *   to be to insulate the driver programmer from the Hermes itself so that
+ *   Lucent has an excuse not to release programming in for it.
+ *
+ * - Lucent only makes available documentation and code for 'HCF Light'
+ *   which is a stripped down version of HCF with certain features not
+ *   implemented, most notably support for 802.11 frames.
+ *
+ * - The HCF code which I have seen blows goats. Whoever decided to
+ *   use a 132 column format should be shot.
+ *
+ * Rather than actually use the Lucent HCF library, I have stripped all
+ * the useful information from it and used it to create a driver in the
+ * usual BSD form. Note: I don't want to hear anybody whining about the
+ * fact that the Lucent code is GPLed and mine isn't. I did not actually
+ * put any of Lucent's code in this driver: I only used it as a reference
+ * to obtain information about the underlying hardware. The Hermes
+ * programming interface is not GPLed, so bite me.
+ */
+
+/*
+ * Size of Hermes & Prism2 I/O space.
+ */
+#define WI_IOSIZ		0x40
+
+/*
+ * Hermes & Prism2 register definitions 
+ */
+
+/* Hermes command/status registers. */
+#define WI_COMMAND		0x00
+#define WI_PARAM0		0x02
+#define WI_PARAM1		0x04
+#define WI_PARAM2		0x06
+#define WI_STATUS		0x08
+#define WI_RESP0		0x0A
+#define WI_RESP1		0x0C
+#define WI_RESP2		0x0E
+
+/* Command register values. */
+#define WI_CMD_BUSY		0x8000 /* busy bit */
+#define WI_CMD_INI		0x0000 /* initialize */
+#define WI_CMD_ENABLE		0x0001 /* enable */
+#define WI_CMD_DISABLE		0x0002 /* disable */
+#define WI_CMD_DIAG		0x0003
+#define WI_CMD_ALLOC_MEM	0x000A /* allocate NIC memory */
+#define WI_CMD_TX		0x000B /* transmit */
+#define WI_CMD_NOTIFY		0x0010
+#define WI_CMD_INQUIRE		0x0011
+#define WI_CMD_ACCESS		0x0021
+#define WI_CMD_ACCESS_WRITE	0x0121
+#define WI_CMD_PROGRAM		0x0022
+#define WI_CMD_READEE		0x0030	/* symbol only */
+#define WI_CMD_READMIF		0x0030	/* prism2 */
+#define WI_CMD_WRITEMIF		0x0031	/* prism2 */
+#define WI_CMD_DEBUG		0x0038	/* Various test commands */
+
+#define WI_CMD_CODE_MASK	0x003F
+
+/*
+ * Various cmd test stuff.
+ */
+#define WI_TEST_MONITOR		0x0B
+#define WI_TEST_STOP		0x0F
+#define WI_TEST_CFG_BITS	0x15
+#define WI_TEST_CFG_BIT_ALC	0x08
+
+/*
+ * Reclaim qualifier bit, applicable to the
+ * TX and INQUIRE commands.
+ */
+#define WI_RECLAIM		0x0100 /* reclaim NIC memory */
+
+/*
+ * ACCESS command qualifier bits.
+ */
+#define WI_ACCESS_READ		0x0000
+#define WI_ACCESS_WRITE		0x0100
+
+/*
+ * PROGRAM command qualifier bits.
+ */
+#define WI_PROGRAM_DISABLE	0x0000
+#define WI_PROGRAM_ENABLE_RAM	0x0100
+#define WI_PROGRAM_ENABLE_NVRAM	0x0200
+#define WI_PROGRAM_NVRAM	0x0300
+
+/* Status register values */
+#define WI_STAT_CMD_CODE	0x003F
+#define WI_STAT_DIAG_ERR	0x0100
+#define WI_STAT_INQ_ERR		0x0500
+#define WI_STAT_CMD_RESULT	0x7F00
+
+/* memory handle management registers */
+#define WI_INFO_FID		0x10
+#define WI_RX_FID		0x20
+#define WI_ALLOC_FID		0x22
+#define WI_TX_CMP_FID		0x24
+
+/*
+ * Buffer Access Path (BAP) registers.
+ * These are I/O channels. I believe you can use each one for
+ * any desired purpose independently of the other. In general
+ * though, we use BAP1 for reading and writing LTV records and
+ * reading received data frames, and BAP0 for writing transmit
+ * frames. This is a convention though, not a rule.
+ */
+#define WI_SEL0			0x18
+#define WI_SEL1			0x1A
+#define WI_OFF0			0x1C
+#define WI_OFF1			0x1E
+#define WI_DATA0		0x36
+#define WI_DATA1		0x38
+#define WI_BAP0			WI_DATA0
+#define WI_BAP1			WI_DATA1
+
+#define WI_OFF_BUSY		0x8000
+#define WI_OFF_ERR		0x4000
+#define WI_OFF_DATAOFF		0x0FFF
+
+/* Event registers */
+#define WI_EVENT_STAT		0x30	/* Event status */
+#define WI_INT_EN		0x32	/* Interrupt enable/disable */
+#define WI_EVENT_ACK		0x34	/* Ack event */
+
+/* Events */
+#define WI_EV_TICK		0x8000	/* aux timer tick */
+#define WI_EV_RES		0x4000	/* controller h/w error (time out) */
+#define WI_EV_INFO_DROP		0x2000	/* no RAM to build unsolicited frame */
+#define WI_EV_NO_CARD		0x0800	/* card removed (hunh?) */
+#define WI_EV_DUIF_RX		0x0400	/* wavelan management packet received */
+#define WI_EV_INFO		0x0080	/* async info frame */
+#define WI_EV_CMD		0x0010	/* command completed */
+#define WI_EV_ALLOC		0x0008	/* async alloc/reclaim completed */
+#define WI_EV_TX_EXC		0x0004	/* async xmit completed with failure */
+#define WI_EV_TX		0x0002	/* async xmit completed succesfully */
+#define WI_EV_RX		0x0001	/* async rx completed */
+
+#define WI_INTRS	\
+	(WI_EV_RX|WI_EV_TX|WI_EV_TX_EXC|WI_EV_ALLOC|WI_EV_INFO|WI_EV_INFO_DROP)
+
+/* Host software registers */
+#define WI_SW0			0x28
+#define WI_SW1			0x2A
+#define WI_SW2			0x2C
+#define WI_SW3			0x2E 	/* does not appear in Prism2 */
+
+#define WI_CNTL			0x14
+
+#define WI_CNTL_AUX_ENA		0xC000
+#define WI_CNTL_AUX_ENA_STAT	0xC000
+#define WI_CNTL_AUX_DIS_STAT	0x0000
+#define WI_CNTL_AUX_ENA_CNTL	0x8000
+#define WI_CNTL_AUX_DIS_CNTL	0x4000
+
+#define WI_AUX_PAGE		0x3A
+#define WI_AUX_OFFSET		0x3C
+#define WI_AUX_DATA		0x3E
+
+#define WI_AUX_PGSZ		128
+#define WI_AUX_KEY0		0xfe01
+#define WI_AUX_KEY1		0xdc23
+#define WI_AUX_KEY2		0xba45
+
+#define WI_COR			0x40	/* only for Symbol */
+#define WI_COR_RESET		0x0080
+#define WI_COR_IOMODE		0x0041
+
+#define WI_HCR			0x42	/* only for Symbol */
+#define WI_HCR_4WIRE		0x0010
+#define WI_HCR_RUN		0x0007
+#define WI_HCR_HOLD		0x000f
+#define WI_HCR_EEHOLD		0x00ce
+
+#define WI_COR_OFFSET	0x3e0	/* OK for PCI, must be bogus for pccard */
+#define WI_COR_VALUE	0x41
+
+/*
+ * One form of communication with the Hermes is with what Lucent calls
+ * LTV records, where LTV stands for Length, Type and Value. The length
+ * and type are 16 bits and are in native byte order. The value is in
+ * multiples of 16 bits and is in little endian byte order.
+ */
+struct wi_ltv_gen {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_val;
+};
+
+struct wi_ltv_str {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_str[17];
+};
+
+#define WI_SETVAL(recno, val)			\
+	do {					\
+		struct wi_ltv_gen	g;	\
+						\
+		g.wi_len = 2;			\
+		g.wi_type = recno;		\
+		g.wi_val = htole16(val);	\
+		wi_write_record(sc, &g);	\
+	} while (0)
+
+#define WI_SETSTR(recno, str)					\
+	do {							\
+		struct wi_ltv_str	s;			\
+		int			l;			\
+								\
+		l = (strlen(str) + 1) & ~0x1;			\
+		bzero((char *)&s, sizeof(s));			\
+		s.wi_len = (l / 2) + 2;				\
+		s.wi_type = recno;				\
+		s.wi_str[0] = htole16(strlen(str));		\
+		bcopy(str, (char *)&s.wi_str[1], strlen(str));	\
+		wi_write_record(sc, (struct wi_ltv_gen *)&s);	\
+	} while (0)
+
+/*
+ * Download buffer location and length (0xFD01).
+ */
+struct wi_ltv_dnld_buf {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_buf_pg; /* page addr of intermediate dl buf*/
+	u_int16_t		wi_buf_off; /* offset of idb */
+	u_int16_t		wi_buf_len; /* len of idb */
+};
+
+/*
+ * Mem sizes (0xFD02).
+ */
+struct wi_ltv_memsz {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_mem_ram;
+	u_int16_t		wi_mem_nvram;
+};
+
+/*
+ * NIC Identification (0xFD0B, 0xFD20)
+ */
+struct wi_ltv_ver {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_ver[4];
+};
+
+/* define card ident */
+#define	WI_NIC_LUCENT_ID	0x0001
+#define	WI_NIC_LUCENT_STR	"Lucent Technologies, WaveLAN/IEEE"
+
+#define	WI_NIC_SONY_ID		0x0002
+#define	WI_NIC_SONY_STR		"Sony WaveLAN/IEEE"
+
+#define	WI_NIC_LUCENT_EMB_ID	0x0005
+#define	WI_NIC_LUCENT_EMB_STR	"Lucent Embedded WaveLAN/IEEE"
+
+/*
+ * List of intended regulatory domains (0xFD11).
+ */
+struct wi_ltv_domains {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_num_dom;
+	u_int8_t		wi_domains[10];
+};
+
+/*
+ * CIS struct (0xFD13).
+ */
+struct wi_ltv_cis {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_cis[240];
+};
+
+/*
+ * Communications quality (0xFD43).
+ */
+struct wi_ltv_commqual {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_coms_qual;
+	u_int16_t		wi_sig_lvl;
+	u_int16_t		wi_noise_lvl;
+};
+
+/*
+ * Actual system scale thresholds (0xFC06, 0xFD46).
+ */
+struct wi_ltv_scalethresh {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_energy_detect;
+	u_int16_t		wi_carrier_detect;
+	u_int16_t		wi_defer;
+	u_int16_t		wi_cell_search;
+	u_int16_t		wi_out_of_range;
+	u_int16_t		wi_delta_snr;
+};
+
+/*
+ * PCF info struct (0xFD87).
+ */
+struct wi_ltv_pcf {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_energy_detect;
+	u_int16_t		wi_carrier_detect;
+	u_int16_t		wi_defer;
+	u_int16_t		wi_cell_search;
+	u_int16_t		wi_range;
+};
+
+/*
+ * Connection control characteristics. (0xFC00)
+ * 0 == IBSS (802.11 compliant mode) (Only PRISM2)
+ * 1 == Basic Service Set (BSS)
+ * 2 == Wireless Distribudion System (WDS)
+ * 3 == Pseudo IBSS 
+ *	(Only PRISM2; not 802.11 compliant mode, testing use only)
+ * 6 == HOST AP (Only PRISM2)
+ */
+#define WI_PORTTYPE_BSS		0x1
+#define WI_PORTTYPE_WDS		0x2
+#define WI_PORTTYPE_ADHOC	0x3
+#define WI_PORTTYPE_IBSS	0x4
+#define WI_PORTTYPE_HOSTAP	0x6
+
+/*
+ * Mac addresses. (0xFC01, 0xFC08)
+ */
+struct wi_ltv_macaddr {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_mac_addr[3];
+};
+
+/*
+ * Station set identification (SSID). (0xFC02, 0xFC04)
+ */
+struct wi_ltv_ssid {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_id[17];
+};
+
+/*
+ * Set our station name. (0xFC0E)
+ */
+struct wi_ltv_nodename {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	u_int16_t		wi_nodename[17];
+};
+
+/*
+ * Multicast addresses to be put in filter. We're
+ * allowed up to 16 addresses in the filter. (0xFC80)
+ */
+struct wi_ltv_mcast {
+	u_int16_t		wi_len;
+	u_int16_t		wi_type;
+	struct ether_addr	wi_mcast[16];
+};
+
+/*
+ * supported rates. (0xFCB4)
+ */
+#define WI_SUPPRATES_1M		0x0001
+#define WI_SUPPRATES_2M		0x0002
+#define WI_SUPPRATES_5M		0x0004
+#define WI_SUPPRATES_11M	0x0008
+#define	WI_RATES_BITS	"\20\0011M\0022M\0035.5M\00411M"
+
+/*
+ * Information frame types.
+ */
+#define WI_INFO_NOTIFY		0xF000	/* Handover address */
+#define WI_INFO_COUNTERS	0xF100	/* Statistics counters */
+#define WI_INFO_SCAN_RESULTS	0xF101	/* Scan results */
+#define WI_INFO_LINK_STAT	0xF200	/* Link status */
+#define WI_INFO_ASSOC_STAT	0xF201	/* Association status */
+
+/*
+ * Hermes transmit/receive frame structure
+ */
+struct wi_frame {
+	u_int16_t		wi_status;	/* 0x00 */
+	u_int16_t		wi_rsvd0;	/* 0x02 */
+	u_int16_t		wi_rsvd1;	/* 0x04 */
+	u_int16_t		wi_q_info;	/* 0x06 */
+	u_int16_t		wi_rsvd2;	/* 0x08 */
+	u_int8_t		wi_tx_rtry;	/* 0x0A */
+	u_int8_t		wi_tx_rate;	/* 0x0B */
+	u_int16_t		wi_tx_ctl;	/* 0x0C */
+	u_int16_t		wi_frame_ctl;	/* 0x0E */
+	u_int16_t		wi_id;		/* 0x10 */
+	u_int8_t		wi_addr1[6];	/* 0x12 */
+	u_int8_t		wi_addr2[6];	/* 0x18 */
+	u_int8_t		wi_addr3[6];	/* 0x1E */
+	u_int16_t		wi_seq_ctl;	/* 0x24 */
+	u_int8_t		wi_addr4[6];	/* 0x26 */
+	u_int16_t		wi_dat_len;	/* 0x2C */
+	u_int8_t		wi_dst_addr[6];	/* 0x2E */
+	u_int8_t		wi_src_addr[6];	/* 0x34 */
+	u_int16_t		wi_len;		/* 0x3A */
+	u_int16_t		wi_dat[3];	/* 0x3C */ /* SNAP header */
+	u_int16_t		wi_type;	/* 0x42 */
+};
+
+#define WI_802_3_OFFSET		0x2E
+#define WI_802_11_OFFSET	0x44
+#define WI_802_11_OFFSET_RAW	0x3C
+#define WI_802_11_OFFSET_HDR    0x0E
+
+#define WI_STAT_BADCRC		0x0001
+#define WI_STAT_UNDECRYPTABLE	0x0002
+#define WI_STAT_ERRSTAT		0x0003
+#define WI_STAT_MAC_PORT	0x0700
+#define WI_STAT_1042		0x2000	/* RFC1042 encoded */
+#define WI_STAT_TUNNEL		0x4000	/* Bridge-tunnel encoded */
+#define WI_STAT_WMP_MSG		0x6000	/* WaveLAN-II management protocol */
+#define WI_STAT_MGMT		0x8000	/* 802.11b management frames */
+#define WI_RXSTAT_MSG_TYPE	0xE000
+
+#define WI_ENC_TX_802_3		0x00
+#define WI_ENC_TX_802_11	0x11
+#define WI_ENC_TX_MGMT		0x08
+#define WI_ENC_TX_E_II		0x0E
+
+#define WI_ENC_TX_1042		0x00
+#define WI_ENC_TX_TUNNEL	0xF8
+
+#define WI_TXCNTL_MACPORT	0x00FF
+#define WI_TXCNTL_STRUCTTYPE	0xFF00
+#define WI_TXCNTL_TX_EX		0x0004
+#define WI_TXCNTL_TX_OK		0x0002
+#define WI_TXCNTL_NOCRYPT	0x0080
+
+/*
+ * SNAP (sub-network access protocol) constants for transmission
+ * of IP datagrams over IEEE 802 networks, taken from RFC1042.
+ * We need these for the LLC/SNAP header fields in the TX/RX frame
+ * structure.
+ */
+#define WI_SNAP_K1		0xaa	/* assigned global SAP for SNAP */
+#define WI_SNAP_K2		0x00
+#define WI_SNAP_CONTROL		0x03	/* unnumbered information format */
+#define WI_SNAP_WORD0		(WI_SNAP_K1 | (WI_SNAP_K1 << 8))
+#define WI_SNAP_WORD1		(WI_SNAP_K2 | (WI_SNAP_CONTROL << 8))
+#define WI_SNAPHDR_LEN		0x6
+#define WI_FCS_LEN		0x4
diff --git a/sys/dev/owi/if_wivar.h b/sys/dev/owi/if_wivar.h
new file mode 100644
index 0000000..723f2ca
--- /dev/null
+++ b/sys/dev/owi/if_wivar.h
@@ -0,0 +1,186 @@
+/*
+ * Copyright (c) 2002
+ *	M Warner Losh <imp@freebsd.org>.  All rights reserved.
+ * Copyright (c) 1997, 1998, 1999
+ *	Bill Paul <wpaul@ctr.columbia.edu>.  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 OR THE VOICES IN HIS HEAD
+ * 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$
+ */
+
+#define WICACHE			/* turn on signal strength cache code */  
+#define	MAXWICACHE	10
+
+/*
+ * Encryption controls. We can enable or disable encryption as
+ * well as specify up to 4 encryption keys. We can also specify
+ * which of the four keys will be used for transmit encryption.
+ */
+#define WI_RID_ENCRYPTION	0xFC20
+#define WI_RID_AUTHTYPE		0xFC21
+#define WI_RID_DEFLT_CRYPT_KEYS	0xFCB0
+#define WI_RID_TX_CRYPT_KEY	0xFCB1
+#define WI_RID_WEP_AVAIL	0xFD4F
+#define WI_RID_P2_TX_CRYPT_KEY	0xFC23
+#define WI_RID_P2_CRYPT_KEY0	0xFC24
+#define WI_RID_P2_CRYPT_KEY1	0xFC25
+#define WI_RID_MICROWAVE_OVEN	0xFC25
+#define WI_RID_P2_CRYPT_KEY2	0xFC26
+#define WI_RID_P2_CRYPT_KEY3	0xFC27
+#define WI_RID_P2_ENCRYPTION	0xFC28
+#define WI_RID_ROAMING_MODE	0xFC2D
+#define WI_RID_CUR_TX_RATE	0xFD44 /* current TX rate */
+
+struct wi_softc	{
+	struct arpcom		arpcom;
+	struct ifmedia		ifmedia;
+	device_t		dev;
+	int			wi_unit;
+	struct resource *	local;
+	int					local_rid;
+	struct resource *	iobase;
+	int					iobase_rid;
+	struct resource *	irq;
+	int					irq_rid;
+	struct resource *	mem;
+	int					mem_rid;
+	bus_space_handle_t	wi_localhandle;
+	bus_space_tag_t		wi_localtag;
+	bus_space_handle_t	wi_bhandle;
+	bus_space_tag_t		wi_btag;
+	bus_space_handle_t	wi_bmemhandle;
+	bus_space_tag_t		wi_bmemtag;
+	void *			wi_intrhand;
+	int			sc_firmware_type;
+#define WI_NOTYPE	0
+#define	WI_LUCENT	1
+	int			sc_pri_firmware_ver;	/* Primary firmware */
+	int			sc_sta_firmware_ver;	/* Station firmware */
+	int			sc_enabled;
+	int			wi_io_addr;
+	int			wi_tx_data_id;
+	int			wi_tx_mgmt_id;
+	int			wi_gone;
+	int			wi_flags;
+#define WI_FLAGS_ATTACHED		0x01
+#define WI_FLAGS_INITIALIZED		0x02
+#define WI_FLAGS_HAS_WEP		0x04
+#define WI_FLAGS_HAS_IBSS		0x08
+#define WI_FLAGS_HAS_CREATE_IBSS	0x10
+#define WI_FLAGS_HAS_MOR		0x20
+#define WI_FLAGS_HAS_ROAMING		0x30
+	int			wi_if_flags;
+	u_int16_t		wi_procframe;
+	u_int16_t		wi_ptype;
+	u_int16_t		wi_portnum;
+	u_int16_t		wi_max_data_len;
+	u_int16_t		wi_rts_thresh;
+	u_int16_t		wi_ap_density;
+	u_int16_t		wi_tx_rate;
+	u_int16_t		wi_create_ibss;
+	u_int16_t		wi_channel;
+	u_int16_t		wi_pm_enabled;
+	u_int16_t		wi_mor_enabled;
+	u_int16_t		wi_max_sleep;
+	u_int16_t		wi_supprates;
+	u_int16_t		wi_authtype;
+	u_int16_t		wi_roaming;
+	char			wi_node_name[32];
+	char			wi_net_name[32];
+	char			wi_ibss_name[32];
+	u_int8_t		wi_txbuf[1596];
+	u_int8_t		wi_scanbuf[1596];
+	int			wi_scanbuf_len;
+	struct wi_counters	wi_stats;
+	int			wi_has_wep;
+	int			wi_use_wep;
+	int			wi_authmode;
+	int			wi_tx_key;
+	struct wi_ltv_keys	wi_keys;
+#ifdef WICACHE
+	int			wi_sigitems;
+	struct wi_sigcache	wi_sigcache[MAXWICACHE];
+	int			wi_nextitem;
+#endif
+	u_int32_t		wi_icv;
+	int			wi_icv_flag;
+	int			wi_ibss_port;
+	struct callout_handle	wi_stat_ch;
+#if __FreeBSD_version >= 500000
+	struct mtx		wi_mtx;
+#endif
+	int			wi_nic_type;
+	int			wi_bus_type;	/* Bus attachment type */
+	struct {
+		u_int16_t               wi_sleep;
+		u_int16_t               wi_delaysupp;
+		u_int16_t               wi_txsupp;
+		u_int16_t               wi_monitor;
+		u_int16_t               wi_ledtest;
+		u_int16_t               wi_ledtest_param0;
+		u_int16_t               wi_ledtest_param1;
+		u_int16_t               wi_conttx;
+		u_int16_t               wi_conttx_param0;
+		u_int16_t               wi_contrx;
+		u_int16_t               wi_sigstate;
+		u_int16_t               wi_sigstate_param0;
+		u_int16_t               wi_confbits;
+		u_int16_t               wi_confbits_param0;
+	} wi_debug;
+
+};
+
+struct wi_card_ident {
+	u_int16_t	card_id;
+	char		*card_name;
+	u_int8_t	firm_type;
+};
+
+#if __FreeBSD_version < 500000
+/*
+ * Various compat hacks/kludges
+ */
+#define le16toh(x) (x)
+#define htole16(x) (x)
+#define ifaddr_byindex(idx) ifnet_addrs[(idx) - 1];
+#define	WI_LOCK(_sc, _s)	s = splimp()
+#define	WI_UNLOCK(_sc, _s)	splx(s)
+#else
+#define	WI_LOCK(_sc, _s) _s = 1
+#define	WI_UNLOCK(_sc, _s)
+#endif
+
+int owi_generic_attach(device_t);
+int owi_generic_detach(device_t);
+void owi_shutdown(device_t);
+int owi_alloc(device_t, int);
+void owi_free(device_t);
+void owi_stop(struct wi_softc *);
+void owi_get_id(struct wi_softc *);
+extern devclass_t owi_devclass;
diff --git a/sys/modules/owi/Makefile b/sys/modules/owi/Makefile
new file mode 100644
index 0000000..3ffb1b0
--- /dev/null
+++ b/sys/modules/owi/Makefile
@@ -0,0 +1,12 @@
+# $FreeBSD$
+
+.PATH: ${.CURDIR}/../../dev/owi
+
+KMOD=	if_owi
+SRCS=	opt_wi.h if_owi.c if_owi_pccard.c \
+	card_if.h device_if.h bus_if.h pci_if.h
+
+opt_wi.h:
+	touch ${.TARGET}
+
+.include <bsd.kmod.mk>