root/dev/ic/rln.c

DEFINITIONS

1. rlnconfig
2. rlninit
3. rlnstart
4. rln_transmit
5. rlnwatchdog
6. rlnintr
7. rlnsoftintr
8. rlnread
9. rlnget
10. rlnioctl
11. rlnstop
12. rln_getenaddr
13. rln_getpromvers
14. rln_sendinit
15. rln_roamconfig
16. rln_roam
17. rln_multicast
18. rln_searchsync
19. rln_iosetparam
20. rln_lockprom
21. rln_ito
22. rln_standby
23. rln_crypt

    1 /*      $OpenBSD: rln.c,v 1.18 2006/03/25 22:41:43 djm Exp $    */
    2 /*
    3  * David Leonard <d@openbsd.org>, 1999. Public Domain.
    4  *
    5  * Driver for the Proxim RangeLAN2 wireless network adaptor.
    6  *
    7  * Information and ideas gleaned from disassembly of Dave Koberstein's
    8  * <davek@komacke.com> Linux driver (apparently based on Proxim source),
    9  * from Yoichi Shinoda's <shinoda@cs.washington.edu> BSDI driver, and
   10  * Geoff Voelker's <voelker@cs.washington.edu> Linux port of the same.
   11  *
   12  */
   14 #include "bpfilter.h"
   16 #include <sys/param.h>
   17 #include <sys/systm.h>
   18 #include <sys/mbuf.h>
   19 #include <sys/socket.h>
   20 #include <sys/ioctl.h>
   21 #include <sys/syslog.h>
   22 #include <sys/device.h>
   23 #include <sys/kernel.h>
   25 #include <net/if.h>
   26 #include <net/if_media.h>
   28 #ifdef INET
   29 #include <netinet/in.h>
   30 #include <netinet/if_ether.h>
   31 #endif
   33 #if NBPFILTER > 0
   34 #include <net/bpf.h>
   35 #endif
   37 #include <machine/bus.h>
   38 #include <machine/intr.h>
   40 #include <dev/ic/rln.h>
   41 #include <dev/ic/rlnvar.h>
   42 #include <dev/ic/rlnreg.h>
   43 #include <dev/ic/rlncmd.h>
   45 /* Autoconfig definition of driver back-end. */
   46 struct cfdriver rln_cd = {
NULL, "rln", DV_IFNET
   48 };
   50 void    rlninit(struct rln_softc *);
   51 void    rlnstart(struct ifnet*);
   52 void    rlnwatchdog(struct ifnet*);
   53 int     rlnioctl(struct ifnet *, u_long, caddr_t);
   54 void    rlnstop(struct rln_softc *);
   56 /* Interrupt handler. */
   57 void    rlnsoftintr(void *);
   59 /* Packet I/O. */
   60 int     rln_transmit(struct rln_softc *, struct mbuf *,
   61                         int, int);
   62 struct mbuf * rlnget(struct rln_softc *, struct rln_mm_cmd *,
   63                         int);
   65 /* Card protocol-level functions. */
   66 int     rln_getenaddr(struct rln_softc *, u_int8_t *);
   67 int     rln_getpromvers(struct rln_softc *, char *, int);
   68 int     rln_sendinit(struct rln_softc *);
   69 #if notyet
   70 int     rln_roamconfig(struct rln_softc *);
   71 int     rln_roam(struct rln_softc *);
   72 int     rln_multicast(struct rln_softc *, int);
   73 int     rln_searchsync(struct rln_softc *);
   74 int     rln_iosetparam(struct rln_softc *, struct rln_param *);
   75 int     rln_lockprom(struct rln_softc *);
   76 int     rln_ito(struct rln_softc *);
   77 int     rln_standby(struct rln_softc *);
   78 #endif
   80 /* Back-end attach and configure. Assumes card has been reset. */
   81 void
rlnconfig(sc)
   83         struct rln_softc * sc;
   84 {
   85         struct ifnet *  ifp = &sc->sc_arpcom.ac_if;
   86         char            promvers[7];
   87         int             i;
dprintf(" [attach %p]", sc);
   91         /* Use the flags supplied from config. */
sc->sc_cardtype |= sc->sc_dev.dv_cfdata->cf_flags;
   94         /* Initialise values in the soft state. */
sc->sc_pktseq = 0;      /* rln_newseq() */
sc->sc_txseq = 0;
sc->sc_state = 0;
   99         /* Initialise user-configurable params. */
sc->sc_param.rp_roam_config = RLN_ROAM_NORMAL;
sc->sc_param.rp_security = RLN_SECURITY_DEFAULT;
sc->sc_param.rp_station_type = RLN_STATIONTYPE_ALTMASTER;
sc->sc_param.rp_domain = 0;
sc->sc_param.rp_channel = 1;
sc->sc_param.rp_subchannel = 1;
bzero(sc->sc_param.rp_master, sizeof sc->sc_param.rp_master);
  109         /* Initialise the message mailboxes. */
  110         for (i = 0; i < RLN_NMBOX; i++)
sc->sc_mbox[i].mb_state = RLNMBOX_VOID;
  113         /* Probe for some properties. */
printf(", %s-piece", 
  115             (sc->sc_cardtype & RLN_CTYPE_ONE_PIECE) ? "one" : "two");
  116         if (sc->sc_cardtype & RLN_CTYPE_OEM)
printf(" oem");
  118         if (sc->sc_cardtype & RLN_CTYPE_UISA)
printf(" micro-isa");
  121         /* Read the card's PROM revision. */
  122         if (rln_getpromvers(sc, promvers, sizeof promvers)) {
printf(": could not read PROM version\n");
  124                 return;
  125         }
printf(", fw %.7s", promvers);
  128         /* Fetch the card's MAC address. */
  129         if (rln_getenaddr(sc, sc->sc_arpcom.ac_enaddr)) {
printf(": could not read MAC address\n");
  131                 return;
  132         }
printf(", addr %s", ether_sprintf(sc->sc_arpcom.ac_enaddr));
timeout_set(&sc->sc_timeout, rlnsoftintr, sc);
  137         /* Attach as a network interface. */
bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_start = rlnstart;
ifp->if_ioctl = rlnioctl;
ifp->if_watchdog = rlnwatchdog;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
ether_ifattach(ifp);
  147 }
  149 /* Bring device up. */
  150 void
