/*      $NetBSD: if_ray.c,v 1.100 2024/02/11 10:36:40 andvar 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.
 *
 *      Authentication added by Steve Weiss <srw@alum.mit.edu> based on
 *      advice from Corey Thomas (author of the Linux RayLink driver).
 *      Authentication is currently limited to adhoc networks, and was
 *      added to support a requirement of the newest Windows drivers for
 *      the RayLink.  Tested with Aviator Pro (firmware 5.63) on Win98.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_ray.c,v 1.100 2024/02/11 10:36:40 andvar Exp $");

#include "opt_inet.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.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>
#include <net/if_ether.h>
#include <net/if_media.h>
#include <net/if_llc.h>
#include <net80211/ieee80211.h>
#include <net80211/ieee80211_ioctl.h>
#include <net/if_media.h>
#include <net/bpf.h>

#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_inarp.h>
#endif

#include <sys/cpu.h>
#include <sys/bus.h>
#include <sys/intr.h>

#include <dev/pcmcia/pcmciareg.h>
#include <dev/pcmcia/pcmciavar.h>
#include <dev/pcmcia/pcmciadevs.h>

#include <dev/pcmcia/if_rayreg.h>

#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

/* amount of time to consider start/join failed */
#ifndef RAY_START_TIMEOUT
#define RAY_START_TIMEOUT       (30 * 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 because resets take ~2s and currently pcmcia
 * spins for the reset.
 */
#ifndef RAY_MAX_RESETS
#define RAY_MAX_RESETS  3
#endif

/*
 * Types
 */

struct ray_softc {
        device_t        sc_dev;
        struct ethercom sc_ec;
        struct ifmedia  sc_media;

        struct pcmcia_function          *sc_pf;
        void                            *sc_ih;
        int                             sc_attached;

        int                             sc_resetloop;

        struct callout                  sc_check_ccs_ch;
        struct callout                  sc_check_scheduled_ch;
        struct callout                  sc_reset_resetloop_ch;
        struct callout                  sc_disable_ch;
        struct callout                  sc_start_join_timo_ch;

        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;

        uint8_t sc_ccsinuse[64];        /* ccs in use -- not for tx */
        u_int           sc_txfree;      /* a free count for efficiency */

        uint8_t sc_bssid[ETHER_ADDR_LEN];       /* current net values */
        uint8_t sc_authid[ETHER_ADDR_LEN];      /* ID of authenticating
                                                           station */
        struct ieee80211_nwid   sc_cnwid;       /* last nwid */
        struct ieee80211_nwid   sc_dnwid;       /* desired nwid */
        uint8_t sc_omode;       /* old operating mode SC_MODE_xx */
        uint8_t sc_mode;        /* current operating mode SC_MODE_xx */
        uint8_t sc_countrycode; /* current country code */
        uint8_t sc_dcountrycode; /* desired country code */
        int             sc_havenet;     /* true if we have acquired a network */
        bus_size_t      sc_txpad;       /* tib size plus "phy" size */
        uint8_t sc_deftxrate;   /* default transfer rate */
        uint8_t sc_encrypt;
        uint8_t sc_authstate;   /* authentication state */

        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;
        uint64_t        sc_rxoverflow;
        uint64_t        sc_rxcksum;
        uint64_t        sc_rxhcksum;
        uint8_t sc_rxnoise;

        /* use to return values to the user */
        struct ray_param_req    *sc_repreq;
        struct ray_param_req    *sc_updreq;

        bus_space_tag_t sc_memt;
        bus_space_handle_t sc_memh;

#ifdef RAY_DO_SIGLEV
        struct ray_siglev       sc_siglevs[RAY_NSIGLEVRECS];
#endif
};
#define sc_ccrt sc_pf->pf_ccrt
#define sc_ccrh sc_pf->pf_ccrh
#define sc_ccroff sc_pf->pf_ccr_offset
#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
#define sc_if           sc_ec.ec_if

/* 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

/* sc_authstate */
#define RAY_AUTH_UNAUTH         0
#define RAY_AUTH_WAITING        1
#define RAY_AUTH_AUTH           2
#define RAY_AUTH_NEEDED         3

#define OPEN_AUTH_REQUEST       1
#define OPEN_AUTH_RESPONSE      2
#define BROADCAST_DEAUTH        0xc0

static int ray_alloc_ccs(struct ray_softc *, bus_size_t *, u_int, u_int);
static bus_size_t ray_fill_in_tx_ccs(struct ray_softc *, size_t,
    u_int, u_int);
