--- /dev/null
+/* $OpenBSD: if_ray.c,v 1.1 2000/03/22 04:40:57 mickey Exp $ */
+/* $NetBSD: if_ray.c,v 1.16 2000/03/10 05:47:42 onoe Exp $ */
+
+/*
+ * Copyright (c) 2000 Christian E. Hopps
+ * 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. 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 THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Driver for the Raylink (Raytheon) / WebGear IEEE 802.11 (FH) WLANs
+ *
+ * 2-way communication with the card is through command structures
+ * stored in shared ram. To communicate with the card a free
+ * command structure is filled in and then the card is interrupted.
+ * The card does the same with a different set of command structures.
+ * Only one command can be processed at a time. This is indicated
+ * by the interrupt having not been cleared since it was last set.
+ * The bit is cleared when the command has been processed (although
+ * it may not yet be complete).
+ *
+ * This driver was only tested with the Aviator 2.4 wireless
+ * The author didn't have the pro version or raylink to test
+ * with.
+ *
+ * N.B. Its unclear yet whether the Aviator 2.4 cards interoperate
+ * with other 802.11 FH 2Mbps cards, since this was also untested.
+ * Given the nature of the buggy build 4 firmware there may be problems.
+ */
+
+#ifdef __NetBSD__
+#include "opt_inet.h"
+#endif
+#include "bpfilter.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/mbuf.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <sys/errno.h>
+#include <sys/device.h>
+#include <sys/kernel.h>
+#include <sys/proc.h>
+
+#include <net/if.h>
+#include <net/if_dl.h>
+#ifdef __NetBSD__
+#include <net/if_ether.h>
+#endif
+#include <net/if_media.h>
+#include <net/if_llc.h>
+
+#ifdef INET
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#ifdef __NetBSD__
+#include <netinet/if_inarp.h>
+#elif defined(__OpenBSD__)
+#include <netinet/if_ether.h>
+#endif
+#endif
+
+#include <net/if_ieee80211.h> /* here, since ETHER_ADDR_LEN is in netinet */
+
+#if NBPFILTER > 0
+#include <net/bpf.h>
+#include <net/bpfdesc.h>
+#endif
+
+#include <machine/cpu.h>
+#include <machine/bus.h>
+#include <machine/intr.h>
+
+#include <dev/pcmcia/pcmciareg.h>
+#include <dev/pcmcia/pcmciavar.h>
+#include <dev/pcmcia/pcmciadevs.h>
+
+#include <dev/pcmcia/if_rayreg.h>
+
+#ifndef PCMCIA_WIDTH_MEM8
+#define PCMCIA_WIDTH_MEM8 0
+#endif
+
+#ifndef offsetof
+#define offsetof(type, member) ((size_t)(&((type *)0)->member))
+#endif
+
+#ifndef ETHER_CRC_LEN
+#define ETHER_CRC_LEN 4
+#endif
+
+#ifndef ETHER_MAX_LEN
+#define ETHER_MAX_LEN 1518
+#endif
+
+#define RAY_USE_AMEM 0
+
+/* #define RAY_DEBUG */
+
+#ifndef RAY_PID_COUNTRY_CODE_DEFAULT
+#define RAY_PID_COUNTRY_CODE_DEFAULT RAY_PID_COUNTRY_CODE_USA
+#endif
+
+/* amount of time to poll for non-return of certain command status */
+#ifndef RAY_CHECK_CCS_TIMEOUT
+#define RAY_CHECK_CCS_TIMEOUT (hz / 2)
+#endif
+
+/* ammount of time to consider start/join failed */
+#ifndef RAY_START_TIMEOUT
+#define RAY_START_TIMEOUT (90 * hz)
+#endif
+
+/*
+ * if a command cannot execute because device is busy try later
+ * this is also done after interrupts and other command timeouts
+ * so we can use a large value safely.
+ */
+#ifndef RAY_CHECK_SCHED_TIMEOUT
+#define RAY_CHECK_SCHED_TIMEOUT (hz) /* XXX 5 */
+#endif
+
+#ifndef RAY_MODE_DEFAULT
+#define RAY_MODE_DEFAULT SC_MODE_ADHOC
+#endif
+
+#ifndef RAY_DEF_NWID
+#define RAY_DEF_NWID "NETWORK_NAME"
+#endif
+
+/*
+ * the number of times the HW is reset in 30s before disabling
+ * this is needed becuase resets take ~2s and currently pcmcia
+ * spins for the reset
+ */
+#ifndef RAY_MAX_RESETS
+#define RAY_MAX_RESETS 3
+#endif
+
+/*
+ * Types
+ */
+
+struct ray_softc {
+ struct device sc_dev;
+#ifdef __NetBSD__
+ struct ethercom sc_ec;
+#elif defined(__OpenBSD__)
+ struct arpcom sc_ec;
+#endif
+ struct ifmedia sc_media;
+
+ struct pcmcia_function *sc_pf;
+ struct pcmcia_mem_handle sc_mem;
+ int sc_window;
+#if RAY_USE_AMEM
+ struct pcmcia_mem_handle sc_amem;
+ int sc_awindow;
+#endif
+ void *sc_ih;
+ void *sc_sdhook;
+ void *sc_pwrhook;
+ int sc_resumeinit;
+ int sc_resetloop;
+
+ struct ray_ecf_startup sc_ecf_startup;
+ struct ray_startup_params_head sc_startup;
+ union {
+ struct ray_startup_params_tail_5 u_params_5;
+ struct ray_startup_params_tail_4 u_params_4;
+ } sc_u;
+
+ u_int8_t sc_ccsinuse[64]; /* ccs in use -- not for tx */
+ u_int sc_txfree; /* a free count for efficiency */
+
+ u_int8_t sc_bssid[ETHER_ADDR_LEN]; /* current net values */
+ u_int8_t sc_cnwid[IEEE80211_NWID_LEN]; /* last nwid */
+ u_int8_t sc_dnwid[IEEE80211_NWID_LEN]; /* desired nwid */
+ u_int8_t sc_omode; /* old operating mode SC_MODE_xx */
+ u_int8_t sc_mode; /* current operating mode SC_MODE_xx */
+ u_int8_t sc_countrycode; /* current country code */
+ u_int8_t sc_dcountrycode; /* desired country code */
+ int sc_havenet; /* true if we have aquired a network */
+ bus_size_t sc_txpad; /* tib size plus "phy" size */
+ u_int8_t sc_deftxrate; /* default transfer rate */
+ u_int8_t sc_encrypt;
+
+
+ int sc_promisc; /* current set value */
+ int sc_running; /* things we are doing */
+ int sc_scheduled; /* things we need to do */
+ int sc_timoneed; /* set if timeout is sched */
+ int sc_timocheck; /* set if timeout is sched */
+ bus_size_t sc_startccs; /* ccs of start/join */
+ u_int sc_startcmd; /* cmd (start | join) */
+
+ int sc_checkcounters;
+ u_int64_t sc_rxoverflow;
+ u_int64_t sc_rxcksum;
+ u_int64_t sc_rxhcksum;
+ u_int8_t sc_rxnoise;
+
+ /* use to return values to the user */
+ struct ray_param_req *sc_repreq;
+ struct ray_param_req *sc_updreq;
+#ifdef RAY_DO_SIGLEV
+ struct ray_siglev sc_siglevs[RAY_NSIGLEVRECS];
+#endif
+};
+#define sc_memt sc_mem.memt
+#define sc_memh sc_mem.memh
+#define sc_ccrt sc_pf->pf_ccrt
+#define sc_ccrh sc_pf->pf_ccrh
+#define sc_startup_4 sc_u.u_params_4
+#define sc_startup_5 sc_u.u_params_5
+#define sc_version sc_ecf_startup.e_fw_build_string
+#define sc_tibsize sc_ecf_startup.e_tib_size
+#ifdef __NetBSD__
+#define sc_if sc_ec.ec_if
+#elif defined(__OpenBSD__)
+#define sc_if sc_ec.ac_if
+#define ec_multicnt ac_multicnt
+#define memmove memcpy /* XXX */
+#endif
+#define sc_xname sc_dev.dv_xname
+
+/* modes of operation */
+#define SC_MODE_ADHOC 0 /* ad-hoc mode */
+#define SC_MODE_INFRA 1 /* infrastructure mode */
+
+/* commands -- priority given to LSB */
+#define SCP_FIRST 0x0001
+#define SCP_UPDATESUBCMD 0x0001
+#define SCP_STARTASSOC 0x0002
+#define SCP_REPORTPARAMS 0x0004
+#define SCP_IFSTART 0x0008
+
+/* update sub commands -- issues are serialized priority to LSB */
+#define SCP_UPD_FIRST 0x0100
+#define SCP_UPD_STARTUP 0x0100
+#define SCP_UPD_STARTJOIN 0x0200
+#define SCP_UPD_PROMISC 0x0400
+#define SCP_UPD_MCAST 0x0800
+#define SCP_UPD_UPDATEPARAMS 0x1000
+#define SCP_UPD_SHIFT 8
+#define SCP_UPD_MASK 0xff00
+
+/* these command (a subset of the update set) require timeout checking */
+#define SCP_TIMOCHECK_CMD_MASK \
+ (SCP_UPD_UPDATEPARAMS | SCP_UPD_STARTUP | SCP_UPD_MCAST | \
+ SCP_UPD_PROMISC)
+
+
+#define IFM_ADHOC \
+ IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, IFM_IEEE80211_ADHOC, 0)
+#define IFM_INFRA \
+ IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_FH2, 0, 0)
+
+typedef void (*ray_cmd_func_t)(struct ray_softc *);
+
+#define SC_BUILD_5 0x5
+#define SC_BUILD_4 0x55
+
+
+int ray_alloc_ccs __P((struct ray_softc *, bus_size_t *, u_int, u_int));
+bus_size_t ray_fill_in_tx_ccs __P((struct ray_softc *, size_t, u_int, u_int));
+void ray_attach __P((struct device *, struct device *, void *));
+ray_cmd_func_t ray_ccs_done __P((struct ray_softc *, bus_size_t));
+void ray_check_ccs __P((void *));
+void ray_check_scheduled __P((void *));
+void ray_cmd_cancel __P((struct ray_softc *, int));
+void ray_cmd_schedule __P((struct ray_softc *, int));
+void ray_cmd_ran __P((struct ray_softc *, int));
+int ray_cmd_is_running __P((struct ray_softc *, int));
+int ray_cmd_is_scheduled __P((struct ray_softc *, int));
+void ray_cmd_done __P((struct ray_softc *, int));
+int ray_detach __P((struct device *, int));
+int ray_activate __P((struct device *, enum devact));
+void ray_disable __P((struct ray_softc *));
+void ray_download_params __P((struct ray_softc *));
+int ray_enable __P((struct ray_softc *));
+u_int ray_find_free_tx_ccs __P((struct ray_softc *, u_int));
+u_int8_t ray_free_ccs __P((struct ray_softc *, bus_size_t));
+void ray_free_ccs_chain __P((struct ray_softc *, u_int));
+void ray_if_start __P((struct ifnet *));
+int ray_init __P((struct ray_softc *));
+int ray_intr __P((void *));
+void ray_intr_start __P((struct ray_softc *));
+int ray_ioctl __P((struct ifnet *, u_long, caddr_t));
+int ray_issue_cmd __P((struct ray_softc *, bus_size_t, u_int));
+int ray_match __P((struct device *, struct cfdata *, void *));
+int ray_media_change __P((struct ifnet *));
+void ray_media_status __P((struct ifnet *, struct ifmediareq *));
+void ray_power __P((int, void *));
+ray_cmd_func_t ray_rccs_intr __P((struct ray_softc *, bus_size_t));
+void ray_read_region __P((struct ray_softc *, bus_size_t,void *,size_t));
+void ray_recv __P((struct ray_softc *, bus_size_t));
+void ray_report_params __P((struct ray_softc *));
+void ray_reset __P((struct ray_softc *));
+void ray_reset_resetloop __P((void *));
+void ray_set_pending __P((struct ray_softc *, u_int));
+void ray_shutdown __P((void *));
+int ray_simple_cmd __P((struct ray_softc *, u_int, u_int));
+void ray_start_assoc __P((struct ray_softc *));
+void ray_start_join_net __P((struct ray_softc *));
+ray_cmd_func_t ray_start_join_net_done __P((struct ray_softc *,
+ u_int, bus_size_t, u_int));
+void ray_start_join_timo __P((void *));
+void ray_stop __P((struct ray_softc *));
+void ray_update_error_counters __P((struct ray_softc *));
+void ray_update_mcast __P((struct ray_softc *));
+ray_cmd_func_t ray_update_params_done __P((struct ray_softc *,
+ bus_size_t, u_int));
+void ray_update_params __P((struct ray_softc *));
+void ray_update_promisc __P((struct ray_softc *));
+void ray_update_subcmd __P((struct ray_softc *));
+int ray_user_report_params __P((struct ray_softc *,
+ struct ray_param_req *));
+int ray_user_update_params __P((struct ray_softc *,
+ struct ray_param_req *));
+void ray_write_region __P((struct ray_softc *,bus_size_t,void *,size_t));
+
+#ifdef RAY_DO_SIGLEV
+void ray_update_siglev __P((struct ray_softc *, u_int8_t *, u_int8_t));
+#endif
+
+#ifdef RAY_DEBUG
+int ray_debug = 1;
+int ray_debug_xmit_sum = 1;
+int ray_debug_dump_desc = 1;
+int ray_debug_dump_rx = 1;
+int ray_debug_dump_tx = 1;
+struct timeval rtv, tv1, tv2, *ttp, *ltp;
+#define RAY_DPRINTF(x) do { if (ray_debug) { \
+ struct timeval *tmp; \
+ microtime(ttp); \
+ timersub(ttp, ltp, &rtv); \
+ tmp = ttp; ttp = ltp; ltp = tmp; \
+ printf("%ld:%ld %ld:%06ld: ", ttp->tv_sec, ttp->tv_usec, rtv.tv_sec, rtv.tv_usec); \
+ printf x ; \
+ } } while (0)
+#define RAY_DPRINTF_XMIT(x) do { if (ray_debug_xmit_sum) { \
+ struct timeval *tmp; \
+ microtime(ttp); \
+ timersub(ttp, ltp, &rtv); \
+ tmp = ttp; ttp = ltp; ltp = tmp; \
+ printf("%ld:%ld %ld:%06ld: ", ttp->tv_sec, ttp->tv_usec, rtv.tv_sec, rtv.tv_usec); \
+ printf x ; \
+ } } while (0)
+
+#define HEXDF_NOCOMPRESS 0x1
+#define HEXDF_NOOFFSET 0x2
+#define HEXDF_NOASCII 0x4
+void hexdump(const u_int8_t *, int, int, int, int);
+void ray_dump_mbuf __P((struct ray_softc *, struct mbuf *));
+
+#else /* !RAY_DEBUG */
+
+#define RAY_DPRINTF(x)
+#define RAY_DPRINTF_XMIT(x)
+
+#endif /* !RAY_DEBUG */
+
+/*
+ * macros for writing to various regions in the mapped memory space
+ */
+
+#if RAY_USE_AMEM
+/* read and write the registers in the CCR (attribute) space */
+#define REG_WRITE(sc, off, val) \
+ bus_space_write_1((sc)->sc_amem.memt, (sc)->sc_amem.memh, (off), (val))
+
+#define REG_READ(sc, off) \
+ bus_space_read_1((sc)->sc_amem.memt, (sc)->sc_amem.memh, (off))
+#else
+ /* use already mapped ccrt */
+#define REG_WRITE(sc, off, val) \
+ bus_space_write_1((sc)->sc_ccrt, (sc)->sc_ccrh, (off), (val))
+
+#define REG_READ(sc, off) \
+ bus_space_read_1((sc)->sc_ccrt, (sc)->sc_ccrh, (off))
+#endif
+
+#define SRAM_READ_1(sc, off) \
+ ((u_int8_t)bus_space_read_1((sc)->sc_memt, (sc)->sc_memh, (off)))
+
+#define SRAM_READ_FIELD_1(sc, off, s, f) \
+ SRAM_READ_1(sc, (off) + offsetof(struct s, f))
+
+#define SRAM_READ_FIELD_2(sc, off, s, f) \
+ ((((u_int16_t)SRAM_READ_1(sc, (off) + offsetof(struct s, f)) << 8) \
+ |(SRAM_READ_1(sc, (off) + 1 + offsetof(struct s, f)))))
+
+#define SRAM_READ_FIELD_N(sc, off, s, f, p, n) \
+ ray_read_region(sc, (off) + offsetof(struct s, f), (p), (n))
+
+#define SRAM_WRITE_1(sc, off, val) \
+ bus_space_write_1((sc)->sc_memt, (sc)->sc_memh, (off), (val))
+
+#define SRAM_WRITE_FIELD_1(sc, off, s, f, v) \
+ SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (v))
+
+#define SRAM_WRITE_FIELD_2(sc, off, s, f, v) do { \
+ SRAM_WRITE_1(sc, (off) + offsetof(struct s, f), (((v) >> 8 ) & 0xff)); \
+ SRAM_WRITE_1(sc, (off) + 1 + offsetof(struct s, f), ((v) & 0xff)); \
+ } while (0)
+
+#define SRAM_WRITE_FIELD_N(sc, off, s, f, p, n) \
+ ray_write_region(sc, (off) + offsetof(struct s, f), (p), (n))
+
+/*
+ * Macros of general usefulness
+ */
+
+#define M_PULLUP(m, s) do { \
+ if ((m)->m_len < (s)) \
+ (m) = m_pullup((m), (s)); \
+ } while (0)
+
+#define RAY_ECF_READY(sc) (!(REG_READ(sc, RAY_ECFIR) & RAY_ECSIR_IRQ))
+#define RAY_ECF_START_CMD(sc) REG_WRITE(sc, RAY_ECFIR, RAY_ECSIR_IRQ)
+#define RAY_GET_INDEX(ccs) (((ccs) - RAY_CCS_BASE) / RAY_CCS_SIZE)
+#define RAY_GET_CCS(i) (RAY_CCS_BASE + (i) * RAY_CCS_SIZE)
+
+/*
+ * Globals
+ */
+
+static const u_int8_t llc_snapid[6] = { LLC_SNAP_LSAP, LLC_SNAP_LSAP, LLC_UI };
+
+/* based on bit index in SCP_xx */
+static const ray_cmd_func_t ray_cmdtab[] = {
+ ray_update_subcmd, /* SCP_UPDATESUBCMD */
+ ray_start_assoc, /* SCP_STARTASSOC */
+ ray_report_params, /* SCP_REPORTPARAMS */
+ ray_intr_start /* SCP_IFSTART */
+};
+static const int ray_ncmdtab = sizeof(ray_cmdtab) / sizeof(*ray_cmdtab);
+
+static const ray_cmd_func_t ray_subcmdtab[] = {
+ ray_download_params, /* SCP_UPD_STARTUP */
+ ray_start_join_net, /* SCP_UPD_STARTJOIN */
+ ray_update_promisc, /* SCP_UPD_PROMISC */
+ ray_update_mcast, /* SCP_UPD_MCAST */
+ ray_update_params /* SCP_UPD_UPDATEPARAMS */
+};
+static const int ray_nsubcmdtab = sizeof(ray_subcmdtab) / sizeof(*ray_subcmdtab);
+
+#ifdef __OpenBSD__
+struct cfdriver ray_cd = {
+ NULL, "ray", DV_IFNET
+};
+#endif
+
+/* autoconf information */
+struct cfattach ray_ca = {
+ sizeof(struct ray_softc), (cfmatch_t)ray_match, ray_attach, ray_detach,
+ ray_activate
+};
+
+
+/*
+ * Config Routines
+ */
+
+int
+ray_match(parent, match, aux)
+ struct device *parent;
+ struct cfdata *match;
+ void *aux;
+{
+ struct pcmcia_attach_args *pa = aux;
+
+#ifdef RAY_DEBUG
+ if (!ltp) {
+ /* initialize timestamp XXX */
+ ttp = &tv1;
+ ltp = &tv2;
+ microtime(ltp);
+ }
+#endif
+ return (pa->manufacturer == PCMCIA_VENDOR_RAYTHEON
+ && pa->product == PCMCIA_PRODUCT_RAYTHEON_WLAN);
+}
+
+
+void
+ray_attach(parent, self, aux)
+ struct device *parent, *self;
+ void *aux;
+{
+ struct ray_ecf_startup *ep;
+ struct pcmcia_attach_args *pa;
+ struct ray_softc *sc;
+ struct ifnet *ifp;
+ bus_addr_t memoff;
+#ifdef __NetBSD__
+ char devinfo[256];
+#endif
+
+ pa = aux;
+ sc = (struct ray_softc *)self;
+ sc->sc_pf = pa->pf;
+ ifp = &sc->sc_if;
+ sc->sc_window = -1;
+#if RAY_USE_AMEM
+ sc->sc_awindow = -1;
+#endif
+
+#ifdef __NetBSD__
+ /* Print out what we are */
+ pcmcia_devinfo(&pa->pf->sc->card, 0, devinfo, sizeof devinfo);
+ printf(": %s\n", devinfo);
+#elif defined(__OpenBSD__)
+ printf("\n");
+#endif
+
+ /* enable the card */
+ pcmcia_function_init(sc->sc_pf, sc->sc_pf->cfe_head.sqh_first);
+ if (pcmcia_function_enable(sc->sc_pf)) {
+ printf(": failed to enable the card");
+ return;
+ }
+
+ /*
+ * map in the memory
+ */
+ if (pcmcia_mem_alloc(sc->sc_pf, RAY_SRAM_MEM_SIZE, &sc->sc_mem)) {
+ printf(": can\'t alloc shared memory\n");
+ goto fail;
+ }
+
+ if (pcmcia_mem_map(sc->sc_pf, PCMCIA_WIDTH_MEM8|PCMCIA_MEM_COMMON,
+ RAY_SRAM_MEM_BASE, RAY_SRAM_MEM_SIZE, &sc->sc_mem, &memoff,
+ &sc->sc_window)) {
+ printf(": can\'t map shared memory\n");
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_mem);
+ goto fail;
+ }
+
+#if RAY_USE_AMEM
+ /* use the already mapped ccrt in our pf */
+ /*
+ * map in the memory
+ */
+ if (pcmcia_mem_alloc(sc->sc_pf, 0x1000, &sc->sc_amem)) {
+ printf(": can\'t alloc attr memory\n");
+ goto fail;
+ }
+
+ if (pcmcia_mem_map(sc->sc_pf, PCMCIA_MEM_ATTR, 0,
+ 0x1000, &sc->sc_amem, &memoff, &sc->sc_awindow)) {
+ printf(": can\'t map attr memory\n");
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_amem);
+ goto fail;
+ }
+#endif
+ /* get startup results */
+ ep = &sc->sc_ecf_startup;
+ ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep,
+ sizeof(sc->sc_ecf_startup));
+
+ /* check to see that card initialized properly */
+ if (ep->e_status != RAY_ECFS_CARD_OK) {
+ printf(": card failed self test: status %d\n",
+ sc->sc_ecf_startup.e_status);
+ goto fail;
+ }
+
+ /* check firmware version */
+ if (sc->sc_version != SC_BUILD_4 && sc->sc_version != SC_BUILD_5) {
+ printf(": unsupported firmware version %d\n",
+ ep->e_fw_build_string);
+ goto fail;
+ }
+
+ /* clear any interrupt if present */
+ REG_WRITE(sc, RAY_HCSIR, 0);
+
+ /*
+ * set the parameters that will survive stop/init
+ */
+ memset(sc->sc_cnwid, 0, sizeof(sc->sc_cnwid));
+ memset(sc->sc_dnwid, 0, sizeof(sc->sc_dnwid));
+ strncpy(sc->sc_dnwid, RAY_DEF_NWID, sizeof(sc->sc_dnwid));
+ strncpy(sc->sc_cnwid, RAY_DEF_NWID, sizeof(sc->sc_dnwid));
+ sc->sc_omode = sc->sc_mode = RAY_MODE_DEFAULT;
+ sc->sc_countrycode = sc->sc_dcountrycode = RAY_PID_COUNTRY_CODE_DEFAULT;
+ sc->sc_resumeinit = 0;
+
+ /*
+ * attach the interface
+ */
+ /* The version isn't the most accurate way, but it's easy. */
+ printf("%s: firmware version %d\n", sc->sc_dev.dv_xname,sc->sc_version);
+ if (sc->sc_version != SC_BUILD_4)
+ printf("%s: supported rates %0x:%0x:%0x:%0x:%0x:%0x:%0x:%0x\n",
+ sc->sc_xname, ep->e_rates[0], ep->e_rates[1],
+ ep->e_rates[2], ep->e_rates[3], ep->e_rates[4],
+ ep->e_rates[5], ep->e_rates[6], ep->e_rates[7]);
+ printf("%s: 802.11 address %s\n", sc->sc_xname,
+ ether_sprintf(ep->e_station_addr));
+
+ memcpy(ifp->if_xname, sc->sc_xname, IFNAMSIZ);
+ ifp->if_softc = sc;
+ ifp->if_start = ray_if_start;
+ ifp->if_ioctl = ray_ioctl;
+ ifp->if_mtu = ETHERMTU;
+ ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST;
+ if_attach(ifp);
+#ifdef __NetBSD__
+ ether_ifattach(ifp, ep->e_station_addr);
+#elif defined(__OpenBSD__)
+ memcpy(&sc->sc_ec.ac_enaddr, ep->e_station_addr, ETHER_ADDR_LEN);
+ ether_ifattach(ifp);
+#endif
+ /* need enough space for ieee80211_header + (snap or e2) */
+ ifp->if_hdrlen =
+ sizeof(struct ieee80211_frame) + sizeof(struct ether_header);
+
+ ifmedia_init(&sc->sc_media, 0, ray_media_change, ray_media_status);
+ ifmedia_add(&sc->sc_media, IFM_ADHOC, 0, 0);
+ ifmedia_add(&sc->sc_media, IFM_INFRA, 0, 0);
+ if (sc->sc_mode == SC_MODE_ADHOC)
+ ifmedia_set(&sc->sc_media, IFM_ADHOC);
+ else
+ ifmedia_set(&sc->sc_media, IFM_INFRA);
+
+#if NBPFILTER > 0
+ bpfattach(&ifp->if_bpf, ifp, DLT_EN10MB, sizeof(struct ether_header));
+#endif
+ /* disable the card */
+ pcmcia_function_disable(sc->sc_pf);
+
+ sc->sc_sdhook = shutdownhook_establish(ray_shutdown, sc);
+ sc->sc_pwrhook = powerhook_establish(ray_power, sc);
+
+ return;
+fail:
+ /* disable the card */
+ pcmcia_function_disable(sc->sc_pf);
+
+ /* free the alloc/map */
+#if RAY_USE_AMEM
+ if (sc->sc_awindow != -1) {
+ pcmcia_mem_unmap(sc->sc_pf, sc->sc_awindow);
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_amem);
+ }
+#endif
+ if (sc->sc_window != -1) {
+ pcmcia_mem_unmap(sc->sc_pf, sc->sc_window);
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_mem);
+ }
+}
+
+int
+ray_activate(dev, act)
+ struct device *dev;
+ enum devact act;
+{
+ struct ray_softc *sc = (struct ray_softc *)dev;
+ struct ifnet *ifp = &sc->sc_if;
+ int s;
+ int rv = 0;
+
+ RAY_DPRINTF(("%s: activate\n", sc->sc_xname));
+
+ s = splnet();
+ switch (act) {
+ case DVACT_ACTIVATE:
+ rv = EOPNOTSUPP;
+ break;
+
+ case DVACT_DEACTIVATE:
+ if (ifp->if_flags & IFF_RUNNING)
+ ray_disable(sc);
+#ifdef __NetBSD__
+ if_deactivate(ifp);
+#elif defined(__OpenBSD__)
+ pcmcia_function_disable(sc->sc_pf);
+ pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
+#endif
+ break;
+ }
+ splx(s);
+ return (rv);
+}
+
+int
+ray_detach(self, flags)
+ struct device *self;
+ int flags;
+{
+ struct ray_softc *sc;
+ struct ifnet *ifp;
+
+ sc = (struct ray_softc *)self;
+ ifp = &sc->sc_if;
+ RAY_DPRINTF(("%s: detach\n", sc->sc_xname));
+
+ if (ifp->if_flags & IFF_RUNNING)
+ ray_disable(sc);
+
+ /* give back the memory */
+#if RAY_USE_AMEM
+ if (sc->sc_awindow != -1) {
+ pcmcia_mem_unmap(sc->sc_pf, sc->sc_awindow);
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_amem);
+ }
+#endif
+ if (sc->sc_window != -1) {
+ pcmcia_mem_unmap(sc->sc_pf, sc->sc_window);
+ pcmcia_mem_free(sc->sc_pf, &sc->sc_mem);
+ }
+
+ ifmedia_delete_instance(&sc->sc_media, IFM_INST_ANY);
+
+#if NBPFILTER > 0
+ bpfdetach(ifp);
+#endif
+ ether_ifdetach(ifp);
+ if_detach(ifp);
+ powerhook_disestablish(sc->sc_pwrhook);
+ shutdownhook_disestablish(sc->sc_sdhook);
+
+ return (0);
+}
+
+/*
+ * start the card running
+ */
+int
+ray_enable(sc)
+ struct ray_softc *sc;
+{
+ int error;
+
+ RAY_DPRINTF(("%s: enable\n", sc->sc_xname));
+
+ if ((error = ray_init(sc)) == 0) {
+ sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
+ ray_intr, sc);
+ if (sc->sc_ih == NULL) {
+ ray_stop(sc);
+ return (EIO);
+ }
+ }
+ return (error);
+}
+
+/*
+ * stop the card running
+ */
+void
+ray_disable(sc)
+ struct ray_softc *sc;
+{
+ RAY_DPRINTF(("%s: disable\n", sc->sc_xname));
+
+ if ((sc->sc_if.if_flags & IFF_RUNNING))
+ ray_stop(sc);
+
+ sc->sc_resetloop = 0;
+ sc->sc_rxoverflow = 0;
+ sc->sc_rxcksum = 0;
+ sc->sc_rxhcksum = 0;
+ sc->sc_rxnoise = 0;
+
+ if (sc->sc_ih)
+ pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
+ sc->sc_ih = 0;
+}
+
+/*
+ * start the card running
+ */
+int
+ray_init(sc)
+ struct ray_softc *sc;
+{
+ struct ray_ecf_startup *ep;
+ bus_size_t ccs;
+ int i;
+
+ RAY_DPRINTF(("%s: init\n", sc->sc_xname));
+
+ if ((sc->sc_if.if_flags & IFF_RUNNING))
+ ray_stop(sc);
+
+ if (pcmcia_function_enable(sc->sc_pf))
+ return (EIO);
+
+ RAY_DPRINTF(("%s: init post-enable\n", sc->sc_xname));
+
+ /* reset some values */
+ memset(sc->sc_ccsinuse, 0, sizeof(sc->sc_ccsinuse));
+ sc->sc_havenet = 0;
+ memset(sc->sc_bssid, 0, sizeof(sc->sc_bssid));
+ sc->sc_deftxrate = 0;
+ sc->sc_encrypt = 0;
+ sc->sc_txpad = 0;
+ sc->sc_promisc = 0;
+ sc->sc_scheduled = 0;
+ sc->sc_running = 0;
+ sc->sc_txfree = RAY_CCS_NTX;
+ sc->sc_checkcounters = 0;
+ sc->sc_resumeinit = 0;
+
+ /* get startup results */
+ ep = &sc->sc_ecf_startup;
+ ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep,
+ sizeof(sc->sc_ecf_startup));
+
+ /* check to see that card initialized properly */
+ if (ep->e_status != RAY_ECFS_CARD_OK) {
+ pcmcia_function_disable(sc->sc_pf);
+ printf("%s: card failed self test: status %d\n",
+ sc->sc_xname, sc->sc_ecf_startup.e_status);
+ return (EIO);
+ }
+
+ /* fixup tib size to be correct */
+ if (sc->sc_version == SC_BUILD_4 && sc->sc_tibsize == 0x55)
+ sc->sc_tibsize = 32;
+ sc->sc_txpad = sc->sc_tibsize;
+
+ /* set all ccs to be free */
+ ccs = RAY_GET_CCS(0);
+ for (i = 0; i < RAY_CCS_LAST; ccs += RAY_CCS_SIZE, i++)
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
+ RAY_CCS_STATUS_FREE);
+
+ /* clear the interrupt if present */
+ REG_WRITE(sc, RAY_HCSIR, 0);
+
+ /* we are now up and running -- and are busy until download is cplt */
+ sc->sc_if.if_flags |= IFF_RUNNING | IFF_OACTIVE;
+
+ /* set this now so it gets set in the download */
+ sc->sc_promisc = !!(sc->sc_if.if_flags & (IFF_PROMISC|IFF_ALLMULTI));
+
+ /* call after we mark ourselves running */
+ ray_download_params(sc);
+
+ return (0);
+}
+
+/*
+ * stop the card running
+ */
+void
+ray_stop(sc)
+ struct ray_softc *sc;
+{
+ RAY_DPRINTF(("%s: stop\n", sc->sc_xname));
+
+ untimeout(ray_check_ccs, sc);
+ sc->sc_timocheck = 0;
+
+ untimeout(ray_check_scheduled, sc);
+ sc->sc_timoneed = 0;
+
+ if (sc->sc_repreq) {
+ sc->sc_repreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ wakeup(ray_report_params);
+ }
+ if (sc->sc_updreq) {
+ sc->sc_repreq->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ wakeup(ray_update_params);
+ }
+
+ sc->sc_if.if_flags &= ~IFF_RUNNING;
+ pcmcia_function_disable(sc->sc_pf);
+}
+
+/*
+ * reset the card
+ */
+void
+ray_reset(sc)
+ struct ray_softc *sc;
+{
+ if (++sc->sc_resetloop >= RAY_MAX_RESETS) {
+ if (sc->sc_resetloop == RAY_MAX_RESETS) {
+ printf("%s: unable to correct, disabling\n",
+ sc->sc_xname);
+ untimeout(ray_reset_resetloop, sc);
+ timeout((void (*)(void *))ray_disable, sc, 1);
+ }
+ } else {
+ printf("%s: unexpected failure resetting hw [%d more]\n",
+ sc->sc_xname, RAY_MAX_RESETS - sc->sc_resetloop);
+ untimeout(ray_reset_resetloop, sc);
+ ray_init(sc);
+ timeout(ray_reset_resetloop, sc, 30 * hz);
+ }
+}
+
+/*
+ * return resetloop to zero (enough time has expired to allow user to
+ * disable a whacked interface) the main reason for all this nonesense
+ * is that resets take ~2 seconds and currently the pcmcia code spins
+ * on these resets
+ */
+void
+ray_reset_resetloop(arg)
+ void *arg;
+{
+ struct ray_softc *sc;
+
+ sc = arg;
+ sc->sc_resetloop = 0;
+}
+
+void
+ray_power(why, arg)
+ int why;
+ void *arg;
+{
+#if 0
+ struct ray_softc *sc;
+
+ /* can't do this until power hooks are called from thread */
+ sc = arg;
+ switch (why) {
+ case PWR_RESUME:
+ if (sc->sc_resumeinit)
+ ray_init(sc);
+ break;
+ case PWR_SUSPEND:
+ if ((sc->sc_if.if_flags & IFF_RUNNING)) {
+ ray_stop(sc);
+ sc->sc_resumeinit = 1;
+ }
+ break;
+ case PWR_STANDBY:
+ default:
+ break;
+ }
+#endif
+}
+
+void
+ray_shutdown(arg)
+ void *arg;
+{
+ struct ray_softc *sc;
+
+ sc = arg;
+ ray_disable(sc);
+}
+
+int
+ray_ioctl(ifp, cmd, data)
+ struct ifnet *ifp;
+ u_long cmd;
+ caddr_t data;
+{
+ u_int8_t nwid[IEEE80211_NWID_LEN];
+ struct ray_param_req pr;
+ struct ray_softc *sc;
+ struct ifreq *ifr;
+ struct ifaddr *ifa;
+ int error, error2, s;
+
+ sc = ifp->if_softc;
+ error = 0;
+
+ ifr = (struct ifreq *)data;
+
+ s = splnet();
+
+ RAY_DPRINTF(("%s: ioctl: cmd 0x%lx data 0x%lx\n", ifp->if_xname,
+ cmd, (long)data));
+
+#ifdef __OpenBSD__
+ if ((error = ether_ioctl(ifp, &sc->sc_ec, cmd, data)) > 0) {
+ splx(s);
+ return error;
+ }
+#endif
+
+ switch (cmd) {
+ case SIOCSIFADDR:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFADDR\n", ifp->if_xname));
+ if ((ifp->if_flags & IFF_RUNNING) == 0)
+ if ((error = ray_enable(sc)))
+ break;
+ ifp->if_flags |= IFF_UP;
+ ifa = (struct ifaddr *)data;
+ switch (ifa->ifa_addr->sa_family) {
+#ifdef INET
+ case AF_INET:
+#ifdef __NetBSD__
+ arp_ifinit(&sc->sc_if, ifa);
+#elif defined(__OpenBSD__)
+ arp_ifinit(&sc->sc_ec, ifa);
+#endif
+ break;
+#endif
+ default:
+ break;
+ }
+ break;
+ case SIOCSIFFLAGS:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFFLAGS\n", ifp->if_xname));
+ if (ifp->if_flags & IFF_UP) {
+ if ((ifp->if_flags & IFF_RUNNING) == 0) {
+ if ((error = ray_enable(sc)))
+ break;
+ } else
+ ray_update_promisc(sc);
+ } else if (ifp->if_flags & IFF_RUNNING)
+ ray_disable(sc);
+ break;
+ case SIOCADDMULTI:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCADDMULTI\n", ifp->if_xname));
+ case SIOCDELMULTI:
+ if (cmd == SIOCDELMULTI)
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCDELMULTI\n",
+ ifp->if_xname));
+ if (cmd == SIOCADDMULTI)
+ error = ether_addmulti(ifr, &sc->sc_ec);
+ else
+ error = ether_delmulti(ifr, &sc->sc_ec);
+ if (error == ENETRESET) {
+ error = 0;
+ ray_update_mcast(sc);
+ }
+ break;
+ case SIOCSIFMEDIA:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFMEDIA\n", ifp->if_xname));
+ case SIOCGIFMEDIA:
+ if (cmd == SIOCGIFMEDIA)
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCGIFMEDIA\n",
+ ifp->if_xname));
+ error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
+ break;
+ case SIOCSRAYPARAM:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCSRAYPARAM\n", ifp->if_xname));
+ if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
+ break;
+ /* disallow certain command that have another interface */
+ switch (pr.r_paramid) {
+ case RAY_PID_NET_TYPE: /* through media opt */
+ case RAY_PID_AP_STATUS: /* unsupported */
+ case RAY_PID_SSID: /* use SIOC80211[GS]NWID */
+ case RAY_PID_MAC_ADDR: /* XXX need interface? */
+ case RAY_PID_PROMISC: /* bpf */
+ error = EINVAL;
+ break;
+ }
+ error = ray_user_update_params(sc, &pr);
+ error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
+ error = error2 ? error2 : error;
+ break;
+ case SIOCGRAYPARAM:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCGRAYPARAM\n", ifp->if_xname));
+ if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
+ break;
+ error = ray_user_report_params(sc, &pr);
+ error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
+ error = error2 ? error2 : error;
+ break;
+ case SIOCS80211NWID:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCSNWID\n", ifp->if_xname));
+ /*
+ * if later people overwrite thats ok -- the latest version
+ * will always get start/joined even if it was set by
+ * a previous command
+ */
+ if ((error = copyin(ifr->ifr_data, nwid, sizeof(nwid))))
+ break;
+ if (!memcmp(sc->sc_dnwid, nwid, sizeof(nwid)))
+ break;
+ memcpy(sc->sc_dnwid, nwid, sizeof(nwid));
+ if (ifp->if_flags & IFF_RUNNING)
+ ray_start_join_net(sc);
+ break;
+ case SIOCG80211NWID:
+ RAY_DPRINTF(("%s: ioctl: cmd SIOCHNWID\n", ifp->if_xname));
+ error = copyout(sc->sc_cnwid, ifr->ifr_data,
+ IEEE80211_NWID_LEN);
+ break;
+#ifdef RAY_DO_SIGLEV
+ error = copyout(sc->sc_siglevs, ifr->ifr_data,
+ sizeof sc->sc_siglevs);
+ break;
+#endif
+ default:
+ RAY_DPRINTF(("%s: ioctl: unknown\n", ifp->if_xname));
+ error = EINVAL;
+ break;
+ }
+
+ RAY_DPRINTF(("%s: ioctl: returns %d\n", ifp->if_xname, error));
+
+ splx(s);
+
+ return (error);
+}
+
+/*
+ * ifnet interface to start transmission on the interface
+ */
+void
+ray_if_start(ifp)
+ struct ifnet *ifp;
+{
+ struct ray_softc *sc;
+
+ sc = ifp->if_softc;
+ ray_intr_start(sc);
+}
+
+int
+ray_media_change(ifp)
+ struct ifnet *ifp;
+{
+ struct ray_softc *sc;
+
+ sc = ifp->if_softc;
+ RAY_DPRINTF(("%s: media change cur %d\n", ifp->if_xname,
+ sc->sc_media.ifm_cur->ifm_media));
+ if (sc->sc_media.ifm_cur->ifm_media & IFM_IEEE80211_ADHOC)
+ sc->sc_mode = SC_MODE_ADHOC;
+ else
+ sc->sc_mode = SC_MODE_INFRA;
+ if (sc->sc_mode != sc->sc_omode)
+ ray_start_join_net(sc);
+ return (0);
+}
+
+void
+ray_media_status(ifp, imr)
+ struct ifnet *ifp;
+ struct ifmediareq *imr;
+{
+ struct ray_softc *sc;
+
+ sc = ifp->if_softc;
+
+ RAY_DPRINTF(("%s: media status\n", ifp->if_xname));
+
+ imr->ifm_status = IFM_AVALID;
+ if (sc->sc_havenet)
+ imr->ifm_status |= IFM_ACTIVE;
+
+ if (sc->sc_mode == SC_MODE_ADHOC)
+ imr->ifm_active = IFM_ADHOC;
+ else
+ imr->ifm_active = IFM_INFRA;
+}
+
+/*
+ * called to start from ray_intr. We don't check for pending
+ * interrupt as a result
+ */
+void
+ray_intr_start(sc)
+ struct ray_softc *sc;
+{
+ struct ieee80211_frame *iframe;
+ struct ether_header *eh;
+ size_t len, pktlen, tmplen;
+ bus_size_t bufp, ebufp;
+ struct mbuf *m0, *m;
+ struct ifnet *ifp;
+ u_int firsti, hinti, previ, i, pcount;
+ u_int16_t et;
+ u_int8_t *d;
+
+ ifp = &sc->sc_if;
+
+ RAY_DPRINTF(("%s: start free %d qlen %d qmax %d\n",
+ ifp->if_xname, sc->sc_txfree, ifp->if_snd.ifq_len,
+ ifp->if_snd.ifq_maxlen));
+
+ ray_cmd_cancel(sc, SCP_IFSTART);
+
+ if ((ifp->if_flags & IFF_RUNNING) == 0 || !sc->sc_havenet)
+ return;
+
+ if (ifp->if_snd.ifq_len == 0)
+ return;
+
+ firsti = i = previ = RAY_CCS_LINK_NULL;
+ hinti = RAY_CCS_TX_FIRST;
+
+ if (!RAY_ECF_READY(sc)) {
+ ray_cmd_schedule(sc, SCP_IFSTART);
+ return;
+ }
+
+ pcount = 0;
+ for (;;) {
+ /* if we have no descriptors be done */
+ if (i == RAY_CCS_LINK_NULL) {
+ i = ray_find_free_tx_ccs(sc, hinti);
+ if (i == RAY_CCS_LINK_NULL) {
+ ifp->if_flags |= IFF_OACTIVE;
+ break;
+ }
+ }
+
+ IF_DEQUEUE(&ifp->if_snd, m0);
+ if (!m0)
+ break;
+ RAY_DPRINTF(("%s: gotmbuf 0x%lx\n", ifp->if_xname, (long)m0));
+ pktlen = m0->m_pkthdr.len;
+ if (pktlen > ETHER_MAX_LEN - ETHER_CRC_LEN) {
+ RAY_DPRINTF((
+ "%s: mbuf too long %lu\n", ifp->if_xname,
+ (u_long)pktlen));
+ ifp->if_oerrors++;
+ m_freem(m0);
+ continue;
+ }
+ RAY_DPRINTF(("%s: mbuf.m_pkthdr.len %d\n", ifp->if_xname,
+ (int)pktlen));
+
+ /* we need the ether_header now for pktlen adjustments */
+ M_PULLUP(m0, sizeof(struct ether_header));
+ if (!m0) {
+ RAY_DPRINTF(( "%s: couldn\'t pullup ether header\n",
+ ifp->if_xname));
+ ifp->if_oerrors++;
+ continue;
+ }
+ RAY_DPRINTF(("%s: got pulled up mbuf 0x%lx\n", ifp->if_xname,
+ (long)m0));
+
+ /* first peek at the type of packet and figure out what to do */
+ eh = mtod(m0, struct ether_header *);
+ et = ntohs(eh->ether_type);
+ if (ifp->if_flags & IFF_LINK0) {
+ /* don't support llc for windows compat operation */
+ if (et <= ETHERMTU) {
+ m_freem(m0);
+ ifp->if_oerrors++;
+ continue;
+ }
+ tmplen = sizeof(struct ieee80211_frame);
+ } else if (et > ETHERMTU) {
+ /* adjust for LLC/SNAP header */
+ tmplen= sizeof(struct ieee80211_frame) - ETHER_ADDR_LEN;
+ }
+ /* now get our space for the 802.11 frame */
+ M_PREPEND(m0, tmplen, M_DONTWAIT);
+ if (m0)
+ M_PULLUP(m0, sizeof(struct ether_header) + tmplen);
+ if (!m0) {
+ RAY_DPRINTF(("%s: couldn\'t prepend header\n",
+ ifp->if_xname));
+ ifp->if_oerrors++;
+ continue;
+ }
+ /* copy the frame into the mbuf for tapping */
+ iframe = mtod(m0, struct ieee80211_frame *);
+ eh = (struct ether_header *)((u_int8_t *)iframe + tmplen);
+ iframe->i_fc[0] =
+ (IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_DATA);
+ if (sc->sc_mode == SC_MODE_ADHOC) {
+ iframe->i_fc[1] = IEEE80211_FC1_DIR_NODS;
+ memcpy(iframe->i_addr1, eh->ether_dhost,ETHER_ADDR_LEN);
+ memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN);
+ memcpy(iframe->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN);
+ } else {
+ iframe->i_fc[1] = IEEE80211_FC1_DIR_TODS;
+ memcpy(iframe->i_addr1, sc->sc_bssid,ETHER_ADDR_LEN);
+ memcpy(iframe->i_addr2, eh->ether_shost,ETHER_ADDR_LEN);
+ memmove(iframe->i_addr3,eh->ether_dhost,ETHER_ADDR_LEN);
+ }
+ iframe->i_dur[0] = iframe->i_dur[1] = 0;
+ iframe->i_seq[0] = iframe->i_seq[1] = 0;
+
+ /* if not using crummy E2 in 802.11 make it LLC/SNAP */
+ if ((ifp->if_flags & IFF_LINK0) == 0 && et > ETHERMTU)
+ memcpy(iframe + 1, llc_snapid, sizeof(llc_snapid));
+
+ RAY_DPRINTF(("%s: i %d previ %d\n", ifp->if_xname, i, previ));
+
+ if (firsti == RAY_CCS_LINK_NULL)
+ firsti = i;
+
+ pktlen = m0->m_pkthdr.len;
+ bufp = ray_fill_in_tx_ccs(sc, pktlen, i, previ);
+ previ = hinti = i;
+ i = RAY_CCS_LINK_NULL;
+
+ RAY_DPRINTF(("%s: bufp 0x%lx new pktlen %d\n",
+ ifp->if_xname, (long)bufp, (int)pktlen));
+
+ /* copy out mbuf */
+ for (m = m0; m; m = m->m_next) {
+ if ((len = m->m_len) == 0)
+ continue;
+ RAY_DPRINTF((
+ "%s: copying mbuf 0x%lx bufp 0x%lx len %d\n",
+ ifp->if_xname, (long)m, (long)bufp, (int)len));
+ d = mtod(m, u_int8_t *);
+ ebufp = bufp + len;
+ if (ebufp <= RAY_TX_END)
+ ray_write_region(sc, bufp, d, len);
+ else {
+ panic("ray_intr_start"); /* XXX */
+ /* wrapping */
+ tmplen = ebufp - bufp;
+ len -= tmplen;
+ ray_write_region(sc, bufp, d, tmplen);
+ d += tmplen;
+ bufp = RAY_TX_BASE;
+ ray_write_region(sc, bufp, d, len);
+ }
+ bufp += len;
+ }
+#if NBPFILTER > 0
+ if (ifp->if_bpf) {
+ if (ifp->if_flags & IFF_LINK0) {
+ m0->m_data += sizeof(struct ieee80211_frame);
+ m0->m_len -= sizeof(struct ieee80211_frame);
+ m0->m_pkthdr.len -= sizeof(struct ieee80211_frame);
+ }
+ bpf_mtap(ifp->if_bpf, m0);
+ if (ifp->if_flags & IFF_LINK0) {
+ m0->m_data -= sizeof(struct ieee80211_frame);
+ m0->m_len += sizeof(struct ieee80211_frame);
+ m0->m_pkthdr.len += sizeof(struct ieee80211_frame);
+ }
+ }
+#endif
+
+#ifdef RAY_DEBUG
+ if (ray_debug && ray_debug_dump_tx)
+ ray_dump_mbuf(sc, m0);
+#endif
+ pcount++;
+ m_freem(m0);
+ }
+
+ if (firsti == RAY_CCS_LINK_NULL)
+ return;
+ i = 0;
+ if (!RAY_ECF_READY(sc)) {
+ /*
+ * if this can really happen perhaps we need to save
+ * the chain and use it later. I think this might
+ * be a confused state though because we check above
+ * and don't issue any commands between.
+ */
+ printf("%s: dropping tx packets device busy\n", sc->sc_xname);
+ ray_free_ccs_chain(sc, firsti);
+ ifp->if_oerrors += pcount;
+ return;
+ }
+
+ /* send it off */
+ RAY_DPRINTF(("%s: ray_start issueing %d \n", sc->sc_xname, firsti));
+ SRAM_WRITE_1(sc, RAY_SCB_CCSI, firsti);
+ RAY_ECF_START_CMD(sc);
+
+ RAY_DPRINTF_XMIT(("%s: sent packet: len %lu\n", sc->sc_xname,
+ (u_long)pktlen));
+
+ ifp->if_opackets += pcount;
+}
+
+/*
+ * recevice a packet from the card
+ */
+void
+ray_recv(sc, ccs)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+{
+ struct ieee80211_frame *frame;
+ struct ether_header *eh;
+ struct mbuf *m;
+ size_t pktlen, len, lenread;
+ bus_size_t bufp, ebufp, tmp;
+ struct ifnet *ifp;
+ u_int8_t *src, *d;
+ u_int frag, nofrag, ni, i, issnap, first;
+ u_int8_t fc0;
+#ifdef RAY_DO_SIGLEV
+ u_int8_t siglev;
+#endif
+
+#ifdef RAY_DEBUG
+ /* have a look if you want to see how the card rx works :) */
+ if (ray_debug && ray_debug_dump_desc)
+ hexdump((caddr_t)sc->sc_memh + RAY_RCS_BASE, 0x400,
+ 16, 4, 0);
+#endif
+
+ nofrag = 0; /* XXX unused */
+ m = 0;
+ ifp = &sc->sc_if;
+
+ /* it looks like at least with build 4 there is no CRC in length */
+ first = RAY_GET_INDEX(ccs);
+ pktlen = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_pktlen);
+#ifdef RAY_DO_SIGLEV
+ siglev = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_siglev);
+#endif
+ RAY_DPRINTF(("%s: recv pktlen %lu nofrag %d\n", sc->sc_xname,
+ (u_long)pktlen, nofrag));
+ RAY_DPRINTF_XMIT(("%s: received packet: len %lu\n", sc->sc_xname,
+ (u_long)pktlen));
+ if (pktlen > MCLBYTES
+ || pktlen < (sizeof(*frame) + sizeof(struct llc))) {
+ RAY_DPRINTF(("%s: PKTLEN TOO BIG OR TOO SMALL\n",
+ sc->sc_xname));
+ ifp->if_ierrors++;
+ goto done;
+ }
+ MGETHDR(m, M_DONTWAIT, MT_DATA);
+ if (!m) {
+ RAY_DPRINTF(("%s: MGETHDR FAILED\n", sc->sc_xname));
+ ifp->if_ierrors++;
+ goto done;
+ }
+ if (pktlen > MHLEN) {
+ /* XXX should allow chaining? */
+ MCLGET(m, M_DONTWAIT);
+ if ((m->m_flags & M_EXT) == 0) {
+ RAY_DPRINTF(("%s: MCLGET FAILED\n", sc->sc_xname));
+ ifp->if_ierrors++;
+ m_freem(m);
+ m = 0;
+ goto done;
+ }
+ }
+ m->m_pkthdr.rcvif = ifp;
+ m->m_pkthdr.len = pktlen;
+ m->m_len = pktlen;
+ d = mtod(m, u_int8_t *);
+
+ RAY_DPRINTF(("%s: recv ccs index %d\n", sc->sc_xname, first));
+ frag = 0;
+ lenread = 0;
+ i = ni = first;
+ while ((i = ni) && i != RAY_CCS_LINK_NULL) {
+ ccs = RAY_GET_CCS(i);
+ bufp = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_bufp);
+ len = SRAM_READ_FIELD_2(sc, ccs, ray_cmd_rx, c_len);
+ /* remove the CRC */
+#if 0
+ /* at least with build 4 no crc seems to be here */
+ if (frag++ == 0)
+ len -= 4;
+#endif
+ ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag);
+ RAY_DPRINTF(("%s: recv frag index %d len %lu bufp %p ni %d\n",
+ sc->sc_xname, i, (u_long)len, bufp, ni));
+ if (len + lenread > pktlen) {
+ RAY_DPRINTF(("%s: BAD LEN current %lu pktlen %lu\n",
+ sc->sc_xname, (u_long)(len + lenread),
+ (u_long)pktlen));
+ ifp->if_ierrors++;
+ m_freem(m);
+ m = 0;
+ goto done;
+ }
+ if (i < RAY_RCCS_FIRST) {
+ printf("ray_recv: bad ccs index 0x%x\n", i);
+ m_freem(m);
+ m = 0;
+ goto done;
+ }
+
+ ebufp = bufp + len;
+ if (ebufp <= RAY_RX_END)
+ ray_read_region(sc, bufp, d, len);
+ else {
+ /* wrapping */
+ ray_read_region(sc, bufp, d, (tmp = RAY_RX_END - bufp));
+ ray_read_region(sc, RAY_RX_BASE, d + tmp, ebufp - RAY_RX_END);
+ }
+ d += len;
+ lenread += len;
+ }
+done:
+
+ RAY_DPRINTF(("%s: recv frag count %d\n", sc->sc_xname, frag));
+
+ /* free the rcss */
+ ni = first;
+ while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
+ ccs = RAY_GET_CCS(i);
+ ni = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_rx, c_nextfrag);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
+ RAY_CCS_STATUS_FREE);
+ }
+
+ if (!m)
+ return;
+
+ RAY_DPRINTF(("%s: recv got packet pktlen %lu actual %lu\n",
+ sc->sc_xname, (u_long)pktlen, (u_long)lenread));
+#ifdef RAY_DEBUG
+ if (ray_debug && ray_debug_dump_rx)
+ ray_dump_mbuf(sc, m);
+#endif
+ /* receivce the packet */
+ frame = mtod(m, struct ieee80211_frame *);
+ fc0 = frame->i_fc[0]
+ & (IEEE80211_FC0_VERSION_MASK|IEEE80211_FC0_TYPE_MASK);
+ if ((fc0 & IEEE80211_FC0_VERSION_MASK) != IEEE80211_FC0_VERSION_0) {
+ RAY_DPRINTF(("%s: pkt not version 0 fc 0x%x\n",
+ sc->sc_xname, fc0));
+ m_freem(m);
+ return;
+ }
+ if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) {
+ RAY_DPRINTF(("%s: pkt not type data fc0 0x%x\n",
+ sc->sc_xname, fc0));
+ m_freem(m);
+ return;
+ }
+
+ if (!memcmp(frame + 1, llc_snapid, sizeof(llc_snapid)))
+ issnap = 1;
+ else {
+ /*
+ * if user has link0 flag set we allow the weird
+ * Ethernet2 in 802.11 encapsulation produced by
+ * the windows driver for the WebGear card
+ */
+ RAY_DPRINTF(("%s: pkt not snap 0\n", sc->sc_xname));
+ if ((ifp->if_flags & IFF_LINK0) == 0) {
+ m_freem(m);
+ return;
+ }
+ issnap = 0;
+ }
+ switch (frame->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
+ case IEEE80211_FC1_DIR_NODS:
+ src = frame->i_addr2;
+ break;
+ case IEEE80211_FC1_DIR_FROMDS:
+ src = frame->i_addr3;
+ break;
+ case IEEE80211_FC1_DIR_TODS:
+ RAY_DPRINTF(("%s: pkt ap2ap\n", sc->sc_xname));
+ m_freem(m);
+ return;
+ default:
+ RAY_DPRINTF(("%s: pkt type unknown\n", sc->sc_xname));
+ m_freem(m);
+ return;
+ }
+
+#ifdef RAY_DO_SIGLEV
+ ray_update_siglev(sc, src, siglev);
+#endif
+
+ /*
+ * This is a mess.. we should support other LLC frame types
+ */
+ if (issnap) {
+ /* create an ether_header over top of the 802.11+SNAP header */
+ eh = (struct ether_header *)((caddr_t)(frame + 1) - 6);
+ memcpy(eh->ether_shost, src, ETHER_ADDR_LEN);
+ memcpy(eh->ether_dhost, frame->i_addr1, ETHER_ADDR_LEN);
+ } else {
+ /* this is the weird e2 in 802.11 encapsulation */
+ eh = (struct ether_header *)(frame + 1);
+ }
+ m_adj(m, (caddr_t)eh - (caddr_t)frame);
+#if NBPFILTER > 0
+ if (ifp->if_bpf)
+ bpf_mtap(ifp->if_bpf, m);
+#endif
+ /* XXX doesn't appear to be included m->m_flags |= M_HASFCS; */
+ ifp->if_ipackets++;
+#ifdef __NetBSD__
+ (*ifp->if_input)(ifp, m);
+#elif defined(__OpenBSD__)
+ m_adj(m, sizeof(struct ether_header));
+ ether_input(ifp, eh, m);
+#endif
+}
+
+
+/*
+ * scan for free buffers
+ *
+ * Note: do _not_ try to optimize this away, there is some kind of
+ * horrible interaction with receiving tx interrupts and they
+ * have to be done as fast as possible, which means zero processing.
+ * this took ~ever to figure out, don't make someone do it again!
+ */
+u_int
+ray_find_free_tx_ccs(sc, hint)
+ struct ray_softc *sc;
+ u_int hint;
+{
+ u_int i, stat;
+
+ for (i = hint; i <= RAY_CCS_TX_LAST; i++) {
+ stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
+ if (stat == RAY_CCS_STATUS_FREE)
+ return (i);
+ }
+
+ if (hint == RAY_CCS_TX_FIRST)
+ return (RAY_CCS_LINK_NULL);
+
+ for (i = RAY_CCS_TX_FIRST; i < hint; i++) {
+ stat = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
+ if (stat == RAY_CCS_STATUS_FREE)
+ return (i);
+ }
+ return (RAY_CCS_LINK_NULL);
+}
+
+/*
+ * allocate, initialize and link in a tx ccs for the given
+ * page and the current chain values
+ */
+bus_size_t
+ray_fill_in_tx_ccs(sc, pktlen, i, pi)
+ struct ray_softc *sc;
+ size_t pktlen;
+ u_int i, pi;
+{
+ bus_size_t ccs, bufp;
+
+ /* pktlen += RAY_TX_PHY_SIZE; */
+ bufp = RAY_TX_BASE + i * RAY_TX_BUF_SIZE;
+ bufp += sc->sc_txpad;
+ ccs = RAY_GET_CCS(i);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_status, RAY_CCS_STATUS_BUSY);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_cmd, RAY_CMD_TX_REQ);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_link, RAY_CCS_LINK_NULL);
+ SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_bufp, bufp);
+ SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_len, pktlen);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_tx_rate, sc->sc_deftxrate);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_apm_mode, 0);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_antenna, 0);
+
+ /* link us in */
+ if (pi != RAY_CCS_LINK_NULL)
+ SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(pi), ray_cmd_tx, c_link, i);
+
+ RAY_DPRINTF(("%s: ray_alloc_tx_ccs bufp 0x%lx idx %d pidx %d \n",
+ sc->sc_xname, bufp, i, pi));
+
+ return (bufp + RAY_TX_PHY_SIZE);
+}
+
+/*
+ * an update params command has completed lookup which command and
+ * the status
+ */
+ray_cmd_func_t
+ray_update_params_done(sc, ccs, stat)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+ u_int stat;
+{
+ ray_cmd_func_t rcmd;
+
+ rcmd = 0;
+
+ RAY_DPRINTF(("%s: ray_update_params_done stat %d\n",
+ sc->sc_xname, stat));
+
+ /* this will get more complex as we add commands */
+ if (stat == RAY_CCS_STATUS_FAIL) {
+ printf("%s: failed to update a promisc\n", sc->sc_xname);
+ /* XXX should probably reset */
+ /* rcmd = ray_reset; */
+ }
+
+ if (sc->sc_running & SCP_UPD_PROMISC) {
+ ray_cmd_done(sc, SCP_UPD_PROMISC);
+ sc->sc_promisc = SRAM_READ_1(sc, RAY_HOST_TO_ECF_BASE);
+ RAY_DPRINTF(("%s: new promisc value %d\n", sc->sc_xname,
+ sc->sc_promisc));
+ } else if (sc->sc_updreq) {
+ ray_cmd_done(sc, SCP_UPD_UPDATEPARAMS);
+ /* get the update parameter */
+ sc->sc_updreq->r_failcause =
+ SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_failcause);
+ sc->sc_updreq = 0;
+ wakeup(ray_update_params);
+
+ rcmd = ray_start_join_net;
+ }
+ return (rcmd);
+}
+
+/*
+ * check too see if we have any pending commands.
+ */
+void
+ray_check_scheduled(arg)
+ void *arg;
+{
+ struct ray_softc *sc;
+ int s, i, mask;
+
+ s = splnet();
+
+ sc = arg;
+ RAY_DPRINTF((
+ "%s: ray_check_scheduled enter schd 0x%x running 0x%x ready %d\n",
+ sc->sc_xname, sc->sc_scheduled, sc->sc_running, RAY_ECF_READY(sc)));
+
+ if (sc->sc_timoneed) {
+ untimeout(ray_check_scheduled, sc);
+ sc->sc_timoneed = 0;
+ }
+
+ /* if update subcmd is running -- clear it in scheduled */
+ if (sc->sc_running & SCP_UPDATESUBCMD)
+ sc->sc_scheduled &= ~SCP_UPDATESUBCMD;
+
+ mask = SCP_FIRST;
+ for (i = 0; i < ray_ncmdtab; mask <<= 1, i++) {
+ if ((sc->sc_scheduled & ~SCP_UPD_MASK) == 0)
+ break;
+ if (!RAY_ECF_READY(sc))
+ break;
+ if (sc->sc_scheduled & mask)
+ (*ray_cmdtab[i])(sc);
+ }
+
+ RAY_DPRINTF((
+ "%s: ray_check_scheduled exit sched 0x%x running 0x%x ready %d\n",
+ sc->sc_xname, sc->sc_scheduled, sc->sc_running, RAY_ECF_READY(sc)));
+
+ if (sc->sc_scheduled & ~SCP_UPD_MASK)
+ ray_set_pending(sc, sc->sc_scheduled);
+
+ splx(s);
+}
+
+/*
+ * check for unreported returns
+ *
+ * this routine is coded to only expect one outstanding request for the
+ * timed out requests at a time, but thats all that can be outstanding
+ * per hardware limitations
+ */
+void
+ray_check_ccs(arg)
+ void *arg;
+{
+ ray_cmd_func_t fp;
+ struct ray_softc *sc;
+ u_int i, cmd, stat;
+ bus_size_t ccs;
+ int s;
+
+ s = splnet();
+ sc = arg;
+
+ RAY_DPRINTF(("%s: ray_check_ccs\n", sc->sc_xname));
+
+ sc->sc_timocheck = 0;
+ for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
+ if (!sc->sc_ccsinuse[i])
+ continue;
+ ccs = RAY_GET_CCS(i);
+ cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
+ switch (cmd) {
+ case RAY_CMD_START_PARAMS:
+ case RAY_CMD_UPDATE_MCAST:
+ case RAY_CMD_UPDATE_PARAMS:
+ stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
+ RAY_DPRINTF(("%s: check ccs idx %d ccs 0x%lx "
+ "cmd 0x%x stat %d\n", sc->sc_xname, i,
+ ccs, cmd, stat));
+ goto breakout;
+ }
+ }
+breakout:
+ /* see if we got one of the commands we are looking for */
+ if (i > RAY_CCS_CMD_LAST)
+ ; /* nothign */
+ else if (stat == RAY_CCS_STATUS_FREE) {
+ stat = RAY_CCS_STATUS_COMPLETE;
+ if ((fp = ray_ccs_done(sc, ccs)))
+ (*fp)(sc);
+ } else if (stat != RAY_CCS_STATUS_BUSY) {
+ if (sc->sc_ccsinuse[i] == 1) {
+ /* give a chance for the interrupt to occur */
+ sc->sc_ccsinuse[i] = 2;
+ if (!sc->sc_timocheck) {
+ timeout(ray_check_ccs, sc, 1);
+ sc->sc_timocheck = 1;
+ }
+ } else if ((fp = ray_ccs_done(sc, ccs)))
+ (*fp)(sc);
+ } else {
+ timeout(ray_check_ccs, sc, RAY_CHECK_CCS_TIMEOUT);
+ sc->sc_timocheck = 1;
+ }
+ splx(s);
+}
+
+/*
+ * read the counters, the card implements the following protocol
+ * to keep the values from being changed while read: It checks
+ * the `own' bit and if zero writes the current internal counter
+ * value, it then sets the `own' bit to 1. If the `own' bit was 1 it
+ * incremenets its internal counter. The user thus reads the counter
+ * if the `own' bit is one and then sets the own bit to 0.
+ */
+void
+ray_update_error_counters(sc)
+ struct ray_softc *sc;
+{
+ bus_size_t csc;
+
+ /* try and update the error counters */
+ csc = RAY_STATUS_BASE;
+ if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxo_own)) {
+ sc->sc_rxoverflow +=
+ SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
+ SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxo_own, 0);
+ }
+ if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxc_own)) {
+ sc->sc_rxcksum +=
+ SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
+ SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxc_own, 0);
+ }
+ if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rxhc_own)) {
+ sc->sc_rxhcksum +=
+ SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_rx_hcksum);
+ SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_rxhc_own, 0);
+ }
+ sc->sc_rxnoise = SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rx_noise);
+}
+
+/*
+ * one of the commands we issued has completed, process.
+ */
+ray_cmd_func_t
+ray_ccs_done(sc, ccs)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+{
+ struct ifnet *ifp;
+ ray_cmd_func_t rcmd;
+ u_int cmd, stat;
+
+ ifp = &sc->sc_if;
+ cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
+ stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
+
+ RAY_DPRINTF(("%s: ray_ccs_done idx %ld cmd 0x%x stat %d\n",
+ sc->sc_xname, RAY_GET_INDEX(ccs), cmd, stat));
+
+ rcmd = 0;
+ switch (cmd) {
+ /*
+ * solicited commands
+ */
+ case RAY_CMD_START_PARAMS:
+ /* start network */
+ ray_cmd_done(sc, SCP_UPD_STARTUP);
+
+ /* ok to start queueing packets */
+ sc->sc_if.if_flags &= ~IFF_OACTIVE;
+
+ sc->sc_omode = sc->sc_mode;
+ memcpy(sc->sc_cnwid, sc->sc_dnwid, sizeof(sc->sc_cnwid));
+
+ rcmd = ray_start_join_net;
+ break;
+ case RAY_CMD_UPDATE_PARAMS:
+ rcmd = ray_update_params_done(sc, ccs, stat);
+ break;
+ case RAY_CMD_REPORT_PARAMS:
+ /* get the reported parameters */
+ ray_cmd_done(sc, SCP_REPORTPARAMS);
+ if (!sc->sc_repreq)
+ break;
+ sc->sc_repreq->r_failcause =
+ SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_failcause);
+ sc->sc_repreq->r_len =
+ SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_len);
+ ray_read_region(sc, RAY_ECF_TO_HOST_BASE, sc->sc_repreq->r_data,
+ sc->sc_repreq->r_len);
+ sc->sc_repreq = 0;
+ wakeup(ray_report_params);
+ break;
+ case RAY_CMD_UPDATE_MCAST:
+ ray_cmd_done(sc, SCP_UPD_MCAST);
+ if (stat == RAY_CCS_STATUS_FAIL)
+ rcmd = ray_reset;
+ break;
+ case RAY_CMD_START_NET:
+ case RAY_CMD_JOIN_NET:
+ rcmd = ray_start_join_net_done(sc, cmd, ccs, stat);
+ break;
+ case RAY_CMD_TX_REQ:
+ if (sc->sc_if.if_flags & IFF_OACTIVE) {
+ sc->sc_if.if_flags &= ~IFF_OACTIVE;
+ /* this may also be a problem */
+ rcmd = ray_intr_start;
+ }
+ /* free it -- no tracking */
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status,
+ RAY_CCS_STATUS_FREE);
+ goto done;
+ case RAY_CMD_START_ASSOC:
+ ray_cmd_done(sc, SCP_STARTASSOC);
+ if (stat == RAY_CCS_STATUS_FAIL)
+ rcmd = ray_start_join_net; /* XXX check */
+ else {
+ sc->sc_havenet = 1;
+ rcmd = ray_intr_start;
+ }
+ break;
+ case RAY_CMD_UPDATE_APM:
+ case RAY_CMD_TEST_MEM:
+ case RAY_CMD_SHUTDOWN:
+ case RAY_CMD_DUMP_MEM:
+ case RAY_CMD_START_TIMER:
+ break;
+ default:
+ printf("%s: intr: unknown command 0x%x\n",
+ sc->sc_if.if_xname, cmd);
+ break;
+ }
+ ray_free_ccs(sc, ccs);
+done:
+ /*
+ * see if needed things can be done now that a command
+ * has completed
+ */
+ ray_check_scheduled(sc);
+
+ return (rcmd);
+}
+
+/*
+ * an unsolicted interrupt, i.e., the ECF is sending us a command
+ */
+ray_cmd_func_t
+ray_rccs_intr(sc, ccs)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+{
+ ray_cmd_func_t rcmd;
+ u_int cmd, stat;
+
+ cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
+ stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
+
+ RAY_DPRINTF(("%s: ray_rccs_intr idx %ld cmd 0x%x stat %d\n",
+ sc->sc_xname, RAY_GET_INDEX(ccs), cmd, stat));
+
+ rcmd = 0;
+ switch (cmd) {
+ /*
+ * unsolicted commands
+ */
+ case RAY_ECMD_RX_DONE:
+ ray_recv(sc, ccs);
+ goto done;
+ case RAY_ECMD_REJOIN_DONE:
+ if (sc->sc_mode == SC_MODE_ADHOC)
+ break;
+ /* get the current ssid */
+ SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id,
+ sc->sc_bssid, sizeof(sc->sc_bssid));
+ rcmd = ray_start_assoc;
+ break;
+ case RAY_ECMD_ROAM_START:
+ /* no longer have network */
+ sc->sc_havenet = 0;
+ break;
+ case RAY_ECMD_JAPAN_CALL_SIGNAL:
+ break;
+ default:
+ ray_update_error_counters(sc);
+
+ /* this is a bogus return from build 4 don't free 0x55 */
+ if (sc->sc_version == SC_BUILD_4 && cmd == 0x55
+ && RAY_GET_INDEX(ccs) == 0x55) {
+ goto done;
+ }
+ printf("%s: intr: unknown command 0x%x\n",
+ sc->sc_if.if_xname, cmd);
+ break;
+ }
+ /* free the ccs */
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE);
+done:
+ return (rcmd);
+}
+
+/*
+ * process an interrupt
+ */
+int
+ray_intr(arg)
+ void *arg;
+{
+ struct ray_softc *sc;
+ ray_cmd_func_t rcmd;
+ u_int i, count;
+
+ sc = arg;
+
+ RAY_DPRINTF(("%s: ray_intr\n", sc->sc_xname));
+
+ if ((++sc->sc_checkcounters % 32) == 0)
+ ray_update_error_counters(sc);
+
+ count = 0;
+ rcmd = 0;
+ if (!REG_READ(sc, RAY_HCSIR))
+ count = 0;
+ else {
+ count = 1;
+ i = SRAM_READ_1(sc, RAY_SCB_RCCSI);
+ if (i <= RAY_CCS_LAST)
+ rcmd = ray_ccs_done(sc, RAY_GET_CCS(i));
+ else if (i <= RAY_RCCS_LAST)
+ rcmd = ray_rccs_intr(sc, RAY_GET_CCS(i));
+ else
+ printf("%s: intr: bad cmd index %d\n", sc->sc_xname, i);
+ }
+
+ if (rcmd)
+ (*rcmd)(sc);
+
+ if (count)
+ REG_WRITE(sc, RAY_HCSIR, 0);
+
+ RAY_DPRINTF(("%s: interrupt handled %d\n", sc->sc_xname, count));
+
+ return (count ? 1 : 0);
+}
+
+
+/*
+ * Generic CCS handling
+ */
+
+/*
+ * free the chain of descriptors -- used for freeing allocated tx chains
+ */
+void
+ray_free_ccs_chain(sc, ni)
+ struct ray_softc *sc;
+ u_int ni;
+{
+ u_int i;
+
+ while ((i = ni) != RAY_CCS_LINK_NULL) {
+ ni = SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_link);
+ SRAM_WRITE_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status,
+ RAY_CCS_STATUS_FREE);
+ }
+}
+
+/*
+ * free up a cmd and return the old status
+ * this routine is only used for commands
+ */
+u_int8_t
+ray_free_ccs(sc, ccs)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+{
+ u_int8_t stat;
+
+ RAY_DPRINTF(("%s: free_ccs idx %ld\n", sc->sc_xname,
+ RAY_GET_INDEX(ccs)));
+
+ stat = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE);
+ if (ccs <= RAY_GET_CCS(RAY_CCS_LAST))
+ sc->sc_ccsinuse[RAY_GET_INDEX(ccs)] = 0;
+
+ return (stat);
+}
+
+/*
+ * returns 1 and in `ccb' the bus offset of the free ccb
+ * or 0 if none are free
+ *
+ * If `track' is not zero, handles tracking this command
+ * possibly indicating a callback is needed and setting a timeout
+ * also if ECF isn't ready we terminate earlier to avoid overhead.
+ *
+ * this routine is only used for commands
+ */
+int
+ray_alloc_ccs(sc, ccsp, cmd, track)
+ struct ray_softc *sc;
+ bus_size_t *ccsp;
+ u_int cmd, track;
+{
+ bus_size_t ccs;
+ u_int i;
+
+ RAY_DPRINTF(("%s: alloc_ccs cmd %d\n", sc->sc_xname, cmd));
+
+ /* for tracked commands, if not ready just set pending */
+ if (track && !RAY_ECF_READY(sc)) {
+ ray_cmd_schedule(sc, track);
+ return (0);
+ }
+
+ /* first scan our inuse array */
+ for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
+ /* XXX wonder if we have to probe here to make the card go */
+ (void)SRAM_READ_FIELD_1(sc, RAY_GET_CCS(i), ray_cmd, c_status);
+ if (!sc->sc_ccsinuse[i])
+ break;
+ }
+ if (i > RAY_CCS_CMD_LAST) {
+ if (track)
+ ray_cmd_schedule(sc, track);
+ return (0);
+ }
+ sc->sc_ccsinuse[i] = 1;
+ ccs = RAY_GET_CCS(i);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_BUSY);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_cmd, cmd);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_link, RAY_CCS_LINK_NULL);
+
+ *ccsp = ccs;
+ return (1);
+}
+
+
+/*
+ * this function sets the pending bit for the command given in 'need'
+ * and schedules a timeout if none is scheduled already. Any command
+ * that uses the `host to ecf' region must be serialized.
+ */
+void
+ray_set_pending(sc, cmdf)
+ struct ray_softc *sc;
+ u_int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_set_pending 0x%x\n", sc->sc_xname, cmdf));
+
+ sc->sc_scheduled |= cmdf;
+ if (!sc->sc_timoneed) {
+ RAY_DPRINTF(("%s: ray_set_pending new timo\n", sc->sc_xname));
+ timeout(ray_check_scheduled, sc, RAY_CHECK_SCHED_TIMEOUT);
+ sc->sc_timoneed = 1;
+ }
+}
+
+/*
+ * schedule the `cmdf' for completion later
+ */
+void
+ray_cmd_schedule(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ int track;
+
+ RAY_DPRINTF(("%s: ray_cmd_schedule 0x%x\n", sc->sc_xname, cmdf));
+
+ track = cmdf;
+ if ((cmdf & SCP_UPD_MASK) == 0)
+ ray_set_pending(sc, track);
+ else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
+ /* don't do timeout mechaniscm if subcmd already going */
+ sc->sc_scheduled |= cmdf;
+ } else
+ ray_set_pending(sc, cmdf | SCP_UPDATESUBCMD);
+}
+
+/*
+ * check to see if `cmdf' has been scheduled
+ */
+int
+ray_cmd_is_scheduled(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_cmd_is_scheduled 0x%x\n", sc->sc_xname, cmdf));
+
+ return ((sc->sc_scheduled & cmdf) ? 1 : 0);
+}
+
+/*
+ * cancel a scheduled command (not a running one though!)
+ */
+void
+ray_cmd_cancel(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_cmd_cancel 0x%x\n", sc->sc_xname, cmdf));
+
+ sc->sc_scheduled &= ~cmdf;
+ if ((cmdf & SCP_UPD_MASK) && (sc->sc_scheduled & SCP_UPD_MASK) == 0)
+ sc->sc_scheduled &= ~SCP_UPDATESUBCMD;
+
+ /* if nothing else needed cancel the timer */
+ if (sc->sc_scheduled == 0 && sc->sc_timoneed) {
+ untimeout(ray_check_scheduled, sc);
+ sc->sc_timoneed = 0;
+ }
+}
+
+/*
+ * called to indicate the 'cmdf' has been issued
+ */
+void
+ray_cmd_ran(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_cmd_ran 0x%x\n", sc->sc_xname, cmdf));
+
+ if (cmdf & SCP_UPD_MASK)
+ sc->sc_running |= cmdf | SCP_UPDATESUBCMD;
+ else
+ sc->sc_running |= cmdf;
+
+ if ((cmdf & SCP_TIMOCHECK_CMD_MASK) && !sc->sc_timocheck) {
+ timeout(ray_check_ccs, sc, RAY_CHECK_CCS_TIMEOUT);
+ sc->sc_timocheck = 1;
+ }
+}
+
+/*
+ * check to see if `cmdf' has been issued
+ */
+int
+ray_cmd_is_running(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_cmd_is_running 0x%x\n", sc->sc_xname, cmdf));
+
+ return ((sc->sc_running & cmdf) ? 1 : 0);
+}
+
+/*
+ * the given `cmdf' that was issued has completed
+ */
+void
+ray_cmd_done(sc, cmdf)
+ struct ray_softc *sc;
+ int cmdf;
+{
+ RAY_DPRINTF(("%s: ray_cmd_done 0x%x\n", sc->sc_xname, cmdf));
+
+ sc->sc_running &= ~cmdf;
+ if (cmdf & SCP_UPD_MASK) {
+ sc->sc_running &= ~SCP_UPDATESUBCMD;
+ if (sc->sc_scheduled & SCP_UPD_MASK)
+ ray_cmd_schedule(sc, sc->sc_scheduled & SCP_UPD_MASK);
+ }
+ if ((sc->sc_running & SCP_TIMOCHECK_CMD_MASK) == 0 && sc->sc_timocheck){
+ untimeout(ray_check_ccs, sc);
+ sc->sc_timocheck = 0;
+ }
+}
+
+/*
+ * issue the command
+ * only used for commands not tx
+ */
+int
+ray_issue_cmd(sc, ccs, track)
+ struct ray_softc *sc;
+ bus_size_t ccs;
+ u_int track;
+{
+ u_int i;
+
+ RAY_DPRINTF(("%s: ray_cmd_issue 0x%x\n", sc->sc_xname, track));
+
+ /*
+ * XXX other drivers did this, but I think
+ * what we really want to do is just make sure we don't
+ * get here or that spinning is ok
+ */
+ i = 0;
+ while (!RAY_ECF_READY(sc))
+ if (++i > 50) {
+ ray_free_ccs(sc, ccs);
+ if (track)
+ ray_cmd_schedule(sc, track);
+ return (0);
+ }
+
+ SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs));
+ RAY_ECF_START_CMD(sc);
+ ray_cmd_ran(sc, track);
+
+ return (1);
+}
+
+/*
+ * send a simple command if we can
+ */
+int
+ray_simple_cmd(sc, cmd, track)
+ struct ray_softc *sc;
+ u_int cmd, track;
+{
+ bus_size_t ccs;
+
+ return (ray_alloc_ccs(sc, &ccs, cmd, track) &&
+ ray_issue_cmd(sc, ccs, track));
+}
+
+/*
+ * Functions based on CCS commands
+ */
+
+/*
+ * run a update subcommand
+ */
+void
+ray_update_subcmd(sc)
+ struct ray_softc *sc;
+{
+ int submask, i;
+
+ RAY_DPRINTF(("%s: ray_update_subcmd\n", sc->sc_xname));
+
+ ray_cmd_cancel(sc, SCP_UPDATESUBCMD);
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ submask = SCP_UPD_FIRST;
+ for (i = 0; i < ray_nsubcmdtab; submask <<= 1, i++) {
+ if ((sc->sc_scheduled & SCP_UPD_MASK) == 0)
+ break;
+ /* when done the next command will be scheduled */
+ if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD))
+ break;
+ if (!RAY_ECF_READY(sc))
+ break;
+ /*
+ * give priority to LSB -- e.g., if previous loop reschuled
+ * doing this command after calling the function won't catch
+ * if a later command sets an earlier bit
+ */
+ if (sc->sc_scheduled & ((submask - 1) & SCP_UPD_MASK))
+ break;
+ if (sc->sc_scheduled & submask)
+ (*ray_subcmdtab[i])(sc);
+ }
+}
+
+/*
+ * report a parameter
+ */
+void
+ray_report_params(sc)
+ struct ray_softc *sc;
+{
+ bus_size_t ccs;
+
+ ray_cmd_cancel(sc, SCP_REPORTPARAMS);
+
+ if (!sc->sc_repreq)
+ return;
+
+ /* do the issue check before equality check */
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ else if (ray_cmd_is_running(sc, SCP_REPORTPARAMS)) {
+ ray_cmd_schedule(sc, SCP_REPORTPARAMS);
+ return;
+ } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_REPORT_PARAMS,
+ SCP_REPORTPARAMS))
+ return;
+
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_paramid,
+ sc->sc_repreq->r_paramid);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_report, c_nparam, 1);
+ (void)ray_issue_cmd(sc, ccs, SCP_REPORTPARAMS);
+}
+
+/*
+ * start an association
+ */
+void
+ray_start_assoc(sc)
+ struct ray_softc *sc;
+{
+ ray_cmd_cancel(sc, SCP_STARTASSOC);
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ else if (ray_cmd_is_running(sc, SCP_STARTASSOC))
+ return;
+ (void)ray_simple_cmd(sc, RAY_CMD_START_ASSOC, SCP_STARTASSOC);
+}
+
+/*
+ * Subcommand functions that use the SCP_UPDATESUBCMD command
+ * (and are serialized with respect to other update sub commands
+ */
+
+/*
+ * download the startup parameters to the card
+ * -- no outstanding commands expected
+ */
+void
+ray_download_params(sc)
+ struct ray_softc *sc;
+{
+ struct ray_startup_params_head *sp;
+ struct ray_startup_params_tail_5 *sp5;
+ struct ray_startup_params_tail_4 *sp4;
+ bus_size_t off;
+
+ RAY_DPRINTF(("%s: init_startup_params\n", sc->sc_xname));
+
+ ray_cmd_cancel(sc, SCP_UPD_STARTUP);
+
+#define PUT2(p, v) \
+ do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0)
+
+ sp = &sc->sc_startup;
+ sp4 = &sc->sc_startup_4;
+ sp5 = &sc->sc_startup_5;
+ memset(sp, 0, sizeof(*sp));
+ if (sc->sc_version == SC_BUILD_4)
+ memset(sp4, 0, sizeof(*sp4));
+ else
+ memset(sp5, 0, sizeof(*sp5));
+ memcpy(sp->sp_ssid, sc->sc_dnwid, sizeof(sp->sp_ssid));
+ sp->sp_scan_mode = 0x1;
+ memcpy(sp->sp_mac_addr, sc->sc_ecf_startup.e_station_addr,
+ ETHER_ADDR_LEN);
+ PUT2(sp->sp_frag_thresh, 0x7fff); /* disabled */
+ if (sc->sc_version == SC_BUILD_4) {
+#if 1
+ /* linux/fbsd */
+ PUT2(sp->sp_dwell_time, 0x200);
+ PUT2(sp->sp_beacon_period, 1);
+#else
+ /* divined */
+ PUT2(sp->sp_dwell_time, 0x400);
+ PUT2(sp->sp_beacon_period, 0);
+#endif
+ } else {
+ PUT2(sp->sp_dwell_time, 128);
+ PUT2(sp->sp_beacon_period, 256);
+ }
+ sp->sp_dtim_interval = 1;
+#if 0
+ /* these are the documented defaults for build 5/6 */
+ sp->sp_max_retry = 0x1f;
+ sp->sp_ack_timo = 0x86;
+ sp->sp_sifs = 0x1c;
+#elif 1
+ /* these were scrounged from the linux driver */
+ sp->sp_max_retry = 0x07;
+
+ sp->sp_ack_timo = 0xa3;
+ sp->sp_sifs = 0x1d;
+#else
+ /* these were divined */
+ sp->sp_max_retry = 0x03;
+
+ sp->sp_ack_timo = 0xa3;
+ sp->sp_sifs = 0x1d;
+#endif
+#if 0
+ /* these are the documented defaults for build 5/6 */
+ sp->sp_difs = 0x82;
+ sp->sp_pifs = 0;
+#else
+ /* linux/fbsd */
+ sp->sp_difs = 0x82;
+
+ if (sc->sc_version == SC_BUILD_4)
+ sp->sp_pifs = 0xce;
+ else
+ sp->sp_pifs = 0x4e;
+#endif
+
+ PUT2(sp->sp_rts_thresh, 0x7fff); /* disabled */
+ if (sc->sc_version == SC_BUILD_4) {
+ PUT2(sp->sp_scan_dwell, 0xfb1e);
+ PUT2(sp->sp_scan_max_dwell, 0xc75c);
+ } else {
+ PUT2(sp->sp_scan_dwell, 0x4e2);
+ PUT2(sp->sp_scan_max_dwell, 0x38a4);
+ }
+ sp->sp_assoc_timo = 0x5;
+ if (sc->sc_version == SC_BUILD_4) {
+#if 1 /* obsd */
+ /* linux/fbsd */
+ sp->sp_adhoc_scan_cycle = 0x4;
+ sp->sp_infra_scan_cycle = 0x2;
+ sp->sp_infra_super_scan_cycle = 0x4;
+#else
+ /* divined */
+ sp->sp_adhoc_scan_cycle = 0x8;
+ sp->sp_infra_scan_cycle = 0x1;
+ sp->sp_infra_super_scan_cycle = 0x18;
+#endif
+ } else {
+ sp->sp_adhoc_scan_cycle = 0x8;
+ sp->sp_infra_scan_cycle = 0x2;
+ sp->sp_infra_super_scan_cycle = 0x8;
+ }
+ sp->sp_promisc = sc->sc_promisc;
+ PUT2(sp->sp_uniq_word, 0x0cbd);
+ if (sc->sc_version == SC_BUILD_4) {
+ /* XXX whats this value anyway.. the std says 50us */
+ /* XXX sp->sp_slot_time = 0x4e; */
+ sp->sp_slot_time = 0x4e;
+#if 1
+ /*linux/fbsd*/
+ sp->sp_roam_low_snr_thresh = 0xff;
+#else
+ /*divined*/
+ sp->sp_roam_low_snr_thresh = 0x30;
+#endif
+ } else {
+ sp->sp_slot_time = 0x32;
+ sp->sp_roam_low_snr_thresh = 0xff; /* disabled */
+ }
+#if 1
+ sp->sp_low_snr_count = 0xff; /* disabled */
+#else
+ /* divined -- check */
+ sp->sp_low_snr_count = 0x07; /* disabled */
+#endif
+#if 0
+ sp->sp_infra_missed_beacon_count = 0x2;
+#elif 1
+ /* linux/fbsd */
+ sp->sp_infra_missed_beacon_count = 0x5;
+#else
+ /* divined -- check, looks fishy */
+ sp->sp_infra_missed_beacon_count = 0x7;
+#endif
+ sp->sp_adhoc_missed_beacon_count = 0xff;
+ sp->sp_country_code = sc->sc_dcountrycode;
+ sp->sp_hop_seq = 0x0b;
+ if (sc->sc_version == SC_BUILD_4) {
+ sp->sp_hop_seq_len = 0x4e;
+ sp4->sp_cw_max = 0x3f; /* single byte on build 4 */
+ sp4->sp_cw_min = 0x0f; /* single byte on build 4 */
+ sp4->sp_noise_filter_gain = 0x4;
+ sp4->sp_noise_limit_offset = 0x8;
+ sp4->sp_rssi_thresh_offset = 0x28;
+ sp4->sp_busy_thresh_offset = 0x28;
+ sp4->sp_sync_thresh = 0x07;
+ sp4->sp_test_mode = 0x0;
+ sp4->sp_test_min_chan = 0x2;
+ sp4->sp_test_max_chan = 0x2;
+ } else {
+ sp->sp_hop_seq_len = 0x4f;
+ PUT2(sp5->sp_cw_max, 0x3f);
+ PUT2(sp5->sp_cw_min, 0x0f);
+ sp5->sp_noise_filter_gain = 0x4;
+ sp5->sp_noise_limit_offset = 0x8;
+ sp5->sp_rssi_thresh_offset = 0x28;
+ sp5->sp_busy_thresh_offset = 0x28;
+ sp5->sp_sync_thresh = 0x07;
+ sp5->sp_test_mode = 0x0;
+ sp5->sp_test_min_chan = 0x2;
+ sp5->sp_test_max_chan = 0x2;
+#if 0
+ sp5->sp_allow_probe_resp = 0x1;
+#else
+ sp5->sp_allow_probe_resp = 0x0;
+#endif
+ sp5->sp_privacy_must_start = 0x0;
+ sp5->sp_privacy_can_join = 0x0;
+ sp5->sp_basic_rate_set[0] = 0x2;
+ /* 2 = 1Mbps, 3 = old 2Mbps 4 = 2Mbps */
+ }
+
+ /* we shouldn't be called with some command pending */
+ if (!RAY_ECF_READY(sc))
+ panic("ray_download_params busy");
+
+ /* write the compatible part */
+ off = RAY_HOST_TO_ECF_BASE;
+ ray_write_region(sc, off, sp, sizeof(sc->sc_startup));
+ off += sizeof(sc->sc_startup);
+ if (sc->sc_version == SC_BUILD_4)
+ ray_write_region(sc, off, sp4, sizeof(*sp4));
+ else
+ ray_write_region(sc, off, sp5, sizeof(*sp5));
+ if (!ray_simple_cmd(sc, RAY_CMD_START_PARAMS, SCP_UPD_STARTUP))
+ panic("ray_download_params issue");
+}
+
+/*
+ * start or join a network
+ */
+void
+ray_start_join_net(sc)
+ struct ray_softc *sc;
+{
+ struct ray_net_params np;
+ bus_size_t ccs;
+ int cmd;
+
+ ray_cmd_cancel(sc, SCP_UPD_STARTJOIN);
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+
+ /* XXX check we may not want to re-issue */
+ if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
+ ray_cmd_schedule(sc, SCP_UPD_STARTJOIN);
+ return;
+ }
+
+ if (sc->sc_mode == SC_MODE_ADHOC)
+ cmd = RAY_CMD_START_NET;
+ else
+ cmd = RAY_CMD_JOIN_NET;
+
+ if (!ray_alloc_ccs(sc, &ccs, cmd, SCP_UPD_STARTJOIN))
+ return;
+ sc->sc_startccs = ccs;
+ sc->sc_startcmd = cmd;
+ if (!memcmp(sc->sc_cnwid, sc->sc_dnwid, sizeof(sc->sc_cnwid))
+ && sc->sc_omode == sc->sc_mode)
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 0);
+ else {
+ sc->sc_havenet = 0;
+ memset(&np, 0, sizeof(np));
+ np.p_net_type = sc->sc_mode;
+ memcpy(np.p_ssid, sc->sc_dnwid, sizeof(np.p_ssid));
+ ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 1);
+ }
+ if (ray_issue_cmd(sc, ccs, SCP_UPD_STARTJOIN))
+ timeout(ray_start_join_timo, sc, RAY_START_TIMEOUT);
+}
+
+void
+ray_start_join_timo(arg)
+ void *arg;
+{
+ struct ray_softc *sc;
+ u_int stat;
+
+ sc = arg;
+ stat = SRAM_READ_FIELD_1(sc, sc->sc_startccs, ray_cmd, c_status);
+ ray_start_join_net_done(sc, sc->sc_startcmd, sc->sc_startccs, stat);
+}
+
+/*
+ * The start/join has completed. Note: we timeout the start
+ * command because it seems to fail to work at least on the
+ * build 4 firmware without reporting an error. This actually
+ * may be a result of not putting the correct params in the
+ * initial download. If this is a timeout `stat' will be
+ * marked busy.
+ */
+ray_cmd_func_t
+ray_start_join_net_done(sc, cmd, ccs, stat)
+ struct ray_softc *sc;
+ u_int cmd;
+ bus_size_t ccs;
+ u_int stat;
+{
+ struct ray_net_params np;
+
+ untimeout(ray_start_join_timo, sc);
+ ray_cmd_done(sc, SCP_UPD_STARTJOIN);
+
+ if (stat == RAY_CCS_STATUS_FAIL) {
+ /* XXX poke ifmedia when it supports this */
+ sc->sc_havenet = 0;
+ return (ray_start_join_net);
+ }
+ if (stat == RAY_CCS_STATUS_BUSY || stat == RAY_CCS_STATUS_FREE) {
+ /* handle the timeout condition */
+ timeout(ray_start_join_timo, sc, RAY_START_TIMEOUT);
+
+ /* be safe -- not a lot occurs with no net though */
+ if (!RAY_ECF_READY(sc))
+ return (0);
+
+ /* see if our nwid is up to date */
+ if (!memcmp(sc->sc_cnwid, sc->sc_dnwid, sizeof(sc->sc_cnwid))
+ && sc->sc_omode == sc->sc_mode)
+ SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 0);
+ else {
+ memset(&np, 0, sizeof(np));
+ np.p_net_type = sc->sc_mode;
+ memcpy(np.p_ssid, sc->sc_dnwid, sizeof(np.p_ssid));
+ ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &np,
+ sizeof(np));
+ SRAM_WRITE_FIELD_1(sc,ccs, ray_cmd_net, c_upd_param, 1);
+ }
+
+ if (sc->sc_mode == SC_MODE_ADHOC)
+ cmd = RAY_CMD_START_NET;
+ else
+ cmd = RAY_CMD_JOIN_NET;
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_cmd,
+ RAY_CCS_STATUS_BUSY);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_status,
+ RAY_CCS_STATUS_BUSY);
+
+ /* we simply poke the card again issuing the same ccs */
+ SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_GET_INDEX(ccs));
+ RAY_ECF_START_CMD(sc);
+ ray_cmd_ran(sc, SCP_UPD_STARTJOIN);
+ return (0);
+ }
+ /* get the current ssid */
+ SRAM_READ_FIELD_N(sc, ccs, ray_cmd_net, c_bss_id, sc->sc_bssid,
+ sizeof(sc->sc_bssid));
+
+ sc->sc_deftxrate = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net,c_def_txrate);
+ sc->sc_encrypt = SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_encrypt);
+
+ /* adjust values for buggy build 4 */
+ if (sc->sc_deftxrate == 0x55)
+ sc->sc_deftxrate = RAY_PID_BASIC_RATE_1500K;
+ if (sc->sc_encrypt == 0x55)
+ sc->sc_encrypt = 0;
+
+ if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param)) {
+ ray_read_region(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
+ memcpy(sc->sc_cnwid, np.p_ssid, sizeof(sc->sc_cnwid));
+ sc->sc_omode = sc->sc_mode;
+ if (np.p_net_type != sc->sc_mode)
+ return (ray_start_join_net);
+ }
+ RAY_DPRINTF(("%s: net start/join nwid %.32s bssid %s inited %d\n",
+ sc->sc_xname, sc->sc_cnwid, ether_sprintf(sc->sc_bssid),
+ SRAM_READ_FIELD_1(sc, ccs, ray_cmd_net, c_inited)));
+
+ /* network is now active */
+ ray_cmd_schedule(sc, SCP_UPD_MCAST|SCP_UPD_PROMISC);
+ if (cmd == RAY_CMD_JOIN_NET)
+ return (ray_start_assoc);
+ else {
+ sc->sc_havenet = 1;
+ return (ray_intr_start);
+ }
+}
+
+/*
+ * set the card in/out of promiscuous mode
+ */
+void
+ray_update_promisc(sc)
+ struct ray_softc *sc;
+{
+ bus_size_t ccs;
+ int promisc;
+
+ ray_cmd_cancel(sc, SCP_UPD_PROMISC);
+
+ /* do the issue check before equality check */
+ promisc = !!(sc->sc_if.if_flags & (IFF_PROMISC | IFF_ALLMULTI));
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
+ ray_cmd_schedule(sc, SCP_UPD_PROMISC);
+ return;
+ } else if (promisc == sc->sc_promisc)
+ return;
+ else if (!ray_alloc_ccs(sc,&ccs,RAY_CMD_UPDATE_PARAMS, SCP_UPD_PROMISC))
+ return;
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid, RAY_PID_PROMISC);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1);
+ SRAM_WRITE_1(sc, RAY_HOST_TO_ECF_BASE, promisc);
+ (void)ray_issue_cmd(sc, ccs, SCP_UPD_PROMISC);
+}
+
+/*
+ * update the parameter based on what the user passed in
+ */
+void
+ray_update_params(sc)
+ struct ray_softc *sc;
+{
+ bus_size_t ccs;
+
+ ray_cmd_cancel(sc, SCP_UPD_UPDATEPARAMS);
+ if (!sc->sc_updreq) {
+ /* XXX do we need to wakeup here? */
+ return;
+ }
+
+ /* do the issue check before equality check */
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
+ ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS);
+ return;
+ } else if (!ray_alloc_ccs(sc, &ccs, RAY_CMD_UPDATE_PARAMS,
+ SCP_UPD_UPDATEPARAMS))
+ return;
+
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_paramid,
+ sc->sc_updreq->r_paramid);
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update, c_nparam, 1);
+ ray_write_region(sc, RAY_HOST_TO_ECF_BASE, sc->sc_updreq->r_data,
+ sc->sc_updreq->r_len);
+
+ (void)ray_issue_cmd(sc, ccs, SCP_UPD_UPDATEPARAMS);
+}
+
+/*
+ * set the multicast filter list
+ */
+void
+ray_update_mcast(sc)
+ struct ray_softc *sc;
+{
+ bus_size_t ccs;
+ struct ether_multistep step;
+ struct ether_multi *enm;
+#ifdef __NetBSD__
+ struct ethercom *ec;
+#elif defined(__OpenBSD__)
+ struct arpcom *ec;
+#endif
+ bus_size_t bufp;
+ int count;
+
+ ec = &sc->sc_ec;
+ ray_cmd_cancel(sc, SCP_UPD_MCAST);
+
+ /* see if we have any ranges */
+ if ((count = sc->sc_ec.ec_multicnt) < 17) {
+ ETHER_FIRST_MULTI(step, ec, enm);
+ while (enm) {
+ /* see if this is a range */
+ if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
+ ETHER_ADDR_LEN)) {
+ count = 17;
+ break;
+ }
+ ETHER_NEXT_MULTI(step, enm);
+ }
+ }
+
+ /* track this stuff even when not running */
+ if (count > 16) {
+ sc->sc_if.if_flags |= IFF_ALLMULTI;
+ ray_update_promisc(sc);
+ return;
+ } else if (sc->sc_if.if_flags & IFF_ALLMULTI) {
+ sc->sc_if.if_flags &= ~IFF_ALLMULTI;
+ ray_update_promisc(sc);
+ }
+
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0)
+ return;
+ else if (ray_cmd_is_running(sc, SCP_UPDATESUBCMD)) {
+ ray_cmd_schedule(sc, SCP_UPD_MCAST);
+ return;
+ } else if (!ray_alloc_ccs(sc,&ccs, RAY_CMD_UPDATE_MCAST, SCP_UPD_MCAST))
+ return;
+ SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_update_mcast, c_nmcast, count);
+ bufp = RAY_HOST_TO_ECF_BASE;
+ ETHER_FIRST_MULTI(step, ec, enm);
+ while (enm) {
+ ray_write_region(sc, bufp, enm->enm_addrlo, ETHER_ADDR_LEN);
+ bufp += ETHER_ADDR_LEN;
+ ETHER_NEXT_MULTI(step, enm);
+ }
+ (void)ray_issue_cmd(sc, ccs, SCP_UPD_MCAST);
+}
+
+/*
+ * User issued commands
+ */
+
+/*
+ * issue a update params
+ *
+ * expected to be called in sleapable context -- intended for user stuff
+ */
+int
+ray_user_update_params(sc, pr)
+ struct ray_softc *sc;
+ struct ray_param_req *pr;
+{
+ int rv;
+
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
+ pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ return (EIO);
+ }
+
+ /* wait to be able to issue the command */
+ rv = 0;
+ while (ray_cmd_is_running(sc, SCP_UPD_UPDATEPARAMS) ||
+ ray_cmd_is_scheduled(sc, SCP_UPD_UPDATEPARAMS)) {
+ rv = tsleep(ray_update_params, 0|PCATCH, "cmd in use", 0);
+ if (rv)
+ return (rv);
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
+ pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ return (EIO);
+ }
+ }
+
+ pr->r_failcause = RAY_FAILCAUSE_WAITING;
+ sc->sc_updreq = pr;
+ ray_cmd_schedule(sc, SCP_UPD_UPDATEPARAMS);
+ ray_check_scheduled(sc);
+
+ while (pr->r_failcause == RAY_FAILCAUSE_WAITING)
+ (void)tsleep(ray_update_params, 0, "waiting cmd", 0);
+ wakeup(ray_update_params);
+
+ return (0);
+}
+
+/*
+ * issue a report params
+ *
+ * expected to be called in sleapable context -- intended for user stuff
+ */
+int
+ray_user_report_params(sc, pr)
+ struct ray_softc *sc;
+ struct ray_param_req *pr;
+{
+ int rv;
+
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
+ pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ return (EIO);
+ }
+
+ /* wait to be able to issue the command */
+ rv = 0;
+ while (ray_cmd_is_running(sc, SCP_REPORTPARAMS)
+ || ray_cmd_is_scheduled(sc, SCP_REPORTPARAMS)) {
+ rv = tsleep(ray_report_params, 0|PCATCH, "cmd in use", 0);
+ if (rv)
+ return (rv);
+ if ((sc->sc_if.if_flags & IFF_RUNNING) == 0) {
+ pr->r_failcause = RAY_FAILCAUSE_EDEVSTOP;
+ return (EIO);
+ }
+ }
+
+ pr->r_failcause = RAY_FAILCAUSE_WAITING;
+ sc->sc_repreq = pr;
+ ray_cmd_schedule(sc, SCP_REPORTPARAMS);
+ ray_check_scheduled(sc);
+
+ while (pr->r_failcause == RAY_FAILCAUSE_WAITING)
+ (void)tsleep(ray_report_params, 0, "waiting cmd", 0);
+ wakeup(ray_report_params);
+
+ return (0);
+}
+
+
+/*
+ * this is a temporary wrapper around bus_space_read_region_1
+ * as it seems to mess with gcc. the line numbers get offset
+ * presumably this is related to the inline asm on i386.
+ */
+
+void
+ray_read_region(sc, off, vp, c)
+ struct ray_softc *sc;
+ bus_size_t off;
+ void *vp;
+ size_t c;
+{
+#ifdef RAY_USE_OPTIMIZED_COPY
+ u_int n2, n4, tmp;
+ u_int8_t *p;
+
+ p = vp;
+
+ /* XXX we may be making poor assumptions here but lets hope */
+ switch ((off|(bus_addr_t)p) & 0x03) {
+ case 0:
+ if ((n4 = c / 4)) {
+ bus_space_read_region_4(sc->sc_memt, sc->sc_memh, off,
+ p, n4);
+ tmp = c & ~0x3;
+ c &= 0x3;
+ p += tmp;
+ off += tmp;
+ }
+ switch (c) {
+ case 3:
+ *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
+ p++, off++;
+ case 2:
+ *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
+ p++, off++;
+ case 1:
+ *p = bus_space_read_1(sc->sc_memt,sc->sc_memh, off);
+ }
+ break;
+ case 2:
+ if ((n2 = (c >> 1)))
+ bus_space_read_region_2(sc->sc_memt, sc->sc_memh, off,
+ p, n2);
+ if (c & 1) {
+ c &= ~0x1;
+ *(p + c) = bus_space_read_1(sc->sc_memt, sc->sc_memh,
+ off + c);
+ }
+ break;
+ case 1:
+ case 3:
+ bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, p, c);
+ break;
+ }
+#else
+ bus_space_read_region_1(sc->sc_memt, sc->sc_memh, off, vp, c);
+#endif
+}
+
+/*
+ * this is a temporary wrapper around bus_space_write_region_1
+ * as it seems to mess with gcc. the line numbers get offset
+ * presumably this is related to the inline asm on i386.
+ */
+void
+ray_write_region(sc, off, vp, c)
+ struct ray_softc *sc;
+ bus_size_t off;
+ void *vp;
+ size_t c;
+{
+#ifdef RAY_USE_OPTIMIZED_COPY
+ size_t n2, n4, tmp;
+ u_int8_t *p;
+
+ p = vp;
+ /* XXX we may be making poor assumptions here but lets hope */
+ switch ((off|(bus_addr_t)p) & 0x03) {
+ case 0:
+ if ((n4 = (c >> 2))) {
+ bus_space_write_region_4(sc->sc_memt, sc->sc_memh, off,
+ p, n4);
+ tmp = c & ~0x3;
+ c &= 0x3;
+ p += tmp;
+ off += tmp;
+ }
+ switch (c) {
+ case 3:
+ bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
+ p++, off++;
+ case 2:
+ bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
+ p++, off++;
+ case 1:
+ bus_space_write_1(sc->sc_memt,sc->sc_memh, off, *p);
+ }
+ break;
+ case 2:
+ if ((n2 = (c >> 1)))
+ bus_space_write_region_2(sc->sc_memt, sc->sc_memh, off,
+ p, n2);
+ if (c & 0x1) {
+ c &= ~0x1;
+ bus_space_write_1(sc->sc_memt, sc->sc_memh,
+ off + c, *(p + c));
+ }
+ break;
+ case 1:
+ case 3:
+ bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, p, c);
+ break;
+ }
+#else
+ bus_space_write_region_1(sc->sc_memt, sc->sc_memh, off, vp, c);
+#endif
+}
+
+#ifdef RAY_DEBUG
+
+#define PRINTABLE(c) ((c) >= 0x20 && (c) <= 0x7f)
+
+void
+hexdump(const u_int8_t *d, int len, int br, int div, int fl)
+{
+ int i, j, offw, first, tlen, ni, nj, sp;
+
+ sp = br / div;
+ offw = 0;
+ if (len && (fl & HEXDF_NOOFFSET) == 0) {
+ tlen = len;
+ do {
+ offw++;
+ } while (tlen /= br);
+ }
+ if (offw)
+ printf("%0*x: ", offw, 0);
+ for (i = 0; i < len; i++, d++) {
+ if (i && (i % br) == 0) {
+ if ((fl & HEXDF_NOASCII) == 0) {
+ printf(" ");
+ d -= br;
+ for (j = 0; j < br; d++, j++) {
+ if (j && (j % sp) == 0)
+ printf(" ");
+ if (PRINTABLE(*d))
+ printf("%c", (int)*d);
+ else
+ printf(".");
+ }
+ }
+ if (offw)
+ printf("\n%0*x: ", offw, i);
+ else
+ printf("\n");
+ if ((fl & HEXDF_NOCOMPRESS) == 0) {
+ first = 1;
+ while (len - i >= br) {
+ if (memcmp(d, d - br, br))
+ break;
+ d += br;
+ i += br;
+ if (first) {
+ printf("*");
+ first = 0;
+ }
+ }
+ if (len == i) {
+ printf("\n%0*x", offw, i);
+ return;
+ }
+ }
+ } else if (i && (i % sp) == 0)
+ printf(" ");
+ printf("%02x ", *d);
+ }
+ if (len && (((i - 1) % br) || i == 1)) {
+ if ((fl & HEXDF_NOASCII) == 0) {
+ i = i % br ? i % br : br;
+ ni = (br - i) % br;
+ j = (i - 1) / sp;
+ nj = (div - j - 1) % div;
+ j = 3 * ni + nj + 3;
+ printf("%*s", j, "");
+ d -= i;
+ for (j = 0; j < i; d++, j++) {
+ if (j && (j % sp) == 0)
+ printf(" ");
+ if (PRINTABLE(*d))
+ printf("%c", (int)*d);
+ else
+ printf(".");
+ }
+ }
+ printf("\n");
+ }
+}
+
+
+
+void
+ray_dump_mbuf(sc, m)
+ struct ray_softc *sc;
+ struct mbuf *m;
+{
+ u_int8_t *d, *ed;
+ u_int i;
+
+ printf("%s: pkt dump:", sc->sc_xname);
+ i = 0;
+ for (; m; m = m->m_next) {
+ d = mtod(m, u_int8_t *);
+ ed = d + m->m_len;
+
+ for (; d < ed; i++, d++) {
+ if ((i % 16) == 0)
+ printf("\n\t");
+ else if ((i % 8) == 0)
+ printf(" ");
+ printf(" %02x", *d);
+ }
+ }
+ if ((i - 1) % 16)
+ printf("\n");
+}
+#endif /* RAY_DEBUG */
+
+#ifdef RAY_DO_SIGLEV
+static void
+ray_update_siglev(sc, src, siglev)
+ struct ray_softc *sc;
+ u_int8_t *src;
+ u_int8_t siglev;
+{
+ int i, mini;
+ struct timeval mint;
+ struct ray_siglev *sl;
+
+ /* try to find host */
+ for (i = 0; i < RAY_NSIGLEVRECS; i++) {
+ sl = &sc->sc_siglevs[i];
+ if (memcmp(sl->rsl_host, src, ETHER_ADDR_LEN) == 0)
+ goto found;
+ }
+ /* not found, find oldest slot */
+ mini = 0;
+ mint.tv_sec = LONG_MAX;
+ mint.tv_usec = 0;
+ for (i = 0; i < RAY_NSIGLEVRECS; i++) {
+ sl = &sc->sc_siglevs[i];
+ if (timercmp(&sl->rsl_time, &mint, <)) {
+ mini = i;
+ mint = sl->rsl_time;
+ }
+ }
+ sl = &sc->sc_siglevs[mini];
+ memset(sl->rsl_siglevs, 0, RAY_NSIGLEV);
+ memcpy(sl->rsl_host, src, ETHER_ADDR_LEN);
+
+ found:
+ microtime(&sl->rsl_time);
+ memmove(&sl->rsl_siglevs[1], sl->rsl_siglevs, RAY_NSIGLEV-1);
+ sl->rsl_siglevs[0] = siglev;
+}
+#endif
--- /dev/null
+/* $OpenBSD: if_rayreg.h,v 1.1 2000/03/22 04:40:58 mickey Exp $ */
+/* $NetBSD: if_rayreg.h,v 1.2 2000/02/27 20:40:43 augustss Exp $ */
+
+/*
+ * Copyright (c) 2000 Christian E. Hopps
+ * 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. 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 THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#define RAY_MAXSSIDLEN 32
+
+/*
+ * CCR registers
+ */
+#define RAY_COR (0xf00 + 0) /* config option register */
+#define RAY_CCSR (0xf00 + 1) /* card config and status register */
+#define RAY_PIN (0xf00 + 2) /* not in hw */
+#define RAY_SOCKETCOPY (0xf00 + 3) /* not used by hw */
+#define RAY_HCSIR (0xf00 + 5) /* HCS intr register */
+#define RAY_ECFIR (0xf00 + 6) /* ECF intr register */
+#define RAY_AR0 (0xf00 + 8) /* authorization register 0 (unused) */
+#define RAY_AR1 (0xf00 + 9) /* authorization register 1 (unused) */
+/*
+ * XXX these registers cannot be accessed with pcmcia.c's 14 byte mapping
+ * of the CCR for us
+ */
+#if 0
+#define RAY_PMR 0xf0a /* program mode register (unused) */
+#define RAY_TMR 0xf0b /* pc test mode register (unused) */
+#define RAY_FCWR 0xf10 /* frequency control word register */
+#define RAY_TMC1 0xf14 /* test mode control 1 (unused) */
+#define RAY_TMC2 0xf15 /* test mode control 1 (unused) */
+#define RAY_TMC3 0xf16 /* test mode control 1 (unused) */
+#define RAY_TMC4 0xf17 /* test mode control 1 (unused) */
+#endif
+
+/*
+ * COR register bits
+ */
+#define RAY_COR_CFG_NUM 0x01 /* currently ignored and set */
+#define RAY_COR_CFG_MASK 0x3f /* mask for function */
+#define RAY_COR_LEVEL_IRQ 0x40 /* currently ignored and set */
+#define RAY_COR_RESET 0x80 /* soft-reset the card */
+
+/*
+ * CCS register bits
+ */
+/* XXX the linux driver indicates bit 0 is the irq bit */
+#define RAY_CCS_IRQ 0x02 /* interrupt pending */
+#define RAY_CCS_POWER_DOWN 0x04
+
+/*
+ * HCSI register bits
+ *
+ * the host can only clear this bit.
+ */
+#define RAY_HCSIR_IRQ 0x01 /* indicates an interrupt */
+
+/*
+ * ECFI register values
+ */
+#define RAY_ECSIR_IRQ 0x01 /* interrupt the card */
+
+/*
+ * authorization register 0 values
+ * -- used for testing/programming the card (unused)
+ */
+#define RAY_AR0_ON 0x57
+
+/*
+ * authorization register 1 values
+ * -- used for testing/programming the card (unused)
+ */
+#define RAY_AR1_ON 0x82
+
+/*
+ * PMR bits -- these are used to program the card (unused)
+ */
+#define RAY_PMR_PC2PM 0x02 /* grant access to firmware flash */
+#define RAY_PMR_PC2CAL 0x10 /* read access to the A/D modem inp */
+#define RAY_PMR_MLSE 0x20 /* read access to the MSLE prom */
+
+/*
+ * TMR bits -- get access to test modes (unused)
+ */
+#define RAY_TMR_TEST 0x08 /* test mode */
+
+/*
+ * FCWR -- frequency control word, values from [0x02,0xA6] map to
+ * RF frequency values.
+ */
+
+/*
+ * 48k of memory -- would like to map this into smaller isa windows
+ * but doesn't seem currently possible with the pcmcia code
+ */
+#define RAY_SRAM_MEM_BASE 0
+#define RAY_SRAM_MEM_SIZE 0xc000
+
+/*
+ * offsets into shared ram
+ */
+#define RAY_SCB_BASE 0x0 /* cfg/status/ctl area */
+#define RAY_STATUS_BASE 0x0100
+#define RAY_HOST_TO_ECF_BASE 0x0200
+#define RAY_ECF_TO_HOST_BASE 0x0300
+#define RAY_CCS_BASE 0x0400
+#define RAY_RCS_BASE 0x0800
+#define RAY_APOINT_TIM_BASE 0x0c00
+#define RAY_SSID_LIST_BASE 0x0d00
+#define RAY_TX_BASE 0x1000
+#define RAY_TX_SIZE 0x7000
+#define RAY_TX_END 0x8000
+#define RAY_RX_BASE 0x8000
+#define RAY_RX_END 0xc000
+#define RAY_RX_MASK 0x3fff
+
+struct ray_ecf_startup {
+ u_int8_t e_status; /* RAY_ECFS_ */
+ u_int8_t e_station_addr[ETHER_ADDR_LEN];
+ u_int8_t e_resv0;
+ u_int8_t e_rates[8];
+ u_int8_t e_japan_callsign[12];
+ u_int8_t e_prg_cksum;
+ u_int8_t e_cis_cksum;
+ u_int8_t e_fw_build_string;
+ u_int8_t e_fw_build;
+ u_int8_t e_fw_resv;
+ u_int8_t e_asic_version;
+ u_int8_t e_tib_size;
+ u_int8_t e_resv1[29];
+};
+
+#define RAY_ECFS_RESERVED0 0x01
+#define RAY_ECFS_PROC_SELF_TEST 0x02
+#define RAY_ECFS_PROG_MEM_CHECKSUM 0x04
+#define RAY_ECFS_DATA_MEM_TEST 0x08
+#define RAY_ECFS_RX_CALIBRATION 0x10
+#define RAY_ECFS_FW_VERSION_COMPAT 0x20
+#define RAY_ECFS_RERSERVED1 0x40
+#define RAY_ECFS_TEST_COMPLETE 0x80
+#define RAY_ECFS_CARD_OK RAY_ECFS_TEST_COMPLETE
+
+/* configure/status/control memory */
+struct ray_csc {
+ u_int8_t csc_mrxo_own; /* 0 ECF writes, 1 host write */
+ u_int8_t csc_mrxc_own; /* " */
+ u_int8_t csc_rxhc_own; /* " */
+ u_int8_t csc_resv;
+ u_int16_t csc_mrx_overflow; /* ECF incs on rx overflow */
+ u_int16_t csc_mrx_cksum; /* " on cksum error */
+ u_int16_t csc_rx_hcksum; /* " on header cksum error */
+ u_int8_t csc_rx_noise; /* average RSL measuremant */
+};
+
+/* status area */
+struct ray_status {
+ u_int8_t st_startup_word;
+ u_int8_t st_station_addr[ETHER_ADDR_LEN];
+ u_int8_t st_calc_prog_cksum;
+ u_int8_t st_calc_cis_cksum;
+ u_int8_t st_ecf_spare[7];
+ u_int8_t st_japan_callsign[12];
+};
+
+/*
+ * Host to ECF data formats
+ */
+struct ray_startup_params_head {
+ u_int8_t sp_net_type; /* 0: ad-hoc 1: infra */
+ u_int8_t sp_ap_status; /* 0: terminal 1: access-point */
+ u_int8_t sp_ssid[RAY_MAXSSIDLEN]; /* current SSID */
+ u_int8_t sp_scan_mode; /* 1: active */
+ u_int8_t sp_apm_mode; /* 0: none 1: power-saving */
+ u_int8_t sp_mac_addr[ETHER_ADDR_LEN];
+ u_int8_t sp_frag_thresh[2];
+/*2c*/ u_int8_t sp_dwell_time[2];
+/*2e*/ u_int8_t sp_beacon_period[2];
+/*30*/ u_int8_t sp_dtim_interval;
+/*31*/ u_int8_t sp_max_retry; /* number of times to attemp tx */
+/*32*/ u_int8_t sp_ack_timo;
+/*33*/ u_int8_t sp_sifs;
+/*34*/ u_int8_t sp_difs;
+/*35*/ u_int8_t sp_pifs;
+/*36*/ u_int8_t sp_rts_thresh[2];
+/*38*/ u_int8_t sp_scan_dwell[2];
+/*3a*/ u_int8_t sp_scan_max_dwell[2];
+/*3c*/ u_int8_t sp_assoc_timo;
+/*3d*/ u_int8_t sp_adhoc_scan_cycle;
+/*3e*/ u_int8_t sp_infra_scan_cycle;
+/*3f*/ u_int8_t sp_infra_super_scan_cycle;
+/*40*/ u_int8_t sp_promisc;
+/*41*/ u_int8_t sp_uniq_word[2];
+/*43*/ u_int8_t sp_slot_time;
+/*44*/ u_int8_t sp_roam_low_snr_thresh; /* if below this inc count */
+
+/*45*/ u_int8_t sp_low_snr_count; /* roam after cnt below thrsh */
+/*46*/ u_int8_t sp_infra_missed_beacon_count;
+/*47*/ u_int8_t sp_adhoc_missed_beacon_count;
+
+/*48*/ u_int8_t sp_country_code;
+/*49*/ u_int8_t sp_hop_seq;
+/*4a*/ u_int8_t sp_hop_seq_len; /* no longer supported */
+} __attribute__((__packed__));
+
+/* build 5 tail to the startup params */
+struct ray_startup_params_tail_5 {
+ u_int8_t sp_cw_max[2];
+ u_int8_t sp_cw_min[2];
+ u_int8_t sp_noise_filter_gain;
+ u_int8_t sp_noise_limit_offset;
+ u_int8_t sp_rssi_thresh_offset;
+ u_int8_t sp_busy_thresh_offset;
+ u_int8_t sp_sync_thresh;
+ u_int8_t sp_test_mode;
+ u_int8_t sp_test_min_chan;
+ u_int8_t sp_test_max_chan;
+ u_int8_t sp_allow_probe_resp;
+ u_int8_t sp_privacy_must_start;
+ u_int8_t sp_privacy_can_join;
+ u_int8_t sp_basic_rate_set[8];
+} __attribute__((__packed__));
+
+/* build 4 (webgear) tail to the startup params */
+struct ray_startup_params_tail_4 {
+/*4b*/ u_int8_t sp_cw_max; /* 2 bytes in build 5 */
+/*4c*/ u_int8_t sp_cw_min; /* 2 bytes in build 5 */
+/*4e*/ u_int8_t sp_noise_filter_gain;
+/*4f*/ u_int8_t sp_noise_limit_offset;
+ u_int8_t sp_rssi_thresh_offset;
+ u_int8_t sp_busy_thresh_offset;
+ u_int8_t sp_sync_thresh;
+ u_int8_t sp_test_mode;
+ u_int8_t sp_test_min_chan;
+ u_int8_t sp_test_max_chan;
+ /* more bytes in build 5 */
+} __attribute__((__packed__));
+
+/*
+ * Parameter IDs for the update/report param commands and values if
+ * relevant
+ */
+#define RAY_PID_NET_TYPE 0
+#define RAY_PID_AP_STATUS 1
+#define RAY_PID_SSID 2
+#define RAY_PID_SCAN_MODE 3
+#define RAY_PID_APM_MODE 4
+#define RAY_PID_MAC_ADDR 5
+#define RAY_PID_FRAG_THRESH 6
+#define RAY_PID_DWELL_TIME 7
+#define RAY_PID_BEACON_PERIOD 8
+#define RAY_PID_DTIM_INT 9
+#define RAY_PID_MAX_RETRY 10
+#define RAY_PID_ACK_TIMO 11
+#define RAY_PID_SIFS 12
+#define RAY_PID_DIFS 13
+#define RAY_PID_PIFS 14
+#define RAY_PID_RTS_THRESH 15
+#define RAY_PID_SCAN_DWELL_PERIOD 16
+#define RAY_PID_MAX_SCAN_DWELL_PERIOD 17
+#define RAY_PID_ASSOC_TIMO 18
+#define RAY_PID_ADHOC_SCAN_CYCLE 19
+#define RAY_PID_INFRA_SCAN_CYCLE 20
+#define RAY_PID_INFRA_SUPER_SCAN_CYCLE 21
+#define RAY_PID_PROMISC 22
+#define RAY_PID_UNIQ_WORD 23
+#define RAY_PID_SLOT_TIME 24
+#define RAY_PID_ROAM_LOW_SNR_THRESH 25
+#define RAY_PID_LOW_SNR_COUNT 26
+#define RAY_PID_INFRA_MISSED_BEACON_COUNT 27
+#define RAY_PID_ADHOC_MISSED_BEACON_COUNT 28
+#define RAY_PID_COUNTRY_CODE 29
+#define RAY_PID_HOP_SEQ 30
+#define RAY_PID_HOP_SEQ_LEN 31
+#define RAY_PID_CW_MAX 32
+#define RAY_PID_CW_MIN 33
+#define RAY_PID_NOISE_FILTER_GAIN 34
+#define RAY_PID_NOISE_LIMIT_OFFSET 35
+#define RAY_PID_RSSI_THRESH_OFFSET 36
+#define RAY_PID_BUSY_THRESH_OFFSET 37
+#define RAY_PID_SYNC_THRESH 38
+#define RAY_PID_TEST_MODE 39
+#define RAY_PID_TEST_MIN_CHAN 40
+#define RAY_PID_TEST_MAX_CHAN 41
+#define RAY_PID_ALLOW_PROBE_RESP 42
+#define RAY_PID_PRIVACY_MUST_START 43
+#define RAY_PID_PRIVACY_CAN_JOIN 44
+#define RAY_PID_BASIC_RATE_SET 45
+#define RAY_PID_MAX 46
+
+/*
+ * various values for the above parameters
+ */
+#define RAY_PID_NET_TYPE_ADHOC 0x00
+#define RAY_PID_NET_TYPE_INFRA 0x01
+
+#define RAY_PID_AP_STATUS_TERMINAL 0x00 /* not access-point */
+#define RAY_PID_AP_STATUS_AP 0x01 /* act as access-point */
+
+#define RAY_PID_SCAN_MODE_PASSIVE 0x00 /* hw doesn't implement */
+#define RAY_PID_SCAN_MODE_ACTIVE 0x01
+
+#define RAY_PID_APM_MODE_NONE 0x00 /* no power saving */
+#define RAY_PID_APM_MODE_PS 0x01 /* power saving mode */
+
+#define RAY_PID_COUNTRY_CODE_USA 0x1
+#define RAY_PID_COUNTRY_CODE_EUROPE 0x2
+#define RAY_PID_COUNTRY_CODE_JAPAN 0x3
+#define RAY_PID_COUNTRY_CODE_KOREA 0x4
+#define RAY_PID_COUNTRY_CODE_SPAIN 0x5
+#define RAY_PID_COUNTRY_CODE_FRANCE 0x6
+#define RAY_PID_COUNTRY_CODE_ISRAEL 0x7
+#define RAY_PID_COUNTRY_CODE_AUSTRALIA 0x8
+#define RAY_PID_COUNTRY_CODE_JAPAN_TEST 0x9
+#define RAY_PID_COUNTRY_CODE_MAX 0xa
+
+#define RAY_PID_TEST_MODE_NORMAL 0x0
+#define RAY_PID_TEST_MODE_ANT_1 0x1
+#define RAY_PID_TEST_MODE_ATN_2 0x2
+#define RAY_PID_TEST_MODE_ATN_BOTH 0x3
+
+#define RAY_PID_ALLOW_PROBE_RESP_DISALLOW 0x0
+#define RAY_PID_ALLOW_PROBE_RESP_ALLOW 0x1
+
+#define RAY_PID_PRIVACY_MUST_START_NOWEP 0x0
+#define RAY_PID_PRIVACY_MUST_START_WEP 0x1
+
+#define RAY_PID_PRIVACY_CAN_JOIN_NOWEP 0x0
+#define RAY_PID_PRIVACY_CAN_JOIN_WEP 0x1
+#define RAY_PID_PRIVACY_CAN_JOIN_DONT_CARE 0x2
+
+#define RAY_PID_BASIC_RATE_500K 1
+#define RAY_PID_BASIC_RATE_1000K 2
+#define RAY_PID_BASIC_RATE_1500K 3
+#define RAY_PID_BASIC_RATE_2000K 4
+
+/*
+ * System Control Block
+ */
+#define RAY_SCB_CCSI 0x00 /* host CCS index */
+#define RAY_SCB_RCCSI 0x01 /* ecf RCCS index */
+
+/*
+ * command control structures (for CCSR commands)
+ */
+
+/*
+ * commands for CCSR
+ */
+#define RAY_CMD_START_PARAMS 0x01 /* download start params */
+#define RAY_CMD_UPDATE_PARAMS 0x02 /* update params */
+#define RAY_CMD_REPORT_PARAMS 0x03 /* report params */
+#define RAY_CMD_UPDATE_MCAST 0x04 /* update mcast list */
+#define RAY_CMD_UPDATE_APM 0x05 /* update power saving mode */
+#define RAY_CMD_START_NET 0x06
+#define RAY_CMD_JOIN_NET 0x07
+#define RAY_CMD_START_ASSOC 0x08
+#define RAY_CMD_TX_REQ 0x09
+#define RAY_CMD_TEST_MEM 0x0a
+#define RAY_CMD_SHUTDOWN 0x0b
+#define RAY_CMD_DUMP_MEM 0x0c
+#define RAY_CMD_START_TIMER 0x0d
+#define RAY_CMD_MAX 0x0e
+
+/*
+ * unsolicted commands from the ECF
+ */
+#define RAY_ECMD_RX_DONE 0x80 /* process rx packet */
+#define RAY_ECMD_REJOIN_DONE 0x81 /* rejoined the network */
+#define RAY_ECMD_ROAM_START 0x82 /* romaining started */
+#define RAY_ECMD_JAPAN_CALL_SIGNAL 0x83 /* japan test thing */
+
+
+#define RAY_CCS_LINK_NULL 0xff
+#define RAY_CCS_SIZE 16
+
+#define RAY_CCS_TX_FIRST 0
+#define RAY_CCS_TX_LAST 13
+#define RAY_CCS_NTX (RAY_CCS_TX_LAST - RAY_CCS_TX_FIRST + 1)
+#define RAY_TX_BUF_SIZE 2048
+#define RAY_CCS_CMD_FIRST 14
+#define RAY_CCS_CMD_LAST 63
+#define RAY_CCS_NCMD (RAY_CCS_CMD_LAST - RAY_CCS_CMD_FIRST + 1)
+#define RAY_CCS_LAST 63
+
+#define RAY_RCCS_FIRST 64
+#define RAY_RCCS_LAST 127
+
+struct ray_cmd {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+};
+
+#define RAY_CCS_STATUS_FREE 0x0
+#define RAY_CCS_STATUS_BUSY 0x1
+#define RAY_CCS_STATUS_COMPLETE 0x2
+#define RAY_CCS_STATUS_FAIL 0x3
+
+/* RAY_CMD_UPDATE_PARAMS */
+struct ray_cmd_update {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_paramid;
+ u_int8_t c_nparam;
+ u_int8_t c_failcause;
+};
+
+/* RAY_CMD_REPORT_PARAMS */
+struct ray_cmd_report {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_paramid;
+ u_int8_t c_nparam;
+ u_int8_t c_failcause;
+ u_int8_t c_len;
+};
+
+/* RAY_CMD_UPDATE_MCAST */
+struct ray_cmd_update_mcast {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_nmcast;
+};
+
+/* RAY_CMD_UPDATE_APM */
+struct ray_cmd_udpate_apm {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_mode;
+};
+
+/* RAY_CMD_START_NET and RAY_CMD_JOIN_NET */
+struct ray_cmd_net {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_upd_param;
+ u_int8_t c_bss_id[ETHER_ADDR_LEN];
+ u_int8_t c_inited;
+ u_int8_t c_def_txrate;
+ u_int8_t c_encrypt;
+};
+
+/* parameters passwd in h2e section when c_upd_param is set in ray_cmd_net */
+struct ray_net_params {
+ u_int8_t p_net_type;
+ u_int8_t p_ssid[32];
+ u_int8_t p_privacy_must_start;
+ u_int8_t p_privacy_can_join;
+};
+
+/* RAY_CMD_UPDATE_ASSOC */
+struct ray_cmd_update_assoc {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_astatus;
+ u_int8_t c_aid[2];
+};
+
+/* RAY_CMD_TX_REQ */
+struct ray_cmd_tx {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_bufp[2];
+ u_int8_t c_len[2];
+ u_int8_t c_resv[5];
+ u_int8_t c_tx_rate;
+ u_int8_t c_apm_mode;
+ u_int8_t c_nretry;
+ u_int8_t c_antenna;
+};
+
+/* RAY_CMD_TX_REQ (for bulid 4) */
+struct ray_cmd_tx_4 {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_bufp[2];
+ u_int8_t c_len[2];
+ u_int8_t c_addr[ETHER_ADDR_LEN];
+ u_int8_t c_apm_mode;
+ u_int8_t c_nretry;
+ u_int8_t c_antenna;
+};
+
+/* RAY_CMD_DUMP_MEM */
+struct ray_cmd_dump_mem {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_memtype;
+ u_int8_t c_memp[2];
+ u_int8_t c_len;
+};
+
+/* RAY_CMD_START_TIMER */
+struct ray_cmd_start_timer {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_duration[2];
+};
+
+struct ray_cmd_rx {
+ u_int8_t c_status; /* ccs generic header */
+ u_int8_t c_cmd; /* " */
+ u_int8_t c_link; /* " */
+ u_int8_t c_bufp[2]; /* buffer pointer */
+ u_int8_t c_len[2]; /* length */
+ u_int8_t c_siglev; /* signal level */
+ u_int8_t c_nextfrag; /* next fragment in packet */
+ u_int8_t c_pktlen[2]; /* total packet length */
+ u_int8_t c_antenna; /* antenna with best reception */
+ u_int8_t c_updbss; /* only 1 for beacon messages */
+};
+
+#define RAY_TX_PHY_SIZE 0x4
+
+/* this is used by the user to request objects */
+struct ray_param_req {
+ int r_failcause;
+ u_int8_t r_paramid;
+ u_int8_t r_len;
+ u_int8_t r_data[256];
+};
+#define RAY_FAILCAUSE_EIDRANGE 1
+#define RAY_FAILCAUSE_ELENGTH 2
+/* device can possibly return up to 255 */
+#define RAY_FAILCAUSE_EDEVSTOP 256
+
+#ifdef _KERNEL
+#define RAY_FAILCAUSE_WAITING 257
+#endif
+
+#ifndef SIOCGIFGENERIC
+#define SIOCGIFGENERIC _IOWR('i', 57, struct ifreq) /* generic IF get op */
+#endif
+
+#ifndef SIOCSIFGENERIC
+#define SIOCSIFGENERIC _IOWR('i', 58, struct ifreq) /* generic IF get op */
+#endif
+
+/* get a param the data is a ray_param_request structure */
+#define SIOCSRAYPARAM SIOCSIFGENERIC
+#define SIOCGRAYPARAM SIOCGIFGENERIC
+
+#define RAY_PID_STRINGS { \
+ "RAY_PID_NET_TYPE", \
+ "RAY_PID_AP_STATUS", \
+ "RAY_PID_SSID", \
+ "RAY_PID_SCAN_MODE", \
+ "RAY_PID_APM_MODE", \
+ "RAY_PID_MAC_ADDR", \
+ "RAY_PID_FRAG_THRESH", \
+ "RAY_PID_DWELL_TIME", \
+ "RAY_PID_BEACON_PERIOD", \
+ "RAY_PID_DTIM_INT", \
+ "RAY_PID_MAX_RETRY", \
+ "RAY_PID_ACK_TIMO", \
+ "RAY_PID_SIFS", \
+ "RAY_PID_DIFS", \
+ "RAY_PID_PIFS", \
+ "RAY_PID_RTS_THRESH", \
+ "RAY_PID_SCAN_DWELL_PERIOD", \
+ "RAY_PID_MAX_SCAN_DWELL_PERIOD", \
+ "RAY_PID_ASSOC_TIMO", \
+ "RAY_PID_ADHOC_SCAN_CYCLE", \
+ "RAY_PID_INFRA_SCAN_CYCLE", \
+ "RAY_PID_INFRA_SUPER_SCAN_CYCLE", \
+ "RAY_PID_PROMISC", \
+ "RAY_PID_UNIQ_WORD", \
+ "RAY_PID_SLOT_TIME", \
+ "RAY_PID_ROAM_LOW_SNR_THRESH", \
+ "RAY_PID_LOW_SNR_COUNT", \
+ "RAY_PID_INFRA_MISSED_BEACON_COUNT", \
+ "RAY_PID_ADHOC_MISSED_BEACON_COUNT", \
+ "RAY_PID_COUNTRY_CODE", \
+ "RAY_PID_HOP_SEQ", \
+ "RAY_PID_HOP_SEQ_LEN", \
+ "RAY_PID_CW_MAX", \
+ "RAY_PID_CW_MIN", \
+ "RAY_PID_NOISE_FILTER_GAIN", \
+ "RAY_PID_NOISE_LIMIT_OFFSET", \
+ "RAY_PID_RSSI_THRESH_OFFSET", \
+ "RAY_PID_BUSY_THRESH_OFFSET", \
+ "RAY_PID_SYNC_THRESH", \
+ "RAY_PID_TEST_MODE", \
+ "RAY_PID_TEST_MIN_CHAN", \
+ "RAY_PID_TEST_MAX_CHAN", \
+ "RAY_PID_ALLOW_PROBE_RESP", \
+ "RAY_PID_PRIVACY_MUST_START", \
+ "RAY_PID_PRIVACY_CAN_JOIN", \
+ "RAY_PID_BASIC_RATE_SET" \
+ }
+
+#ifdef RAY_DO_SIGLEV
+#define SIOCGRAYSIGLEV _IOWR('i', 201, struct ifreq)
+
+#define RAY_NSIGLEVRECS 8
+#define RAY_NSIGLEV 8
+
+struct ray_siglev {
+ u_int8_t rsl_host[ETHER_ADDR_LEN]; /* MAC address */
+ u_int8_t rsl_siglevs[RAY_NSIGLEV]; /* levels, newest in [0] */
+ struct timeval rsl_time; /* time of last packet */
+};
+#endif
projects / openbsd / commitdiff