rlninit(sc)
  152         struct rln_softc * sc;
  153 {
  154         /* LLDInit() */
  155         struct ifnet * ifp = &sc->sc_arpcom.ac_if;
  156         int s;
s = splnet();
dprintf(" [init]");
sc->sc_intsel = 0;
sc->sc_status = 0;
sc->sc_control = 0;
ifp->if_flags &= ~IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
  167         /* Do a hard reset. */
  168         if (rln_reset(sc)) {
printf("%s: could not reset card\n", sc->sc_dev.dv_xname);
  170                 goto fail;
  171         }
sc->sc_state = 0;       /* Also clears RLN_STATE_NEEDINIT. */
  174         /* Use this host's name as a master name. */
  175         if (!cold && sc->sc_param.rp_master[0] == '\0') {
bcopy(hostname, sc->sc_param.rp_master, 
min(hostnamelen, sizeof sc->sc_param.rp_master));
  178         }
rln_enable(sc, 1);
  182         /* Initialise operational params. */
  183         if (rln_sendinit(sc)) {
printf("%s: could not set card parameters\n",
sc->sc_dev.dv_xname);
  186                 goto fail;
  187         }
  188 #if 0
rln_roamconfig(sc);
  190         /* rln_lockprom(sc); */
  191         /* SendSetITO() */
rln_multicast(sc, 1);
rln_roam(sc);
  195         /* Synchronise with something. */
rln_searchsync(sc);
  197 #endif
ifp->if_flags |= IFF_RUNNING;
rlnstart(ifp);
splx(s);
  202         return;
fail:
ifp->if_flags &= ~IFF_UP;
splx(s);
  207         return;
  208 }
  210 /* Start outputting on interface. This is always called at splnet(). */
  211 void
rlnstart(ifp)
  213         struct ifnet *  ifp;
  214 {
  215         struct rln_softc * sc = (struct rln_softc *)ifp->if_softc;
  216         struct mbuf *   m0;
  217         int             len, pad, ret, s;
dprintf(" start[");
  221         if (sc->sc_state & RLN_STATE_NEEDINIT)
rlninit(sc);
  224         /* Don't transmit if interface is busy or not running. */
  225         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING) {
dprintf(" %s] ", (ifp->if_flags & IFF_OACTIVE) ? 
  227                     "busy" : "stopped");
  228                 return;
  229         }
  231         /* Don't transmit if we are not synchronised. */
  232         if ((sc->sc_state & RLN_STATE_SYNC) == 0) {
dprintf(" nosync]");
  234                 return;
  235         }
rln_enable(sc, 1);
startagain:
s = splnet();
IFQ_DEQUEUE(&ifp->if_snd, m0);
splx(s);
  244         if (m0 == NULL) {
dprintf(" empty]");
  246                 return;
  247         }
  249 #if NBPFILTER > 0
  250         /* Tap packet stream here for BPF listeners. */
  251         if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
  253 #endif
  255         /* We need to use m->m_pkthdr.len, so require the header. */
  256         if ((m0->m_flags & M_PKTHDR) == 0) {
printf("%s: no mbuf header\n", sc->sc_dev.dv_xname);
  258                 goto oerror;
  259         }
len = m0->m_pkthdr.len;
  263 #define PACKETMIN       (sizeof (struct ether_header) + ETHERMIN)
  264 #define PACKETMAX       (sizeof (struct ether_header) + ETHERMTU + 4)
  266         /* Packet size has to be an even number between 60 and 1518 octets. */
pad = len & 1;
  268         if (len + pad < PACKETMIN)
pad = PACKETMIN - len;
  271         if (len + pad > PACKETMAX) {
printf("%s: packet too big (%d > %d)\n",
sc->sc_dev.dv_xname, len + pad,
PACKETMAX);
  275                 ++ifp->if_oerrors;
m_freem(m0);
  277                 goto startagain;
  278         }
ret = rln_transmit(sc, m0, len, pad);
  281         if (ret)
  282                 goto oerror;
ifp->if_flags |= IFF_OACTIVE;
m_freem(m0);
dprintf(" sent]");
  288         return;
oerror:
  291         ++ifp->if_oerrors;
m_freem(m0);
rln_need_reset(sc);
  294         return;
  295 }
  297 /* Transmit one packet. */
  298 int