static int ray_validate_config(struct pcmcia_config_entry *);
static void ray_attach(device_t, device_t, void *);
static ray_cmd_func_t ray_ccs_done(struct ray_softc *, bus_size_t);
static void ray_check_ccs(void *);
static void ray_check_scheduled(void *);
static void ray_cmd_cancel(struct ray_softc *, int);
static void ray_cmd_schedule(struct ray_softc *, int);
static void ray_cmd_ran(struct ray_softc *, int);
static int ray_cmd_is_running(struct ray_softc *, int);
static int ray_cmd_is_scheduled(struct ray_softc *, int);
static void ray_cmd_done(struct ray_softc *, int);
static int ray_detach(device_t, int);
static int ray_activate(device_t, enum devact);
static void ray_disable(struct ray_softc *);
static void ray_download_params(struct ray_softc *);
static int ray_enable(struct ray_softc *);
static u_int ray_find_free_tx_ccs(struct ray_softc *, u_int);
static uint8_t ray_free_ccs(struct ray_softc *, bus_size_t);
static void ray_free_ccs_chain(struct ray_softc *, u_int);
static void ray_if_start(struct ifnet *);
static void ray_if_stop(struct ifnet *, int);
static int ray_init(struct ray_softc *);
static int ray_intr(void *);
static void ray_intr_start(struct ray_softc *);
static int ray_ioctl(struct ifnet *, u_long, void *);
static int ray_issue_cmd(struct ray_softc *, bus_size_t, u_int);
static int ray_match(device_t, cfdata_t, void *);
static int ray_media_change(struct ifnet *);
static void ray_media_status(struct ifnet *, struct ifmediareq *);
static ray_cmd_func_t ray_rccs_intr(struct ray_softc *, bus_size_t);
static void ray_read_region(struct ray_softc *, bus_size_t, void *, size_t);
static void ray_recv(struct ray_softc *, bus_size_t);
static void ray_recv_auth(struct ray_softc *, struct ieee80211_frame *);
static void ray_report_params(struct ray_softc *);
static void ray_reset(struct ray_softc *);
static void ray_reset_resetloop(void *);
static int ray_send_auth(struct ray_softc *, uint8_t *, uint8_t);
static void ray_set_pending(struct ray_softc *, u_int);
static int ray_simple_cmd(struct ray_softc *, u_int, u_int);
static void ray_start_assoc(struct ray_softc *);
static void ray_start_join_net(struct ray_softc *);
static ray_cmd_func_t ray_start_join_net_done(struct ray_softc *,
    u_int, bus_size_t, u_int);
static void ray_start_join_timo(void *);
static void ray_stop(struct ray_softc *);
static void ray_update_error_counters(struct ray_softc *);
static void ray_update_mcast(struct ray_softc *);
static ray_cmd_func_t ray_update_params_done(struct ray_softc *,
    bus_size_t, u_int);
static void ray_update_params(struct ray_softc *);
static void ray_update_promisc(struct ray_softc *);
static void ray_update_subcmd(struct ray_softc *);
static int ray_user_report_params(struct ray_softc *,
    struct ray_param_req *);
static int ray_user_update_params(struct ray_softc *,
    struct ray_param_req *);
static void ray_write_region(struct ray_softc *, bus_size_t, void *, size_t);

#ifdef RAY_DO_SIGLEV
static void ray_update_siglev(struct ray_softc *, uint8_t *, uint8_t);
#endif

#ifdef RAY_DEBUG
static int ray_debug = 0;
static int ray_debug_xmit_sum = 0;
static int ray_debug_dump_desc = 0;
static int ray_debug_dump_rx = 0;
static int ray_debug_dump_tx = 0;
static struct timeval rtv, tv1, tv2, *ttp, *ltp;
#define RAY_DPRINTF(x)  do { if (ray_debug) {   \
        struct timeval *ttmp;                   \
        microtime(ttp);                         \
        timersub(ttp, ltp, &rtv);               \
        ttmp = ttp; ttp = ltp; ltp = ttmp;      \
        printf("%ld:%ld %ld:%06ld: ",           \
            (long int)ttp->tv_sec,              \
            (long int)ttp->tv_usec,             \
            (long int)rtv.tv_sec,               \
            (long int)rtv.tv_usec);             \
        printf x ;                              \
        } } while (0)
#define RAY_DPRINTF_XMIT(x)     do { if (ray_debug_xmit_sum) {  \
        struct timeval *ttmp;                   \
        microtime(ttp);                         \
        timersub(ttp, ltp, &rtv);               \
        ttmp = ttp; ttp = ltp; ltp = ttmp;      \
        printf("%ld:%ld %ld:%06ld: ",           \
            (long int)ttp->tv_sec,              \
            (long int)ttp->tv_usec,             \
            (long int)rtv.tv_sec,               \
            (long int)rtv.tv_usec);             \
        printf x ;                              \
        } } while (0)

static void ray_dump_mbuf(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
 */

        /* use already mapped ccrt */
#define REG_WRITE(sc, off, val) \
        bus_space_write_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off)), (val))

#define REG_READ(sc, off) \
        bus_space_read_1((sc)->sc_ccrt, (sc)->sc_ccrh, ((sc)->sc_ccroff + (off)))

#define SRAM_READ_1(sc, off) \
        ((uint8_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)                        \
        ((((uint16_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 uint8_t llc_snapid[6] = { LLC_SNAP_LSAP, LLC_SNAP_LSAP, LLC_UI, };

/* based on bit index in SCP_xx */
static 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 int ray_ncmdtab = sizeof(ray_cmdtab) / sizeof(*ray_cmdtab);

static 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 int ray_nsubcmdtab = sizeof(ray_subcmdtab) / sizeof(*ray_subcmdtab);

/* autoconf information */
CFATTACH_DECL_NEW(ray, sizeof(struct ray_softc),
    ray_match, ray_attach, ray_detach, ray_activate);

/*
 * Config Routines
 */

static int
ray_match(device_t parent, cfdata_t 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);
}

static int
ray_validate_config(struct pcmcia_config_entry *cfe)
{
        if (cfe->iftype != PCMCIA_IFTYPE_IO ||
            cfe->num_memspace != 1 ||
            cfe->num_iospace != 0 ||
            cfe->memspace[0].length != RAY_SRAM_MEM_SIZE)
                return (EINVAL);
        return (0);
}

static void
ray_attach(device_t parent, device_t self, void *aux)
{
        struct ray_softc *sc = device_private(self);
        struct pcmcia_attach_args *pa = aux;
        struct ifnet *ifp = &sc->sc_if;
        struct pcmcia_config_entry *cfe;
        struct ray_ecf_startup *ep;
        int error;

        sc->sc_dev = self;
        sc->sc_pf = pa->pf;

        /*XXXmem8|common*/
        error = pcmcia_function_configure(pa->pf, ray_validate_config);
        if (error) {
                aprint_error_dev(self, "configure failed, error=%d\n", error);
                return;
        }

        cfe = pa->pf->cfe;
        sc->sc_memt = cfe->memspace[0].handle.memt;
        sc->sc_memh = cfe->memspace[0].handle.memh;

        callout_init(&sc->sc_reset_resetloop_ch, 0);
        callout_init(&sc->sc_disable_ch, 0);
        callout_init(&sc->sc_start_join_timo_ch, 0);

        error = ray_enable(sc);
        if (error)
                goto fail;

        /* 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) {
                aprint_error_dev(self, "card failed self test: status %d\n",
                    sc->sc_ecf_startup.e_status);
                goto fail2;
        }

        /* check firmware version */
        if (sc->sc_version != SC_BUILD_4 && sc->sc_version != SC_BUILD_5) {
                aprint_error_dev(self, "unsupported firmware version %d\n",
                    ep->e_fw_build_string);
                goto fail2;
        }

        /* clear any interrupt if present */
        REG_WRITE(sc, RAY_HCSIR, 0);

        /*
         * set the parameters that will survive stop/init
         */
        memset(&sc->sc_dnwid, 0, sizeof(sc->sc_dnwid));
        sc->sc_dnwid.i_len = strlen(RAY_DEF_NWID);
        memcpy(sc->sc_dnwid.i_nwid, RAY_DEF_NWID, sc->sc_dnwid.i_len);
        memcpy(&sc->sc_cnwid, &sc->sc_dnwid, sizeof(sc->sc_cnwid));
        sc->sc_omode = sc->sc_mode = RAY_MODE_DEFAULT;
        sc->sc_countrycode = sc->sc_dcountrycode =
            RAY_PID_COUNTRY_CODE_DEFAULT;

        /*
         * attach the interface
         */
        /* The version isn't the most accurate way, but it's easy. */
        aprint_normal_dev(self, "firmware version %d\n",
            sc->sc_version);
        if (sc->sc_version != SC_BUILD_4)
                aprint_normal_dev(self,
                    "supported rates %0x:%0x:%0x:%0x:%0x:%0x:%0x:%0x\n",
                    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]);
        aprint_normal_dev(self, "802.11 address %s\n",
            ether_sprintf(ep->e_station_addr));

        memcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
        ifp->if_softc = sc;
        ifp->if_start = ray_if_start;
        ifp->if_stop = ray_if_stop;
        ifp->if_ioctl = ray_ioctl;
        ifp->if_mtu = ETHERMTU;
        ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
        IFQ_SET_READY(&ifp->if_snd);

        if_attach(ifp);
        ether_ifattach(ifp, ep->e_station_addr);
        /* 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 (pmf_device_register(self, NULL, NULL))
                pmf_class_network_register(self, ifp);
        else
                aprint_error_dev(self, "couldn't establish power handler\n");

        /* The attach is successful. */
        sc->sc_attached = 1;
        ray_disable(sc);
        return;

fail2:
        ray_disable(sc);
fail:
        pcmcia_function_unconfigure(pa->pf);
}

static int
ray_activate(device_t self, enum devact act)
{
        struct ray_softc *sc = device_private(self);
        struct ifnet *ifp = &sc->sc_if;

        RAY_DPRINTF(("%s: activate\n", device_xname(self)));

        switch (act) {
        case DVACT_DEACTIVATE:
                if_deactivate(ifp);
                return 0;
        default:
                return EOPNOTSUPP;
        }
}

static int
ray_detach(device_t self, int flags)
{
        struct ray_softc *sc;
        struct ifnet *ifp;

        sc = device_private(self);
        ifp = &sc->sc_if;
        RAY_DPRINTF(("%s: detach\n", device_xname(sc->sc_dev)));

        if (!sc->sc_attached)
                return (0);

        pmf_device_deregister(self);

        if (sc->sc_if.if_flags & IFF_UP)
                ray_disable(sc);

        ether_ifdetach(ifp);
        if_detach(ifp);
        ifmedia_fini(&sc->sc_media);

        pcmcia_function_unconfigure(sc->sc_pf);

        return (0);
}

/*
 * start the card running
 */
static int
ray_enable(struct ray_softc *sc)
{
        int error;

        RAY_DPRINTF(("%s: enable\n", device_xname(sc->sc_dev)));

        sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET, ray_intr, sc);
        if (!sc->sc_ih)
                return (EIO);

        error = ray_init(sc);
        if (error) {
                pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
                sc->sc_ih = 0;
        }

        return (error);
}

/*
 * stop the card running
 */
static void
ray_disable(struct ray_softc *sc)
{
        RAY_DPRINTF(("%s: disable\n", device_xname(sc->sc_dev)));

        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
 */
static int
ray_init(struct ray_softc *sc)
{
        struct ray_ecf_startup *ep;
        bus_size_t ccs;
        int i;

        RAY_DPRINTF(("%s: init\n", device_xname(sc->sc_dev)));

        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", device_xname(sc->sc_dev)));

        /* 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_authstate = RAY_AUTH_UNAUTH;

        /* 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",
                    device_xname(sc->sc_dev), 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);

        callout_init(&sc->sc_check_ccs_ch, 0);
        callout_init(&sc->sc_check_scheduled_ch, 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 */
        if (sc->sc_if.if_flags & IFF_ALLMULTI)
                sc->sc_if.if_flags |= IFF_PROMISC;
        else if (sc->sc_if.if_pcount == 0)
                sc->sc_if.if_flags &= ~IFF_PROMISC;
        sc->sc_promisc = !!(sc->sc_if.if_flags & IFF_PROMISC);

        /* call after we mark ourselves running */
        ray_download_params(sc);

        return (0);
}

/*
 * stop the card running
 */
static void
ray_stop(struct ray_softc *sc)
{
        RAY_DPRINTF(("%s: stop\n", device_xname(sc->sc_dev)));

        callout_stop(&sc->sc_check_ccs_ch);
        sc->sc_timocheck = 0;

        callout_stop(&sc->sc_check_scheduled_ch);
        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_updreq->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
 */
static void
ray_reset(struct ray_softc *sc)
{
        if (++sc->sc_resetloop >= RAY_MAX_RESETS) {
                if (sc->sc_resetloop == RAY_MAX_RESETS) {
                        aprint_error_dev(sc->sc_dev,
                            "unable to correct, disabling\n");
                        callout_stop(&sc->sc_reset_resetloop_ch);
                        callout_reset(&sc->sc_disable_ch, 1,
                            (void (*)(void *))ray_disable, sc);
                }
        } else {
                aprint_error_dev(sc->sc_dev,
                    "unexpected failure resetting hw [%d more]\n",
                    RAY_MAX_RESETS - sc->sc_resetloop);
                callout_stop(&sc->sc_reset_resetloop_ch);
                ray_init(sc);
                callout_reset(&sc->sc_reset_resetloop_ch, 30 * hz,
                    ray_reset_resetloop, sc);
        }
}

/*
 * 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
 */
static void
ray_reset_resetloop(void *arg)
{
        struct ray_softc *sc;

        sc = arg;
        sc->sc_resetloop = 0;
}

static int
ray_ioctl(struct ifnet *ifp, u_long cmd, void *data)
{
        struct ieee80211_nwid nwid;
        struct ray_param_req pr;
        struct ray_softc *sc;
        struct ifreq *ifr;
        struct ifaddr *ifa;
        int error, error2, s, i;

        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));
        switch (cmd) {
        case SIOCINITIFADDR:
                RAY_DPRINTF(("%s: ioctl: cmd SIOCINITIFADDR\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:
                        arp_ifinit(&sc->sc_if, ifa);
                        break;
#endif
                default:
                        break;
                }
                break;
        case SIOCSIFFLAGS:
                RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFFLAGS\n", ifp->if_xname));
                if ((error = ifioctl_common(ifp, cmd, data)) != 0)
                        break;
                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));
                /* FALLTHROUGH */
        case SIOCDELMULTI:
                if (cmd == SIOCDELMULTI)
                        RAY_DPRINTF(("%s: ioctl: cmd SIOCDELMULTI\n",
                            ifp->if_xname));
                if ((error = ether_ioctl(ifp, cmd, data)) == ENETRESET) {
                        if (ifp->if_flags & IFF_RUNNING)
                                ray_update_mcast(sc);
                        error = 0;
                }
                break;
        case SIOCSIFMEDIA:
                RAY_DPRINTF(("%s: ioctl: cmd SIOCSIFMEDIA\n", ifp->if_xname));
                /* FALLTHROUGH */
        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 SIOCS80211NWID\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 (nwid.i_len > IEEE80211_NWID_LEN) {
                        error = EINVAL;
                        break;
                }
                /* clear trailing garbages */
                for (i = nwid.i_len; i < IEEE80211_NWID_LEN; i++)
                        nwid.i_nwid[i] = 0;
                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 SIOCG80211NWID\n", ifp->if_xname));
                error = copyout(&sc->sc_cnwid, ifr->ifr_data,
                    sizeof(sc->sc_cnwid));
                break;
#ifdef RAY_DO_SIGLEV
        case SIOCGRAYSIGLEV:
                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 = ether_ioctl(ifp, cmd, data);
                break;
        }

        RAY_DPRINTF(("%s: ioctl: returns %d\n", ifp->if_xname, error));

        splx(s);

        return (error);
}

/*
 * ifnet interface to start transmission on the interface
 */
static void
ray_if_start(struct ifnet *ifp)
{
        struct ray_softc *sc;

        sc = ifp->if_softc;
        ray_intr_start(sc);
}

static void
ray_if_stop(struct ifnet *ifp, int disable)
{
        struct ray_softc *sc = ifp->if_softc;

        ray_stop(sc);
}

static int
ray_media_change(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);
}

