sys/dev/netif/wl/if_wl.c

   1 /* $FreeBSD: src/sys/i386/isa/if_wl.c,v 1.27.2.2 2000/07/17 21:24:32 archie Exp $ */
   2 /* $DragonFly: src/sys/dev/netif/wl/if_wl.c,v 1.27 2005/12/31 14:08:00 sephe Exp $ */
   3 /*
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain all copyright
   8  *    notices, this list of conditions and the following disclaimer.
   9  * 2. The names of the authors may not be used to endorse or promote products
  10  *    derived from this software withough specific prior written permission
  11  *
  12  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  13  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  14  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  15  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  16  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  17  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  18  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  19  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  20  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  21  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22  *
  23  */
  24 /*
  25  * if_wl.c - original MACH, then BSDI ISA wavelan driver
  26  *      ported to mach by Anders Klemets
  27  *      to BSDI by Robert Morris
  28  *      to FreeBSD by Jim Binkley
  29  *      to FreeBSD 2.2+ by Michael Smith
  30  *
  31  * 2.2 update:
  32  * Changed interface to match 2.1-2.2 differences.
  33  * Implement IRQ selection logic in wlprobe()
  34  * Implement PSA updating.
  35  * Pruned heading comments for relevance.
  36  * Ripped out all the 'interface counters' cruft.
  37  * Cut the missing-interrupt timer back to 100ms.
  38  * 2.2.1 update:
  39  * now supports all multicast mode (mrouted will work),
  40  *      but unfortunately must do that by going into promiscuous mode
  41  * NWID sysctl added so that normally promiscuous mode is NWID-specific
  42  *      but can be made NWID-inspecific
  43  *                      7/14/97 jrb
  44  *
  45  * Work done:
  46  * Ported to FreeBSD, got promiscuous mode working with bpfs,
  47  * and rewired timer routine.  The i82586 will hang occasionally on output
  48  * and the watchdog timer will kick it if so and log an entry.
  49  * 2 second timeout there.  Apparently the chip loses an interrupt.
  50  * Code borrowed from if_ie.c for watchdog timer.
  51  *
  52  * The wavelan card is a 2mbit radio modem that emulates ethernet;
  53  * i.e., it uses MAC addresses.  This should not be a surprise since
  54  * it uses an ethernet controller as a major hw item.
  55  * It can broadcast, unicast or apparently multicast in a base cell
  56  * using a omni-directional antennae that is
  57  * about 800 feet around the base cell barring walls and metal.
  58  * With directional antennae, it can be used point to point over a mile
  59  * or so apparently (haven't tried that).
  60  *
  61  * There are ISA and pcmcia versions (not supported by this code).
  62  * The ISA card has an Intel 82586 lan controller on it.  It consists
  63  * of 2 pieces of hw, the lan controller (intel) and a radio-modem.
  64  * The latter has an extra set of controller registers that has nothing
  65  * to do with the i82586 and allows setting and monitoring of radio
  66  * signal strength, etc.  There is a nvram area called the PSA that
  67  * contains a number of setup variables including the IRQ and so-called
  68  * NWID or Network ID.  The NWID must be set the same for all radio
  69  * cards to communicate (unless you are using the ATT/NCR roaming feature
  70  * with their access points.  There is no support for that here. Roaming
  71  * involves a link-layer beacon sent out from the access points.  End
  72  * stations monitor the signal strength and only use the strongest
  73  * access point).  This driver assumes that the base ISA port, IRQ,
  74  * and NWID are first set in nvram via the dos-side "instconf.exe" utility
  75  * supplied with the card. This driver takes the ISA port from
  76  * the kernel configuration setup, and then determines the IRQ either
  77  * from the kernel config (if an explicit IRQ is set) or from the
  78  * PSA on the card if not.
  79  * The hw also magically just uses the IRQ set in the nvram.
  80  * The NWID is used magically as well by the radio-modem
  81  * to determine which packets to keep or throw out.
  82  *
  83  * sample config:
  84  *
  85  * device wl0 at isa? port 0x300 net irq ?
  86  *
  87  * Ifdefs:
  88  * 1. WLDEBUG. (off) - if turned on enables IFF_DEBUG set via ifconfig debug
  89  * 2. MULTICAST (on) - turned on and works up to and including mrouted
  90  * 3. WLCACHE (off) -  define to turn on a signal strength
  91  * (and other metric) cache that is indexed by sender MAC address.
  92  * Apps can read this out to learn the remote signal strength of a
  93  * sender.  Note that it has a switch so that it only stores
  94  * broadcast/multicast senders but it could be set to store unicast
  95  * too only.  Size is hardwired in if_wl_wavelan.h
  96  *
  97  * one further note: promiscuous mode is a curious thing.  In this driver,
  98  * promiscuous mode apparently CAN catch ALL packets and ignore the NWID
  99  * setting.  This is probably more useful in a sense (for snoopers) if
 100  * you are interested in all traffic as opposed to if you are interested
 101  * in just your own.  There is a driver specific sysctl to turn promiscuous
 102  * from just promiscuous to wildly promiscuous...
 103  *
 104  * This driver also knows how to load the synthesizers in the 2.4 Gz
 105  * ISA Half-card, Product number 847647476 (USA/FCC IEEE Channel set).
 106  * This product consists of a "mothercard" that contains the 82586,
 107  * NVRAM that holds the PSA, and the ISA-buss interface custom ASIC.
 108  * The radio transceiver is a "daughtercard" called the WaveMODEM which
 109  * connects to the mothercard through two single-inline connectors: a
 110  * 20-pin connector provides DC-power and modem signals, and a 3-pin
 111  * connector which exports the antenna connection. The code herein
 112  * loads the receive and transmit synthesizers and the corresponding
 113  * transmitter output power value from an EEPROM controlled through
 114  * additional registers via the MMC. The EEPROM address selected
 115  * are those whose values are preset by the DOS utility programs
 116  * provided with the product, and this provides compatible operation
 117  * with the DOS Packet Driver software. A future modification will
 118  * add the necessary functionality to this driver and to the wlconfig
 119  * utility to completely replace the DOS Configuration Utilities.
 120  * The 2.4 Gz WaveMODEM is described in document number 407-024692/E,
 121  * and is available through Lucent Technologies OEM supply channels.
 122  * --RAB 1997/06/08.
 123  */
 124
 125 #define MULTICAST  1
 126
 127 /*
 128  *      Olivetti PC586 Mach Ethernet driver v1.0
 129  *      Copyright Ing. C. Olivetti & C. S.p.A. 1988, 1989
 130  *      All rights reserved.
 131  *
 132  */
 133
 134 /*
 135   Copyright 1988, 1989 by Olivetti Advanced Technology Center, Inc.,
 136 Cupertino, California.
 137
 138                 All Rights Reserved
 139
 140   Permission to use, copy, modify, and distribute this software and
 141 its documentation for any purpose and without fee is hereby
 142 granted, provided that the above copyright notice appears in all
 143 copies and that both the copyright notice and this permission notice
 144 appear in supporting documentation, and that the name of Olivetti
 145 not be used in advertising or publicity pertaining to distribution
 146 of the software without specific, written prior permission.
 147
 148   OLIVETTI DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 149 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
 150 IN NO EVENT SHALL OLIVETTI BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 151 CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 152 LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 153 NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUR OF OR IN CONNECTION
 154 WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 155 */
 156
 157 /*
 158   Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.
 159
 160                 All Rights Reserved
 161
 162 Permission to use, copy, modify, and distribute this software and
 163 its documentation for any purpose and without fee is hereby
 164 granted, provided that the above copyright notice appears in all
 165 copies and that both the copyright notice and this permission notice
 166 appear in supporting documentation, and that the name of Intel
 167 not be used in advertising or publicity pertaining to distribution
 168 of the software without specific, written prior permission.
 169
 170 INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 171 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
 172 IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 173 CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 174 LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 175 NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 176 WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 177 */
 178
 179 /*
 180  * NOTE:
 181  *              by rvb:
 182  *  1.  The best book on the 82586 is:
 183  *              LAN Components User's Manual by Intel
 184  *      The copy I found was dated 1984.  This really tells you
 185  *      what the state machines are doing
 186  *  2.  In the current design, we only do one write at a time,
 187  *      though the hardware is capable of chaining and possibly
 188  *      even batching.  The problem is that we only make one
 189  *      transmit buffer available in sram space.
 190  */
 191
 192 #include "opt_wavelan.h"
 193 #include "opt_inet.h"
 194
 195 #include <sys/param.h>
 196 #include <sys/systm.h>
 197 #include <sys/sockio.h>
 198 #include <sys/mbuf.h>
 199 #include <sys/socket.h>
 200 #include <sys/syslog.h>
 201 #include <sys/proc.h>
 202 #include <sys/serialize.h>
 203 #include <sys/thread2.h>
 204
 205 #include <sys/kernel.h>
 206 #include <sys/sysctl.h>
 207
 208 #include <machine/bus.h>
 209 #include <machine/resource.h>
 210 #include <sys/bus.h>
 211 #include <sys/rman.h>
 212
 213 #include <net/ethernet.h>
 214 #include <net/if.h>
 215 #include <net/if_arp.h>
 216 #include <net/ifq_var.h>
 217 #include <net/if_dl.h>
 218
 219 #ifdef INET
 220 #include <netinet/in.h>
 221 #include <netinet/in_systm.h>
 222 #include <netinet/ip.h>
 223 #include <netinet/if_ether.h>
 224 #endif
 225
 226 #include <net/bpf.h>
 227
 228 #include <bus/isa/isavar.h>
 229 #include <bus/isa/i386/isa_device.h>
 230 #include "if_wl_i82586.h"       /* Definitions for the Intel chip */
 231
 232 /* was 1000 in original, fed to DELAY(x) */
 233 #define DELAYCONST      1000
 234 #include "if_wl.h"
 235 #include <machine/if_wl_wavelan.h>
 236
 237 static char     t_packet[ETHERMTU + sizeof(struct ether_header) + sizeof(long)];
 238
 239 struct wl_softc{
 240     struct      arpcom  wl_ac;                  /* Ethernet common part */
 241 #define wl_if   wl_ac.ac_if                     /* network visible interface */
 242 #define wl_addr wl_ac.ac_enaddr                 /* hardware address */
 243     u_char      psa[0x40];
 244     u_char      nwid[2];        /* current radio modem nwid */
 245     short       base;
 246     int         flags;
 247     int         tbusy;          /* flag to determine if xmit is busy */
 248     u_short     begin_fd;
 249     u_short     end_fd;
 250     u_short     end_rbd;
 251     u_short     hacr;           /* latest host adapter CR command */
 252     short       mode;
 253     u_char      chan24;         /* 2.4 Gz: channel number/EEPROM Area # */
 254     u_short     freq24;         /* 2.4 Gz: resulting frequency  */
 255     int         rid_ioport;
 256     int         rid_irq;
 257     struct      resource *res_ioport;
 258     struct      resource *res_irq;
 259     void        *intr_handle;
 260     struct      callout watchdog_ch;
 261 #ifdef WLCACHE
 262     int         w_sigitems;     /* number of cached entries */
 263     /*  array of cache entries */
 264     struct w_sigcache w_sigcache[ MAXCACHEITEMS ];
 265     int w_nextcache;            /* next free cache entry */
 266     int w_wrapindex;            /* next "free" cache entry */
 267 #endif
 268 };
 269
 270 /*
 271  * XXX  The Wavelan appears to be prone to dropping stuff if you talk to
 272  * it too fast.  This disgusting hack inserts a delay after each packet
 273  * is queued which helps avoid this behaviour on fast systems.
 274  */
 275 static int      wl_xmit_delay = 250;
 276 SYSCTL_INT(_machdep, OID_AUTO, wl_xmit_delay, CTLFLAG_RW, &wl_xmit_delay, 0, "");
 277
 278 /*
 279  * not XXX, but ZZZ (bizarre).
 280  * promiscuous mode can be toggled to ignore NWIDs.  By default,
 281  * it does not.  Caution should be exercised about combining
 282  * this mode with IFF_ALLMULTI which puts this driver in
 283  * promiscuous mode.
 284  */
 285 static int      wl_ignore_nwid = 0;
 286 SYSCTL_INT(_machdep, OID_AUTO, wl_ignore_nwid, CTLFLAG_RW, &wl_ignore_nwid, 0, "");
 287
 288 /*
 289  * Emit diagnostics about transmission problems
 290  */
 291 static int      xmt_watch = 0;
 292 SYSCTL_INT(_machdep, OID_AUTO, wl_xmit_watch, CTLFLAG_RW, &xmt_watch, 0, "");
 293
 294 /*
 295  * Collect SNR statistics
 296  */
 297 static int      gathersnr = 0;
 298 SYSCTL_INT(_machdep, OID_AUTO, wl_gather_snr, CTLFLAG_RW, &gathersnr, 0, "");
 299
 300 static int      wlprobe(device_t);
 301 static int      wlattach(device_t);
 302 static int      wldetach(device_t);
 303 static int      wl_alloc_resources(device_t);
 304 static void     wl_free_resources(device_t);
 305 static void     wlstart(struct ifnet *);
 306 static void     wlinit(void *);
 307 static int      wlioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
 308 static timeout_t wlwatchdog;
 309 static void     wlintr(void *);
 310 static void     wlxmt(struct wl_softc *, struct mbuf *);
 311 static int      wldiag(struct wl_softc *);
 312 static int      wlconfig(struct wl_softc *);
 313 static int      wlcmd(struct wl_softc *, const char *);
 314 static void     wlmmcstat(struct wl_softc *);
 315 static u_short  wlbldru(struct wl_softc *);
 316 static u_short  wlmmcread(u_int, u_short);
 317 static void     wlinitmmc(struct wl_softc *);
 318 static int      wlhwrst(struct wl_softc *);
 319 static void     wlrustrt(struct wl_softc *);
 320 static void     wlbldcu(struct wl_softc *);
 321 static int      wlack(struct wl_softc *);
 322 static int      wlread(struct wl_softc *, u_short);
 323 static void     getsnr(struct wl_softc *);
 324 static void     wlrcv(struct wl_softc *);
 325 static int      wlrequeue(struct wl_softc *, u_short);
 326 static void     wlsftwsleaze(u_short *, u_char **, struct mbuf **);
 327 static void     wlhdwsleaze(u_short *, u_char **, struct mbuf **);
 328 static void     wltbd(struct wl_softc *);
 329 static void     wlgetpsa(int, u_char *);
 330 static void     wlsetpsa(struct wl_softc *);
 331 static u_short  wlpsacrc(u_char *);
 332 static void     wldump(struct wl_softc *);
 333 #ifdef WLCACHE
 334 static void     wl_cache_store(struct wl_softc *, int, struct ether_header *,
 335                                struct mbuf *);
 336 static void     wl_cache_zero(struct wl_softc *);
 337 #endif
 338 #ifdef MULTICAST
 339 # if defined(__FreeBSD__) && __FreeBSD_version < 300000
 340 static int      check_allmulti(struct wl_softc *);
 341 # endif
 342 #endif
 343
 344 static device_method_t wl_methods[] = {
 345         DEVMETHOD(device_probe,         wlprobe),
 346         DEVMETHOD(device_attach,        wlattach),
 347         DEVMETHOD(device_detach,        wldetach),
 348         { 0, 0 }
 349 };
 350
 351 static driver_t wl_driver = {
 352         "wl",
 353         wl_methods,
 354         sizeof(struct wl_softc)
 355 };
 356
 357 devclass_t wl_devclass;
 358 DECLARE_DUMMY_MODULE(if_wl);
 359 DRIVER_MODULE(wl, isa, wl_driver, wl_devclass, 0, 0);
 360 MODULE_DEPEND(wl, isa, 1, 1, 1);
 361
 362 static struct isa_pnp_id wl_ids[] = {
 363         { 0, NULL }
 364 };
 365
 366 /* array for maping irq numbers to values for the irq parameter register */
 367 static int irqvals[16] = {
 368     0, 0, 0, 0x01, 0x02, 0x04, 0, 0x08, 0, 0, 0x10, 0x20, 0x40, 0, 0, 0x80
 369 };
 370
 371 /*
 372  * wlprobe:
 373  *
 374  *      This function "probes" or checks for the WaveLAN board on the bus to
 375  *      see if it is there.  As far as I can tell, the best break between this
 376  *      routine and the attach code is to simply determine whether the board
 377  *      is configured in properly.  Currently my approach to this is to write
 378  *      and read a word from the SRAM on the board being probed.  If the word
 379  *      comes back properly then we assume the board is there.  The config
 380  *      code expects to see a successful return from the probe routine before
 381  *      attach will be called.
 382  */
 383 static int
 384 wlprobe(device_t dev)
 385 {
 386     struct wl_softc     *sc;
 387     short               base;
 388     const char          *str = "wl%d: board out of range [0..%d]\n";
 389     u_char              inbuf[100];
 390     int                 irq, error;
 391
 392     error = ISA_PNP_PROBE(device_get_parent(dev), dev, wl_ids);
 393     if (error == ENXIO || error == 0)
 394         return (error);
 395
 396     sc = device_get_softc(dev);
 397     error = wl_alloc_resources(dev);
 398     if (error)
 399         return error;
 400
 401     base = rman_get_start(sc->res_ioport);
 402
 403     /* TBD. not true.
 404      * regular CMD() will not work, since no softc yet
 405      */
 406 #define PCMD(base, hacr) outw((base), (hacr))
 407
 408     PCMD(base, HACR_RESET);                     /* reset the board */
 409     DELAY(DELAYCONST);                          /* >> 4 clocks at 6MHz */
 410     PCMD(base, HACR_RESET);                     /* reset the board */
 411     DELAY(DELAYCONST);                          /* >> 4 clocks at 6MHz */
 412
 413     /* clear reset command and set PIO#1 in autoincrement mode */
 414     PCMD(base, HACR_DEFAULT);
 415     PCMD(base, HACR_DEFAULT);
 416     outw(PIOR1(base), 0);                       /* go to beginning of RAM */
 417     outsw(PIOP1(base), str, strlen(str)/2+1);   /* write string */
 418
 419     outw(PIOR1(base), 0);                       /* rewind */
 420     insw(PIOP1(base), inbuf, strlen(str)/2+1);  /* read result */
 421
 422     if (bcmp(str, inbuf, strlen(str))) {
 423         error = ENXIO;
 424         goto fail;
 425     }
 426
 427     sc->chan24 = 0;                             /* 2.4 Gz: config channel */
 428     sc->freq24 = 0;                             /* 2.4 Gz: frequency    */
 429
 430     /* read the PSA from the board into temporary storage */
 431     wlgetpsa(base, inbuf);
 432
 433     /* We read the IRQ value from the PSA on the board. */
 434     for (irq = 15; irq >= 0; irq--)
 435         if (irqvals[irq] == inbuf[WLPSA_IRQNO])
 436             break;
 437     if ((irq == 0) || (irqvals[irq] == 0)){
 438         device_printf(dev, "PSA corrupt (invalid IRQ value)\n");
 439     } else {
 440         u_long sirq, dummy;
 441
 442         /*
 443          * If the IRQ requested by the PSA is already claimed by another
 444          * device, the board won't work, but the user can still access the
 445          * driver to change the IRQ.
 446          */
 447         if (bus_get_resource(dev, SYS_RES_IRQ, 0, &sirq, &dummy))
 448             goto fail;
 449         if (irq != (int)sirq)
 450             device_printf(dev, "board is configured for interrupt %d\n", irq);
 451     }
 452     error = 0;
 453
 454 fail:
 455     wl_free_resources(dev);
 456     return (error);
 457 }
 458
 459 /*
 460  * wlattach:
 461  *
 462  *      This function attaches a WaveLAN board to the "system".  The rest of
 463  *      runtime structures are initialized here (this routine is called after
 464  *      a successful probe of the board).  Once the ethernet address is read
 465  *      and stored, the board's ifnet structure is attached and readied.
 466  */
 467 static int
 468 wlattach(device_t dev)
 469 {
 470     struct wl_softc     *sc;
 471     short               base;
 472     int                 i, j, error;
 473     struct ifnet        *ifp;
 474
 475     sc = device_get_softc(dev);
 476
 477     ifp = &sc->wl_if;
 478     if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 479
 480     error = wl_alloc_resources(dev);
 481     if (error)
 482         return error;
 483
 484     base = rman_get_start(sc->res_ioport);
 485
 486 #ifdef WLDEBUG
 487     device_printf(dev, "%s: base %x, unit %d\n",
 488                   __func__, base, device_get_unit(dev));
 489 #endif
 490
 491     sc->base = base;
 492     sc->flags = 0;
 493     sc->mode = 0;
 494     sc->hacr = HACR_RESET;
 495     callout_init(&sc->watchdog_ch);
 496     CMD(sc);                            /* reset the board */
 497     DELAY(DELAYCONST);                  /* >> 4 clocks at 6MHz */
 498
 499     /* clear reset command and set PIO#2 in parameter access mode */
 500     sc->hacr = (HACR_DEFAULT & ~HACR_16BITS);
 501     CMD(sc);
 502
 503     /* Read the PSA from the board for our later reference */
 504     wlgetpsa(base, sc->psa);
 505
 506     /* fetch NWID */
 507     sc->nwid[0] = sc->psa[WLPSA_NWID];
 508     sc->nwid[1] = sc->psa[WLPSA_NWID+1];
 509
 510     /* fetch MAC address - decide which one first */
 511     if (sc->psa[WLPSA_MACSEL] & 1) {
 512         j = WLPSA_LOCALMAC;
 513     } else {
 514         j = WLPSA_UNIMAC;
 515     }
 516     for(i=0; i < WAVELAN_ADDR_SIZE; ++i) {
 517         sc->wl_addr[i] = sc->psa[j + i];
 518     }
 519
 520     /* enter normal 16 bit mode operation */
 521     sc->hacr = HACR_DEFAULT;
 522     CMD(sc);
 523
 524     wlinitmmc(sc);
 525     outw(PIOR1(base), OFFSET_SCB + 8);  /* address of scb_crcerrs */
 526     outw(PIOP1(base), 0);                       /* clear scb_crcerrs */
 527     outw(PIOP1(base), 0);                       /* clear scb_alnerrs */
 528     outw(PIOP1(base), 0);                       /* clear scb_rscerrs */
 529     outw(PIOP1(base), 0);                       /* clear scb_ovrnerrs */
 530
 531     ifp->if_softc = sc;
 532     ifp->if_mtu = WAVELAN_MTU;
 533     ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
 534 #ifdef    WLDEBUG
 535     ifp->if_flags |= IFF_DEBUG;
 536 #endif
 537 #if     MULTICAST
 538     ifp->if_flags |= IFF_MULTICAST;
 539 #endif  /* MULTICAST */
 540     ifp->if_init = wlinit;
 541     ifp->if_start = wlstart;
 542     ifp->if_ioctl = wlioctl;
 543     ifp->if_timer = 0;   /* paranoia */
 544     /* no entries
 545        ifp->if_watchdog
 546        ifp->if_done
 547        ifp->if_reset
 548        */
 549     ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 550     ifq_set_ready(&ifp->if_snd);
 551     ether_ifattach(ifp, sc->wl_ac.ac_enaddr, NULL);
 552
 553     if (sc->freq24)
 554         printf(", Freq %d MHz",sc->freq24);             /* 2.4 Gz       */
 555     printf("\n");                                       /* 2.4 Gz       */
 556
 557     error = bus_setup_intr(dev, sc->res_irq, INTR_NETSAFE,
 558                            wlintr, sc, &sc->intr_handle,
 559                            ifp->if_serializer);
 560     if (error) {
 561         device_printf(dev, "setup irq fail!\n");
 562         ether_ifdetach(ifp);
 563         wl_free_resources(dev);
 564         return error;
 565     }
 566
 567     if (bootverbose)
 568         wldump(sc);
 569     return 0;
 570 }
 571
 572 static int
 573 wldetach(device_t dev)
 574 {
 575     struct wl_softc *sc = device_get_softc(dev);
 576     device_t parent = device_get_parent(dev);
 577     struct ifnet *ifp = &sc->wl_if;
 578
 579     lwkt_serialize_enter(ifp->if_serializer);
 580
 581     /* reset the board */
 582     sc->hacr = HACR_RESET;
 583     CMD(sc);
 584     sc->hacr = HACR_DEFAULT;
 585     CMD(sc);
 586
 587     if (sc->intr_handle != NULL) {
 588         BUS_TEARDOWN_INTR(parent, dev, sc->res_irq, sc->intr_handle);
 589         sc->intr_handle = NULL;
 590     }
 591
 592     lwkt_serialize_exit(ifp->if_serializer);
 593
 594     ether_ifdetach(ifp);
 595     bus_generic_detach(dev);
 596     wl_free_resources(dev);
 597
 598     return (0);
 599 }
 600
 601 static int
 602 wl_alloc_resources(device_t dev)
 603 {
 604     struct wl_softc *sc = device_get_softc(dev);
 605     int ports = 16;             /* Number of ports */
 606
 607     sc->res_ioport = bus_alloc_resource(dev, SYS_RES_IOPORT,
 608         &sc->rid_ioport, 0ul, ~0ul, ports, RF_ACTIVE);
 609     if (sc->res_ioport == NULL)
 610         goto fail;
 611
 612     sc->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 613         &sc->rid_irq, RF_SHAREABLE | RF_ACTIVE);
 614     if (sc->res_irq == NULL)
 615         goto fail;
 616     return (0);
 617
 618 fail:
 619     wl_free_resources(dev);
 620     return (ENXIO);
 621 }
 622
 623 static void
 624 wl_free_resources(device_t dev)
 625 {
 626     struct wl_softc *sc = device_get_softc(dev);
 627
 628     if (sc->res_irq != 0) {
 629         bus_deactivate_resource(dev, SYS_RES_IRQ, sc->rid_irq, sc->res_irq);
 630         bus_release_resource(dev, SYS_RES_IRQ, sc->rid_irq, sc->res_irq);
 631         sc->res_irq = 0;
 632     }
 633     if (sc->res_ioport != 0) {
 634         bus_deactivate_resource(dev, SYS_RES_IOPORT,
 635             sc->rid_ioport, sc->res_ioport);
 636         bus_release_resource(dev, SYS_RES_IOPORT,
 637             sc->rid_ioport, sc->res_ioport);
 638         sc->res_ioport = 0;
 639     }
 640 }
 641
 642 /*
 643  * Print out interesting information about the 82596.
 644  */
 645 static void
 646 wldump(struct wl_softc *sc)
 647 {
 648     int         base = sc->base;
 649     int         i;
 650
 651     if_printf(&sc->wl_if, "hasr %04x\n", inw(HASR(base)));
 652
 653     if_printf(&sc->wl_if, "scb at %04x:\n ", OFFSET_SCB);
 654     outw(PIOR1(base), OFFSET_SCB);
 655     for(i = 0; i < 8; i++)
 656         printf("%04x ", inw(PIOP1(base)));
 657     printf("\n");
 658
 659     if_printf(&sc->wl_if, "cu at %04x:\n ", OFFSET_CU);
 660     outw(PIOR1(base), OFFSET_CU);
 661     for(i = 0; i < 8; i++)
 662         printf("%04x ", inw(PIOP1(base)));
 663     printf("\n");
 664
 665     if_printf(&sc->wl_if, "tbd at %04x:\n ", OFFSET_TBD);
 666     outw(PIOR1(base), OFFSET_TBD);
 667     for(i = 0; i < 4; i++)
 668         printf("%04x ", inw(PIOP1(base)));
 669     printf("\n");
 670 }
 671
 672 /* Initialize the Modem Management Controller */
 673 static void
 674 wlinitmmc(struct wl_softc *sc)
 675 {
 676     int         base = sc->base;
 677     int         configured;
 678     int         mode = sc->mode;
 679     int         i;                              /* 2.4 Gz               */
 680
 681     /* enter 8 bit operation */
 682     sc->hacr = (HACR_DEFAULT & ~HACR_16BITS);
 683     CMD(sc);
 684
 685     configured = sc->psa[WLPSA_CONFIGURED] & 1;
 686
 687     /*
 688      * Set default modem control parameters.  Taken from NCR document
 689      *  407-0024326 Rev. A
 690      */
 691     MMC_WRITE(MMC_JABBER_ENABLE, 0x01);
 692     MMC_WRITE(MMC_ANTEN_SEL, 0x02);
 693     MMC_WRITE(MMC_IFS, 0x20);
 694     MMC_WRITE(MMC_MOD_DELAY, 0x04);
 695     MMC_WRITE(MMC_JAM_TIME, 0x38);
 696     MMC_WRITE(MMC_DECAY_PRM, 0x00);             /* obsolete ? */
 697     MMC_WRITE(MMC_DECAY_UPDAT_PRM, 0x00);
 698     if (!configured) {
 699         MMC_WRITE(MMC_LOOPT_SEL, 0x00);
 700         if (sc->psa[WLPSA_COMPATNO] & 1) {
 701             MMC_WRITE(MMC_THR_PRE_SET, 0x01);   /* 0x04 for AT and 0x01 for MCA */
 702         } else {
 703             MMC_WRITE(MMC_THR_PRE_SET, 0x04);   /* 0x04 for AT and 0x01 for MCA */
 704         }
 705         MMC_WRITE(MMC_QUALITY_THR, 0x03);
 706     } else {
 707         /* use configuration defaults from parameter storage area */
 708         if (sc->psa[WLPSA_NWIDENABLE] & 1) {
 709             if ((mode & (MOD_PROM | MOD_ENAL)) && wl_ignore_nwid) {
 710                 MMC_WRITE(MMC_LOOPT_SEL, 0x40);
 711             } else {
 712                 MMC_WRITE(MMC_LOOPT_SEL, 0x00);
 713             }
 714         } else {
 715             MMC_WRITE(MMC_LOOPT_SEL, 0x40);     /* disable network id check */
 716         }
 717         MMC_WRITE(MMC_THR_PRE_SET, sc->psa[WLPSA_THRESH]);
 718         MMC_WRITE(MMC_QUALITY_THR, sc->psa[WLPSA_QUALTHRESH]);
 719     }
 720     MMC_WRITE(MMC_FREEZE, 0x00);
 721     MMC_WRITE(MMC_ENCR_ENABLE, 0x00);
 722
 723     MMC_WRITE(MMC_NETW_ID_L,sc->nwid[1]);       /* set NWID */
 724     MMC_WRITE(MMC_NETW_ID_H,sc->nwid[0]);
 725
 726     /* enter normal 16 bit mode operation */
 727     sc->hacr = HACR_DEFAULT;
 728     CMD(sc);
 729     CMD(sc);                                    /* virtualpc1 needs this! */
 730
 731     if (sc->psa[WLPSA_COMPATNO]==               /* 2.4 Gz: half-card ver     */
 732                 WLPSA_COMPATNO_WL24B) {         /* 2.4 Gz                    */
 733         i=sc->chan24<<4;                        /* 2.4 Gz: position ch #     */
 734         MMC_WRITE(MMC_EEADDR,i+0x0f);           /* 2.4 Gz: named ch, wc=16   */
 735         MMC_WRITE(MMC_EECTRL,MMC_EECTRL_DWLD+   /* 2.4 Gz: Download Synths   */
 736                         MMC_EECTRL_EEOP_READ);  /* 2.4 Gz: Read EEPROM       */
 737         for (i=0; i<1000; ++i) {                /* 2.4 Gz: wait for download */
 738             DELAY(40);                          /* 2.4 Gz             */
 739             if ((wlmmcread(base,MMC_EECTRLstat) /* 2.4 Gz: check DWLD and    */
 740                 &(MMC_EECTRLstat_DWLD           /* 2.4 Gz:       EEBUSY      */
 741                  +MMC_EECTRLstat_EEBUSY))==0)   /* 2.4 Gz:                   */
 742                 break;                          /* 2.4 Gz: download finished */
 743         }                                       /* 2.4 Gz                    */
 744         if (i==1000) {
 745             if_printf(&sc->wl_if,
 746                       "synth load failed\n");   /* 2.4 Gz       */
 747         }
 748         MMC_WRITE(MMC_EEADDR,0x61);             /* 2.4 Gz: default pwr, wc=2 */
 749         MMC_WRITE(MMC_EECTRL,MMC_EECTRL_DWLD+   /* 2.4 Gz: Download Xmit Pwr */
 750                         MMC_EECTRL_EEOP_READ);  /* 2.4 Gz: Read EEPROM       */
 751         for (i=0; i<1000; ++i) {                /* 2.4 Gz: wait for download */
 752             DELAY(40);                          /* 2.4 Gz             */
 753             if ((wlmmcread(base,MMC_EECTRLstat) /* 2.4 Gz: check DWLD and    */
 754                 &(MMC_EECTRLstat_DWLD           /* 2.4 Gz:       EEBUSY      */
 755                  +MMC_EECTRLstat_EEBUSY))==0)   /* 2.4 Gz:                   */
 756                 break;                          /* 2.4 Gz: download finished */
 757         }                                       /* 2.4 Gz                    */
 758         if (i==1000) {
 759             if_printf(&sc->wl_if,
 760                       "xmit pwr load failed\n");/* 2.4 Gz            */
 761         }
 762         MMC_WRITE(MMC_ANALCTRL,                 /* 2.4 Gz: EXT ant+polarity  */
 763                         MMC_ANALCTRL_ANTPOL +   /* 2.4 Gz:                   */
 764                         MMC_ANALCTRL_EXTANT);   /* 2.4 Gz:                   */
 765         i=sc->chan24<<4;                        /* 2.4 Gz: position ch #     */
 766         MMC_WRITE(MMC_EEADDR,i);                /* 2.4 Gz: get frequency     */
 767         MMC_WRITE(MMC_EECTRL,                   /* 2.4 Gz: EEPROM read      */
 768                         MMC_EECTRL_EEOP_READ);  /* 2.4 Gz:                  */
 769         DELAY(40);                              /* 2.4 Gz                    */
 770         i = wlmmcread(base,MMC_EEDATALrv)       /* 2.4 Gz: freq val          */
 771           + (wlmmcread(base,MMC_EEDATAHrv)<<8); /* 2.4 Gz                    */
 772         sc->freq24 = (i>>6)+2400;               /* 2.4 Gz: save real freq    */
 773     }
 774 }
 775
 776 /*
 777  * wlinit:
 778  *
 779  *      Another routine that interfaces the "if" layer to this driver.
 780  *      Simply resets the structures that are used by "upper layers".
 781  *      As well as calling wlhwrst that does reset the WaveLAN board.
 782  *
 783  * input        : softc pointer for this interface
 784  * output       : structures (if structs) and board are reset
 785  *
 786  */
 787 static void
 788 wlinit(void *xsc)
 789 {
 790     struct wl_softc *sc = xsc;
 791     struct ifnet        *ifp = &sc->wl_if;
 792     int                 stat;
 793
 794 #ifdef WLDEBUG
 795     if (ifp->if_flags & IFF_DEBUG)
 796         if_printf(ifp, "entered wlinit()\n");
 797 #endif
 798     if ((stat = wlhwrst(sc)) == TRUE) {
 799         ifp->if_flags |= IFF_RUNNING;   /* same as DSF_RUNNING */
 800         /*
 801          * OACTIVE is used by upper-level routines
 802          * and must be set
 803          */
 804         ifp->if_flags &= ~IFF_OACTIVE;  /* same as tbusy below */
 805
 806         sc->flags |= DSF_RUNNING;
 807         sc->tbusy = 0;
 808         callout_stop(&sc->watchdog_ch);
 809
 810         wlstart(ifp);
 811     } else {
 812         if_printf(ifp, "init(): trouble resetting board.\n");
 813     }
 814 }
 815
 816 /*
 817  * wlhwrst:
 818  *
 819  *      This routine resets the WaveLAN board that corresponds to the
 820  *      board number passed in.
 821  *
 822  * input        : softc pointer for this interface
 823  * output       : board is reset
 824  *
 825  */
 826 static int
 827 wlhwrst(struct wl_softc *sc)
 828 {
 829 #ifdef WLDEBUG
 830     if (sc->wl_if.if_flags & IFF_DEBUG)
 831         if_printf(&sc->wl_if, "entered wlhwrst()\n");
 832 #endif
 833     sc->hacr = HACR_RESET;
 834     CMD(sc);                    /* reset the board */
 835
 836     /* clear reset command and set PIO#1 in autoincrement mode */
 837     sc->hacr = HACR_DEFAULT;
 838     CMD(sc);
 839
 840 #ifdef  WLDEBUG
 841     if (sc->wl_if.if_flags & IFF_DEBUG)
 842         wlmmcstat(sc);          /* Display MMC registers */
 843 #endif  /* WLDEBUG */
 844     wlbldcu(sc);                /* set up command unit structures */
 845
 846     if (wldiag(sc) == 0)
 847         return(0);
 848
 849     if (wlconfig(sc) == 0)
 850             return(0);
 851     /*
 852      * insert code for loopback test here
 853      */
 854     wlrustrt(sc);               /* start receive unit */
 855
 856     /* enable interrupts */
 857     sc->hacr = (HACR_DEFAULT | HACR_INTRON);
 858     CMD(sc);
 859
 860     return(1);
 861 }
 862
 863 /*
 864  * wlbldcu:
 865  *
 866  *      This function builds up the command unit structures.  It inits
 867  *      the scp, iscp, scb, cb, tbd, and tbuf.
 868  *
 869  */
 870 static void
 871 wlbldcu(struct wl_softc *sc)
 872 {
 873     short               base = sc->base;
 874     scp_t               scp;
 875     iscp_t              iscp;
 876     scb_t               scb;
 877     ac_t                cb;
 878     tbd_t               tbd;
 879     int         i;
 880
 881     bzero(&scp, sizeof(scp));
 882     scp.scp_sysbus = 0;
 883     scp.scp_iscp = OFFSET_ISCP;
 884     scp.scp_iscp_base = 0;
 885     outw(PIOR1(base), OFFSET_SCP);
 886     outsw(PIOP1(base), &scp, sizeof(scp_t)/2);
 887
 888     bzero(&iscp, sizeof(iscp));
 889     iscp.iscp_busy = 1;
 890     iscp.iscp_scb_offset = OFFSET_SCB;
 891     iscp.iscp_scb = 0;
 892     iscp.iscp_scb_base = 0;
 893     outw(PIOR1(base), OFFSET_ISCP);
 894     outsw(PIOP1(base), &iscp, sizeof(iscp_t)/2);
 895
 896     scb.scb_status = 0;
 897     scb.scb_command = SCB_RESET;
 898     scb.scb_cbl_offset = OFFSET_CU;
 899     scb.scb_rfa_offset = OFFSET_RU;
 900     scb.scb_crcerrs = 0;
 901     scb.scb_alnerrs = 0;
 902     scb.scb_rscerrs = 0;
 903     scb.scb_ovrnerrs = 0;
 904     outw(PIOR1(base), OFFSET_SCB);
 905     outsw(PIOP1(base), &scb, sizeof(scb_t)/2);
 906
 907     SET_CHAN_ATTN(sc);
 908
 909     outw(PIOR0(base), OFFSET_ISCP + 0); /* address of iscp_busy */
 910     for (i = 1000000; inw(PIOP0(base)) && (i-- > 0); );
 911     if (i <= 0) if_printf(&sc->wl_if, "bldcu(): iscp_busy timeout.\n");
 912     outw(PIOR0(base), OFFSET_SCB + 0);  /* address of scb_status */
 913     for (i = STATUS_TRIES; i-- > 0; ) {
 914         if (inw(PIOP0(base)) == (SCB_SW_CX|SCB_SW_CNA))
 915             break;
 916     }
 917     if (i <= 0)
 918         if_printf(&sc->wl_if, "bldcu(): not ready after reset.\n");
 919     wlack(sc);
 920
 921     cb.ac_status = 0;
 922     cb.ac_command = AC_CW_EL;           /* NOP */
 923     cb.ac_link_offset = OFFSET_CU;
 924     outw(PIOR1(base), OFFSET_CU);
 925     outsw(PIOP1(base), &cb, 6/2);
 926
 927     tbd.act_count = 0;
 928     tbd.next_tbd_offset = I82586NULL;
 929     tbd.buffer_addr = 0;
 930     tbd.buffer_base = 0;
 931     outw(PIOR1(base), OFFSET_TBD);
 932     outsw(PIOP1(base), &tbd, sizeof(tbd_t)/2);
 933 }
 934
 935 /*
 936  * wlstart:
 937  *
 938  *      send a packet
 939  *
 940  * input        : pointer the appropriate "if" struct
 941  * output       : stuff sent to board if any there
 942  *
 943  */
 944 static void
 945 wlstart(struct ifnet *ifp)
 946 {
 947     struct mbuf                 *m;
 948     struct wl_softc     *sc = ifp->if_softc;
 949     short                       base = sc->base;
 950     int                         scb_status, cu_status, scb_command;
 951
 952 #ifdef WLDEBUG
 953     if (ifp->if_flags & IFF_DEBUG)
 954         if_printf(ifp, "entered wlstart()\n");
 955 #endif
 956
 957     outw(PIOR1(base), OFFSET_CU);
 958     cu_status = inw(PIOP1(base));
 959     outw(PIOR0(base),OFFSET_SCB + 0);   /* scb_status */
 960     scb_status = inw(PIOP0(base));
 961     outw(PIOR0(base), OFFSET_SCB + 2);
 962     scb_command = inw(PIOP0(base));
 963
 964     /*
 965      * don't need OACTIVE check as tbusy here checks to see
 966      * if we are already busy
 967      */
 968     if (sc->tbusy) {
 969         if((scb_status & 0x0700) == SCB_CUS_IDLE &&
 970            (cu_status & AC_SW_B) == 0){
 971             sc->tbusy = 0;
 972             callout_stop(&sc->watchdog_ch);
 973             ifp->if_flags &= ~IFF_OACTIVE;
 974             /*
 975              * This is probably just a race.  The xmt'r is just
 976              * became idle but WE have masked interrupts so ...
 977              */
 978 #ifdef WLDEBUG
 979             if_printf(ifp, "CU idle, scb %04x %04x cu %04x\n",
 980                       scb_status, scb_command, cu_status);
 981 #endif
 982             if (xmt_watch) if_printf(ifp, "!!\n");
 983         } else {
 984             return;     /* genuinely still busy */
 985         }
 986     } else if((scb_status & 0x0700) == SCB_CUS_ACTV ||
 987               (cu_status & AC_SW_B)){
 988 #ifdef WLDEBUG
 989         if_printf(ifp, "CU unexpectedly busy; scb %04x cu %04x\n",
 990                   scb_status, cu_status);
 991 #endif
 992         if (xmt_watch) if_printf(ifp, "busy?!");
 993         return;         /* hey, why are we busy? */
 994     }
 995
 996     /* get ourselves some data */
 997     ifp = &(sc->wl_if);
 998     m = ifq_dequeue(&ifp->if_snd, NULL);
 999     if (m != NULL) {
1000         BPF_MTAP(ifp, m);
1001         sc->tbusy++;
1002         /* set the watchdog timer so that if the board
1003          * fails to interrupt we will restart
1004          */
1005         /* try 10 ticks, not very long */
1006         callout_reset(&sc->watchdog_ch, 10, wlwatchdog, sc);
1007         ifp->if_flags |= IFF_OACTIVE;
1008         ifp->if_opackets++;
1009         wlxmt(sc, m);
1010     } else {
1011         ifp->if_flags &= ~IFF_OACTIVE;
1012     }
1013 }
1014
1015 /*
1016  * wlread:
1017  *
1018  *      This routine does the actual copy of data (including ethernet header
1019  *      structure) from the WaveLAN to an mbuf chain that will be passed up
1020  *      to the "if" (network interface) layer.  NOTE:  we currently
1021  *      don't handle trailer protocols, so if that is needed, it will
1022  *      (at least in part) be added here.  For simplicities sake, this
1023  *      routine copies the receive buffers from the board into a local (stack)
1024  *      buffer until the frame has been copied from the board.  Once in
1025  *      the local buffer, the contents are copied to an mbuf chain that
1026  *      is then enqueued onto the appropriate "if" queue.
1027  *
1028  * input        : softc pointer for this interface and
1029  *                an frame descriptor address
1030  * output       : the packet is put into an mbuf chain, and passed up
1031  * assumes      : if any errors occur, packet is "dropped on the floor"
1032  *
1033  */
1034 static int
1035 wlread(struct wl_softc *sc, u_short fd_p)
1036 {
1037     struct ifnet        *ifp = &sc->wl_if;
1038     short                       base = sc->base;
1039     fd_t                        fd;
1040     struct ether_header         eh;
1041     struct mbuf                 *m, *tm;
1042     rbd_t                       rbd;
1043     u_char                      *mb_p;
1044     u_short                     mlen, len, clen;
1045     u_short                     bytes_in_msg, bytes_in_mbuf, bytes;
1046
1047
1048 #ifdef WLDEBUG
1049     if (ifp->if_flags & IFF_DEBUG)
1050         if_printf(ifp, "entered wlread()\n");
1051 #endif
1052     if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
1053         if_printf(ifp, "read(): board is not running.\n");
1054         sc->hacr &= ~HACR_INTRON;
1055         CMD(sc);                /* turn off interrupts */
1056     }
1057     /* read ether_header info out of device memory. doesn't
1058      * go into mbuf.  goes directly into eh structure
1059      */
1060     len = sizeof(struct ether_header);  /* 14 bytes */
1061     outw(PIOR1(base), fd_p);
1062     insw(PIOP1(base), &fd, (sizeof(fd_t) - len)/2);
1063     insw(PIOP1(base), &eh, (len-2)/2);
1064     eh.ether_type = ntohs(inw(PIOP1(base)));
1065 #ifdef WLDEBUG
1066     if (ifp->if_flags & IFF_DEBUG)
1067         if_printf(ifp, "wlread: rcv packet, type is %x\n", eh.ether_type);
1068 #endif
1069     /*
1070      * WARNING.  above is done now in ether_input, above may be
1071      * useful for debug. jrb
1072      */
1073     eh.ether_type = htons(eh.ether_type);
1074
1075     if (fd.rbd_offset == I82586NULL) {
1076         if_printf(ifp, "read(): Invalid buffer\n");
1077         if (wlhwrst(sc) != TRUE)
1078             if_printf(ifp, "read(): hwrst trouble.\n");
1079         return 0;
1080     }
1081
1082     outw(PIOR1(base), fd.rbd_offset);
1083     insw(PIOP1(base), &rbd, sizeof(rbd_t)/2);
1084     bytes_in_msg = rbd.status & RBD_SW_COUNT;
1085     MGETHDR(m, MB_DONTWAIT, MT_DATA);
1086     tm = m;
1087     if (m == NULL) {
1088         /*
1089          * not only do we want to return, we need to drop the packet on
1090          * the floor to clear the interrupt.
1091          *
1092          */
1093         if (wlhwrst(sc) != TRUE) {
1094             sc->hacr &= ~HACR_INTRON;
1095             CMD(sc);            /* turn off interrupts */
1096             if_printf(ifp, "read(): hwrst trouble.\n");
1097         }
1098         return 0;
1099     }
1100     m->m_next = (struct mbuf *) 0;
1101     m->m_pkthdr.rcvif = ifp;
1102     m->m_pkthdr.len = 0; /* don't know this yet */
1103     m->m_len = MHLEN;
1104
1105     /* always use a cluster. jrb
1106      */
1107     MCLGET(m, MB_DONTWAIT);
1108     if (m->m_flags & M_EXT) {
1109         m->m_len = MCLBYTES;
1110     }
1111     else {
1112         m_freem(m);
1113         if (wlhwrst(sc) != TRUE) {
1114             sc->hacr &= ~HACR_INTRON;
1115             CMD(sc);            /* turn off interrupts */
1116             if_printf(ifp, "read(): hwrst trouble.\n");
1117         }
1118         return 0;
1119     }
1120
1121     mlen = 0;
1122     clen = mlen;
1123     bytes_in_mbuf = m->m_len - sizeof(eh);
1124     mb_p = mtod(tm, u_char *);
1125     bytes = min(bytes_in_mbuf, bytes_in_msg);
1126     bcopy(&eh, mb_p, sizeof(eh));
1127     mb_p += sizeof(eh);
1128     for (;;) {
1129         if (bytes & 1) {
1130             len = bytes + 1;
1131         } else {
1132             len = bytes;
1133         }
1134         outw(PIOR1(base), rbd.buffer_addr);
1135         insw(PIOP1(base), mb_p, len/2);
1136         clen += bytes;
1137         mlen += bytes;
1138
1139         if (!(bytes_in_mbuf -= bytes)) {
1140             MGET(tm->m_next, MB_DONTWAIT, MT_DATA);
1141             tm = tm->m_next;
1142             if (tm == (struct mbuf *)0) {
1143                 m_freem(m);
1144                 if_printf(ifp, "read(): No mbuf nth\n");
1145                 if (wlhwrst(sc) != TRUE) {
1146                     sc->hacr &= ~HACR_INTRON;
1147                     CMD(sc);  /* turn off interrupts */
1148                     if_printf(ifp, "read(): hwrst trouble.\n");
1149                 }
1150                 return 0;
1151             }
1152             mlen = 0;
1153             tm->m_len = MLEN;
1154             bytes_in_mbuf = MLEN;
1155             mb_p = mtod(tm, u_char *);
1156         } else {
1157             mb_p += bytes;
1158         }
1159
1160         if (!(bytes_in_msg  -= bytes)) {
1161             if (rbd.status & RBD_SW_EOF ||
1162                 rbd.next_rbd_offset == I82586NULL) {
1163                 tm->m_len = mlen;
1164                 break;
1165             } else {
1166                 outw(PIOR1(base), rbd.next_rbd_offset);
1167                 insw(PIOP1(base), &rbd, sizeof(rbd_t)/2);
1168                 bytes_in_msg = rbd.status & RBD_SW_COUNT;
1169             }
1170         } else {
1171             rbd.buffer_addr += bytes;
1172         }
1173
1174         bytes = min(bytes_in_mbuf, bytes_in_msg);
1175     }
1176
1177     m->m_pkthdr.len = clen;
1178
1179     /*
1180      * If hw is in promiscuous mode (note that I said hardware, not if
1181      * IFF_PROMISC is set in ifnet flags), then if this is a unicast
1182      * packet and the MAC dst is not us, drop it.  This check in normally
1183      * inside ether_input(), but IFF_MULTI causes hw promisc without
1184      * a bpf listener, so this is wrong.
1185      *          Greg Troxel <gdt@ir.bbn.com>, 1998-08-07
1186      */
1187     /*
1188      * TBD: also discard packets where NWID does not match.
1189      * However, there does not appear to be a way to read the nwid
1190      * for a received packet.  -gdt 1998-08-07
1191      */
1192     if (
1193 #ifdef WL_USE_IFNET_PROMISC_CHECK /* not defined */
1194         (ifp->if_flags & (IFF_PROMISC|IFF_ALLMULTI))
1195 #else
1196         /* hw is in promisc mode if this is true */
1197         (sc->mode & (MOD_PROM | MOD_ENAL))
1198 #endif
1199         &&
1200         (eh.ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */
1201         bcmp(eh.ether_dhost, sc->wl_ac.ac_enaddr,
1202              sizeof(eh.ether_dhost)) != 0 ) {
1203       m_freem(m);
1204       return 1;
1205     }
1206
1207 #ifdef WLDEBUG
1208     if (ifp->if_flags & IFF_DEBUG)
1209         if_printf(ifp, "wlrecv %d bytes\n", clen);
1210 #endif
1211
1212 #ifdef WLCACHE
1213     wl_cache_store(sc, base, &eh, m);
1214 #endif
1215
1216     /*
1217      * received packet is now in a chain of mbuf's.  next step is
1218      * to pass the packet upwards.
1219      *
1220      */
1221     ifp->if_input(ifp, m);
1222     return 1;
1223 }
1224
1225 /*
1226  * wlioctl:
1227  *
1228  *      This routine processes an ioctl request from the "if" layer
1229  *      above.
1230  *
1231  * input        : pointer the appropriate "if" struct, command and data
1232  * output       : based on command appropriate action is taken on the
1233  *                WaveLAN board(s) or related structures
1234  * return       : error is returned containing exit conditions
1235  *
1236  */
1237 static int
1238 wlioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cred)
1239 {
1240     struct ifreq        *ifr = (struct ifreq *)data;
1241     struct wl_softc     *sc = ifp->if_softc;
1242     short               base = sc->base;
1243     short               mode = 0;
1244     int                 error = 0;
1245     int                 irq, irqval, i, isroot, size;
1246     caddr_t             up;
1247     char *              cpt;
1248     struct thread *td = curthread; /* XXX */
1249
1250
1251 #ifdef WLDEBUG
1252     if (ifp->if_flags & IFF_DEBUG)
1253         if_printf(ifp, "entered wlioctl()\n");
1254 #endif
1255     switch (cmd) {
1256     case SIOCSIFFLAGS:
1257         if (ifp->if_flags & IFF_ALLMULTI) {
1258             mode |= MOD_ENAL;
1259         }
1260         if (ifp->if_flags & IFF_PROMISC) {
1261             mode |= MOD_PROM;
1262         }
1263         if(ifp->if_flags & IFF_LINK0) {
1264             mode |= MOD_PROM;
1265         }
1266         /*
1267          * force a complete reset if the recieve multicast/
1268          * promiscuous mode changes so that these take
1269          * effect immediately.
1270          *
1271          */
1272         if (sc->mode != mode) {
1273             sc->mode = mode;
1274             if (sc->flags & DSF_RUNNING) {
1275                 sc->flags &= ~DSF_RUNNING;
1276                 wlinit(sc);
1277             }
1278         }
1279         /* if interface is marked DOWN and still running then
1280          * stop it.
1281          */
1282         if ((ifp->if_flags & IFF_UP) == 0 && sc->flags & DSF_RUNNING) {
1283             if_printf(ifp, "ioctl(): board is not running\n");
1284             sc->flags &= ~DSF_RUNNING;
1285             sc->hacr &= ~HACR_INTRON;
1286             CMD(sc);              /* turn off interrupts */
1287         }
1288         /* else if interface is UP and RUNNING, start it
1289                 */
1290         else if (ifp->if_flags & IFF_UP && (sc->flags & DSF_RUNNING) == 0) {
1291             wlinit(sc);
1292         }
1293
1294         /* if WLDEBUG set on interface, then printf rf-modem regs
1295         */
1296         if(ifp->if_flags & IFF_DEBUG)
1297             wlmmcstat(sc);
1298         break;
1299 #if     MULTICAST
1300     case SIOCADDMULTI:
1301     case SIOCDELMULTI:
1302
1303 #if defined(__FreeBSD__) && __FreeBSD_version < 300000
1304         if (cmd == SIOCADDMULTI) {
1305             error = ether_addmulti(ifr, &sc->wl_ac);
1306         }
1307         else {
1308             error = ether_delmulti(ifr, &sc->wl_ac);
1309         }
1310
1311         /* see if we should be in all multicast mode
1312          * note that 82586 cannot do that, must simulate with
1313          * promiscuous mode
1314          */
1315         if (check_allmulti(sc)) {
1316                 ifp->if_flags |=  IFF_ALLMULTI;
1317                 sc->mode |= MOD_ENAL;
1318                 sc->flags &= ~DSF_RUNNING;
1319                 wlinit(sc);
1320                 error = 0;
1321                 break;
1322         }
1323
1324         if (error == ENETRESET) {
1325             if(sc->flags & DSF_RUNNING) {
1326                 sc->flags &= ~DSF_RUNNING;
1327                 wlinit(sc);
1328             }
1329             error = 0;
1330         }
1331 #else
1332         wlinit(sc);
1333 #endif
1334         break;
1335 #endif  /* MULTICAST */
1336
1337     /* DEVICE SPECIFIC */
1338
1339
1340         /* copy the PSA out to the caller */
1341     case SIOCGWLPSA:
1342         /* pointer to buffer in user space */
1343         up = (void *)ifr->ifr_data;
1344         /* work out if they're root */
1345         isroot = (suser(td) == 0);
1346
1347         for (i = 0; i < 0x40; i++) {
1348             /* don't hand the DES key out to non-root users */
1349             if ((i > WLPSA_DESKEY) && (i < (WLPSA_DESKEY + 8)) && !isroot)
1350                 continue;
1351             if (subyte((up + i), sc->psa[i]))
1352                 return(EFAULT);
1353         }
1354         break;
1355
1356
1357         /* copy the PSA in from the caller; we only copy _some_ values */
1358     case SIOCSWLPSA:
1359         /* root only */
1360         if ((error = suser(td)))
1361             break;
1362         error = EINVAL; /* assume the worst */
1363         /* pointer to buffer in user space containing data */
1364         up = (void *)ifr->ifr_data;
1365
1366         /* check validity of input range */
1367         for (i = 0; i < 0x40; i++)
1368             if (fubyte(up + i) < 0)
1369                 return(EFAULT);
1370
1371         /* check IRQ value */
1372         irqval = fubyte(up+WLPSA_IRQNO);
1373         for (irq = 15; irq >= 0; irq--)
1374             if(irqvals[irq] == irqval)
1375                 break;
1376         if (irq == 0)                   /* oops */
1377             break;
1378         /* new IRQ */
1379         sc->psa[WLPSA_IRQNO] = irqval;
1380
1381         /* local MAC */
1382         for (i = 0; i < 6; i++)
1383             sc->psa[WLPSA_LOCALMAC+i] = fubyte(up+WLPSA_LOCALMAC+i);
1384
1385         /* MAC select */
1386         sc->psa[WLPSA_MACSEL] = fubyte(up+WLPSA_MACSEL);
1387
1388         /* default nwid */
1389         sc->psa[WLPSA_NWID] = fubyte(up+WLPSA_NWID);
1390         sc->psa[WLPSA_NWID+1] = fubyte(up+WLPSA_NWID+1);
1391
1392         error = 0;
1393         wlsetpsa(sc);           /* update the PSA */
1394         break;
1395
1396
1397         /* get the current NWID out of the sc since we stored it there */
1398     case SIOCGWLCNWID:
1399         ifr->ifr_data = (caddr_t) (sc->nwid[0] << 8 | sc->nwid[1]);
1400         break;
1401
1402
1403         /*
1404          * change the nwid dynamically.  This
1405          * ONLY changes the radio modem and does not
1406          * change the PSA.
1407          *
1408          * 2 steps:
1409          *      1. save in softc "soft registers"
1410          *      2. save in radio modem (MMC)
1411          */
1412     case SIOCSWLCNWID:
1413         /* root only */
1414         if ((error = suser(td)))
1415             break;
1416         if (!(ifp->if_flags & IFF_UP)) {
1417             error = EIO;        /* only allowed while up */
1418         } else {
1419             /*
1420              * soft c nwid shadows radio modem setting
1421              */
1422             sc->nwid[0] = (int)ifr->ifr_data >> 8;
1423             sc->nwid[1] = (int)ifr->ifr_data & 0xff;
1424             MMC_WRITE(MMC_NETW_ID_L,sc->nwid[1]);
1425             MMC_WRITE(MMC_NETW_ID_H,sc->nwid[0]);
1426         }
1427         break;
1428
1429         /* copy the EEPROM in 2.4 Gz WaveMODEM  out to the caller */
1430     case SIOCGWLEEPROM:
1431         /* root only */
1432         if ((error = suser(td)))
1433             break;
1434         /* pointer to buffer in user space */
1435         up = (void *)ifr->ifr_data;
1436
1437         for (i=0x00; i<0x80; ++i) {             /* 2.4 Gz: size of EEPROM   */
1438             MMC_WRITE(MMC_EEADDR,i);            /* 2.4 Gz: get frequency    */
1439             MMC_WRITE(MMC_EECTRL,               /* 2.4 Gz: EEPROM read      */
1440                         MMC_EECTRL_EEOP_READ);  /* 2.4 Gz:                  */
1441             DELAY(40);                          /* 2.4 Gz                   */
1442             if (subyte(up + 2*i  ,              /* 2.4 Gz: pass low byte of */
1443                  wlmmcread(base,MMC_EEDATALrv)) /* 2.4 Gz: EEPROM word      */
1444                ) return(EFAULT);                /* 2.4 Gz:                  */
1445             if (subyte(up + 2*i+1,              /* 2.4 Gz: pass hi byte of  */
1446                  wlmmcread(base,MMC_EEDATALrv)) /* 2.4 Gz: EEPROM word      */
1447                ) return(EFAULT);                /* 2.4 Gz:                  */
1448         }
1449         break;
1450
1451 #ifdef WLCACHE
1452         /* zero (Delete) the wl cache */
1453     case SIOCDWLCACHE:
1454         /* root only */
1455         if ((error = suser(td)))
1456             break;
1457         wl_cache_zero(sc);
1458         break;
1459
1460         /* read out the number of used cache elements */
1461     case SIOCGWLCITEM:
1462         ifr->ifr_data = (caddr_t) sc->w_sigitems;
1463         break;
1464
1465         /* read out the wl cache */
1466     case SIOCGWLCACHE:
1467         /* pointer to buffer in user space */
1468         up = (void *)ifr->ifr_data;
1469         cpt = (char *) &sc->w_sigcache[0];
1470         size = sc->w_sigitems * sizeof(struct w_sigcache);
1471
1472         for (i = 0; i < size; i++) {
1473             if (subyte((up + i), *cpt++))
1474                 return(EFAULT);
1475         }
1476         break;
1477 #endif
1478
1479     default:
1480         error = ether_ioctl(ifp, cmd, data);
1481         break;
1482     }
1483     return (error);
1484 }
1485
1486 /*
1487  * wlwatchdog():
1488  *
1489  * Called if the timer set in wlstart expires before an interrupt is received
1490  * from the wavelan.   It seems to lose interrupts sometimes.
1491  * The watchdog routine gets called if the transmitter failed to interrupt
1492  *
1493  * input        : which board is timing out
1494  * output       : board reset
1495  *
1496  */
1497 static void
1498 wlwatchdog(void *vsc)
1499 {
1500     struct wl_softc *sc = vsc;
1501     struct ifnet *ifp = &sc->wl_if;
1502
1503     lwkt_serialize_enter(ifp->if_serializer);
1504     log(LOG_ERR, "%s: wavelan device timeout on xmit\n", sc->wl_if.if_xname);
1505     sc->wl_if.if_oerrors++;
1506     wlinit(sc);
1507     lwkt_serialize_exit(ifp->if_serializer);
1508 }
1509
1510 /*
1511  * wlintr:
1512  *
1513  *      This function is the interrupt handler for the WaveLAN
1514  *      board.  This routine will be called whenever either a packet
1515  *      is received, or a packet has successfully been transfered and
1516  *      the unit is ready to transmit another packet.
1517  *
1518  * input        : softc pointer for this interface
1519  * output       : either a packet is received, or a packet is transfered
1520  *
1521  */
1522 static void
1523 wlintr(void *arg)
1524 {
1525     struct wl_softc *sc = arg;
1526     struct ifnet *ifp = &sc->wl_if;
1527     short               base = sc->base;
1528     int                 ac_status;
1529     u_short             int_type, int_type1;
1530
1531 #ifdef WLDEBUG
1532     if (ifp->if_flags & IFF_DEBUG)
1533         if_printf(ifp, "wlintr() called\n");
1534 #endif
1535
1536     if((int_type = inw(HASR(base))) & HASR_MMC_INTR) {
1537         /* handle interrupt from the modem management controler */
1538         /* This will clear the interrupt condition */
1539         (void) wlmmcread(base,MMC_DCE_STATUS); /* ignored for now */
1540     }
1541
1542     if(!(int_type & HASR_INTR)){        /* return if no interrupt from 82586 */
1543         /* commented out. jrb.  it happens when reinit occurs
1544            if_printf(ifp, "%s: int_type %x, dump follows\n",
1545                      __func__, int_type);
1546            wldump(sc);
1547            */
1548         return;
1549     }
1550
1551     if (gathersnr)
1552         getsnr(sc);
1553     for(;;) {
1554         outw(PIOR0(base), OFFSET_SCB + 0);      /* get scb status */
1555         int_type = (inw(PIOP0(base)) & SCB_SW_INT);
1556         if (int_type == 0)                      /* no interrupts left */
1557             break;
1558
1559         int_type1 = wlack(sc);                  /* acknowledge interrupt(s) */
1560         /* make sure no bits disappeared (others may appear) */
1561         if ((int_type & int_type1) != int_type) {
1562             if_printf(ifp, "wlack() int bits disappeared: "
1563                       "%04x != int_type %04x\n", int_type1, int_type);
1564         }
1565         int_type = int_type1;                   /* go with the new status */
1566         /*
1567          * incoming packet
1568          */
1569         if (int_type & SCB_SW_FR) {
1570             ifp->if_ipackets++;
1571             wlrcv(sc);
1572         }
1573         /*
1574          * receiver not ready
1575          */
1576         if (int_type & SCB_SW_RNR) {
1577             ifp->if_ierrors++;
1578 #ifdef  WLDEBUG
1579             if (ifp->if_flags & IFF_DEBUG) {
1580                 if_printf(ifp, "intr(): receiver overrun! begin_fd = %x\n",
1581                           sc->begin_fd);
1582             }
1583 #endif
1584             wlrustrt(sc);
1585         }
1586         /*
1587          * CU not ready
1588          */
1589         if (int_type & SCB_SW_CNA) {
1590             /*
1591              * At present, we don't care about CNA's.  We
1592              * believe they are a side effect of XMT.
1593              */
1594         }
1595         if (int_type & SCB_SW_CX) {
1596             /*
1597              * At present, we only request Interrupt for
1598              * XMT.
1599              */
1600             outw(PIOR1(base), OFFSET_CU);       /* get command status */
1601             ac_status = inw(PIOP1(base));
1602
1603             if (xmt_watch) {                    /* report some anomalies */
1604
1605                 if (sc->tbusy == 0) {
1606                     if_printf(ifp, "xmt intr but not busy, CU %04x\n",
1607                               ac_status);
1608                 }
1609                 if (ac_status == 0) {
1610                     if_printf(ifp, "xmt intr but ac_status == 0\n");
1611                 }
1612                 if (ac_status & AC_SW_A) {
1613                     if_printf(ifp, "xmt aborted\n");
1614                 }
1615 #ifdef  notdef
1616                 if (ac_status & TC_CARRIER) {
1617                     if_printf(ifp, "no carrier\n");
1618                 }
1619 #endif  /* notdef */
1620                 if (ac_status & TC_CLS) {
1621                     if_printf(ifp, "no CTS\n");
1622                 }
1623                 if (ac_status & TC_DMA) {
1624                     if_printf(ifp, "DMA underrun\n");
1625                 }
1626                 if (ac_status & TC_DEFER) {
1627                     if_printf(ifp, "xmt deferred\n");
1628                 }
1629                 if (ac_status & TC_SQE) {
1630                     if_printf(ifp, "heart beat\n");
1631                 }
1632                 if (ac_status & TC_COLLISION) {
1633                     if_printf(ifp, "too many collisions\n");
1634                 }
1635             }
1636             /* if the transmit actually failed, or returned some status */
1637             if ((!(ac_status & AC_SW_OK)) || (ac_status & 0xfff)) {
1638                 if (ac_status & (TC_COLLISION | TC_CLS | TC_DMA)) {
1639                     ifp->if_oerrors++;
1640                 }
1641
1642                 /* count collisions */
1643                 ifp->if_collisions += (ac_status & 0xf);
1644                 /* if TC_COLLISION set and collision count zero, 16 collisions */
1645                 if ((ac_status & 0x20) == 0x20) {
1646                     ifp->if_collisions += 0x10;
1647                 }
1648             }
1649             sc->tbusy = 0;
1650             callout_stop(&sc->watchdog_ch);
1651             ifp->if_flags &= ~IFF_OACTIVE;
1652             wlstart(ifp);
1653         }
1654     }
1655 }
1656
1657 /*
1658  * wlrcv:
1659  *
1660  *      This routine is called by the interrupt handler to initiate a
1661  *      packet transfer from the board to the "if" layer above this
1662  *      driver.  This routine checks if a buffer has been successfully
1663  *      received by the WaveLAN.  If so, the routine wlread is called
1664  *      to do the actual transfer of the board data (including the
1665  *      ethernet header) into a packet (consisting of an mbuf chain).
1666  *
1667  * input        : softc pointer for this interface
1668  * output       : if a packet is available, it is "sent up"
1669  *
1670  */
1671 static void
1672 wlrcv(struct wl_softc *sc)
1673 {
1674     short       base = sc->base;
1675     u_short     fd_p, status, offset, link_offset;
1676
1677 #ifdef WLDEBUG
1678     if (sc->wl_if.if_flags & IFF_DEBUG)
1679         if_printf(&sc->wl_if, "entered wlrcv()\n");
1680 #endif
1681     for (fd_p = sc->begin_fd; fd_p != I82586NULL; fd_p = sc->begin_fd) {
1682
1683         outw(PIOR0(base), fd_p + 0);    /* address of status */
1684         status = inw(PIOP0(base));
1685         outw(PIOR1(base), fd_p + 4);    /* address of link_offset */
1686         link_offset = inw(PIOP1(base));
1687         offset = inw(PIOP1(base));      /* rbd_offset */
1688         if (status == 0xffff || offset == 0xffff /*I82586NULL*/) {
1689             if (wlhwrst(sc) != TRUE)
1690                 if_printf(&sc->wl_if, "rcv(): hwrst ffff trouble.\n");
1691             return;
1692         } else if (status & AC_SW_C) {
1693             if (status == (RFD_DONE|RFD_RSC)) {
1694                 /* lost one */
1695 #ifdef  WLDEBUG
1696                 if (sc->wl_if.if_flags & IFF_DEBUG)
1697                     if_printf(&sc->wl_if, "RCV: RSC %x\n", status);
1698 #endif
1699                 sc->wl_if.if_ierrors++;
1700             } else if (!(status & RFD_OK)) {
1701                 if_printf(&sc->wl_if, "RCV: !OK %x\n", status);
1702                 sc->wl_if.if_ierrors++;
1703             } else if (status & 0xfff) {        /* can't happen */
1704                 if_printf(&sc->wl_if, "RCV: ERRs %x\n", status);
1705                 sc->wl_if.if_ierrors++;
1706             } else if (!wlread(sc, fd_p))
1707                 return;
1708
1709             if (!wlrequeue(sc, fd_p)) {
1710                 /* abort on chain error */
1711                 if (wlhwrst(sc) != TRUE)
1712                     if_printf(&sc->wl_if, "rcv(): hwrst trouble.\n");
1713                 return;
1714             }
1715             sc->begin_fd = link_offset;
1716         } else {
1717             break;
1718         }
1719     }
1720 }
1721
1722 /*
1723  * wlrequeue:
1724  *
1725  *      This routine puts rbd's used in the last receive back onto the
1726  *      free list for the next receive.
1727  *
1728  */
1729 static int
1730 wlrequeue(struct wl_softc *sc, u_short fd_p)
1731 {
1732     short               base = sc->base;
1733     fd_t                fd;
1734     u_short             l_rbdp, f_rbdp, rbd_offset;
1735
1736     outw(PIOR0(base), fd_p + 6);
1737     rbd_offset = inw(PIOP0(base));
1738     if ((f_rbdp = rbd_offset) != I82586NULL) {
1739         l_rbdp = f_rbdp;
1740         for(;;) {
1741             outw(PIOR0(base), l_rbdp + 0);      /* address of status */
1742             if(inw(PIOP0(base)) & RBD_SW_EOF)
1743                 break;
1744             outw(PIOP0(base), 0);
1745             outw(PIOR0(base), l_rbdp + 2);      /* next_rbd_offset */
1746             if((l_rbdp = inw(PIOP0(base))) == I82586NULL)
1747                 break;
1748         }
1749         outw(PIOP0(base), 0);
1750         outw(PIOR0(base), l_rbdp + 2);          /* next_rbd_offset */
1751         outw(PIOP0(base), I82586NULL);
1752         outw(PIOR0(base), l_rbdp + 8);          /* address of size */
1753         outw(PIOP0(base), inw(PIOP0(base)) | AC_CW_EL);
1754         outw(PIOR0(base), sc->end_rbd + 2);
1755         outw(PIOP0(base), f_rbdp);              /* end_rbd->next_rbd_offset */
1756         outw(PIOR0(base), sc->end_rbd + 8);     /* size */
1757         outw(PIOP0(base), inw(PIOP0(base)) & ~AC_CW_EL);
1758         sc->end_rbd = l_rbdp;
1759     }
1760
1761     fd.status = 0;
1762     fd.command = AC_CW_EL;
1763     fd.link_offset = I82586NULL;
1764     fd.rbd_offset = I82586NULL;
1765     outw(PIOR1(base), fd_p);
1766     outsw(PIOP1(base), &fd, 8/2);
1767
1768     outw(PIOR1(base), sc->end_fd + 2);  /* addr of command */
1769     outw(PIOP1(base), 0);               /* command = 0 */
1770     outw(PIOP1(base), fd_p);            /* end_fd->link_offset = fd_p */
1771     sc->end_fd = fd_p;
1772
1773     return 1;
1774 }
1775
1776 #ifdef  WLDEBUG
1777 static int xmt_debug = 0;
1778 #endif  /* WLDEBUG */
1779
1780 /*
1781  * wlxmt:
1782  *
1783  *      This routine fills in the appropriate registers and memory
1784  *      locations on the WaveLAN board and starts the board off on
1785  *      the transmit.
1786  *
1787  * input        : softc pointer for this interface, and a pointer to the mbuf
1788  * output       : board memory and registers are set for xfer and attention
1789  *
1790  */
1791 static void
1792 wlxmt(struct wl_softc *sc, struct mbuf *m)
1793 {
1794     u_short             xmtdata_p = OFFSET_TBUF;
1795     u_short             xmtshort_p;
1796     struct      mbuf                    *tm_p = m;
1797     struct ether_header *eh_p = mtod(m, struct ether_header *);
1798     u_char                              *mb_p = mtod(m, u_char *) + sizeof(struct ether_header);
1799     u_short                             count = m->m_len - sizeof(struct ether_header);
1800     ac_t                                cb;
1801     u_short                             tbd_p = OFFSET_TBD;
1802     u_short                             len, clen = 0;
1803     short                               base = sc->base;
1804     int                                 spin;
1805
1806 #ifdef WLDEBUG
1807     if (sc->wl_if.if_flags & IFF_DEBUG)
1808         if_printf(&sc->wl_if, "entered wlxmt()\n");
1809 #endif
1810
1811     cb.ac_status = 0;
1812     cb.ac_command = (AC_CW_EL|AC_TRANSMIT|AC_CW_I);
1813     cb.ac_link_offset = I82586NULL;
1814     outw(PIOR1(base), OFFSET_CU);
1815     outsw(PIOP1(base), &cb, 6/2);
1816     outw(PIOP1(base), OFFSET_TBD);      /* cb.cmd.transmit.tbd_offset */
1817     outsw(PIOP1(base), eh_p->ether_dhost, WAVELAN_ADDR_SIZE/2);
1818     outw(PIOP1(base), eh_p->ether_type);
1819
1820 #ifdef  WLDEBUG
1821     if (sc->wl_if.if_flags & IFF_DEBUG) {
1822         if (xmt_debug) {
1823             if_printf(&sc->wl_if, "XMT    mbuf: L%d @%p ", count, (void *)mb_p);
1824             printf("ether type %x\n", eh_p->ether_type);
1825         }
1826     }
1827 #endif  /* WLDEBUG */
1828     outw(PIOR0(base), OFFSET_TBD);
1829     outw(PIOP0(base), 0);               /* act_count */
1830     outw(PIOR1(base), OFFSET_TBD + 4);
1831     outw(PIOP1(base), xmtdata_p);       /* buffer_addr */
1832     outw(PIOP1(base), 0);               /* buffer_base */
1833     for (;;) {
1834         if (count) {
1835             if (clen + count > WAVELAN_MTU)
1836                 break;
1837             if (count & 1)
1838                 len = count + 1;
1839             else
1840                 len = count;
1841             outw(PIOR1(base), xmtdata_p);
1842             outsw(PIOP1(base), mb_p, len/2);
1843             clen += count;
1844             outw(PIOR0(base), tbd_p);  /* address of act_count */
1845             outw(PIOP0(base), inw(PIOP0(base)) + count);
1846             xmtdata_p += len;
1847             if ((tm_p = tm_p->m_next) == (struct mbuf *)0)
1848                 break;
1849             if (count & 1) {
1850                 /* go to the next descriptor */
1851                 outw(PIOR0(base), tbd_p + 2);
1852                 tbd_p += sizeof (tbd_t);
1853                 outw(PIOP0(base), tbd_p); /* next_tbd_offset */
1854                 outw(PIOR0(base), tbd_p);
1855                 outw(PIOP0(base), 0);   /* act_count */
1856                 outw(PIOR1(base), tbd_p + 4);
1857                 outw(PIOP1(base), xmtdata_p); /* buffer_addr */
1858                 outw(PIOP1(base), 0);         /* buffer_base */
1859                 /* at the end -> coallesce remaining mbufs */
1860                 if (tbd_p == OFFSET_TBD + (N_TBD-1) * sizeof (tbd_t)) {
1861                     wlsftwsleaze(&count, &mb_p, &tm_p);
1862                     continue;
1863                 }
1864                 /* next mbuf short -> coallesce as needed */
1865                 if ( (tm_p->m_next == (struct mbuf *) 0) ||
1866 #define HDW_THRESHOLD 55
1867                      tm_p->m_len > HDW_THRESHOLD)
1868                     /* ok */;
1869                 else {
1870                     wlhdwsleaze(&count, &mb_p, &tm_p);
1871                     continue;
1872                 }
1873             }
1874         } else if ((tm_p = tm_p->m_next) == (struct mbuf *)0)
1875             break;
1876         count = tm_p->m_len;
1877         mb_p = mtod(tm_p, u_char *);
1878 #ifdef  WLDEBUG
1879         if (sc->wl_if.if_flags & IFF_DEBUG)
1880             if (xmt_debug)
1881                 if_printf(&sc->wl_if, "mbuf+ L%d @%p ", count, (void *)mb_p);
1882 #endif  /* WLDEBUG */
1883     }
1884 #ifdef  WLDEBUG
1885     if (sc->wl_if.if_flags & IFF_DEBUG)
1886         if (xmt_debug)
1887             if_printf(&sc->wl_if, "CLEN = %d\n", clen);
1888 #endif  /* WLDEBUG */
1889     outw(PIOR0(base), tbd_p);
1890     if (clen < ETHERMIN) {
1891         outw(PIOP0(base), inw(PIOP0(base)) + ETHERMIN - clen);
1892         outw(PIOR1(base), xmtdata_p);
1893         for (xmtshort_p = xmtdata_p; clen < ETHERMIN; clen += 2)
1894             outw(PIOP1(base), 0);
1895     }
1896     outw(PIOP0(base), inw(PIOP0(base)) | TBD_SW_EOF);
1897     outw(PIOR0(base), tbd_p + 2);
1898     outw(PIOP0(base), I82586NULL);
1899 #ifdef  WLDEBUG
1900     if (sc->wl_if.if_flags & IFF_DEBUG) {
1901         if (xmt_debug) {
1902             wltbd(sc);
1903             printf("\n");
1904         }
1905     }
1906 #endif  /* WLDEBUG */
1907
1908     outw(PIOR0(base), OFFSET_SCB + 2);  /* address of scb_command */
1909     /*
1910      * wait for 586 to clear previous command, complain if it takes
1911      * too long
1912      */
1913     for (spin = 1;;spin = (spin + 1) % 10000) {
1914         if (inw(PIOP0(base)) == 0) {            /* it's done, we can go */
1915             break;
1916         }
1917         if ((spin == 0) && xmt_watch) {         /* not waking up, and we care */
1918             if_printf(&sc->wl_if, "slow accepting xmit\n");
1919         }
1920     }
1921     outw(PIOP0(base), SCB_CU_STRT);             /* new command */
1922     SET_CHAN_ATTN(sc);
1923
1924     m_freem(m);
1925
1926     /* XXX
1927      * Pause to avoid transmit overrun problems.
1928      * The required delay tends to vary with platform type, and may be
1929      * related to interrupt loss.
1930      */
1931     if (wl_xmit_delay) {
1932         DELAY(wl_xmit_delay);
1933     }
1934 }
1935
1936 /*
1937  * wlbldru:
1938  *
1939  *      This function builds the linear linked lists of fd's and
1940  *      rbd's.  Based on page 4-32 of 1986 Intel microcom handbook.
1941  *
1942  */
1943 static u_short
1944 wlbldru(struct wl_softc *sc)
1945 {
1946     short       base = sc->base;
1947     fd_t        fd;
1948     rbd_t       rbd;
1949     u_short     fd_p = OFFSET_RU;
1950     u_short     rbd_p = OFFSET_RBD;
1951     int         i;
1952
1953     sc->begin_fd = fd_p;
1954     for(i = 0; i < N_FD; i++) {
1955         fd.status = 0;
1956         fd.command = 0;
1957         fd.link_offset = fd_p + sizeof(fd_t);
1958         fd.rbd_offset = I82586NULL;
1959         outw(PIOR1(base), fd_p);
1960         outsw(PIOP1(base), &fd, 8/2);
1961         fd_p = fd.link_offset;
1962     }
1963     fd_p -= sizeof(fd_t);
1964     sc->end_fd = fd_p;
1965     outw(PIOR1(base), fd_p + 2);
1966     outw(PIOP1(base), AC_CW_EL);        /* command */
1967     outw(PIOP1(base), I82586NULL);      /* link_offset */
1968     fd_p = OFFSET_RU;
1969
1970     outw(PIOR0(base), fd_p + 6);        /* address of rbd_offset */
1971     outw(PIOP0(base), rbd_p);
1972     outw(PIOR1(base), rbd_p);
1973     for(i = 0; i < N_RBD; i++) {
1974         rbd.status = 0;
1975         rbd.buffer_addr = rbd_p + sizeof(rbd_t) + 2;
1976         rbd.buffer_base = 0;
1977         rbd.size = RCVBUFSIZE;
1978         if (i != N_RBD-1) {
1979             rbd_p += sizeof(ru_t);
1980             rbd.next_rbd_offset = rbd_p;
1981         } else {
1982             rbd.next_rbd_offset = I82586NULL;
1983             rbd.size |= AC_CW_EL;
1984             sc->end_rbd = rbd_p;
1985         }
1986         outsw(PIOP1(base), &rbd, sizeof(rbd_t)/2);
1987         outw(PIOR1(base), rbd_p);
1988     }
1989     return sc->begin_fd;
1990 }
1991
1992 /*
1993  * wlrustrt:
1994  *
1995  *      This routine starts the receive unit running.  First checks if the
1996  *      board is actually ready, then the board is instructed to receive
1997  *      packets again.
1998  *
1999  */
2000 static void
2001 wlrustrt(struct wl_softc *sc)
2002 {
2003     short               base = sc->base;
2004     u_short             rfa;
2005
2006 #ifdef WLDEBUG
2007     if (sc->wl_if.if_flags & IFF_DEBUG)
2008         if_printf(&sc->wl_if, "entered wlrustrt()\n");
2009 #endif
2010     outw(PIOR0(base), OFFSET_SCB);
2011     if (inw(PIOP0(base)) & SCB_RUS_READY){
2012         if_printf(&sc->wl_if, "wlrustrt: RUS_READY\n");
2013         return;
2014     }
2015
2016     outw(PIOR0(base), OFFSET_SCB + 2);
2017     outw(PIOP0(base), SCB_RU_STRT);             /* command */
2018     rfa = wlbldru(sc);
2019     outw(PIOR0(base), OFFSET_SCB + 6);  /* address of scb_rfa_offset */
2020     outw(PIOP0(base), rfa);
2021
2022     SET_CHAN_ATTN(sc);
2023 }
2024
2025 /*
2026  * wldiag:
2027  *
2028  *      This routine does a 586 op-code number 7, and obtains the
2029  *      diagnose status for the WaveLAN.
2030  *
2031  */
2032 static int
2033 wldiag(struct wl_softc *sc)
2034 {
2035     short base = sc->base;
2036     short status;
2037
2038 #ifdef WLDEBUG
2039     if (sc->wl_if.if_flags & IFF_DEBUG)
2040         if_printf(&sc->wl_if, "entered wldiag()\n");
2041 #endif
2042     outw(PIOR0(base), OFFSET_SCB);
2043     status = inw(PIOP0(base));
2044     if (status & SCB_SW_INT) {
2045                 /* state is 2000 which seems ok
2046                    if_printf(&sc->wl_if, "diag(): unexpected initial state %\n",
2047                    inw(PIOP0(base)));
2048                 */
2049         wlack(sc);
2050     }
2051     outw(PIOR1(base), OFFSET_CU);
2052     outw(PIOP1(base), 0);                       /* ac_status */
2053     outw(PIOP1(base), AC_DIAGNOSE|AC_CW_EL);/* ac_command */
2054     if(wlcmd(sc, "diag()") == 0)
2055         return 0;
2056     outw(PIOR0(base), OFFSET_CU);
2057     if (inw(PIOP0(base)) & 0x0800) {
2058         if_printf(&sc->wl_if, "i82586 Self Test failed!\n");
2059         return 0;
2060     }
2061     return TRUE;
2062 }
2063
2064 /*
2065  * wlconfig:
2066  *
2067  *      This routine does a standard config of the WaveLAN board.
2068  *
2069  */
2070 static int
2071 wlconfig(struct wl_softc *sc)
2072 {
2073     configure_t configure;
2074     short base = sc->base;
2075
2076 #if     MULTICAST
2077 #if defined(__DragonFly__) || (defined(__FreeBSD__) && __FreeBSD_version >= 300000)
2078     struct ifmultiaddr *ifma;
2079     u_char *addrp;
2080 #else
2081     struct ether_multi *enm;
2082     struct ether_multistep step;
2083 #endif
2084     int cnt = 0;
2085 #endif  /* MULTICAST */
2086
2087 #ifdef WLDEBUG
2088     if (sc->wl_if.if_flags & IFF_DEBUG)
2089         if_printf(&sc->wl_if, "entered wlconfig()\n");
2090 #endif
2091     outw(PIOR0(base), OFFSET_SCB);
2092     if (inw(PIOP0(base)) & SCB_SW_INT) {
2093         /*
2094           if_printf(&sc->wl_if, "config(): unexpected initial state %x\n",
2095           inw(PIOP0(base)));
2096           */
2097     }
2098     wlack(sc);
2099
2100     outw(PIOR1(base), OFFSET_CU);
2101     outw(PIOP1(base), 0);                               /* ac_status */
2102     outw(PIOP1(base), AC_CONFIGURE|AC_CW_EL);   /* ac_command */
2103
2104 /* jrb hack */
2105     configure.fifolim_bytecnt   = 0x080c;
2106     configure.addrlen_mode      = 0x0600;
2107     configure.linprio_interframe        = 0x2060;
2108     configure.slot_time         = 0xf200;
2109     configure.hardware          = 0x0008;       /* tx even w/o CD */
2110     configure.min_frame_len     = 0x0040;
2111 #if 0
2112     /* This is the configuration block suggested by Marc Meertens
2113      * <mmeerten@obelix.utrecht.NCR.COM> in an e-mail message to John
2114      * Ioannidis on 10 Nov 92.
2115      */
2116     configure.fifolim_bytecnt   = 0x040c;
2117     configure.addrlen_mode      = 0x0600;
2118     configure.linprio_interframe        = 0x2060;
2119     configure.slot_time         = 0xf000;
2120     configure.hardware          = 0x0008;       /* tx even w/o CD */
2121     configure.min_frame_len     = 0x0040;
2122 #else
2123     /*
2124      * below is the default board configuration from p2-28 from 586 book
2125      */
2126     configure.fifolim_bytecnt   = 0x080c;
2127     configure.addrlen_mode      = 0x2600;
2128     configure.linprio_interframe        = 0x7820;       /* IFS=120, ACS=2 */
2129     configure.slot_time         = 0xf00c;       /* slottime=12    */
2130     configure.hardware          = 0x0008;       /* tx even w/o CD */
2131     configure.min_frame_len     = 0x0040;
2132 #endif
2133     if(sc->mode & (MOD_PROM | MOD_ENAL)) {
2134         configure.hardware |= 1;
2135     }
2136     outw(PIOR1(base), OFFSET_CU + 6);
2137     outsw(PIOP1(base), &configure, sizeof(configure_t)/2);
2138
2139     if(wlcmd(sc, "config()-configure") == 0)
2140         return 0;
2141 #if     MULTICAST
2142     outw(PIOR1(base), OFFSET_CU);
2143     outw(PIOP1(base), 0);                               /* ac_status */
2144     outw(PIOP1(base), AC_MCSETUP|AC_CW_EL);             /* ac_command */
2145     outw(PIOR1(base), OFFSET_CU + 8);
2146 #if defined(__DragonFly__) || (defined(__FreeBSD__) && __FreeBSD_version >= 300000)
2147     LIST_FOREACH(ifma, &sc->wl_if.if_multiaddrs, ifma_link) {
2148         if (ifma->ifma_addr->sa_family != AF_LINK)
2149             continue;
2150
2151         addrp = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
2152         outw(PIOP1(base), addrp[0] + (addrp[1] << 8));
2153         outw(PIOP1(base), addrp[2] + (addrp[3] << 8));
2154         outw(PIOP1(base), addrp[4] + (addrp[5] << 8));
2155         ++cnt;
2156     }
2157 #else
2158     ETHER_FIRST_MULTI(step, &sc->wl_ac, enm);
2159     while (enm != NULL) {
2160         unsigned int lo, hi;
2161         /* break if setting a multicast range, else we would crash */
2162         if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
2163                 break;
2164         }
2165         lo = (enm->enm_addrlo[3] << 16) + (enm->enm_addrlo[4] << 8)
2166             + enm->enm_addrlo[5];
2167         hi = (enm->enm_addrhi[3] << 16) + (enm->enm_addrhi[4] << 8)
2168             + enm->enm_addrhi[5];
2169         while(lo <= hi) {
2170             outw(PIOP1(base),enm->enm_addrlo[0] +
2171                  (enm->enm_addrlo[1] << 8));
2172             outw(PIOP1(base),enm->enm_addrlo[2] +
2173                  ((lo >> 8) & 0xff00));
2174             outw(PIOP1(base), ((lo >> 8) & 0xff) +
2175                  ((lo << 8) & 0xff00));
2176 /* #define MCASTDEBUG */
2177 #ifdef MCASTDEBUG
2178 printf("mcast_addr[%d,%d,%d] %x %x %x %x %x %x\n", lo, hi, cnt,
2179                 enm->enm_addrlo[0],
2180                 enm->enm_addrlo[1],
2181                 enm->enm_addrlo[2],
2182                 enm->enm_addrlo[3],
2183                 enm->enm_addrlo[4],
2184                 enm->enm_addrlo[5]);
2185 #endif
2186             ++cnt;
2187             ++lo;
2188         }
2189         ETHER_NEXT_MULTI(step, enm);
2190     }
2191 #endif
2192     outw(PIOR1(base), OFFSET_CU + 6);           /* mc-cnt */
2193     outw(PIOP1(base), cnt * WAVELAN_ADDR_SIZE);
2194     if(wlcmd(sc, "config()-mcaddress") == 0)
2195         return 0;
2196 #endif  /* MULTICAST */
2197
2198     outw(PIOR1(base), OFFSET_CU);
2199     outw(PIOP1(base), 0);                               /* ac_status */
2200     outw(PIOP1(base), AC_IASETUP|AC_CW_EL);             /* ac_command */
2201     outw(PIOR1(base), OFFSET_CU + 6);
2202     outsw(PIOP1(base), sc->wl_addr, WAVELAN_ADDR_SIZE/2);
2203
2204     if(wlcmd(sc, "config()-address") == 0)
2205         return(0);
2206
2207     wlinitmmc(sc);
2208
2209     return(1);
2210 }
2211
2212 /*
2213  * wlcmd:
2214  *
2215  * Set channel attention bit and busy wait until command has
2216  * completed. Then acknowledge the command completion.
2217  */
2218 static int
2219 wlcmd(struct wl_softc *sc, const char *str)
2220 {
2221     short base = sc->base;
2222     int i;
2223
2224     outw(PIOR0(base), OFFSET_SCB + 2);  /* address of scb_command */
2225     outw(PIOP0(base), SCB_CU_STRT);
2226
2227     SET_CHAN_ATTN(sc);
2228
2229     outw(PIOR0(base), OFFSET_CU);
2230     for(i = 0; i < 0xffff; i++)
2231         if (inw(PIOP0(base)) & AC_SW_C)
2232             break;
2233     if (i == 0xffff || !(inw(PIOP0(base)) & AC_SW_OK)) {
2234         if_printf(&sc->wl_if, "%s failed; status = %d, inw = %x, outw = %x\n",
2235                   str, inw(PIOP0(base)) & AC_SW_OK, inw(PIOP0(base)),
2236                   inw(PIOR0(base)));
2237         outw(PIOR0(base), OFFSET_SCB);
2238         printf("scb_status %x\n", inw(PIOP0(base)));
2239         outw(PIOR0(base), OFFSET_SCB+2);
2240         printf("scb_command %x\n", inw(PIOP0(base)));
2241         outw(PIOR0(base), OFFSET_SCB+4);
2242         printf("scb_cbl %x\n", inw(PIOP0(base)));
2243         outw(PIOR0(base), OFFSET_CU+2);
2244         printf("cu_cmd %x\n", inw(PIOP0(base)));
2245         return(0);
2246     }
2247
2248     outw(PIOR0(base), OFFSET_SCB);
2249     if ((inw(PIOP0(base)) & SCB_SW_INT) && (inw(PIOP0(base)) != SCB_SW_CNA)) {
2250         /*
2251           if_printf(&sc->wl_if, "%s: unexpected final state %x\n",
2252           str, inw(PIOP0(base)));
2253           */
2254     }
2255     wlack(sc);
2256     return(TRUE);
2257 }
2258
2259 /*
2260  * wlack: if the 82596 wants attention because it has finished
2261  * sending or receiving a packet, acknowledge its desire and
2262  * return bits indicating the kind of attention. wlack() returns
2263  * these bits so that the caller can service exactly the
2264  * conditions that wlack() acknowledged.
2265  */
2266 static int
2267 wlack(struct wl_softc *sc)
2268 {
2269     int i;
2270     u_short cmd;
2271     short base = sc->base;
2272
2273     outw(PIOR1(base), OFFSET_SCB);
2274     if(!(cmd = (inw(PIOP1(base)) & SCB_SW_INT)))
2275         return(0);
2276 #ifdef WLDEBUG
2277     if (sc->wl_if.if_flags & IFF_DEBUG)
2278         if_printf(&sc->wl_if, "doing a wlack()\n");
2279 #endif
2280     outw(PIOP1(base), cmd);
2281     SET_CHAN_ATTN(sc);
2282     outw(PIOR0(base), OFFSET_SCB + 2);  /* address of scb_command */
2283     for (i = 1000000; inw(PIOP0(base)) && (i-- > 0); );
2284     if (i < 1)
2285         if_printf(&sc->wl_if, "wlack(): board not accepting command.\n");
2286     return(cmd);
2287 }
2288
2289 static void
2290 wltbd(struct wl_softc *sc)
2291 {
2292     short               base = sc->base;
2293     u_short             tbd_p = OFFSET_TBD;
2294     tbd_t               tbd;
2295     int                 i = 0;
2296     int                 sum = 0;
2297
2298     for (;;) {
2299         outw(PIOR1(base), tbd_p);
2300         insw(PIOP1(base), &tbd, sizeof(tbd_t)/2);
2301         sum += (tbd.act_count & ~TBD_SW_EOF);
2302         printf("%d: addr %x, count %d (%d), next %x, base %x\n",
2303                i++, tbd.buffer_addr,
2304                (tbd.act_count & ~TBD_SW_EOF), sum,
2305                tbd.next_tbd_offset, tbd.buffer_base);
2306         if (tbd.act_count & TBD_SW_EOF)
2307             break;
2308         tbd_p = tbd.next_tbd_offset;
2309     }
2310 }
2311
2312 static void
2313 wlhdwsleaze(u_short *countp, u_char **mb_pp, struct mbuf **tm_pp)
2314 {
2315     struct mbuf *tm_p = *tm_pp;
2316     u_char              *mb_p = *mb_pp;
2317     u_short             count = 0;
2318     u_char              *cp;
2319     int         len;
2320
2321     /*
2322      * can we get a run that will be coallesced or
2323      * that terminates before breaking
2324      */
2325     do {
2326         count += tm_p->m_len;
2327         if (tm_p->m_len & 1)
2328             break;
2329     } while ((tm_p = tm_p->m_next) != (struct mbuf *)0);
2330     if ( (tm_p == (struct mbuf *)0) ||
2331          count > HDW_THRESHOLD) {
2332         *countp = (*tm_pp)->m_len;
2333         *mb_pp = mtod((*tm_pp), u_char *);
2334         return;
2335     }
2336
2337     /* we need to copy */
2338     tm_p = *tm_pp;
2339     mb_p = *mb_pp;
2340     count = 0;
2341     cp = (u_char *) t_packet;
2342     for (;;) {
2343         bcopy(mtod(tm_p, u_char *), cp, len = tm_p->m_len);
2344         count += len;
2345         if (count > HDW_THRESHOLD)
2346                         break;
2347         cp += len;
2348         if (tm_p->m_next == (struct mbuf *)0)
2349             break;
2350         tm_p = tm_p->m_next;
2351     }
2352     *countp = count;
2353     *mb_pp = (u_char *) t_packet;
2354     *tm_pp = tm_p;
2355 }
2356
2357 static void
2358 wlsftwsleaze(u_short *countp, u_char **mb_pp, struct mbuf **tm_pp)
2359 {
2360     struct mbuf *tm_p = *tm_pp;
2361     u_short             count = 0;
2362     u_char              *cp = (u_char *) t_packet;
2363     int                 len;
2364
2365     /* we need to copy */
2366     for (;;) {
2367         bcopy(mtod(tm_p, u_char *), cp, len = tm_p->m_len);
2368         count += len;
2369         cp += len;
2370         if (tm_p->m_next == (struct mbuf *)0)
2371             break;
2372         tm_p = tm_p->m_next;
2373     }
2374
2375     *countp = count;
2376     *mb_pp = (u_char *) t_packet;
2377     *tm_pp = tm_p;
2378 }
2379
2380 static void
2381 wlmmcstat(struct wl_softc *sc)
2382 {
2383     short       base = sc->base;
2384     u_short tmp;
2385
2386     if_printf(&sc->wl_if, "DCE_STATUS: 0x%x, ",
2387               wlmmcread(base,MMC_DCE_STATUS) & 0x0f);
2388     tmp = wlmmcread(base,MMC_CORRECT_NWID_H) << 8;
2389     tmp |= wlmmcread(base,MMC_CORRECT_NWID_L);
2390     printf("Correct NWID's: %d, ", tmp);
2391     tmp = wlmmcread(base,MMC_WRONG_NWID_H) << 8;
2392     tmp |= wlmmcread(base,MMC_WRONG_NWID_L);
2393     printf("Wrong NWID's: %d\n", tmp);
2394     printf("THR_PRE_SET: 0x%x, ", wlmmcread(base,MMC_THR_PRE_SET));
2395     printf("SIGNAL_LVL: %d, SILENCE_LVL: %d\n",
2396            wlmmcread(base,MMC_SIGNAL_LVL),
2397            wlmmcread(base,MMC_SILENCE_LVL));
2398     printf("SIGN_QUAL: 0x%x, NETW_ID: %x:%x, DES: %d\n",
2399            wlmmcread(base,MMC_SIGN_QUAL),
2400            wlmmcread(base,MMC_NETW_ID_H),
2401            wlmmcread(base,MMC_NETW_ID_L),
2402            wlmmcread(base,MMC_DES_AVAIL));
2403 }
2404
2405 static u_short
2406 wlmmcread(u_int base, u_short reg)
2407 {
2408     while(inw(HASR(base)) & HASR_MMC_BUSY) ;
2409     outw(MMCR(base),reg << 1);
2410     while(inw(HASR(base)) & HASR_MMC_BUSY) ;
2411     return (u_short)inw(MMCR(base)) >> 8;
2412 }
2413
2414 static void
2415 getsnr(struct wl_softc *sc)
2416 {
2417     MMC_WRITE(MMC_FREEZE,1);
2418     /*
2419      * SNR retrieval procedure :
2420      *
2421      * read signal level : wlmmcread(base, MMC_SIGNAL_LVL);
2422      * read silence level : wlmmcread(base, MMC_SILENCE_LVL);
2423      */
2424     MMC_WRITE(MMC_FREEZE,0);
2425     /*
2426      * SNR is signal:silence ratio.
2427      */
2428 }
2429
2430 /*
2431 ** wlgetpsa
2432 **
2433 ** Reads the psa for the wavelan at (base) into (buf)
2434 */
2435 static void
2436 wlgetpsa(int base, u_char *buf)
2437 {
2438     int i;
2439
2440     PCMD(base, HACR_DEFAULT & ~HACR_16BITS);
2441     PCMD(base, HACR_DEFAULT & ~HACR_16BITS);
2442
2443     for (i = 0; i < 0x40; i++) {
2444         outw(PIOR2(base), i);
2445         buf[i] = inb(PIOP2(base));
2446     }
2447     PCMD(base, HACR_DEFAULT);
2448     PCMD(base, HACR_DEFAULT);
2449 }
2450
2451 /*
2452 ** wlsetpsa
2453 **
2454 ** Writes the psa for wavelan (unit) from the softc back to the
2455 ** board.  Updates the CRC and sets the CRC OK flag.
2456 **
2457 ** Do not call this when the board is operating, as it doesn't
2458 ** preserve the hacr.
2459 */
2460 static void
2461 wlsetpsa(struct wl_softc *sc)
2462 {
2463     short       base = sc->base;
2464     int         i;
2465     u_short     crc;
2466
2467     crc = wlpsacrc(sc->psa);    /* calculate CRC of PSA */
2468     sc->psa[WLPSA_CRCLOW] = crc & 0xff;
2469     sc->psa[WLPSA_CRCHIGH] = (crc >> 8) & 0xff;
2470     sc->psa[WLPSA_CRCOK] = 0x55;        /* default to 'bad' until programming complete */
2471
2472     PCMD(base, HACR_DEFAULT & ~HACR_16BITS);
2473     PCMD(base, HACR_DEFAULT & ~HACR_16BITS);
2474
2475     for (i = 0; i < 0x40; i++) {
2476         DELAY(DELAYCONST);
2477         outw(PIOR2(base),i);  /* write param memory */
2478         DELAY(DELAYCONST);
2479         outb(PIOP2(base), sc->psa[i]);
2480     }
2481     DELAY(DELAYCONST);
2482     outw(PIOR2(base),WLPSA_CRCOK);  /* update CRC flag*/
2483     DELAY(DELAYCONST);
2484     sc->psa[WLPSA_CRCOK] = 0xaa;        /* OK now */
2485     outb(PIOP2(base), 0xaa);    /* all OK */
2486     DELAY(DELAYCONST);
2487
2488     PCMD(base, HACR_DEFAULT);
2489     PCMD(base, HACR_DEFAULT);
2490 }
2491
2492 /*
2493 ** CRC routine provided by Christopher Giordano <cgiordan@gdeb.com>,
2494 ** from original code by Tomi Mikkonen (tomitm@remedy.fi)
2495 */
2496
2497 static u_int crc16_table[16] = {
2498     0x0000, 0xCC01, 0xD801, 0x1400,
2499     0xF001, 0x3C00, 0x2800, 0xE401,
2500     0xA001, 0x6C00, 0x7800, 0xB401,
2501     0x5000, 0x9C01, 0x8801, 0x4400
2502 };
2503
2504 static u_short
2505 wlpsacrc(u_char *buf)
2506 {
2507     u_short     crc = 0;
2508     int         i, r1;
2509
2510     for (i = 0; i < 0x3d; i++, buf++) {
2511         /* lower 4 bits */
2512         r1 = crc16_table[crc & 0xF];
2513         crc = (crc >> 4) & 0x0FFF;
2514         crc = crc ^ r1 ^ crc16_table[*buf & 0xF];
2515
2516         /* upper 4 bits */
2517         r1 = crc16_table[crc & 0xF];
2518         crc = (crc >> 4) & 0x0FFF;
2519         crc = crc ^ r1 ^ crc16_table[(*buf >> 4) & 0xF];
2520     }
2521     return(crc);
2522 }
2523 #ifdef WLCACHE
2524
2525 /*
2526  * wl_cache_store
2527  *
2528  * take input packet and cache various radio hw characteristics
2529  * indexed by MAC address.
2530  *
2531  * Some things to think about:
2532  *      note that no space is malloced.
2533  *      We might hash the mac address if the cache were bigger.
2534  *      It is not clear that the cache is big enough.
2535  *              It is also not clear how big it should be.
2536  *      The cache is IP-specific.  We don't care about that as
2537  *              we want it to be IP-specific.
2538  *      The last N recv. packets are saved.  This will tend
2539  *              to reward agents and mobile hosts that beacon.
2540  *              That is probably fine for mobile ip.
2541  */
2542
2543 /* globals for wavelan signal strength cache */
2544 /* this should go into softc structure above.
2545 */
2546
2547 /* set true if you want to limit cache items to broadcast/mcast
2548  * only packets (not unicast)
2549  */
2550 static int wl_cache_mcastonly = 1;
2551 SYSCTL_INT(_machdep, OID_AUTO, wl_cache_mcastonly, CTLFLAG_RW,
2552         &wl_cache_mcastonly, 0, "");
2553
2554 /* set true if you want to limit cache items to IP packets only
2555 */
2556 static int wl_cache_iponly = 1;
2557 SYSCTL_INT(_machdep, OID_AUTO, wl_cache_iponly, CTLFLAG_RW,
2558         &wl_cache_iponly, 0, "");
2559
2560 /* zero out the cache
2561 */
2562 static void
2563 wl_cache_zero(struct wl_softc *sc)
2564 {
2565         bzero(&sc->w_sigcache[0], sizeof(struct w_sigcache) * MAXCACHEITEMS);
2566         sc->w_sigitems = 0;
2567         sc->w_nextcache = 0;
2568         sc->w_wrapindex = 0;
2569 }
2570
2571 /* store hw signal info in cache.
2572  * index is MAC address, but an ip src gets stored too
2573  * There are two filters here controllable via sysctl:
2574  *      throw out unicast (on by default, but can be turned off)
2575  *      throw out non-ip (on by default, but can be turned off)
2576  */
2577 static
2578 void wl_cache_store (struct wl_softc *sc, int base, struct ether_header *eh,
2579                      struct mbuf *m)
2580 {
2581         struct ip *ip = NULL;   /* Avoid GCC warning */
2582         int i;
2583         int signal, silence;
2584         int w_insertcache;   /* computed index for cache entry storage */
2585         int ipflag = wl_cache_iponly;
2586
2587         /* filters:
2588          * 1. ip only
2589          * 2. configurable filter to throw out unicast packets,
2590          * keep multicast only.
2591          */
2592
2593 #ifdef INET
2594         /* reject if not IP packet
2595         */
2596         if ( wl_cache_iponly && (ntohs(eh->ether_type) != 0x800)) {
2597                 return;
2598         }
2599
2600         /* check if broadcast or multicast packet.  we toss
2601          * unicast packets
2602          */
2603         if (wl_cache_mcastonly && ((eh->ether_dhost[0] & 1) == 0)) {
2604                 return;
2605         }
2606
2607         /* find the ip header.  we want to store the ip_src
2608          * address.  use the mtod macro(in mbuf.h)
2609          * to typecast m to struct ip *
2610          */
2611         if (ipflag) {
2612                 ip = mtod(m, struct ip *);
2613         }
2614
2615         /* do a linear search for a matching MAC address
2616          * in the cache table
2617          * . MAC address is 6 bytes,
2618          * . var w_nextcache holds total number of entries already cached
2619          */
2620         for(i = 0; i < sc->w_nextcache; i++) {
2621                 if (! bcmp(eh->ether_shost, sc->w_sigcache[i].macsrc,  6 )) {
2622                         /* Match!,
2623                          * so we already have this entry,
2624                          * update the data, and LRU age
2625                          */
2626                         break;
2627                 }
2628         }
2629
2630         /* did we find a matching mac address?
2631          * if yes, then overwrite a previously existing cache entry
2632          */
2633         if (i <  sc->w_nextcache )   {
2634                 w_insertcache = i;
2635         }
2636         /* else, have a new address entry,so
2637          * add this new entry,
2638          * if table full, then we need to replace entry
2639          */
2640         else    {
2641
2642                 /* check for space in cache table
2643                  * note: w_nextcache also holds number of entries
2644                  * added in the cache table
2645                  */
2646                 if ( sc->w_nextcache < MAXCACHEITEMS ) {
2647                         w_insertcache = sc->w_nextcache;
2648                         sc->w_nextcache++;
2649                         sc->w_sigitems = sc->w_nextcache;
2650                 }
2651                 /* no space found, so simply wrap with wrap index
2652                  * and "zap" the next entry
2653                  */
2654                 else {
2655                         if (sc->w_wrapindex == MAXCACHEITEMS) {
2656                                 sc->w_wrapindex = 0;
2657                         }
2658                         w_insertcache = sc->w_wrapindex++;
2659                 }
2660         }
2661
2662         /* invariant: w_insertcache now points at some slot
2663          * in cache.
2664          */
2665         if (w_insertcache < 0 || w_insertcache >= MAXCACHEITEMS) {
2666                 log(LOG_ERR,
2667                         "wl_cache_store, bad index: %d of [0..%d], gross cache error\n",
2668                         w_insertcache, MAXCACHEITEMS);
2669                 return;
2670         }
2671
2672         /*  store items in cache
2673          *  .ipsrc
2674          *  .macsrc
2675          *  .signal (0..63) ,silence (0..63) ,quality (0..15)
2676          */
2677         if (ipflag) {
2678                 sc->w_sigcache[w_insertcache].ipsrc = ip->ip_src.s_addr;
2679         }
2680         bcopy( eh->ether_shost, sc->w_sigcache[w_insertcache].macsrc,  6);
2681         signal = sc->w_sigcache[w_insertcache].signal  = wlmmcread(base, MMC_SIGNAL_LVL) & 0x3f;
2682         silence = sc->w_sigcache[w_insertcache].silence = wlmmcread(base, MMC_SILENCE_LVL) & 0x3f;
2683         sc->w_sigcache[w_insertcache].quality = wlmmcread(base, MMC_SIGN_QUAL) & 0x0f;
2684         if (signal > 0)
2685                 sc->w_sigcache[w_insertcache].snr =
2686                         signal - silence;
2687         else
2688                 sc->w_sigcache[w_insertcache].snr = 0;
2689 #endif /* INET */
2690
2691 }
2692 #endif /* WLCACHE */
2693
2694 /*
2695  * determine if in all multicast mode or not
2696  *
2697  * returns: 1 if IFF_ALLMULTI should be set
2698  *          else 0
2699  */
2700 #ifdef MULTICAST
2701
2702 #if defined(__FreeBSD__) && __FreeBSD_version < 300000  /* not required */
2703 static int
2704 check_allmulti(struct wl_softc *sc)
2705 {
2706     short  base = sc->base;
2707     struct ether_multi *enm;
2708     struct ether_multistep step;
2709
2710     ETHER_FIRST_MULTI(step, &sc->wl_ac, enm);
2711     while (enm != NULL) {
2712         unsigned int lo, hi;
2713 #ifdef MDEBUG
2714                 printf("enm_addrlo %x:%x:%x:%x:%x:%x\n", enm->enm_addrlo[0], enm->enm_addrlo[1],
2715                 enm->enm_addrlo[2], enm->enm_addrlo[3], enm->enm_addrlo[4],
2716                 enm->enm_addrlo[5]);
2717                 printf("enm_addrhi %x:%x:%x:%x:%x:%x\n", enm->enm_addrhi[0], enm->enm_addrhi[1],
2718                 enm->enm_addrhi[2], enm->enm_addrhi[3], enm->enm_addrhi[4],
2719                 enm->enm_addrhi[5]);
2720 #endif
2721         if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) != 0) {
2722                 return(1);
2723         }
2724         ETHER_NEXT_MULTI(step, enm);
2725     }
2726     return(0);
2727 }
2728 #endif
2729 #endif