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