static void
ray_media_status(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
 */
static void
ray_intr_start(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;
        uint16_t et;
        uint8_t *d;

        ifp = &sc->sc_if;

        RAY_DPRINTF(("%s: start free %d\n",
            ifp->if_xname, sc->sc_txfree));

        ray_cmd_cancel(sc, SCP_IFSTART);

        if ((ifp->if_flags & IFF_RUNNING) == 0 || !sc->sc_havenet)
                return;

        if (IFQ_IS_EMPTY(&ifp->if_snd))
                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;
        }

        /* Check to see if we need to authenticate before sending packets. */
        if (sc->sc_authstate == RAY_AUTH_NEEDED) {
                RAY_DPRINTF(("%s: Sending auth request.\n", ifp->if_xname));
                sc->sc_authstate = RAY_AUTH_WAITING;
                ray_send_auth(sc, sc->sc_authid, OPEN_AUTH_REQUEST);
                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) {
                                RAY_DPRINTF(("%s: no descriptors.\n",
                                    ifp->if_xname));
                                ifp->if_flags |= IFF_OACTIVE;
                                break;
                        }
                }

                IFQ_DEQUEUE(&ifp->if_snd, m0);
                if (!m0) {
                        RAY_DPRINTF(("%s: dry queue.\n", ifp->if_xname));
                        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 %ld\n", ifp->if_xname,
                            (u_long)pktlen));
                        if_statinc(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));
                        if_statinc(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);
                                if_statinc(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;
                } else {
                        tmplen = 0;
                }
                /* 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));
                        if_statinc(ifp, if_oerrors);
                        continue;
                }
                /* copy the frame into the mbuf for tapping */
                iframe = mtod(m0, struct ieee80211_frame *);
                eh = (struct ether_header *)((uint8_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, uint8_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 (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, m0, BPF_D_OUT);
                        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);
                        }
                }

#ifdef RAY_DEBUG
                if (ray_debug && ray_debug_dump_tx)
                        ray_dump_mbuf(sc, m0);
#endif
                pcount++;
                m_freem(m0);

                RAY_DPRINTF_XMIT(("%s: sent packet: len %ld\n",
                    device_xname(sc->sc_dev), (u_long)pktlen));
        }

        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",
                    device_xname(sc->sc_dev));
                ray_free_ccs_chain(sc, firsti);
                if_statadd(ifp, if_oerrors, pcount);
                return;
        }

        /* send it off */
        RAY_DPRINTF(("%s: ray_start issuing %d \n", device_xname(sc->sc_dev),
            firsti));
        SRAM_WRITE_1(sc, RAY_SCB_CCSI, firsti);
        RAY_ECF_START_CMD(sc);

        if_statadd(ifp, if_opackets, pcount);
}

/*
 * receive a packet from the card
 */
static void
ray_recv(struct ray_softc *sc, bus_size_t ccs)
{
        struct ieee80211_frame *frame;
        struct ether_header *eh;
        struct mbuf *m;
        size_t pktlen, fudge, len, lenread = 0;
        bus_size_t bufp, ebufp, tmp;
        struct ifnet *ifp;
        uint8_t *src, *d;
        u_int frag = 0, ni, i, issnap, first;
        uint8_t fc0;
#ifdef RAY_DO_SIGLEV
        uint8_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(printf, __func__, (char *)sc->sc_memh + RAY_RCS_BASE,
                    0x400);
#endif

        m = 0;
        ifp = &sc->sc_if;

        /*
         * If we're expecting the E2-in-802.11 encapsulation that the
         * WebGear Windows driver produces, fudge the packet forward
         * in the mbuf by 2 bytes so that the payload after the
         * Ethernet header will be aligned.  If we end up getting a
         * packet that's not of this type, we'll just drop it anyway.
         */
        if (ifp->if_flags & IFF_LINK0)
                fudge = 2;
        else
                fudge = 0;

        /* 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 %ld frag %d\n", device_xname(sc->sc_dev),
            (u_long)pktlen, frag));
        RAY_DPRINTF_XMIT(("%s: received packet: len %ld\n",
            device_xname(sc->sc_dev), (u_long)pktlen));
        if (pktlen > MCLBYTES || pktlen < sizeof(*frame)) {
                RAY_DPRINTF(("%s: PKTLEN TOO BIG OR TOO SMALL\n",
                    device_xname(sc->sc_dev)));
                if_statinc(ifp, if_ierrors);
                goto done;
        }
        MGETHDR(m, M_DONTWAIT, MT_DATA);
        if (!m) {
                RAY_DPRINTF(("%s: MGETHDR FAILED\n", device_xname(sc->sc_dev)));
                if_statinc(ifp, if_ierrors);
                goto done;
        }
        if ((pktlen + fudge) > MHLEN) {
                /* XXX should allow chaining? */
                MCLGET(m, M_DONTWAIT);
                if ((m->m_flags & M_EXT) == 0) {
                        RAY_DPRINTF(("%s: MCLGET FAILED\n",
                            device_xname(sc->sc_dev)));
                        if_statinc(ifp, if_ierrors);
                        m_freem(m);
                        m = 0;
                        goto done;
                }
        }
        m_set_rcvif(m, ifp);
        m->m_pkthdr.len = pktlen;
        m->m_len = pktlen;
        m->m_data += fudge;
        d = mtod(m, uint8_t *);

        RAY_DPRINTF(("%s: recv ccs index %d\n", device_xname(sc->sc_dev),
            first));
        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 %ld bufp 0x%llx ni %d\n",
                    device_xname(sc->sc_dev), i, (u_long)len,
                    (unsigned long long)bufp, ni));
                if (len + lenread > pktlen) {
                        RAY_DPRINTF(("%s: BAD LEN current 0x%lx pktlen 0x%lx\n",
                            device_xname(sc->sc_dev), (u_long)(len + lenread),
                            (u_long)pktlen));
                        if_statinc(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", device_xname(sc->sc_dev),
            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 %ld actual %ld\n",
            device_xname(sc->sc_dev), (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",
                    device_xname(sc->sc_dev), fc0));
                m_freem(m);
                return;
        }
        if ((fc0 & IEEE80211_FC0_TYPE_MASK) == IEEE80211_FC0_TYPE_MGT) {
                switch (frame->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
                case IEEE80211_FC0_SUBTYPE_BEACON:
                        /* Ignore beacon silently. */
                        break;
                case IEEE80211_FC0_SUBTYPE_AUTH:
                        ray_recv_auth(sc, frame);
                        break;
                case IEEE80211_FC0_SUBTYPE_DEAUTH:
                        sc->sc_authstate = RAY_AUTH_UNAUTH;
                        break;
                default:
                        RAY_DPRINTF(("%s: mgt packet not supported\n",
                            device_xname(sc->sc_dev)));
#ifdef RAY_DEBUG
                        hexdump(printf, __func__, frame, pktlen);
#endif
                        RAY_DPRINTF(("\n"));
                        break;
                }
                m_freem(m);
                return;
        } else if ((fc0 & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_DATA) {
                RAY_DPRINTF(("%s: pkt not type data fc0 0x%x\n",
                    device_xname(sc->sc_dev), fc0));
                m_freem(m);
                return;
        }

        if (pktlen < sizeof(*frame) + sizeof(struct llc)) {
                RAY_DPRINTF(("%s: pkt too small for llc (%ld)\n",
                    device_xname(sc->sc_dev), (u_long)pktlen));
                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", device_xname(sc->sc_dev)));
                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", device_xname(sc->sc_dev)));
                m_freem(m);
                return;
        default:
                RAY_DPRINTF(("%s: pkt type unknown\n",
                    device_xname(sc->sc_dev)));
                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 *)((char *)(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, (char *)eh - (char *)frame);
        bpf_mtap(ifp, m, BPF_D_IN);
        /* XXX doesn't appear to be included m->m_flags |= M_HASFCS; */
        if_percpuq_enqueue(ifp->if_percpuq, m);
}

/*
 * receive an auth packet
 */
static void
ray_recv_auth(struct ray_softc *sc, struct ieee80211_frame *frame)
{
        uint8_t *var = (uint8_t *)(frame + 1);

        if (sc->sc_mode == SC_MODE_ADHOC) {
                RAY_DPRINTF(("%s: recv auth packet:\n",
                    device_xname(sc->sc_dev)));
#ifdef RAY_DEBUG
                hexdump(printf, __func__, frame, sizeof(*frame) + 6);
#endif
                RAY_DPRINTF(("\n"));

                if (var[2] == OPEN_AUTH_REQUEST) {
                        RAY_DPRINTF(("%s: Sending authentication response.\n",
                            device_xname(sc->sc_dev)));
                        if (ray_send_auth(sc, frame->i_addr2,
                            OPEN_AUTH_RESPONSE) == 0) {
                                sc->sc_authstate = RAY_AUTH_NEEDED;
                                memcpy(sc->sc_authid, frame->i_addr2,
                                    ETHER_ADDR_LEN);
                        }
                } else if (var[2] == OPEN_AUTH_RESPONSE) {
                        RAY_DPRINTF(("%s: Authenticated!\n",
                            device_xname(sc->sc_dev)));
                        sc->sc_authstate = RAY_AUTH_AUTH;
                }
        }
}

/*
 * send an auth packet
 */
static int
ray_send_auth(struct ray_softc *sc, uint8_t *dest, uint8_t auth_type)
{
        uint8_t packet[sizeof(struct ieee80211_frame) + ETHER_ADDR_LEN], *var;
        struct ieee80211_frame *frame;
        bus_size_t bufp;
        int ccsindex;

        ccsindex = ray_find_free_tx_ccs(sc, RAY_CCS_TX_FIRST);
        if (ccsindex == RAY_CCS_LINK_NULL) {
                RAY_DPRINTF(("%s: send auth failed -- no free tx slots\n",
                    device_xname(sc->sc_dev)));
                return (ENOMEM);
        }

        bufp = ray_fill_in_tx_ccs(sc, sizeof(packet), ccsindex,
            RAY_CCS_LINK_NULL);
        frame = (struct ieee80211_frame *) packet;
        frame->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_SUBTYPE_AUTH;
        frame->i_fc[1] = 0;
        memcpy(frame->i_addr1, dest, ETHER_ADDR_LEN);
        memcpy(frame->i_addr2, sc->sc_ecf_startup.e_station_addr,
            ETHER_ADDR_LEN);
        memcpy(frame->i_addr3, sc->sc_bssid, ETHER_ADDR_LEN);

        var = (uint8_t *)(frame + 1);
        memset(var, 0, ETHER_ADDR_LEN);
        var[2] = auth_type;

        ray_write_region(sc, bufp, packet, sizeof(packet));

        SRAM_WRITE_1(sc, RAY_SCB_CCSI, ccsindex);
        RAY_ECF_START_CMD(sc);

        RAY_DPRINTF_XMIT(("%s: sent auth packet: len %lu\n",
            device_xname(sc->sc_dev), (u_long) sizeof(packet)));

        return (0);
}

/*
 * 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!
 */
static u_int
ray_find_free_tx_ccs(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
 */
static bus_size_t
ray_fill_in_tx_ccs(struct ray_softc *sc, size_t pktlen, u_int i, u_int 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%llx idx %u pidx %u\n",
            device_xname(sc->sc_dev), (unsigned long long)bufp, i, pi));

        return (bufp + RAY_TX_PHY_SIZE);
}

