diff options
Diffstat (limited to 'sys/dev/pcmcia/if_cnw.c')
| -rw-r--r-- | sys/dev/pcmcia/if_cnw.c | 889 |
1 files changed, 889 insertions, 0 deletions
diff --git a/sys/dev/pcmcia/if_cnw.c b/sys/dev/pcmcia/if_cnw.c new file mode 100644 index 00000000000..49907c257c1 --- /dev/null +++ b/sys/dev/pcmcia/if_cnw.c @@ -0,0 +1,889 @@ +/* $OpenBSD: if_cnw.c,v 1.1 1999/08/13 20:34:17 fgsch Exp $ */ +/*- + * Copyright (c) 1998 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Michael Eriksson. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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. + */ + +/* + * This is a driver for the Xircom CreditCard Netwave (also known as + * the Netwave Airsurfer) wireless LAN PCMCIA adapter. + * + * When this driver was developed, the Linux Netwave driver was used + * as a hardware manual. That driver is Copyright (c) 1997 University + * of Tromsų, Norway. It is part of the Linix pcmcia-cs package that + * can be found at + * http://hyper.stanford.edu/HyperNews/get/pcmcia/home.html. The most + * recent version of the pcmcia-cs package when this driver was + * written was 3.0.6. + * + * Unfortunately, a lot of explicit numeric constants were used in the + * Linux driver. I have tried to use symbolic names whenever possible, + * but since I don't have any real hardware documentation, there's + * still one or two "magic numbers" :-(. + * + * Driver limitations: This driver doesn't do multicasting or receiver + * promiscuity, because of missing hardware documentation. I couldn't + * get receiver promiscuity to work, and I haven't even tried + * multicast. Volunteers are welcome, of course :-). + */ + +#include "bpfilter.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/device.h> +#include <sys/socket.h> +#include <sys/mbuf.h> +#include <sys/ioctl.h> + +#include <dev/pcmcia/if_cnwreg.h> + +#include <dev/pcmcia/pcmciareg.h> +#include <dev/pcmcia/pcmciavar.h> +#include <dev/pcmcia/pcmciadevs.h> + +#include <net/if.h> +#include <net/if_dl.h> + +#ifdef INET +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/in_var.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#endif + +#if NBPFILTER > 0 +#include <net/bpf.h> +#include <net/bpfdesc.h> +#endif + + +/* + * Let these be patchable variables, initialized from macros that can + * be set in the kernel config file. Someone with lots of spare time + * could probably write a nice Netwave configuration program to do + * this a little bit more elegantly :-). + */ +#ifndef CNW_DOMAIN +#define CNW_DOMAIN 0x100 +#endif +int cnw_domain = CNW_DOMAIN; /* Domain */ +#ifndef CNW_SCRAMBLEKEY +#define CNW_SCRAMBLEKEY 0 +#endif +int cnw_skey = CNW_SCRAMBLEKEY; /* Scramble key */ + + +int cnw_match __P((struct device *, void *, void *)); +void cnw_attach __P((struct device *, struct device *, void *)); +int cnw_detach __P((struct device *, int)); +int cnw_activate __P((struct device *, enum devact)); + +struct cnw_softc { + struct device sc_dev; /* Device glue (must be first) */ + struct arpcom sc_arpcom; /* Ethernet common part */ + int sc_domain; /* Netwave domain */ + int sc_skey; /* Netwave scramble key */ + + /* PCMCIA-specific stuff */ + struct pcmcia_function *sc_pf; /* PCMCIA function */ + struct pcmcia_io_handle sc_pcioh; /* PCMCIA I/O space handle */ + int sc_iowin; /* ...window */ + bus_space_tag_t sc_iot; /* ...bus_space tag */ + bus_space_handle_t sc_ioh; /* ...bus_space handle */ + struct pcmcia_mem_handle sc_pcmemh; /* PCMCIA memory handle */ + bus_addr_t sc_memoff; /* ...offset */ + int sc_memwin; /* ...window */ + bus_space_tag_t sc_memt; /* ...bus_space tag */ + bus_space_handle_t sc_memh; /* ...bus_space handle */ + void *sc_ih; /* Interrupt cookie */ +}; + +struct cfattach cnw_ca = { + sizeof(struct cnw_softc), cnw_match, cnw_attach, + cnw_detach, cnw_activate +}; + +struct cfdriver cnw_cd = { + NULL, "cnw", DV_IFNET +}; + +void cnw_reset __P((struct cnw_softc *)); +void cnw_init __P((struct cnw_softc *)); +int cnw_enable __P((struct cnw_softc *sc)); +void cnw_disable __P((struct cnw_softc *sc)); +void cnw_config __P((struct cnw_softc *sc, u_int8_t *)); +void cnw_start __P((struct ifnet *)); +void cnw_transmit __P((struct cnw_softc *, struct mbuf *)); +struct mbuf *cnw_read __P((struct cnw_softc *)); +void cnw_recv __P((struct cnw_softc *)); +int cnw_intr __P((void *arg)); +int cnw_ioctl __P((struct ifnet *, u_long, caddr_t)); +void cnw_watchdog __P((struct ifnet *)); + +/* ---------------------------------------------------------------- */ + +/* Help routines */ +static int wait_WOC __P((struct cnw_softc *, int)); +static int read16 __P((struct cnw_softc *, int)); +static int cnw_cmd __P((struct cnw_softc *, int, int, int, int)); + +/* + * Wait until the WOC (Write Operation Complete) bit in the + * ASR (Adapter Status Register) is asserted. + */ +static int +wait_WOC(sc, line) + struct cnw_softc *sc; + int line; +{ + int i, asr; + + for (i = 0; i < 5000; i++) { + asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); + if (asr & CNW_ASR_WOC) + return (0); + DELAY(100); + } + if (line > 0) + printf("%s: wedged at line %d\n", sc->sc_dev.dv_xname, line); + return (1); +} +#define WAIT_WOC(sc) wait_WOC(sc, __LINE__) + + +/* + * Read a 16 bit value from the card. + */ +static int +read16(sc, offset) + struct cnw_softc *sc; + int offset; +{ + int hi, lo; + + /* This could presumably be done more efficient with + * bus_space_read_2(), but I don't know anything about the + * byte sex guarantees... Besides, this is pretty cheap as + * well :-) + */ + lo = bus_space_read_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + offset); + hi = bus_space_read_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + offset + 1); + return ((hi << 8) | lo); +} + + +/* + * Send a command to the card by writing it to the command buffer. + */ +int +cnw_cmd(sc, cmd, count, arg1, arg2) + struct cnw_softc *sc; + int cmd, count, arg1, arg2; +{ + int ptr = sc->sc_memoff + CNW_EREG_CB; + + if (wait_WOC(sc, 0)) { + printf("%s: wedged when issuing cmd 0x%x\n", + sc->sc_dev.dv_xname, cmd); + /* + * We'll continue anyway, as that's probably the best + * thing we can do; at least the user knows there's a + * problem, and can reset the interface with ifconfig + * down/up. + */ + } + + bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr, cmd); + if (count > 0) { + bus_space_write_1(sc->sc_memt, sc->sc_memh, ptr + 1, arg1); + if (count > 1) + bus_space_write_1(sc->sc_memt, sc->sc_memh, + ptr + 2, arg2); + } + bus_space_write_1(sc->sc_memt, sc->sc_memh, + ptr + count + 1, CNW_CMD_EOC); + return (0); +} +#define CNW_CMD0(sc, cmd) \ + do { cnw_cmd(sc, cmd, 0, 0, 0); } while (0) +#define CNW_CMD1(sc, cmd, arg1) \ + do { cnw_cmd(sc, cmd, 1, arg1 , 0); } while (0) +#define CNW_CMD2(sc, cmd, arg1, arg2) \ + do { cnw_cmd(sc, cmd, 2, arg1, arg2); } while (0) + +/* ---------------------------------------------------------------- */ + +/* + * Reset the hardware. + */ +void +cnw_reset(sc) + struct cnw_softc *sc; +{ +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: resetting\n", sc->sc_dev.dv_xname); +#endif + wait_WOC(sc, 0); + bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, CNW_PMR_RESET); + bus_space_write_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_WOC); + bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_PMR, 0); +} + + +/* + * Initialize the card. + */ +void +cnw_init(sc) + struct cnw_softc *sc; +{ + /* Reset the card */ + cnw_reset(sc); + + /* Issue a NOP to check the card */ + CNW_CMD0(sc, CNW_CMD_NOP); + + /* Set up receive configuration */ + CNW_CMD1(sc, CNW_CMD_SRC, CNW_RXCONF_RXENA | CNW_RXCONF_BCAST); + + /* Set up transmit configuration */ + CNW_CMD1(sc, CNW_CMD_STC, CNW_TXCONF_TXENA); + + /* Set domain */ + CNW_CMD2(sc, CNW_CMD_SMD, sc->sc_domain, sc->sc_domain >> 8); + + /* Set scramble key */ + CNW_CMD2(sc, CNW_CMD_SSK, sc->sc_skey, sc->sc_skey >> 8); + + /* Enable interrupts */ + WAIT_WOC(sc); + bus_space_write_1(sc->sc_iot, sc->sc_ioh, + CNW_REG_IMR, CNW_IMR_IENA | CNW_IMR_RFU1); + + /* Enable receiver */ + CNW_CMD0(sc, CNW_CMD_ER); + + /* "Set the IENA bit in COR" */ + WAIT_WOC(sc); + bus_space_write_1(sc->sc_iot, sc->sc_ioh, CNW_REG_COR, + CNW_COR_IENA | CNW_COR_LVLREQ); +} + + +/* + * Enable and initialize the card. + */ +int +cnw_enable(sc) + struct cnw_softc *sc; +{ + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + + sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET, cnw_intr, sc); + if (sc->sc_ih == NULL) { + printf("%s: couldn't establish interrupt handler\n", + sc->sc_dev.dv_xname); + return (EIO); + } + if (pcmcia_function_enable(sc->sc_pf) != 0) { + printf("%s: couldn't enable card\n", sc->sc_dev.dv_xname); + return (EIO); + } + cnw_init(sc); + ifp->if_flags |= IFF_RUNNING; + return (0); +} + + +/* + * Stop and disable the card. + */ +void +cnw_disable(sc) + struct cnw_softc *sc; +{ + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + + pcmcia_function_disable(sc->sc_pf); + pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); + ifp->if_flags &= ~IFF_RUNNING; + ifp->if_timer = 0; +} + + +/* + * Match the hardware we handle. + */ +int +cnw_match(parent, match, aux) + struct device *parent; + void *match, *aux; +{ + struct pcmcia_attach_args *pa = aux; + + return (pa->manufacturer == PCMCIA_VENDOR_XIRCOM && + pa->product == PCMCIA_PRODUCT_XIRCOM_XIR_CNW); +} + + +/* + * Attach the card. + */ +void +cnw_attach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct cnw_softc *sc = (void *) self; + struct pcmcia_attach_args *pa = aux; + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + int i; + + /* Enable the card */ + sc->sc_pf = pa->pf; + pcmcia_function_init(sc->sc_pf, sc->sc_pf->cfe_head.sqh_first); + if (pcmcia_function_enable(sc->sc_pf)) { + printf(": function enable failed\n"); + return; + } + + /* Map I/O register and "memory" */ + if (pcmcia_io_alloc(sc->sc_pf, 0, CNW_IO_SIZE, CNW_IO_SIZE, + &sc->sc_pcioh) != 0) { + printf(": can't allocate i/o space\n"); + return; + } + if (pcmcia_io_map(sc->sc_pf, PCMCIA_WIDTH_IO16, 0, + CNW_IO_SIZE, &sc->sc_pcioh, &sc->sc_iowin) != 0) { + printf(": can't map i/o space\n"); + return; + } + sc->sc_iot = sc->sc_pcioh.iot; + sc->sc_ioh = sc->sc_pcioh.ioh; + if (pcmcia_mem_alloc(sc->sc_pf, CNW_MEM_SIZE, &sc->sc_pcmemh) != 0) { + printf(": can't allocate memory\n"); + return; + } + if (pcmcia_mem_map(sc->sc_pf, PCMCIA_MEM_COMMON, CNW_MEM_ADDR, + CNW_MEM_SIZE, &sc->sc_pcmemh, &sc->sc_memoff, + &sc->sc_memwin) != 0) { + printf(": can't map memory\n"); + return; + } + sc->sc_memt = sc->sc_pcmemh.memt; + sc->sc_memh = sc->sc_pcmemh.memh; + printf(": %s\n", PCMCIA_STR_XIRCOM_XIR_CNW); + + /* Finish setup of softc */ + sc->sc_domain = cnw_domain; + sc->sc_skey = cnw_skey; + + /* Get MAC address */ + cnw_reset(sc); + for (i = 0; i < ETHER_ADDR_LEN; i++) + sc->sc_arpcom.ac_enaddr[i] = bus_space_read_1(sc->sc_memt, + sc->sc_memh, sc->sc_memoff + CNW_EREG_PA + i); + printf("%s: address %s\n", sc->sc_dev.dv_xname, + ether_sprintf(sc->sc_arpcom.ac_enaddr)); + + /* Set up ifnet structure */ + bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ); + ifp->if_softc = sc; + ifp->if_start = cnw_start; + ifp->if_ioctl = cnw_ioctl; + ifp->if_watchdog = cnw_watchdog; + ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS; + + /* Attach the interface */ + if_attach(ifp); + ether_ifattach(ifp); +#if NBPFILTER > 0 + bpfattach(&sc->sc_arpcom.ac_if.if_bpf, ifp, DLT_EN10MB, + sizeof(struct ether_header)); +#endif + + /* Disable the card now, and turn it on when the interface goes up */ + pcmcia_function_disable(sc->sc_pf); +} + +/* + * Start outputting on the interface. + */ +void +cnw_start(ifp) + struct ifnet *ifp; +{ + struct cnw_softc *sc = ifp->if_softc; + struct mbuf *m0; + int asr; + +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: cnw_start\n", ifp->if_xname); +#endif + + for (;;) { + /* Is there any buffer space available on the card? */ + WAIT_WOC(sc); + asr = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); + if (!(asr & CNW_ASR_TXBA)) { +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: no buffer space\n", ifp->if_xname); +#endif + return; + } + + IF_DEQUEUE(&ifp->if_snd, m0); + if (m0 == 0) + return; + +#if NBPFILTER > 0 + if (ifp->if_bpf) + bpf_mtap(ifp->if_bpf, m0); +#endif + + cnw_transmit(sc, m0); + ++ifp->if_opackets; + ifp->if_timer = 3; /* start watchdog timer */ + } +} + + +/* + * Transmit a packet. + */ +void +cnw_transmit(sc, m0) + struct cnw_softc *sc; + struct mbuf *m0; +{ + int buffer, bufsize, bufoffset, bufptr, bufspace, len, mbytes, n; + struct mbuf *m; + u_int8_t *mptr; + + /* Get buffer info from card */ + buffer = read16(sc, CNW_EREG_TDP); + bufsize = read16(sc, CNW_EREG_TDP + 2); + bufoffset = read16(sc, CNW_EREG_TDP + 4); +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: cnw_transmit b=0x%x s=%d o=0x%x\n", + sc->sc_dev.dv_xname, buffer, bufsize, bufoffset); +#endif + + /* Copy data from mbuf chain to card buffers */ + bufptr = sc->sc_memoff + buffer + bufoffset; + bufspace = bufsize; + len = 0; + for (m = m0; m; ) { + mptr = mtod(m, u_int8_t *); + mbytes = m->m_len; + len += mbytes; + while (mbytes > 0) { + if (bufspace == 0) { + buffer = read16(sc, buffer); + bufptr = sc->sc_memoff + buffer + bufoffset; + bufspace = bufsize; +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: next buffer @0x%x\n", + sc->sc_dev.dv_xname, buffer); +#endif + } + n = mbytes <= bufspace ? mbytes : bufspace; + bus_space_write_region_1(sc->sc_memt, sc->sc_memh, + bufptr, mptr, n); + bufptr += n; + bufspace -= n; + mptr += n; + mbytes -= n; + } + MFREE(m, m0); + m = m0; + } + + /* Issue transmit command */ + CNW_CMD2(sc, CNW_CMD_TL, len, len >> 8); +} + + +/* + * Pull a packet from the card into an mbuf chain. + */ +struct mbuf * +cnw_read(sc) + struct cnw_softc *sc; +{ + struct mbuf *m, *top, **mp; + int totbytes, buffer, bufbytes, bufptr, mbytes, n; + u_int8_t *mptr; + + WAIT_WOC(sc); + totbytes = read16(sc, CNW_EREG_RDP); +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: recv %d bytes\n", sc->sc_dev.dv_xname, totbytes); +#endif + buffer = CNW_EREG_RDP + 2; + bufbytes = 0; + bufptr = 0; /* XXX make gcc happy */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == 0) + return (0); + m->m_pkthdr.rcvif = &sc->sc_arpcom.ac_if; + m->m_pkthdr.len = totbytes; + mbytes = MHLEN; + top = 0; + mp = ⊤ + + while (totbytes > 0) { + if (top) { + MGET(m, M_DONTWAIT, MT_DATA); + if (m == 0) { + m_freem(top); + return (0); + } + mbytes = MLEN; + } + if (totbytes >= MINCLSIZE) { + MCLGET(m, M_DONTWAIT); + if ((m->m_flags & M_EXT) == 0) { + m_free(m); + m_freem(top); + return (0); + } + mbytes = MCLBYTES; + } + if (!top) { + int pad = + ALIGN(sizeof(struct ether_header)) - + sizeof(struct ether_header); + m->m_data += pad; + mbytes -= pad; + } + mptr = mtod(m, u_int8_t *); + mbytes = m->m_len = min(totbytes, mbytes); + totbytes -= mbytes; + while (mbytes > 0) { + if (bufbytes == 0) { + buffer = read16(sc, buffer); + bufbytes = read16(sc, buffer + 2); + bufptr = sc->sc_memoff + buffer + + read16(sc, buffer + 4); +#ifdef CNW_DEBUG + if (sc->sc_arpcom.ac_if.if_flags & IFF_DEBUG) + printf("%s: %d bytes @0x%x+0x%x\n", + sc->sc_dev.dv_xname, bufbytes, + buffer, bufptr - buffer - + sc->sc_memoff); +#endif + } + n = mbytes <= bufbytes ? mbytes : bufbytes; + bus_space_read_region_1(sc->sc_memt, sc->sc_memh, + bufptr, mptr, n); + bufbytes -= n; + bufptr += n; + mbytes -= n; + mptr += n; + } + *mp = m; + mp = &m->m_next; + } + + return (top); +} + + +/* + * Handle received packets. + */ +void +cnw_recv(sc) + struct cnw_softc *sc; +{ + int rser; + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + struct mbuf *m; + struct ether_header *eh; + + for (;;) { + WAIT_WOC(sc); + rser = bus_space_read_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_RSER); + if (!(rser & CNW_RSER_RXAVAIL)) + return; + + /* Pull packet off card */ + m = cnw_read(sc); + + /* Acknowledge packet */ + CNW_CMD0(sc, CNW_CMD_SRP); + + /* Did we manage to get the packet from the interface? */ + if (m == 0) { + ++ifp->if_ierrors; + return; + } + ++ifp->if_ipackets; + +#if NBPFILTER > 0 + if (ifp->if_bpf) + bpf_mtap(ifp->if_bpf, m); +#endif + + /* + * Check that the packet is for us or {multi,broad}cast. Maybe + * there's a fool-poof hardware check for this, but I don't + * really know... + */ + eh = mtod(m, struct ether_header *); + if ((eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */ + bcmp(sc->sc_arpcom.ac_enaddr, eh->ether_dhost, + sizeof(eh->ether_dhost)) != 0) { + m_freem(m); + continue; + } + + /* Pass the packet up, with the ether header sort-of removed */ + m_adj(m, sizeof(struct ether_header)); + ether_input(ifp, eh, m); + } +} + + +/* + * Interrupt handler. + */ +int +cnw_intr(arg) + void *arg; +{ + struct cnw_softc *sc = arg; + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + int ret, status, rser, tser; + + if (!(sc->sc_arpcom.ac_if.if_flags & IFF_RUNNING)) + return (0); + ifp->if_timer = 0; /* stop watchdog timer */ + + ret = 0; + for (;;) { + WAIT_WOC(sc); + if (!(bus_space_read_1(sc->sc_iot, sc->sc_ioh, + CNW_REG_CCSR) & 0x02)) { + if (ret == 0) + printf("%s: spurious interrupt\n", + sc->sc_dev.dv_xname); + return (ret); + } + ret = 1; + status = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CNW_REG_ASR); + + /* Anything to receive? */ + if (status & CNW_ASR_RXRDY) + cnw_recv(sc); + + /* Receive error */ + if (status & CNW_ASR_RXERR) { + /* + * I get a *lot* of spurious receive errors + * (many per second), even when the interface + * is quiescent, so we don't increment + * if_ierrors here. + */ + rser = bus_space_read_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_RSER); + /* Clear error bits in RSER */ + WAIT_WOC(sc); + bus_space_write_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_RSERW, + CNW_RSER_RXERR | + (rser & (CNW_RSER_RXCRC | CNW_RSER_RXBIG))); + /* Clear RXERR in ASR */ + WAIT_WOC(sc); + bus_space_write_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_ASCC, CNW_ASR_RXERR); + } + + /* Transmit done */ + if (status & CNW_ASR_TXDN) { + tser = bus_space_read_1(sc->sc_memt, sc->sc_memh, + CNW_EREG_TSER); + if (tser & CNW_TSER_TXOK) { + WAIT_WOC(sc); + bus_space_write_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_TSERW, + CNW_TSER_TXOK | CNW_TSER_RTRY); + } + if (tser & CNW_TSER_ERROR) { + ++ifp->if_oerrors; + WAIT_WOC(sc); + bus_space_write_1(sc->sc_memt, sc->sc_memh, + sc->sc_memoff + CNW_EREG_TSERW, + (tser & CNW_TSER_ERROR) | + CNW_TSER_RTRY); + } + /* Continue to send packets from the queue */ + cnw_start(&sc->sc_arpcom.ac_if); + } + + } +} + + +/* + * Handle device ioctls. + */ +int +cnw_ioctl(ifp, cmd, data) + register struct ifnet *ifp; + u_long cmd; + caddr_t data; +{ + struct cnw_softc *sc = ifp->if_softc; + struct ifaddr *ifa = (struct ifaddr *)data; + int s, error = 0; + + s = splnet(); + + switch (cmd) { + + case SIOCSIFADDR: + if (!(ifp->if_flags & IFF_RUNNING) && + (error = cnw_enable(sc)) != 0) + break; + ifp->if_flags |= IFF_UP; + switch (ifa->ifa_addr->sa_family) { +#ifdef INET + case AF_INET: + arp_ifinit(&sc->sc_arpcom, ifa); + break; +#endif + } + break; + + case SIOCSIFFLAGS: + if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_RUNNING) { + /* + * The interface is marked down and it is running, so + * stop it. + */ + cnw_disable(sc); + } else if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_UP){ + /* + * The interface is marked up and it is stopped, so + * start it. + */ + error = cnw_enable(sc); + } + break; + + default: + error = EINVAL; + break; + } + + splx(s); + return (error); +} + + +/* + * Device timeout/watchdog routine. Entered if the device neglects to + * generate an interrupt after a transmit has been started on it. + */ +void +cnw_watchdog(ifp) + struct ifnet *ifp; +{ + struct cnw_softc *sc = ifp->if_softc; + + printf("%s: device timeout; card reset\n", sc->sc_dev.dv_xname); + ++ifp->if_oerrors; + cnw_init(sc); +} + + +int +cnw_detach(dev, flags) + struct device *dev; + int flags; +{ + struct cnw_softc *sc = (struct cnw_softc *)dev; + struct ifnet *ifp = &sc->sc_arpcom.ac_if; + int rv = 0; + + pcmcia_io_unmap(sc->sc_pf, sc->sc_iowin); + pcmcia_io_free(sc->sc_pf, &sc->sc_pcioh); + pcmcia_mem_unmap(sc->sc_pf, sc->sc_memwin); + pcmcia_mem_free(sc->sc_pf, &sc->sc_pcmemh); + + ether_ifdetach(ifp); + if_detach(ifp); + + return (rv); +} + +int +cnw_activate(dev, act) + struct device *dev; + enum devact act; +{ + struct cnw_softc *sc = (struct cnw_softc *)dev; + int s; + + s = splnet(); + switch (act) { + case DVACT_ACTIVATE: + pcmcia_function_enable(sc->sc_pf); + sc->sc_ih = + pcmcia_intr_establish(sc->sc_pf, IPL_NET, cnw_intr, sc); + break; + + case DVACT_DEACTIVATE: + pcmcia_function_disable(sc->sc_pf); + pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih); + break; + } + splx(s); + return (0); +} |