![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_hy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxif|
Return to if_hy.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxif |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Tektronix Inc.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)if_hy.c 7.6 (Berkeley) 6/28/90
24: */
25:
26: /*
27: * 4.2 BSD Unix Kernel - Vax Network Interface Support
28: *
29: * $Header: if_hy.c,v 10.1 84/07/22 21:02:56 steveg Exp $
30: * $Locker: $
31: *
32: * Modifications from Berkeley 4.2 BSD
33: * Copyright (c) 1983, Tektronix Inc.
34: * All Rights Reserved
35: *
36: * $Log: if_hy.c,v $
37: * Revision 10.1 84/07/22 21:02:56 steveg
38: * define PI13 (moved from if_hyreg.h, somehow got dropped in the process)
39: * rework hywatch to check for power fails first
40: *
41: * Revision 10.0 84/06/30 19:54:27 steveg
42: * Big Build
43: *
44: * Revision 3.17 84/06/20 19:20:28 steveg
45: * increment hy_ntime in hywatch
46: * print out state name, csr, last command, and hy_flags when watchdog timer
47: * expires
48: *
49: * Revision 3.16 84/06/20 19:09:34 steveg
50: * turn on continuous logging by default
51: *
52: * Revision 3.15 84/05/30 22:19:09 steveg
53: * changes to reflect new layout ot statistics data
54: *
55: * Revision 3.14 84/05/30 19:25:15 steveg
56: * move driver states to if_hy.h so log printing programs can use them
57: *
58: * Revision 3.13 84/05/30 17:13:26 steveg
59: * make it compile
60: *
61: * Revision 3.12 84/05/30 13:46:16 steveg
62: * rework logging
63: *
64: * Revision 3.11 84/05/18 19:35:02 steveg
65: * clear IFF_RUNNING and IFF_UP on unibus reset to force resource allocation
66: * by the init routine
67: *
68: * Revision 3.10 84/05/04 12:14:44 steveg
69: * more rework to make it actually work under 4.2
70: *
71: * Revision 3.9 84/05/01 23:34:52 steveg
72: * fix typo so it compiles (unit -> ui->ui_unit)
73: *
74: * Revision 3.8 84/05/01 23:18:30 steveg
75: * changes after talking with rickk
76: * - check power off more closely
77: * - support remote loopback through A710 adapters
78: * - IMPLINK -> HYLINK
79: * - return EHOSTUNREACH on hyroute failure
80: * - bump if_collisions on abnormal interrupts that aren't input or output
81: *
82: *
83: */
84:
85:
86: #include "hy.h"
87: #if NHY > 0
88:
89: /*
90: * Network Systems Copropration Hyperchanel interface
91: */
92: #include "machine/pte.h"
93:
94: #include "param.h"
95: #include "systm.h"
96: #include "mbuf.h"
97: #include "buf.h"
98: #include "protosw.h"
99: #include "socket.h"
100: #include "vmmac.h"
101: #include "errno.h"
102: #include "time.h"
103: #include "kernel.h"
104: #include "ioctl.h"
105:
106: #include "../net/if.h"
107: #include "../net/netisr.h"
108: #include "../net/route.h"
109:
110: #ifdef INET
111: #include "../netinet/in.h"
112: #include "../netinet/in_systm.h"
113: #include "../netinet/in_var.h"
114: #include "../netinet/ip.h"
115: #endif
116:
117: #include "../vax/cpu.h"
118: #include "../vax/mtpr.h"
119: #include "../vaxuba/ubareg.h"
120: #include "../vaxuba/ubavar.h"
121:
122: /*
123: * configuration specific paramters
124: * - change as appropriate for particular installaions
125: */
126: #define HYROUTE
127: #define HYELOG
128: #define HYLOG
129: #define HYMTU 1100
130: #define PI13
131:
132: #ifdef DEBUG
133: #define HYLOG
134: #endif
135:
136: #include "if_hy.h"
137: #include "if_hyreg.h"
138: #include "if_uba.h"
139:
140: int hyprobe(), hyattach(), hyinit(), hyioctl();
141: int hyoutput(), hyreset(), hywatch();
142: struct uba_device *hyinfo[NHY];
143: u_short hystd[] = { 0772410, 0 };
144: struct uba_driver hydriver =
145: { hyprobe, 0, hyattach, 0, hystd, "hy", hyinfo };
146:
147: /*
148: * Hyperchannel software status per interface.
149: *
150: * Each interface is referenced by a network interface structure,
151: * hy_if, which the routing code uses to locate the interface.
152: * This structure contains the output queue for the interface, its address, ...
153: * We also have, for each interface, a UBA interface structure, which
154: * contains information about the UNIBUS resources held by the interface:
155: * map registers, buffered data paths, etc. Information is cached in this
156: * structure for use by the if_uba.c routines in running the interface
157: * efficiently.
158: */
159: struct hy_softc {
160: struct ifnet hy_if; /* network-visible interface */
161: struct ifuba hy_ifuba; /* UNIBUS resources */
162: short hy_flags; /* flags */
163: short hy_state; /* driver state */
164: u_short hy_host; /* local host number */
165: struct in_addr hy_addr; /* internet address */
166: int hy_olen; /* packet length on output */
167: int hy_lastwcr; /* last command's word count */
168: short hy_savedstate; /* saved for reissue after status */
169: short hy_savedcmd; /* saved command for reissue */
170: int hy_savedcount; /* saved byte count for reissue */
171: int hy_savedaddr; /* saved unibus address for reissue */
172: int hy_ntime; /* number of timeouts since last cmd */
173: int hy_retry; /* retry counter */
174: struct hy_stat hy_stat; /* statistics */
175: struct hy_status hy_status; /* status */
176: } hy_softc[NHY];
177:
178: #ifdef HYELOG
179: u_long hy_elog[HYE_SIZE];
180: #endif
181:
182: #ifdef HYLOG
183: struct hy_log hy_log;
184: #endif
185:
186: #ifdef HYROUTE
187: struct hy_route hy_route[NHY];
188: #endif
189:
190: #ifdef DEBUG
191: #define printL printf
192: #define printD if (hy_debug_flag) printf
193: int hy_debug_flag = 0;
194: /*
195: * hy_nodebug bit 0x01 set hy_debug_flag on hycancel
196: * hy_nodebug bit 0x02 set hy_debug_flag on command reissue
197: * hy_nodebug bit 0x04 set hy_debug_flag on abnormal interrupt
198: */
199: int hy_nodebug = 0x0;
200: #endif
201:
202: #define SCANINTERVAL 10 /* seconds */
203: #define MAXINTERVAL 20 /* seconds (max action) */
204:
205: /*
206: * Cause a device interrupt. This code uses a buffer starting at
207: * location zero on the unibus (which is already mapped by the
208: * autoconfigure code in the kernel).
209: */
210: hyprobe(reg)
211: caddr_t reg;
212: {
213: register int br, cvec; /* r11, r10 value-result */
214: register struct hydevice *addr = (struct hydevice *) reg;
215:
216: #ifdef lint
217: br = 0; cvec = br; br = cvec;
218: hyint(0);
219: #endif
220: /*
221: * request adapter status to a buffer starting at unibus location 0
222: */
223: addr->hyd_bar = 0;
224: addr->hyd_wcr = -((sizeof(struct hy_status) + 1) >> 1);
225: addr->hyd_dbuf = HYF_STATUS;
226: #ifdef PI13
227: addr->hyd_csr |= S_GO | S_IE | S_IATTN;
228: #else
229: addr->hyd_csr |= S_GO | S_IE;
230: #endif
231: DELAY(10000);
232: #ifdef PI13
233: addr->hyd_csr |= S_CLRINT; /* clear any stacked interrupts */
234: #endif
235: addr->hyd_csr &= ~(S_IE | S_CLRINT); /* disable further interrupts */
236: return(sizeof(struct hydevice));
237: }
238:
239: /*
240: * Interface exists: make available by filling in network interface
241: * record. System will initialize the interface when it is ready
242: * to accept packets.
243: */
244: hyattach(ui)
245: struct uba_device *ui;
246: {
247: register struct hy_softc *is = &hy_softc[ui->ui_unit];
248: register struct ifnet *ifp = &is->hy_if;
249:
250: ifp->if_unit = ui->ui_unit;
251: ifp->if_name = "hy";
252: ifp->if_mtu = HYMTU;
253: is->hy_state = STARTUP; /* don't allow state transitions yet */
254: ifp->if_init = hyinit;
255: ifp->if_ioctl = hyioctl;
256: ifp->if_output = hyoutput;
257: ifp->if_reset = hyreset;
258: ifp->if_watchdog = hywatch;
259: ifp->if_timer = SCANINTERVAL;
260: is->hy_ifuba.ifu_flags = UBA_CANTWAIT;
261: #ifdef notdef
262: is->hy_ifuba.ifu_flags |= UBA_NEEDBDP;
263: #endif
264: if_attach(ifp);
265: }
266:
267: /*
268: * Reset of interface after UNIBUS reset.
269: * If interface is on specified uba, reset its state.
270: */
271: hyreset(unit, uban)
272: int unit, uban;
273: {
274: register struct uba_device *ui;
275: register struct hy_softc *is;
276:
277: if (unit >= NHY || (ui = hyinfo[unit]) == 0 || ui->ui_alive == 0 ||
278: ui->ui_ubanum != uban)
279: return;
280: printf(" hy%d", unit);
281: is = &hy_softc[unit]; /* force unibus resource allocation */
282: is->hy_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
283: hyinit(unit);
284: }
285:
286: /*
287: * Initialization of interface; clear recorded pending
288: * operations, and reinitialize UNIBUS usage.
289: */
290: hyinit(unit)
291: int unit;
292: {
293: register struct hy_softc *is = &hy_softc[unit];
294: register struct uba_device *ui = hyinfo[unit];
295: register struct mbuf *m;
296: int s;
297:
298: if (is->hy_if.if_addrlist == 0) /* address still unknown */
299: return;
300: if (is->hy_if.if_flags & IFF_RUNNING) /* just reset the device */
301: goto justreset;
302: if (if_ubainit(&is->hy_ifuba, ui->ui_ubanum,
303: sizeof (struct hym_hdr), (int)btoc(HYMTU)) == 0) {
304: #ifdef DEBUG
305: if (hy_nodebug & 4)
306: hy_debug_flag = 1;
307: #endif
308: printf("hy%d: can't initialize\n", unit);
309: is->hy_if.if_flags &= ~IFF_UP;
310: return;
311: }
312: is->hy_if.if_flags |= IFF_RUNNING;
313:
314: justreset:
315: /*
316: * remove any left over outgoing messages, reset the hardware and
317: * start the state machine
318: */
319: s = splimp();
320: #ifdef HYLOG
321: hylog(HYL_RESET, 0, (char *)0);
322: #endif
323: is->hy_state = IDLE;
324: is->hy_flags = RQ_STATUS | RQ_STATISTICS | RQ_MARKUP;
325: is->hy_retry = 0;
326: for(;;) {
327: IF_DEQUEUE(&is->hy_if.if_snd, m);
328: if (m != NULL)
329: m_freem(m);
330: else
331: break;
332: }
333: hycancel(ui); /* also bumps the state machine */
334: splx(s);
335: }
336:
337: /*
338: * Issue a command to the adapter
339: */
340: hystart(ui, cmd, count, ubaddr)
341: struct uba_device *ui;
342: int cmd, count, ubaddr;
343: {
344: register struct hy_softc *is = &hy_softc[ui->ui_unit];
345: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
346:
347: #ifdef DEBUG
348: printD("hy%d: hystart cmd = 0x%x count=%d ubaddr=0x%x\n",
349: ui->ui_unit, cmd, count, ubaddr);
350: printD("hy%d: - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
351: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
352: addr->hyd_wcr);
353: #endif
354: if (((is->hy_flags & RQ_REISSUE) == 0) &&
355: (cmd != HYF_STATUS) && (cmd != HYF_END_OP) && (cmd != HYF_RSTATS)) {
356: is->hy_savedstate = is->hy_state;
357: is->hy_savedcmd = cmd;
358: is->hy_savedcount = count;
359: is->hy_savedaddr = ubaddr;
360: }
361: #ifdef PI13
362: if (addr->hyd_csr & S_POWEROFF) {
363: printf("hy%d: \"Soft\" Adapter Power Failure (hystart)\n", ui->ui_unit);
364: addr->hyd_csr |= S_POWEROFF;
365: DELAY(100);
366: if (addr->hyd_csr & S_POWEROFF) {
367: printf( "hy%d: \"Hard\" Adapter Power Failure, Network Shutdown (hystart)\n", ui->ui_unit);
368: if_down(&is->hy_if);
369: is->hy_if.if_flags &= ~IFF_UP;
370: is->hy_state = STARTUP;
371: } else {
372: printf("hy%d: Adapter Power Restored (hystart)\n", ui->ui_unit);
373: }
374: return;
375: }
376: #endif
377: addr->hyd_bar = ubaddr & 0xffff;
378: addr->hyd_wcr = is->hy_lastwcr = -((count+1) >> 1);
379: addr->hyd_dbuf = cmd;
380: #ifdef PI13
381: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE | S_IATTN;
382: #else
383: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE;
384: #endif
385: #ifdef DEBUG
386: printD("hy%d: exit hystart - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
387: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
388: addr->hyd_wcr);
389: #endif
390: #ifdef HYLOG
391: {
392: struct {
393: u_char hcmd;
394: u_char hstate;
395: short hcount;
396: } hcl;
397:
398: hcl.hcmd = cmd;
399: hcl.hstate = is->hy_state;
400: hcl.hcount = count;
401: hylog(HYL_CMD, sizeof(hcl), (char *)&hcl);
402: }
403: #endif
404: is->hy_ntime = 0;
405: }
406:
407: int hyint_active = 0; /* set during hy interrupt */
408: /*
409: * Hyperchannel interface interrupt.
410: *
411: * An interrupt can occur for many reasons. Examine the status of
412: * the hyperchannel status bits to determine what to do next.
413: *
414: * If input error just drop packet.
415: * Otherwise purge input buffered data path and examine
416: * packet to determine type. Othewise decapsulate
417: * packet based on type and pass to type specific higher-level
418: * input routine.
419: */
420: hyint(unit)
421: int unit;
422: {
423: register struct hy_softc *is = &hy_softc[unit];
424: register struct uba_device *ui = hyinfo[unit];
425: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
426:
427: if (hyint_active)
428: panic("RECURSIVE HYPERCHANNEL INTERRUPT");
429: hyint_active++;
430: #ifdef DEBUG
431: printD("hy%d: hyint enter - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
432: unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, addr->hyd_wcr);
433: #endif
434: #ifdef HYLOG
435: logit:
436: {
437: struct {
438: u_char hstate;
439: u_char hflags;
440: short hcsr;
441: short hwcr;
442: } hil;
443: hil.hstate = is->hy_state;
444: hil.hflags = is->hy_flags;
445: hil.hcsr = addr->hyd_csr;
446: hil.hwcr = addr->hyd_wcr;
447: hylog(HYL_INT, sizeof(hil), (char *)&hil);
448: }
449: #endif
450: if (HYS_ERROR(addr) && ((addr->hyd_csr & S_ATTN) == 0)) {
451: /*
452: * Error bit set, some sort of error in the interface.
453: *
454: * The adapter sets attn on command completion so that's not
455: * a real error even though the interface considers it one.
456: */
457: #ifdef DEBUG
458: if (hy_nodebug & 4)
459: hy_debug_flag = 1;
460: #endif
461: printf("csr = 0x%b\nbar = 0x%x\nwcr = 0x%x\n",
462: addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
463: addr->hyd_wcr);
464: if (addr->hyd_csr & S_NEX) {
465: printf("hy%d: NEX - Non Existant Memory\n", unit);
466: #ifdef PI13
467: addr->hyd_csr |= S_NEX; /* as per PI13 manual */
468: #else
469: addr->hyd_csr &= ~S_NEX;
470: #endif
471: hycancel(ui);
472: #ifdef PI13
473: } else if (addr->hyd_csr & S_POWEROFF) {
474: printf("hy%d: \"Soft\" Adapter Power Failure (hyint)\n", unit);
475: addr->hyd_csr |= S_POWEROFF;
476: DELAY(100);
477: if (addr->hyd_csr & S_POWEROFF) {
478: printf( "hy%d: \"Hard\" Adapter Power Failure, Network Shutdown (hyint)\n", unit);
479: if_down(&is->hy_if);
480: is->hy_if.if_flags &= ~IFF_UP;
481: is->hy_state = STARTUP;
482: } else {
483: printf("hy%d: Adapter Power Restored (hyint)\n", unit);
484: }
485: #endif
486: } else {
487: printf("hy%d: BAR overflow\n", unit);
488: hycancel(ui);
489: }
490: } else if (HYS_NORMAL(addr)) {
491: /*
492: * Normal interrupt, bump state machine unless in state
493: * waiting and no data present (assumed to be word count
494: * zero interrupt or other hardware botch).
495: */
496: if (is->hy_state != WAITING || HYS_RECVDATA(addr))
497: hyact(ui);
498: } else if (HYS_ABNORMAL(addr)) {
499: /*
500: * Abnormal termination.
501: * bump error counts, retry the last function
502: * 'MAXRETRY' times before kicking the bucket.
503: *
504: * Don't reissue the cmd if in certain states, abnormal
505: * on a reissued cmd or max retry exceeded.
506: */
507: #ifdef HYLOG
508: if (hy_log.hyl_enable != hy_log.hyl_onerr) {
509: hy_log.hyl_enable = hy_log.hyl_onerr;
510: goto logit;
511: }
512: #endif
513: #ifdef DEBUG
514: if (hy_nodebug & 4)
515: hy_debug_flag = 1;
516: printD("hy%d: abnormal interrupt, driver state \"%s\" (%d)\n",
517: unit, hy_state_names[is->hy_state], is->hy_state);
518: printD("\tflags 0x%x olen %d lastwcr %d retry %d\n",
519: is->hy_flags, is->hy_olen, is->hy_lastwcr, is->hy_retry);
520: printD("\tsaved: state %d count %d cmd 0x%x ptr 0x%x\n",
521: is->hy_savedstate, is->hy_savedcount,
522: is->hy_savedaddr, is->hy_savedcmd);
523: #endif
524: #ifdef PI13
525: addr->hyd_csr &= ~S_C; /* clear the damned PI-13 */
526: #endif
527: if (is->hy_state == XMITSENT || is->hy_state == XMITDATASENT)
528: is->hy_if.if_oerrors++;
529: else if (is->hy_state == RECVSENT || is->hy_state == RECVDATASENT)
530: is->hy_if.if_ierrors++;
531: else
532: is->hy_if.if_collisions++; /* other errors */
533: if (is->hy_state == XMITDATASENT ||
534: is->hy_state == RECVSENT ||
535: is->hy_state == RECVDATASENT ||
536: (is->hy_flags & RQ_REISSUE) != 0 || is->hy_retry > MAXRETRY)
537: hycancel(ui);
538: else {
539: #ifdef DEBUG
540: if (hy_nodebug & 2)
541: hy_debug_flag = 1;
542: #endif
543: is->hy_retry++;
544: is->hy_flags |= RQ_ENDOP | RQ_STATUS | RQ_REISSUE;
545: is->hy_state = IDLE;
546: hyact(ui);
547: }
548: } else {
549: /*
550: * Interrupt is neither normal, abnormal, or interface error.
551: * Ignore it. It's either stacked or a word count 0.
552: */
553: #ifdef HYLOG
554: if (hy_log.hyl_enable != hy_log.hyl_onerr) {
555: hy_log.hyl_enable = hy_log.hyl_onerr;
556: goto logit;
557: }
558: #endif
559: #ifdef DEBUG
560: printD("hy%d: possible stacked interrupt ignored\n", unit);
561: #endif
562: }
563: #ifdef DEBUG
564: printD("hy%d: hyint exit\n\n", unit);
565: #endif
566: hyint_active = 0;
567:
568: }
569:
570: int hyoutprint = 0;
571:
572: /*
573: * Encapsulate a packet of type family for the local net.
574: */
575: hyoutput(ifp, m0, dst)
576: struct ifnet *ifp;
577: struct mbuf *m0;
578: struct sockaddr *dst;
579: {
580: register struct hym_hdr *hym;
581: register struct mbuf *m;
582: register char *mp;
583: int dlen; /* packet size, incl hardware header, but not sw header */
584: int error = 0;
585: int s;
586:
587: /*
588: * Calculate packet length for later deciding whether it will fit
589: * in a message proper or we also need associated data.
590: */
591: dlen = 0;
592: for (m = m0; m; m = m->m_next)
593: dlen += m->m_len;
594: m = m0;
595: if (dst->sa_family == AF_HYLINK) { /* don't add header */
596: dlen -= HYM_SWLEN;
597: goto headerexists;
598: }
599:
600: /*
601: * Add the software and hardware hyperchannel headers.
602: * If there's not enough space in the first mbuf, allocate another.
603: * If that should fail, drop this sucker.
604: * No extra space for headers is allocated.
605: */
606: mp = mtod(m, char *); /* save pointer to real message */
607: M_PREPEND(m, sizeof(struct hym_hdr), M_DONTWAIT);
608: if (m == 0) {
609: error = ENOBUFS;
610: goto bad;
611: }
612: dlen += sizeof(struct hym_hdr) - HYM_SWLEN;
613:
614: hym = mtod(m, struct hym_hdr *);
615:
616: bzero((caddr_t)hym, sizeof(struct hym_hdr));
617:
618: switch(dst->sa_family) {
619:
620: #ifdef INET
621: case AF_INET: {
622: int i;
623:
624: /*
625: * if loopback address, swizzle ip header so when
626: * it comes back it looks like it was addressed to us
627: */
628: i = hyroute(ifp, (u_long)in_lnaof(((struct sockaddr_in *)dst)->sin_addr), hym);
629: if (i < 0)
630: goto notfound;
631: if (i > 0) {
632: struct in_addr temp;
633:
634: temp.s_addr = ((struct ip *)mp)->ip_dst.s_addr;
635: ((struct ip *)mp)->ip_dst.s_addr = ((struct ip *)mp)->ip_src.s_addr;
636: ((struct ip *)mp)->ip_src.s_addr = temp.s_addr;
637: }
638: /*
639: * If entire packet won't fit in message proper, just
640: * send hyperchannel hardware header and ip header in
641: * message proper.
642: *
643: * This insures that the associated data is at least a
644: * TCP/UDP header in length and thus prevents potential
645: * problems with very short word counts.
646: */
647: if (dlen > MPSIZE)
648: hym->hym_mplen = sizeof(struct hy_hdr) + (((struct ip *)mp)->ip_hl << 2);
649: hym->hym_type = HYLINK_IP;
650: break;
651: }
652: #endif
653:
654: default:
655: printf("hy%d: can't handle af%d\n", ifp->if_unit,
656: dst->sa_family);
657: error = EAFNOSUPPORT;
658: goto drop;
659: }
660:
661:
662: headerexists:
663:
664: /*
665: * insure message proper is below the maximum
666: */
667: if (hym->hym_mplen > MPSIZE || (dlen > MPSIZE && hym->hym_mplen == 0))
668: hym->hym_mplen = MPSIZE;
669:
670: hym->hym_from = htons(hy_softc[ifp->if_unit].hy_host);
671: if (hym->hym_mplen)
672: hym->hym_ctl |= H_ASSOC;
673: else
674: hym->hym_ctl &= ~H_ASSOC;
675: if (hyoutprint) printf("hy%d: output mplen=%x ctl=%x access=%x to=%x from=%x param=%x type=%x\n",
676: ifp->if_unit, hym->hym_mplen, hym->hym_ctl,
677: hym->hym_access, hym->hym_to, hym->hym_from,
678: hym->hym_param, hym->hym_type);
679: #ifdef DEBUG
680: printD("hy%d: output mplen=%x ctl=%x access=%x to=%x from=%x param=%x type=%x\n",
681: ifp->if_unit, hym->hym_mplen, hym->hym_ctl,
682: hym->hym_access, hym->hym_to, hym->hym_from,
683: hym->hym_param, hym->hym_type);
684: #endif
685: s = splimp();
686: if (IF_QFULL(&ifp->if_snd)) {
687: IF_DROP(&ifp->if_snd);
688: error = ENOBUFS;
689: splx(s);
690: goto drop;
691: }
692: IF_ENQUEUE(&ifp->if_snd, m);
693: if (hy_softc[ifp->if_unit].hy_state == WAITING)
694: hyact(hyinfo[ifp->if_unit]);
695: splx(s);
696: return (0);
697: notfound:
698: error = EHOSTUNREACH;
699: drop:
700: m_freem(m);
701: return (error);
702: }
703:
704: int
705: hyroute(ifp, dest, hym)
706: register struct ifnet *ifp;
707: u_long dest;
708: register struct hym_hdr *hym;
709: {
710: #ifdef HYROUTE
711: register struct hy_route *rt = &hy_route[ifp->if_unit];
712: register struct hyr_hash *rhash;
713: register int i;
714: #endif
715:
716: hym->hym_param = 0;
717: #ifdef HYROUTE
718: if (rt->hyr_lasttime != 0) {
719: i = HYRHASH(dest);
720: rhash = &rt->hyr_hash[i];
721: i = 0;
722: while (rhash->hyr_key != dest) {
723: if (rhash->hyr_flags == 0 || i > HYRSIZE)
724: return(-1);
725: rhash++; i++;
726: if (rhash >= &rt->hyr_hash[HYRSIZE])
727: rhash = &rt->hyr_hash[0];
728: }
729: if (rhash->hyr_flags & HYR_GATE) {
730: i = rhash->hyr_nextgate;
731: if (i >= rhash->hyr_egate)
732: rhash->hyr_nextgate = rhash->hyr_pgate;
733: else
734: rhash->hyr_nextgate++;
735: rhash = &rt->hyr_hash[rt->hyr_gateway[i]];
736: if ((rhash->hyr_flags & HYR_DIR) == 0)
737: return(-1);
738: } else if (rhash->hyr_flags & HYR_LOOP) {
739: hym->hym_param = H_LOOPBK; /* adapter loopback */
740: } else if (rhash->hyr_flags & HYR_RLOOP) {
741: hym->hym_param = H_RLOOPBK; /* A710 remote loopback */
742: }
743: hym->hym_ctl = rhash->hyr_ctl;
744: hym->hym_access = rhash->hyr_access;
745: hym->hym_to = rhash->hyr_dst;
746: } else {
747: #endif
748: hym->hym_ctl = H_XTRUNKS | H_RTRUNKS;
749: hym->hym_access = 0;
750: hym->hym_to = htons((u_short)dest);
751: if (dest & 0x010000)
752: hym->hym_param = H_LOOPBK; /* adapter loopback */
753: else if (dest & 0x020000)
754: hym->hym_param = H_RLOOPBK; /* A710 remote loopback */
755: #ifdef HYROUTE
756: }
757: #endif
758:
759: if (hym->hym_param == 0)
760: return(0);
761: else
762: return(1);
763: }
764:
765: hyact(ui)
766: register struct uba_device *ui;
767: {
768: register struct hy_softc *is = &hy_softc[ui->ui_unit];
769: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
770:
771: actloop:
772: #ifdef DEBUG
773: printD("hy%d: hyact, enter state \"%s\"\n", ui->ui_unit,
774: hy_state_names[is->hy_state]);
775: #endif
776: switch (is->hy_state) {
777:
778: case STARTUP:
779: goto endintr;
780:
781: case IDLE: {
782: register rq = is->hy_flags;
783:
784: if (rq & RQ_STATUS) {
785: is->hy_flags &= ~RQ_STATUS;
786: is->hy_state = STATSENT;
787: hystart(ui, HYF_STATUS, sizeof (is->hy_status),
788: is->hy_ifuba.ifu_r.ifrw_info);
789: } else if (rq & RQ_ENDOP) {
790: is->hy_flags &= ~RQ_ENDOP;
791: is->hy_state = ENDOPSENT;
792: hystart(ui, HYF_END_OP, 0, 0);
793: } else if (rq & RQ_STATISTICS) {
794: is->hy_flags &= ~RQ_STATISTICS;
795: is->hy_state = RSTATSENT;
796: hystart(ui, HYF_RSTATS, sizeof (is->hy_stat),
797: is->hy_ifuba.ifu_r.ifrw_info);
798: } else if (HYS_RECVDATA(addr)) {
799: is->hy_state = RECVSENT;
800: is->hy_retry = 0;
801: hystart(ui, HYF_INPUTMSG, MPSIZE, is->hy_ifuba.ifu_r.ifrw_info + HYM_SWLEN);
802: } else if (rq & RQ_REISSUE) {
803: is->hy_flags &= ~RQ_REISSUE;
804: is->hy_state = is->hy_savedstate;
805: #ifdef DEBUG
806: printD("hy%d: reissue cmd=0x%x count=%d",
807: ui->ui_unit, is->hy_savedcmd, is->hy_savedcount);
808: printD(" ubaddr=0x%x retry=%d\n",
809: is->hy_savedaddr, is->hy_retry);
810: #endif
811: hystart(ui, is->hy_savedcmd, is->hy_savedcount,
812: is->hy_savedaddr);
813: } else {
814: register struct mbuf *m;
815:
816: IF_DEQUEUE(&is->hy_if.if_snd, m);
817: if (m != NULL) {
818: register struct hym_hdr *hym;
819: register int mplen;
820: register int cmd;
821:
822: is->hy_state = XMITSENT;
823: is->hy_retry = 0;
824: hym = mtod(m, struct hym_hdr *);
825: #ifdef HYLOG
826: hylog(HYL_XMIT, sizeof(struct hym_hdr),
827: (char *)hym);
828: #endif
829: mplen = hym->hym_mplen;
830: if (hym->hym_to_adapter == hym->hym_from_adapter)
831: cmd = HYF_XMITLOCMSG;
832: else
833: cmd = HYF_XMITMSG;
834: #ifdef DEBUG
835: printD("hy%d: hym_hdr = ", ui->ui_unit);
836: if (hy_debug_flag)
837: hyprintdata((char *)hym,
838: sizeof (struct hym_hdr));
839: #endif
840: is->hy_olen = if_wubaput(&is->hy_ifuba, m) - HYM_SWLEN;
841: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
842: UBAPURGE(is->hy_ifuba.ifu_uba,
843: is->hy_ifuba.ifu_w.ifrw_bdp);
844: #ifdef DEBUG
845: printD(
846: "hy%d: sending packet (mplen = %d, hy_olen = %d) data = ",
847: ui->ui_unit, mplen, is->hy_olen);
848: if (hy_debug_flag)
849: hyprintdata(
850: is->hy_ifuba.ifu_w.ifrw_addr,
851: is->hy_olen + HYM_SWLEN);
852: #endif
853: if (mplen == 0) {
854: is->hy_flags &= ~RQ_XASSOC;
855: mplen = is->hy_olen;
856: } else {
857: is->hy_flags |= RQ_XASSOC;
858: }
859: hystart(ui, cmd, mplen, is->hy_ifuba.ifu_w.ifrw_info + HYM_SWLEN);
860: } else if (rq & RQ_MARKDOWN) {
861: is->hy_flags &= ~(RQ_MARKUP | RQ_MARKDOWN);
862: is->hy_state = MARKPORT;
863: is->hy_retry = 0;
864: /*
865: * Port number is taken from status data
866: */
867: hystart(ui,
868: (int)(HYF_MARKP0|(PORTNUM(&is->hy_status)<<2)),
869: 0, 0);
870: } else if (rq & RQ_MARKUP) {
871: register struct ifnet *ifp = &is->hy_if;
872:
873: is->hy_flags &= ~RQ_MARKUP;
874: is->hy_retry = 0;
875: /*
876: * Fill in the host number
877: * from the status buffer
878: */
879: printf(
880: "hy%d: unit number 0x%x port %d type %x microcode level 0x%x\n",
881: ui->ui_unit,
882: is->hy_stat.hyc_uaddr,
883: PORTNUM(&is->hy_status),
884: (is->hy_stat.hyc_atype[0]<<8) |
885: is->hy_stat.hyc_atype[1],
886: is->hy_stat.hyc_atype[2]);
887:
888: is->hy_host =
889: (is->hy_stat.hyc_uaddr << 8) |
890: PORTNUM(&is->hy_status);
891: ifp->if_flags |= IFF_UP;
892: #ifdef HYLOG
893: hylog(HYL_UP, 0, (char *)0);
894: #endif
895: } else {
896: is->hy_state = WAITING;
897: is->hy_retry = 0;
898: hystart(ui, HYF_WAITFORMSG, 0, 0);
899: }
900: }
901: break;
902: }
903:
904: case STATSENT:
905: bcopy(is->hy_ifuba.ifu_r.ifrw_addr, (caddr_t)&is->hy_status,
906: sizeof (struct hy_status));
907: #ifdef DEBUG
908: printD("hy%d: status - %x %x %x %x %x %x %x %x\n",
909: ui->ui_unit, is->hy_status.hys_gen_status,
910: is->hy_status.hys_last_fcn,
911: is->hy_status.hys_resp_trunk,
912: is->hy_status.hys_status_trunk,
913: is->hy_status.hys_recd_resp,
914: is->hy_status.hys_error,
915: is->hy_status.hys_caddr,
916: is->hy_status.hys_pad);
917: #endif
918: is->hy_state = IDLE;
919: #ifdef HYLOG
920: hylog(HYL_STATUS, sizeof (struct hy_status),
921: (char *)&is->hy_status);
922: #endif
923: #ifdef HYELOG
924: {
925: register int i;
926:
927: i = is->hy_status.hys_error;
928: if (i > HYE_MAX)
929: i = HYE_MAX;
930: switch (is->hy_status.hys_last_fcn) {
931: case HYF_XMITLOCMSG:
932: i += HYE_MAX+1; /* fall through */
933: case HYF_XMITLSTDATA:
934: i += HYE_MAX+1; /* fall through */
935: case HYF_XMITMSG:
936: i += HYE_MAX+1;
937: }
938: hy_elog[i]++;
939: }
940: #endif
941: break;
942:
943: case RSTATSENT: {
944: register struct hy_stat *p =
945: (struct hy_stat *)is->hy_ifuba.ifu_r.ifrw_addr;
946:
947: bcopy((caddr_t)p, (caddr_t)&is->hy_stat, sizeof(struct hy_stat));
948: #ifdef DEBUG
949:
950: printD("hy%d: statistics - df0 %d df1 %d df2 %d df3 %d\n",
951: ui->ui_unit,
952: (is->hy_stat.hyc_df0[0]<<16) | (is->hy_stat.hyc_df0[1]<<8) | is->hy_stat.hyc_df0[2],
953: (is->hy_stat.hyc_df1[0]<<16) | (is->hy_stat.hyc_df1[1]<<8) | is->hy_stat.hyc_df1[2],
954: (is->hy_stat.hyc_df2[0]<<16) | (is->hy_stat.hyc_df2[1]<<8) | is->hy_stat.hyc_df2[2],
955: (is->hy_stat.hyc_df3[0]<<16) | (is->hy_stat.hyc_df3[1]<<8) | is->hy_stat.hyc_df3[2]);
956: printD(" ret0 %d ret1 %d ret2 %d ret3 %d\n",
957: (is->hy_stat.hyc_ret0[0]<<16) | (is->hy_stat.hyc_ret0[1]<<8) | is->hy_stat.hyc_ret0[2],
958: (is->hy_stat.hyc_ret1[0]<<16) | (is->hy_stat.hyc_ret1[1]<<8) | is->hy_stat.hyc_ret1[2],
959: (is->hy_stat.hyc_ret2[0]<<16) | (is->hy_stat.hyc_ret2[1]<<8) | is->hy_stat.hyc_ret2[2],
960: (is->hy_stat.hyc_ret3[0]<<16) | (is->hy_stat.hyc_ret3[1]<<8) | is->hy_stat.hyc_ret3[2]);
961: printD(" cancel %d abort %d atype %x %x %x uaddr %x\n",
962: (is->hy_stat.hyc_cancel[0]<<8) | is->hy_stat.hyc_cancel[1],
963: (is->hy_stat.hyc_abort[0]<<8) | is->hy_stat.hyc_abort[1],
964: is->hy_stat.hyc_atype[0], is->hy_stat.hyc_atype[1],
965: is->hy_stat.hyc_atype[2], is->hy_stat.hyc_uaddr);
966: #endif
967: is->hy_state = IDLE;
968: #ifdef HYLOG
969: hylog(HYL_STATISTICS, sizeof (struct hy_stat),
970: (char *)&is->hy_stat);
971: #endif
972: break;
973: }
974:
975: case CLEARSENT:
976: is->hy_state = IDLE;
977: break;
978:
979: case ENDOPSENT:
980: is->hy_state = IDLE;
981: break;
982:
983: case RECVSENT: {
984: register struct hym_hdr *hym;
985: register unsigned len;
986:
987: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
988: UBAPURGE(is->hy_ifuba.ifu_uba,
989: is->hy_ifuba.ifu_r.ifrw_bdp);
990: hym = (struct hym_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr);
991: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
992: if (len > MPSIZE) {
993: printf("hy%d: RECVD MP > MPSIZE (%d)\n",
994: ui->ui_unit, len);
995: is->hy_state = IDLE;
996: #ifdef DEBUG
997: hy_debug_flag = 1;
998: printD("hy%d: csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
999: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS,
1000: addr->hyd_bar, addr->hyd_wcr);
1001: #endif
1002: }
1003: hym->hym_mplen = len;
1004: #ifdef DEBUG
1005: printD("hy%d: recvd mp, len = %d, data = ", ui->ui_unit, len);
1006: if (hy_debug_flag)
1007: hyprintdata((char *)hym, len + HYM_SWLEN);
1008: #endif
1009: if (hym->hym_ctl & H_ASSOC) {
1010: is->hy_state = RECVDATASENT;
1011: is->hy_retry = 0;
1012: hystart(ui, HYF_INPUTDATA,
1013: (int)(HYMTU + sizeof (struct hy_hdr) - len),
1014: (int)(HYM_SWLEN + is->hy_ifuba.ifu_r.ifrw_info + len));
1015: } else {
1016: hyrecvdata(ui, hym, (int)len + HYM_SWLEN);
1017: is->hy_state = IDLE;
1018: }
1019: break;
1020: }
1021:
1022: case RECVDATASENT: {
1023: register struct hym_hdr *hym;
1024: register unsigned len;
1025:
1026: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
1027: UBAPURGE(is->hy_ifuba.ifu_uba,
1028: is->hy_ifuba.ifu_r.ifrw_bdp);
1029: hym = (struct hym_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr);
1030: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
1031: #ifdef DEBUG
1032: printD("hy%d: recvd assoc data, len = %d, data = ",
1033: ui->ui_unit, len);
1034: if (hy_debug_flag)
1035: hyprintdata((char *)hym + hym->hym_mplen, len);
1036: #endif
1037: hyrecvdata(ui, hym, (int)(len + hym->hym_mplen + HYM_SWLEN));
1038: is->hy_state = IDLE;
1039: break;
1040: }
1041:
1042: case XMITSENT:
1043: if (is->hy_flags & RQ_XASSOC) {
1044: register int len;
1045:
1046: is->hy_flags &= ~RQ_XASSOC;
1047: is->hy_state = XMITDATASENT;
1048: is->hy_retry = 0;
1049: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
1050: if (len > is->hy_olen) {
1051: printf(
1052: "hy%d: xmit error - len > hy_olen [%d > %d]\n",
1053: ui->ui_unit, len, is->hy_olen);
1054: #ifdef DEBUG
1055: hy_debug_flag = 1;
1056: #endif
1057: }
1058: hystart(ui, HYF_XMITLSTDATA, is->hy_olen - len,
1059: is->hy_ifuba.ifu_w.ifrw_info + HYM_SWLEN + len);
1060: break;
1061: }
1062: /* fall through to ... */
1063:
1064: case XMITDATASENT:
1065: hyxmitdata(ui);
1066: is->hy_state = IDLE;
1067: break;
1068:
1069: case WAITING: /* wait for message complete or output requested */
1070: if (HYS_RECVDATA(addr))
1071: is->hy_state = IDLE;
1072: else {
1073: is->hy_state = CLEARSENT;
1074: is->hy_retry = 0;
1075: hystart(ui, HYF_CLRWFMSG, 0, 0);
1076: }
1077: break;
1078:
1079: case MARKPORT:
1080: is->hy_state = STARTUP;
1081: if_down(&is->hy_if);
1082: is->hy_if.if_flags &= ~IFF_UP;
1083: goto endintr;
1084:
1085: default:
1086: printf("hy%d: DRIVER BUG - INVALID STATE %d\n",
1087: ui->ui_unit, is->hy_state);
1088: panic("HYPERCHANNEL IN INVALID STATE");
1089: /*NOTREACHED*/
1090: }
1091: if (is->hy_state == IDLE)
1092: goto actloop;
1093: endintr:
1094: ;
1095: #ifdef DEBUG
1096: printD("hy%d: hyact, exit at \"%s\"\n", ui->ui_unit,
1097: hy_state_names[is->hy_state]);
1098: #endif
1099: }
1100:
1101: struct sockproto hypproto = { PF_HYLINK };
1102: struct sockaddr_in hypdst = { sizeof(hypdst), AF_HYLINK };
1103: struct sockaddr_in hypsrc = { sizeof(hypsrc), AF_HYLINK };
1104:
1105: /*
1106: * Called from device interrupt when receiving data.
1107: * Examine packet to determine type. Decapsulate packet
1108: * based on type and pass to type specific higher-level
1109: * input routine.
1110: */
1111: hyrecvdata(ui, hym, len)
1112: struct uba_device *ui;
1113: register struct hym_hdr *hym;
1114: int len;
1115: {
1116: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1117: struct mbuf *m;
1118: register struct ifqueue *inq;
1119:
1120: is->hy_if.if_ipackets++;
1121: #ifdef DEBUG
1122: printD("hy%d: recieved packet, len = %d\n", ui->ui_unit, len);
1123: #endif
1124: #ifdef HYLOG
1125: {
1126: struct {
1127: short hlen;
1128: struct hym_hdr hhdr;
1129: } hh;
1130: hh.hlen = len;
1131: hh.hhdr = *hym;
1132: hylog(HYL_RECV, sizeof(hh), (char *)&hh);
1133: }
1134: #endif
1135: if (len > HYMTU + MPSIZE || len == 0)
1136: return; /* sanity */
1137: /*
1138: * Pull packet off interface.
1139: */
1140: m = if_rubaget(&is->hy_ifuba, len, 0, &is->hy_if);
1141: if (m == NULL)
1142: return;
1143:
1144: /*
1145: * if normal or adapter loopback response packet believe hym_type,
1146: * otherwise, use the raw input queue cause it's a response from an
1147: * adapter command.
1148: */
1149: if (hym->hym_param != 0 && (u_short)hym->hym_param != 0x80ff)
1150: goto rawlinkin;
1151:
1152: switch (hym->hym_type) {
1153:
1154: #ifdef INET
1155: case HYLINK_IP:
1156: schednetisr(NETISR_IP);
1157: inq = &ipintrq;
1158: break;
1159: #endif
1160: default:
1161: rawlinkin:
1162: {
1163: M_PREPEND(m, sizeof(struct hym_hdr), M_DONTWAIT);
1164: if (m == 0) {
1165: m_freem(m);
1166: return;
1167: }
1168: bcopy((caddr_t)hym, mtod(m, caddr_t), sizeof(struct hym_hdr));
1169: hypproto.sp_protocol = 0;
1170: hypdst.sin_addr = is->hy_addr;
1171: hypsrc.sin_addr = is->hy_addr;
1172: raw_input(m, &hypproto, (struct sockaddr *)&hypsrc,
1173: (struct sockaddr *)&hypdst);
1174: return;
1175: }
1176: }
1177: if (IF_QFULL(inq)) {
1178: IF_DROP(inq);
1179: m_freem(m);
1180: } else
1181: IF_ENQUEUE(inq, m);
1182: }
1183:
1184: /*
1185: * Transmit done, release resources, bump counters.
1186: */
1187: hyxmitdata(ui)
1188: struct uba_device *ui;
1189: {
1190: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1191:
1192: is->hy_if.if_opackets++;
1193: if (is->hy_ifuba.ifu_xtofree) {
1194: m_freem(is->hy_ifuba.ifu_xtofree);
1195: is->hy_ifuba.ifu_xtofree = 0;
1196: }
1197: }
1198:
1199: hycancel(ui)
1200: register struct uba_device *ui;
1201: {
1202: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1203:
1204: if (is->hy_ifuba.ifu_xtofree) {
1205: m_freem(is->hy_ifuba.ifu_xtofree);
1206: is->hy_ifuba.ifu_xtofree = 0;
1207: }
1208: #ifdef HYLOG
1209: hylog(HYL_CANCEL, 0, (char *)0);
1210: #endif
1211: #ifdef DEBUG
1212: if (hy_nodebug & 1)
1213: hy_debug_flag = 1;
1214: #endif
1215: #ifdef DEBUG
1216: printD("hy%d: cancel from state \"%s\" cmd=0x%x count=%d ptr=0x%x\n",
1217: ui->ui_unit, hy_state_names[is->hy_state], is->hy_savedcmd,
1218: is->hy_savedcount, is->hy_savedaddr);
1219: printD("\tflags 0x%x olen %d lastwcr %d retry %d\n",
1220: is->hy_flags, is->hy_olen, is->hy_lastwcr, is->hy_retry);
1221: printD("\tsaved: state %d count %d ptr 0x%x cmd 0x%x\n",
1222: is->hy_savedstate, is->hy_savedcount, is->hy_savedaddr,
1223: is->hy_savedcmd);
1224: #endif
1225: is->hy_state = IDLE;
1226: is->hy_flags |= (RQ_ENDOP | RQ_STATUS);
1227: hyact(ui);
1228: }
1229:
1230: #ifdef DEBUG
1231: hyprintdata(cp, len)
1232: register char *cp;
1233: register int len;
1234: {
1235: register int count = 16;
1236: register char *fmt;
1237: static char regfmt[] = "\n\t %x";
1238:
1239: fmt = ®fmt[2];
1240: while (--len >= 0) {
1241: printL(fmt, *cp++ & 0xff);
1242: fmt = ®fmt[2];
1243: if (--count <= 0) {
1244: fmt = ®fmt[0];
1245: count = 16;
1246: }
1247: }
1248: printL("\n");
1249: }
1250: #endif
1251:
1252: hywatch(unit)
1253: int unit;
1254: {
1255: register struct hy_softc *is = &hy_softc[unit];
1256: register struct uba_device *ui = hyinfo[unit];
1257: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
1258: int s;
1259:
1260: s = splimp();
1261: #ifdef PI13
1262: if ((addr->hyd_csr & S_POWEROFF) != 0) {
1263: addr->hyd_csr |= S_POWEROFF;
1264: DELAY(100);
1265: if ((addr->hyd_csr & S_POWEROFF) == 0) {
1266: printf("hy%d: Adapter Power Restored (hywatch)\n", unit);
1267: is->hy_state = IDLE;
1268: is->hy_flags |=
1269: (RQ_MARKUP | RQ_STATISTICS | RQ_ENDOP | RQ_STATUS);
1270: hyact(ui);
1271: }
1272: }
1273: #endif
1274: if (++is->hy_ntime >= 2 && is->hy_state != WAITING &&
1275: is->hy_state != STARTUP && is->hy_state != IDLE) {
1276: #ifdef HYLOG
1277: printf("hy%d: watchdog timer expired in state \"%s\"\n", unit,
1278: hy_state_names[is->hy_state]);
1279: #else
1280: printf("hy%d: watchdog timer expired in state %d\n", unit,
1281: is->hy_state);
1282: #endif
1283: printf("hy%d: last command 0x%x, flags 0x%x, csr 0x%b\n", unit,
1284: is->hy_savedcmd, is->hy_flags, addr->hyd_csr, HY_CSR_BITS);
1285: hycancel(ui);
1286: }
1287: splx(s);
1288: is->hy_if.if_timer = SCANINTERVAL;
1289: }
1290:
1291: #ifdef HYLOG
1292: hylog(code, len, ptr)
1293: int code, len;
1294: char *ptr;
1295: {
1296: register unsigned char *p;
1297: int s;
1298:
1299: s = splimp();
1300: if (hy_log.hyl_self != &hy_log) {
1301: hy_log.hyl_eptr = &hy_log.hyl_buf[HYL_SIZE];
1302: hy_log.hyl_ptr = &hy_log.hyl_buf[0];
1303: hy_log.hyl_self = &hy_log;
1304: hy_log.hyl_enable = HYL_CONTINUOUS;
1305: hy_log.hyl_onerr = HYL_CONTINUOUS;
1306: hy_log.hyl_count = 0;
1307: hy_log.hyl_icount = 16;
1308: hy_log.hyl_filter = 0xffff; /* enable all */
1309: }
1310: if (hy_log.hyl_enable == HYL_DISABLED || ((1 << code) & hy_log.hyl_filter) == 0)
1311: goto out;
1312: p = hy_log.hyl_ptr;
1313: if (p + len + 3 >= hy_log.hyl_eptr) {
1314: bzero((caddr_t)p, (unsigned)(hy_log.hyl_eptr - p));
1315: p = &hy_log.hyl_buf[0];
1316: if (hy_log.hyl_enable != HYL_CONTINUOUS) {
1317: hy_log.hyl_enable = HYL_DISABLED;
1318: goto out;
1319: }
1320: }
1321: *p++ = code;
1322: *p++ = len;
1323: bcopy((caddr_t)ptr, (caddr_t)p, (unsigned)len);
1324: if (hy_log.hyl_count != 0 && --hy_log.hyl_count == 0) {
1325: *p++ = '\0';
1326: hy_log.hyl_enable = HYL_DISABLED;
1327: hy_log.hyl_count = hy_log.hyl_icount;
1328: }
1329: p += len;
1330: if (hy_log.hyl_wait != 0) { /* wakeup HYGETLOG if wanted */
1331: if (hy_log.hyl_wait <= p - hy_log.hyl_ptr) {
1332: wakeup((caddr_t)&hy_log);
1333: hy_log.hyl_wait = 0;
1334: } else
1335: hy_log.hyl_wait -= p - hy_log.hyl_ptr;
1336: }
1337: hy_log.hyl_ptr = p;
1338: out:
1339: splx(s);
1340: }
1341: #endif
1342:
1343: /*ARGSUSED*/
1344: hyioctl(ifp, cmd, data)
1345: register struct ifnet *ifp;
1346: int cmd;
1347: caddr_t data;
1348: {
1349: struct ifaddr *ifa = (struct ifaddr *) data;
1350: struct hyrsetget *sg = (struct hyrsetget *)data;
1351: #if defined(HYLOG) || defined(HYELOG)
1352: struct hylsetget *sgl = (struct hylsetget *)data;
1353: #endif
1354: struct hy_route *r = (struct hy_route *)&hy_route[ifp->if_unit];
1355: int s = splimp(), error = 0;
1356: #ifdef HYLOG
1357: struct hy_softc *is = &hy_softc[ifp->if_unit];
1358: struct {
1359: u_char hstate;
1360: u_char hflags;
1361: u_short iflags;
1362: int hcmd;
1363: int herror;
1364: u_long haddr;
1365: u_long hmisc;
1366: } hil;
1367:
1368: hil.hmisc = -1;
1369: hil.hstate = is->hy_state;
1370: hil.hflags = is->hy_flags;
1371: hil.hcmd = cmd;
1372: #endif
1373:
1374: switch(cmd) {
1375:
1376: case SIOCSIFADDR:
1377: if (ifa->ifa_addr->sa_family != AF_INET)
1378: return(EINVAL);
1379: if ((ifp->if_flags & IFF_RUNNING) == 0)
1380: hyinit(ifp->if_unit);
1381: hy_softc[ifp->if_unit].hy_addr = IA_SIN(ifa)->sin_addr;
1382: #ifdef HYLOG
1383: hil.haddr = is->hy_addr.s_addr;
1384: #endif
1385: break;
1386:
1387: case HYSETROUTE:
1388: if (error = suser(u.u_cred, &u.u_acflag))
1389: goto out;
1390:
1391: if (sg->hyrsg_len != sizeof(struct hy_route)) {
1392: error = EINVAL;
1393: goto out;
1394: }
1395: if (copyin((caddr_t)(sg->hyrsg_ptr), (caddr_t)r, sg->hyrsg_len)) {
1396: r->hyr_lasttime = 0; /* disable further routing if trouble */
1397: error = EFAULT;
1398: goto out;
1399: }
1400: r->hyr_lasttime = time.tv_sec;
1401: #ifdef HYLOG
1402: hil.hmisc = r->hyr_lasttime;
1403: #endif
1404: break;
1405:
1406: case HYGETROUTE:
1407: if (sg->hyrsg_len < sizeof(struct hy_route)) {
1408: error = EINVAL;
1409: goto out;
1410: }
1411: if (copyout((caddr_t)r, (caddr_t) (sg->hyrsg_ptr), sizeof(struct hy_route))) {
1412: error = EFAULT;
1413: goto out;
1414: }
1415: break;
1416:
1417: #ifdef HYELOG
1418: case HYGETELOG:
1419: if (sgl->hylsg_len < sizeof(hy_elog)) {
1420: error = EINVAL;
1421: goto out;
1422: }
1423: if (copyout((caddr_t)hy_elog, sgl->hylsg_ptr, sizeof(hy_elog))) {
1424: error = EFAULT;
1425: goto out;
1426: }
1427: if (sgl->hylsg_cmd) {
1428: if (error = suser(u.u_cred, &u.u_acflag))
1429: goto out;
1430: bzero((caddr_t)hy_elog, sizeof(hy_elog));
1431: }
1432: break;
1433: #endif
1434:
1435: #ifdef HYLOG
1436: case HYSETLOG:
1437: if (error = suser(u.u_cred, &u.u_acflag))
1438: goto out;
1439: hy_log.hyl_enable = HYL_DISABLED;
1440: hylog(HYL_NOP, 0, (char *)0); /* force log init */
1441: hy_log.hyl_enable = sgl->hylsg_cmd & 0x0f;
1442: hy_log.hyl_onerr = (sgl->hylsg_cmd >> 4) & 0x0f;
1443: hy_log.hyl_filter = (sgl->hylsg_cmd >> 8) & 0xffffff;
1444: hy_log.hyl_count = hy_log.hyl_icount = sgl->hylsg_len;
1445: wakeup((caddr_t)&hy_log); /* wakeup sleeping HYGETLOG */
1446: break;
1447:
1448: case HYGETLOG:
1449: if (sgl->hylsg_len < sizeof(hy_log)) {
1450: error = EINVAL;
1451: goto out;
1452: }
1453: if (sgl->hylsg_cmd != 0) {
1454: if (hy_log.hyl_wait) {
1455: error = EBUSY;
1456: goto out;
1457: }
1458: hy_log.hyl_wait = sgl->hylsg_cmd;
1459: sleep((caddr_t)&hy_log, PZERO - 1);
1460: }
1461:
1462: if (copyout((caddr_t)&hy_log, sgl->hylsg_ptr, sizeof(hy_log))) {
1463: error = EFAULT;
1464: goto out;
1465: }
1466: break;
1467: #endif
1468:
1469: default:
1470: error = EINVAL;
1471: break;
1472: }
1473: out:
1474: #ifdef HYLOG
1475: hil.herror = error;
1476: hil.iflags = ifp->if_flags;
1477: hil.haddr = is->hy_addr.s_addr;
1478: hylog(HYL_IOCTL, sizeof(hil), (char *)&hil);
1479: #endif
1480: splx(s);
1481: return (error);
1482: }
1483: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.