/*
 * an update params command has completed lookup which command and
 * the status
 */
static ray_cmd_func_t
ray_update_params_done(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",
           device_xname(sc->sc_dev), stat));

        /* this will get more complex as we add commands */
        if (stat == RAY_CCS_STATUS_FAIL) {
                printf("%s: failed to update a promisc\n",
                    device_xname(sc->sc_dev));
                /* 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",
                    device_xname(sc->sc_dev), 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.
 */
static void
ray_check_scheduled(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",
            device_xname(sc->sc_dev), sc->sc_scheduled, sc->sc_running,
            RAY_ECF_READY(sc)));

        if (sc->sc_timoneed) {
                callout_stop(&sc->sc_check_scheduled_ch);
                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",
            device_xname(sc->sc_dev), 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
 */
static void
ray_check_ccs(void *arg)
{
        ray_cmd_func_t fp;
        struct ray_softc *sc;
        u_int i, cmd, stat = 0;
        bus_size_t ccs = 0;
        int s;

        s = splnet();
        sc = arg;

        RAY_DPRINTF(("%s: ray_check_ccs\n", device_xname(sc->sc_dev)));

        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 %u ccs 0x%llx "
                            "cmd 0x%x stat %u\n", device_xname(sc->sc_dev), i,
                            (unsigned long long)ccs, cmd, stat));
                        goto breakout;
                }
        }
breakout:
        /* see if we got one of the commands we are looking for */
        if (i > RAY_CCS_CMD_LAST)
                ; /* nothing */
        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) {
                                callout_reset(&sc->sc_check_ccs_ch, 1,
                                    ray_check_ccs, sc);
                                sc->sc_timocheck = 1;
                        }
                } else if ((fp = ray_ccs_done(sc, ccs)))
                        (*fp)(sc);
        } else {
                callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT,
                    ray_check_ccs, sc);
                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
 * increments its internal counter.  The user thus reads the counter
 * if the `own' bit is one and then sets the own bit to 0.
 */
static void
ray_update_error_counters(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.
 */
static ray_cmd_func_t
ray_ccs_done(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_ccs_done idx %llu cmd 0x%x stat %u\n",
            device_xname(sc->sc_dev), (unsigned long long)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 unsolicited interrupt, i.e., the ECF is sending us a command
 */
static ray_cmd_func_t
ray_rccs_intr(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 %llu cmd 0x%x stat %u\n",
            device_xname(sc->sc_dev), (unsigned long long)RAY_GET_INDEX(ccs),
            cmd, stat));

        rcmd = 0;
        switch (cmd) {
        /*
         * unsolicited 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
 */
static int
ray_intr(void *arg)
{
        struct ray_softc *sc;
        ray_cmd_func_t rcmd;
        u_int i, count;

        sc = arg;

        RAY_DPRINTF(("%s: ray_intr\n", device_xname(sc->sc_dev)));

        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",
                            device_xname(sc->sc_dev), i);
        }

        if (rcmd)
                (*rcmd)(sc);

        if (count)
                REG_WRITE(sc, RAY_HCSIR, 0);

        RAY_DPRINTF(("%s: interrupt handled %d\n", device_xname(sc->sc_dev),
            count));

        return (count ? 1 : 0);
}


/*
 * Generic CCS handling
 */

/*
 * free the chain of descriptors -- used for freeing allocated tx chains
 */
static void
ray_free_ccs_chain(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
 */
static uint8_t
ray_free_ccs(struct ray_softc *sc, bus_size_t ccs)
{
        uint8_t stat;

        RAY_DPRINTF(("%s: free_ccs idx %llu\n", device_xname(sc->sc_dev),
            (unsigned long long)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
 */
static int
ray_alloc_ccs(struct ray_softc *sc, bus_size_t *ccsp, u_int cmd, u_int track)
{
        bus_size_t ccs;
        u_int i;

        RAY_DPRINTF(("%s: alloc_ccs cmd %d\n", device_xname(sc->sc_dev), 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.
 */
static void
ray_set_pending(struct ray_softc *sc, u_int cmdf)
{
        RAY_DPRINTF(("%s: ray_set_pending 0x%x\n", device_xname(sc->sc_dev),
            cmdf));

        sc->sc_scheduled |= cmdf;
        if (!sc->sc_timoneed) {
                RAY_DPRINTF(("%s: ray_set_pending new timo\n",
                    device_xname(sc->sc_dev)));
                callout_reset(&sc->sc_check_scheduled_ch,
                    RAY_CHECK_SCHED_TIMEOUT, ray_check_scheduled, sc);
                sc->sc_timoneed = 1;
        }
}

/*
 * schedule the `cmdf' for completion later
 */