rln_transmit(sc, m0, len, pad)
  300         struct rln_softc *      sc;
  301         struct mbuf *   m0;
  302         int             len;
  303         int             pad;
  304 {
  305         struct mbuf *   m;
  306         int             zfirst;
  307         int             actlen;
  308         int             tlen = len + pad;
  309         struct rln_msg_tx_state state;
  310         static u_int8_t zeroes[60];
  311         struct rln_mm_sendpacket cmd = { RLN_MM_SENDPACKET };
  313         /* Does the packet start with a zero bit? */
zfirst = ((*mtod(m0, u_int8_t *) & 1) == 0);
cmd.mode = 
RLN_MM_SENDPACKET_MODE_BIT7 | 
  318                    (zfirst ? RLN_MM_SENDPACKET_MODE_ZFIRST : 0) |
  319                    (0 ? RLN_MM_SENDPACKET_MODE_QFSK : 0),       /* sc->qfsk? */
cmd.power = 0x70;       /* 0x70 or 0xf0 */
cmd.length_lo = htons(4 + tlen) & 0xff;
cmd.length_hi = (htons(4 + tlen) >> 8) & 0xff;
cmd.xxx1 = 0;
cmd.xxx2 = 0;
cmd.xxx3 = 0;
  327         /* A unique packet-level sequence number, independent of sc_seq. */
cmd.sequence = sc->sc_txseq;
sc->sc_txseq++;
  330         if (sc->sc_txseq > RLN_MAXSEQ)
sc->sc_txseq = 0;
dprintf(" T[%d+%d", len, pad);
  335         if (rln_msg_tx_start(sc, &cmd, sizeof cmd + tlen, &state))
  336                 goto error;
cmd.mm_cmd.cmd_seq = rln_newseq(sc);
  340         /* Send the SENDPACKET command header  */
  341 #ifdef RLNDUMP
printf("%s: send %c%d seq %d data ", sc->sc_dev.dv_xname,
cmd.mm_cmd.cmd_letter, cmd.mm_cmd.cmd_fn, cmd.mm_cmd.cmd_seq);
RLNDUMPHEX(&cmd, sizeof cmd);
printf(":");
  346 #endif
rln_msg_tx_data(sc, &cmd, sizeof cmd, &state);
  349         /* XXX do we need to insert a hardware header here??? */
  351         /* Follow the header immediately with the packet payload */
actlen = 0;
  353         for (m = m0; m; m = m->m_next)  {
  354                 if (m->m_len) {
  355 #ifdef RLNDUMP
RLNDUMPHEX(mtod(m, void *), m->m_len);
  357 #endif
rln_msg_tx_data(sc, mtod(m, void *), m->m_len, &state);
  359                 }
  360                 if (m->m_next)
printf("|");
actlen += m->m_len;
  363         }
  364 #ifdef DIAGNOSTIC
  365         if (actlen != len)
panic("rln_transmit: len %d != %d", actlen, len);
  367         if (pad > sizeof zeroes)
panic("rln_transmit: pad %d > %d", pad, sizeof zeroes);
  369 #endif
  370         if (pad) {
  371 #ifdef RLNDUMP
printf(":");
RLNDUMPHEX(zeroes, pad);
  374 #endif
rln_msg_tx_data(sc, zeroes, pad, &state);
  376         }
  378 #ifdef RLNDUMP
printf("\n");
  380 #endif
  381         if (rln_msg_tx_end(sc, &state))
  382                 goto error;
  383         return (0);
error:
dprintf(" error]");
  387         return (-1);
  388 }
  390 /* (Supposedly) called when interrupts are suspiciously absent. */
  391 void
rlnwatchdog(ifp)
  393         struct ifnet * ifp;
  394 {
  395         struct rln_softc * sc = (struct rln_softc *)ifp->if_softc;
log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
  398         ++sc->sc_arpcom.ac_if.if_oerrors;
rlninit(sc);
rln_enable(sc, 1);
  401 }
  403 /* Handle single card interrupt. */
  404 int
rlnintr(arg)
  406         void *  arg;
  407 {
  408         struct rln_softc * sc = (struct rln_softc *)arg;
dprintf("!");
  412         /* Tell card not to interrupt any more. */
rln_enable(sc, 0);
  415         if (cold)
  416                 /* During autoconfig - must handle interrupts now. */
rlnsoftintr(sc);
  418         else
  419                 /* Handle later. */
timeout_add(&sc->sc_timeout, 1);
  422         return (1);
  423 }
  425 /* Process earlier card interrupt at splsoftnet. */
  426 void
