/* * Copyright (C) 2000 * Dr. Duncan McLennan Barclay, dmlb@ragnet.demon.co.uk. * * 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 DUNCAN BARCLAY 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 DUNCAN BARCLAY 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. * * $Id: if_ray.c,v 1.4 2000/02/27 19:52:29 dmlb Exp $ * */ #define XXX 0 #define XXX_TRACKING 0 /* * XXX build options - move to LINT */ #define RAY_DEBUG 100 /* Big numbers get more verbose */ #define RAY_CCS_TIMEOUT (hz/2) /* Timeout for CCS commands - only used for downloading startup parameters */ #define RAY_NEED_STARTJOIN_TIMO 0 /* Might be needed with build 4 */ #define RAY_SJ_TIMEOUT (90*hz) /* Timeout for failing STARTJOIN commands - only used with RAY_NEED_STARTJOIN_TIMO */ #define RAY_NEED_CM_REMAPPING 1 /* Needed until pccard maps more than one memory area */ #define RAY_DUMP_CM_ON_GIFMEDIA 1 /* Dump some common memory when the SIOCGIFMEDIA ioctl is issued - a nasty hack for debugging and will be placed by an ioctl and control program */ /* * XXX build options - move to LINT */ /* * Debugging odds and odds */ #ifndef RAY_DEBUG #define RAY_DEBUG 0 #endif /* RAY_DEBUG */ #if RAY_DEBUG > 0 #define RAY_DHEX8(p, l) do { if (RAY_DEBUG > 10) { \ u_int8_t *i; \ for (i = p; i < (u_int8_t *)(p+l); i += 8) \ printf(" 0x%08lx %8D\n", \ (unsigned long)i, (unsigned char *)i, " "); \ } } while (0) #define RAY_DPRINTF(x) do { if (RAY_DEBUG) { \ printf x ; \ } } while (0) #define RAY_DNET_DUMP(sc, s) do { if (RAY_DEBUG) { \ printf("ray%d: Network parameters%s\n", (sc)->unit, (s)); \ printf(" bss_id %6D\n", (sc)->sc_bss_id, ":"); \ printf(" inited 0x%02x\n", (sc)->sc_inited); \ printf(" def_txrate 0x%02x\n", (sc)->sc_def_txrate); \ printf(" encrypt 0x%02x\n", (sc)->sc_encrypt); \ printf(" net_type 0x%02x\n", (sc)->sc_net_type); \ printf(" ssid \"%.32s\"\n", (sc)->sc_ssid); \ printf(" priv_start 0x%02x\n", (sc)->sc_priv_start); \ printf(" priv_join 0x%02x\n", (sc)->sc_priv_join); \ } } while (0) #else #define RAY_HEX8(p, l) #define RAY_DPRINTF(x) #define RAY_DNET_DUMP(sc, s) #endif /* RAY_DEBUG > 0 */ #if RAY_DEBUG > 10 #define RAY_DMBUF_DUMP(sc, m, s) ray_dump_mbuf((sc), (m), (s)) #else #define RAY_DMBUF_DUMP(sc, m, s) #endif /* RAY_DEBUG > 10 */ #include "ray.h" #include "card.h" #include "apm.h" #include "bpfilter.h" #if NRAY > 0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if NBPFILTER > 0 #include #endif /* NBPFILTER */ #include #include #include #include #include #include #include #include #if NCARD > 0 #include #include #include #include #endif /* NCARD */ #if NAPM > 0 #include #endif /* NAPM */ /* * One of these structures per allocated device */ struct ray_softc { struct arpcom arpcom; /* Ethernet common */ struct ifmedia ifmedia; /* Ifnet common */ struct callout_handle \ timerh; /* Handle for timer */ #if RAY_NEED_STARTJOIN_TIMO struct callout_handle \ sj_timerh; /* Handle for start_join timer */ #endif /* RAY_NEED_STARTJOIN_TIMO */ char *card_type; /* Card model name */ char *vendor; /* Card manufacturer */ int unit; /* Unit number */ u_char gone; /* 1 = Card bailed out */ int irq; /* Assigned IRQ */ caddr_t maddr; /* Shared RAM Address */ int msize; /* Shared RAM Size */ int translation; /* Packet translation types */ /* XXX these can go when attribute reading is fixed */ int slotnum; /* Slot number */ struct mem_desc md; /* Map info for common memory */ struct ray_ecf_startup_v5 \ sc_ecf_startup; /* Startup info from card */ u_int8_t sc_ccsinuse[64];/* ccss' in use -- not for tx */ size_t sc_ccs; /* ccs used by non-scheduled, */ /* non-overlapping procedures */ struct ray_cmd_net sc_cnet_1; /* current network params from */ struct ray_net_params sc_cnet_2; /* starting/joining a network */ #if 0 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 */ #endif int sc_havenet; /* true if we have aquired a network */ }; static struct ray_softc ray_softc[NRAY]; #define sc_station_addr sc_ecf_startup.e_station_addr #define sc_version sc_ecf_startup.e_fw_build_string #define sc_tibsize sc_ecf_startup.e_tibsize #define sc_upd_param sc_cnet_1.c_upd_param #define sc_bss_id sc_cnet_1.c_bss_id #define sc_inited sc_cnet_1.c_inited #define sc_def_txrate sc_cnet_1.c_def_txrate #define sc_encrypt sc_cnet_1.c_encrypt #define sc_net_type sc_cnet_2.p_net_type #define sc_ssid sc_cnet_2.p_ssid #define sc_priv_start sc_cnet_2.p_privacy_must_start #define sc_priv_join sc_cnet_2.p_privacy_can_join /*XXX add to debug macro too */ /* 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) /* Translation types */ /* XXX maybe better as part of the if structure? */ #define SC_TRANSLATE_WEBGEAR 0 /* * PCMCIA driver definition */ static int ray_pccard_init __P((struct pccard_devinfo *dev_p)); static void ray_pccard_unload __P((struct pccard_devinfo *dev_p)); static int ray_pccard_intr __P((struct pccard_devinfo *dev_p)); PCCARD_MODULE(ray, ray_pccard_init, ray_pccard_unload, ray_pccard_intr, 0, net_imask); /* * ISA driver definition */ static int ray_probe __P((struct isa_device *dev)); static int ray_attach __P((struct isa_device *dev)); struct isa_driver raydriver = { ray_probe, ray_attach, "ray", 1 }; /* * Network driver definition */ static void ray_start __P((struct ifnet *ifp)); static int ray_ioctl __P((struct ifnet *ifp, u_long command, caddr_t data)); static void ray_watchdog __P((struct ifnet *ifp)); static void ray_init __P((void *xsc)); static void ray_stop __P((struct ray_softc *sc)); /* * Internal utilites */ static int ray_alloc_ccs __P((struct ray_softc *sc, size_t *ccsp, u_int cmd, u_int track)); static void ray_ccs_done __P((struct ray_softc *sc, size_t ccs)); static void ray_download_params __P((struct ray_softc *sc)); static void ray_download_timo __P((void *xsc)); static u_int8_t ray_free_ccs __P((struct ray_softc *sc, size_t ccs)); static int ray_issue_cmd __P((struct ray_softc *sc, size_t ccs, u_int track)); static void ray_rcs_intr __P((struct ray_softc *sc, size_t ccs)); static void ray_rx __P((struct ray_softc *sc, size_t rcs)); static void ray_start_join_done __P((struct ray_softc *sc, size_t ccs, u_int8_t status)); #if RAY_NEED_STARTJOIN_TIMO static void ray_start_join_timo __P((void *xsc)); #endif /* RAY_NEED_STARTJOIN_TIMO */ #if RAY_DEBUG > 10 static void ray_dump_mbuf __P((struct ray_softc *sc, struct mbuf *m, char *s)); #endif /* RAY_DEBUG > 10 */ /* * Indirections for reading/writing shared memory - from NetBSD/if_ray.c */ #ifndef offsetof #define offsetof(type, member) \ ((size_t)(&((type *)0)->member)) #endif /* offsetof */ #define SRAM_READ_1(sc, off) \ (u_int8_t)*((sc)->maddr + (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 ray_read_region(sc, off, vp, n) \ bcopy((sc)->maddr + (off), (vp), (n)) #define SRAM_WRITE_1(sc, off, val) \ *((sc)->maddr + (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)) #define ray_write_region(sc, off, vp, n) \ bcopy((vp), (sc)->maddr + (off), (n)) /* * Macro's */ #ifndef RAY_CCS_TIMEOUT #define RAY_CCS_TIMEOUT (hz / 2) #endif #define RAY_ECF_READY(sc) (!(ray_read_reg(sc, RAY_ECFIR) & RAY_ECFIR_IRQ)) #define RAY_ECF_START_CMD(sc) ray_attr_write((sc), RAY_ECFIR, RAY_ECFIR_IRQ) #define RAY_HCS_CLEAR_INTR(sc) ray_attr_write((sc), RAY_HCSIR, 0) #define RAY_HCS_INTR(sc) (ray_read_reg(sc, RAY_HCSIR) & RAY_HCSIR_IRQ) /* * XXX * As described in if_xe.c... * * Horrid stuff for accessing CIS tuples and remapping common memory... * XXX */ #define CARD_MAJOR 50 static int ray_attr_write __P((struct ray_softc *sc, off_t offset, u_int8_t byte)); static int ray_attr_read __P((struct ray_softc *sc, off_t offset, u_int8_t *buf, int size)); static u_int8_t ray_read_reg __P((struct ray_softc *sc, off_t reg)); #if RAY_NEED_CM_REMAPPING static void ray_attr_getmap __P((struct ray_softc *sc)); static void ray_attr_cm __P((struct ray_softc *sc)); #define RAY_MAP_CM(sc) ray_attr_cm(sc) #else #define RAY_MAP_CM(sc) #endif /* RAY_NEED_CM_REMAPPING */ /* * PCCard initialise. */ static int ray_pccard_init (dev_p) struct pccard_devinfo *dev_p; { struct ray_softc *sc; u_int32_t irq; int j; RAY_DPRINTF(("ray%d: PCCard probe\n", dev_p->isahd.id_unit)); if (dev_p->isahd.id_unit >= NRAY) return(ENODEV); sc = &ray_softc[dev_p->isahd.id_unit]; sc->gone = 0; sc->unit = dev_p->isahd.id_unit; sc->slotnum = dev_p->slt->slotnum; /* Get IRQ - encoded as a bitmask. */ irq = dev_p->isahd.id_irq; for (j = 0; j < 32; j++) { if (irq & 0x1) break; irq >>= 1; } sc->irq = j; sc->maddr = dev_p->isahd.id_maddr; sc->msize = dev_p->isahd.id_msize; printf("ray%d: maddr 0x%lx msize 0x%x irq %d on isa (PC-Card slot %d)\n", sc->unit, (unsigned long)sc->maddr, sc->msize, sc->irq, sc->slotnum); #if RAY_NEED_CM_REMAPPING ray_attr_getmap(sc); #endif /* RAY_NEED_CM_REMAPPING */ if (ray_attach(&dev_p->isahd)) return(ENXIO); return(0); } /* * PCCard unload. */ static void ray_pccard_unload (dev_p) struct pccard_devinfo *dev_p; { struct ray_softc *sc; struct ifnet *ifp; RAY_DPRINTF(("ray%d: PCCard unload\n", dev_p->isahd.id_unit)); sc = &ray_softc[dev_p->isahd.id_unit]; if (sc->gone) { printf("ray%d: already unloaded\n", sc->unit); return; } /* Cleardown interface */ ifp = &sc->arpcom.ac_if; ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE); if_down(ifp); /* XXX probably should be if_detach but I don't know if it works in 3.1 */ /* Mark card as gone */ sc->gone = 1; printf("ray%d: unloaded\n", sc->unit); return; } /* * PCCard interrupt. */ /* XXX return 1 if we take interrupt, 0 otherwise */ static int ray_pccard_intr (dev_p) struct pccard_devinfo *dev_p; { struct ray_softc *sc; int ccsi, handled; RAY_DPRINTF(("ray%d: PCCard intr\n", dev_p->isahd.id_unit)); sc = &ray_softc[dev_p->isahd.id_unit]; RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before interrupt!\n", sc->unit); return(0); } /* * Check that the interrupt was for us, if so get the rcs/ccs and vector * on the command contained within it. */ if (!RAY_HCS_INTR(sc)) { handled = 0; } else { handled = 1; ccsi = SRAM_READ_1(sc, RAY_SCB_RCSI); if (ccsi <= RAY_CCS_LAST) ray_ccs_done(sc, RAY_CCS_ADDRESS(ccsi)); else if (ccsi <= RAY_RCS_LAST) ray_rcs_intr(sc, RAY_CCS_ADDRESS(ccsi)); else printf("ray%d: ray_intr bad ccs index %d\n", sc->unit, ccsi); #if XXX ccs_done and rcs_intr return function pointers - why dont they just do it themselves? its not as if each command only requires a single function call - things like start_join_net call a couple on the way... if (rcmd) (*rcmd)(sc); #endif } if (handled) RAY_HCS_CLEAR_INTR(sc); RAY_DPRINTF(("ray%d: interrupt %s handled\n", sc->unit, handled?"was":"not")); /* Send any packets lying around */ if (!(sc->sc_if.if_flags & IFF_OACTIVE) && (ifp->if_snd.ifq_head != NULL)) ray_start(ifp); return(handled); } /* * ISA probe routine. */ static int ray_probe (dev_p) struct isa_device *dev_p; { RAY_DPRINTF(("ray%d: ISA probe\n", dev_p->id_unit)); return(0); } /* * ISA/PCCard attach. */ static int ray_attach (dev_p) struct isa_device *dev_p; { struct ray_softc *sc; struct ray_ecf_startup_v5 *ep; struct ifnet *ifp; char ifname[IFNAMSIZ]; RAY_DPRINTF(("ray%d: ISA/PCCard attach\n", dev_p->id_unit)); sc = &ray_softc[dev_p->id_unit]; RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before attach!\n", sc->unit); return(0); } /* * Read startup results, check the card is okay and work out what * version we are using. */ ep = &sc->sc_ecf_startup; ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep, sizeof(sc->sc_ecf_startup)); if (ep->e_status != RAY_ECFS_CARD_OK) { printf("ray%d: card failed self test: status 0x%b\n", sc->unit, ep->e_status, "\020" /* print in hex */ "\001RESERVED0" "\002PROC_SELF_TEST" "\003PROG_MEM_CHECKSUM" "\004DATA_MEM_TEST" "\005RX_CALIBRATION" "\006FW_VERSION_COMPAT" "\007RERSERVED1" "\008TEST_COMPLETE" ); return(0); } if (sc->sc_version != RAY_ECFS_BUILD_4 && sc->sc_version != RAY_ECFS_BUILD_5 ) { printf("ray%d: unsupported firmware version 0x%0x\n", sc->unit, ep->e_fw_build_string); return(0); } if (bootverbose || RAY_DEBUG) { printf("ray%d: Start Up Results\n", sc->unit); if (RAY_DEBUG > 10) RAY_DHEX8((u_int8_t *)sc->maddr + RAY_ECF_TO_HOST_BASE, 0x40); if (sc->sc_version == RAY_ECFS_BUILD_4) printf(" Firmware version 4\n"); else printf(" Firmware version 5\n"); printf(" Status 0x%x\n", ep->e_status); printf(" Ether address %6D\n", ep->e_station_addr, ":"); if (sc->sc_version == RAY_ECFS_BUILD_4) { printf(" Program checksum %0x\n", ep->e_resv0); printf(" CIS checksum %0x\n", ep->e_rates[0]); } else { printf(" (reserved word) %0x\n", ep->e_resv0); printf(" Supported rates %8D\n", ep->e_rates, ":"); } printf(" Japan call sign %12D\n", ep->e_japan_callsign, ":"); if (sc->sc_version == RAY_ECFS_BUILD_5) { printf(" Program checksum %0x\n", ep->e_prg_cksum); printf(" CIS checksum %0x\n", ep->e_cis_cksum); printf(" Firmware version %0x\n", ep->e_fw_build_string); printf(" Firmware revision %0x\n", ep->e_fw_build); printf(" (reserved word) %0x\n", ep->e_fw_resv); printf(" ASIC version %0x\n", ep->e_asic_version); printf(" TIB size %0x\n", ep->e_tibsize); } } /* Reset any pending interrupts */ RAY_HCS_CLEAR_INTR(sc); /* * Set the parameters that will survive stop/init * * Do not update these in ray_init's parameter setup */ #if XXX see the ray_init section for stuff to move here #endif /* * Initialise the network interface structure */ bcopy((char *)&ep->e_station_addr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN); ifp = &sc->arpcom.ac_if; ifp->if_softc = sc; ifp->if_name = "ray"; ifp->if_unit = sc->unit; ifp->if_timer = 0; ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX ); /* XXX - IFF_MULTICAST */ #if XXX ifp->if_hdr = ...; make this big enough to hold the .11 and .3 headers #endif ifp->if_baudrate = 1000000; /* XXX Is this baud or bps ;-) */ ifp->if_output = ether_output; ifp->if_start = ray_start; ifp->if_ioctl = ray_ioctl; ifp->if_watchdog = ray_watchdog; ifp->if_init = ray_init; ifp->if_snd.ifq_maxlen = RAY_CCS_TX_LAST; /* * If this logical interface has already been attached, * don't attach it again or chaos will ensue. */ sprintf(ifname, "ray%d", sc->unit); if (ifunit(ifname) == NULL) { callout_handle_init(&sc->timerh); #if RAY_NEED_STARTJOIN_TIMO callout_handle_init(&sc->sj_timerh); #endif /* RAY_NEED_STARTJOIN_TIMO */ if_attach(ifp); ether_ifattach(ifp); #if NBPFILTER > 0 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header)); #endif /* NBFFILTER */ #if XXX this looks like a good idea at_shutdown(ray_shutdown, sc, SHUTDOWN_POST_SYNC); #endif /* XXX */ } return(0); } /* * Network start. * *XXX from if_xe * Start output on interface. We make two assumptions here: * 1) that the current priority is set to splimp _before_ this code * is called *and* is returned to the appropriate priority after * return * 2) that the IFF_OACTIVE flag is checked before this code is called * (i.e. that the output part of the interface is idle) *XXX from if_xe so maybe we can ignore? see start_join_net_done */ static void ray_start (ifp) register struct ifnet *ifp; { struct ray_softc *sc; struct mbuf *m; RAY_DPRINTF(("ray%d: Network start\n", ifp->if_unit)); /* XXX mark output queue full so the kernel waits */ ifp->if_flags |= IFF_OACTIVE; return; /* XXX mark output queue full so the kernel waits */ sc = ifp->if_softc; RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before start!\n", sc->unit); return; } if ((ifp->if_flags & IFF_RUNNING) == 0 || !sc->sc_havenet) return; /* We only deal with one packet at a time */ /* XXX is this actually true? I don't think so there are 16 ccs */ if (ifp->if_flags & IFF_OACTIVE) return; #if XXX netbsd driver uses a loop repeat get a ccs get a mbuf translate and send packet to shared ram until (no more ccs's) || (no more mbuf's) send ccs chain to card exit Linux driver is simple single shot packet (with a lot of spinlocks!) general why 14 CCS reserved for TX in Linux+NetBSD? Is it simply that there are that many ethernet+80211header packets in the TX memory space? probably the tx space is 0x7000 = 28kB, and TX buffer size is 2048? so there can be 14 requests at 2kB each from this 2k we have to remove the TIB - whatever that is - for data netbsd: we need to call _start after receiveing a packet to see if any packets were queued whilst in the interrupt there is a potential race in obtaining ccs's for the tx, in that we might be in _start synchronously and then an rx interrupt occurs. the rx will call _start and steal tx ccs from underneath the interrupted entry. toptions don't call _start from rx interrupt find a safe way of locking find a better way of obtaining ccs using next free avilable? look at other drivers use tsleep/wakeup some form of ring to hold ccs free lsit #endif IF_DEQUEUE(&ifp->if_snd, m); if (m == NULL) return; return; } /* * Network ioctl request. */ static int ray_ioctl (ifp, command, data) register struct ifnet *ifp; u_long command; caddr_t data; { struct ray_softc *sc; int s, error = 0; RAY_DPRINTF(("ray%d: Network ioctl\n", ifp->if_unit)); sc = ifp->if_softc; RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before ioctl!\n", sc->unit); ifp->if_flags &= ~IFF_RUNNING; return ENXIO; } s = splimp(); switch (command) { case SIOCSIFADDR: case SIOCGIFADDR: case SIOCSIFMTU: RAY_DPRINTF(("ray%d: ioctl SIFADDR/GIFADDR/SIFMTU\n", sc->unit)); error = ether_ioctl(ifp, command, data); break; case SIOCSIFFLAGS: RAY_DPRINTF(("ray%d: for SIFFLAGS\n", sc->unit)); /* * If the interface is marked up and stopped, then start * it. If it is marked down and running, then stop it. */ if (ifp->if_flags & IFF_UP) { if (!(ifp->if_flags & IFF_RUNNING)) ray_init(sc); } else { if (ifp->if_flags & IFF_RUNNING) ray_stop(sc); } /* DROP THROUGH */ #if XXX case SIOCADDMULTI: case SIOCDELMULTI: RAY_DPRINTF(("ray%d: ioctl called for ADDMULTI/DELMULTI\n, sc->unit")); /* * Multicast list has (maybe) changed; set the hardware filter * accordingly. This also serves to deal with promiscuous mode * if we have a BPF listener active. */ ray_setmulti(sc); #endif /* XXX */ error = 0; break; case SIOCGIFFLAGS: RAY_DPRINTF(("ray%d: ioctl called for GIFFLAGS\n", sc->unit)); error = EINVAL; break; case SIOCGIFMETRIC: RAY_DPRINTF(("ray%d: ioctl called for GIFMETRIC\n", sc->unit)); error = EINVAL; break; case SIOCGIFMTU: RAY_DPRINTF(("ray%d: ioctl called for GIFMTU\n", sc->unit)); error = EINVAL; break; case SIOCGIFPHYS: RAY_DPRINTF(("ray%d: ioctl called for GIFPYHS\n", sc->unit)); error = EINVAL; break; case SIOCSIFMEDIA: RAY_DPRINTF(("ray%d: ioctl called for SIFMEDIA\n", sc->unit)); error = EINVAL; break; case SIOCGIFMEDIA: RAY_DPRINTF(("ray%d: ioctl called for GIFMEDIA\n", sc->unit)); #if RAY_DUMP_CM_ON_GIFMEDIA RAY_DPRINTF(("ray%d: RAY_SCB\n", sc->unit)); RAY_DHEX8((u_int8_t *)sc->maddr + RAY_SCB_BASE, 0x20); RAY_DPRINTF(("ray%d: RAY_STATUS\n", sc->unit)); RAY_DNET_DUMP(sc, "."); #endif /* RAY_DUMP_CM_ON_GIFMEDIA */ error = EINVAL; break; default: error = EINVAL; } (void)splx(s); return(error); } static void ray_watchdog (ifp) register struct ifnet *ifp; { struct ray_softc *sc; RAY_DPRINTF(("ray%d: Network watchdog\n", ifp->if_unit)); sc = ifp->if_softc; RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before watchdog!\n", sc->unit); return; } printf("ray%d: watchdog timeout\n", sc->unit); /* XXX may need to have remedial action here for example ray_reset - may be useful elsewhere ray_stop ... ray_init */ return; } /* * Network initialisation. */ static void ray_init (xsc) void *xsc; { struct ray_softc *sc = xsc; struct ray_ecf_startup_v5 *ep; struct ifnet *ifp; size_t ccs; int i; RAY_DPRINTF(("ray%d: Network init\n", sc->unit)); RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before init!\n", sc->unit); return; } ifp = &sc->arpcom.ac_if; if ((ifp->if_flags & IFF_RUNNING)) ray_stop(sc); /* * Reset instance variables * * The first set are network parameters that are fully initialised * when the card starts or joins the network. * * The second set are network parameters that are downloaded to * the card. * * All of the variables in these sets can be updated by the card or ioctls. */ sc->sc_upd_param = 0; bzero(sc->sc_bss_id, sizeof(sc->sc_bss_id)); sc->sc_inited = 0; sc->sc_def_txrate = 0; sc->sc_encrypt = 0; sc->translation = SC_TRANSLATE_WEBGEAR; #if XXX these might be better in _attach so updated values are kept over up/down events we probably also need a few more countrycode #endif sc->sc_net_type = RAY_MIB_NET_TYPE_DEFAULT; bzero(&sc->sc_ssid, sizeof(sc->sc_ssid)); strncpy(sc->sc_ssid, RAY_MIB_SSID_DEFAULT, RAY_MAXSSIDLEN); sc->sc_priv_start = RAY_MIB_PRIVACY_MUST_START_DEFAULT; sc->sc_priv_join = RAY_MIB_PRIVACY_CAN_JOIN_DEFAULT; sc->sc_havenet = 0; #if XXX NetBSD sc->sc_scheduled = 0; sc->sc_running = 0; sc->sc_txfree = RAY_CCS_NTX; sc->sc_checkcounters = 0; #endif /* Set all ccs to be free */ bzero(sc->sc_ccsinuse, sizeof(sc->sc_ccsinuse)); sc->sc_ccs = RAY_CCS_LAST + 1; ccs = RAY_CCS_ADDRESS(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 any pending interrupts */ RAY_HCS_CLEAR_INTR(sc); /* * Get startup results - the card may have been reset */ ep = &sc->sc_ecf_startup; ray_read_region(sc, RAY_ECF_TO_HOST_BASE, ep, sizeof(sc->sc_ecf_startup)); if (ep->e_status != RAY_ECFS_CARD_OK) { printf("ray%d: card failed self test: status 0x%b\n", sc->unit, ep->e_status, "\020" /* print in hex */ "\001RESERVED0" "\002PROC_SELF_TEST" "\003PROG_MEM_CHECKSUM" "\004DATA_MEM_TEST" "\005RX_CALIBRATION" "\006FW_VERSION_COMPAT" "\007RERSERVED1" "\008TEST_COMPLETE" ); #if XXX return; /* XXX This doesn't mark the interface as down */ #endif /* XXX */ } /* * Fixup tib size to be correct - on build 4 it is garbage */ if (sc->sc_version == RAY_ECFS_BUILD_4 && sc->sc_tibsize == 0x55) sc->sc_tibsize = 32; /* * We are now up and running. Next we have to download network * configuration into the card. We are busy until download is done. */ ifp->if_flags |= IFF_RUNNING | IFF_OACTIVE; #if XXX /* set this now so it gets set in the download */ sc->sc_promisc = !!(sc->sc_if.if_flags & (IFF_PROMISC|IFF_ALLMULTI)); #endif /* XXX */ ray_download_params(sc); #if XXX need to understand how the doenload finishes first Start up flow is as follows. The kernel calls ray_init when the interface is assigned an address. ray_init does a bit of house keeping before calling ray_download_params. ray_download_params fills the startup parameter structure out and sends it to the card. The download command simply completes so we use schedule a timeout function call to ray_download_timo. We pass the ccs in use via sc->sc_css. ray_download_timo checks the ccs for command completion/errors. Then it tells the card to start an adhoc or join a managed network. This should complete via the interrupt mechanism, but the NetBSD driver includes a timeout for some buggy stuff somewhere. I've left the hooks in but don't use them. The interrupt handler passes control to ray_start_join_done - the ccs is handled by the interrupt mechanism. Once ray_start_join_done has checked the ccs and uploaded/updated the network parameters we are ready to process packets. It can then call ray_start. #endif /* XXX */ return; } /* * Network stop. */ static void ray_stop (sc) struct ray_softc *sc; { struct ifnet *ifp; RAY_DPRINTF(("ray%d: Network stop\n", sc->unit)); RAY_MAP_CM(sc); if (sc->gone) { printf("ray%d: unloaded before stop!\n", sc->unit); return; } ifp = &sc->arpcom.ac_if; /* XXX stuff here please to kill activity on the card and drain down transmissons */ /* Mark as not running */ ifp->if_flags &= ~IFF_RUNNING; return; } /* * Process CCS command completion - called from ray_intr */ static void ray_ccs_done (sc, ccs) struct ray_softc *sc; size_t ccs; { u_int cmd, status; RAY_DPRINTF(("ray%d: Processing ccs %d\n", sc->unit, RAY_CCS_INDEX(ccs))); RAY_MAP_CM(sc); cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd); status = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status); RAY_DPRINTF(("ray%d: ccs idx %d ccs 0x%x cmd 0x%x stat %d\n", sc->unit, RAY_CCS_INDEX(ccs), ccs, cmd, status)); /* XXX should we panic on unrecognised commands or just ignore them? * maybe I'll macroize the printf's */ switch (cmd) { case RAY_CMD_START_PARAMS: printf("ray%d: ray_ccs_done got START_PARAMS - why?\n", sc->unit); break; case RAY_CMD_UPDATE_PARAMS: RAY_DPRINTF(("ray%d: ray_ccs_done got UPDATE_PARAMS\n", sc->unit)); XXX; break; case RAY_CMD_REPORT_PARAMS: RAY_DPRINTF(("ray%d: ray_ccs_done got REPORT_PARAMS\n", sc->unit)); XXX; break; case RAY_CMD_UPDATE_MCAST: RAY_DPRINTF(("ray%d: ray_ccs_done got UPDATE_MCAST\n", sc->unit)); XXX; break; case RAY_CMD_UPDATE_APM: RAY_DPRINTF(("ray%d: ray_ccs_done got UPDATE_APM\n", sc->unit)); XXX; break; case RAY_CMD_START_NET: case RAY_CMD_JOIN_NET: RAY_DPRINTF(("ray%d: ray_ccs_done got START|JOIN_NET\n", sc->unit)); ray_start_join_done(sc, ccs, status); break; case RAY_CMD_START_ASSOC: RAY_DPRINTF(("ray%d: ray_ccs_done got START_ASSOC\n", sc->unit)); sc->sc_havenet = 1; /* Should not be here but in function */ XXX; break; case RAY_CMD_TX_REQ: RAY_DPRINTF(("ray%d: ray_ccs_done got TX_REQ\n", sc->unit)); SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_FREE); if (sc->sc_if.if_flags & IFF_OACTIVE) sc->sc_if.if_flags &= ~IFF_OACTIVE; return; case RAY_CMD_TEST_MEM: printf("ray%d: ray_ccs_done got TEST_MEM - why?\n", sc->unit); break; case RAY_CMD_SHUTDOWN: printf("ray%d: ray_ccs_done got SHUTDOWN - why?\n", sc->unit); break; case RAY_CMD_DUMP_MEM: printf("ray%d: ray_ccs_done got DUMP_MEM - why?\n", sc->unit); break; case RAY_CMD_START_TIMER: printf("ray%d: ray_ccs_done got START_TIMER - why?\n", sc->unit); break; default: printf("ray%d: ray_ccs_done unknown command 0x%x\n", sc->unit, cmd); break; } ray_free_ccs(sc, ccs); return; } /* * Process ECF command request - called from ray_intr */ static void ray_rcs_intr (sc, rcs) struct ray_softc *sc; size_t rcs; { struct ifnet *ifp; u_int cmd, status; RAY_DPRINTF(("ray%d: Processing rcs %d\n", sc->unit, RAY_CCS_INDEX(rcs))); RAY_MAP_CM(sc); ifp = &sc->arpcom.ac_if; cmd = SRAM_READ_FIELD_1(sc, rcs, ray_cmd, c_cmd); status = SRAM_READ_FIELD_1(sc, rcs, ray_cmd, c_status); RAY_DPRINTF(("ray%d: rcs idx %d rcs 0x%x cmd 0x%x stat %d\n", sc->unit, RAY_CCS_INDEX(rcs), rcs, cmd, status)); /* XXX should we panic on unrecognised commands or just ignore them? * maybe I'll macroize the printf's */ switch (cmd) { case RAY_ECMD_RX_DONE: printf("ray%d: ray_rcs_intr got RX_DONE\n", sc->unit); ray_rx(sc, rcs); break; case RAY_ECMD_REJOIN_DONE: RAY_DPRINTF(("ray%d: ray_rcs_intr got UPDATE_PARAMS\n", sc->unit)); XXX; break; case RAY_ECMD_ROAM_START: RAY_DPRINTF(("ray%d: ray_rcs_intr got ROAM_START\n", sc->unit)); sc->sc_havenet = 0; /* Should not be here but in function */ XXX; break; case RAY_ECMD_JAPAN_CALL_SIGNAL: printf("ray%d: ray_rcs_intr got JAPAN_CALL_SIGNAL - why?\n", sc->unit); break; default: printf("ray%d: ray_rcs_intr unknown command 0x%x\n", sc->unit, cmd); break; } SRAM_WRITE_FIELD_1(sc, rcs, ray_cmd, c_status, RAY_CCS_STATUS_FREE); return; } /* * Receive a packet */ static void ray_rx (sc, rcs) struct ray_softc *sc; size_t rcs; { struct ieee80211_header *header; struct ether_header *eh; struct ifnet *ifp; struct mbuf *m; size_t pktlen, fraglen, readlen, tmplen; size_t bufp, ebufp; u_int8_t *dst, *src; u_int8_t fc; u_int first, ni, i; RAY_DPRINTF(("ray%d: ray_rx\n", sc->unit)); RAY_MAP_CM(sc); RAY_DPRINTF(("ray%d: rcs chain - using rcs 0x%x\n", sc->unit, rcs)); ifp = &sc->arpcom.ac_if; m = NULL; readlen = 0; /* * Get first part of packet and the length. Do some sanity checks * and get a mbuf. */ first = RAY_CCS_INDEX(rcs); pktlen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_pktlen); if ((pktlen > MCLBYTES) || (pktlen < 1/*XXX should be header size*/)) { RAY_DPRINTF(("ray%d: ray_rx packet is too big or too small\n", sc->unit)); ifp->if_ierrors++; goto skip_read; } MGETHDR(m, M_DONTWAIT, MT_DATA); if (m == NULL) { RAY_DPRINTF(("ray%d: ray_rx MGETHDR failed\n", sc->unit)); ifp->if_ierrors++; goto skip_read; } if (pktlen > MHLEN) { MCLGET(m, M_DONTWAIT); if ((m->m_flags & M_EXT) == 0) { RAY_DPRINTF(("ray%d: ray_rx MCLGET failed\n", sc->unit)); ifp->if_ierrors++; m_freem(m); m = 0; goto skip_read; } } m->m_pkthdr.rcvif = ifp; m->m_pkthdr.len = pktlen; m->m_len = pktlen; dst = mtod(m, u_int8_t *); /* * Walk the fragment chain to build the complete packet. * * The use of two index variables removes a race with the * hardware. If one index were used the clearing of the CCS would * happen before reading the next pointer and the hardware can get in. * Not my idea but verbatim from the NetBSD driver. */ i = ni = first; while ((i = ni) && (i != RAY_CCS_LINK_NULL)) { rcs = RAY_CCS_ADDRESS(i); ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag); bufp = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_bufp); fraglen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_len); RAY_DPRINTF(("ray%d: ray_rx frag index %d len %d bufp 0x%x ni %d\n", sc->unit, i, fraglen, (int)bufp, ni)); if (fraglen + readlen > pktlen) { RAY_DPRINTF(("ray%d: ray_rx bad length current 0x%x pktlen 0x%x\n", sc->unit, fraglen + readlen, pktlen)); ifp->if_ierrors++; m_freem(m); m = 0; goto skip_read; } if ((i < RAY_RCS_FIRST) || (i > RAY_RCS_LAST)) { printf("ray%d: ray_rx bad rcs index 0x%x\n", sc->unit, i); ifp->if_ierrors++; m_freem(m); m = 0; goto skip_read; } ebufp = bufp + fraglen; if (ebufp <= RAY_RX_END) ray_read_region(sc, bufp, dst, fraglen); else { ray_read_region(sc, bufp, dst, (tmplen = RAY_RX_END - bufp)); ray_read_region(sc, RAY_RX_BASE, dst + tmplen, ebufp - RAY_RX_END); } dst += fraglen; readlen += fraglen; } skip_read: /* * Walk the chain again to free the rcss. */ i = ni = first; RAY_DPRINTF(("ray%d: ray_rx cleaning rcs fragments ", sc->unit)); while ((i = ni) && (i != RAY_CCS_LINK_NULL)) { RAY_DPRINTF(("%d ", i)); rcs = RAY_CCS_ADDRESS(i); ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag); SRAM_WRITE_FIELD_1(sc, rcs, ray_cmd, c_status, RAY_CCS_STATUS_FREE); } RAY_DPRINTF(("\n")); if (!m) return; RAY_DPRINTF(("ray%d: ray_rx got packet pktlen %d actual %d\n", sc->unit, pktlen, readlen)); RAY_DMBUF_DUMP(sc, m, "ray_rx"); /* * Check the 802.11 packet type and obtain the .11 src address. * * XXX CTL and MGT packets will have separate functions, * DATA dealt with here */ header = mtod(m, struct ieee80211_header *); fc = header->i_fc[0]; if ((fc & IEEE80211_FC0_VERSION_MASK) != IEEE80211_FC0_VERSION_0) { RAY_DPRINTF(("ray%d: header not version 0 fc 0x%x\n", sc->unit, fc)); m_freem(m); return; } switch (fc & IEEE80211_FC0_TYPE_MASK) { case IEEE80211_FC0_TYPE_MGT: printf("ray%d: ray_rx got a .11 MGT packet - why?\n", sc->unit); m_freem(m); return; case IEEE80211_FC0_TYPE_CTL: printf("ray%d: ray_rx got a .11 CTL packet - why?\n", sc->unit); m_freem(m); return; case IEEE80211_FC0_TYPE_DATA: RAY_DPRINTF(("ray%d: ray_rx got a .11 DATA packet\n", sc->unit)); break; default: printf("ray%d: ray_rx got a unknown .11 packet fc0 0x%x - why?\n", sc->unit, fc); m_freem(m); return; } fc = header->i_fc[1]; switch (fc & IEEE80211_FC1_RCVFROM_MASK) { case IEEE80211_FC1_RCVFROM_TERMINAL: src = header->i_addr2; RAY_DPRINTF(("ray%d: ray_rx got packet from station %6D\n", sc->unit, src, ":")); break; case IEEE80211_FC1_RCVFROM_AP: src = header->i_addr3; RAY_DPRINTF(("ray%d: ray_rx got packet from ap %6D\n", sc->unit, src, ":")); break; case IEEE80211_FC1_RCVFROM_AP2AP: RAY_DPRINTF(("ray%d: ray_rx saw packet between aps %6D %6D %6D\n", sc->unit, header->i_addr1, ":", header->i_addr2, ":", header->i_addr3, ":")); m_freem(m); return; default: printf("ray%d: ray_rx packet type unknown fc1 0x%x - why?\n", sc->unit, fc); m_freem(m); return; } /* * XXX * * Currently only support the Webgear encapsulation * 802.11 header struct ieee80211_header * 802.3 header struct ether_header * 802.2 LLC header * 802.2 SNAP header * * We should support whatever packet types the following drivers have * if_wi.c FreeBSD, RFC1042 * if_ray.c NetBSD Webgear, RFC1042 * rayctl.c Linux Webgear, RFC1042 * also whatever we can divine from the NDC Access points and * Kanda's boxes. * * Most appear to have a RFC1042 translation. The incoming packet is * 802.11 header struct ieee80211_header * 802.2 LLC header * 802.2 SNAP header * * This is translated to * 802.3 header struct ether_header * 802.2 LLC header * 802.2 SNAP header * * Linux seems to look at the SNAP org_code and do some translations * for IPX and APPLEARP on that. This just may be how Linux does IPX * and NETATALK. Need to see how FreeBSD does these. * * Translation should be selected via if_media stuff or link types. */ switch (sc->translation) { case SC_TRANSLATE_WEBGEAR: /* XXX error checking ? how? */ eh = (struct ether_header *)(header + 1); m_adj(m, sizeof(struct ieee80211_header)+sizeof(struct ether_header)); break; default: printf("ray%d: ray_rx unknown translation type 0x%x - why?\n", sc->unit, sc->translation); m_freem(m); return; } #if NBPFILTER > 0 /* Handle BPF listeners. */ if (ifp->if_bpf) bpf_mtap(ifp, m); #endif /* NBPFILTER */ #if XXX if_wi.c - might be needed if we hear our own broadcasts in promiscuous mode if ((ifp->if_flags & IFF_PROMISC) && (bcmp(eh->ether_shost, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN) && (eh->ether_dhost[0] & 1) == 0) ) { m_freem(m); return; } #endif /* XXX */ ether_input(ifp, eh, m); return; } /* * Download start up structures to card. * * Part of ray_init, download, startjoin control flow. */ static void ray_download_params (sc) struct ray_softc *sc; { struct ray_mib_4 ray_mib_4_default; struct ray_mib_5 ray_mib_5_default; RAY_DPRINTF(("ray%d: Downloading startup parameters\n", sc->unit)); RAY_MAP_CM(sc); RAY_DNET_DUMP(sc, " before we download them."); #if XXX netbsd ray_cmd_cancel(sc, SCP_UPD_STARTUP); #endif /* XXX */ #define MIB4(m) ray_mib_4_default.##m #define MIB5(m) ray_mib_5_default.##m #define PUT2(p, v) \ do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0) /* * Firmware version 4 defaults - see if_raymib.h for details */ MIB4(mib_net_type) = sc->sc_net_type; MIB4(mib_ap_status) = RAY_MIB_AP_STATUS_DEFAULT; strncpy(MIB4(mib_ssid), sc->sc_ssid, RAY_MAXSSIDLEN); MIB4(mib_scan_mode) = RAY_MIB_SCAN_MODE_DEFAULT; MIB4(mib_apm_mode) = RAY_MIB_APM_MODE_DEFAULT; bcopy(sc->sc_station_addr, MIB4(mib_mac_addr), ETHER_ADDR_LEN); PUT2(MIB4(mib_frag_thresh), RAY_MIB_FRAG_THRESH_DEFAULT); PUT2(MIB4(mib_dwell_time), RAY_MIB_DWELL_TIME_V4); PUT2(MIB4(mib_beacon_period), RAY_MIB_BEACON_PERIOD_V4); MIB4(mib_dtim_interval) = RAY_MIB_DTIM_INTERVAL_DEFAULT; MIB4(mib_max_retry) = RAY_MIB_MAX_RETRY_DEFAULT; MIB4(mib_ack_timo) = RAY_MIB_ACK_TIMO_DEFAULT; MIB4(mib_sifs) = RAY_MIB_SIFS_DEFAULT; MIB4(mib_difs) = RAY_MIB_DIFS_DEFAULT; MIB4(mib_pifs) = RAY_MIB_PIFS_V4; PUT2(MIB4(mib_rts_thresh), RAY_MIB_RTS_THRESH_DEFAULT); PUT2(MIB4(mib_scan_dwell), RAY_MIB_SCAN_DWELL_V4); PUT2(MIB4(mib_scan_max_dwell), RAY_MIB_SCAN_MAX_DWELL_V4); MIB4(mib_assoc_timo) = RAY_MIB_ASSOC_TIMO_DEFAULT; MIB4(mib_adhoc_scan_cycle) = RAY_MIB_ADHOC_SCAN_CYCLE_DEFAULT; MIB4(mib_infra_scan_cycle) = RAY_MIB_INFRA_SCAN_CYCLE_DEFAULT; MIB4(mib_infra_super_scan_cycle) = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_DEFAULT; MIB4(mib_promisc) = RAY_MIB_PROMISC_DEFAULT; PUT2(MIB4(mib_uniq_word), RAY_MIB_UNIQ_WORD_DEFAULT); MIB4(mib_slot_time) = RAY_MIB_SLOT_TIME_V4; MIB4(mib_roam_low_snr_thresh) = RAY_MIB_ROAM_LOW_SNR_THRESH_DEFAULT; MIB4(mib_low_snr_count) = RAY_MIB_LOW_SNR_COUNT_DEFAULT; MIB4(mib_infra_missed_beacon_count)= RAY_MIB_INFRA_MISSED_BEACON_COUNT_DEFAULT; MIB4(mib_adhoc_missed_beacon_count)= RAY_MIB_ADHOC_MISSED_BEACON_COUNT_DEFAULT; MIB4(mib_country_code) = RAY_MIB_COUNTRY_CODE_DEFAULT; MIB4(mib_hop_seq) = RAY_MIB_HOP_SEQ_DEFAULT; MIB4(mib_hop_seq_len) = RAY_MIB_HOP_SEQ_LEN_V4; MIB4(mib_cw_max) = RAY_MIB_CW_MAX_V4; MIB4(mib_cw_min) = RAY_MIB_CW_MIN_V4; MIB4(mib_noise_filter_gain) = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT; MIB4(mib_noise_limit_offset) = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT; MIB4(mib_rssi_thresh_offset) = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT; MIB4(mib_busy_thresh_offset) = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT; MIB4(mib_sync_thresh) = RAY_MIB_SYNC_THRESH_DEFAULT; MIB4(mib_test_mode) = RAY_MIB_TEST_MODE_DEFAULT; MIB4(mib_test_min_chan) = RAY_MIB_TEST_MIN_CHAN_DEFAULT; MIB4(mib_test_max_chan) = RAY_MIB_TEST_MAX_CHAN_DEFAULT; /* * Firmware version 5 defaults - see if_raymib.h for details */ MIB5(mib_net_type) = sc->sc_net_type; MIB5(mib_ap_status) = RAY_MIB_AP_STATUS_DEFAULT; strncpy(MIB5(mib_ssid), sc->sc_ssid, RAY_MAXSSIDLEN); MIB5(mib_scan_mode) = RAY_MIB_SCAN_MODE_DEFAULT; MIB5(mib_apm_mode) = RAY_MIB_APM_MODE_DEFAULT; bcopy(sc->sc_station_addr, MIB5(mib_mac_addr), ETHER_ADDR_LEN); PUT2(MIB5(mib_frag_thresh), RAY_MIB_FRAG_THRESH_DEFAULT); PUT2(MIB5(mib_dwell_time), RAY_MIB_DWELL_TIME_V5); PUT2(MIB5(mib_beacon_period), RAY_MIB_BEACON_PERIOD_V5); MIB5(mib_dtim_interval) = RAY_MIB_DTIM_INTERVAL_DEFAULT; MIB5(mib_max_retry) = RAY_MIB_MAX_RETRY_DEFAULT; MIB5(mib_ack_timo) = RAY_MIB_ACK_TIMO_DEFAULT; MIB5(mib_sifs) = RAY_MIB_SIFS_DEFAULT; MIB5(mib_difs) = RAY_MIB_DIFS_DEFAULT; MIB5(mib_pifs) = RAY_MIB_PIFS_V5; PUT2(MIB5(mib_rts_thresh), RAY_MIB_RTS_THRESH_DEFAULT); PUT2(MIB5(mib_scan_dwell), RAY_MIB_SCAN_DWELL_V5); PUT2(MIB5(mib_scan_max_dwell), RAY_MIB_SCAN_MAX_DWELL_V5); MIB5(mib_assoc_timo) = RAY_MIB_ASSOC_TIMO_DEFAULT; MIB5(mib_adhoc_scan_cycle) = RAY_MIB_ADHOC_SCAN_CYCLE_DEFAULT; MIB5(mib_infra_scan_cycle) = RAY_MIB_INFRA_SCAN_CYCLE_DEFAULT; MIB5(mib_infra_super_scan_cycle) = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_DEFAULT; MIB5(mib_promisc) = RAY_MIB_PROMISC_DEFAULT; PUT2(MIB5(mib_uniq_word), RAY_MIB_UNIQ_WORD_DEFAULT); MIB5(mib_slot_time) = RAY_MIB_SLOT_TIME_V5; MIB5(mib_roam_low_snr_thresh) = RAY_MIB_ROAM_LOW_SNR_THRESH_DEFAULT; MIB5(mib_low_snr_count) = RAY_MIB_LOW_SNR_COUNT_DEFAULT; MIB5(mib_infra_missed_beacon_count)= RAY_MIB_INFRA_MISSED_BEACON_COUNT_DEFAULT; MIB5(mib_adhoc_missed_beacon_count)= RAY_MIB_ADHOC_MISSED_BEACON_COUNT_DEFAULT; MIB5(mib_country_code) = RAY_MIB_COUNTRY_CODE_DEFAULT; MIB5(mib_hop_seq) = RAY_MIB_HOP_SEQ_DEFAULT; MIB5(mib_hop_seq_len) = RAY_MIB_HOP_SEQ_LEN_V5; PUT2(MIB5(mib_cw_max), RAY_MIB_CW_MAX_V5); PUT2(MIB5(mib_cw_min), RAY_MIB_CW_MIN_V5); MIB5(mib_noise_filter_gain) = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT; MIB5(mib_noise_limit_offset) = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT; MIB5(mib_rssi_thresh_offset) = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT; MIB5(mib_busy_thresh_offset) = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT; MIB5(mib_sync_thresh) = RAY_MIB_SYNC_THRESH_DEFAULT; MIB5(mib_test_mode) = RAY_MIB_TEST_MODE_DEFAULT; MIB5(mib_test_min_chan) = RAY_MIB_TEST_MIN_CHAN_DEFAULT; MIB5(mib_test_max_chan) = RAY_MIB_TEST_MAX_CHAN_DEFAULT; MIB5(mib_allow_probe_resp) = RAY_MIB_ALLOW_PROBE_RESP_DEFAULT; MIB5(mib_privacy_must_start) = RAY_MIB_PRIVACY_MUST_START_DEFAULT; MIB5(mib_privacy_can_join) = sc->sc_priv_start; MIB5(mib_basic_rate_set[0]) = sc->sc_priv_join; if (!RAY_ECF_READY(sc)) panic("ray%d: ray_download_params something is already happening\n", sc->unit); if (sc->sc_version == RAY_ECFS_BUILD_4) ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &ray_mib_4_default, sizeof(ray_mib_4_default)); else ray_write_region(sc, RAY_HOST_TO_ECF_BASE, &ray_mib_5_default, sizeof(ray_mib_5_default)); /* XXX * NetBSD * hand expanding ray_simple_cmd * we dont do any of the clever timeout stuff yet (i.e. ray_cmd_ran) just * simple check * * if (!ray_simple_cmd(sc, RAY_CMD_START_PARAMS, SCP_UPD_STARTUP)) * panic("ray_download_params issue"); * * ray_simple_cmd == * ray_alloc_ccs(sc, &ccs, cmd, track) && * ray_issue_cmd(sc, ccs, track)); * */ /* * Get a free command ccs and issue the command - there is nothing * to fill in for a START_PARAMS command. The start parameters * command just gets serviced, so we use a timeout to complete the * sequence. */ if (!ray_alloc_ccs(sc, &sc->sc_ccs, RAY_CMD_START_PARAMS, SCP_UPD_STARTUP)) panic("ray%d: ray_download_params can't get a CCS\n", sc->unit); if (!ray_issue_cmd(sc, sc->sc_ccs, SCP_UPD_STARTUP)) panic("ray%d: ray_download_params can't issue command\n", sc->unit); sc->timerh = timeout(ray_download_timo, sc, RAY_CCS_TIMEOUT); RAY_DPRINTF(("ray%d: Download now awaiting timeout\n", sc->unit)); return; } /* * Download timeout routine. * * Part of ray_init, download, start_join control flow. */ static void ray_download_timo (xsc) void *xsc; { struct ray_softc *sc = xsc; size_t ccs; u_int8_t status, cmd; RAY_DPRINTF(("ray%d: ray_download_timo\n", sc->unit)); RAY_MAP_CM(sc); status = SRAM_READ_FIELD_1(sc, sc->sc_ccs, ray_cmd, c_status); cmd = SRAM_READ_FIELD_1(sc, sc->sc_ccs, ray_cmd, c_cmd); RAY_DPRINTF(("ray%d: check rayidx %d ccs 0x%x cmd 0x%x stat %d\n", sc->unit, RAY_CCS_INDEX(sc->sc_ccs), sc->sc_ccs, cmd, status)); if ((cmd != RAY_CMD_START_PARAMS) || (status != RAY_CCS_STATUS_FREE)) printf("ray%d: Download ccs odd cmd = 0x%02x, status = 0x%02x", sc->unit, cmd, status); /*XXX so what do we do? reset or retry? */ /*XXX this gets triggered when we try and re-reset the ipaddress * ray_init gets called */ /* * If the card is still busy, re-schedule ourself */ if (status == RAY_CCS_STATUS_BUSY) { RAY_DPRINTF(("ray%d: ray_download_timo - still busy, see you soon\n", sc->unit)); sc->timerh = timeout(ray_download_timo, sc, RAY_CCS_TIMEOUT); } /* Clear the ccs */ ray_free_ccs(sc, sc->sc_ccs); sc->sc_ccs = RAY_CCS_LAST + 1; #if XXX NetBSD clear IFF_OACTIVE at this point #endif /* * Grab a ccs and don't bother updating the network parameters. * Issue the start/join command and we get interrupted back. */ if (sc->sc_net_type == RAY_MIB_NET_TYPE_ADHOC) cmd = RAY_CMD_START_NET; else cmd = RAY_CMD_JOIN_NET; if (!ray_alloc_ccs(sc, &ccs, cmd, SCP_UPD_STARTJOIN)) panic("ray%d: ray_download_timo can't get a CCS to start/join net\n", sc->unit); SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_net, c_upd_param, 0); if (!ray_issue_cmd(sc, ccs, SCP_UPD_STARTJOIN)) panic("ray%d: ray_download_timo can't issue start/join\n", sc->unit); #if RAY_NEED_STARTJOIN_TIMO sc->sj_timerh = timeout(ray_start_join_timo, sc, RAY_CCS_TIMEOUT); #endif /* RAY_NEED_STARTJOIN_TIMO */ RAY_DPRINTF(("ray%d: Start-join awaiting interrupt/timeout\n", sc->unit)); return; } /* * Complete start or join command. * * Part of ray_init, download, start_join control flow. */ static void ray_start_join_done (sc, ccs, status) struct ray_softc *sc; size_t ccs; u_int8_t status; { u_int8_t o_net_type; RAY_DPRINTF(("ray%d: ray_start_join_done\n", sc->unit)); RAY_MAP_CM(sc); #if RAY_NEED_STARTJOIN_TIMO untimeout(ray_start_join_timo, sc, sc->sj_timerh); #endif /* RAY_NEED_STARTJOIN_TIMO */ #if XXX_TRACKING ray_cmd_done(sc, SCP_UPD_STARTJOIN); #endif /* XXX_TRACKING */ switch (status) { case RAY_CCS_STATUS_FREE: case RAY_CCS_STATUS_BUSY: printf("ray%d: ray_start_join_done status is FREE/BUSY - why?\n", sc->unit); break; case RAY_CCS_STATUS_COMPLETE: break; case RAY_CCS_STATUS_FAIL: printf("ray%d: ray_start_join_done status is FAIL - why?\n", sc->unit); sc->sc_havenet = 0; #if XXX restart ray_start_join sequence may need to split download_done for this #endif break; default: printf("ray%d: ray_start_join_done unknown status 0x%x\n", sc->unit, status); break; } if (status != RAY_CCS_STATUS_COMPLETE) return; /* * If the command completed correctly, get a few network parameters * from the ccs and active the network. */ ray_read_region(sc, ccs, &sc->sc_cnet_1, sizeof(struct ray_cmd_net)); /* adjust values for buggy build 4 */ if (sc->sc_def_txrate == 0x55) sc->sc_def_txrate = RAY_MIB_BASIC_RATE_SET_1500K; if (sc->sc_encrypt == 0x55) sc->sc_encrypt = 0; /* card is telling us to update the network parameters */ if (sc->sc_upd_param) { RAY_DPRINTF(("ray%d: sj_done card updating parameters - why?\n", sc->unit)); o_net_type = sc->sc_net_type; ray_read_region(sc, RAY_HOST_TO_ECF_BASE, &sc->sc_cnet_2, sizeof(struct ray_net_params)); if (sc->sc_net_type != o_net_type) { printf("ray%d: sj_done card changing network type - why?\n", sc->unit); #if XXX restart ray_start_join sequence ? may need to split download_timo for this panic? #endif } } RAY_DNET_DUMP(sc, " after start/join network completed."); /* * Hurrah! The network is now active */ #if XXX_MCASTPROM ray_cmd_schedule(sc, SCP_UPD_MCAST|SCP_UPD_PROMISC); #endif /* XXX_MCASTPROM */ if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd) == RAY_CMD_JOIN_NET) #if XXX ray_start_assoc(sc); #else RAY_DPRINTF(("wanted to join a NET!\n")); #endif /* XXX */ else { sc->sc_havenet = 1; /* XXX need to check havenet setting/clearing */ #if XXX ray_start needs OACTIVE clear and more than splimp NetBSD has already cleared OACTIVE need to know interrupt level we enter ray_pccard_intr at ray_start(&sc->arpcom.ac_if); #endif /* XXX */ } return; } #if RAY_NEED_STARTJOIN_TIMO /* * Back stop catcher for start_join command. The NetBSD driver * suggests that they need it to catch a bug in the firmware or the * parameters they use - they are not sure. I'll just panic as I seem * to get interrupts back fine and I have version 4 firmware. */ static void ray_start_join_timo (xsc) void *xsc; { struct ray_softc *sc = xsc; RAY_DPRINTF(("ray%d: ray_start_join_timo\n", sc->unit)); RAY_MAP_CM(sc); panic("ray%d: ray-start_join_timo occured\n", sc->unit); return; } #endif /* RAY_NEED_STARTJOIN_TIMO */ /* * Obtain a free ccs buffer. * * Returns 1 and in `ccsp' the bus offset of the free ccs * or 0 if none are free * * If `track' is not zero, handles tracking this command * possibly indicating a callback is needed and setting a timeout * also if ECF isn't ready we terminate earlier to avoid overhead. * * This routine is only used for commands */ static int ray_alloc_ccs (sc, ccsp, cmd, track) struct ray_softc *sc; size_t *ccsp; u_int cmd, track; { size_t ccs; u_int i; RAY_DPRINTF(("ray%d: ray_alloc_ccs for cmd %d\n", sc->unit, cmd)); RAY_MAP_CM(sc); #if XXX /* for tracked commands, if not ready just set pending */ if (track && !RAY_ECF_READY(sc)) { ray_cmd_schedule(sc, track); return (0); } #endif /* XXX */ for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) { /* probe here to make the card go */ (void)SRAM_READ_FIELD_1(sc, RAY_CCS_ADDRESS(i), ray_cmd, c_status); if (!sc->sc_ccsinuse[i]) break; } if (i > RAY_CCS_CMD_LAST) { #if XXX if (track) ray_cmd_schedule(sc, track); #endif /* XXX */ return (0); } sc->sc_ccsinuse[i] = 1; ccs = RAY_CCS_ADDRESS(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); } /* * Free up a ccs/cmd and return the old status. * This routine is only used for commands. */ static u_int8_t ray_free_ccs (sc, ccs) struct ray_softc *sc; size_t ccs; { u_int8_t stat; RAY_DPRINTF(("ray%d: free_ccs 0x%02x\n", sc->unit, RAY_CCS_INDEX(ccs))); RAY_MAP_CM(sc); 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_CCS_ADDRESS(RAY_CCS_LAST)) sc->sc_ccsinuse[RAY_CCS_INDEX(ccs)] = 0; return (stat); } /* * Issue a command by writing the mailbox and tickling the card. * Only used for commands not transmitted packets. */ static int ray_issue_cmd(sc, ccs, track) struct ray_softc *sc; size_t ccs; u_int track; { u_int i; RAY_DPRINTF(("ray%d: ray_cmd_issue, track = 0x%x\n", sc->unit, track)); RAY_MAP_CM(sc); /* * 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 XXX_TRACKING if (track) ray_cmd_schedule(sc, track); #endif /* XXX_TRACKING */ return (0); } SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_CCS_INDEX(ccs)); RAY_ECF_START_CMD(sc); #if XXX_TRACKING ray_cmd_ran(sc, track); #endif /* XXX_TRACKING */ return (1); } #if RAY_DEBUG > 10 static void ray_dump_mbuf(sc, m, s) struct ray_softc *sc; struct mbuf *m; char *s; { u_int8_t *d, *ed; u_int i; char p[17]; printf("ray%d: %s mbuf dump:", sc->unit, s); i = 0; bzero(p, 17); 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(" %s\n\t", p); } else if ((i % 8) == 0) printf(" "); printf(" %02x", *d); p[i % 16] = ((*d >= 0x20) && (*d < 0x80)) ? *d : '.'; } } if ((i - 1) % 16) printf("%s\n", p); } #endif /* RAY_DEBUG > 10 */ /* * Routines to read from/write to the attribute memory. * * Taken from if_xe.c. * * Until there is a real way of accessing the attribute memory from a driver * these have to stay. * * The hack to use the crdread/crdwrite device functions causes the attribute * memory to be remapped into the controller and looses the mapping of * the common memory. * * We cheat by using PIOCSMEM and assume that the common memory window * is in window 0 of the card structure. * * Also * pccard/pcic.c/crdread does mark the unmapped window as inactive * pccard/pccard.c/map_mem toggles the mapping of a window on * successive calls * */ #if RAY_NEED_CM_REMAPPING static void ray_attr_getmap (struct ray_softc *sc) { struct ucred uc; struct pcred pc; struct proc p; RAY_DPRINTF(("ray%d: attempting to get map for common memory\n", sc->unit)); sc->md.window = 0; p.p_cred = &pc; p.p_cred->pc_ucred = &uc; p.p_cred->pc_ucred->cr_uid = 0; RAY_DPRINTF((" ioctl returns 0x%0x\n", cdevsw[CARD_MAJOR]->d_ioctl(makedev(CARD_MAJOR, sc->slotnum), PIOCGMEM, (caddr_t)&sc->md, 0, &p))); RAY_DPRINTF((" flags 0x%02x, start 0x%p, size 0x%08x, card address 0x%lx\n", sc->md.flags, sc->md.start, sc->md.size, sc->md.card)); return; } static void ray_attr_cm (struct ray_softc *sc) { struct ucred uc; struct pcred pc; struct proc p; RAY_DPRINTF(("ray%d: attempting to remap common memory\n", sc->unit)); p.p_cred = &pc; p.p_cred->pc_ucred = &uc; p.p_cred->pc_ucred->cr_uid = 0; cdevsw[CARD_MAJOR]->d_ioctl(makedev(CARD_MAJOR, sc->slotnum), PIOCSMEM, (caddr_t)&sc->md, 0, &p); return; } #endif /* RAY_NEED_CM_REMAPPING */ static int ray_attr_write (struct ray_softc *sc, off_t offset, u_int8_t byte) { struct iovec iov; struct uio uios; int err; iov.iov_base = &byte; iov.iov_len = sizeof(byte); uios.uio_iov = &iov; uios.uio_iovcnt = 1; uios.uio_offset = offset; uios.uio_resid = sizeof(byte); uios.uio_segflg = UIO_SYSSPACE; uios.uio_rw = UIO_WRITE; uios.uio_procp = 0; err = cdevsw[CARD_MAJOR]->d_write(makedev(CARD_MAJOR, sc->slotnum), &uios, 0); #if RAY_NEED_CM_REMAPPING ray_attr_cm(sc); #endif /* RAY_NEED_CM_REMAPPING */ return(err); } static int ray_attr_read (struct ray_softc *sc, off_t offset, u_int8_t *buf, int size) { struct iovec iov; struct uio uios; int err; iov.iov_base = buf; iov.iov_len = size; uios.uio_iov = &iov; uios.uio_iovcnt = 1; uios.uio_offset = offset; uios.uio_resid = size; uios.uio_segflg = UIO_SYSSPACE; uios.uio_rw = UIO_READ; uios.uio_procp = 0; err = cdevsw[CARD_MAJOR]->d_read(makedev(CARD_MAJOR, sc->slotnum), &uios, 0); #if RAY_NEED_CM_REMAPPING ray_attr_cm(sc); #endif /* RAY_NEED_CM_REMAPPING */ return(err); } static u_int8_t ray_read_reg (sc, reg) struct ray_softc *sc; off_t reg; { u_int8_t byte; ray_attr_read(sc, reg, &byte, 1); return(byte); } #if XXX /* * Could be replaced by the following macro * RAY_ECF_READY(sc) (!(REG_READ(sc, RAY_ECFIR) & RAY_ECFIR_IRQ)) * where reg_read is a suitable macro to read a byte in the attribute memory. */ static int ray_ecf_ready(struct ray_softc *sc) { u_int8_t byte; ray_attr_read(sc, RAY_ECFIR, &byte, 1); return (!(byte & RAY_ECFIR_IRQ)); } /* * Could be replaced by the following macro * RAY_HCS_INTR(sc) (REG_READ(sc, RAY_HCSIR) & RAY_HCSIR_IRQ) * where reg_read is a suitable macro to read a byte in the attribute memory. */ static int ray_hcs_intr(struct ray_softc *sc) { u_int8_t byte; ray_attr_read(sc, RAY_HCSIR, &byte, 1); return (byte & RAY_HCSIR_IRQ); } #endif #endif /* NRAY */