![[BACK]](/icons/back.gif){kind=icon}
Return to rln.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to rln.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 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: */
13:
14: #include "bpfilter.h"
15:
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>
24:
25: #include <net/if.h>
26: #include <net/if_media.h>
27:
28: #ifdef INET
29: #include <netinet/in.h>
30: #include <netinet/if_ether.h>
31: #endif
32:
33: #if NBPFILTER > 0
34: #include <net/bpf.h>
35: #endif
36:
37: #include <machine/bus.h>
38: #include <machine/intr.h>
39:
40: #include <dev/ic/rln.h>
41: #include <dev/ic/rlnvar.h>
42: #include <dev/ic/rlnreg.h>
43: #include <dev/ic/rlncmd.h>
44:
45: /* Autoconfig definition of driver back-end. */
46: struct cfdriver rln_cd = {
47: NULL, "rln", DV_IFNET
48: };
49:
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 *);
55:
56: /* Interrupt handler. */
57: void rlnsoftintr(void *);
58:
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);
64:
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
79:
80: /* Back-end attach and configure. Assumes card has been reset. */
81: void
82: rlnconfig(sc)
83: struct rln_softc * sc;
84: {
85: struct ifnet * ifp = &sc->sc_arpcom.ac_if;
86: char promvers[7];
87: int i;
88:
89: dprintf(" [attach %p]", sc);
90:
91: /* Use the flags supplied from config. */
92: sc->sc_cardtype |= sc->sc_dev.dv_cfdata->cf_flags;
93:
94: /* Initialise values in the soft state. */
95: sc->sc_pktseq = 0; /* rln_newseq() */
96: sc->sc_txseq = 0;
97: sc->sc_state = 0;
98:
99: /* Initialise user-configurable params. */
100: sc->sc_param.rp_roam_config = RLN_ROAM_NORMAL;
101: sc->sc_param.rp_security = RLN_SECURITY_DEFAULT;
102: sc->sc_param.rp_station_type = RLN_STATIONTYPE_ALTMASTER;
103: sc->sc_param.rp_domain = 0;
104: sc->sc_param.rp_channel = 1;
105: sc->sc_param.rp_subchannel = 1;
106:
107: bzero(sc->sc_param.rp_master, sizeof sc->sc_param.rp_master);
108:
109: /* Initialise the message mailboxes. */
110: for (i = 0; i < RLN_NMBOX; i++)
111: sc->sc_mbox[i].mb_state = RLNMBOX_VOID;
112:
113: /* Probe for some properties. */
114: printf(", %s-piece",
115: (sc->sc_cardtype & RLN_CTYPE_ONE_PIECE) ? "one" : "two");
116: if (sc->sc_cardtype & RLN_CTYPE_OEM)
117: printf(" oem");
118: if (sc->sc_cardtype & RLN_CTYPE_UISA)
119: printf(" micro-isa");
120:
121: /* Read the card's PROM revision. */
122: if (rln_getpromvers(sc, promvers, sizeof promvers)) {
123: printf(": could not read PROM version\n");
124: return;
125: }
126: printf(", fw %.7s", promvers);
127:
128: /* Fetch the card's MAC address. */
129: if (rln_getenaddr(sc, sc->sc_arpcom.ac_enaddr)) {
130: printf(": could not read MAC address\n");
131: return;
132: }
133: printf(", addr %s", ether_sprintf(sc->sc_arpcom.ac_enaddr));
134:
135: timeout_set(&sc->sc_timeout, rlnsoftintr, sc);
136:
137: /* Attach as a network interface. */
138: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
139: ifp->if_softc = sc;
140: ifp->if_start = rlnstart;
141: ifp->if_ioctl = rlnioctl;
142: ifp->if_watchdog = rlnwatchdog;
143: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS;
144: IFQ_SET_READY(&ifp->if_snd);
145: if_attach(ifp);
146: ether_ifattach(ifp);
147: }
148:
149: /* Bring device up. */
150: void
151: rlninit(sc)
152: struct rln_softc * sc;
153: {
154: /* LLDInit() */
155: struct ifnet * ifp = &sc->sc_arpcom.ac_if;
156: int s;
157:
158: s = splnet();
159: dprintf(" [init]");
160:
161: sc->sc_intsel = 0;
162: sc->sc_status = 0;
163: sc->sc_control = 0;
164: ifp->if_flags &= ~IFF_RUNNING;
165: ifp->if_flags &= ~IFF_OACTIVE;
166:
167: /* Do a hard reset. */
168: if (rln_reset(sc)) {
169: printf("%s: could not reset card\n", sc->sc_dev.dv_xname);
170: goto fail;
171: }
172: sc->sc_state = 0; /* Also clears RLN_STATE_NEEDINIT. */
173:
174: /* Use this host's name as a master name. */
175: if (!cold && sc->sc_param.rp_master[0] == '\0') {
176: bcopy(hostname, sc->sc_param.rp_master,
177: min(hostnamelen, sizeof sc->sc_param.rp_master));
178: }
179:
180: rln_enable(sc, 1);
181:
182: /* Initialise operational params. */
183: if (rln_sendinit(sc)) {
184: printf("%s: could not set card parameters\n",
185: sc->sc_dev.dv_xname);
186: goto fail;
187: }
188: #if 0
189: rln_roamconfig(sc);
190: /* rln_lockprom(sc); */
191: /* SendSetITO() */
192: rln_multicast(sc, 1);
193: rln_roam(sc);
194:
195: /* Synchronise with something. */
196: rln_searchsync(sc);
197: #endif
198: ifp->if_flags |= IFF_RUNNING;
199: rlnstart(ifp);
200: splx(s);
201:
202: return;
203:
204: fail:
205: ifp->if_flags &= ~IFF_UP;
206: splx(s);
207: return;
208: }
209:
210: /* Start outputting on interface. This is always called at splnet(). */
211: void
212: 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;
218:
219: dprintf(" start[");
220:
221: if (sc->sc_state & RLN_STATE_NEEDINIT)
222: rlninit(sc);
223:
224: /* Don't transmit if interface is busy or not running. */
225: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING) {
226: dprintf(" %s] ", (ifp->if_flags & IFF_OACTIVE) ?
227: "busy" : "stopped");
228: return;
229: }
230:
231: /* Don't transmit if we are not synchronised. */
232: if ((sc->sc_state & RLN_STATE_SYNC) == 0) {
233: dprintf(" nosync]");
234: return;
235: }
236:
237: rln_enable(sc, 1);
238:
239: startagain:
240: s = splnet();
241: IFQ_DEQUEUE(&ifp->if_snd, m0);
242: splx(s);
243:
244: if (m0 == NULL) {
245: dprintf(" empty]");
246: return;
247: }
248:
249: #if NBPFILTER > 0
250: /* Tap packet stream here for BPF listeners. */
251: if (ifp->if_bpf)
252: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
253: #endif
254:
255: /* We need to use m->m_pkthdr.len, so require the header. */
256: if ((m0->m_flags & M_PKTHDR) == 0) {
257: printf("%s: no mbuf header\n", sc->sc_dev.dv_xname);
258: goto oerror;
259: }
260:
261: len = m0->m_pkthdr.len;
262:
263: #define PACKETMIN (sizeof (struct ether_header) + ETHERMIN)
264: #define PACKETMAX (sizeof (struct ether_header) + ETHERMTU + 4)
265:
266: /* Packet size has to be an even number between 60 and 1518 octets. */
267: pad = len & 1;
268: if (len + pad < PACKETMIN)
269: pad = PACKETMIN - len;
270:
271: if (len + pad > PACKETMAX) {
272: printf("%s: packet too big (%d > %d)\n",
273: sc->sc_dev.dv_xname, len + pad,
274: PACKETMAX);
275: ++ifp->if_oerrors;
276: m_freem(m0);
277: goto startagain;
278: }
279:
280: ret = rln_transmit(sc, m0, len, pad);
281: if (ret)
282: goto oerror;
283:
284: ifp->if_flags |= IFF_OACTIVE;
285: m_freem(m0);
286:
287: dprintf(" sent]");
288: return;
289:
290: oerror:
291: ++ifp->if_oerrors;
292: m_freem(m0);
293: rln_need_reset(sc);
294: return;
295: }
296:
297: /* Transmit one packet. */
298: int
299: 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 };
312:
313: /* Does the packet start with a zero bit? */
314: zfirst = ((*mtod(m0, u_int8_t *) & 1) == 0);
315:
316: cmd.mode =
317: RLN_MM_SENDPACKET_MODE_BIT7 |
318: (zfirst ? RLN_MM_SENDPACKET_MODE_ZFIRST : 0) |
319: (0 ? RLN_MM_SENDPACKET_MODE_QFSK : 0), /* sc->qfsk? */
320: cmd.power = 0x70; /* 0x70 or 0xf0 */
321: cmd.length_lo = htons(4 + tlen) & 0xff;
322: cmd.length_hi = (htons(4 + tlen) >> 8) & 0xff;
323: cmd.xxx1 = 0;
324: cmd.xxx2 = 0;
325: cmd.xxx3 = 0;
326:
327: /* A unique packet-level sequence number, independent of sc_seq. */
328: cmd.sequence = sc->sc_txseq;
329: sc->sc_txseq++;
330: if (sc->sc_txseq > RLN_MAXSEQ)
331: sc->sc_txseq = 0;
332:
333: dprintf(" T[%d+%d", len, pad);
334:
335: if (rln_msg_tx_start(sc, &cmd, sizeof cmd + tlen, &state))
336: goto error;
337:
338: cmd.mm_cmd.cmd_seq = rln_newseq(sc);
339:
340: /* Send the SENDPACKET command header */
341: #ifdef RLNDUMP
342: printf("%s: send %c%d seq %d data ", sc->sc_dev.dv_xname,
343: cmd.mm_cmd.cmd_letter, cmd.mm_cmd.cmd_fn, cmd.mm_cmd.cmd_seq);
344: RLNDUMPHEX(&cmd, sizeof cmd);
345: printf(":");
346: #endif
347: rln_msg_tx_data(sc, &cmd, sizeof cmd, &state);
348:
349: /* XXX do we need to insert a hardware header here??? */
350:
351: /* Follow the header immediately with the packet payload */
352: actlen = 0;
353: for (m = m0; m; m = m->m_next) {
354: if (m->m_len) {
355: #ifdef RLNDUMP
356: RLNDUMPHEX(mtod(m, void *), m->m_len);
357: #endif
358: rln_msg_tx_data(sc, mtod(m, void *), m->m_len, &state);
359: }
360: if (m->m_next)
361: printf("|");
362: actlen += m->m_len;
363: }
364: #ifdef DIAGNOSTIC
365: if (actlen != len)
366: panic("rln_transmit: len %d != %d", actlen, len);
367: if (pad > sizeof zeroes)
368: panic("rln_transmit: pad %d > %d", pad, sizeof zeroes);
369: #endif
370: if (pad) {
371: #ifdef RLNDUMP
372: printf(":");
373: RLNDUMPHEX(zeroes, pad);
374: #endif
375: rln_msg_tx_data(sc, zeroes, pad, &state);
376: }
377:
378: #ifdef RLNDUMP
379: printf("\n");
380: #endif
381: if (rln_msg_tx_end(sc, &state))
382: goto error;
383: return (0);
384:
385: error:
386: dprintf(" error]");
387: return (-1);
388: }
389:
390: /* (Supposedly) called when interrupts are suspiciously absent. */
391: void
392: rlnwatchdog(ifp)
393: struct ifnet * ifp;
394: {
395: struct rln_softc * sc = (struct rln_softc *)ifp->if_softc;
396:
397: log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
398: ++sc->sc_arpcom.ac_if.if_oerrors;
399: rlninit(sc);
400: rln_enable(sc, 1);
401: }
402:
403: /* Handle single card interrupt. */
404: int
405: rlnintr(arg)
406: void * arg;
407: {
408: struct rln_softc * sc = (struct rln_softc *)arg;
409:
410: dprintf("!");
411:
412: /* Tell card not to interrupt any more. */
413: rln_enable(sc, 0);
414:
415: if (cold)
416: /* During autoconfig - must handle interrupts now. */
417: rlnsoftintr(sc);
418: else
419: /* Handle later. */
420: timeout_add(&sc->sc_timeout, 1);
421:
422: return (1);
423: }
424:
425: /* Process earlier card interrupt at splsoftnet. */
426: void
427: 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;
433: u_int8_t w;
434: struct rln_mm_cmd hdr;
435: int s;
436:
437: s = splsoftnet();
438: dprintf(" si(");
439:
440: again:
441: /* Save wakeup state. */
442: w = rln_wakeup(sc, RLN_WAKEUP_SET);
443:
444: if ((len = rln_rx_request(sc, 300)) < 0) {
445: /* Error in transfer. */
446: rln_need_reset(sc);
447: rln_rx_end(sc);
448: } else if (len < sizeof hdr) {
449: /* Short message. */
450: rln_rx_end(sc);
451: printf("%s: short msg (%d)\n", sc->sc_dev.dv_xname, len);
452: ifp->if_ierrors++;
453: } else {
454: /* Valid message: read header and process. */
455: rln_rx_data(sc, &hdr, sizeof hdr);
456: rlnread(sc, &hdr, len);
457: }
458:
459: /* Ensure that wakeup state is unchanged if transmitting. */
460: if (ifp->if_flags & IFF_OACTIVE)
461: w |= RLN_WAKEUP_NOCHANGE;
462: rln_wakeup(sc, w);
463:
464: /* Check for more interrupts. */
465: if ((sc->sc_state & RLN_STATE_NEEDINIT) == 0 &&
466: rln_status_rx_ready(sc)) {
467: if (rln_status_rx_read(sc) == RLN_STATUS_RX_ERROR) {
468: #ifdef DIAGNOSTIC
469: printf("%s: protocol error\n", sc->sc_dev.dv_xname);
470: #endif
471: DELAY(100 * 1000); /* Woah, baby. */
472: rln_clear_nak(sc);
473: } else {
474: #ifdef DIAGNOSTIC
475: printf("%s: intr piggyback\n", sc->sc_dev.dv_xname);
476: #endif
477: goto again;
478: }
479: }
480:
481: rln_eoi(sc);
482: rln_enable(sc, 1);
483:
484: dprintf(")");
485: splx(s);
486: }
487:
488: /* Read and process a message from the card. */
489: void
490: 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;
497: u_int8_t data[1538];
498: u_int8_t *buf;
499: 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;
503:
504: dprintf(" [read]");
505:
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)
510: panic("rlnread buflen");
511: #endif
512: bcopy(hdr, buf, sizeof *hdr);
513: buf += sizeof *hdr;
514: len -= sizeof *hdr;
515: buflen -= sizeof *hdr;
516: if (len) {
517: if (len == buflen) /* Expected size */
518: rln_rx_pdata(sc, buf, len, &pd);
519: else if (len < buflen) { /* Underfill */
520: #ifdef DIAGNOSTIC
521: printf("%s: underfill %d<%d, cmd %c%d\n",
522: sc->sc_dev.dv_xname,
523: len, buflen,
524: hdr->cmd_letter, hdr->cmd_fn);
525: #endif
526: rln_rx_pdata(sc, buf, len, &pd);
527: } else { /* Overflow */
528: #ifdef DIAGNOSTIC
529: printf("%s: overflow %d>%d, cmd %c%d\n",
530: sc->sc_dev.dv_xname,
531: len, buflen,
532: hdr->cmd_letter, hdr->cmd_fn);
533: #endif
534: rln_rx_pdata(sc, buf, buflen, &pd);
535: /* Drain the rest somewhere. */
536: rln_rx_pdata(sc, data, len - buflen, &pd);
537: }
538: }
539: rln_rx_end(sc);
540:
541: /* This message can now be handled by the waiter. */
542: rln_mbox_unlock(sc, hdr->cmd_seq, len + sizeof *hdr);
543: return;
544: }
545:
546: /* Otherwise, handle the message, right here, right now. */
547:
548: /* Check if we can cope with the size of this message. */
549: if (len > sizeof data) {
550: printf("%s: msg too big (%d)\n", sc->sc_dev.dv_xname, len);
551: ifp->if_ierrors++;
552: rln_rx_end(sc);
553: /* rln_need_reset(sc); */
554: return;
555: }
556:
557: /* Check for error results. */
558: if (hdr->cmd_error & 0x80) {
559: printf("%s: command error 0x%02x command %c%d len=%d\n",
560: sc->sc_dev.dv_xname,
561: hdr->cmd_error & ~0x80,
562: hdr->cmd_letter, hdr->cmd_fn,
563: len);
564: ifp->if_ierrors++;
565: rln_rx_end(sc);
566: rln_need_reset(sc);
567: return;
568: }
569:
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) {
576: m = rlnget(sc, hdr, len);
577: rln_rx_end(sc);
578: if (m == NULL)
579: return;
580: ifp->if_ipackets++;
581: #ifdef DIAGNOSTIC
582: if (bcmp(mtod(m, u_int8_t *), "prox", 4) == 0) {
583: printf("%s: proxim special packet received\n",
584: sc->sc_dev.dv_xname);
585: }
586: #endif
587:
588: #if NBPFILTER > 0
589: if (ifp->if_bpf)
590: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
591: #endif
592:
593: ether_input_mbuf(ifp, m);
594: return;
595: }
596:
597:
598: /* Otherwise we read the packet into a buffer on the stack. */
599: bcopy(hdr, data, sizeof *hdr);
600: if (len > sizeof *hdr)
601: rln_rx_pdata(sc, data + sizeof *hdr, len - sizeof *hdr, &pd);
602: rln_rx_end(sc);
603:
604: #ifdef RLNDUMP
605: printf("%s: recv %c%d seq %d data ", sc->sc_dev.dv_xname,
606: hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
607: RLNDUMPHEX(hdr, sizeof hdr);
608: printf(":");
609: RLNDUMPHEX(data + sizeof hdr, len - sizeof hdr);
610: printf("\n");
611: #endif
612:
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)
617: printf("%s: 'b0' len %d != 7\n",
618: sc->sc_dev.dv_xname, len);
619: #endif
620: ifp->if_flags &= ~IFF_OACTIVE;
621: ifp->if_opackets++;
622: s = splnet();
623: rlnstart(ifp);
624: splx(s);
625: break;
626:
627: case RLN_MM_CMD('a', 20): /* a20: Card fault. */
628: printf("%s: hardware fault\n", sc->sc_dev.dv_xname);
629: break;
630:
631: case RLN_MM_CMD('a', 4): /* a4: Sync'd. */
632: if (bcmp(syncp->enaddr, sc->sc_arpcom.ac_enaddr,
633: 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: */
644:
645: printf("%s: nothing to sync to; now master ",
646: sc->sc_dev.dv_xname);
647: }
648: else
649: printf("%s: synchronised to ", sc->sc_dev.dv_xname);
650: printf("%.11s (%s) channel %d/%d\n",
651: syncp->mastername,
652: ether_sprintf(syncp->enaddr),
653: syncp->channel,
654: syncp->subchannel);
655:
656: /* Record the new circumstances. */
657: sc->sc_param.rp_channel = syncp->channel;
658: sc->sc_param.rp_subchannel = syncp->subchannel;
659: sc->sc_state |= RLN_STATE_SYNC;
660:
661: /* Resume sending. */
662: s = splnet();
663: rlnstart(ifp);
664: splx(s);
665: break;
666:
667: case RLN_MM_CMD('a', 5): /* a4: Lost sync. */
668: printf("%s: lost sync\n", sc->sc_dev.dv_xname);
669: sc->sc_state &= ~RLN_STATE_SYNC;
670: break;
671:
672: case RLN_MM_CMD('a', 18): /* a18: Roaming. */
673: printf("%s: roaming\n", sc->sc_dev.dv_xname);
674: break;
675: default:
676: #ifdef DIAGNOSTIC
677: printf("%s: msg `%c%d' seq %d data {",
678: sc->sc_dev.dv_xname,
679: hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
680: RLNDUMPHEX(hdr, sizeof hdr);
681: printf(":");
682: RLNDUMPHEX(data, len);
683: printf("}\n");
684: #endif
685: break;
686: }
687:
688: }
689:
690: /* Extract a received network packet from the card. */
691: struct mbuf *
692: 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 {
703: u_int8_t rssi;
704: u_int8_t xxx1; /* always 00? */
705: u_int16_t len; /* payload length */
706: u_int8_t xxx2; /* always 00? */
707: u_int8_t xxx3; /* always c0? */
708: u_int8_t seq;
709: u_int8_t xxx4;
710: struct ether_addr to; /* destination station addr */
711: struct ether_addr from; /* sending station addr */
712: } hwhdr;
713:
714: dprintf(" [get]");
715:
716: #ifdef RLNDUMP
717: /* Decode the command header: */
718: printf("%s: recv %c%d seq %d data ", sc->sc_dev.dv_xname,
719: hdr->cmd_letter, hdr->cmd_fn, hdr->cmd_seq);
720: RLNDUMPHEX(hdr, sizeof hdr);
721: printf(":");
722: #endif
723: totlen -= sizeof *hdr;
724:
725: #ifdef DIAGNOSTIC
726: if (totlen <= 0) {
727: printf("%s: empty packet", sc->sc_dev.dv_xname);
728: goto drop;
729: }
730: #endif
731:
732: /* Decode the hardware header: */
733: rln_rx_pdata(sc, &hwhdr, sizeof hwhdr, &pd);
734: totlen -= sizeof hwhdr;
735: #ifdef RLNDUMP
736: RLNDUMPHEX(&hwhdr, sizeof hwhdr);
737: printf("/");
738: #endif
739: /* (Most of the following code fleeced from elink3.c.) */
740:
741: MGETHDR(m, M_DONTWAIT, MT_DATA);
742: if (m == NULL)
743: goto drop;
744: m->m_pkthdr.rcvif = ifp;
745: m->m_pkthdr.len = totlen;
746: /*
747: * Insert some leading padding in the mbuf, so that payload data is
748: * aligned.
749: */
750: pad = ALIGN(sizeof(struct ether_header)) - sizeof(struct ether_header);
751: m->m_data += pad;
752: len = MHLEN - pad;
753: top = 0;
754: mp = ⊤
755:
756: while (totlen > 0) {
757: if (top) {
758: MGET(m, M_DONTWAIT, MT_DATA);
759: if (m == NULL) {
760: m_freem(top);
761: goto drop;
762: }
763: len = MLEN;
764: }
765: if (totlen >= MINCLSIZE) {
766: MCLGET(m, M_DONTWAIT);
767: if (m->m_flags & M_EXT) {
768: len = MCLBYTES;
769: if (!top) {
770: m->m_data += pad;
771: len -= pad;
772: }
773: }
774: }
775: len = min(totlen, len);
776: rln_rx_pdata(sc, mtod(m, u_int8_t *), len, &pd);
777: #ifdef RLNDUMP
778: RLNDUMPHEX(mtod(m, u_int8_t *), len);
779: if (totlen != len)
780: printf("|");
781: #endif
782: m->m_len = len;
783: totlen -= len;
784: *mp = m;
785: mp = &m->m_next;
786: }
787: #ifdef RLNDUMP
788: printf("\n");
789: #endif
790: return top;
791:
792: drop:
793: #ifdef RLNDUMP
794: printf(": drop\n");
795: #endif
796: ifp->if_iqdrops++;
797: return NULL;
798: }
799:
800: /* Interface control. */
801: int
802: rlnioctl(ifp, cmd, data)
803: struct ifnet *ifp;
804: u_long cmd;
805: 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;
811:
812: printf("%s: ioctl cmd[%c/%d] data=%x\n", sc->sc_dev.dv_xname,
813: IOCGROUP(cmd), IOCBASECMD(cmd), data);
814:
815: s = splnet();
816: if ((error = ether_ioctl(ifp, &sc->sc_arpcom, cmd, data)) != 0) {
817: splx(s);
818: return error;
819: }
820:
821: switch (cmd) {
822: case SIOCSIFADDR:
823: /* Set address. */
824: ifp->if_flags |= IFF_UP;
825:
826: switch (ifa->ifa_addr->sa_family) {
827: #ifdef INET
828: case AF_INET:
829: rlninit(sc);
830: arp_ifinit(&sc->sc_arpcom, ifa);
831: break;
832: #endif
833: default:
834: rlninit(sc);
835: break;
836: }
837: break;
838:
839: case SIOCSIFFLAGS:
840: need_init = 0;
841:
842: if ((ifp->if_flags & IFF_UP) == 0 &&
843: (ifp->if_flags & IFF_RUNNING) != 0) {
844: /* Was running, want down: stop. */
845: 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. */
849: need_init = 1;
850: }
851:
852: if (ifp->if_flags & IFF_RUNNING) {
853: if ((ifp->if_flags & IFF_PROMISC) &&
854: (sc->sc_state & RLN_STATE_PROMISC) == 0) {
855: sc->sc_state |= RLN_STATE_PROMISC;
856: need_init = 1;
857: }
858: else if ((ifp->if_flags & IFF_PROMISC) == 0 &&
859: (sc->sc_state & RLN_STATE_PROMISC)) {
860: sc->sc_state &= ~RLN_STATE_PROMISC;
861: need_init = 1;
862: }
863: }
864:
865: if (need_init)
866: rlninit(sc);
867:
868: break;
869:
870: case SIOCADDMULTI:
871: case SIOCDELMULTI:
872: error = EOPNOTSUPP;
873: break;
874:
875: #if notyet
876: case RLNIOSPARAM:
877: error = rln_iosetparam(sc, (struct rln_param *)&data);
878: break;
879:
880: case RLNIOGPARAM:
881: bcopy(&sc->sc_param, (struct rln_param *)&data,
882: sizeof sc->sc_param);
883: break;
884: #endif
885:
886: default:
887: error = EINVAL;
888: break;
889: }
890:
891: splx(s);
892: return (error);
893: }
894:
895: /* Stop output from the card. */
896: void
897: rlnstop(sc)
898: struct rln_softc *sc;
899: {
900: struct ifnet *ifp = &sc->sc_arpcom.ac_if;
901:
902: dprintf(" [stop]");
903: ifp->if_flags &= ~IFF_RUNNING;
904: rln_enable(sc, 0);
905: }
906:
907: /* Get MAC address from card. */
908: int
909: rln_getenaddr(sc, enaddr)
910: struct rln_softc *sc;
911: u_int8_t * enaddr;
912: {
913: struct rln_mm_cmd query = RLN_MM_GETENADDR;
914: struct rln_mm_gotenaddr response = { RLN_MM_GETENADDR };
915:
916: if (rln_msg_txrx(sc, &query, sizeof query,
917: &response, sizeof response))
918: return (-1);
919: bcopy(response.enaddr, enaddr, sizeof response.enaddr);
920: return (0);
921: };
922:
923: /* Get firmware version string from card. */
924: int
925: 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;
933:
934: #ifdef DIAGNOSTIC
935: if (verlen != sizeof response.version)
936: panic("rln_getpromvers");
937: #endif
938:
939: if (rln_msg_txrx(sc, &query, sizeof query,
940: &response, sizeof response))
941: return (-1);
942: bcopy(response.version, ver, verlen);
943: /* Nul trailing spaces. */
944: for (i = verlen - 1; i >= 0 && ver[i] <= ' '; i--)
945: ver[i] = '\0';
946: return (0);
947: };
948:
949: /* Set default operational parameters on card. */
950: int
951: 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
961:
962: bzero((char *)&init + sizeof init.mm_cmd,
963: sizeof init - sizeof init.mm_cmd);
964:
965: dprintf(" [setting parameters]");
966: init.opmode = (sc->sc_state & RLN_STATE_PROMISC ?
967: RLN_MM_INIT_OPMODE_PROMISC : RLN_MM_INIT_OPMODE_NORMAL);
968: init.stationtype = sc->sc_param.rp_station_type;
969:
970: /* Spread-spectrum frequency hopping. */
971: init.hop_period = 1;
972: init.bfreq = 2;
973: init.sfreq = 7;
974:
975: /* Choose channel. */
976: init.channel = sc->sc_param.rp_channel;
977: init.subchannel = sc->sc_param.rp_subchannel;
978: init.domain = sc->sc_param.rp_domain;
979:
980: /* Name of this station when acting as master. */
981: bcopy(sc->sc_param.rp_master, init.mastername, sizeof init.mastername);
982:
983: /* Security params. */
984: init.sec1 = (sc->sc_param.rp_security & 0x0000ff) >> 0;
985: init.sec2 = (sc->sc_param.rp_security & 0x00ff00) >> 8;
986: init.sec3 = (sc->sc_param.rp_security & 0xff0000) >> 16;
987:
988: init.sync_to = 1;
989: bzero(init.syncname, sizeof init.syncname);
990:
991: if (rln_msg_txrx(sc, &init, sizeof init,
992: &iresponse, sizeof iresponse))
993: return (-1);
994: #if 0
995: dprintf(" [setting magic]");
996: magic.fairness_slot = 3; /* lite: 1, norm: 3, off: -1 */
997: magic.deferral_slot = 3; /* lite: 0, norm: 3, off: -1 */
998: magic.regular_mac_retry = 7;
999: magic.frag_mac_retry = 10;
1000: magic.regular_mac_qfsk = 2;
1001: magic.frag_mac_qfsk = 5;
1002: magic.xxx1 = 0xff;
1003: magic.xxx2 = 0xff;
1004: magic.xxx3 = 0xff;
1005: magic.xxx4 = 0x00;
1006: if (rln_msg_txrx(sc, &magic, sizeof magic,
1007: &response, sizeof response))
1008: return (-1);
1009:
1010: dprintf(" [disabling freq hopping]");
1011: hop.hopflag = RLN_MM_DISABLEHOPPING_HOPFLAG_DISABLE;
1012: if (rln_msg_txrx(sc, &hop, sizeof hop,
1013: &response, sizeof response))
1014: return (-1);
1015:
1016: #endif
1017: return (0);
1018: }
1019:
1020: #if notyet
1021: /* Configure the way the card leaves a basestation. */
1022: int
1023: 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 };
1030:
1031: dprintf(" [roamconfig]");
1032: #ifdef DIAGNOSTIC
1033: if (sc->sc_param.rp_roam_config > 2)
1034: panic("roamconfig");
1035: #endif
1036: roam.sync_alarm = 0;
1037: roam.retry_thresh = retry[sc->sc_param.rp_roam_config];
1038: roam.rssi_threshold = rssi[sc->sc_param.rp_roam_config];
1039: roam.xxx1 = 0x5a;
1040: roam.sync_rssi_threshold = 0;
1041: roam.xxx2 = 0x5a;
1042: roam.missed_sync = 0x4;
1043: if (rln_msg_txrx(sc, &roam, sizeof roam,
1044: &response, sizeof response))
1045: return (-1);
1046:
1047: return (0);
1048: }
1049:
1050: /* Enable roaming. */
1051: int
1052: rln_roam(sc)
1053: struct rln_softc *sc;
1054: {
1055: struct rln_mm_cmd roam = RLN_MM_ROAM;
1056: struct rln_mm_cmd response;
1057:
1058: return (rln_msg_txrx(sc, &roam, sizeof roam,
1059: &response, sizeof response));
1060: }
1061:
1062: /* Enable multicast capability. */
1063: int
1064: 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;
1072:
1073: mcast.enable = enable;
1074:
1075: ret = rln_msg_txrx(sc, &mcast, sizeof mcast,
1076: &response, sizeof response);
1077: if (ret == 0) {
1078: if (enable)
1079: ifp->if_flags |= IFF_MULTICAST;
1080: else
1081: ifp->if_flags &= ~IFF_MULTICAST;
1082: }
1083: return (ret);
1084: }
1085:
1086: /* Search for and sync with any master. */
1087: int
1088: rln_searchsync(sc)
1089: struct rln_softc *sc;
1090: {
1091: struct rln_mm_search search = { RLN_MM_SEARCH };
1092: struct rln_mm_searching response;
1093:
1094: bzero(search.xxx1, sizeof search.xxx1);
1095: search.domain = sc->sc_param.rp_domain;
1096: search.roaming = 1;
1097: search.xxx3 = 0;
1098: search.xxx4 = 1;
1099: search.xxx5 = 0;
1100: bzero(search.xxx6, sizeof search.xxx6);
1101:
1102: return (rln_msg_txrx(sc, &search, sizeof search,
1103: &response, sizeof response));
1104: }
1105:
1106: /* Set values from an external parameter block. */
1107: int
1108: rln_iosetparam(sc, param)
1109: struct rln_softc *sc;
1110: struct rln_param *param;
1111: {
1112: int error = 0;
1113:
1114: if (param->rp_roam_config > 2)
1115: error = EINVAL;
1116: if (param->rp_security > 0x00ffffff)
1117: error = EINVAL;
1118: if (param->rp_station_type > 2)
1119: error = EINVAL;
1120: if (param->rp_channel > 15)
1121: error = EINVAL;
1122: if (param->rp_subchannel > 15)
1123: error = EINVAL;
1124: if (error == 0) {
1125: /* Apply immediately. */
1126: bcopy(param, &sc->sc_param, sizeof *param);
1127: if (rln_sendinit(sc))
1128: error = EIO;
1129: }
1130: return (error);
1131: }
1132:
1133: /* Protect the eeprom from storing a security ID(?) */
1134: int
1135: 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;
1140:
1141: /* XXX Always yields an error? */
1142: return (rln_msg_txrx(sc, &lock, sizeof lock,
1143: &response, sizeof response));
1144: }
1145:
1146: /* Set the h/w Inactivity Time Out timer on the card. */
1147: int
1148: rln_ito(sc)
1149: struct rln_softc * sc;
1150: {
1151: struct rln_mm_setito ito = { RLN_MM_MULTICAST };
1152: struct rln_mm_cmd response;
1153:
1154: ito.xxx = 3;
1155: ito.timeout = LLDInactivityTimeOut /* enabler, 0 or 1 */;
1156: ito.bd_wakeup = LLDBDWakeup /* 0 */;
1157: ito.pm_sync = LLDPMSync /* 0 */;
1158: ito.sniff_time = ito.timeout ? LLDSniffTime /* 0 */ : 0;
1159:
1160: if (rln_msg_txrx(sc, &ito, sizeof ito,
1161: &response, sizeof response))
1162: return (-1);
1163: }
1164:
1165: /* Put the card into standby mode. */
1166: int
1167: rln_standby(sc)
1168: struct rln_softc * sc;
1169: {
1170: struct rln_mm_standby standby = { RLN_MM_STANDBY };
1171:
1172: standby.xxx = 0;
1173: if (rln_msg_txrx(sc, &ito, sizeof ito, NULL, 0))
1174: return (-1);
1175: }
1176:
1177: void
1178: rln_crypt(userkey, cardkey)
1179: char *userkey; /* User's string (max 20 chars). */
1180: 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: */
1196: int32_t key;
1197: int8_t ret;
1198: int i;
1199: int len;
1200: int32_t multiplicand = 0x80000181;
1201: int64_t res;
1202:
1203: /*
1204: * This algorithm is `compatible' with Proxim's first
1205: * `proprietary confidential algorithm': i.e., it appears
1206: * to be functionally identical.
1207: */
1208: len = strlen(s);
1209: key = 0x030201;
1210: for (i = 0; i < len; i++) {
1211:
1212: key *= userkey[i];
1213: res = (int64_t)multiplicand * key;
1214: key = key - 0xfffffd *
1215: (((key + (int32_t)(res >> 32)) >> 23) - (key >> 31));
1216: }
1217:
1218: cardkey[0] = (key >> 16) & 0xff;
1219: cardkey[1] = (key >> 8) & 0xff;
1220: cardkey[2] = key & 0xff;
1221:
1222: cardkey[0] |= 0x03; /* Restrict key space by 2 bits. */
1223: }
1224: #endif