rlnsoftintr(arg)
  428         void * arg;
  429 {
  430         struct rln_softc *sc = (struct rln_softc *)arg;
  431         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  432         int len;
u_int8_t w;
  434         struct rln_mm_cmd hdr;
  435         int s;
s = splsoftnet();
dprintf(" si(");
again:
  441         /* Save wakeup state. */
w = rln_wakeup(sc, RLN_WAKEUP_SET);
  444         if ((len = rln_rx_request(sc, 300)) < 0) {
  445                 /* Error in transfer. */
rln_need_reset(sc);
rln_rx_end(sc);
  448         } else if (len < sizeof hdr) {
  449                 /* Short message. */
rln_rx_end(sc);
printf("%s: short msg (%d)\n", sc->sc_dev.dv_xname, len);
ifp->if_ierrors++;
  453         } else {
  454                 /* Valid message: read header and process. */
rln_rx_data(sc, &hdr, sizeof hdr);
rlnread(sc, &hdr, len);
  457         }
  459         /* Ensure that wakeup state is unchanged if transmitting. */
  460         if (ifp->if_flags & IFF_OACTIVE)
w |= RLN_WAKEUP_NOCHANGE;
rln_wakeup(sc, w);
  464         /* Check for more interrupts. */
  465         if ((sc->sc_state & RLN_STATE_NEEDINIT) == 0 && 
rln_status_rx_ready(sc)) {
  467                 if (rln_status_rx_read(sc) == RLN_STATUS_RX_ERROR) {
  468 #ifdef DIAGNOSTIC
printf("%s: protocol error\n", sc->sc_dev.dv_xname);
  470 #endif
DELAY(100 * 1000);      /* Woah, baby. */
rln_clear_nak(sc);
  473                 } else {
  474 #ifdef DIAGNOSTIC
printf("%s: intr piggyback\n", sc->sc_dev.dv_xname);
  476 #endif
  477                         goto again;
  478                 }
  479         }
rln_eoi(sc);
rln_enable(sc, 1);
dprintf(")");
splx(s);
  486 }
  488 /* Read and process a message from the card. */
  489 void
rlnread(sc, hdr, len)
  491         struct rln_softc *sc;
  492         struct rln_mm_cmd *hdr;
  493         int len;
  494 {
  495         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  496         struct mbuf *m;
u_int8_t data[1538];
u_int8_t  *buf;
size_t    buflen;
  500         struct rln_pdata pd = RLN_PDATA_INIT;
  501         struct rln_mm_synchronised * syncp = (struct rln_mm_synchronised *)data;
  502         int s;
dprintf(" [read]");
  506         /* Were we waiting for this message? */
  507         if (rln_mbox_lock(sc, hdr->cmd_seq, (void **)&buf, &buflen) == 0) {
  508 #ifdef DIAGNOSTIC
  509                 if (buflen < sizeof *hdr)
panic("rlnread buflen");
  511 #endif
bcopy(hdr, buf, sizeof *hdr);
buf += sizeof *hdr;
len -= sizeof *hdr;
buflen -= sizeof *hdr;
  516                 if (len) {
  517                         if (len == buflen)              /* Expected size */
rln_rx_pdata(sc, buf, len, &pd);
  519                         else if (len < buflen) {        /* Underfill */
  520 #ifdef DIAGNOSTIC
printf("%s: underfill %d<%d, cmd %c%d\n",
sc->sc_dev.dv_xname,
len, buflen,
hdr->cmd_letter, hdr->cmd_fn);
  525 #endif
rln_rx_pdata(sc, buf, len, &pd);
  527                         } else {                        /* Overflow */
  528 #ifdef DIAGNOSTIC
printf("%s: overflow %d>%d, cmd %c%d\n",
sc->sc_dev.dv_xname,
len, buflen,
hdr->cmd_letter, hdr->cmd_fn);
  533 #endif
rln_rx_pdata(sc, buf, buflen, &pd);
  535                                 /* Drain the rest somewhere. */
rln_rx_pdata(sc, data, len - buflen, &pd);
  537                         }
  538                 }
rln_rx_end(sc);
  541                 /* This message can now be handled by the waiter. */
rln_mbox_unlock(sc, hdr->cmd_seq, len + sizeof *hdr);
  543                 return;
  544         } 
  546         /* Otherwise, handle the message, right here, right now. */
  548         /* Check if we can cope with the size of this message. */
  549         if (len > sizeof data) {
printf("%s: msg too big (%d)\n", sc->sc_dev.dv_xname, len);
ifp->if_ierrors++;
rln_rx_end(sc);
  553                 /* rln_need_reset(sc); */
  554                 return;
  555         }
  557         /* Check for error results. */
  558         if (hdr->cmd_error & 0x80) {
printf("%s: command error 0x%02x command %c%d len=%d\n",
sc->sc_dev.dv_xname,
hdr->cmd_error & ~0x80,
hdr->cmd_letter, hdr->cmd_fn,
len);
ifp->if_ierrors++;
rln_rx_end(sc);
rln_need_reset(sc);
  567                 return;
  568         }
  570         /*
  571          * "b1": Receiving a packet is a special case.
  572          * We wish to read the data with pio straight into an 
  573          * mbuf to avoid a memory-memory copy.
  574          */
  575         if (hdr->cmd_letter == 'b' && hdr->cmd_fn == 1) {
m = rlnget(sc, hdr, len);
rln_rx_end(sc);
  578                 if (m == NULL) 
  579                         return;
ifp->if_ipackets++;
  581 #ifdef DIAGNOSTIC
  582                 if (bcmp(mtod(m, u_int8_t *), "prox", 4) == 0) {
printf("%s: proxim special packet received\n",
sc->sc_dev.dv_xname);
  585                 }
  586 #endif
  588 #if NBPFILTER > 0
  589                 if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
  591 #endif
ether_input_mbuf(ifp, m);
  594                 return;
  595         }
  598         /* Otherwise we read the packet into a buffer on the stack. */
bcopy(hdr, data, sizeof *hdr);
  600         if (len > sizeof *hdr) 
rln_rx_pdata(sc, data + sizeof *hdr, len - sizeof *hdr, &pd);
rln_rx_end(sc);
  604 #ifdef RLNDUMP
printf("%s: recv %c%d seq %d data ", sc->sc_dev.dv_xname,
hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
RLNDUMPHEX(hdr, sizeof hdr);
printf(":");
RLNDUMPHEX(data + sizeof hdr, len - sizeof hdr);
printf("\n");
  611 #endif
  613         switch (RLN_MM_CMD(hdr->cmd_letter, hdr->cmd_fn)) {
  614         case RLN_MM_CMD('b', 0):                        /* b0: Transmit done. */
  615 #ifdef DIAGNOSTIC
  616                 if (len != 7)
printf("%s: 'b0' len %d != 7\n",
sc->sc_dev.dv_xname, len);
  619 #endif
ifp->if_flags &= ~IFF_OACTIVE;
ifp->if_opackets++;
s = splnet();
rlnstart(ifp);
splx(s);
  625                 break;
  627         case RLN_MM_CMD('a', 20):                       /* a20: Card fault. */
printf("%s: hardware fault\n", sc->sc_dev.dv_xname);
  629                 break;
  631         case RLN_MM_CMD('a', 4):                        /* a4: Sync'd. */
  632                 if (bcmp(syncp->enaddr, sc->sc_arpcom.ac_enaddr,
ETHER_ADDR_LEN) == 0) {
  634                         /* Sync'd to own enaddr. */
  635  /*
  636   * From http://www.proxim.com/support/faq/7400.shtml
  637   * 3. RLNSETUP reports that I'm synchronized to my own MAC address. What
  638   *    does that mean?
  639   *    You are the acting Master for this network. Either you are
  640   *    configured as the Master or as an Alternate Master. If you are an
  641   *    Alternate Master, you may be out of range or on a different Domain
  642   *    and Security ID from the true Master.
  643   */
printf("%s: nothing to sync to; now master ",
sc->sc_dev.dv_xname);
  647                 }
  648                 else
printf("%s: synchronised to ", sc->sc_dev.dv_xname);
printf("%.11s (%s) channel %d/%d\n",
syncp->mastername,
ether_sprintf(syncp->enaddr),
syncp->channel,
syncp->subchannel);
  656                 /* Record the new circumstances. */
sc->sc_param.rp_channel = syncp->channel;
sc->sc_param.rp_subchannel = syncp->subchannel;
sc->sc_state |= RLN_STATE_SYNC;
  661                 /* Resume sending. */
s = splnet();
rlnstart(ifp);
splx(s);
  665                 break;
  667         case RLN_MM_CMD('a', 5):                        /* a4: Lost sync. */
printf("%s: lost sync\n", sc->sc_dev.dv_xname);
sc->sc_state &= ~RLN_STATE_SYNC;
  670                 break;
  672         case RLN_MM_CMD('a', 18):                       /* a18: Roaming. */
printf("%s: roaming\n", sc->sc_dev.dv_xname);
  674                 break;
  675         default:
  676 #ifdef DIAGNOSTIC
printf("%s: msg `%c%d' seq %d data {",
sc->sc_dev.dv_xname, 
hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
RLNDUMPHEX(hdr, sizeof hdr);
printf(":");
RLNDUMPHEX(data, len);
printf("}\n");
  684 #endif
  685                 break;
  686         }
  688 }
  690 /* Extract a received network packet from the card. */
  691 struct mbuf *
rlnget(sc, hdr, totlen)
  693         struct rln_softc *sc;
  694         struct rln_mm_cmd *hdr;
  695         int totlen;
  696 {
  697         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  698         int len;
  699         int pad;
  700         struct mbuf *m, **mp, *top;
  701         struct rln_pdata pd = RLN_PDATA_INIT;
  702         struct {
u_int8_t rssi;
u_int8_t xxx1;  /* always 00? */
u_int16_t len;  /* payload length */
u_int8_t xxx2;  /* always 00? */
u_int8_t xxx3;  /* always c0? */
u_int8_t seq;
u_int8_t xxx4;
  710                 struct  ether_addr to;   /* destination station addr */
  711                 struct  ether_addr from; /* sending station addr */
  712         } hwhdr;
dprintf(" [get]");
  716 #ifdef RLNDUMP
  717         /* Decode the command header: */
printf("%s: recv %c%d seq %d data ", sc->sc_dev.dv_xname,
hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
RLNDUMPHEX(hdr, sizeof hdr);
printf(":");
  722 #endif
totlen -= sizeof *hdr;
  725 #ifdef DIAGNOSTIC
  726         if (totlen <= 0) {
printf("%s: empty packet", sc->sc_dev.dv_xname);
  728                 goto drop;
  729         }
  730 #endif
  732         /* Decode the hardware header: */
rln_rx_pdata(sc, &hwhdr, sizeof hwhdr, &pd);
totlen -= sizeof hwhdr;
  735 #ifdef RLNDUMP
RLNDUMPHEX(&hwhdr, sizeof hwhdr);
printf("/");
  738 #endif
  739         /* (Most of the following code fleeced from elink3.c.) */
MGETHDR(m, M_DONTWAIT, MT_DATA);
  742         if (m == NULL)
  743                 goto drop;
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.len = totlen;
  746         /*
  747          * Insert some leading padding in the mbuf, so that payload data is
  748          * aligned.
  749          */
pad = ALIGN(sizeof(struct ether_header)) - sizeof(struct ether_header);
m->m_data += pad;
len = MHLEN - pad;
top = 0;
mp = &top;
  756         while (totlen > 0) {
  757                 if (top) {
MGET(m, M_DONTWAIT, MT_DATA);
  759                         if (m == NULL) {
m_freem(top);
  761                                 goto drop;
  762                         }
len = MLEN;
  764                 }
  765                 if (totlen >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
  767                         if (m->m_flags & M_EXT) {
len = MCLBYTES;
  769                                 if (!top) {
m->m_data += pad;
len -= pad;
  772                                 }
  773                         }
  774                 }
len = min(totlen, len);
rln_rx_pdata(sc, mtod(m, u_int8_t *), len, &pd);
  777 #ifdef RLNDUMP
RLNDUMPHEX(mtod(m, u_int8_t *), len);
  779                 if (totlen != len)
printf("|");
  781 #endif
m->m_len = len;
totlen -= len;
  784                 *mp = m;
mp = &m->m_next;
  786         }
  787 #ifdef RLNDUMP
printf("\n");
  789 #endif
  790         return top;
drop:
  793 #ifdef RLNDUMP
printf(": drop\n");
  795 #endif
ifp->if_iqdrops++;
  797         return NULL;
  798 }
  800 /* Interface control. */
  801 int
rlnioctl(ifp, cmd, data)
  803         struct ifnet *ifp;
u_long cmd;
caddr_t data;
  806 {
  807         struct rln_softc *sc = ifp->if_softc;
  808         struct ifaddr *ifa = (struct ifaddr *)data;
  809         int s, error;
  810         int need_init;
printf("%s: ioctl cmd[%c/%d] data=%x\n", sc->sc_dev.dv_xname,
IOCGROUP(cmd), IOCBASECMD(cmd), data);
s = splnet();
  816         if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) != 0) {
splx(s);
  818                 return error;
  819         }
  821         switch (cmd) {
  822         case SIOCSIFADDR:
  823                 /* Set address. */
ifp->if_flags |= IFF_UP;
  826                 switch (ifa->ifa_addr->sa_family) {
  827 #ifdef INET
  828                 case AF_INET:
rlninit(sc);
arp_ifinit(&sc->sc_arpcom, ifa);
  831                         break;
  832 #endif
  833                 default:
rlninit(sc);
  835                         break;
  836                 }
  837                 break;
  839         case SIOCSIFFLAGS:
need_init = 0;
  842                 if ((ifp->if_flags & IFF_UP) == 0 &&
  843                     (ifp->if_flags & IFF_RUNNING) != 0) {
  844                         /* Was running, want down: stop. */
rlnstop(sc);
  846                 } else if ((ifp->if_flags & IFF_UP) != 0 &&
  847                            (ifp->if_flags & IFF_RUNNING) == 0) {
  848                         /* Was not running, want up: start. */
need_init = 1;
  850                 } 
  852                 if (ifp->if_flags & IFF_RUNNING) {
  853                         if ((ifp->if_flags & IFF_PROMISC) &&
  854                             (sc->sc_state & RLN_STATE_PROMISC) == 0) {
sc->sc_state |= RLN_STATE_PROMISC;
need_init = 1;
  857                         }
  858                         else if ((ifp->if_flags & IFF_PROMISC) == 0 &&
  859                             (sc->sc_state & RLN_STATE_PROMISC)) {
sc->sc_state &= ~RLN_STATE_PROMISC;
need_init = 1;
  862                         }
  863                 }
  865                 if (need_init)
rlninit(sc);
  868                 break;
  870         case SIOCADDMULTI:
  871         case SIOCDELMULTI:
error = EOPNOTSUPP;
  873                 break;
  875 #if notyet
  876         case RLNIOSPARAM:
error = rln_iosetparam(sc, (struct rln_param *)&data);
  878                 break;
  880         case RLNIOGPARAM:
bcopy(&sc->sc_param, (struct rln_param *)&data, 
  882                     sizeof sc->sc_param);
  883                 break;
  884 #endif
  886         default:
error = EINVAL;
  888                 break;
  889         }
splx(s);
  892         return (error);
  893 }
  895 /* Stop output from the card. */
  896 void
rlnstop(sc)
  898         struct rln_softc *sc;
  899 {
  900         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
dprintf(" [stop]");
ifp->if_flags &= ~IFF_RUNNING;
rln_enable(sc, 0);
  905 }
  907 /* Get MAC address from card. */
  908 int
rln_getenaddr(sc, enaddr)
  910         struct rln_softc *sc;
u_int8_t * enaddr;
  912 {
  913         struct rln_mm_cmd query = RLN_MM_GETENADDR;
  914         struct rln_mm_gotenaddr response = { RLN_MM_GETENADDR };
  916         if (rln_msg_txrx(sc, &query, sizeof query,
  917             &response, sizeof response))
  918                 return (-1);
bcopy(response.enaddr, enaddr, sizeof response.enaddr);
  920         return (0);
  921 };
  923 /* Get firmware version string from card. */
  924 int
rln_getpromvers(sc, ver, verlen)
  926         struct rln_softc *sc;
  927         char *ver;
  928         int verlen;
  929 {
  930         struct rln_mm_cmd query = RLN_MM_GETPROMVERSION;
  931         struct rln_mm_gotpromversion response = { RLN_MM_GOTPROMVERSION };
  932         int i;
  934 #ifdef DIAGNOSTIC
  935         if (verlen != sizeof response.version)
panic("rln_getpromvers");
  937 #endif
  939         if (rln_msg_txrx(sc, &query, sizeof query,
  940             &response, sizeof response))
  941                 return (-1);
bcopy(response.version, ver, verlen);
  943         /* Nul trailing spaces. */
  944         for (i = verlen - 1; i >= 0 && ver[i] <= ' '; i--)
ver[i] = '\0';
  946         return (0);
  947 };
  949 /* Set default operational parameters on card. */
  950 int
rln_sendinit(sc)
  952         struct rln_softc *sc;
  953 {
  954         struct rln_mm_init init = { RLN_MM_INIT };
  955         struct rln_mm_initted iresponse;
  956 #if 0
  957         struct rln_mm_setmagic magic = { RLN_MM_SETMAGIC };
  958         struct rln_mm_disablehopping hop = { RLN_MM_DISABLEHOPPING };
  959         struct rln_mm_cmd response;
  960 #endif
bzero((char *)&init + sizeof init.mm_cmd,
  963                 sizeof init - sizeof init.mm_cmd);
dprintf(" [setting parameters]");
init.opmode = (sc->sc_state & RLN_STATE_PROMISC ?
RLN_MM_INIT_OPMODE_PROMISC : RLN_MM_INIT_OPMODE_NORMAL);
init.stationtype = sc->sc_param.rp_station_type;
  970         /* Spread-spectrum frequency hopping. */
init.hop_period = 1;
init.bfreq = 2;
init.sfreq = 7;
  975         /* Choose channel. */
init.channel = sc->sc_param.rp_channel;
init.subchannel = sc->sc_param.rp_subchannel;
init.domain = sc->sc_param.rp_domain;
  980         /* Name of this station when acting as master. */
bcopy(sc->sc_param.rp_master, init.mastername, sizeof init.mastername);
  983         /* Security params. */
init.sec1 = (sc->sc_param.rp_security & 0x0000ff) >> 0;
init.sec2 = (sc->sc_param.rp_security & 0x00ff00) >> 8;
init.sec3 = (sc->sc_param.rp_security & 0xff0000) >> 16;
init.sync_to = 1;
bzero(init.syncname, sizeof init.syncname);
  991         if (rln_msg_txrx(sc, &init, sizeof init,
  992             &iresponse, sizeof iresponse))
  993                 return (-1);
  994 #if 0
dprintf(" [setting magic]");
magic.fairness_slot = 3;        /* lite: 1, norm: 3, off: -1 */
magic.deferral_slot = 3;        /* lite: 0, norm: 3, off: -1 */
magic.regular_mac_retry = 7;
magic.frag_mac_retry = 10;
magic.regular_mac_qfsk = 2;
magic.frag_mac_qfsk = 5;
magic.xxx1 = 0xff;
magic.xxx2 = 0xff;
magic.xxx3 = 0xff;
magic.xxx4 = 0x00;
 1006         if (rln_msg_txrx(sc, &magic, sizeof magic,
 1007             &response, sizeof response))
 1008                 return (-1);
dprintf(" [disabling freq hopping]");
hop.hopflag = RLN_MM_DISABLEHOPPING_HOPFLAG_DISABLE;
 1012         if (rln_msg_txrx(sc, &hop, sizeof hop,
 1013             &response, sizeof response))
 1014                 return (-1);
 1016 #endif
 1017         return (0);
 1018 }
 1020 #if notyet
 1021 /* Configure the way the card leaves a basestation. */
 1022 int
rln_roamconfig(sc)
 1024         struct rln_softc *sc;
 1025 {
 1026         struct rln_mm_setroaming roam = { RLN_MM_SETROAMING };
 1027         struct rln_mm_cmd response;
 1028         static int retry[3] = { 6, 6, 4 };
 1029         static int rssi[3] = { 5, 15, 5 };
dprintf(" [roamconfig]");
 1032 #ifdef DIAGNOSTIC
 1033         if (sc->sc_param.rp_roam_config > 2)
panic("roamconfig");
 1035 #endif
roam.sync_alarm = 0;
roam.retry_thresh = retry[sc->sc_param.rp_roam_config];
roam.rssi_threshold = rssi[sc->sc_param.rp_roam_config];
roam.xxx1 = 0x5a;
roam.sync_rssi_threshold = 0;
roam.xxx2 = 0x5a;
roam.missed_sync = 0x4;
 1043         if (rln_msg_txrx(sc, &roam, sizeof roam,
 1044             &response, sizeof response))
 1045                 return (-1);
 1047         return (0);
 1048 }
 1050 /* Enable roaming. */
 1051 int
rln_roam(sc)
 1053         struct rln_softc *sc;
 1054 {
 1055         struct rln_mm_cmd roam = RLN_MM_ROAM;
 1056         struct rln_mm_cmd response;
 1058         return (rln_msg_txrx(sc, &roam, sizeof roam,
 1059             &response, sizeof response));
 1060 }
 1062 /* Enable multicast capability. */
 1063 int
rln_multicast(sc, enable)
 1065         struct rln_softc *sc;
 1066         int enable;
 1067 {
 1068         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
 1069         struct rln_mm_multicast mcast = { RLN_MM_MULTICAST };
 1070         struct rln_mm_cmd response;
 1071         int ret;
mcast.enable = enable;
ret = rln_msg_txrx(sc, &mcast, sizeof mcast,
 1076             &response, sizeof response);
 1077         if (ret == 0) {
 1078                 if (enable)
ifp->if_flags |= IFF_MULTICAST;
 1080                 else
ifp->if_flags &= ~IFF_MULTICAST;
 1082         }
 1083         return (ret);
 1084 }
 1086 /* Search for and sync with any master. */
 1087 int
rln_searchsync(sc)
 1089         struct rln_softc *sc;
 1090 {
 1091         struct rln_mm_search search = { RLN_MM_SEARCH };
 1092         struct rln_mm_searching response;
bzero(search.xxx1, sizeof search.xxx1);
search.domain = sc->sc_param.rp_domain;
search.roaming = 1;
search.xxx3 = 0;
search.xxx4 = 1;
search.xxx5 = 0;
bzero(search.xxx6, sizeof search.xxx6);
 1102         return (rln_msg_txrx(sc, &search, sizeof search,
 1103                 &response, sizeof response));
 1104 }
 1106 /* Set values from an external parameter block. */
 1107 int
rln_iosetparam(sc, param)
 1109         struct rln_softc *sc;
 1110         struct rln_param *param;
 1111 {
 1112         int error = 0;
 1114         if (param->rp_roam_config > 2)
error = EINVAL;
 1116         if (param->rp_security > 0x00ffffff)
error = EINVAL;
 1118         if (param->rp_station_type > 2)
error = EINVAL;
 1120         if (param->rp_channel > 15)
error = EINVAL;
 1122         if (param->rp_subchannel > 15)
error = EINVAL;
 1124         if (error == 0) {
 1125                 /* Apply immediately. */
bcopy(param, &sc->sc_param, sizeof *param);
 1127                 if (rln_sendinit(sc))
error = EIO;
 1129         }
 1130         return (error);
 1131 }
 1133 /* Protect the eeprom from storing a security ID(?) */
 1134 int
rln_lockprom(sc)
 1136         struct rln_softc *sc;
 1137 {
 1138         struct rln_mm_cmd lock = RLN_MM_EEPROM_PROTECT;
 1139         struct rln_mm_cmd response;
 1141         /* XXX Always yields an error? */
 1142         return (rln_msg_txrx(sc, &lock, sizeof lock,
 1143             &response, sizeof response));
 1144 }
 1146 /* Set the h/w Inactivity Time Out timer on the card. */
 1147 int
rln_ito(sc)
 1149         struct rln_softc * sc;
 1150 {
 1151         struct rln_mm_setito ito = { RLN_MM_MULTICAST };
 1152         struct rln_mm_cmd response;
ito.xxx = 3;
ito.timeout = LLDInactivityTimeOut /* enabler, 0 or 1 */;
ito.bd_wakeup = LLDBDWakeup /* 0 */;
ito.pm_sync = LLDPMSync /* 0 */;
ito.sniff_time = ito.timeout ? LLDSniffTime /* 0 */ : 0;
 1160         if (rln_msg_txrx(sc, &ito, sizeof ito,
 1161             &response, sizeof response))
 1162                 return (-1);
 1163 }
 1165 /* Put the card into standby mode. */
 1166 int
rln_standby(sc)
 1168         struct rln_softc * sc;
 1169 {
 1170         struct rln_mm_standby standby = { RLN_MM_STANDBY };
standby.xxx = 0;
 1173         if (rln_msg_txrx(sc, &ito, sizeof ito, NULL, 0))
 1174                 return (-1);
 1175 }
 1177 void
 1178 rln_crypt(userkey, cardkey)
 1179         char *userkey;          /* User's string (max 20 chars). */
u_int8_t *cardkey;      /* 20 bits (3 bytes) */
 1181 {
 1182         /*
 1183          * From <http://www.proxim.com/learn/whiteppr/rl2security.shtml> 
 1184          * "RangeLAN2 Security Features":
 1185          *
 1186          *  The Security ID is a unique, 20 character alphanumeric
 1187          *  string defined and configured by the user. It must be
 1188          *  identically configured in every radio intended to
 1189          *  communicate with others in the same network. Once
 1190          *  configured, the Security ID is reduced to 20 bits by a
 1191          *  proprietary algorithm confidential to Proxim. It is
 1192          *  merged with the radio MAC address (a 12 character field
 1193          *  unique to every radio), scrambled and stored using another
 1194          *  proprietary, confidential algorithm.
 1195          */
int32_t key;
int8_t ret;
 1198         int i;
 1199         int len;
int32_t multiplicand = 0x80000181;
int64_t res;
 1203         /* 
 1204          * This algorithm is `compatible' with Proxim's first
 1205          * `proprietary confidential algorithm': i.e., it appears
 1206          * to be functionally identical.
 1207          */
len = strlen(s);
key = 0x030201;
 1210         for (i = 0; i < len; i++) {
key *= userkey[i];
res = (int64_t)multiplicand * key;
key = key - 0xfffffd * 
 1215                     (((key + (int32_t)(res >> 32)) >> 23) - (key >> 31));
 1216         }
cardkey[0] = (key >> 16) & 0xff;
cardkey[1] = (key >> 8) & 0xff;
cardkey[2] = key & 0xff;
cardkey[0] |= 0x03;     /* Restrict key space by 2 bits. */
 1223 }
 1224 #endif