static void
ray_cmd_schedule(struct ray_softc *sc, int cmdf)
{
        int track;

        RAY_DPRINTF(("%s: ray_cmd_schedule 0x%x\n", device_xname(sc->sc_dev),
            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 mechanism if subcmd already going */
                sc->sc_scheduled |= cmdf;
        } else
                ray_set_pending(sc, cmdf | SCP_UPDATESUBCMD);
}

/*
 * check to see if `cmdf' has been scheduled
 */
static int
ray_cmd_is_scheduled(struct ray_softc *sc, int cmdf)
{
        RAY_DPRINTF(("%s: ray_cmd_is_scheduled 0x%x\n",
            device_xname(sc->sc_dev), cmdf));

        return ((sc->sc_scheduled & cmdf) ? 1 : 0);
}

/*
 * cancel a scheduled command (not a running one though!)
 */
static void
ray_cmd_cancel(struct ray_softc *sc, int cmdf)
{
        RAY_DPRINTF(("%s: ray_cmd_cancel 0x%x\n", device_xname(sc->sc_dev),
            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) {
                callout_stop(&sc->sc_check_scheduled_ch);
                sc->sc_timoneed = 0;
        }
}

/*
 * called to indicate the 'cmdf' has been issued
 */
static void
ray_cmd_ran(struct ray_softc *sc, int cmdf)
{
        RAY_DPRINTF(("%s: ray_cmd_ran 0x%x\n", device_xname(sc->sc_dev),
            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) {
                callout_reset(&sc->sc_check_ccs_ch, RAY_CHECK_CCS_TIMEOUT,
                    ray_check_ccs, sc);
                sc->sc_timocheck = 1;
        }
}

/*
 * check to see if `cmdf' has been issued
 */
static int
ray_cmd_is_running(struct ray_softc *sc, int cmdf)
{
        RAY_DPRINTF(("%s: ray_cmd_is_running 0x%x\n", device_xname(sc->sc_dev),
            cmdf));

        return ((sc->sc_running & cmdf) ? 1 : 0);
}

/*
 * the given `cmdf' that was issued has completed
 */
static void
ray_cmd_done(struct ray_softc *sc, int cmdf)
{
        RAY_DPRINTF(("%s: ray_cmd_done 0x%x\n", device_xname(sc->sc_dev),
            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){
                callout_stop(&sc->sc_check_ccs_ch);
                sc->sc_timocheck = 0;
        }
}

/*
 * issue the command
 * only used for commands not tx
 */
static int
ray_issue_cmd(struct ray_softc *sc, bus_size_t ccs, u_int track)
{
        u_int i;

        RAY_DPRINTF(("%s: ray_cmd_issue 0x%x\n", device_xname(sc->sc_dev),
            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
 */
static int
ray_simple_cmd(struct ray_softc *sc, u_int cmd, u_int 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
 */
static void
ray_update_subcmd(struct ray_softc *sc)
{
        int submask, i;

        RAY_DPRINTF(("%s: ray_update_subcmd\n", device_xname(sc->sc_dev)));

        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 rescheduled
                 * 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
 */
static void
ray_report_params(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
 */
static void
ray_start_assoc(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
 */
static void
ray_download_params(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", device_xname(sc->sc_dev)));

        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));
        /* XXX: Raylink firmware doesn't have length field for ssid */
        memcpy(sp->sp_ssid, sc->sc_dnwid.i_nwid, 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 0
                /* 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 what is 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
 */
static void
ray_start_join_net(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.i_nwid, 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))
                callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT,
                    ray_start_join_timo, sc);
}

static void
ray_start_join_timo(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.
 */
static ray_cmd_func_t
ray_start_join_net_done(struct ray_softc *sc, u_int cmd, bus_size_t ccs,
    u_int stat)
{
        int i;
        struct ray_net_params np;

        callout_stop(&sc->sc_start_join_timo_ch);
        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 */
                callout_reset(&sc->sc_start_join_timo_ch, RAY_START_TIMEOUT,
                    ray_start_join_timo, sc);

                /* 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.i_nwid,
                            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));
                /* XXX: Raylink firmware doesn't have length field for ssid */
                for (i = 0; i < sizeof(np.p_ssid); i++) {
                        if (np.p_ssid[i] == '\0')
                                break;
                }
                sc->sc_cnwid.i_len = i;
                memcpy(sc->sc_cnwid.i_nwid, np.p_ssid, i);
                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",
            device_xname(sc->sc_dev), sc->sc_cnwid.i_nwid,
            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
 */
static void
ray_update_promisc(struct ray_softc *sc)
{
        bus_size_t ccs;
        int promisc;

        ray_cmd_cancel(sc, SCP_UPD_PROMISC);

        /* do the issue check before equality check */
        if (sc->sc_if.if_flags & IFF_ALLMULTI)
                sc->sc_if.if_flags |= IFF_PROMISC;
        else if (sc->sc_if.if_pcount == 0)
                sc->sc_if.if_flags &= ~IFF_PROMISC;
        promisc = !!(sc->sc_if.if_flags & IFF_PROMISC);
        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
 */
static void
ray_update_params(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
 */
static void
ray_update_mcast(struct ray_softc *sc)
{
        bus_size_t ccs;
        struct ether_multistep step;
        struct ether_multi *enm;
        struct ethercom *ec;
        bus_size_t bufp;
        int count;

        ec = &sc->sc_ec;
        ray_cmd_cancel(sc, SCP_UPD_MCAST);

        ETHER_LOCK(ec);
        /* 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);
                }
        }
        ETHER_UNLOCK(ec);

        /* 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_LOCK(ec);
        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);
        }
        ETHER_UNLOCK(ec);
        (void)ray_issue_cmd(sc, ccs, SCP_UPD_MCAST);
}

/*
 * User issued commands
 */

/*
 * issue an "update params"
 *
 * expected to be called in sleepable context -- intended for user stuff
 */
static int
ray_user_update_params(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 sleepable context -- intended for user stuff
 */
static int
ray_user_report_params(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.
 */

static void
ray_read_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c)
{
#ifdef RAY_USE_OPTIMIZED_COPY
        u_int n2, n4, tmp;
        uint8_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.
 */
static void
ray_write_region(struct ray_softc *sc, bus_size_t off, void *vp, size_t c)
{
#ifdef RAY_USE_OPTIMIZED_COPY
        size_t n2, n4, tmp;
        uint8_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

static void
ray_dump_mbuf(struct ray_softc *sc, struct mbuf *m)
{
        printf("%s: pkt dump:", device_xname(sc->sc_dev));
        for (; m; m = m->m_next) {
                hexdump(printf, NULL, mtod(m, void *), m->m_len);
        }
}
#endif  /* RAY_DEBUG */

#ifdef RAY_DO_SIGLEV
static void
ray_update_siglev(struct ray_softc *sc, uint8_t *src, uint8_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