![[BACK]](/icons/back.gif){kind=icon}
Return to rlnsubr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to rlnsubr.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: rlnsubr.c,v 1.5 2002/03/14 01:26:55 millert Exp $ */
2: /*
3: * David Leonard <d@openbsd.org>, 1999. Public Domain.
4: *
5: * Low level card protocol access to the Proxim RangeLAN2 wireless
6: * network adaptor.
7: *
8: * Information and ideas gleaned from
9: * - disassembly of Dave Koberstein's <davek@komacke.com> Linux driver
10: * (which is built with Proxim source),
11: * - Yoichi Shinoda's <shinoda@cs.washington.edu> BSDI driver, and
12: * - Geoff Voelker's <voelker@cs.washington.edu> Linux port of the same.
13: */
14:
15: #include <sys/param.h>
16: #include <sys/systm.h>
17: #include <sys/mbuf.h>
18: #include <sys/socket.h>
19: #include <sys/ioctl.h>
20: #include <sys/syslog.h>
21: #include <sys/device.h>
22: #include <sys/queue.h>
23: #include <sys/proc.h>
24: #include <sys/kernel.h>
25:
26: #include <net/if.h>
27:
28: #ifdef INET
29: #include <netinet/in.h>
30: #include <netinet/if_ether.h>
31: #endif
32:
33: #include <machine/bus.h>
34: #include <machine/intr.h>
35:
36: #include <dev/ic/rln.h>
37: #include <dev/ic/rlnvar.h>
38: #include <dev/ic/rlnreg.h>
39: #include <dev/ic/rlncmd.h>
40:
41: static int rln_tx_request(struct rln_softc *, u_int16_t);
42: static int rln_tx_end(struct rln_softc *);
43:
44: /*
45: * Disables or enables interrupts from the card. Returns the old
46: * interrupt-enable state.
47: */
48: int
49: rln_enable(sc, enable)
50: struct rln_softc * sc;
51: int enable;
52: {
53: int s;
54: int was_enabled;
55:
56: s = splhigh();
57: was_enabled = (sc->sc_intsel & RLN_INTSEL_ENABLE) ? 1 : 0;
58: if (enable != was_enabled) {
59: if (enable)
60: sc->sc_intsel |= RLN_INTSEL_ENABLE;
61: else
62: sc->sc_intsel &=~RLN_INTSEL_ENABLE;
63: _rln_register_write_1(sc, RLN_REG_INTSEL, sc->sc_intsel);
64: }
65: splx(s);
66: return (was_enabled);
67: }
68:
69: /*
70: * Perform a hard reset of the card. Determines bus width (8 or
71: * 16 bit), if sc->sc_width is unset. Returns 0 on success.
72: * Note: takes about 200ms at splhigh, meaning this is an expensive call,
73: * but normal (error-free) operation of the card will not need more than
74: * two resets - one at probe time, and the other when the interface is
75: * brought up.
76: */
77: int
78: rln_reset(sc)
79: struct rln_softc * sc;
80: {
81: int s;
82: int i;
83: int status;
84: u_int8_t op = 0x00;
85:
86: s = splhigh();
87: dprintf(" R[");
88: if (sc->sc_cardtype & (RLN_CTYPE_UISA | RLN_CTYPE_ONE_PIECE))
89: op = 0x04;
90: if (rln_status_read(sc) & RLN_STATUS_WAKEUP) {
91: rln_control_write(sc, op);
92: rln_control_write(sc, op | RLN_CONTROL_RESET);
93: dprintf(" 7ms");
94: DELAY(7000);
95: rln_control_write(sc, op);
96: dprintf(" 7ms");
97: DELAY(7000);
98: }
99: rln_control_write(sc, op);
100: rln_control_write(sc, op);
101: rln_control_write(sc, op | RLN_CONTROL_BIT3);
102: dprintf(" 67ms");
103: DELAY(67000);
104: rln_status_write(sc, 0x00);
105: if (sc->sc_cardtype & (RLN_CTYPE_UISA | RLN_CTYPE_ONE_PIECE))
106: rln_control_write(sc, 0x38);
107: /* RLN_CONTROL_BIT3 | RLN_CONTROL_RESET | RLN_CONTROL_16BIT */
108: else
109: rln_control_write(sc, 0x2c);
110: /* RLN_CONTROL_BIT3 | RLN_CONTROL_BIT2 | RLN_CONTROL_16BIT */
111: dprintf(" 67ms");
112: DELAY(67000);
113: rln_data_write_2(sc, 0xaa55);
114: rln_status_write(sc, 0x5a);
115: splx(s);
116: for (i = 0; i < 200 * 10; i++) { /* Proxim says 200. */
117: if ((status = rln_status_read(sc)) == 0x5a)
118: break;
119: DELAY(1000);
120: }
121: dprintf(" (%dms)", i);
122: s = splhigh();
123: if (status != 0x5a) {
124: splx(s);
125: /* Only winge if bus width not yet probed */
126: if (sc->sc_width != 0)
127: printf("%s: reset timeout\n", sc->sc_dev.dv_xname);
128: dprintf("]=-1");
129: return (-1);
130: }
131: if (sc->sc_width == 8) {
132: if (sc->sc_cardtype & (RLN_CTYPE_UISA | RLN_CTYPE_ONE_PIECE))
133: rln_control_write(sc, RLN_CONTROL_BIT3);
134: else
135: rln_control_write(sc, RLN_CONTROL_BIT3 |
136: RLN_CONTROL_BIT2);
137: rln_data_write_1(sc, 0x20);
138: } else if (sc->sc_width == 16) {
139: rln_data_write_2(sc, 0x0000);
140: } else {
141: if (rln_data_read_2(sc) == 0x55aa) {
142: rln_data_write_2(sc, 0x0000);
143: sc->sc_width = 16;
144: } else {
145: if (sc->sc_cardtype & (RLN_CTYPE_UISA |
146: RLN_CTYPE_ONE_PIECE))
147: rln_control_write(sc, RLN_CONTROL_BIT3);
148: else
149: rln_control_write(sc, RLN_CONTROL_BIT3 |
150: RLN_CONTROL_BIT2);
151: rln_data_write_1(sc, 0x20);
152: sc->sc_width = 8;
153: }
154: /* printf("%s: %d bit bus\n", sc->sc_dev.dv_xname,
155: sc->sc_width); */
156: }
157: rln_status_write(sc, 0x00);
158: sc->sc_intsel = 0;
159: rln_intsel_write(sc, sc->sc_irq);
160: splx(s);
161: dprintf("]");
162: return (0);
163: }
164:
165: /*
166: * Sets the new 'wakeup' state. Returns the old wakeup state.
167: * The special state value RLN_WAKEUP_SET should be used to wake the
168: * card up. The card can be partially put to sleep (presumably to save
169: * power) by sending it the 'Standby' command.
170: */
171: u_int8_t
172: rln_wakeup(sc, wnew)
173: struct rln_softc * sc;
174: u_int8_t wnew;
175: {
176: u_int8_t wold, s;
177: int i;
178:
179: /* Save what the last-written values were. */
180: wold = (sc->sc_status & RLN_STATUS_WAKEUP) |
181: (sc->sc_control & RLN_CONTROL_RESET);
182:
183: if (wnew == RLN_WAKEUP_SET) {
184: /* SetWakeupBit() */
185: dprintf(" Ws[");
186: rln_status_set(sc, RLN_STATUS_WAKEUP);
187: if (0/*LLDInactivityTimeOut &&
188: (sc->sc_cardtype & RLN_CTYPE_OEM)*/) {
189: dprintf (" 167ms");
190: DELAY(167000);
191: } else {
192: dprintf (" .1ms");
193: DELAY(100);
194: }
195: s = rln_status_read(sc);
196: rln_control_set(sc, RLN_CONTROL_RESET);
197: if ((s & RLN_STATUS_WAKEUP) != 0)
198: for (i = 0; i < 9; i++) {
199: dprintf(" 2ms");
200: DELAY(2000);
201: rln_status_set(sc, RLN_STATUS_WAKEUP);
202: }
203: dprintf("]");
204: } else {
205: /* ClearWakeupBit() */
206: dprintf(" Wc[");
207: if ((wnew & RLN_STATUS_WAKEUP) == 0)
208: rln_status_clear(sc, RLN_STATUS_WAKEUP);
209: if ((wnew & RLN_CONTROL_RESET) == 0)
210: rln_control_clear(sc, RLN_CONTROL_RESET);
211: dprintf("]");
212: }
213: return (wold);
214: }
215:
216: /*
217: * Performs the first (request) stage of transmitting a command message
218: * to the card. 'len' is the expected length of the message is needed.
219: * Returns: 0 on success
220: * 1 on timeout
221: * 2 on NAK (card busy, and will need a rln_clear_nak() after 100ms)
222: */
223: static int
224: rln_tx_request(sc, len)
225: struct rln_softc * sc;
226: u_int16_t len;
227: {
228: /* TxRequest() */
229: int s;
230: int i;
231: u_int8_t status;
232:
233: /* u_int8_t w; */
234: /* w = rln_wakeup(sc, RLN_WAKEUP_SET); */
235:
236: dprintf(" Tr[");
237: if (sc->sc_width == 16) {
238: rln_status_tx_write(sc, RLN_STATUS_TX_HILEN_AVAIL);
239: rln_data_write_2(sc, len);
240: rln_status_tx_int(sc);
241:
242: s = spl0();
243: for (i = 0; i < 600; i++) {
244: status = rln_status_tx_read(sc);
245: if (status == RLN_STATUS_TX_HILEN_ACCEPT ||
246: status == RLN_STATUS_TX_ERROR)
247: break;
248: DELAY(1000);
249: }
250: splx(s);
251: dprintf(" %dms", i);
252: if (status == RLN_STATUS_TX_HILEN_ACCEPT)
253: goto success;
254: if (status == RLN_STATUS_TX_ERROR)
255: goto error;
256: } else if (sc->sc_width == 8) {
257: rln_status_tx_write(sc, RLN_STATUS_TX_LOLEN_AVAIL);
258: rln_data_write_1(sc, len & 0xff);
259: rln_status_tx_int(sc);
260: s = spl0();
261: for (i = 0; i < 6800; i++) {
262: status = rln_status_tx_read(sc);
263: if (status == RLN_STATUS_TX_LOLEN_ACCEPT)
264: break;
265: DELAY(1000);
266: }
267: splx(s);
268: dprintf(" %dms", i);
269: if (status == RLN_STATUS_TX_LOLEN_ACCEPT) {
270: rln_data_write_1(sc, (len >> 8) & 0xff);
271: rln_status_tx_write(sc, RLN_STATUS_TX_HILEN_AVAIL);
272: s = spl0();
273: for (i = 0; i < 600; i++) {
274: status = rln_status_tx_read(sc);
275: if (status == RLN_STATUS_TX_HILEN_ACCEPT ||
276: status == RLN_STATUS_TX_ERROR)
277: break;
278: DELAY(1000);
279: }
280: splx(s);
281: dprintf(" %dms", i);
282: if (status == RLN_STATUS_TX_HILEN_ACCEPT)
283: goto success;
284: if (status == RLN_STATUS_TX_ERROR)
285: goto error;
286: }
287: }
288: #ifdef DIAGNOSTIC
289: else
290: panic("rln: bus width");
291: #endif
292:
293: printf("%s: tx_request timed out, status 0x%02x",
294: sc->sc_dev.dv_xname, status);
295: dprintf("]=(1)");
296: return (1);
297:
298: error:
299: /* Will need to clear nak within 100 ms. */
300: dprintf("]=2");
301: #ifdef DIAGNOSTIC
302: printf("%s: tx protocol fault (nak)\n", sc->sc_dev.dv_xname);
303: #endif
304: return (2);
305:
306: success:
307: /* rln_wakeup(sc, w); */
308: dprintf("]=0");
309: return (0);
310: }
311:
312: /*
313: * Performs the third (and final) stage of transmitting a command
314: * message to the card.
315: * Returns: 0 on command success.
316: * non-zero on failure (card will need reset)
317: */
318: static int
319: rln_tx_end(sc)
320: struct rln_softc * sc;
321: {
322: /* EndOfTx() */
323: int i;
324: int s;
325: u_int8_t status;
326:
327: dprintf(" Te[");
328: s = spl0();
329: for (i = 0; i < 600; i++) {
330: status = rln_status_tx_read(sc);
331: if (status == RLN_STATUS_TX_XFR_COMPLETE)
332: break;
333: DELAY(1000);
334: }
335: splx(s);
336: if (status == RLN_STATUS_TX_XFR_COMPLETE) {
337: rln_status_tx_write(sc, RLN_STATUS_TX_IDLE);
338: dprintf("]=0");
339: return (0);
340: } else {
341: printf("%s: tx cmd failed (%02x)\n", sc->sc_dev.dv_xname,
342: status);
343: rln_need_reset(sc);
344: dprintf("]=-1");
345: return (-1);
346: }
347: }
348:
349: /*
350: * Performs first (request) stage of receiving a message from the card.
351: * Returns: 0 on failure,
352: * n>0 on success, where 'n' is the length of the message
353: */
354:
355: int
356: rln_rx_request(sc, timeo)
357: struct rln_softc * sc;
358: int timeo; /* milliseconds */
359: {
360: /* RxRequest */
361: int s;
362: int len = 0;
363: int i;
364: u_int8_t status;
365: u_int8_t hi, lo;
366:
367: dprintf(" Rr[");
368: status = rln_status_rx_read(sc);
369:
370: /* Short wait for states 1|5|6. */
371: s = spl0();
372: for (i = 0; i < timeo; i++) {
373: if (status == RLN_STATUS_RX_LOLEN_AVAIL ||
374: status == RLN_STATUS_RX_HILEN_AVAIL ||
375: status == RLN_STATUS_RX_ERROR)
376: break;
377: DELAY(1000);
378: status = rln_status_rx_read(sc);
379: }
380: splx(s);
381: dprintf(" (%dms)",i);
382:
383: if (sc->sc_width == 16) {
384: if (status != RLN_STATUS_RX_HILEN_AVAIL)
385: goto badstatus_quiet;
386: /* Read 2 octets. */
387: len = rln_data_read_2(sc);
388: } else if (sc->sc_width == 8) {
389: if (status != RLN_STATUS_RX_LOLEN_AVAIL)
390: goto badstatus_quiet;
391: /* Read low octet. */
392: lo = rln_data_read_1(sc);
393: rln_status_rx_write(sc, RLN_STATUS_RX_LOLEN_ACCEPT);
394: rln_status_rx_int(sc);
395: s = spl0();
396: for (i = 0; i < 600; i++) {
397: status = rln_status_rx_read(sc);
398: if (status == RLN_STATUS_RX_HILEN_AVAIL)
399: break;
400: DELAY(1000);
401: }
402: splx(s);
403: if (status != RLN_STATUS_RX_HILEN_AVAIL)
404: goto badstatus;
405: /* Read high octet. */
406: hi = rln_data_read_1(sc);
407: len = lo | (hi << 8);
408: }
409: #ifdef DIAGNOSTIC
410: else
411: panic("rln: bus width %d", sc->sc_width);
412: #endif
413:
414: dprintf(" len=%d]", len);
415: return (len);
416:
417: badstatus:
418: printf("%s: rx_request timed out, status %02x\n",
419: sc->sc_dev.dv_xname, status);
420: badstatus_quiet:
421: if (status == RLN_STATUS_RX_ERROR)
422: printf("%s: rx protocol error (nak)\n", sc->sc_dev.dv_xname);
423: dprintf("]");
424: return (-1);
425: }
426:
427: /* Performs part of the second (transfer) stage of receiving a data message. */
428: void
429: rln_rx_pdata(sc, buf, len, pd)
430: struct rln_softc * sc;
431: void * buf;
432: int len;
433: struct rln_pdata * pd;
434: {
435: char * data = (char *)buf;
436:
437: if (pd->p_nremain) {
438: *data++ = pd->p_data;
439: if (--len == 0)
440: return;
441: }
442:
443: pd->p_nremain = 0;
444:
445: if (sc->sc_width == 16) {
446: /* Round down to the closest even multiple. */
447: rln_data_read_multi_2(sc, data, len / 2);
448: #ifdef RLNDEBUG_REG
449: dprintf(" D>");
450: dprinthex(data, len);
451: #endif
452: if (len & 1) {
453: /* Read the last octet plus a bit extra. */
454: union {
455: u_int16_t w;
456: u_int8_t b[2];
457: } u;
458:
459: u.w = rln_data_read_2(sc);
460: data[len - 1] = u.b[0];
461: pd->p_data = u.b[1];
462: pd->p_nremain = 1;
463: #ifdef RLNDEBUG_REG
464: dprintf(" D>{%02x%02x}", u.b[0], u.b[1]);
465: #endif
466: }
467: } else if (sc->sc_width == 8) {
468: rln_data_read_multi_1(sc, data, len);
469: #ifdef RLNDEBUG_REG
470: dprintf(" D>");
471: dprinthex(data, len);
472: #endif
473: if (len & 1) {
474: /* Must read multiples of two. */
475: pd->p_data = rln_data_read_1(sc);
476: pd->p_nremain = 1;
477: #ifdef RLNDEBUG_REG
478: dprintf(" D>{%02x}", pd->p_data);
479: #endif
480: }
481: }
482:
483: }
484:
485: int
486: rln_rx_data(sc, buf, len)
487: struct rln_softc * sc;
488: void * buf;
489: int len;
490: {
491: /* RxData() */
492: struct rln_pdata pd = { 0, 0 };
493: int s;
494: int i;
495: u_int8_t status;
496:
497: dprintf(" Rd[");
498: rln_status_rx_write(sc, RLN_STATUS_RX_HILEN_ACCEPT);
499: rln_status_rx_int(sc);
500: s = spl0();
501: for (i = 0; i < 600; i++) {
502: status = rln_status_rx_read(sc);
503: if (status == RLN_STATUS_RX_XFR)
504: break;
505: DELAY(1000);
506: }
507: splx(s);
508: if (status != RLN_STATUS_RX_XFR) {
509: dprintf("]=-1");
510: return (-1);
511: }
512:
513: rln_rx_pdata(sc, buf, len, &pd);
514: #ifdef DIAGNOSTIC
515: /* We should have nothing left over. */
516: if (pd.p_nremain || len & 1)
517: panic("rln_rx_data: leftover");
518: #endif
519:
520: dprintf("]=0");
521: return (0);
522: }
523:
524: void
525: rln_rx_end(sc)
526: struct rln_softc * sc;
527: {
528: /* EndOfRx() */
529:
530: dprintf(" Re[");
531: rln_status_rx_write(sc, RLN_STATUS_RX_XFR_COMPLETE);
532: rln_status_rx_int(sc);
533: /* rln_wakeup(sc, 0); */
534: dprintf("]");
535: }
536:
537: /* Clear a transmission NAK from the card. */
538: void
539: rln_clear_nak(sc)
540: struct rln_softc * sc;
541: {
542: /* ClearNAK() */
543:
544: rln_status_tx_write(sc, RLN_STATUS_CLRNAK);
545: rln_status_tx_int(sc);
546: }
547:
548: /*
549: * Send a command message to the card. Returns;
550: * 2: NAK
551: * -1: failure
552: * 0: success
553: */
554: int
555: rln_msg_tx_start(sc, buf, pktlen, state)
556: struct rln_softc * sc;
557: void * buf;
558: int pktlen;
559: struct rln_msg_tx_state * state;
560: {
561: struct rln_mm_cmd * cmd = (struct rln_mm_cmd *)buf;
562: int ret;
563:
564: state->ien = rln_enable(sc, 0);
565: state->pd.p_nremain = 0;
566:
567: if (!(cmd->cmd_letter == 'A' && cmd->cmd_fn == 6)) /* Standby. */
568: state->w = rln_wakeup(sc, RLN_WAKEUP_SET);
569: else
570: state->w = RLN_WAKEUP_NOCHANGE;
571:
572: ret = rln_tx_request(sc, pktlen);
573: if (ret == 2) {
574: rln_clear_nak(sc);
575: if (sc->sc_cardtype & RLN_CTYPE_OEM)
576: rln_need_reset(sc);
577: ret = 2;
578: }
579: else if (ret == 1) {
580: /* Timeout. */
581: rln_status_tx_write(sc, RLN_STATUS_TX_XFR);
582: ret = -1;
583: }
584: return (ret);
585: }
586:
587: void
588: rln_msg_tx_data(sc, buf, len, state)
589: struct rln_softc * sc;
590: void * buf;
591: u_int16_t len;
592: struct rln_msg_tx_state * state;
593: {
594: char * data = (char *)buf;
595:
596: if (sc->sc_width == 16 && state->pd.p_nremain) {
597: /* XXX htons() needed? */
598: union {
599: u_int8_t b[2];
600: u_int16_t w;
601: } u;
602:
603: u.b[0] = state->pd.p_data;
604: if (len) {
605: u.b[1] = *data++;
606: len--;
607: } else
608: u.b[1] = '\0';
609: #ifdef RLNDEBUG_REG
610: dprintf(" D<%02x%02x", u.b[0], u.b[1]);
611: #endif
612: rln_data_write_2(sc, u.w);
613: state->pd.p_nremain = 0;
614: }
615:
616: if (len) {
617: if (sc->sc_width == 16) {
618: if (len >= 2)
619: rln_data_write_multi_2(sc, buf, len / 2);
620: if (len & 1) {
621: state->pd.p_nremain = 1;
622: state->pd.p_data = data[len - 1];
623: }
624: } else if (sc->sc_width == 8)
625: rln_data_write_multi_1(sc, buf, len);
626: #ifdef DIAGNOSTIC
627: else
628: panic("rln_msg_tx_data width %d", sc->sc_width);
629: #endif
630: #ifdef RLNDEBUG_REG
631: dprintf(" D<");
632: dprinthex(data, len);
633: #endif
634: }
635: }
636:
637:
638: int
639: rln_msg_tx_end(sc, state)
640: struct rln_softc * sc;
641: struct rln_msg_tx_state * state;
642: {
643: int ret;
644:
645: /* Flush the tx buffer. */
646: if (state->pd.p_nremain)
647: rln_msg_tx_data(sc, NULL, 0, state);
648:
649: #ifdef DIAGNOSTIC
650: if (state->pd.p_nremain)
651: panic("rln_msg_tx_end remain %d", state->pd.p_nremain);
652: #endif
653: ret = rln_tx_end(sc);
654: if (sc->sc_arpcom.ac_if.if_flags & IFF_OACTIVE)
655: state->w = RLN_WAKEUP_NOCHANGE;
656: rln_wakeup(sc, state->w);
657: rln_enable(sc, state->ien);
658: return (ret);
659: }
660:
661: /* Return the next unique sequence number to use for a transmitted command */
662: u_int8_t
663: rln_newseq(sc)
664: struct rln_softc * sc;
665: {
666: int s;
667: u_int8_t seq;
668:
669: s = splhigh();
670: seq = sc->sc_pktseq++;
671: if (sc->sc_pktseq > RLN_MAXSEQ)
672: sc->sc_pktseq = 0;
673: splx(s);
674: return (seq);
675: }
676:
677: /*
678: * Transmit a command message to, and (optionally) receive a response
679: * message from the card. Each transmitted message has a sequence
680: * number, and corresponding reply messages have the same sequence
681: * number. We use the sequence numbers to index the mailboxes so
682: * that rlnsoftintr() can signal this routine when it has serviced
683: * and correctly received a response.
684: */
685:
686: int
687: rln_msg_txrx(sc, tx, txlen, rx, rxlen)
688: struct rln_softc * sc;
689: void * tx;
690: int txlen;
691: void * rx;
692: int rxlen;
693: {
694: struct rln_mm_cmd * txc = (struct rln_mm_cmd *)tx;
695: struct rln_mm_cmd * rxc = (struct rln_mm_cmd *)rx;
696: struct rln_msg_tx_state state;
697: int ien;
698: int ret;
699:
700: #ifdef DIAGNOSTIC
701: if (rx != NULL && rxlen < sizeof *rxc)
702: panic("rln_msg_txrx");
703: #endif
704:
705: txc->cmd_seq = rln_newseq(sc);
706:
707: #ifdef RLNDUMP
708: printf("%s: send %c%d seq %d data ", sc->sc_dev.dv_xname,
709: txc->cmd_letter, txc->cmd_fn, txc->cmd_seq);
710: RLNDUMPHEX(txc, sizeof *txc);
711: printf(":");
712: RLNDUMPHEX((char *)tx + sizeof *txc, txlen - sizeof *txc);
713: printf("\n");
714: #endif
715:
716: if (rx != NULL)
717: if (rln_mbox_create(sc, txc->cmd_seq, rx, rxlen) < 0)
718: /* Mailbox collision. */
719: return (-1);
720:
721: /* Start the transfer. */
722: if ((ret = rln_msg_tx_start(sc, tx, txlen, &state))) {
723: if (rx != NULL)
724: rln_mbox_wait(sc, txc->cmd_seq, -1);
725: return (ret);
726: }
727:
728: /* Always send an even number of octets. */
729: rln_msg_tx_data(sc, tx, (txlen + 1) & ~1, &state);
730:
731: /* End the transmission. */
732: if ((ret = rln_msg_tx_end(sc, &state))) {
733: /* Destroy mailbox. */
734: if (rx != NULL)
735: rln_mbox_wait(sc, txc->cmd_seq, -1);
736: return (ret);
737: }
738:
739: /* Don't wait for reply if there is nowhere to put it. */
740: if (rx == NULL)
741: return (0);
742:
743: /* Enable interrupts if not already. */
744: ien = rln_enable(sc, 1);
745:
746: /* Wait for the reply message. */
747: if (rln_mbox_wait(sc, txc->cmd_seq, 4000) <= 0) {
748: printf("%s: lost message %c%d seq %d\n", sc->sc_dev.dv_xname,
749: txc->cmd_letter, txc->cmd_fn, txc->cmd_seq);
750: rln_enable(sc, ien);
751: return (-1);
752: }
753: rln_enable(sc, ien);
754:
755: #ifdef RLNDUMP
756: printf("%s: recv %c%d seq %d data ", sc->sc_dev.dv_xname,
757: rxc->cmd_letter, rxc->cmd_fn, rxc->cmd_seq);
758: RLNDUMPHEX(rxc, sizeof *rxc);
759: printf(":");
760: RLNDUMPHEX(((char *)rx) + sizeof *rxc, rxlen - sizeof *rxc);
761: printf("\n");
762: #endif
763:
764: /* Check for errors in the received message. */
765: if (rxc->cmd_error & 0x80) {
766: printf("%s: command error 0x%02x command %c%d\n",
767: sc->sc_dev.dv_xname,
768: rxc->cmd_error & ~0x80,
769: rxc->cmd_letter, rxc->cmd_fn);
770: return (-1);
771: }
772:
773: return (0);
774: }
775:
776: /*
777: * Mailboxes provide a simple way to tell the interrupt
778: * service routine that someone is expecting a reply message.
779: * Mailboxes are identified by the message sequence number
780: * and also hold a pointer to storage supplied by the waiter.
781: * The interrupt service routine signals the mailbox when it
782: * gets the reply message.
783: */
784:
785: /* Create a mailbox for filling. */
786: int
787: rln_mbox_create(sc, seq, buf, len)
788: struct rln_softc * sc;
789: u_int8_t seq;
790: void * buf;
791: size_t len;
792: {
793: int s;
794: struct rln_mbox * mb = &sc->sc_mbox[seq];
795:
796: dprintf(" <create %d", seq);
797:
798: #ifdef DIAGNOSTIC
799: if (seq > RLN_NMBOX)
800: panic("mbox create");
801: #endif
802:
803: s = splhigh();
804: if (mb->mb_state != RLNMBOX_VOID) {
805: #ifdef DIAGNOSTIC
806: printf("mbox collision");
807: #endif
808: splx(s);
809: return (-1);
810: }
811: mb->mb_buf = buf;
812: mb->mb_len = len;
813: mb->mb_actlen = 0;
814: mb->mb_state = RLNMBOX_EMPTY;
815: dprintf(" empty>");
816: splx(s);
817: return (0);
818: }
819:
820:
821: /* Wait for a mailbox to be filled. */
822: int
823: rln_mbox_wait(sc, seq, timeo)
824: struct rln_softc * sc;
825: u_int8_t seq;
826: int timeo;
827: {
828: int i;
829: int s;
830: int ret;
831: volatile struct rln_mbox * mb = &sc->sc_mbox[seq];
832:
833: dprintf(" <wait %d", seq);
834:
835: #ifdef DIAGNOSTIC
836: if (seq > RLN_NMBOX)
837: panic("mbox wait");
838: #endif
839:
840: #if defined(RLN_TSLEEP)
841: if (!cold) {
842: tsleep((void *)mb, PRIBIO, "rlnmbox", hz * timeo / 1000);
843: if (mb->mb_state == RLNMBOX_FILLING) {
844: /* Must wait until filled. */
845: s = spl0();
846: while (mb->mb_state == RLNMBOX_FILLING)
847: ;
848: splx(s);
849: }
850: } else {
851: /* Autoconfiguration - spin at spl0. */
852: #endif
853: s = spl0();
854: i = 0;
855: while (mb->mb_state == RLNMBOX_EMPTY && i < timeo) {
856: DELAY(1000);
857: i++;
858: }
859: if (i)
860: dprintf(" %dms", i);
861: while (mb->mb_state == RLNMBOX_FILLING)
862: ;
863: splx(s);
864: #if defined(RLN_TSLEEP)
865: }
866: #endif
867:
868: s = splhigh();
869:
870: #ifdef DIAGNOSTIC
871: if (mb->mb_state != RLNMBOX_EMPTY && mb->mb_state != RLNMBOX_FILLED)
872: panic("mbox wait %d", mb->mb_state);
873: #endif
874: ret = mb->mb_actlen;
875: mb->mb_state = RLNMBOX_VOID;
876: dprintf(" void>=%d", ret);
877: splx(s);
878: return (ret);
879: }
880:
881: /* Lock a mailbox for filling. */
882: int
883: rln_mbox_lock(sc, seq, bufp, lenp)
884: struct rln_softc * sc;
885: u_int8_t seq;
886: void ** bufp;
887: size_t * lenp;
888: {
889: int s;
890: struct rln_mbox * mb = &sc->sc_mbox[seq];
891:
892: dprintf(" <lock %d", seq);
893:
894: s = splhigh();
895: #ifdef DIAGNOSTIC
896: if (seq > RLN_NMBOX)
897: panic("mbox lock");
898: #endif
899: if (mb->mb_state != RLNMBOX_EMPTY) {
900: splx(s);
901: dprintf(" ?>");
902: return (-1);
903: }
904:
905: mb->mb_state = RLNMBOX_FILLING;
906: dprintf(" filling>");
907: *bufp = mb->mb_buf;
908: *lenp = mb->mb_len;
909:
910: splx(s);
911: return (0);
912: }
913:
914: /* Unlock a mailbox and inform the waiter of the actual number of octets. */
915: void
916: rln_mbox_unlock(sc, seq, actlen)
917: struct rln_softc * sc;
918: u_int8_t seq;
919: size_t actlen;
920: {
921: int s;
922: struct rln_mbox * mb = &sc->sc_mbox[seq];
923:
924: dprintf(" <unlock %d", seq);
925:
926: s = splhigh();
927: #ifdef DIAGNOSTIC
928: if (seq > RLN_NMBOX)
929: panic("mbox unlock seq");
930: if (mb->mb_state != RLNMBOX_FILLING)
931: panic("mbox unlock");
932: #endif
933: mb->mb_state = RLNMBOX_FILLED;
934: dprintf(" filled>");
935: mb->mb_actlen = actlen;
936: #if defined(RLN_TSLEEP)
937: wakeup(mb);
938: #endif
939: splx(s);
940: }
941: