sys/dev/netif/ray/if_ray.c

   1 /*
   2  * Copyright (C) 2000
   3  * Dr. Duncan McLennan Barclay, dmlb@ragnet.demon.co.uk.
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the author nor the names of any co-contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY DUNCAN BARCLAY AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL DUNCAN BARCLAY OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  * $FreeBSD: src/sys/dev/ray/if_ray.c,v 1.47.2.4 2001/08/14 22:54:05 dmlb Exp $
  32  * $DragonFly: src/sys/dev/netif/ray/Attic/if_ray.c,v 1.10 2004/03/14 15:36:51 joerg Exp $
  33  *
  34  */
  35
  36 /*      $NetBSD: if_ray.c,v 1.12 2000/02/07 09:36:27 augustss Exp $     */
  37 /*
  38  * Copyright (c) 2000 Christian E. Hopps
  39  * All rights reserved.
  40  *
  41  * Redistribution and use in source and binary forms, with or without
  42  * modification, are permitted provided that the following conditions
  43  * are met:
  44  * 1. Redistributions of source code must retain the above copyright
  45  *    notice, this list of conditions and the following disclaimer.
  46  * 2. Redistributions in binary form must reproduce the above copyright
  47  *    notice, this list of conditions and the following disclaimer in the
  48  *    documentation and/or other materials provided with the distribution.
  49  * 3. Neither the name of the author nor the names of any co-contributors
  50  *    may be used to endorse or promote products derived from this software
  51  *    without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  54  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  56  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  57  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  58  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  59  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  60  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  61  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  62  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  63  * SUCH DAMAGE.
  64  */
  65
  66 /*
  67  * Card configuration
  68  * ==================
  69  *
  70  * This card is unusual in that it uses both common and attribute
  71  * memory whilst working. It should use common memory and an IO port.
  72  *
  73  * The bus resource allocations need to work around the brain deadness
  74  * of pccardd (where it reads the CIS for common memory, sets it all
  75  * up and then throws it all away assuming the card is an ed
  76  * driver...). Note that this could be dangerous (because it doesn't
  77  * interact with pccardd) if you use other memory mapped cards in the
  78  * same pccard slot as currently old mappings are not cleaned up very well
  79  * by the bus_release_resource methods or pccardd.
  80  *
  81  * There is no support for running this driver on 4.0.
  82  *
  83  * Ad-hoc and infra-structure modes
  84  * ================================
  85  *
  86  * The driver supports ad-hoc mode for V4 firmware and infrastructure
  87  * mode for V5 firmware. V5 firmware in ad-hoc mode is untested and should
  88  * work.
  89  *
  90  * The Linux driver also seems to have the capability to act as an AP.
  91  * I wonder what facilities the "AP" can provide within a driver? We can
  92  * probably use the BRIDGE code to form an ESS but I don't think
  93  * power saving etc. is easy.
  94  *
  95  *
  96  * Packet framing/encapsulation/translation
  97  * ========================================
  98  *
  99  * Currently we support the Webgear encapsulation:
 100  *      802.11  header <net/if_ieee80211.h>struct ieee80211_frame
 101  *      802.3   header <net/ethernet.h>struct ether_header
 102  *      IP/ARP  payload
 103  *
 104  * and RFC1042 encapsulation of IP datagrams (translation):
 105  *      802.11  header <net/if_ieee80211.h>struct ieee80211_frame
 106  *      802.2   LLC header
 107  *      802.2   SNAP header
 108  *      802.3   Ethertype
 109  *      IP/ARP  payload
 110  *
 111  * Framing should be selected via if_media stuff or link types but
 112  * is currently hardcoded to:
 113  *      V4      encapsulation
 114  *      V5      translation
 115  *
 116  *
 117  * Authentication
 118  * ==============
 119  *
 120  * 802.11 provides two authentication mechanisms. The first is a very
 121  * simple host based mechanism (like xhost) called Open System and the
 122  * second is a more complex challenge/response called Shared Key built
 123  * ontop of WEP.
 124  *
 125  * This driver only supports Open System and does not implement any
 126  * host based control lists. In otherwords authentication is always
 127  * granted to hosts wanting to authenticate with this station. This is
 128  * the only sensible behaviour as the Open System mechanism uses MAC
 129  * addresses to identify hosts. Send me patches if you need it!
 130  */
 131
 132 /*
 133  * ***check all XXX_INFRA code - reassoc not done well at all!
 134  * ***watchdog to catch screwed up removals?
 135  * ***error handling of RAY_COM_RUNQ
 136  * ***error handling of ECF command completions
 137  * ***can't seem to create a n/w that Win95 wants to see.
 138  * ***remove panic in ray_com_ecf by re-quing or timeout
 139  * ***use new ioctl stuff - probably need to change RAY_COM_FCHKRUNNING things?
 140  *      consider user doing:
 141  *              ifconfig ray0 192.168.200.38 -bssid "freed"
 142  *              ifconfig ray0 192.168.200.38 -bssid "fred"
 143  *      here the second one would be missed in this code
 144  * check that v5 needs timeouts on ecf commands
 145  * write up driver structure in comments above
 146  * UPDATE_PARAMS seems to return via an interrupt - maybe the timeout
 147  *      is needed for wrong values?
 148  * proper setting of mib_hop_seq_len with country code for v4 firmware
 149  *      best done with raycontrol?
 150  * countrycode setting is broken I think
 151  *      userupdate should trap and do via startjoin etc.
 152  * fragmentation when rx level drops?
 153  * v5 might not need download
 154  *      defaults are as documented apart from hop_seq_length
 155  *      settings are sane for ad-hoc not infra
 156  *
 157  * driver state
 158  *      most state is implied by the sequence of commands in the runq
 159  *      but in fact any of the rx and tx path that uses variables
 160  *      in the sc_c are potentially going to get screwed?
 161  *
 162  * infra mode stuff
 163  *      proper handling of the basic rate set - see the manual
 164  *      all ray_sj, ray_assoc sequencues need a "nicer" solution as we
 165  *              remember association and authentication
 166  *      need to consider WEP
 167  *      acting as ap - should be able to get working from the manual
 168  *      need to finish RAY_ECMD_REJOIN_DONE
 169  *      finish authenitcation code, it doesn't handle errors/timeouts/
 170  *      REJOIN etc.
 171  *
 172  * ray_nw_param
 173  *      promisc in here too? - done
 174  *      should be able to update the parameters before we download to the
 175  *              device. This means we must attach a desired struct to the
 176  *              runq entry and maybe have another big case statement to
 177  *              move these desired into current when not running.
 178  *              init must then use the current settings (pre-loaded
 179  *              in attach now!) and pass to download. But we can't access
 180  *              current nw params outside of the runq - ahhh
 181  *      differeniate between parameters set in attach and init
 182  *      sc_station_addr in here too (for changing mac address)
 183  *      move desired into the command structure?
 184  *      take downloaded MIB from a complete nw_param?
 185  *      longer term need to attach a desired nw params to the runq entry
 186  *
 187  *
 188  * RAY_COM_RUNQ errors
 189  *
 190  * if sleeping in ccs_alloc with eintr/erestart/enxio/enodev
 191  *      erestart        try again from the top
 192  *                      XXX do not malloc more comqs
 193  *                      XXX ccs allocation hard
 194  *      eintr           clean up and return
 195  *      enxio           clean up and return - done in macro
 196  *
 197  * if sleeping in runq_arr itself with eintr/erestart/enxio/enodev
 198  *      erestart        try again from the top
 199  *                      XXX do not malloc more comqs
 200  *                      XXX ccs allocation hard
 201  *                      XXX reinsert comqs at head of list
 202  *      eintr           clean up and return
 203  *      enxio           clean up and return - done in macro
 204  */
 205
 206 #define XXX             0
 207 #define XXX_ACTING_AP   0
 208 #define XXX_INFRA       0
 209 #define RAY_DEBUG       (                               \
 210                         /* RAY_DBG_AUTH         | */    \
 211                         /* RAY_DBG_SUBR         | */    \
 212                         /* RAY_DBG_BOOTPARAM    | */    \
 213                         /* RAY_DBG_STARTJOIN    | */    \
 214                         /* RAY_DBG_CCS          | */    \
 215                         /* RAY_DBG_IOCTL        | */    \
 216                         /* RAY_DBG_MBUF         | */    \
 217                         /* RAY_DBG_RX           | */    \
 218                         /* RAY_DBG_CM           | */    \
 219                         /* RAY_DBG_COM          | */    \
 220                         /* RAY_DBG_STOP         | */    \
 221                         /* RAY_DBG_CTL          | */    \
 222                         /* RAY_DBG_MGT          | */    \
 223                         /* RAY_DBG_TX           | */    \
 224                         /* RAY_DBG_DCOM         | */    \
 225                         0                               \
 226                         )
 227
 228 /*
 229  * XXX build options - move to LINT
 230  */
 231 #define RAY_CM_RID              0       /* pccardd abuses windows 0 and 1 */
 232 #define RAY_AM_RID              3       /* pccardd abuses windows 0 and 1 */
 233 #define RAY_COM_TIMEOUT         (hz/2)  /* Timeout for CCS commands */
 234 #define RAY_TX_TIMEOUT          (hz/2)  /* Timeout for rescheduling TX */
 235 #define RAY_ECF_SPIN_DELAY      1000    /* Wait 1ms before checking ECF ready */
 236 #define RAY_ECF_SPIN_TRIES      10      /* Wait this many times for ECF ready */
 237 /*
 238  * XXX build options - move to LINT
 239  */
 240
 241 #ifndef RAY_DEBUG
 242 #define RAY_DEBUG               0x0000
 243 #endif /* RAY_DEBUG */
 244
 245 #include <sys/param.h>
 246 #include <sys/systm.h>
 247 #include <sys/malloc.h>
 248 #include <sys/kernel.h>
 249
 250 #include <machine/bus.h>
 251 #include <machine/resource.h>
 252 #include <machine/clock.h>
 253 #include <sys/bus.h>
 254 #include <sys/rman.h>
 255
 256 #include <sys/mbuf.h>
 257 #include <sys/socket.h>
 258 #include <sys/sockio.h>
 259
 260 #include <net/bpf.h>
 261 #include <net/ethernet.h>
 262 #include <net/if.h>
 263 #include <net/if_arp.h>
 264 #include <net/if_dl.h>
 265 #include <net/if_ieee80211.h>
 266 #include <net/if_llc.h>
 267
 268 #include <machine/limits.h>
 269
 270 #include <bus/pccard/pccardvar.h>
 271 #include "card_if.h"
 272
 273 #include "if_rayreg.h"
 274 #include "if_raymib.h"
 275 #include "if_raydbg.h"
 276 #include "if_rayvar.h"
 277
 278 /*
 279  * Prototyping
 280  */
 281 static int      ray_attach              (device_t);
 282 static int      ray_ccs_alloc           (struct ray_softc *sc, size_t *ccsp, char *wmesg);
 283 static void     ray_ccs_fill            (struct ray_softc *sc, size_t ccs, u_int cmd);
 284 static void     ray_ccs_free            (struct ray_softc *sc, size_t ccs);
 285 static int      ray_ccs_tx              (struct ray_softc *sc, size_t *ccsp, size_t *bufpp);
 286 static void     ray_com_ecf             (struct ray_softc *sc, struct ray_comq_entry *com);
 287 static void     ray_com_ecf_done        (struct ray_softc *sc);
 288 static void     ray_com_ecf_timo        (void *xsc);
 289 static struct ray_comq_entry *
 290                 ray_com_init            (struct ray_comq_entry *com, ray_comqfn_t function, int flags, char *mesg);
 291 static struct ray_comq_entry *
 292                 ray_com_malloc          (ray_comqfn_t function, int flags, char *mesg);
 293 static void     ray_com_runq            (struct ray_softc *sc);
 294 static int      ray_com_runq_add        (struct ray_softc *sc, struct ray_comq_entry *com[], int ncom, char *wmesg);
 295 static void     ray_com_runq_done       (struct ray_softc *sc);
 296 static int      ray_detach              (device_t);
 297 static void     ray_init                (void *xsc);
 298 static int      ray_init_user           (struct ray_softc *sc);
 299 static void     ray_init_assoc          (struct ray_softc *sc, struct ray_comq_entry *com);
 300 static void     ray_init_assoc_done     (struct ray_softc *sc, u_int8_t status, size_t ccs);
 301 static void     ray_init_auth           (struct ray_softc *sc, struct ray_comq_entry *com);
 302 static int      ray_init_auth_send      (struct ray_softc *sc, u_int8_t *dst, int sequence);
 303 static void     ray_init_auth_done      (struct ray_softc *sc, u_int8_t status);
 304 static void     ray_init_download       (struct ray_softc *sc, struct ray_comq_entry *com);
 305 static void     ray_init_download_done  (struct ray_softc *sc, u_int8_t status, size_t ccs);
 306 static void     ray_init_download_v4    (struct ray_softc *sc, struct ray_comq_entry *com);
 307 static void     ray_init_download_v5    (struct ray_softc *sc, struct ray_comq_entry *com);
 308 static void     ray_init_mcast          (struct ray_softc *sc, struct ray_comq_entry *com);
 309 static void     ray_init_sj             (struct ray_softc *sc, struct ray_comq_entry *com);
 310 static void     ray_init_sj_done        (struct ray_softc *sc, u_int8_t status, size_t ccs);
 311 static void     ray_intr                (void *xsc);
 312 static void     ray_intr_ccs            (struct ray_softc *sc, u_int8_t cmd, u_int8_t status, size_t ccs);
 313 static void     ray_intr_rcs            (struct ray_softc *sc, u_int8_t cmd, size_t ccs);
 314 static void     ray_intr_updt_errcntrs  (struct ray_softc *sc);
 315 static int      ray_ioctl               (struct ifnet *ifp, u_long command, caddr_t data);
 316 static void     ray_mcast               (struct ray_softc *sc, struct ray_comq_entry *com);
 317 static void     ray_mcast_done          (struct ray_softc *sc, u_int8_t status, size_t ccs);
 318 static int      ray_mcast_user          (struct ray_softc *sc);
 319 static int      ray_probe               (device_t);
 320 static void     ray_promisc             (struct ray_softc *sc, struct ray_comq_entry *com);
 321 static void     ray_repparams           (struct ray_softc *sc, struct ray_comq_entry *com);
 322 static void     ray_repparams_done      (struct ray_softc *sc, u_int8_t status, size_t ccs);
 323 static int      ray_repparams_user      (struct ray_softc *sc, struct ray_param_req *pr);
 324 static int      ray_repstats_user       (struct ray_softc *sc, struct ray_stats_req *sr);
 325 static int      ray_res_alloc_am        (struct ray_softc *sc);
 326 static int      ray_res_alloc_cm        (struct ray_softc *sc);
 327 static int      ray_res_alloc_irq       (struct ray_softc *sc);
 328 static void     ray_res_release         (struct ray_softc *sc);
 329 static void     ray_rx                  (struct ray_softc *sc, size_t rcs);
 330 static void     ray_rx_ctl              (struct ray_softc *sc, struct mbuf *m0);
 331 static void     ray_rx_data             (struct ray_softc *sc, struct mbuf *m0, u_int8_t siglev, u_int8_t antenna);
 332 static void     ray_rx_mgt              (struct ray_softc *sc, struct mbuf *m0);
 333 static void     ray_rx_mgt_auth         (struct ray_softc *sc, struct mbuf *m0);
 334 static void     ray_rx_mgt_beacon       (struct ray_softc *sc, struct mbuf *m0);
 335 static void     ray_rx_mgt_info         (struct ray_softc *sc, struct mbuf *m0, struct ieee80211_information *elements);
 336 static void     ray_rx_update_cache     (struct ray_softc *sc, u_int8_t *src, u_int8_t siglev, u_int8_t antenna);
 337 static void     ray_stop                (struct ray_softc *sc, struct ray_comq_entry *com);
 338 static int      ray_stop_user           (struct ray_softc *sc);
 339 static void     ray_tx                  (struct ifnet *ifp);
 340 static void     ray_tx_done             (struct ray_softc *sc, u_int8_t status, size_t ccs);
 341 static void     ray_tx_timo             (void *xsc);
 342 static int      ray_tx_send             (struct ray_softc *sc, size_t ccs, int pktlen, u_int8_t *dst);
 343 static size_t   ray_tx_wrhdr            (struct ray_softc *sc, size_t bufp, u_int8_t type, u_int8_t fc1, u_int8_t *addr1, u_int8_t *addr2, u_int8_t *addr3);
 344 static void     ray_upparams            (struct ray_softc *sc, struct ray_comq_entry *com);
 345 static void     ray_upparams_done       (struct ray_softc *sc, u_int8_t status, size_t ccs);
 346 static int      ray_upparams_user       (struct ray_softc *sc, struct ray_param_req *pr);
 347 static void     ray_watchdog            (struct ifnet *ifp);
 348 static u_int8_t ray_tx_best_antenna     (struct ray_softc *sc, u_int8_t *dst);
 349
 350 #if RAY_DEBUG & RAY_DBG_COM
 351 static void     ray_com_ecf_check       (struct ray_softc *sc, size_t ccs, char *mesg);
 352 #endif /* RAY_DEBUG & RAY_DBG_COM */
 353 #if RAY_DEBUG & RAY_DBG_MBUF
 354 static void     ray_dump_mbuf           (struct ray_softc *sc, struct mbuf *m, char *s);
 355 #endif /* RAY_DEBUG & RAY_DBG_MBUF */
 356
 357 /*
 358  * PC-Card (PCMCIA) driver definition
 359  */
 360 static device_method_t ray_methods[] = {
 361         /* Device interface */
 362         DEVMETHOD(device_probe,         ray_probe),
 363         DEVMETHOD(device_attach,        ray_attach),
 364         DEVMETHOD(device_detach,        ray_detach),
 365
 366         { 0, 0 }
 367 };
 368
 369 static driver_t ray_driver = {
 370         "ray",
 371         ray_methods,
 372         sizeof(struct ray_softc)
 373 };
 374
 375 static devclass_t ray_devclass;
 376
 377 DECLARE_DUMMY_MODULE(if_ray);
 378 DRIVER_MODULE(if_ray, pccard, ray_driver, ray_devclass, 0, 0);
 379
 380 /*
 381  * Probe for the card by checking its startup results.
 382  *
 383  * Fixup any bugs/quirks for different firmware.
 384  */
 385 static int
 386 ray_probe(device_t dev)
 387 {
 388         struct ray_softc *sc = device_get_softc(dev);
 389         struct ray_ecf_startup_v5 *ep = &sc->sc_ecf_startup;
 390         int error;
 391
 392         sc->dev = dev;
 393         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
 394
 395         /*
 396          * Read startup results from the card.
 397          */
 398         error = ray_res_alloc_cm(sc);
 399         if (error)
 400                 return (error);
 401         error = ray_res_alloc_am(sc);
 402         if (error) {
 403                 ray_res_release(sc);
 404                 return (error);
 405         }
 406         RAY_MAP_CM(sc);
 407         SRAM_READ_REGION(sc, RAY_ECF_TO_HOST_BASE, ep,
 408             sizeof(sc->sc_ecf_startup));
 409         ray_res_release(sc);
 410
 411         /*
 412          * Check the card is okay and work out what version we are using.
 413          */
 414         if (ep->e_status != RAY_ECFS_CARD_OK) {
 415                 RAY_PRINTF(sc, "card failed self test 0x%b",
 416                     ep->e_status, RAY_ECFS_PRINTFB);
 417                 return (ENXIO);
 418         }
 419         if (sc->sc_version != RAY_ECFS_BUILD_4 &&
 420             sc->sc_version != RAY_ECFS_BUILD_5) {
 421                 RAY_PRINTF(sc, "unsupported firmware version 0x%0x",
 422                     ep->e_fw_build_string);
 423                 return (ENXIO);
 424         }
 425         RAY_DPRINTF(sc, RAY_DBG_BOOTPARAM, "found a card");
 426         sc->sc_gone = 0;
 427
 428         /*
 429          * Fixup tib size to be correct - on build 4 it is garbage
 430          */
 431         if (sc->sc_version == RAY_ECFS_BUILD_4 && sc->sc_tibsize == 0x55)
 432                 sc->sc_tibsize = sizeof(struct ray_tx_tib);
 433
 434         return (0);
 435 }
 436
 437 /*
 438  * Attach the card into the kernel
 439  */
 440 static int
 441 ray_attach(device_t dev)
 442 {
 443         struct ray_softc *sc = device_get_softc(dev);
 444         struct ray_ecf_startup_v5 *ep = &sc->sc_ecf_startup;
 445         struct ifnet *ifp = &sc->arpcom.ac_if;
 446         size_t ccs;
 447         int i, error;
 448
 449         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
 450
 451         if ((sc == NULL) || (sc->sc_gone))
 452                 return (ENXIO);
 453
 454         /*
 455          * Grab the resources I need
 456          */
 457         error = ray_res_alloc_cm(sc);
 458         if (error)
 459                 return (error);
 460         error = ray_res_alloc_am(sc);
 461         if (error) {
 462                 ray_res_release(sc);
 463                 return (error);
 464         }
 465         error = ray_res_alloc_irq(sc);
 466         if (error) {
 467                 ray_res_release(sc);
 468                 return (error);
 469         }
 470
 471         /*
 472          * Reset any pending interrupts
 473          */
 474         RAY_HCS_CLEAR_INTR(sc);
 475
 476         /*
 477          * Set the parameters that will survive stop/init and
 478          * reset a few things on the card.
 479          *
 480          * Do not update these in ray_init_download's parameter setup
 481          *
 482          * XXX see the ray_init_download section for stuff to move
 483          */
 484         RAY_MAP_CM(sc);
 485         bzero(&sc->sc_d, sizeof(struct ray_nw_param));
 486         bzero(&sc->sc_c, sizeof(struct ray_nw_param));
 487
 488         /* Clear statistics counters */
 489         sc->sc_rxoverflow = 0;
 490         sc->sc_rxcksum = 0;
 491         sc->sc_rxhcksum = 0;
 492         sc->sc_rxnoise = 0;
 493
 494         /* Clear signal and antenna cache */
 495         bzero(sc->sc_siglevs, sizeof(sc->sc_siglevs));
 496
 497         /* Set all ccs to be free */
 498         bzero(sc->sc_ccsinuse, sizeof(sc->sc_ccsinuse));
 499         ccs = RAY_CCS_ADDRESS(0);
 500         for (i = 0; i < RAY_CCS_LAST; ccs += RAY_CCS_SIZE, i++)
 501                 RAY_CCS_FREE(sc, ccs);
 502
 503         /*
 504          * Initialise the network interface structure
 505          */
 506         if_initname(ifp, "ray", device_get_unit(dev));
 507         ifp->if_softc = sc;
 508         ifp->if_timer = 0;
 509         ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST);
 510         ifp->if_hdrlen = sizeof(struct ieee80211_frame) +
 511             sizeof(struct ether_header);
 512         ifp->if_baudrate = 1000000; /* Is this baud or bps ;-) */
 513         ifp->if_output = ether_output;
 514         ifp->if_start = ray_tx;
 515         ifp->if_ioctl = ray_ioctl;
 516         ifp->if_watchdog = ray_watchdog;
 517         ifp->if_init = ray_init;
 518         ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
 519
 520         ether_ifattach(ifp, ep->e_station_addr);
 521
 522         /*
 523          * Initialise the timers and driver
 524          */
 525         callout_handle_init(&sc->com_timerh);
 526         callout_handle_init(&sc->tx_timerh);
 527         TAILQ_INIT(&sc->sc_comq);
 528
 529         /*
 530          * Print out some useful information
 531          */
 532         if (bootverbose || (RAY_DEBUG & RAY_DBG_BOOTPARAM)) {
 533                 RAY_PRINTF(sc, "start up results");
 534                 if (sc->sc_version == RAY_ECFS_BUILD_4)
 535                         printf(".  Firmware version 4\n");
 536                 else
 537                         printf(".  Firmware version 5\n");
 538                 printf(".  Status 0x%b\n", ep->e_status, RAY_ECFS_PRINTFB);
 539                 printf(".  Ether address %6D\n", ep->e_station_addr, ":");
 540                 if (sc->sc_version == RAY_ECFS_BUILD_4) {
 541                         printf(".  Program checksum %0x\n", ep->e_resv0);
 542                         printf(".  CIS checksum %0x\n", ep->e_rates[0]);
 543                 } else {
 544                         printf(".  (reserved word) %0x\n", ep->e_resv0);
 545                         printf(".  Supported rates %8D\n", ep->e_rates, ":");
 546                 }
 547                 printf(".  Japan call sign %12D\n", ep->e_japan_callsign, ":");
 548                 if (sc->sc_version == RAY_ECFS_BUILD_5) {
 549                         printf(".  Program checksum %0x\n", ep->e_prg_cksum);
 550                         printf(".  CIS checksum %0x\n", ep->e_cis_cksum);
 551                         printf(".  Firmware version %0x\n",
 552                             ep->e_fw_build_string);
 553                         printf(".  Firmware revision %0x\n", ep->e_fw_build);
 554                         printf(".  (reserved word) %0x\n", ep->e_fw_resv);
 555                         printf(".  ASIC version %0x\n", ep->e_asic_version);
 556                         printf(".  TIB size %0x\n", ep->e_tibsize);
 557                 }
 558         }
 559
 560         return (0);
 561 }
 562
 563 /*
 564  * Detach the card
 565  *
 566  * This is usually called when the card is ejected, but
 567  * can be caused by a modunload of a controller driver.
 568  * The idea is to reset the driver's view of the device
 569  * and ensure that any driver entry points such as
 570  * read and write do not hang.
 571  */
 572 static int
 573 ray_detach(device_t dev)
 574 {
 575         struct ray_softc *sc = device_get_softc(dev);
 576         struct ifnet *ifp = &sc->arpcom.ac_if;
 577         struct ray_comq_entry *com;
 578         int s;
 579
 580         s = splimp();
 581
 582         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
 583
 584         if ((sc == NULL) || (sc->sc_gone))
 585                 return (0);
 586
 587         /*
 588          * Mark as not running and detach the interface.
 589          *
 590          * N.B. if_detach can trigger ioctls so we do it first and
 591          * then clean the runq.
 592          */
 593         sc->sc_gone = 1;
 594         sc->sc_c.np_havenet = 0;
 595         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 596         ether_ifdetach(ifp);
 597
 598         /*
 599          * Stop the runq and wake up anyone sleeping for us.
 600          */
 601         untimeout(ray_com_ecf_timo, sc, sc->com_timerh);
 602         untimeout(ray_tx_timo, sc, sc->tx_timerh);
 603         com = TAILQ_FIRST(&sc->sc_comq);
 604         for (com = TAILQ_FIRST(&sc->sc_comq); com != NULL;
 605             com = TAILQ_NEXT(com, c_chain)) {
 606                 com->c_flags |= RAY_COM_FDETACHED;
 607                 com->c_retval = 0;
 608                 RAY_DPRINTF(sc, RAY_DBG_STOP, "looking at com %p %b",
 609                     com, com->c_flags, RAY_COM_FLAGS_PRINTFB);
 610                 if (com->c_flags & RAY_COM_FWOK) {
 611                         RAY_DPRINTF(sc, RAY_DBG_STOP, "waking com %p", com);
 612                         wakeup(com->c_wakeup);
 613                 }
 614         }
 615
 616         /*
 617          * Release resources
 618          */
 619         ray_res_release(sc);
 620         RAY_DPRINTF(sc, RAY_DBG_STOP, "unloading complete");
 621
 622         splx(s);
 623
 624         return (0);
 625 }
 626
 627 /*
 628  * Network ioctl request.
 629  */
 630 static int
 631 ray_ioctl(register struct ifnet *ifp, u_long command, caddr_t data)
 632 {
 633         struct ray_softc *sc = ifp->if_softc;
 634         struct ray_param_req pr;
 635         struct ray_stats_req sr;
 636         struct ifreq *ifr = (struct ifreq *)data;
 637         int s, error, error2;
 638
 639         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_IOCTL, "");
 640
 641         if ((sc == NULL) || (sc->sc_gone))
 642                 return (ENXIO);
 643
 644         error = error2 = 0;
 645         s = splimp();
 646
 647         switch (command) {
 648
 649         case SIOCGIFADDR:
 650         case SIOCSIFMTU:
 651         case SIOCSIFADDR:
 652                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFADDR/SIFMTU");
 653                 error = ether_ioctl(ifp, command, data);
 654 /* XXX SIFADDR used to fall through to SIOCSIFFLAGS */
 655                 break;
 656
 657         case SIOCSIFFLAGS:
 658                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SIFFLAGS 0x%0x", ifp->if_flags);
 659                 /*
 660                  * If the interface is marked up we call ray_init_user.
 661                  * This will deal with mcast and promisc flags as well as
 662                  * initialising the hardware if it needs it.
 663                  */
 664                 if (ifp->if_flags & IFF_UP)
 665                         error = ray_init_user(sc);
 666                 else
 667                         error = ray_stop_user(sc);
 668                 break;
 669
 670         case SIOCADDMULTI:
 671         case SIOCDELMULTI:
 672                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "ADDMULTI/DELMULTI");
 673                 error = ray_mcast_user(sc);
 674                 break;
 675
 676         case SIOCSRAYPARAM:
 677                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SRAYPARAM");
 678                 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
 679                         break;
 680                 error = ray_upparams_user(sc, &pr);
 681                 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
 682                 error = error2 ? error2 : error;
 683                 break;
 684
 685         case SIOCGRAYPARAM:
 686                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYPARAM");
 687                 if ((error = copyin(ifr->ifr_data, &pr, sizeof(pr))))
 688                         break;
 689                 error = ray_repparams_user(sc, &pr);
 690                 error2 = copyout(&pr, ifr->ifr_data, sizeof(pr));
 691                 error = error2 ? error2 : error;
 692                 break;
 693
 694         case SIOCGRAYSTATS:
 695                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYSTATS");
 696                 error = ray_repstats_user(sc, &sr);
 697                 error2 = copyout(&sr, ifr->ifr_data, sizeof(sr));
 698                 error = error2 ? error2 : error;
 699                 break;
 700
 701         case SIOCGRAYSIGLEV:
 702                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GRAYSIGLEV");
 703                 error = copyout(sc->sc_siglevs, ifr->ifr_data,
 704                     sizeof(sc->sc_siglevs));
 705                 break;
 706
 707         case SIOCGIFFLAGS:
 708                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFFLAGS");
 709                 error = EINVAL;
 710                 break;
 711
 712         case SIOCGIFMETRIC:
 713                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMETRIC");
 714                 error = EINVAL;
 715                 break;
 716
 717         case SIOCGIFMTU:
 718                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMTU");
 719                 error = EINVAL;
 720                 break;
 721
 722         case SIOCGIFPHYS:
 723                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFPYHS");
 724                 error = EINVAL;
 725                 break;
 726
 727         case SIOCSIFMEDIA:
 728                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "SIFMEDIA");
 729                 error = EINVAL;
 730                 break;
 731
 732         case SIOCGIFMEDIA:
 733                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "GIFMEDIA");
 734                 error = EINVAL;
 735                 break;
 736
 737         default:
 738                 error = EINVAL;
 739
 740         }
 741
 742         splx(s);
 743
 744         return (error);
 745 }
 746
 747 /*
 748  * Ethernet layer entry to ray_init - discard errors
 749  */
 750 static void
 751 ray_init(void *xsc)
 752 {
 753         struct ray_softc *sc = (struct ray_softc *)xsc;
 754
 755         ray_init_user(sc);
 756 }
 757
 758 /*
 759  * User land entry to network initialisation and changes in interface flags.
 760  *
 761  * We do a very little work here, just creating runq entries to
 762  * processes the actions needed to cope with interface flags. We do it
 763  * this way in case there are runq entries outstanding from earlier
 764  * ioctls that modify the interface flags.
 765  *
 766  * Returns values are either 0 for success, a varity of resource allocation
 767  * failures or errors in the command sent to the card.
 768  *
 769  * Note, IFF_RUNNING is eventually set by init_sj_done or init_assoc_done
 770  */
 771 static int
 772 ray_init_user(struct ray_softc *sc)
 773 {
 774         struct ray_comq_entry *com[6];
 775         int error, ncom;
 776
 777         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
 778
 779         /*
 780          * Create the following runq entries to bring the card up.
 781          *
 782          *              init_download   - download the network to the card
 783          *              init_mcast      - reset multicast list
 784          *              init_sj         - find or start a BSS
 785          *              init_auth       - authenticate with a ESSID if needed
 786          *              init_assoc      - associate with a ESSID if needed
 787          *
 788          * They are only actually executed if the card is not running.
 789          * We may enter this routine from a simple change of IP
 790          * address and do not need to get the card to do these things.
 791          * However, we cannot perform the check here as there may be
 792          * commands in the runq that change the IFF_RUNNING state of
 793          * the interface.
 794          */
 795         ncom = 0;
 796         com[ncom++] = RAY_COM_MALLOC(ray_init_download, RAY_COM_FCHKRUNNING);
 797         com[ncom++] = RAY_COM_MALLOC(ray_init_mcast, RAY_COM_FCHKRUNNING);
 798         com[ncom++] = RAY_COM_MALLOC(ray_init_sj, RAY_COM_FCHKRUNNING);
 799         com[ncom++] = RAY_COM_MALLOC(ray_init_auth, RAY_COM_FCHKRUNNING);
 800         com[ncom++] = RAY_COM_MALLOC(ray_init_assoc, RAY_COM_FCHKRUNNING);
 801
 802         /*
 803          * Create runq entries to process flags
 804          *
 805          *              promisc         - set/reset PROMISC and ALLMULTI flags
 806          *
 807          * They are only actually executed if the card is running
 808          */
 809         com[ncom++] = RAY_COM_MALLOC(ray_promisc, 0);
 810
 811         RAY_COM_RUNQ(sc, com, ncom, "rayinit", error);
 812
 813         /* XXX no real error processing from anything yet! */
 814
 815         RAY_COM_FREE(com, ncom);
 816
 817         return (error);
 818 }
 819
 820 /*
 821  * Runq entry for resetting driver and downloading start up structures to card
 822  */
 823 static void
 824 ray_init_download(struct ray_softc *sc, struct ray_comq_entry *com)
 825 {
 826         struct ifnet *ifp = &sc->arpcom.ac_if;
 827
 828         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
 829
 830         /* If the card already running we might not need to download */
 831         RAY_COM_CHKRUNNING(sc, com, ifp);
 832
 833         /*
 834          * Reset instance variables
 835          *
 836          * The first set are network parameters that are read back when
 837          * the card starts or joins the network.
 838          *
 839          * The second set are network parameters that are downloaded to
 840          * the card.
 841          *
 842          * The third set are driver parameters.
 843          *
 844          * All of the variables in these sets can be updated by the
 845          * card or ioctls.
 846          *
 847          * XXX see the ray_attach section for stuff to move
 848          */
 849         sc->sc_d.np_upd_param = 0;
 850         bzero(sc->sc_d.np_bss_id, ETHER_ADDR_LEN);
 851         sc->sc_d.np_inited = 0;
 852         sc->sc_d.np_def_txrate = RAY_MIB_BASIC_RATE_SET_DEFAULT;
 853         sc->sc_d.np_encrypt = 0;
 854
 855         bzero(sc->sc_d.np_ssid, IEEE80211_NWID_LEN);
 856         if (sc->sc_version == RAY_ECFS_BUILD_4) {
 857                 sc->sc_d.np_net_type = RAY_MIB_NET_TYPE_V4;
 858                 strncpy(sc->sc_d.np_ssid, RAY_MIB_SSID_V4, IEEE80211_NWID_LEN);
 859                 sc->sc_d.np_ap_status = RAY_MIB_AP_STATUS_V4;
 860                 sc->sc_d.np_framing = RAY_FRAMING_ENCAPSULATION;
 861         } else {
 862                 sc->sc_d.np_net_type = RAY_MIB_NET_TYPE_V5;
 863                 strncpy(sc->sc_d.np_ssid, RAY_MIB_SSID_V5, IEEE80211_NWID_LEN);
 864                 sc->sc_d.np_ap_status = RAY_MIB_AP_STATUS_V5;
 865                 sc->sc_d.np_framing = RAY_FRAMING_TRANSLATION;
 866         }
 867         sc->sc_d.np_priv_start = RAY_MIB_PRIVACY_MUST_START_DEFAULT;
 868         sc->sc_d.np_priv_join = RAY_MIB_PRIVACY_CAN_JOIN_DEFAULT;
 869         sc->sc_d.np_promisc = !!(ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI));
 870
 871 /* XXX this is a hack whilst I transition the code. The instance
 872  * XXX variables above should be set somewhere else. This is needed for
 873  * XXX start_join */
 874 bcopy(&sc->sc_d, &com->c_desired, sizeof(struct ray_nw_param));
 875
 876         /*
 877          * Download the right firmware defaults
 878          */
 879         if (sc->sc_version == RAY_ECFS_BUILD_4)
 880                 ray_init_download_v4(sc, com);
 881         else
 882                 ray_init_download_v5(sc, com);
 883
 884         /*
 885          * Kick the card
 886          */
 887         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_DOWNLOAD_PARAMS);
 888         ray_com_ecf(sc, com);
 889 }
 890
 891 #define PUT2(p, v)      \
 892     do { (p)[0] = ((v >> 8) & 0xff); (p)[1] = (v & 0xff); } while(0)
 893 /*
 894  * Firmware version 4 defaults - see if_raymib.h for details
 895  */
 896 static void
 897 ray_init_download_v4(struct ray_softc *sc, struct ray_comq_entry *com)
 898 {
 899         struct ray_mib_4 ray_mib_4_default;
 900
 901         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
 902         RAY_MAP_CM(sc);
 903
 904 #define MIB4(m)         ray_mib_4_default.m
 905
 906         MIB4(mib_net_type)              = com->c_desired.np_net_type;
 907         MIB4(mib_ap_status)             = com->c_desired.np_ap_status;
 908         bcopy(com->c_desired.np_ssid, MIB4(mib_ssid), IEEE80211_NWID_LEN);
 909         MIB4(mib_scan_mode)             = RAY_MIB_SCAN_MODE_V4;
 910         MIB4(mib_apm_mode)              = RAY_MIB_APM_MODE_V4;
 911         bcopy(sc->sc_station_addr, MIB4(mib_mac_addr), ETHER_ADDR_LEN);
 912    PUT2(MIB4(mib_frag_thresh),            RAY_MIB_FRAG_THRESH_V4);
 913    PUT2(MIB4(mib_dwell_time),             RAY_MIB_DWELL_TIME_V4);
 914    PUT2(MIB4(mib_beacon_period),          RAY_MIB_BEACON_PERIOD_V4);
 915         MIB4(mib_dtim_interval)         = RAY_MIB_DTIM_INTERVAL_V4;
 916         MIB4(mib_max_retry)             = RAY_MIB_MAX_RETRY_V4;
 917         MIB4(mib_ack_timo)              = RAY_MIB_ACK_TIMO_V4;
 918         MIB4(mib_sifs)                  = RAY_MIB_SIFS_V4;
 919         MIB4(mib_difs)                  = RAY_MIB_DIFS_V4;
 920         MIB4(mib_pifs)                  = RAY_MIB_PIFS_V4;
 921    PUT2(MIB4(mib_rts_thresh),             RAY_MIB_RTS_THRESH_V4);
 922    PUT2(MIB4(mib_scan_dwell),             RAY_MIB_SCAN_DWELL_V4);
 923    PUT2(MIB4(mib_scan_max_dwell),         RAY_MIB_SCAN_MAX_DWELL_V4);
 924         MIB4(mib_assoc_timo)            = RAY_MIB_ASSOC_TIMO_V4;
 925         MIB4(mib_adhoc_scan_cycle)      = RAY_MIB_ADHOC_SCAN_CYCLE_V4;
 926         MIB4(mib_infra_scan_cycle)      = RAY_MIB_INFRA_SCAN_CYCLE_V4;
 927         MIB4(mib_infra_super_scan_cycle)
 928                                         = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_V4;
 929         MIB4(mib_promisc)               = com->c_desired.np_promisc;
 930    PUT2(MIB4(mib_uniq_word),              RAY_MIB_UNIQ_WORD_V4);
 931         MIB4(mib_slot_time)             = RAY_MIB_SLOT_TIME_V4;
 932         MIB4(mib_roam_low_snr_thresh)   = RAY_MIB_ROAM_LOW_SNR_THRESH_V4;
 933         MIB4(mib_low_snr_count)         = RAY_MIB_LOW_SNR_COUNT_V4;
 934         MIB4(mib_infra_missed_beacon_count)
 935                                         = RAY_MIB_INFRA_MISSED_BEACON_COUNT_V4;
 936         MIB4(mib_adhoc_missed_beacon_count)
 937                                         = RAY_MIB_ADHOC_MISSED_BEACON_COUNT_V4;
 938         MIB4(mib_country_code)          = RAY_MIB_COUNTRY_CODE_V4;
 939         MIB4(mib_hop_seq)               = RAY_MIB_HOP_SEQ_V4;
 940         MIB4(mib_hop_seq_len)           = RAY_MIB_HOP_SEQ_LEN_V4;
 941         MIB4(mib_cw_max)                = RAY_MIB_CW_MAX_V4;
 942         MIB4(mib_cw_min)                = RAY_MIB_CW_MIN_V4;
 943         MIB4(mib_noise_filter_gain)     = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT;
 944         MIB4(mib_noise_limit_offset)    = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT;
 945         MIB4(mib_rssi_thresh_offset)    = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT;
 946         MIB4(mib_busy_thresh_offset)    = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT;
 947         MIB4(mib_sync_thresh)           = RAY_MIB_SYNC_THRESH_DEFAULT;
 948         MIB4(mib_test_mode)             = RAY_MIB_TEST_MODE_DEFAULT;
 949         MIB4(mib_test_min_chan)         = RAY_MIB_TEST_MIN_CHAN_DEFAULT;
 950         MIB4(mib_test_max_chan)         = RAY_MIB_TEST_MAX_CHAN_DEFAULT;
 951 #undef MIB4
 952
 953         SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
 954             &ray_mib_4_default, sizeof(ray_mib_4_default));
 955 }
 956
 957 /*
 958  * Firmware version 5 defaults - see if_raymib.h for details
 959  */
 960 static void
 961 ray_init_download_v5(struct ray_softc *sc, struct ray_comq_entry *com)
 962 {
 963         struct ray_mib_5 ray_mib_5_default;
 964
 965         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
 966         RAY_MAP_CM(sc);
 967
 968 #define MIB5(m)         ray_mib_5_default.m
 969         MIB5(mib_net_type)              = com->c_desired.np_net_type;
 970         MIB5(mib_ap_status)             = com->c_desired.np_ap_status;
 971         bcopy(com->c_desired.np_ssid, MIB5(mib_ssid), IEEE80211_NWID_LEN);
 972         MIB5(mib_scan_mode)             = RAY_MIB_SCAN_MODE_V5;
 973         MIB5(mib_apm_mode)              = RAY_MIB_APM_MODE_V5;
 974         bcopy(sc->sc_station_addr, MIB5(mib_mac_addr), ETHER_ADDR_LEN);
 975    PUT2(MIB5(mib_frag_thresh),            RAY_MIB_FRAG_THRESH_V5);
 976    PUT2(MIB5(mib_dwell_time),             RAY_MIB_DWELL_TIME_V5);
 977    PUT2(MIB5(mib_beacon_period),          RAY_MIB_BEACON_PERIOD_V5);
 978         MIB5(mib_dtim_interval)         = RAY_MIB_DTIM_INTERVAL_V5;
 979         MIB5(mib_max_retry)             = RAY_MIB_MAX_RETRY_V5;
 980         MIB5(mib_ack_timo)              = RAY_MIB_ACK_TIMO_V5;
 981         MIB5(mib_sifs)                  = RAY_MIB_SIFS_V5;
 982         MIB5(mib_difs)                  = RAY_MIB_DIFS_V5;
 983         MIB5(mib_pifs)                  = RAY_MIB_PIFS_V5;
 984    PUT2(MIB5(mib_rts_thresh),             RAY_MIB_RTS_THRESH_V5);
 985    PUT2(MIB5(mib_scan_dwell),             RAY_MIB_SCAN_DWELL_V5);
 986    PUT2(MIB5(mib_scan_max_dwell),         RAY_MIB_SCAN_MAX_DWELL_V5);
 987         MIB5(mib_assoc_timo)            = RAY_MIB_ASSOC_TIMO_V5;
 988         MIB5(mib_adhoc_scan_cycle)      = RAY_MIB_ADHOC_SCAN_CYCLE_V5;
 989         MIB5(mib_infra_scan_cycle)      = RAY_MIB_INFRA_SCAN_CYCLE_V5;
 990         MIB5(mib_infra_super_scan_cycle)
 991                                         = RAY_MIB_INFRA_SUPER_SCAN_CYCLE_V5;
 992         MIB5(mib_promisc)               = com->c_desired.np_promisc;
 993    PUT2(MIB5(mib_uniq_word),              RAY_MIB_UNIQ_WORD_V5);
 994         MIB5(mib_slot_time)             = RAY_MIB_SLOT_TIME_V5;
 995         MIB5(mib_roam_low_snr_thresh)   = RAY_MIB_ROAM_LOW_SNR_THRESH_V5;
 996         MIB5(mib_low_snr_count) = RAY_MIB_LOW_SNR_COUNT_V5;
 997         MIB5(mib_infra_missed_beacon_count)
 998                                         = RAY_MIB_INFRA_MISSED_BEACON_COUNT_V5;
 999         MIB5(mib_adhoc_missed_beacon_count)
1000                                         = RAY_MIB_ADHOC_MISSED_BEACON_COUNT_V5;
1001         MIB5(mib_country_code)          = RAY_MIB_COUNTRY_CODE_V5;
1002         MIB5(mib_hop_seq)               = RAY_MIB_HOP_SEQ_V5;
1003         MIB5(mib_hop_seq_len)           = RAY_MIB_HOP_SEQ_LEN_V5;
1004    PUT2(MIB5(mib_cw_max),                 RAY_MIB_CW_MAX_V5);
1005    PUT2(MIB5(mib_cw_min),                 RAY_MIB_CW_MIN_V5);
1006         MIB5(mib_noise_filter_gain)     = RAY_MIB_NOISE_FILTER_GAIN_DEFAULT;
1007         MIB5(mib_noise_limit_offset)    = RAY_MIB_NOISE_LIMIT_OFFSET_DEFAULT;
1008         MIB5(mib_rssi_thresh_offset)    = RAY_MIB_RSSI_THRESH_OFFSET_DEFAULT;
1009         MIB5(mib_busy_thresh_offset)    = RAY_MIB_BUSY_THRESH_OFFSET_DEFAULT;
1010         MIB5(mib_sync_thresh)           = RAY_MIB_SYNC_THRESH_DEFAULT;
1011         MIB5(mib_test_mode)             = RAY_MIB_TEST_MODE_DEFAULT;
1012         MIB5(mib_test_min_chan)         = RAY_MIB_TEST_MIN_CHAN_DEFAULT;
1013         MIB5(mib_test_max_chan)         = RAY_MIB_TEST_MAX_CHAN_DEFAULT;
1014         MIB5(mib_allow_probe_resp)      = RAY_MIB_ALLOW_PROBE_RESP_DEFAULT;
1015         MIB5(mib_privacy_must_start)    = com->c_desired.np_priv_start;
1016         MIB5(mib_privacy_can_join)      = com->c_desired.np_priv_join;
1017         MIB5(mib_basic_rate_set[0])     = com->c_desired.np_def_txrate;
1018 #undef MIB5
1019
1020         SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
1021             &ray_mib_5_default, sizeof(ray_mib_5_default));
1022 }
1023 #undef PUT2
1024
1025 /*
1026  * Download completion routine
1027  */
1028 static void
1029 ray_init_download_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1030 {
1031         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1032         RAY_COM_CHECK(sc, ccs);
1033
1034         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1035
1036         ray_com_ecf_done(sc);
1037 }
1038
1039 /*
1040  * Runq entry to empty the multicast filter list
1041  */
1042 static void
1043 ray_init_mcast(struct ray_softc *sc, struct ray_comq_entry *com)
1044 {
1045         struct ifnet *ifp = &sc->arpcom.ac_if;
1046
1047         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1048         RAY_MAP_CM(sc);
1049
1050         /* If the card already running we might not need to reset the list */
1051         RAY_COM_CHKRUNNING(sc, com, ifp);
1052
1053         /*
1054          * Kick the card
1055          */
1056         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_MCAST);
1057         SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update_mcast, c_nmcast, 0);
1058
1059         ray_com_ecf(sc, com);
1060 }
1061
1062 /*
1063  * Runq entry to starting or joining a network
1064  */
1065 static void
1066 ray_init_sj(struct ray_softc *sc, struct ray_comq_entry *com)
1067 {
1068         struct ifnet *ifp = &sc->arpcom.ac_if;
1069         struct ray_net_params np;
1070         int update;
1071
1072         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1073         RAY_MAP_CM(sc);
1074
1075         /* If the card already running we might not need to start the n/w */
1076         RAY_COM_CHKRUNNING(sc, com, ifp);
1077
1078         /*
1079          * Set up the right start or join command and determine
1080          * whether we should tell the card about a change in operating
1081          * parameters.
1082          */
1083         sc->sc_c.np_havenet = 0;
1084         if (sc->sc_d.np_net_type == RAY_MIB_NET_TYPE_ADHOC)
1085                 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_START_NET);
1086         else
1087                 ray_ccs_fill(sc, com->c_ccs, RAY_CMD_JOIN_NET);
1088
1089         update = 0;
1090         if (sc->sc_c.np_net_type != sc->sc_d.np_net_type)
1091                 update++;
1092         if (bcmp(sc->sc_c.np_ssid, sc->sc_d.np_ssid, IEEE80211_NWID_LEN))
1093                 update++;
1094         if (sc->sc_c.np_priv_join != sc->sc_d.np_priv_join)
1095                 update++;
1096         if (sc->sc_c.np_priv_start != sc->sc_d.np_priv_start)
1097                 update++;
1098         RAY_DPRINTF(sc, RAY_DBG_STARTJOIN,
1099             "%s updating nw params", update?"is":"not");
1100         if (update) {
1101                 bzero(&np, sizeof(np));
1102                 np.p_net_type = sc->sc_d.np_net_type;
1103                 bcopy(sc->sc_d.np_ssid, np.p_ssid,  IEEE80211_NWID_LEN);
1104                 np.p_privacy_must_start = sc->sc_d.np_priv_start;
1105                 np.p_privacy_can_join = sc->sc_d.np_priv_join;
1106                 SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE, &np, sizeof(np));
1107                 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_net, c_upd_param, 1);
1108         } else
1109                 SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_net, c_upd_param, 0);
1110
1111         /*
1112          * Kick the card
1113          */
1114         ray_com_ecf(sc, com);
1115 }
1116
1117 /*
1118  * Complete start command or intermediate step in assoc command
1119  */
1120 static void
1121 ray_init_sj_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1122 {
1123         struct ifnet *ifp = &sc->arpcom.ac_if;
1124
1125         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1126         RAY_MAP_CM(sc);
1127         RAY_COM_CHECK(sc, ccs);
1128
1129         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1130
1131         /*
1132          * Read back network parameters that the ECF sets
1133          */
1134         SRAM_READ_REGION(sc, ccs, &sc->sc_c.p_1, sizeof(struct ray_cmd_net));
1135
1136         /* Adjust values for buggy firmware */
1137         if (sc->sc_c.np_inited == 0x55)
1138                 sc->sc_c.np_inited = 0;
1139         if (sc->sc_c.np_def_txrate == 0x55)
1140                 sc->sc_c.np_def_txrate = sc->sc_d.np_def_txrate;
1141         if (sc->sc_c.np_encrypt == 0x55)
1142                 sc->sc_c.np_encrypt = sc->sc_d.np_encrypt;
1143
1144         /*
1145          * Update our local state if we updated the network parameters
1146          * when the START_NET or JOIN_NET was issued.
1147          */
1148         if (sc->sc_c.np_upd_param) {
1149                 RAY_DPRINTF(sc, RAY_DBG_STARTJOIN, "updated parameters");
1150                 SRAM_READ_REGION(sc, RAY_HOST_TO_ECF_BASE,
1151                     &sc->sc_c.p_2, sizeof(struct ray_net_params));
1152         }
1153
1154         /*
1155          * Hurrah! The network is now active.
1156          *
1157          * Clearing IFF_OACTIVE will ensure that the system will send us
1158          * packets. Just before we return from the interrupt context
1159          * we check to see if packets have been queued.
1160          */
1161         if (SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd) == RAY_CMD_START_NET) {
1162                 sc->sc_c.np_havenet = 1;
1163                 sc->sc_c.np_framing = sc->sc_d.np_framing;
1164                 ifp->if_flags |= IFF_RUNNING;
1165                 ifp->if_flags &= ~IFF_OACTIVE;
1166         }
1167
1168         ray_com_ecf_done(sc);
1169 }
1170
1171 /*
1172  * Runq entry to authenticate with an access point or another station
1173  */
1174 static void
1175 ray_init_auth(struct ray_softc *sc, struct ray_comq_entry *com)
1176 {
1177         struct ifnet *ifp = &sc->arpcom.ac_if;
1178
1179         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1180
1181         /* If card already running we might not need to authenticate */
1182         RAY_COM_CHKRUNNING(sc, com, ifp);
1183
1184         /*
1185          * XXX Don't do anything if we are not in a managed network
1186          *
1187          * XXX V4 adhoc does not need this, V5 adhoc unknown
1188          */
1189         if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_INFRA) {
1190                 ray_com_runq_done(sc);
1191                 return;
1192         }
1193
1194 /*
1195  * XXX_AUTH need to think of run queue when doing auths from request i.e. would
1196  * XXX_AUTH need to have auth at top of runq?
1197  * XXX_AUTH ditto for sending any auth response packets...what about timeouts?
1198  */
1199
1200         /*
1201          * Kick the card
1202          */
1203 /* XXX_AUTH check exit status and retry or fail as we can't associate without this */
1204         ray_init_auth_send(sc, sc->sc_c.np_bss_id, IEEE80211_AUTH_OPEN_REQUEST);
1205 }
1206
1207 /*
1208  * Build and send an authentication packet
1209  *
1210  * If an error occurs, returns 1 else returns 0.
1211  */
1212 static int
1213 ray_init_auth_send(struct ray_softc *sc, u_int8_t *dst, int sequence)
1214 {
1215         size_t ccs, bufp;
1216         int pktlen = 0;
1217
1218         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1219
1220         /* Get a control block */
1221         if (ray_ccs_tx(sc, &ccs, &bufp)) {
1222                 RAY_RECERR(sc, "could not obtain a ccs");
1223                 return (1);
1224         }
1225
1226         /* Fill the header in */
1227         bufp = ray_tx_wrhdr(sc, bufp,
1228             IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_AUTH,
1229             IEEE80211_FC1_DIR_NODS,
1230             dst,
1231             sc->arpcom.ac_enaddr,
1232             sc->sc_c.np_bss_id);
1233
1234         /* Add algorithm number */
1235         SRAM_WRITE_1(sc, bufp + pktlen++, IEEE80211_AUTH_ALG_OPEN);
1236         SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1237
1238         /* Add sequence number */
1239         SRAM_WRITE_1(sc, bufp + pktlen++, sequence);
1240         SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1241
1242         /* Add status code */
1243         SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1244         SRAM_WRITE_1(sc, bufp + pktlen++, 0);
1245         pktlen += sizeof(struct ieee80211_frame);
1246
1247         return (ray_tx_send(sc, ccs, pktlen, dst));
1248 }
1249
1250 /*
1251  * Complete authentication runq
1252  */
1253 static void
1254 ray_init_auth_done(struct ray_softc *sc, u_int8_t status)
1255 {
1256         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN | RAY_DBG_AUTH, "");
1257
1258         if (status != IEEE80211_STATUS_SUCCESS)
1259                 RAY_RECERR(sc, "authentication failed with status %d", status);
1260 /*
1261  * XXX_AUTH retry? if not just recall ray_init_auth_send and dont clear runq?
1262  * XXX_AUTH association requires that authenitcation is successful
1263  * XXX_AUTH before we associate, and the runq is the only way to halt the
1264  * XXX_AUTH progress of associate.
1265  * XXX_AUTH In this case I might not need the RAY_AUTH_NEEDED state
1266  */
1267         ray_com_runq_done(sc);
1268 }
1269
1270 /*
1271  * Runq entry to starting an association with an access point
1272  */
1273 static void
1274 ray_init_assoc(struct ray_softc *sc, struct ray_comq_entry *com)
1275 {
1276         struct ifnet *ifp = &sc->arpcom.ac_if;
1277
1278         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1279
1280         /* If the card already running we might not need to associate */
1281         RAY_COM_CHKRUNNING(sc, com, ifp);
1282
1283         /*
1284          * Don't do anything if we are not in a managed network
1285          */
1286         if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_INFRA) {
1287                 ray_com_runq_done(sc);
1288                 return;
1289         }
1290
1291         /*
1292          * Kick the card
1293          */
1294         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_START_ASSOC);
1295         ray_com_ecf(sc, com);
1296 }
1297
1298 /*
1299  * Complete association
1300  */
1301 static void
1302 ray_init_assoc_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1303 {
1304         struct ifnet *ifp = &sc->arpcom.ac_if;
1305
1306         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
1307         RAY_COM_CHECK(sc, ccs);
1308
1309         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
1310
1311         /*
1312          * Hurrah! The network is now active.
1313          *
1314          * Clearing IFF_OACTIVE will ensure that the system will send us
1315          * packets. Just before we return from the interrupt context
1316          * we check to see if packets have been queued.
1317          */
1318         sc->sc_c.np_havenet = 1;
1319         sc->sc_c.np_framing = sc->sc_d.np_framing;
1320         ifp->if_flags |= IFF_RUNNING;
1321         ifp->if_flags &= ~IFF_OACTIVE;
1322
1323         ray_com_ecf_done(sc);
1324 }
1325
1326 /*
1327  * Network stop.
1328  *
1329  * Inhibit card - if we can't prevent reception then do not worry;
1330  * stopping a NIC only guarantees no TX.
1331  *
1332  * The change to the interface flags is done via the runq so that any
1333  * existing commands can execute normally.
1334  */
1335 static int
1336 ray_stop_user(struct ray_softc *sc)
1337 {
1338         struct ray_comq_entry *com[1];
1339         int error, ncom;
1340
1341         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
1342
1343         /*
1344          * Schedule the real stop routine
1345          */
1346         ncom = 0;
1347         com[ncom++] = RAY_COM_MALLOC(ray_stop, 0);
1348
1349         RAY_COM_RUNQ(sc, com, ncom, "raystop", error);
1350
1351         /* XXX no real error processing from anything yet! */
1352
1353         RAY_COM_FREE(com, ncom);
1354
1355         return (error);
1356 }
1357
1358 /*
1359  * Runq entry for stopping the interface activity
1360  */
1361 static void
1362 ray_stop(struct ray_softc *sc, struct ray_comq_entry *com)
1363 {
1364         struct ifnet *ifp = &sc->arpcom.ac_if;
1365         struct mbuf *m;
1366
1367         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STOP, "");
1368
1369         /*
1370          * Mark as not running and drain output queue
1371          */
1372         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1373         ifp->if_timer = 0;
1374         for (;;) {
1375                 IF_DEQUEUE(&ifp->if_snd, m);
1376                 if (m == NULL)
1377                         break;
1378                 m_freem(m);
1379         }
1380
1381         ray_com_runq_done(sc);
1382 }
1383
1384 static void
1385 ray_watchdog(struct ifnet *ifp)
1386 {
1387         struct ray_softc *sc = ifp->if_softc;
1388
1389         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1390         RAY_MAP_CM(sc);
1391
1392         if ((sc == NULL) || (sc->sc_gone))
1393                 return;
1394
1395         RAY_PRINTF(sc, "watchdog timeout");
1396 }
1397
1398 /*
1399  * Transmit packet handling
1400  */
1401
1402 /*
1403  * Send a packet.
1404  *
1405  * We make two assumptions here:
1406  *  1) That the current priority is set to splimp _before_ this code
1407  *     is called *and* is returned to the appropriate priority after
1408  *     return
1409  *  2) That the IFF_OACTIVE flag is checked before this code is called
1410  *     (i.e. that the output part of the interface is idle)
1411  *
1412  * A simple one packet at a time TX routine is used - we don't bother
1413  * chaining TX buffers. Performance is sufficient to max out the
1414  * wireless link on a P75.
1415  *
1416  * AST J30 Windows 95A (100MHz Pentium) to
1417  *   Libretto 50CT FreeBSD-3.1 (75MHz Pentium)          167.37kB/s
1418  *   Nonname box FreeBSD-3.4 (233MHz AMD K6)            161.82kB/s
1419  *
1420  * Libretto 50CT FreeBSD-3.1 (75MHz Pentium) to
1421  *   AST J30 Windows 95A (100MHz Pentium)               167.37kB/s
1422  *   Nonname box FreeBSD-3.4 (233MHz AMD K6)            161.38kB/s
1423  *
1424  * Given that 160kB/s is saturating the 2Mb/s wireless link we
1425  * are about there.
1426  *
1427  * In short I'm happy that the added complexity of chaining TX
1428  * packets together isn't worth it for my machines.
1429  */
1430 static void
1431 ray_tx(struct ifnet *ifp)
1432 {
1433         struct ray_softc *sc = ifp->if_softc;
1434         struct mbuf *m0, *m;
1435         struct ether_header *eh;
1436         struct llc *llc;
1437         size_t ccs, bufp;
1438         int pktlen, len;
1439
1440         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1441         RAY_MAP_CM(sc);
1442
1443         /*
1444          * Some simple checks first - some are overkill
1445          */
1446         if ((sc == NULL) || (sc->sc_gone))
1447                 return;
1448         if (!(ifp->if_flags & IFF_RUNNING)) {
1449                 RAY_RECERR(sc, "cannot transmit - not running");
1450                 return;
1451         }
1452         if (!sc->sc_c.np_havenet) {
1453                 RAY_RECERR(sc, "cannot transmit - no network");
1454                 return;
1455         }
1456         if (!RAY_ECF_READY(sc)) {
1457                 /* Can't assume that the ECF is busy because of this driver */
1458                 if ((sc->tx_timerh.callout == NULL) ||
1459                     (!callout_active(sc->tx_timerh.callout))) {
1460                         sc->tx_timerh =
1461                             timeout(ray_tx_timo, sc, RAY_TX_TIMEOUT);
1462                         return;
1463                     }
1464         } else
1465                 untimeout(ray_tx_timo, sc, sc->tx_timerh);
1466
1467         /*
1468          * We find a ccs before we process the mbuf so that we are sure it
1469          * is worthwhile processing the packet. All errors in the mbuf
1470          * processing are either errors in the mbuf or gross configuration
1471          * errors and the packet wouldn't get through anyway.
1472          */
1473         if (ray_ccs_tx(sc, &ccs, &bufp)) {
1474                 ifp->if_flags |= IFF_OACTIVE;
1475                 return;
1476         }
1477
1478         /*
1479          * Get the mbuf and process it - we have to remember to free the
1480          * ccs if there are any errors.
1481          */
1482         IF_DEQUEUE(&ifp->if_snd, m0);
1483         if (m0 == NULL) {
1484                 RAY_CCS_FREE(sc, ccs);
1485                 return;
1486         }
1487
1488         pktlen = m0->m_pkthdr.len;
1489         if (pktlen > ETHER_MAX_LEN - ETHER_CRC_LEN) {
1490                 RAY_RECERR(sc, "mbuf too long %d", pktlen);
1491                 RAY_CCS_FREE(sc, ccs);
1492                 ifp->if_oerrors++;
1493                 m_freem(m0);
1494                 return;
1495         }
1496
1497         m0 = m_pullup(m0, sizeof(struct ether_header));
1498         if (m0 == NULL) {
1499                 RAY_RECERR(sc, "could not pullup ether");
1500                 RAY_CCS_FREE(sc, ccs);
1501                 ifp->if_oerrors++;
1502                 return;
1503         }
1504         eh = mtod(m0, struct ether_header *);
1505
1506         /*
1507          * Write the 802.11 header according to network type etc.
1508          */
1509         if (sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_ADHOC)
1510                 bufp = ray_tx_wrhdr(sc, bufp,
1511                     IEEE80211_FC0_TYPE_DATA,
1512                     IEEE80211_FC1_DIR_NODS,
1513                     eh->ether_dhost,
1514                     eh->ether_shost,
1515                     sc->sc_c.np_bss_id);
1516         else
1517                 if (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_TERMINAL)
1518                         bufp = ray_tx_wrhdr(sc, bufp,
1519                             IEEE80211_FC0_TYPE_DATA,
1520                             IEEE80211_FC1_DIR_TODS,
1521                             sc->sc_c.np_bss_id,
1522                             eh->ether_shost,
1523                             eh->ether_dhost);
1524                 else
1525                         bufp = ray_tx_wrhdr(sc, bufp,
1526                             IEEE80211_FC0_TYPE_DATA,
1527                             IEEE80211_FC1_DIR_FROMDS,
1528                             eh->ether_dhost,
1529                             sc->sc_c.np_bss_id,
1530                             eh->ether_shost);
1531
1532         /*
1533          * Framing
1534          *
1535          * Add to the mbuf.
1536          */
1537         switch (sc->sc_c.np_framing) {
1538
1539         case RAY_FRAMING_ENCAPSULATION:
1540                 /* Nice and easy - nothing! (just add an 802.11 header) */
1541                 break;
1542
1543         case RAY_FRAMING_TRANSLATION:
1544                 /*
1545                  * Drop the first address in the ethernet header and
1546                  * write an LLC and SNAP header over the second.
1547                  */
1548                 m_adj(m0, ETHER_ADDR_LEN);
1549                 if (m0 == NULL) {
1550                         RAY_RECERR(sc, "could not get space for 802.2 header");
1551                         RAY_CCS_FREE(sc, ccs);
1552                         ifp->if_oerrors++;
1553                         return;
1554                 }
1555                 llc = mtod(m0, struct llc *);
1556                 llc->llc_dsap = LLC_SNAP_LSAP;
1557                 llc->llc_ssap = LLC_SNAP_LSAP;
1558                 llc->llc_control = LLC_UI;
1559                 llc->llc_un.type_snap.org_code[0] = 0;
1560                 llc->llc_un.type_snap.org_code[1] = 0;
1561                 llc->llc_un.type_snap.org_code[2] = 0;
1562                 break;
1563
1564         default:
1565                 RAY_RECERR(sc, "unknown framing type %d", sc->sc_c.np_framing);
1566                 RAY_CCS_FREE(sc, ccs);
1567                 ifp->if_oerrors++;
1568                 m_freem(m0);
1569                 return;
1570
1571         }
1572         if (m0 == NULL) {
1573                 RAY_RECERR(sc, "could not frame packet");
1574                 RAY_CCS_FREE(sc, ccs);
1575                 ifp->if_oerrors++;
1576                 return;
1577         }
1578         RAY_MBUF_DUMP(sc, RAY_DBG_TX, m0, "framed packet");
1579
1580         /*
1581          * Copy the mbuf to the buffer in common memory
1582          *
1583          * We drop and don't bother wrapping as Ethernet packets are 1518
1584          * bytes, we checked the mbuf earlier, and our TX buffers are 2048
1585          * bytes. We don't have 530 bytes of headers etc. so something
1586          * must be fubar.
1587          */
1588         pktlen = sizeof(struct ieee80211_frame);
1589         for (m = m0; m != NULL; m = m->m_next) {
1590                 pktlen += m->m_len;
1591                 if ((len = m->m_len) == 0)
1592                         continue;
1593                 if ((bufp + len) < RAY_TX_END)
1594                         SRAM_WRITE_REGION(sc, bufp, mtod(m, u_int8_t *), len);
1595                 else {
1596                         RAY_RECERR(sc, "tx buffer overflow");
1597                         RAY_CCS_FREE(sc, ccs);
1598                         ifp->if_oerrors++;
1599                         m_freem(m0);
1600                         return;
1601                 }
1602                 bufp += len;
1603         }
1604
1605         /*
1606          * Send it off
1607          */
1608         if (ray_tx_send(sc, ccs, pktlen, eh->ether_dhost))
1609                 ifp->if_oerrors++;
1610         else
1611                 ifp->if_opackets++;
1612         m_freem(m0);
1613 }
1614
1615 /*
1616  * Start timeout routine.
1617  *
1618  * Used when card was busy but we needed to send a packet.
1619  */
1620 static void
1621 ray_tx_timo(void *xsc)
1622 {
1623         struct ray_softc *sc = (struct ray_softc *)xsc;
1624         struct ifnet *ifp = &sc->arpcom.ac_if;
1625         int s;
1626
1627         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1628
1629         if (!(ifp->if_flags & IFF_OACTIVE) && (ifp->if_snd.ifq_head != NULL)) {
1630                 s = splimp();
1631                 ray_tx(ifp);
1632                 splx(s);
1633         }
1634 }
1635
1636 /*
1637  * Write an 802.11 header into the Tx buffer space and return the
1638  * adjusted buffer pointer.
1639  */
1640 static size_t
1641 ray_tx_wrhdr(struct ray_softc *sc, size_t bufp, u_int8_t type, u_int8_t fc1, u_int8_t *addr1, u_int8_t *addr2, u_int8_t *addr3)
1642 {
1643         struct ieee80211_frame header;
1644
1645         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1646         RAY_MAP_CM(sc);
1647
1648         bzero(&header, sizeof(struct ieee80211_frame));
1649         header.i_fc[0] = (IEEE80211_FC0_VERSION_0 | type);
1650         header.i_fc[1] = fc1;
1651         bcopy(addr1, header.i_addr1, ETHER_ADDR_LEN);
1652         bcopy(addr2, header.i_addr2, ETHER_ADDR_LEN);
1653         bcopy(addr3, header.i_addr3, ETHER_ADDR_LEN);
1654
1655         SRAM_WRITE_REGION(sc, bufp, (u_int8_t *)&header,
1656             sizeof(struct ieee80211_frame));
1657
1658         return (bufp + sizeof(struct ieee80211_frame));
1659 }
1660
1661 /*
1662  * Fill in a few loose ends and kick the card to send the packet
1663  *
1664  * Returns 0 on success, 1 on failure
1665  */
1666 static int
1667 ray_tx_send(struct ray_softc *sc, size_t ccs, int pktlen, u_int8_t *dst)
1668 {
1669         int i = 0;
1670
1671         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1672         RAY_MAP_CM(sc);
1673
1674         while (!RAY_ECF_READY(sc)) {
1675                 DELAY(RAY_ECF_SPIN_DELAY);
1676                 if (++i > RAY_ECF_SPIN_TRIES) {
1677                         RAY_RECERR(sc, "ECF busy, dropping packet");
1678                         RAY_CCS_FREE(sc, ccs);
1679                         return (1);
1680                 }
1681         }
1682         if (i != 0)
1683                 RAY_RECERR(sc, "spun %d times", i);
1684
1685         SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_len, pktlen);
1686         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_antenna,
1687             ray_tx_best_antenna(sc, dst));
1688         SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_CCS_INDEX(ccs));
1689         RAY_ECF_START_CMD(sc);
1690
1691         return (0);
1692 }
1693
1694 /*
1695  * Determine best antenna to use from rx level and antenna cache
1696  */
1697 static u_int8_t
1698 ray_tx_best_antenna(struct ray_softc *sc, u_int8_t *dst)
1699 {
1700         struct ray_siglev *sl;
1701         int i;
1702         u_int8_t antenna;
1703
1704         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1705
1706         if (sc->sc_version == RAY_ECFS_BUILD_4)
1707                 return (0);
1708
1709         /* try to find host */
1710         for (i = 0; i < RAY_NSIGLEVRECS; i++) {
1711                 sl = &sc->sc_siglevs[i];
1712                 if (bcmp(sl->rsl_host, dst, ETHER_ADDR_LEN) == 0)
1713                         goto found;
1714         }
1715         /* not found, return default setting */
1716         return (0);
1717
1718 found:
1719         /* This is a simple thresholding scheme that takes the mean
1720          * of the best antenna history. This is okay but as it is a
1721          * filter, it adds a bit of lag in situations where the
1722          * best antenna swaps from one side to the other slowly. Don't know
1723          * how likely this is given the horrible fading though.
1724          */
1725         antenna = 0;
1726         for (i = 0; i < RAY_NANTENNA; i++) {
1727                 antenna += sl->rsl_antennas[i];
1728         }
1729
1730         return (antenna > (RAY_NANTENNA >> 1));
1731 }
1732
1733 /*
1734  * Transmit now complete so clear ccs and network flags.
1735  */
1736 static void
1737 ray_tx_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
1738 {
1739         struct ifnet *ifp = &sc->arpcom.ac_if;
1740
1741         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_TX, "");
1742
1743         RAY_CCSERR(sc, status, if_oerrors);
1744
1745         RAY_CCS_FREE(sc, ccs);
1746         ifp->if_timer = 0;
1747         if (ifp->if_flags & IFF_OACTIVE)
1748             ifp->if_flags &= ~IFF_OACTIVE;
1749 }
1750
1751 /*
1752  * Receiver packet handling
1753  */
1754
1755 /*
1756  * Receive a packet from the card
1757  */
1758 static void
1759 ray_rx(struct ray_softc *sc, size_t rcs)
1760 {
1761         struct ieee80211_frame *header;
1762         struct ifnet *ifp = &sc->arpcom.ac_if;
1763         struct mbuf *m0;
1764         size_t pktlen, fraglen, readlen, tmplen;
1765         size_t bufp, ebufp;
1766         u_int8_t siglev, antenna;
1767         u_int first, ni, i;
1768         u_int8_t *mp;
1769
1770         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
1771         RAY_MAP_CM(sc);
1772
1773         RAY_DPRINTF(sc, RAY_DBG_CCS, "using rcs 0x%x", rcs);
1774
1775         m0 = NULL;
1776         readlen = 0;
1777
1778         /*
1779          * Get first part of packet and the length. Do some sanity checks
1780          * and get a mbuf.
1781          */
1782         first = RAY_CCS_INDEX(rcs);
1783         pktlen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_pktlen);
1784         siglev = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_siglev);
1785         antenna = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_antenna);
1786
1787         if ((pktlen > MCLBYTES) || (pktlen < sizeof(struct ieee80211_frame))) {
1788                 RAY_RECERR(sc, "packet too big or too small");
1789                 ifp->if_ierrors++;
1790                 goto skip_read;
1791         }
1792
1793         MGETHDR(m0, M_DONTWAIT, MT_DATA);
1794         if (m0 == NULL) {
1795                 RAY_RECERR(sc, "MGETHDR failed");
1796                 ifp->if_ierrors++;
1797                 goto skip_read;
1798         }
1799         if (pktlen > MHLEN) {
1800                 MCLGET(m0, M_DONTWAIT);
1801                 if (!(m0->m_flags & M_EXT)) {
1802                         RAY_RECERR(sc, "MCLGET failed");
1803                         ifp->if_ierrors++;
1804                         m_freem(m0);
1805                         m0 = NULL;
1806                         goto skip_read;
1807                 }
1808         }
1809         m0->m_pkthdr.rcvif = ifp;
1810         m0->m_pkthdr.len = pktlen;
1811         m0->m_len = pktlen;
1812         mp = mtod(m0, u_int8_t *);
1813
1814         /*
1815          * Walk the fragment chain to build the complete packet.
1816          *
1817          * The use of two index variables removes a race with the
1818          * hardware. If one index were used the clearing of the CCS would
1819          * happen before reading the next pointer and the hardware can get in.
1820          * Not my idea but verbatim from the NetBSD driver.
1821          */
1822         i = ni = first;
1823         while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
1824                 rcs = RAY_CCS_ADDRESS(i);
1825                 ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag);
1826                 bufp = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_bufp);
1827                 fraglen = SRAM_READ_FIELD_2(sc, rcs, ray_cmd_rx, c_len);
1828                 if (fraglen + readlen > pktlen) {
1829                         RAY_RECERR(sc, "bad length current 0x%x pktlen 0x%x",
1830                             fraglen + readlen, pktlen);
1831                         ifp->if_ierrors++;
1832                         m_freem(m0);
1833                         m0 = NULL;
1834                         goto skip_read;
1835                 }
1836                 if ((i < RAY_RCS_FIRST) || (i > RAY_RCS_LAST)) {
1837                         RAY_RECERR(sc, "bad rcs index 0x%x", i);
1838                         ifp->if_ierrors++;
1839                         m_freem(m0);
1840                         m0 = NULL;
1841                         goto skip_read;
1842                 }
1843
1844                 ebufp = bufp + fraglen;
1845                 if (ebufp <= RAY_RX_END)
1846                         SRAM_READ_REGION(sc, bufp, mp, fraglen);
1847                 else {
1848                         SRAM_READ_REGION(sc, bufp, mp,
1849                             (tmplen = RAY_RX_END - bufp));
1850                         SRAM_READ_REGION(sc, RAY_RX_BASE, mp + tmplen,
1851                             ebufp - RAY_RX_END);
1852                 }
1853                 mp += fraglen;
1854                 readlen += fraglen;
1855         }
1856
1857 skip_read:
1858
1859         /*
1860          * Walk the chain again to free the rcss.
1861          */
1862         i = ni = first;
1863         while ((i = ni) && (i != RAY_CCS_LINK_NULL)) {
1864                 rcs = RAY_CCS_ADDRESS(i);
1865                 ni = SRAM_READ_FIELD_1(sc, rcs, ray_cmd_rx, c_nextfrag);
1866                 RAY_CCS_FREE(sc, rcs);
1867         }
1868
1869         if (m0 == NULL)
1870                 return;
1871
1872         /*
1873          * Check the 802.11 packet type and hand off to
1874          * appropriate functions.
1875          */
1876         header = mtod(m0, struct ieee80211_frame *);
1877         if ((header->i_fc[0] & IEEE80211_FC0_VERSION_MASK)
1878             != IEEE80211_FC0_VERSION_0) {
1879                 RAY_RECERR(sc, "header not version 0 fc0 0x%x",
1880                     header->i_fc[0]);
1881                 ifp->if_ierrors++;
1882                 m_freem(m0);
1883                 return;
1884         }
1885         switch (header->i_fc[0] & IEEE80211_FC0_TYPE_MASK) {
1886
1887         case IEEE80211_FC0_TYPE_DATA:
1888                 ray_rx_data(sc, m0, siglev, antenna);
1889                 break;
1890
1891         case IEEE80211_FC0_TYPE_MGT:
1892                 ray_rx_mgt(sc, m0);
1893                 break;
1894
1895         case IEEE80211_FC0_TYPE_CTL:
1896                 ray_rx_ctl(sc, m0);
1897                 break;
1898
1899         default:
1900                 RAY_RECERR(sc, "unknown packet fc0 0x%x", header->i_fc[0]);
1901                 ifp->if_ierrors++;
1902                 m_freem(m0);
1903         }
1904 }
1905
1906 /*
1907  * Deal with DATA packet types
1908  */
1909 static void
1910 ray_rx_data(struct ray_softc *sc, struct mbuf *m0, u_int8_t siglev, u_int8_t antenna)
1911 {
1912         struct ifnet *ifp = &sc->arpcom.ac_if;
1913         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
1914         struct ether_header *eh;
1915         struct llc *llc;
1916         u_int8_t *sa = NULL, *da = NULL, *ra = NULL, *ta = NULL;
1917         int trim = 0;
1918
1919         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_RX, "");
1920
1921         /*
1922          * Check the the data packet subtype, some packets have
1923          * nothing in them so we will drop them here.
1924          */
1925         switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
1926
1927         case IEEE80211_FC0_SUBTYPE_DATA:
1928         case IEEE80211_FC0_SUBTYPE_CF_ACK:
1929         case IEEE80211_FC0_SUBTYPE_CF_POLL:
1930         case IEEE80211_FC0_SUBTYPE_CF_ACPL:
1931                 RAY_DPRINTF(sc, RAY_DBG_RX, "DATA packet");
1932                 break;
1933
1934         case IEEE80211_FC0_SUBTYPE_NODATA:
1935         case IEEE80211_FC0_SUBTYPE_CFACK:
1936         case IEEE80211_FC0_SUBTYPE_CFPOLL:
1937         case IEEE80211_FC0_SUBTYPE_CF_ACK_CF_ACK:
1938                 RAY_DPRINTF(sc, RAY_DBG_RX, "NULL packet");
1939                 m_freem(m0);
1940                 return;
1941                 break;
1942
1943         default:
1944                 RAY_RECERR(sc, "reserved DATA packet subtype 0x%x",
1945                     header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
1946                 ifp->if_ierrors++;
1947                 m_freem(m0);
1948                 return;
1949         }
1950
1951         /*
1952          * Parse the To DS and From DS fields to determine the length
1953          * of the 802.11 header for use later on.
1954          *
1955          * Additionally, furtle out the right destination and
1956          * source MAC addresses for the packet. Packets may come via
1957          * APs so the MAC addresses of the immediate node may be
1958          * different from the node that actually sent us the packet.
1959          *
1960          *      da      destination address of final recipient
1961          *      sa      source address of orginator
1962          *      ra      receiver address of immediate recipient
1963          *      ta      transmitter address of immediate orginator
1964          *
1965          * Address matching is performed on da or sa with the AP or
1966          * BSSID in ra and ta.
1967          */
1968         RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(1) packet before framing");
1969         switch (header->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
1970
1971         case IEEE80211_FC1_DIR_NODS:
1972                 da = ra = header->i_addr1;
1973                 sa = ta = header->i_addr2;
1974                 trim = sizeof(struct ieee80211_frame);
1975                 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D",
1976                     sa, ":", da, ":");
1977                 break;
1978
1979         case IEEE80211_FC1_DIR_FROMDS:
1980                 da = ra = header->i_addr1;
1981                 ta = header->i_addr2;
1982                 sa = header->i_addr3;
1983                 trim = sizeof(struct ieee80211_frame);
1984                 RAY_DPRINTF(sc, RAY_DBG_RX, "ap %6D from %6D to %6D",
1985                     ta, ":", sa, ":", da, ":");
1986                 break;
1987
1988         case IEEE80211_FC1_DIR_TODS:
1989                 ra = header->i_addr1;
1990                 sa = ta = header->i_addr2;
1991                 da = header->i_addr3;
1992                 trim = sizeof(struct ieee80211_frame);
1993                 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D ap %6D",
1994                     sa, ":", da, ":", ra, ":");
1995                 break;
1996
1997         case IEEE80211_FC1_DIR_DSTODS:
1998                 ra = header->i_addr1;
1999                 ta = header->i_addr2;
2000                 da = header->i_addr3;
2001                 sa = (u_int8_t *)header+1;
2002                 trim = sizeof(struct ieee80211_frame) + ETHER_ADDR_LEN;
2003                 RAY_DPRINTF(sc, RAY_DBG_RX, "from %6D to %6D ap %6D to %6D",
2004                     sa, ":", da, ":", ta, ":", ra, ":");
2005                 break;
2006         }
2007
2008         /*
2009          * Framing
2010          *
2011          * Each case must leave an Ethernet header and adjust trim.
2012          */
2013         switch (sc->sc_c.np_framing) {
2014
2015         case RAY_FRAMING_ENCAPSULATION:
2016                 /* A NOP as the Ethernet header is in the packet */
2017                 break;
2018
2019         case RAY_FRAMING_TRANSLATION:
2020                 /* Check that we have an LLC and SNAP sequence */
2021                 llc = (struct llc *)((u_int8_t *)header + trim);
2022                 if (llc->llc_dsap == LLC_SNAP_LSAP &&
2023                     llc->llc_ssap == LLC_SNAP_LSAP &&
2024                     llc->llc_control == LLC_UI &&
2025                     llc->llc_un.type_snap.org_code[0] == 0 &&
2026                     llc->llc_un.type_snap.org_code[1] == 0 &&
2027                     llc->llc_un.type_snap.org_code[2] == 0) {
2028                         /*
2029                          * This is not magic. RFC1042 header is 8
2030                          * bytes, with the last two bytes being the
2031                          * ether type. So all we need is another
2032                          * ETHER_ADDR_LEN bytes to write the
2033                          * destination into.
2034                          */
2035                         trim -= ETHER_ADDR_LEN;
2036                         eh = (struct ether_header *)((u_int8_t *)header + trim);
2037
2038                         /*
2039                          * Copy carefully to avoid mashing the MAC
2040                          * addresses. The address layout in the .11 header
2041                          * does make sense, honest, but it is a pain.
2042                          *
2043                          * NODS         da sa           no risk
2044                          * FROMDS       da ta sa        sa then da
2045                          * DSTODS       ra ta da sa     sa then da
2046                          * TODS         ra sa da        da then sa
2047                          */
2048                         if (sa > da) {
2049                                 /* Copy sa first */
2050                                 bcopy(sa, eh->ether_shost, ETHER_ADDR_LEN);
2051                                 bcopy(da, eh->ether_dhost, ETHER_ADDR_LEN);
2052                         } else {
2053                                 /* Copy da first */
2054                                 bcopy(da, eh->ether_dhost, ETHER_ADDR_LEN);
2055                                 bcopy(sa, eh->ether_shost, ETHER_ADDR_LEN);
2056                         }
2057
2058                 } else {
2059
2060                         /* Assume RAY_FRAMING_ENCAPSULATION */
2061                         RAY_RECERR(sc,
2062                             "got encapsulated packet but in translation mode");
2063
2064                 }
2065                 break;
2066
2067         default:
2068                 RAY_RECERR(sc, "unknown framing type %d", sc->sc_c.np_framing);
2069                 ifp->if_ierrors++;
2070                 m_freem(m0);
2071                 return;
2072         }
2073         RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(2) packet after framing");
2074
2075         /*
2076          * Finally, do a bit of house keeping before sending the packet
2077          * up the stack.
2078          */
2079         m_adj(m0, trim);
2080         RAY_MBUF_DUMP(sc, RAY_DBG_RX, m0, "(3) packet after trimming");
2081         ifp->if_ipackets++;
2082         ray_rx_update_cache(sc, header->i_addr2, siglev, antenna);
2083         eh = mtod(m0, struct ether_header *);
2084         m_adj(m0, sizeof(struct ether_header));
2085         ether_input(ifp, eh, m0);
2086 }
2087
2088 /*
2089  * Deal with MGT packet types
2090  */
2091 static void
2092 ray_rx_mgt(struct ray_softc *sc, struct mbuf *m0)
2093 {
2094         struct ifnet *ifp = &sc->arpcom.ac_if;
2095         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2096
2097         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2098
2099         if ((header->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
2100             IEEE80211_FC1_DIR_NODS) {
2101                 RAY_RECERR(sc, "MGT TODS/FROMDS wrong fc1 0x%x",
2102                     header->i_fc[1] & IEEE80211_FC1_DIR_MASK);
2103                 ifp->if_ierrors++;
2104                 m_freem(m0);
2105                 return;
2106         }
2107
2108         /*
2109          * Check the the mgt packet subtype, some packets should be
2110          * dropped depending on the mode the station is in. See pg
2111          * 52(60) of docs
2112          *
2113          * P - proccess, J - Junk, E - ECF deals with, I - Illegal
2114          * ECF Proccesses
2115          *  AHDOC procces or junk
2116          *   INFRA STA process or junk
2117          *    INFRA AP process or jumk
2118          *
2119          * +PPP IEEE80211_FC0_SUBTYPE_BEACON
2120          * +EEE IEEE80211_FC0_SUBTYPE_PROBE_REQ
2121          * +EEE IEEE80211_FC0_SUBTYPE_PROBE_RESP
2122          *  PPP IEEE80211_FC0_SUBTYPE_AUTH
2123          *  PPP IEEE80211_FC0_SUBTYPE_DEAUTH
2124          *  JJP IEEE80211_FC0_SUBTYPE_ASSOC_REQ
2125          *  JPJ IEEE80211_FC0_SUBTYPE_ASSOC_RESP
2126          *  JPP IEEE80211_FC0_SUBTYPE_DISASSOC
2127          *  JJP IEEE80211_FC0_SUBTYPE_REASSOC_REQ
2128          *  JPJ IEEE80211_FC0_SUBTYPE_REASSOC_RESP
2129          * +EEE IEEE80211_FC0_SUBTYPE_ATIM
2130          */
2131         RAY_MBUF_DUMP(sc, RAY_DBG_MGT, m0, "MGT packet");
2132         switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
2133
2134         case IEEE80211_FC0_SUBTYPE_BEACON:
2135                 RAY_DPRINTF(sc, RAY_DBG_MGT, "BEACON MGT packet");
2136                 ray_rx_mgt_beacon(sc, m0);
2137                 break;
2138
2139         case IEEE80211_FC0_SUBTYPE_AUTH:
2140                 RAY_DPRINTF(sc, RAY_DBG_MGT, "AUTH MGT packet");
2141                 ray_rx_mgt_auth(sc, m0);
2142                 break;
2143
2144         case IEEE80211_FC0_SUBTYPE_DEAUTH:
2145                 RAY_DPRINTF(sc, RAY_DBG_MGT, "DEAUTH MGT packet");
2146                 /* XXX ray_rx_mgt_deauth(sc, m0); */
2147                 break;
2148
2149         case IEEE80211_FC0_SUBTYPE_ASSOC_REQ:
2150         case IEEE80211_FC0_SUBTYPE_REASSOC_REQ:
2151                 RAY_DPRINTF(sc, RAY_DBG_MGT, "(RE)ASSOC_REQ MGT packet");
2152                 if ((sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2153                     (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_AP))
2154                         RAY_RECERR(sc, "can't be an AP yet"); /* XXX_ACTING_AP */
2155                 break;
2156
2157         case IEEE80211_FC0_SUBTYPE_ASSOC_RESP:
2158         case IEEE80211_FC0_SUBTYPE_REASSOC_RESP:
2159                 RAY_DPRINTF(sc, RAY_DBG_MGT, "(RE)ASSOC_RESP MGT packet");
2160                 if ((sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2161                     (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_TERMINAL))
2162                         RAY_RECERR(sc, "can't be in INFRA yet"); /* XXX_INFRA */
2163                 break;
2164
2165         case IEEE80211_FC0_SUBTYPE_DISASSOC:
2166                 RAY_DPRINTF(sc, RAY_DBG_MGT, "DISASSOC MGT packet");
2167                 if (sc->sc_c.np_net_type == RAY_MIB_NET_TYPE_INFRA)
2168                         RAY_RECERR(sc, "can't be in INFRA yet"); /* XXX_INFRA */
2169                 break;
2170
2171         case IEEE80211_FC0_SUBTYPE_PROBE_REQ:
2172         case IEEE80211_FC0_SUBTYPE_PROBE_RESP:
2173         case IEEE80211_FC0_SUBTYPE_ATIM:
2174                 RAY_RECERR(sc, "unexpected MGT packet subtype 0x%0x",
2175                     header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2176                 ifp->if_ierrors++;
2177                 break;
2178
2179         default:
2180                 RAY_RECERR(sc, "reserved MGT packet subtype 0x%x",
2181                     header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2182                 ifp->if_ierrors++;
2183         }
2184
2185         m_freem(m0);
2186 }
2187
2188 /*
2189  * Deal with BEACON management packet types
2190  * XXX furtle anything interesting out
2191  * XXX Note that there are rules governing what beacons to read
2192  * XXX see 8802 S7.2.3, S11.1.2.3
2193  * XXX is this actually useful?
2194  */
2195 static void
2196 ray_rx_mgt_beacon(struct ray_softc *sc, struct mbuf *m0)
2197 {
2198         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2199         ieee80211_mgt_beacon_t beacon = (u_int8_t *)(header+1);
2200         struct ieee80211_information elements;
2201
2202         u_int64_t *timestamp;
2203
2204         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2205
2206         timestamp = (u_int64_t *)beacon;
2207
2208 RAY_DPRINTF(sc, RAY_DBG_MGT, "timestamp\t0x%x", *timestamp);
2209 RAY_DPRINTF(sc, RAY_DBG_MGT, "interval\t\t0x%x", IEEE80211_BEACON_INTERVAL(beacon));
2210 RAY_DPRINTF(sc, RAY_DBG_MGT, "capability\t0x%x", IEEE80211_BEACON_CAPABILITY(beacon));
2211
2212         ray_rx_mgt_info(sc, m0, &elements);
2213
2214 }
2215
2216 static void
2217 ray_rx_mgt_info(struct ray_softc *sc, struct mbuf *m0, struct ieee80211_information *elements)
2218 {
2219         struct ifnet *ifp = &sc->arpcom.ac_if;
2220         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2221         ieee80211_mgt_beacon_t beacon = (u_int8_t *)(header+1);
2222         ieee80211_mgt_beacon_t bp, be;
2223         int len;
2224
2225         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_MGT, "");
2226
2227         bp = beacon + 12;
2228         be = mtod(m0, u_int8_t *) + m0->m_len;
2229
2230         while (bp < be) {
2231                 len = *(bp + 1);
2232                 RAY_DPRINTF(sc, RAY_DBG_MGT, "id 0x%02x length %d", *bp, len);
2233
2234                 switch (*bp) {
2235
2236                 case IEEE80211_ELEMID_SSID:
2237                         if (len  > IEEE80211_NWID_LEN) {
2238                                 RAY_RECERR(sc, "bad SSD length: %d from %6D",
2239                                     len, header->i_addr2, ":");
2240                         }
2241                         strncpy(elements->ssid, bp + 2, len);
2242                         elements->ssid[len] = 0;
2243                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2244                             "beacon ssid %s", elements->ssid);
2245                         break;
2246
2247                 case IEEE80211_ELEMID_RATES:
2248                         RAY_DPRINTF(sc, RAY_DBG_MGT, "rates");
2249                         break;
2250
2251                 case IEEE80211_ELEMID_FHPARMS:
2252                         elements->fh.dwell = bp[2] + (bp[3] << 8);
2253                         elements->fh.set = bp[4];
2254                         elements->fh.pattern = bp[5];
2255                         elements->fh.index = bp[6];
2256                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2257                             "fhparams dwell\t0x%04x", elements->fh.dwell);
2258                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2259                             "fhparams set\t0x%02x", elements->fh.set);
2260                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2261                             "fhparams pattern\t0x%02x", elements->fh.pattern);
2262                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2263                             "fhparams index\t0x%02x", elements->fh.index);
2264                         break;
2265
2266                 case IEEE80211_ELEMID_DSPARMS:
2267                         RAY_RECERR(sc, "got direct sequence params!");
2268                         break;
2269
2270                 case IEEE80211_ELEMID_CFPARMS:
2271                         RAY_DPRINTF(sc, RAY_DBG_MGT, "cfparams");
2272                         break;
2273
2274                 case IEEE80211_ELEMID_TIM:
2275                         elements->tim.count = bp[2];
2276                         elements->tim.period = bp[3];
2277                         elements->tim.bitctl = bp[4];
2278                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2279                             "tim count\t0x%02x", elements->tim.count);
2280                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2281                             "tim period\t0x%02x", elements->tim.period);
2282                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2283                             "tim bitctl\t0x%02x", elements->tim.bitctl);
2284 #if RAY_DEBUG & RAY_DBG_MGT
2285                         {
2286                                 int i;
2287                                 for (i = 5; i < len + 1; i++)
2288                                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2289                                             "tim pvt[%03d]\t0x%02x", i-5, bp[i]);
2290                         }
2291 #endif
2292                         break;
2293
2294                 case IEEE80211_ELEMID_IBSSPARMS:
2295                         elements->ibss.atim = bp[2] + (bp[3] << 8);
2296                         RAY_DPRINTF(sc, RAY_DBG_MGT,
2297                             "ibssparams atim\t0x%02x", elements->ibss.atim);
2298                         break;
2299
2300                 case IEEE80211_ELEMID_CHALLENGE:
2301                         RAY_DPRINTF(sc, RAY_DBG_MGT, "challenge");
2302                         break;
2303
2304                 default:
2305                         RAY_RECERR(sc, "reserved MGT element id 0x%x", *bp);
2306                         ifp->if_ierrors++;break;
2307                 }
2308                 bp += bp[1] + 2;
2309         }
2310 }
2311
2312 /*
2313  * Deal with AUTH management packet types
2314  */
2315 static void
2316 ray_rx_mgt_auth(struct ray_softc *sc, struct mbuf *m0)
2317 {
2318         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2319         ieee80211_mgt_auth_t auth = (u_int8_t *)(header+1);
2320
2321         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_AUTH, "");
2322
2323         switch (IEEE80211_AUTH_ALGORITHM(auth)) {
2324
2325         case IEEE80211_AUTH_ALG_OPEN:
2326                 RAY_DPRINTF(sc, RAY_DBG_AUTH,
2327                     "open system authentication sequence number %d",
2328                     IEEE80211_AUTH_TRANSACTION(auth));
2329                 if (IEEE80211_AUTH_TRANSACTION(auth) ==
2330                     IEEE80211_AUTH_OPEN_REQUEST) {
2331
2332 /* XXX_AUTH use ray_init_auth_send */
2333
2334                 } else if (IEEE80211_AUTH_TRANSACTION(auth) ==
2335                     IEEE80211_AUTH_OPEN_RESPONSE)
2336                         ray_init_auth_done(sc, IEEE80211_AUTH_STATUS(auth));
2337                 break;
2338
2339         case IEEE80211_AUTH_ALG_SHARED:
2340                 RAY_RECERR(sc,
2341                     "shared key authentication sequence number %d",
2342                     IEEE80211_AUTH_TRANSACTION(auth));
2343                 break;
2344
2345         default:
2346                 RAY_RECERR(sc,
2347                     "reserved authentication subtype 0x%04hx",
2348                     IEEE80211_AUTH_ALGORITHM(auth));
2349                 break;
2350         }
2351 }
2352
2353 /*
2354  * Deal with CTL packet types
2355  */
2356 static void
2357 ray_rx_ctl(struct ray_softc *sc, struct mbuf *m0)
2358 {
2359         struct ifnet *ifp = &sc->arpcom.ac_if;
2360         struct ieee80211_frame *header = mtod(m0, struct ieee80211_frame *);
2361
2362         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CTL, "");
2363
2364         if ((header->i_fc[1] & IEEE80211_FC1_DIR_MASK) !=
2365             IEEE80211_FC1_DIR_NODS) {
2366                 RAY_RECERR(sc, "CTL TODS/FROMDS wrong fc1 0x%x",
2367                     header->i_fc[1] & IEEE80211_FC1_DIR_MASK);
2368                 ifp->if_ierrors++;
2369                 m_freem(m0);
2370                 return;
2371         }
2372
2373         /*
2374          * Check the the ctl packet subtype, some packets should be
2375          * dropped depending on the mode the station is in. The ECF
2376          * should deal with everything but the power save poll to an
2377          * AP. See pg 52(60) of docs.
2378          */
2379         RAY_MBUF_DUMP(sc, RAY_DBG_CTL, m0, "CTL packet");
2380         switch (header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) {
2381
2382         case IEEE80211_FC0_SUBTYPE_PS_POLL:
2383                 RAY_DPRINTF(sc, RAY_DBG_CTL, "PS_POLL CTL packet");
2384                 if ((sc->sc_d.np_net_type == RAY_MIB_NET_TYPE_INFRA) &&
2385                     (sc->sc_c.np_ap_status == RAY_MIB_AP_STATUS_AP))
2386                         RAY_RECERR(sc, "can't be an AP yet"); /* XXX_ACTING_AP */
2387                 break;
2388
2389         case IEEE80211_FC0_SUBTYPE_RTS:
2390         case IEEE80211_FC0_SUBTYPE_CTS:
2391         case IEEE80211_FC0_SUBTYPE_ACK:
2392         case IEEE80211_FC0_SUBTYPE_CF_END:
2393         case IEEE80211_FC0_SUBTYPE_CF_END_ACK:
2394                 RAY_RECERR(sc, "unexpected CTL packet subtype 0x%0x",
2395                     header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2396                 ifp->if_ierrors++;
2397                 break;
2398
2399         default:
2400                 RAY_RECERR(sc, "reserved CTL packet subtype 0x%x",
2401                     header->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK);
2402                 ifp->if_ierrors++;
2403         }
2404
2405         m_freem(m0);
2406 }
2407
2408 /*
2409  * Update rx level and antenna cache
2410  */
2411 static void
2412 ray_rx_update_cache(struct ray_softc *sc, u_int8_t *src, u_int8_t siglev, u_int8_t antenna)
2413 {
2414         struct timeval mint;
2415         struct ray_siglev *sl;
2416         int i, mini;
2417
2418         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2419
2420         /* Try to find host */
2421         for (i = 0; i < RAY_NSIGLEVRECS; i++) {
2422                 sl = &sc->sc_siglevs[i];
2423                 if (bcmp(sl->rsl_host, src, ETHER_ADDR_LEN) == 0)
2424                         goto found;
2425         }
2426         /* Not found, find oldest slot */
2427         mini = 0;
2428         mint.tv_sec = LONG_MAX;
2429         mint.tv_usec = 0;
2430         for (i = 0; i < RAY_NSIGLEVRECS; i++) {
2431                 sl = &sc->sc_siglevs[i];
2432                 if (timevalcmp(&sl->rsl_time, &mint, <)) {
2433                         mini = i;
2434                         mint = sl->rsl_time;
2435                 }
2436         }
2437         sl = &sc->sc_siglevs[mini];
2438         bzero(sl->rsl_siglevs, RAY_NSIGLEV);
2439         bzero(sl->rsl_antennas, RAY_NANTENNA);
2440         bcopy(src, sl->rsl_host, ETHER_ADDR_LEN);
2441
2442 found:
2443         microtime(&sl->rsl_time);
2444         bcopy(sl->rsl_siglevs, &sl->rsl_siglevs[1], RAY_NSIGLEV-1);
2445         sl->rsl_siglevs[0] = siglev;
2446         if (sc->sc_version != RAY_ECFS_BUILD_4) {
2447                 bcopy(sl->rsl_antennas, &sl->rsl_antennas[1], RAY_NANTENNA-1);
2448                 sl->rsl_antennas[0] = antenna;
2449         }
2450 }
2451
2452 /*
2453  * Interrupt handling
2454  */
2455
2456 /*
2457  * Process an interrupt
2458  */
2459 static void
2460 ray_intr(void *xsc)
2461 {
2462         struct ray_softc *sc = (struct ray_softc *)xsc;
2463         struct ifnet *ifp = &sc->arpcom.ac_if;
2464         size_t ccs;
2465         u_int8_t cmd, status;
2466         int ccsi;
2467
2468         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2469         RAY_MAP_CM(sc);
2470
2471         if ((sc == NULL) || (sc->sc_gone))
2472                 return;
2473
2474         /*
2475          * Check that the interrupt was for us, if so get the rcs/ccs
2476          * and vector on the command contained within it.
2477          */
2478         if (RAY_HCS_INTR(sc)) {
2479                 ccsi = SRAM_READ_1(sc, RAY_SCB_RCSI);
2480                 ccs = RAY_CCS_ADDRESS(ccsi);
2481                 cmd = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_cmd);
2482                 status = SRAM_READ_FIELD_1(sc, ccs, ray_cmd, c_status);
2483                 if (ccsi <= RAY_CCS_LAST)
2484                         ray_intr_ccs(sc, cmd, status, ccs);
2485                 else if (ccsi <= RAY_RCS_LAST)
2486                         ray_intr_rcs(sc, cmd, ccs);
2487                 else
2488                     RAY_RECERR(sc, "bad ccs index 0x%x", ccsi);
2489                 RAY_HCS_CLEAR_INTR(sc);
2490         }
2491
2492         /* Send any packets lying around and update error counters */
2493         if (!(ifp->if_flags & IFF_OACTIVE) && (ifp->if_snd.ifq_head != NULL))
2494                 ray_tx(ifp);
2495         if ((++sc->sc_checkcounters % 32) == 0)
2496                 ray_intr_updt_errcntrs(sc);
2497 }
2498
2499 /*
2500  * Read the error counters.
2501  */
2502 static void
2503 ray_intr_updt_errcntrs(struct ray_softc *sc)
2504 {
2505         size_t csc;
2506
2507         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2508         RAY_MAP_CM(sc);
2509
2510         /*
2511          * The card implements the following protocol to keep the
2512          * values from being changed while read: It checks the `own'
2513          * bit and if zero writes the current internal counter value,
2514          * it then sets the `own' bit to 1. If the `own' bit was 1 it
2515          * incremenets its internal counter. The user thus reads the
2516          * counter if the `own' bit is one and then sets the own bit
2517          * to 0.
2518          */
2519         csc = RAY_STATUS_BASE;
2520         if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxo_own)) {
2521                 sc->sc_rxoverflow +=
2522                     SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
2523                 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxo_own, 0);
2524         }
2525         if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_mrxc_own)) {
2526                 sc->sc_rxcksum +=
2527                     SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_mrx_overflow);
2528                 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_mrxc_own, 0);
2529         }
2530         if (SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rxhc_own)) {
2531                 sc->sc_rxhcksum +=
2532                     SRAM_READ_FIELD_2(sc, csc, ray_csc, csc_rx_hcksum);
2533                 SRAM_WRITE_FIELD_1(sc, csc, ray_csc, csc_rxhc_own, 0);
2534         }
2535         sc->sc_rxnoise = SRAM_READ_FIELD_1(sc, csc, ray_csc, csc_rx_noise);
2536 }
2537
2538 /*
2539  * Process CCS command completion
2540  */
2541 static void
2542 ray_intr_ccs(struct ray_softc *sc, u_int8_t cmd, u_int8_t status, size_t ccs)
2543 {
2544         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2545
2546         switch (cmd) {
2547
2548         case RAY_CMD_DOWNLOAD_PARAMS:
2549                 RAY_DPRINTF(sc, RAY_DBG_COM, "START_PARAMS");
2550                 ray_init_download_done(sc, status, ccs);
2551                 break;
2552
2553         case RAY_CMD_UPDATE_PARAMS:
2554                 RAY_DPRINTF(sc, RAY_DBG_COM, "UPDATE_PARAMS");
2555                 ray_upparams_done(sc, status, ccs);
2556                 break;
2557
2558         case RAY_CMD_REPORT_PARAMS:
2559                 RAY_DPRINTF(sc, RAY_DBG_COM, "REPORT_PARAMS");
2560                 ray_repparams_done(sc, status, ccs);
2561                 break;
2562
2563         case RAY_CMD_UPDATE_MCAST:
2564                 RAY_DPRINTF(sc, RAY_DBG_COM, "UPDATE_MCAST");
2565                 ray_mcast_done(sc, status, ccs);
2566                 break;
2567
2568         case RAY_CMD_START_NET:
2569         case RAY_CMD_JOIN_NET:
2570                 RAY_DPRINTF(sc, RAY_DBG_COM, "START|JOIN_NET");
2571                 ray_init_sj_done(sc, status, ccs);
2572                 break;
2573
2574         case RAY_CMD_TX_REQ:
2575                 RAY_DPRINTF(sc, RAY_DBG_COM, "TX_REQ");
2576                 ray_tx_done(sc, status, ccs);
2577                 break;
2578
2579         case RAY_CMD_START_ASSOC:
2580                 RAY_DPRINTF(sc, RAY_DBG_COM, "START_ASSOC");
2581                 ray_init_assoc_done(sc, status, ccs);
2582                 break;
2583
2584         case RAY_CMD_UPDATE_APM:
2585                 RAY_RECERR(sc, "unexpected UPDATE_APM");
2586                 break;
2587
2588         case RAY_CMD_TEST_MEM:
2589                 RAY_RECERR(sc, "unexpected TEST_MEM");
2590                 break;
2591
2592         case RAY_CMD_SHUTDOWN:
2593                 RAY_RECERR(sc, "unexpected SHUTDOWN");
2594                 break;
2595
2596         case RAY_CMD_DUMP_MEM:
2597                 RAY_RECERR(sc, "unexpected DUMP_MEM");
2598                 break;
2599
2600         case RAY_CMD_START_TIMER:
2601                 RAY_RECERR(sc, "unexpected START_TIMER");
2602                 break;
2603
2604         default:
2605                 RAY_RECERR(sc, "unknown command 0x%x", cmd);
2606                 break;
2607         }
2608 }
2609
2610 /*
2611  * Process ECF command request
2612  */
2613 static void
2614 ray_intr_rcs(struct ray_softc *sc, u_int8_t cmd, size_t rcs)
2615 {
2616         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2617
2618         switch (cmd) {
2619
2620         case RAY_ECMD_RX_DONE:
2621                 RAY_DPRINTF(sc, RAY_DBG_RX, "RX_DONE");
2622                 ray_rx(sc, rcs);
2623                 break;
2624
2625         case RAY_ECMD_REJOIN_DONE:
2626                 RAY_DPRINTF(sc, RAY_DBG_RX, "REJOIN_DONE");
2627                 sc->sc_c.np_havenet = 1; /* XXX Should not be here but in function */
2628                 break;
2629
2630         case RAY_ECMD_ROAM_START:
2631                 RAY_DPRINTF(sc, RAY_DBG_RX, "ROAM_START");
2632                 sc->sc_c.np_havenet = 0; /* XXX Should not be here but in function */
2633                 break;
2634
2635         case RAY_ECMD_JAPAN_CALL_SIGNAL:
2636                 RAY_RECERR(sc, "unexpected JAPAN_CALL_SIGNAL");
2637                 break;
2638
2639         default:
2640                 RAY_RECERR(sc, "unknown command 0x%x", cmd);
2641                 break;
2642         }
2643
2644         RAY_CCS_FREE(sc, rcs);
2645 }
2646
2647 /*
2648  * User land entry to multicast list changes
2649  */
2650 static int
2651 ray_mcast_user(struct ray_softc *sc)
2652 {
2653         struct ray_comq_entry *com[2];
2654         int error, ncom;
2655
2656         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2657
2658         /*
2659          * Do all checking in the runq to preserve ordering.
2660          *
2661          * We run promisc to pick up changes to the ALL_MULTI
2662          * interface flag.
2663          */
2664         ncom = 0;
2665         com[ncom++] = RAY_COM_MALLOC(ray_mcast, 0);
2666         com[ncom++] = RAY_COM_MALLOC(ray_promisc, 0);
2667
2668         RAY_COM_RUNQ(sc, com, ncom, "raymcast", error);
2669
2670         /* XXX no real error processing from anything yet! */
2671
2672         RAY_COM_FREE(com, ncom);
2673
2674         return (error);
2675 }
2676
2677 /*
2678  * Runq entry to setting the multicast filter list
2679  *
2680  * MUST always be followed by a call to ray_promisc to pick up changes
2681  * to promisc flag
2682  */
2683 static void
2684 ray_mcast(struct ray_softc *sc, struct ray_comq_entry *com)
2685 {
2686         struct ifnet *ifp = &sc->arpcom.ac_if;
2687         struct ifmultiaddr *ifma;
2688         size_t bufp;
2689         int count = 0;
2690
2691         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2692         RAY_MAP_CM(sc);
2693
2694         /*
2695          * If card is not running we don't need to update this.
2696          */
2697         if (!(ifp->if_flags & IFF_RUNNING)) {
2698                 RAY_DPRINTF(sc, RAY_DBG_IOCTL, "not running");
2699                 ray_com_runq_done(sc);
2700                 return;
2701         }
2702
2703         /*
2704          * The multicast list is only 16 items long so use promiscuous
2705          * mode and don't bother updating the multicast list.
2706          */
2707         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
2708             ifma = ifma->ifma_link.le_next)
2709                 count++;
2710         if (count == 0) {
2711                 ray_com_runq_done(sc);
2712                 return;
2713         } else if (count > 16) {
2714                 ifp->if_flags |= IFF_ALLMULTI;
2715                 ray_com_runq_done(sc);
2716                 return;
2717         } else if (ifp->if_flags & IFF_ALLMULTI)
2718                 ifp->if_flags &= ~IFF_ALLMULTI;
2719
2720         /*
2721          * Kick the card
2722          */
2723         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_MCAST);
2724         SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2725             ray_cmd_update_mcast, c_nmcast, count);
2726         bufp = RAY_HOST_TO_ECF_BASE;
2727         for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
2728             ifma = ifma->ifma_link.le_next) {
2729                 SRAM_WRITE_REGION(
2730                     sc,
2731                     bufp,
2732                     LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
2733                     ETHER_ADDR_LEN
2734                 );
2735                 bufp += ETHER_ADDR_LEN;
2736         }
2737
2738         ray_com_ecf(sc, com);
2739 }
2740
2741 /*
2742  * Complete the multicast filter list update
2743  */
2744 static void
2745 ray_mcast_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
2746 {
2747         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_STARTJOIN, "");
2748         RAY_COM_CHECK(sc, ccs);
2749
2750         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
2751
2752         ray_com_ecf_done(sc);
2753 }
2754
2755 /*
2756  * Runq entry to set/reset promiscuous mode
2757  */
2758 static void
2759 ray_promisc(struct ray_softc *sc, struct ray_comq_entry *com)
2760 {
2761         struct ifnet *ifp = &sc->arpcom.ac_if;
2762
2763         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2764         RAY_MAP_CM(sc);
2765
2766         /*
2767          * If card not running or we already have the right flags
2768          * we don't need to update this
2769          */
2770         sc->sc_d.np_promisc = !!(ifp->if_flags & (IFF_PROMISC | IFF_ALLMULTI));
2771         if (!(ifp->if_flags & IFF_RUNNING) ||
2772             (sc->sc_c.np_promisc == sc->sc_d.np_promisc)) {
2773                 ray_com_runq_done(sc);
2774                 return;
2775         }
2776
2777         /*
2778          * Kick the card
2779          */
2780         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_PARAMS);
2781         SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2782             ray_cmd_update, c_paramid, RAY_MIB_PROMISC);
2783         SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update, c_nparam, 1);
2784         SRAM_WRITE_1(sc, RAY_HOST_TO_ECF_BASE, sc->sc_d.np_promisc);
2785
2786         ray_com_ecf(sc, com);
2787 }
2788
2789 /*
2790  * User land entry to parameter reporting
2791  *
2792  * As we by pass the runq to report current parameters this function
2793  * only provides a snap shot of the driver's state.
2794  */
2795 static int
2796 ray_repparams_user(struct ray_softc *sc, struct ray_param_req *pr)
2797 {
2798         struct ray_comq_entry *com[1];
2799         int error, ncom;
2800
2801         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2802
2803         /*
2804          * Test for illegal values or immediate responses
2805          */
2806         if (pr->r_paramid > RAY_MIB_MAX)
2807                 return (EINVAL);
2808         if ((sc->sc_version == RAY_ECFS_BUILD_4) &&
2809             !(mib_info[pr->r_paramid][0] & RAY_V4))
2810                 return (EINVAL);
2811         if ((sc->sc_version == RAY_ECFS_BUILD_5) &&
2812             !(mib_info[pr->r_paramid][0] & RAY_V5))
2813                 return (EINVAL);
2814         if (pr->r_paramid > RAY_MIB_LASTUSER) {
2815                 switch (pr->r_paramid) {
2816
2817                 case  RAY_MIB_VERSION:
2818                         if (sc->sc_version == RAY_ECFS_BUILD_4)
2819                             *pr->r_data = RAY_V4;
2820                         else
2821                             *pr->r_data = RAY_V5;
2822                         break;
2823                 case  RAY_MIB_CUR_BSSID:
2824                         bcopy(sc->sc_c.np_bss_id, pr->r_data, ETHER_ADDR_LEN);
2825                         break;
2826                 case  RAY_MIB_CUR_INITED:
2827                         *pr->r_data = sc->sc_c.np_inited;
2828                         break;
2829                 case  RAY_MIB_CUR_DEF_TXRATE:
2830                         *pr->r_data = sc->sc_c.np_def_txrate;
2831                         break;
2832                 case  RAY_MIB_CUR_ENCRYPT:
2833                         *pr->r_data = sc->sc_c.np_encrypt;
2834                         break;
2835                 case  RAY_MIB_CUR_NET_TYPE:
2836                         *pr->r_data = sc->sc_c.np_net_type;
2837                         break;
2838                 case  RAY_MIB_CUR_SSID:
2839                         bcopy(sc->sc_c.np_ssid, pr->r_data, IEEE80211_NWID_LEN);
2840                         break;
2841                 case  RAY_MIB_CUR_PRIV_START:
2842                         *pr->r_data = sc->sc_c.np_priv_start;
2843                         break;
2844                 case  RAY_MIB_CUR_PRIV_JOIN:
2845                         *pr->r_data = sc->sc_c.np_priv_join;
2846                         break;
2847                 case  RAY_MIB_DES_BSSID:
2848                         bcopy(sc->sc_d.np_bss_id, pr->r_data, ETHER_ADDR_LEN);
2849                         break;
2850                 case  RAY_MIB_DES_INITED:
2851                         *pr->r_data = sc->sc_d.np_inited;
2852                         break;
2853                 case  RAY_MIB_DES_DEF_TXRATE:
2854                         *pr->r_data = sc->sc_d.np_def_txrate;
2855                         break;
2856                 case  RAY_MIB_DES_ENCRYPT:
2857                         *pr->r_data = sc->sc_d.np_encrypt;
2858                         break;
2859                 case  RAY_MIB_DES_NET_TYPE:
2860                         *pr->r_data = sc->sc_d.np_net_type;
2861                         break;
2862                 case  RAY_MIB_DES_SSID:
2863                         bcopy(sc->sc_d.np_ssid, pr->r_data, IEEE80211_NWID_LEN);
2864                         break;
2865                 case  RAY_MIB_DES_PRIV_START:
2866                         *pr->r_data = sc->sc_d.np_priv_start;
2867                         break;
2868                 case  RAY_MIB_DES_PRIV_JOIN:
2869                         *pr->r_data = sc->sc_d.np_priv_join;
2870                         break;
2871                 case  RAY_MIB_CUR_AP_STATUS:
2872                         *pr->r_data = sc->sc_c.np_ap_status;
2873                         break;
2874                 case  RAY_MIB_CUR_PROMISC:
2875                         *pr->r_data = sc->sc_c.np_promisc;
2876                         break;
2877                 case  RAY_MIB_DES_AP_STATUS:
2878                         *pr->r_data = sc->sc_d.np_ap_status;
2879                         break;
2880                 case  RAY_MIB_DES_PROMISC:
2881                         *pr->r_data = sc->sc_d.np_promisc;
2882                         break;
2883                 case RAY_MIB_CUR_FRAMING:
2884                         *pr->r_data = sc->sc_c.np_framing;
2885                         break;
2886                 case RAY_MIB_DES_FRAMING:
2887                         *pr->r_data = sc->sc_d.np_framing;
2888                         break;
2889
2890                 default:
2891                         return (EINVAL);
2892                         break;
2893                 }
2894                 pr->r_failcause = 0;
2895                 if (sc->sc_version == RAY_ECFS_BUILD_4)
2896                     pr->r_len = mib_info[pr->r_paramid][RAY_MIB_INFO_SIZ4];
2897                 else if (sc->sc_version == RAY_ECFS_BUILD_5)
2898                     pr->r_len = mib_info[pr->r_paramid][RAY_MIB_INFO_SIZ5];
2899                 return (0);
2900         }
2901
2902         pr->r_failcause = 0;
2903         ncom = 0;
2904         com[ncom++] = RAY_COM_MALLOC(ray_repparams, RAY_COM_FWOK);
2905         com[ncom-1]->c_pr = pr;
2906
2907         RAY_COM_RUNQ(sc, com, ncom, "rayrparm", error);
2908
2909         /* XXX no real error processing from anything yet! */
2910         if (!com[0]->c_retval && pr->r_failcause)
2911                 error = EINVAL;
2912
2913         RAY_COM_FREE(com, ncom);
2914
2915         return (error);
2916 }
2917
2918 /*
2919  * Runq entry to read the required parameter
2920  *
2921  * The card and driver are happy for parameters to be read
2922  * whenever the card is plugged in
2923  */
2924 static void
2925 ray_repparams(struct ray_softc *sc, struct ray_comq_entry *com)
2926 {
2927         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2928         RAY_MAP_CM(sc);
2929
2930         /*
2931          * Kick the card
2932          */
2933         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_REPORT_PARAMS);
2934         SRAM_WRITE_FIELD_1(sc, com->c_ccs,
2935             ray_cmd_report, c_paramid, com->c_pr->r_paramid);
2936         SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_report, c_nparam, 1);
2937
2938         ray_com_ecf(sc, com);
2939 }
2940
2941 /*
2942  * Complete the parameter reporting
2943  */
2944 static void
2945 ray_repparams_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
2946 {
2947         struct ray_comq_entry *com;
2948
2949         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2950         RAY_MAP_CM(sc);
2951         RAY_COM_CHECK(sc, ccs);
2952
2953         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
2954
2955         com = TAILQ_FIRST(&sc->sc_comq);
2956         com->c_pr->r_failcause =
2957             SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_failcause);
2958         com->c_pr->r_len =
2959             SRAM_READ_FIELD_1(sc, ccs, ray_cmd_report, c_len);
2960         SRAM_READ_REGION(sc, RAY_ECF_TO_HOST_BASE,
2961             com->c_pr->r_data, com->c_pr->r_len);
2962
2963         ray_com_ecf_done(sc);
2964 }
2965
2966 /*
2967  * User land entry (and exit) to the error counters
2968  */
2969 static int
2970 ray_repstats_user(struct ray_softc *sc, struct ray_stats_req *sr)
2971 {
2972         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2973
2974         sr->rxoverflow = sc->sc_rxoverflow;
2975         sr->rxcksum = sc->sc_rxcksum;
2976         sr->rxhcksum = sc->sc_rxhcksum;
2977         sr->rxnoise = sc->sc_rxnoise;
2978
2979         return (0);
2980 }
2981
2982 /*
2983  * User land entry to parameter update changes
2984  *
2985  * As a parameter change can cause the network parameters to be
2986  * invalid we have to re-start/join.
2987  */
2988 static int
2989 ray_upparams_user(struct ray_softc *sc, struct ray_param_req *pr)
2990 {
2991         struct ray_comq_entry *com[4];
2992         int error, ncom, todo;
2993 #define RAY_UPP_SJ      0x1
2994 #define RAY_UPP_PARAMS  0x2
2995
2996         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
2997
2998         /*
2999          * Check that the parameter is available based on firmware version
3000          */
3001         pr->r_failcause = 0;
3002         if (pr->r_paramid > RAY_MIB_LASTUSER)
3003                 return (EINVAL);
3004         if ((sc->sc_version == RAY_ECFS_BUILD_4) &&
3005             !(mib_info[pr->r_paramid][0] & RAY_V4))
3006                 return (EINVAL);
3007         if ((sc->sc_version == RAY_ECFS_BUILD_5) &&
3008             !(mib_info[pr->r_paramid][0] & RAY_V5))
3009                 return (EINVAL);
3010
3011         /*
3012          * Handle certain parameters specially
3013          */
3014         todo = 0;
3015         switch (pr->r_paramid) {
3016         case RAY_MIB_NET_TYPE:          /* Updated via START_NET JOIN_NET  */
3017                 sc->sc_d.np_net_type = *pr->r_data;
3018                 todo |= RAY_UPP_SJ;
3019                 break;
3020
3021         case RAY_MIB_SSID:              /* Updated via START_NET JOIN_NET  */
3022                 bcopy(pr->r_data, sc->sc_d.np_ssid, IEEE80211_NWID_LEN);
3023                 todo |= RAY_UPP_SJ;
3024                 break;
3025
3026         case RAY_MIB_PRIVACY_MUST_START:/* Updated via START_NET */
3027                 if (sc->sc_c.np_net_type != RAY_MIB_NET_TYPE_ADHOC)
3028                         return (EINVAL);
3029                 sc->sc_d.np_priv_start = *pr->r_data;
3030                 todo |= RAY_UPP_SJ;
3031                 break;
3032
3033         case RAY_MIB_PRIVACY_CAN_JOIN:  /* Updated via START_NET JOIN_NET  */
3034                 sc->sc_d.np_priv_join = *pr->r_data;
3035                 todo |= RAY_UPP_SJ;
3036                 break;
3037
3038         case RAY_MIB_BASIC_RATE_SET:
3039                 sc->sc_d.np_def_txrate = *pr->r_data;
3040                 todo |= RAY_UPP_PARAMS;
3041                 break;
3042
3043         case RAY_MIB_AP_STATUS: /* Unsupported */
3044         case RAY_MIB_MAC_ADDR:  /* XXX Need interface up but could be done */
3045         case RAY_MIB_PROMISC:   /* BPF */
3046                 return (EINVAL);
3047                 break;
3048
3049         default:
3050                 todo |= RAY_UPP_PARAMS;
3051                 todo |= RAY_UPP_SJ;
3052                 break;
3053         }
3054
3055         /*
3056          * Generate the runq entries as needed
3057          */
3058         ncom = 0;
3059         if (todo & RAY_UPP_PARAMS) {
3060                 com[ncom++] = RAY_COM_MALLOC(ray_upparams, 0);
3061                 com[ncom-1]->c_pr = pr;
3062         }
3063         if (todo & RAY_UPP_SJ) {
3064                 com[ncom++] = RAY_COM_MALLOC(ray_init_sj, 0);
3065                 com[ncom++] = RAY_COM_MALLOC(ray_init_auth, 0);
3066                 com[ncom++] = RAY_COM_MALLOC(ray_init_assoc, 0);
3067         }
3068
3069         RAY_COM_RUNQ(sc, com, ncom, "rayuparam", error);
3070
3071         /* XXX no real error processing from anything yet! */
3072         if (!com[0]->c_retval && pr->r_failcause)
3073                 error = EINVAL;
3074
3075         RAY_COM_FREE(com, ncom);
3076
3077         return (error);
3078 }
3079
3080 /*
3081  * Runq entry to update a parameter
3082  *
3083  * The card and driver are happy for parameters to be updated
3084  * whenever the card is plugged in
3085  *
3086  * XXX the above is a little bit of a lie until _download is sorted out and we
3087  * XXX keep local copies of things
3088  */
3089 static void
3090 ray_upparams(struct ray_softc *sc, struct ray_comq_entry *com)
3091 {
3092         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3093         RAY_MAP_CM(sc);
3094
3095         ray_ccs_fill(sc, com->c_ccs, RAY_CMD_UPDATE_PARAMS);
3096
3097         SRAM_WRITE_FIELD_1(sc, com->c_ccs,
3098             ray_cmd_update, c_paramid, com->c_pr->r_paramid);
3099         SRAM_WRITE_FIELD_1(sc, com->c_ccs, ray_cmd_update, c_nparam, 1);
3100         SRAM_WRITE_REGION(sc, RAY_HOST_TO_ECF_BASE,
3101             com->c_pr->r_data, com->c_pr->r_len);
3102
3103         ray_com_ecf(sc, com);
3104 }
3105
3106 /*
3107  * Complete the parameter update, note that promisc finishes up here too
3108  */
3109 static void
3110 ray_upparams_done(struct ray_softc *sc, u_int8_t status, size_t ccs)
3111 {
3112         struct ray_comq_entry *com;
3113
3114         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3115         RAY_MAP_CM(sc);
3116         RAY_COM_CHECK(sc, ccs);
3117
3118         RAY_CCSERR(sc, status, if_oerrors); /* XXX error counter */
3119
3120         com = TAILQ_FIRST(&sc->sc_comq);
3121
3122         switch (SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_paramid)) {
3123
3124         case RAY_MIB_PROMISC:
3125                 sc->sc_c.np_promisc = SRAM_READ_1(sc, RAY_HOST_TO_ECF_BASE);
3126                 RAY_DPRINTF(sc, RAY_DBG_IOCTL,
3127                     "promisc value %d", sc->sc_c.np_promisc);
3128                 break;
3129
3130         default:
3131                 com->c_pr->r_failcause =
3132                     SRAM_READ_FIELD_1(sc, ccs, ray_cmd_update, c_failcause);
3133                 break;
3134
3135         }
3136
3137         ray_com_ecf_done(sc);
3138 }
3139
3140 /*
3141  * Command queuing and execution
3142  */
3143
3144 /*
3145  * Set up a comq entry struct
3146  */
3147 static struct ray_comq_entry *
3148 ray_com_init(struct ray_comq_entry *com, ray_comqfn_t function, int flags, char *mesg)
3149 {
3150         com->c_function = function;
3151         com->c_flags = flags;
3152         com->c_retval = 0;
3153         com->c_ccs = NULL;
3154         com->c_wakeup = NULL;
3155         com->c_pr = NULL;
3156         com->c_mesg = mesg;
3157
3158         return (com);
3159 }
3160
3161 /*
3162  * Malloc and set up a comq entry struct
3163  */
3164 static struct ray_comq_entry *
3165 ray_com_malloc(ray_comqfn_t function, int flags, char *mesg)
3166 {
3167         struct ray_comq_entry *com;
3168
3169         MALLOC(com, struct ray_comq_entry *,
3170             sizeof(struct ray_comq_entry), M_RAYCOM, M_WAITOK);
3171
3172         return (ray_com_init(com, function, flags, mesg));
3173 }
3174
3175 /*
3176  * Add an array of commands to the runq, get some ccs's for them and
3177  * then run, waiting on the last command.
3178  *
3179  * We add the commands to the queue first to preserve ioctl ordering.
3180  *
3181  * On recoverable errors, this routine removes the entries from the
3182  * runq. A caller can requeue the commands (and still preserve its own
3183  * processes ioctl ordering) but doesn't have to. When the card is
3184  * detached we get out quickly to prevent panics and don't bother
3185  * about the runq.
3186  */
3187 static int
3188 ray_com_runq_add(struct ray_softc *sc, struct ray_comq_entry *com[], int ncom, char *wmesg)
3189 {
3190         int i, error;
3191
3192         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3193
3194         error = 0;
3195         /*
3196          * Add the commands to the runq but don't let it run until
3197          * the ccs's are allocated successfully
3198          */
3199         com[0]->c_flags |= RAY_COM_FWAIT;
3200         for (i = 0; i < ncom; i++) {
3201                 com[i]->c_wakeup = com[ncom-1];
3202                 RAY_DPRINTF(sc, RAY_DBG_COM, "adding %p", com[i]);
3203                 RAY_DCOM(sc, RAY_DBG_DCOM, com[i], "adding");
3204                 TAILQ_INSERT_TAIL(&sc->sc_comq, com[i], c_chain);
3205         }
3206         com[ncom-1]->c_flags |= RAY_COM_FWOK;
3207
3208         /*
3209          * Allocate ccs's for each command.
3210          */
3211         for (i = 0; i < ncom; i++) {
3212                 error = ray_ccs_alloc(sc, &com[i]->c_ccs, wmesg);
3213                 if (error == ENXIO)
3214                         return (ENXIO);
3215                 else if (error)
3216                         goto cleanup;
3217         }
3218
3219         /*
3220          * Allow the queue to run and sleep if needed.
3221          *
3222          * Iff the FDETACHED flag is set in the com entry we waited on
3223          * the driver is in a zombie state! The softc structure has been
3224          * freed by the generic bus detach methods - eek. We tread very
3225          * carefully!
3226          */
3227         com[0]->c_flags &= ~RAY_COM_FWAIT;
3228         ray_com_runq(sc);
3229         if (TAILQ_FIRST(&sc->sc_comq) != NULL) {
3230                 RAY_DPRINTF(sc, RAY_DBG_COM, "sleeping");
3231                 error = tsleep(com[ncom-1], PCATCH, wmesg, 0);
3232                 if (com[ncom-1]->c_flags & RAY_COM_FDETACHED)
3233                         return (ENXIO);
3234                 RAY_DPRINTF(sc, RAY_DBG_COM,
3235                     "awakened, tsleep returned 0x%x", error);
3236         } else
3237                 error = 0;
3238
3239 cleanup:
3240         /*
3241          * Only clean the queue on real errors - we don't care about it
3242          * when we detach as the queue entries are freed by the callers.
3243          */
3244         if (error && (error != ENXIO))
3245                 for (i = 0; i < ncom; i++)
3246                         if (!(com[i]->c_flags & RAY_COM_FCOMPLETED)) {
3247                                 RAY_DPRINTF(sc, RAY_DBG_COM, "removing %p",
3248                                     com[i]);
3249                                 RAY_DCOM(sc, RAY_DBG_DCOM, com[i], "removing");
3250                                 TAILQ_REMOVE(&sc->sc_comq, com[i], c_chain);
3251                                 ray_ccs_free(sc, com[i]->c_ccs);
3252                                 com[i]->c_ccs = NULL;
3253                         }
3254
3255         return (error);
3256 }
3257
3258 /*
3259  * Run the command at the head of the queue (if not already running)
3260  */
3261 static void
3262 ray_com_runq(struct ray_softc *sc)
3263 {
3264         struct ray_comq_entry *com;
3265
3266         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3267
3268         com = TAILQ_FIRST(&sc->sc_comq);
3269         if ((com == NULL) ||
3270             (com->c_flags & RAY_COM_FRUNNING) ||
3271             (com->c_flags & RAY_COM_FWAIT) ||
3272             (com->c_flags & RAY_COM_FDETACHED))
3273                 return;
3274
3275         com->c_flags |= RAY_COM_FRUNNING;
3276         RAY_DPRINTF(sc, RAY_DBG_COM, "running %p", com);
3277         RAY_DCOM(sc, RAY_DBG_DCOM, com, "running");
3278         com->c_function(sc, com);
3279 }
3280
3281 /*
3282  * Remove run command, free ccs and wakeup caller.
3283  *
3284  * Minimal checks are done here as we ensure that the com and command
3285  * handler were matched up earlier. Must be called at splnet or higher
3286  * so that entries on the command queue are correctly removed.
3287  *
3288  * Remove the com from the comq, and wakeup the caller if it requested
3289  * to be woken. This is used for ensuring a sequence of commands
3290  * completes. Finally, re-run the queue.
3291  */
3292 static void
3293 ray_com_runq_done(struct ray_softc *sc)
3294 {
3295         struct ray_comq_entry *com;
3296
3297         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3298
3299         com = TAILQ_FIRST(&sc->sc_comq); /* XXX shall we check this as below */
3300         RAY_DPRINTF(sc, RAY_DBG_COM, "removing %p", com);
3301         RAY_DCOM(sc, RAY_DBG_DCOM, com, "removing");
3302         TAILQ_REMOVE(&sc->sc_comq, com, c_chain);
3303
3304         com->c_flags &= ~RAY_COM_FRUNNING;
3305         com->c_flags |= RAY_COM_FCOMPLETED;
3306         com->c_retval = 0;
3307         ray_ccs_free(sc, com->c_ccs);
3308         com->c_ccs = NULL;
3309
3310         if (com->c_flags & RAY_COM_FWOK)
3311                 wakeup(com->c_wakeup);
3312
3313         ray_com_runq(sc);
3314
3315         /* XXX what about error on completion then? deal with when i fix
3316          * XXX the status checking
3317          *
3318          * XXX all the runq_done calls from IFF_RUNNING checks in runq
3319          * XXX routines should return EIO but shouldn't abort the runq
3320          */
3321 }
3322
3323 /*
3324  * Send a command to the ECF.
3325  */
3326 static void
3327 ray_com_ecf(struct ray_softc *sc, struct ray_comq_entry *com)
3328 {
3329         int i = 0;
3330
3331         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3332         RAY_MAP_CM(sc);
3333
3334         while (!RAY_ECF_READY(sc)) {
3335                 DELAY(RAY_ECF_SPIN_DELAY);
3336                 if (++i > RAY_ECF_SPIN_TRIES)
3337                         RAY_PANIC(sc, "spun too long");
3338         }
3339         if (i != 0)
3340                 RAY_RECERR(sc, "spun %d times", i);
3341
3342         RAY_DPRINTF(sc, RAY_DBG_COM, "sending %p", com);
3343         RAY_DCOM(sc, RAY_DBG_DCOM, com, "sending");
3344         SRAM_WRITE_1(sc, RAY_SCB_CCSI, RAY_CCS_INDEX(com->c_ccs));
3345         RAY_ECF_START_CMD(sc);
3346
3347         if (RAY_COM_NEEDS_TIMO(
3348             SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_cmd))) {
3349                 RAY_DPRINTF(sc, RAY_DBG_COM, "adding timeout");
3350                 sc->com_timerh = timeout(ray_com_ecf_timo, sc, RAY_COM_TIMEOUT);
3351         }
3352 }
3353
3354 /*
3355  * Deal with commands that require a timeout to test completion.
3356  *
3357  * This routine is coded to only expect one outstanding request for the
3358  * timed out requests at a time, but thats all that can be outstanding
3359  * per hardware limitations and all that we issue anyway.
3360  *
3361  * We don't do any fancy testing of the command currently issued as we
3362  * know it must be a timeout based one...unless I've got this wrong!
3363  */
3364 static void
3365 ray_com_ecf_timo(void *xsc)
3366 {
3367         struct ray_softc *sc = (struct ray_softc *)xsc;
3368         struct ray_comq_entry *com;
3369         u_int8_t cmd, status;
3370         int s;
3371
3372         s = splnet();
3373
3374         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3375         RAY_MAP_CM(sc);
3376
3377         com = TAILQ_FIRST(&sc->sc_comq);
3378
3379         cmd = SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_cmd);
3380         status = SRAM_READ_FIELD_1(sc, com->c_ccs, ray_cmd, c_status);
3381         switch (status) {
3382
3383         case RAY_CCS_STATUS_COMPLETE:
3384         case RAY_CCS_STATUS_FREE:                       /* Buggy firmware */
3385                 ray_intr_ccs(sc, cmd, status, com->c_ccs);
3386                 break;
3387
3388         case RAY_CCS_STATUS_BUSY:
3389                 sc->com_timerh = timeout(ray_com_ecf_timo, sc, RAY_COM_TIMEOUT);
3390                 break;
3391
3392         default:                                        /* Replicates NetBSD */
3393                 if (sc->sc_ccsinuse[RAY_CCS_INDEX(com->c_ccs)] == 1) {
3394                         /* give a chance for the interrupt to occur */
3395                         sc->sc_ccsinuse[RAY_CCS_INDEX(com->c_ccs)] = 2;
3396                         sc->com_timerh = timeout(ray_com_ecf_timo, sc,
3397                             RAY_COM_TIMEOUT);
3398                 } else
3399                         ray_intr_ccs(sc, cmd, status, com->c_ccs);
3400                 break;
3401
3402         }
3403
3404         splx(s);
3405 }
3406
3407 /*
3408  * Called when interrupt handler for the command has done all it
3409  * needs to. Will be called at splnet.
3410  */
3411 static void
3412 ray_com_ecf_done(struct ray_softc *sc)
3413 {
3414         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "");
3415
3416         untimeout(ray_com_ecf_timo, sc, sc->com_timerh);
3417
3418         ray_com_runq_done(sc);
3419 }
3420
3421 #if RAY_DEBUG & RAY_DBG_COM
3422 /*
3423  * Process completed ECF commands that probably came from the command queue
3424  *
3425  * This routine is called after vectoring the completed ECF command
3426  * to the appropriate _done routine. It helps check everything is okay.
3427  */
3428 static void
3429 ray_com_ecf_check(struct ray_softc *sc, size_t ccs, char *mesg)
3430 {
3431         struct ray_comq_entry *com;
3432
3433         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_COM, "%s", mesg);
3434
3435         com = TAILQ_FIRST(&sc->sc_comq);
3436
3437         if (com == NULL)
3438                 RAY_PANIC(sc, "no command queue");
3439         if (com->c_ccs != ccs)
3440                 RAY_PANIC(sc, "ccs's don't match");
3441 }
3442 #endif /* RAY_DEBUG & RAY_DBG_COM */
3443
3444 /*
3445  * CCS allocators
3446  */
3447
3448 /*
3449  * Obtain a ccs for a commmand
3450  *
3451  * Returns 0 and in `ccsp' the bus offset of the free ccs. Will block
3452  * awaiting free ccs if needed - if the sleep is interrupted
3453  * EINTR/ERESTART is returned, if the card is ejected we return ENXIO.
3454  */
3455 static int
3456 ray_ccs_alloc(struct ray_softc *sc, size_t *ccsp, char *wmesg)
3457 {
3458         size_t ccs;
3459         u_int i;
3460         int error;
3461
3462         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3463         RAY_MAP_CM(sc);
3464
3465         for (;;) {
3466                 for (i = RAY_CCS_CMD_FIRST; i <= RAY_CCS_CMD_LAST; i++) {
3467                         /* we probe here to make the card go */
3468                         (void)SRAM_READ_FIELD_1(sc, RAY_CCS_ADDRESS(i), ray_cmd,
3469                             c_status);
3470                         if (!sc->sc_ccsinuse[i])
3471                                 break;
3472                 }
3473                 if (i > RAY_CCS_CMD_LAST) {
3474                         RAY_DPRINTF(sc, RAY_DBG_CCS, "sleeping");
3475                         error = tsleep(ray_ccs_alloc, PCATCH, wmesg, 0);
3476                         if ((sc == NULL) || (sc->sc_gone))
3477                                 return (ENXIO);
3478                         RAY_DPRINTF(sc, RAY_DBG_CCS,
3479                             "awakened, tsleep returned 0x%x", error);
3480                         if (error)
3481                                 return (error);
3482                 } else
3483                         break;
3484         }
3485         RAY_DPRINTF(sc, RAY_DBG_CCS, "allocated 0x%02x", i);
3486         sc->sc_ccsinuse[i] = 1;
3487         ccs = RAY_CCS_ADDRESS(i);
3488         *ccsp = ccs;
3489
3490         return (0);
3491 }
3492
3493 /*
3494  * Fill the easy bits in of a pre-allocated CCS
3495  */
3496 static void
3497 ray_ccs_fill(struct ray_softc *sc, size_t ccs, u_int cmd)
3498 {
3499         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3500         RAY_MAP_CM(sc);
3501
3502         if (ccs == NULL)
3503                 RAY_PANIC(sc, "ccs not allocated");
3504
3505         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_status, RAY_CCS_STATUS_BUSY);
3506         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_cmd, cmd);
3507         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd, c_link, RAY_CCS_LINK_NULL);
3508 }
3509
3510 /*
3511  * Free up a ccs allocated via ray_ccs_alloc
3512  *
3513  * Return the old status. This routine is only used for ccs allocated via
3514  * ray_ccs_alloc (not tx, rx or ECF command requests).
3515  */
3516 static void
3517 ray_ccs_free(struct ray_softc *sc, size_t ccs)
3518 {
3519         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3520         RAY_MAP_CM(sc);
3521
3522 #if 1 | (RAY_DEBUG & RAY_DBG_CCS)
3523         if (!sc->sc_ccsinuse[RAY_CCS_INDEX(ccs)])
3524                 RAY_RECERR(sc, "freeing free ccs 0x%02x", RAY_CCS_INDEX(ccs));
3525 #endif /* RAY_DEBUG & RAY_DBG_CCS */
3526         if (!sc->sc_gone)
3527                 RAY_CCS_FREE(sc, ccs);
3528         sc->sc_ccsinuse[RAY_CCS_INDEX(ccs)] = 0;
3529         RAY_DPRINTF(sc, RAY_DBG_CCS, "freed 0x%02x", RAY_CCS_INDEX(ccs));
3530         wakeup(ray_ccs_alloc);
3531 }
3532
3533 /*
3534  * Obtain a ccs and tx buffer to transmit with and fill them in.
3535  *
3536  * Returns 0 and in `ccsp' the bus offset of the free ccs. Will not block
3537  * and if none available and will returns EAGAIN.
3538  *
3539  * The caller must fill in the length later.
3540  * The caller must clear the ccs on errors.
3541  */
3542 static int
3543 ray_ccs_tx(struct ray_softc *sc, size_t *ccsp, size_t *bufpp)
3544 {
3545         size_t ccs, bufp;
3546         int i;
3547         u_int8_t status;
3548
3549         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CCS, "");
3550         RAY_MAP_CM(sc);
3551
3552         i = RAY_CCS_TX_FIRST;
3553         do {
3554                 status = SRAM_READ_FIELD_1(sc, RAY_CCS_ADDRESS(i),
3555                     ray_cmd, c_status);
3556                 if (status == RAY_CCS_STATUS_FREE)
3557                         break;
3558                 i++;
3559         } while (i <= RAY_CCS_TX_LAST);
3560         if (i > RAY_CCS_TX_LAST) {
3561                 return (EAGAIN);
3562         }
3563         RAY_DPRINTF(sc, RAY_DBG_CCS, "allocated 0x%02x", i);
3564
3565         /*
3566          * Reserve and fill the ccs - must do the length later.
3567          *
3568          * Even though build 4 and build 5 have different fields all these
3569          * are common apart from tx_rate. Neither the NetBSD driver or Linux
3570          * driver bother to overwrite this for build 4 cards.
3571          *
3572          * The start of the buffer must be aligned to a 256 byte boundary
3573          * (least significant byte of address = 0x00).
3574          */
3575         ccs = RAY_CCS_ADDRESS(i);
3576         bufp = RAY_TX_BASE + i * RAY_TX_BUF_SIZE;
3577         bufp += sc->sc_tibsize;
3578         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_status, RAY_CCS_STATUS_BUSY);
3579         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_cmd, RAY_CMD_TX_REQ);
3580         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_link, RAY_CCS_LINK_NULL);
3581         SRAM_WRITE_FIELD_2(sc, ccs, ray_cmd_tx, c_bufp, bufp);
3582         SRAM_WRITE_FIELD_1(sc,
3583             ccs, ray_cmd_tx, c_tx_rate, sc->sc_c.np_def_txrate);
3584         SRAM_WRITE_FIELD_1(sc, ccs, ray_cmd_tx, c_apm_mode, 0);
3585         bufp += sizeof(struct ray_tx_phy_header);
3586
3587         *ccsp = ccs;
3588         *bufpp = bufp;
3589         return (0);
3590 }
3591
3592 /*
3593  * Routines to obtain resources for the card
3594  */
3595
3596 /*
3597  * Allocate the attribute memory on the card
3598  *
3599  * The attribute memory space is abused by these devices as IO space. As such
3600  * the OS card services don't have a chance of knowing that they need to keep
3601  * the attribute space mapped. We have to do it manually.
3602  */
3603 static int
3604 ray_res_alloc_am(struct ray_softc *sc)
3605 {
3606         int error;
3607
3608         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CM, "");
3609
3610         sc->am_rid = RAY_AM_RID;
3611         sc->am_res = bus_alloc_resource(sc->dev, SYS_RES_MEMORY,
3612             &sc->am_rid, 0UL, ~0UL, 0x1000, RF_ACTIVE);
3613         if (!sc->am_res) {
3614                 RAY_PRINTF(sc, "Cannot allocate attribute memory");
3615                 return (ENOMEM);
3616         }
3617         error = CARD_SET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3618             sc->am_rid, 0, NULL);
3619         if (error) {
3620                 RAY_PRINTF(sc, "CARD_SET_MEMORY_OFFSET returned 0x%0x", error);
3621                 return (error);
3622         }
3623         error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3624             SYS_RES_MEMORY, sc->am_rid, PCCARD_A_MEM_ATTR);
3625         if (error) {
3626                 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3627                 return (error);
3628         }
3629         error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3630             SYS_RES_MEMORY, sc->am_rid, PCCARD_A_MEM_8BIT);
3631         if (error) {
3632                 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3633                 return (error);
3634         }
3635         sc->am_bsh = rman_get_bushandle(sc->am_res);
3636         sc->am_bst = rman_get_bustag(sc->am_res);
3637
3638 #if RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM)
3639 {
3640         u_long flags;
3641         u_int32_t offset;
3642         CARD_GET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3643             SYS_RES_MEMORY, sc->am_rid, &flags);
3644         CARD_GET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3645             sc->am_rid, &offset);
3646         RAY_PRINTF(sc, "allocated attribute memory:\n"
3647             ".  start 0x%0lx count 0x%0lx flags 0x%0lx offset 0x%0x",
3648             bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->am_rid),
3649             bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->am_rid),
3650             flags, offset);
3651 }
3652 #endif /* RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM) */
3653
3654         return (0);
3655 }
3656
3657 /*
3658  * Allocate the common memory on the card
3659  *
3660  * As this memory is described in the CIS, the OS card services should
3661  * have set the map up okay, but the card uses 8 bit RAM. This is not
3662  * described in the CIS.
3663  */
3664 static int
3665 ray_res_alloc_cm(struct ray_softc *sc)
3666 {
3667         u_long start, count, end;
3668         int error;
3669
3670         RAY_DPRINTF(sc, RAY_DBG_SUBR | RAY_DBG_CM, "");
3671
3672         RAY_DPRINTF(sc,RAY_DBG_CM | RAY_DBG_BOOTPARAM,
3673             "cm start 0x%0lx count 0x%0lx",
3674             bus_get_resource_start(sc->dev, SYS_RES_MEMORY, RAY_CM_RID),
3675             bus_get_resource_count(sc->dev, SYS_RES_MEMORY, RAY_CM_RID));
3676
3677         sc->cm_rid = RAY_CM_RID;
3678         start = bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->cm_rid);
3679         count = bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->cm_rid);
3680         end = start + count - 1;
3681         sc->cm_res = bus_alloc_resource(sc->dev, SYS_RES_MEMORY,
3682             &sc->cm_rid, start, end, count, RF_ACTIVE);
3683         if (!sc->cm_res) {
3684                 RAY_PRINTF(sc, "Cannot allocate common memory");
3685                 return (ENOMEM);
3686         }
3687         error = CARD_SET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3688             sc->cm_rid, 0, NULL);
3689         if (error) {
3690                 RAY_PRINTF(sc, "CARD_SET_MEMORY_OFFSET returned 0x%0x", error);
3691                 return (error);
3692         }
3693         error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3694             SYS_RES_MEMORY, sc->cm_rid, PCCARD_A_MEM_COM);
3695         if (error) {
3696                 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3697                 return (error);
3698         }
3699         error = CARD_SET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3700             SYS_RES_MEMORY, sc->cm_rid, PCCARD_A_MEM_8BIT);
3701         if (error) {
3702                 RAY_PRINTF(sc, "CARD_SET_RES_FLAGS returned 0x%0x", error);
3703                 return (error);
3704         }
3705         sc->cm_bsh = rman_get_bushandle(sc->cm_res);
3706         sc->cm_bst = rman_get_bustag(sc->cm_res);
3707
3708 #if RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM)
3709 {
3710         u_long flags;
3711         u_int32_t offset;
3712         CARD_GET_RES_FLAGS(device_get_parent(sc->dev), sc->dev,
3713             SYS_RES_MEMORY, sc->cm_rid, &flags);
3714         CARD_GET_MEMORY_OFFSET(device_get_parent(sc->dev), sc->dev,
3715             sc->cm_rid, &offset);
3716         RAY_PRINTF(sc, "allocated common memory:\n"
3717             ".  start 0x%0lx count 0x%0lx flags 0x%0lx offset 0x%0x",
3718             bus_get_resource_start(sc->dev, SYS_RES_MEMORY, sc->cm_rid),
3719             bus_get_resource_count(sc->dev, SYS_RES_MEMORY, sc->cm_rid),
3720             flags, offset);
3721 }
3722 #endif /* RAY_DEBUG & (RAY_DBG_CM | RAY_DBG_BOOTPARAM) */
3723
3724         return (0);
3725 }
3726
3727 /*
3728  * Get an irq and attach it to the bus
3729  */
3730 static int
3731 ray_res_alloc_irq(struct ray_softc *sc)
3732 {
3733         int error;
3734
3735         RAY_DPRINTF(sc, RAY_DBG_SUBR, "");
3736
3737         RAY_DPRINTF(sc,RAY_DBG_CM | RAY_DBG_BOOTPARAM,
3738             "irq start 0x%0lx count 0x%0lx",
3739             bus_get_resource_start(sc->dev, SYS_RES_IRQ, 0),
3740             bus_get_resource_count(sc->dev, SYS_RES_IRQ, 0));
3741
3742         sc->irq_rid = 0;
3743         sc->irq_res = bus_alloc_resource(sc->dev, SYS_RES_IRQ, &sc->irq_rid,
3744             0, ~0, 1, RF_ACTIVE);
3745         if (!sc->irq_res) {
3746                 RAY_PRINTF(sc, "Cannot allocate irq");
3747                 return (ENOMEM);
3748         }
3749         if ((error = bus_setup_intr(sc->dev, sc->irq_res, INTR_TYPE_NET,
3750             ray_intr, sc, &sc->irq_handle)) != 0) {
3751                 RAY_PRINTF(sc, "Failed to setup irq");
3752                 return (error);
3753         }
3754         RAY_DPRINTF(sc, RAY_DBG_CM | RAY_DBG_BOOTPARAM, "allocated irq:\n"
3755             ".  start 0x%0lx count 0x%0lx",
3756             bus_get_resource_start(sc->dev, SYS_RES_IRQ, sc->irq_rid),
3757             bus_get_resource_count(sc->dev, SYS_RES_IRQ, sc->irq_rid));
3758
3759         return (0);
3760 }
3761
3762 /*
3763  * Release all of the card's resources
3764  */
3765 static void
3766 ray_res_release(struct ray_softc *sc)
3767 {
3768         if (sc->irq_res != 0) {
3769                 bus_teardown_intr(sc->dev, sc->irq_res, sc->irq_handle);
3770                 bus_release_resource(sc->dev, SYS_RES_IRQ,
3771                     sc->irq_rid, sc->irq_res);
3772                 sc->irq_res = 0;
3773         }
3774         if (sc->am_res != 0) {
3775                 bus_release_resource(sc->dev, SYS_RES_MEMORY,
3776                     sc->am_rid, sc->am_res);
3777                 sc->am_res = 0;
3778         }
3779         if (sc->cm_res != 0) {
3780                 bus_release_resource(sc->dev, SYS_RES_MEMORY,
3781                     sc->cm_rid, sc->cm_res);
3782                 sc->cm_res = 0;
3783         }
3784 }
3785
3786 /*
3787  * mbuf dump
3788  */
3789 #if RAY_DEBUG & RAY_DBG_MBUF
3790 static void
3791 ray_dump_mbuf(struct ray_softc *sc, struct mbuf *m, char *s)
3792 {
3793         u_int8_t *d, *ed;
3794         u_int i;
3795         char p[17];
3796
3797         RAY_PRINTF(sc, "%s", s);
3798         RAY_PRINTF(sc, "\nm0->data\t0x%p\nm_pkthdr.len\t%d\nm_len\t%d",
3799             mtod(m, u_int8_t *), m->m_pkthdr.len, m->m_len);
3800         i = 0;
3801         bzero(p, 17);
3802         for (; m; m = m->m_next) {
3803                 d = mtod(m, u_int8_t *);
3804                 ed = d + m->m_len;
3805
3806                 for (; d < ed; i++, d++) {
3807                         if ((i % 16) == 0) {
3808                                 printf("  %s\n\t", p);
3809                         } else if ((i % 8) == 0)
3810                                 printf("  ");
3811                         printf(" %02x", *d);
3812                         p[i % 16] = ((*d >= 0x20) && (*d < 0x80)) ? *d : '.';
3813                 }
3814         }
3815         if ((i - 1) % 16)
3816                 printf("  %s\n", p);
3817 }
3818 #endif /* RAY_DEBUG & RAY_DBG_MBUF */