![[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] / 42BSD / sys / vaxif|
Return to if_hy.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxif |
1.1 root 1: /* if_hy.c 6.1 83/07/29 */
2:
3: #include "hy.h"
4: #if NHY > 0
5:
6: /*
7: * Network Systems Copropration Hyperchanel interface
8: *
9: * UNTESTED WITH 4.2
10: */
11: #include "../machine/pte.h"
12:
13: #include "../h/param.h"
14: #include "../h/systm.h"
15: #include "../h/mbuf.h"
16: #include "../h/buf.h"
17: #include "../h/protosw.h"
18: #include "../h/socket.h"
19: #include "../h/vmmac.h"
20: #include "../h/errno.h"
21: #include "../h/time.h"
22: #include "../h/kernel.h"
23: #include "../h/ioctl.h"
24:
25: #include "../net/if.h"
26: #include "../net/netisr.h"
27: #include "../net/route.h"
28: #include "../netinet/in.h"
29: #include "../netinet/in_systm.h"
30: #include "../netinet/ip.h"
31: #include "../netinet/ip_var.h"
32:
33: #include "../vax/cpu.h"
34: #include "../vax/mtpr.h"
35: #include "../vaxuba/ubareg.h"
36: #include "../vaxuba/ubavar.h"
37: #include "../vaxif/if_hy.h"
38: #include "../vaxif/if_hyreg.h"
39: #include "../vaxif/if_uba.h"
40:
41: #define HYROUTE
42: #define HYELOG
43: #define HYMTU 576
44:
45: int hyprobe(), hyattach(), hyinit(), hyioctl();
46: int hyoutput(), hyreset(), hywatch();
47: struct uba_device *hyinfo[NHY];
48: u_short hystd[] = { 0772410, 0 };
49: struct uba_driver hydriver =
50: { hyprobe, 0, hyattach, 0, hystd, "hy", hyinfo };
51:
52: /*
53: * Hyperchannel software status per interface.
54: *
55: * Each interface is referenced by a network interface structure,
56: * hy_if, which the routing code uses to locate the interface.
57: * This structure contains the output queue for the interface, its address, ...
58: * We also have, for each interface, a UBA interface structure, which
59: * contains information about the UNIBUS resources held by the interface:
60: * map registers, buffered data paths, etc. Information is cached in this
61: * structure for use by the if_uba.c routines in running the interface
62: * efficiently.
63: */
64: struct hy_softc {
65: struct ifnet hy_if; /* network-visible interface */
66: struct ifuba hy_ifuba; /* UNIBUS resources */
67: short hy_flags; /* flags */
68: short hy_state; /* driver state */
69: int hy_ilen; /* mp length on input */
70: int hy_olen; /* packet length on output */
71: int hy_lastwcr; /* last command's word count */
72: short hy_savedstate; /* saved for reissue after status */
73: short hy_savedcmd; /* saved command for reissue */
74: int hy_savedcount; /* saved byte count for reissue */
75: int hy_savedaddr; /* saved unibus address for reissue */
76: int hy_ntime; /* number of timeouts since last cmd */
77: int hy_retry; /* retry counter */
78: struct hy_stat hy_stat; /* statistics */
79: struct hy_status hy_status; /* status */
80: } hy_softc[NHY];
81:
82: #ifdef HYELOG
83: #define HYE_MAX 0x18
84: u_long hy_elog[(HYE_MAX+1)*4];
85: #endif
86:
87: #ifdef DEBUG
88: #define printL lprintf
89: #define printD if (hy_debug_flag) lprintf
90: int hy_debug_flag = 0;
91: /*
92: * hy_nodebug bit 0x01 set hy_debug_flag on hycancel
93: * hy_nodebug bit 0x02 set hy_debug_flag on command reissue
94: * hy_nodebug bit 0x04 set hy_debug_flag on abnormal interrupt
95: * hy_nodebug bit 0x08 set hy_debug_flag on hyouput
96: * hy_nodebug bit 0x10 set hy_debug_flag on hyouput with associated data
97: */
98: int hy_nodebug = 0x0;
99: #else
100: #define printD hyvoid
101: #endif
102:
103: /*
104: * Requests for service (in order by descending priority).
105: */
106: #define RQ_ENDOP 001 /* end the last adapter function */
107: #define RQ_REISSUE 002 /* reissue previous cmd after status */
108: #define RQ_STATUS 004 /* get the status of the adapter */
109: #define RQ_STATISTICS 010 /* get the statistics of the adapter */
110: #define RQ_MARKDOWN 020 /* mark this adapter port down */
111: #define RQ_MARKUP 040 /* mark this interface up */
112:
113: #define RQ_XASSOC 0100 /* associated data to transmit */
114:
115: /*
116: * Driver states.
117: */
118: #define STARTUP 0 /* initial state (before fully there) */
119: #define IDLE 1 /* idle state */
120: #define STATSENT 2 /* status cmd sent to adapter */
121: #define ENDOPSENT 3 /* end operation cmd sent */
122: #define RECVSENT 4 /* input message cmd sent */
123: #define RECVDATASENT 5 /* input data cmd sent */
124: #define XMITSENT 6 /* transmit message cmd sent */
125: #define XMITDATASENT 7 /* transmit data cmd sent */
126: #define WAITING 8 /* waiting for messages */
127: #define CLEARSENT 9 /* clear wait for message cmd sent */
128: #define MARKPORT 10 /* mark this host's adapter port down issued */
129: #define RSTATSENT 11 /* read statistics cmd sent to adapter */
130:
131: #ifdef DEBUG
132: char *hy_state_names[] = {
133: "Startup",
134: "Idle",
135: "Status Sent",
136: "End op Sent",
137: "Recieve Message Proper Sent",
138: "Recieve Data Sent",
139: "Transmit Message Proper Sent",
140: "Transmit Data Sent",
141: "Wait for Message Sent",
142: "Clear Wait for Message Sent",
143: "Mark Port Down Sent",
144: "Read Statistics Sent"
145: };
146: #endif
147:
148: #define SCANINTERVAL 10 /* seconds */
149: #define MAXINTERVAL 20 /* seconds (max action) */
150:
151: /*
152: * Cause a device interrupt. This code uses a buffer starting at
153: * location zero on the unibus (which is already mapped by the
154: * autoconfigure code in the kernel).
155: */
156: hyprobe(reg)
157: caddr_t reg;
158: {
159: register int br, cvec; /* r11, r10 value-result */
160: register struct hydevice *addr = (struct hydevice *) reg;
161:
162: #ifdef lint
163: br = 0; cvec = br; br = cvec;
164: hyint(0);
165: #endif
166: /*
167: * request adapter status to a buffer starting at unibus location 0
168: */
169: addr->hyd_bar = 0;
170: addr->hyd_wcr = -((sizeof(struct hy_status) + 1) >> 1);
171: addr->hyd_dbuf = HYF_STATUS;
172: #ifdef PI13
173: addr->hyd_csr |= S_GO | S_IE | S_IATTN;
174: #else
175: addr->hyd_csr |= S_GO | S_IE;
176: #endif
177: DELAY(10000);
178: #ifdef PI13
179: addr->hyd_csr |= S_CLRINT; /* clear any stacked interrupts */
180: #endif
181: addr->hyd_csr &= ~(S_IE | S_CLRINT); /* disable further interrupts */
182: return(1);
183: }
184:
185: /*
186: * Interface exists: make available by filling in network interface
187: * record. System will initialize the interface when it is ready
188: * to accept packets.
189: */
190: hyattach(ui)
191: struct uba_device *ui;
192: {
193: register struct hy_softc *is = &hy_softc[ui->ui_unit];
194: register struct ifnet *ifp = &is->hy_if;
195:
196: ifp->if_unit = ui->ui_unit;
197: ifp->if_name = "hy";
198: ifp->if_mtu = HYMTU;
199: is->hy_state = STARTUP; /* don't allow state transitions yet */
200: ifp->if_init = hyinit;
201: ifp->if_ioctl = hyioctl;
202: ifp->if_output = hyoutput;
203: ifp->if_reset = hyreset;
204: ifp->if_watchdog = hywatch;
205: ifp->if_timer = SCANINTERVAL;
206: is->hy_ifuba.ifu_flags = UBA_CANTWAIT;
207: #ifdef notdef
208: is->hy_ifuba.ifu_flags |= UBA_NEEDBDP;
209: #endif
210: if_attach(ifp);
211: }
212:
213: /*
214: * Reset of interface after UNIBUS reset.
215: * If interface is on specified uba, reset its state.
216: */
217: hyreset(unit, uban)
218: int unit, uban;
219: {
220: register struct uba_device *ui = hyinfo[unit];
221:
222: if (unit >= NHY || ui == 0 || ui->ui_alive == 0 ||
223: ui->ui_ubanum != uban)
224: return;
225: printf(" hy%d", unit);
226: hyinit(unit);
227: }
228:
229: /*
230: * Initialization of interface; clear recorded pending
231: * operations, and reinitialize UNIBUS usage.
232: */
233: hyinit(unit)
234: int unit;
235: {
236: register struct hy_softc *is = &hy_softc[unit];
237: register struct uba_device *ui = hyinfo[unit];
238: struct sockaddr_in *sin;
239: int s;
240:
241: sin = (struct sockaddr_in *)&is->hy_if.if_addr;
242: if (in_netof(sin->sin_addr) == 0)
243: return;
244: if (if_ubainit(&is->hy_ifuba, ui->ui_ubanum,
245: sizeof (struct hy_hdr), (int)btoc(HYMTU)) == 0) {
246: #ifdef DEBUG
247: if (hy_nodebug & 4)
248: hy_debug_flag = 1;
249: #endif
250: printf("hy%d: can't initialize\n", unit);
251: is->hy_if.if_flags &= ~IFF_UP;
252: return;
253: }
254: is->hy_if.if_flags |= IFF_RUNNING;
255: /*
256: * Issue wait for message and start the state machine
257: */
258: s = splimp();
259: is->hy_state = IDLE;
260: is->hy_flags = RQ_STATUS | RQ_STATISTICS | RQ_MARKUP;
261: is->hy_retry = 0;
262: hyact(ui);
263: splx(s);
264: }
265:
266: /*
267: * Issue a command to the adapter
268: */
269: hystart(ui, cmd, count, ubaddr)
270: struct uba_device *ui;
271: int cmd, count, ubaddr;
272: {
273: register struct hy_softc *is = &hy_softc[ui->ui_unit];
274: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
275:
276: #ifdef DEBUG
277: printD("hy%d: hystart cmd = 0x%x count=%d ubaddr=0x%x\n",
278: ui->ui_unit, cmd, count, ubaddr);
279: printD("hy%d: - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
280: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
281: addr->hyd_wcr);
282: #endif
283: if (((is->hy_flags & RQ_REISSUE) == 0) &&
284: (cmd != HYF_STATUS) && (cmd != HYF_END_OP) && (cmd != HYF_RSTATS)) {
285: is->hy_savedstate = is->hy_state;
286: is->hy_savedcmd = cmd;
287: is->hy_savedcount = count;
288: is->hy_savedaddr = ubaddr;
289: }
290: addr->hyd_bar = ubaddr & 0xffff;
291: addr->hyd_wcr = is->hy_lastwcr = -((count+1) >> 1);
292: addr->hyd_dbuf = cmd;
293: #ifdef PI13
294: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE | S_IATTN;
295: #else
296: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE;
297: #endif
298: #ifdef DEBUG
299: printD("hy%d: exit hystart - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
300: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
301: addr->hyd_wcr);
302: #endif
303: #ifdef HYLOG
304: {
305: struct {
306: u_char hcmd;
307: u_char hstate;
308: short hcount;
309: } hcl;
310:
311: hcl.hcmd = cmd;
312: hcl.hstate = is->hy_state;
313: hcl.hcount = count;
314: hylog(HYL_CMD, sizeof(hcl), (char *)&hcl);
315: }
316: #endif
317: is->hy_ntime = 0;
318: }
319:
320: int hyint_active = 0; /* set during hy interrupt */
321: /*
322: * Hyperchannel interface interrupt.
323: *
324: * An interrupt can occur for many reasons. Examine the status of
325: * the hyperchannel status bits to determine what to do next.
326: *
327: * If input error just drop packet.
328: * Otherwise purge input buffered data path and examine
329: * packet to determine type. Othewise decapsulate
330: * packet based on type and pass to type specific higher-level
331: * input routine.
332: */
333: hyint(unit)
334: int unit;
335: {
336: register struct hy_softc *is = &hy_softc[unit];
337: register struct uba_device *ui = hyinfo[unit];
338: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
339:
340: if (hyint_active)
341: panic("RECURSIVE HYPERCHANNEL INTERRUPT");
342: hyint_active++;
343: #ifdef DEBUG
344: printD("hy%d: hyint enter - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
345: unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, addr->hyd_wcr);
346: #endif
347: #ifdef HYLOG
348: logit:
349: {
350: struct {
351: u_char hstate;
352: u_char hflags;
353: short hcsr;
354: short hwcr;
355: } hil;
356: hil.hstate = is->hy_state;
357: hil.hflags = is->hy_flags;
358: hil.hcsr = addr->hyd_csr;
359: hil.hwcr = addr->hyd_wcr;
360: hylog(HYL_INT, sizeof(hil), (char *)&hil);
361: }
362: #endif
363: if (HYS_ERROR(addr) && ((addr->hyd_csr & S_ATTN) == 0)) {
364: /*
365: * Error bit set, some sort of error in the interface.
366: *
367: * The adapter sets attn on command completion so that's not
368: * a real error even though the interface considers it one.
369: */
370: #ifdef DEBUG
371: if (hy_nodebug & 4)
372: hy_debug_flag = 1;
373: #endif
374: printf("csr = 0x%b\nbar = 0x%x\nwcr = 0x%x\n",
375: addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar,
376: addr->hyd_wcr);
377: if (addr->hyd_csr & S_NEX) {
378: printf("hy%d: NEX - Non Existant Memory\n", unit);
379: #ifdef PI13
380: addr->hyd_csr |= S_NEX; /* as per PI13 manual */
381: #else
382: addr->hyd_csr &= ~S_NEX;
383: #endif
384: hycancel(ui);
385: #ifdef PI13
386: } else if (addr->hyd_csr & S_POWEROFF) {
387: printf("hy%d: Power Off bit set, trying to reset\n",
388: unit);
389: addr->hyd_csr |= S_POWEROFF;
390: DELAY(100);
391: if (addr->hyd_csr & S_POWEROFF) {
392: if_down(&is->hy_if);
393: is->hy_state = STARTUP;
394: printf(
395: "hy%d: Power Off Error, network shutdown\n",
396: unit);
397: }
398: #endif
399: } else {
400: printf("hy%d: BAR overflow\n", unit);
401: hycancel(ui);
402: }
403: } else if (HYS_NORMAL(addr)) {
404: /*
405: * Normal interrupt, bump state machine unless in state
406: * waiting and no data present (assumed to be word count
407: * zero interrupt or other hardware botch).
408: */
409: if (is->hy_state != WAITING || HYS_RECVDATA(addr))
410: hyact(ui);
411: } else if (HYS_ABNORMAL(addr)) {
412: /*
413: * Abnormal termination.
414: * bump error counts, retry the last function
415: * 'MAXRETRY' times before kicking the bucket.
416: *
417: * Don't reissue the cmd if in certain states, abnormal
418: * on a reissued cmd or max retry exceeded.
419: */
420: #ifdef HYLOG
421: if (hy_log.hyl_enable != hy_log.hyl_onerr) {
422: hy_log.hyl_enable = hy_log.hyl_onerr;
423: goto logit;
424: }
425: #endif
426: #ifdef DEBUG
427: if (hy_nodebug & 4)
428: hy_debug_flag = 1;
429: printD("hy%d: abnormal interrupt, driver state \"%s\" (%d)\n",
430: unit, hy_state_names[is->hy_state], is->hy_state);
431: printD("\tflags 0x%x ilen %d olen %d lastwcr %d retry %d\n",
432: is->hy_flags, is->hy_ilen, is->hy_olen,
433: is->hy_lastwcr, is->hy_retry);
434: printD("\tsaved: state %d count %d cmd 0x%x ptr 0x%x\n",
435: is->hy_savedstate, is->hy_savedcount,
436: is->hy_savedaddr, is->hy_savedcmd);
437: #endif
438: #ifdef PI13
439: addr->hyd_csr &= ~S_C; /* clear the damned PI-13 */
440: #endif
441: if (is->hy_state == XMITSENT || is->hy_state == XMITDATASENT)
442: is->hy_if.if_oerrors++;
443: if (is->hy_state == RECVSENT || is->hy_state == RECVDATASENT)
444: is->hy_if.if_ierrors++;
445: if (is->hy_state == XMITDATASENT ||
446: is->hy_state == RECVSENT ||
447: is->hy_state == RECVDATASENT ||
448: (is->hy_flags & RQ_REISSUE) != 0 || is->hy_retry > MAXRETRY)
449: hycancel(ui);
450: else {
451: #ifdef DEBUG
452: if (hy_nodebug & 2)
453: hy_debug_flag = 1;
454: #endif
455: is->hy_retry++;
456: is->hy_flags |= RQ_ENDOP | RQ_STATUS | RQ_REISSUE;
457: is->hy_state = IDLE;
458: hyact(ui);
459: }
460: } else {
461: /*
462: * Interrupt is neither normal, abnormal, or interface error.
463: * Ignore it. It's either stacked or a word count 0.
464: */
465: #ifdef HYLOG
466: if (hy_log.hyl_enable != hy_log.hyl_onerr) {
467: hy_log.hyl_enable = hy_log.hyl_onerr;
468: goto logit;
469: }
470: #endif
471: #ifdef DEBUG
472: printD("hy%d: possible stacked interrupt ignored\n", unit);
473: #endif
474: }
475: #ifdef DEBUG
476: printD("hy%d: hyint exit\n\n", unit);
477: #endif
478: hyint_active = 0;
479:
480: }
481:
482: /*
483: * Encapsulate a packet of type family for the local net.
484: */
485: hyoutput(ifp, m0, dst)
486: struct ifnet *ifp;
487: struct mbuf *m0;
488: struct sockaddr *dst;
489: {
490: register struct hym_hdr *hym;
491: register struct mbuf *m;
492: #ifdef HYROUTE
493: register struct hyroute *r = &hy_route[ifp->if_unit];
494: #endif
495: short dtype; /* packet type */
496: int dhost; /* destination adapter address */
497: int dlen;
498: int mplen = 0; /* message proper length */
499: short loopback = 0; /* hardware loopback requested */
500: int error = 0;
501: int s;
502:
503: #ifdef DEBUG
504: if (hy_nodebug & 8)
505: hy_debug_flag = 1;
506: #endif
507: dlen = 0;
508: for (m = m0; m; m = m->m_next)
509: dlen += m->m_len;
510: m = m0;
511: switch(dst->sa_family) {
512:
513: #ifdef INET
514: case AF_INET: {
515: register struct ip *ip = mtod(m, struct ip *);
516: register struct sockaddr_in *sin = (struct sockaddr_in *)dst;
517: register long hostaddr = in_lnaof(sin->sin_addr);
518:
519: dhost = hostaddr & 0xffff;
520: dtype = HYLINK_IP;
521: #ifdef DEBUG
522: printD("hy%d: output to host %x, dhost %x\n",
523: ifp->if_unit, sin->sin_addr.s_addr, dhost);
524: #endif
525: /*
526: * Debugging loopback support:
527: * upper byte of 24 bit host number interpreted as follows
528: * 0x00 --> no loopback
529: * 0x01 --> hardware loop through remote adapter
530: * other --> software loop through remote ip layer
531: */
532: if (hostaddr & 0xff0000) {
533: struct in_addr temp;
534:
535: temp = ip->ip_dst;
536: ip->ip_dst = ip->ip_src;
537: ip->ip_src = temp;
538: if ((hostaddr & 0xff0000) == 0x10000)
539: loopback = H_LOOPBK;
540: }
541: /*
542: * If entire packet won't fit in message proper, just
543: * send hyperchannel hardware header and ip header in
544: * message proper. If that won't fit either, just send
545: * the maximum message proper.
546: *
547: * This insures that the associated data is at least a
548: * TCP/UDP header in length and thus prevents potential
549: * problems with very short word counts.
550: */
551: if (dlen > MPSIZE - sizeof (struct hy_hdr)) {
552: mplen = sizeof(struct hy_hdr) + (ip->ip_hl << 2);
553: if (mplen > MPSIZE)
554: mplen = MPSIZE;
555: }
556: break;
557: }
558: #endif
559:
560: default:
561: printf("hy%d: can't handle af%d\n", ifp->if_unit,
562: dst->sa_family);
563: #ifdef DEBUG
564: if (hy_nodebug & 4)
565: hy_debug_flag = 1;
566: #endif
567: error = EAFNOSUPPORT;
568: goto drop;
569: }
570:
571: /*
572: * Add the software and hardware hyperchannel headers.
573: * If there's not enough space in the first mbuf, allocate another.
574: * If that should fail, drop this sucker.
575: * No extra space for headers is allocated.
576: */
577: if (m->m_off > MMAXOFF ||
578: MMINOFF + sizeof(struct hym_hdr) > m->m_off) {
579: m = m_get(M_DONTWAIT, MT_HEADER);
580: if (m == 0) {
581: m = m0;
582: error = ENOBUFS;
583: goto drop;
584: }
585: m->m_next = m0;
586: m->m_off = MMINOFF;
587: m->m_len = sizeof(struct hym_hdr);
588: } else {
589: m->m_off -= sizeof(struct hym_hdr);
590: m->m_len += sizeof(struct hym_hdr);
591: }
592: hym = mtod(m, struct hym_hdr *);
593: hym->hym_mplen = mplen;
594: hym->hym_hdr.hyh_type = dtype;
595: hym->hym_hdr.hyh_off = 0;
596: hym->hym_hdr.hyh_from = htons((u_short)ifp->if_host[0]);
597: hym->hym_hdr.hyh_param = loopback;
598: #ifdef HYROUTE
599: if (r->hyr_lasttime.tv_sec != 0) {
600: register struct hy_hash *rh;
601: register int i;
602:
603: i = HYRHASH(dhost);
604: rh = &r->hyr_hash[i];
605: i = 0;
606: while (rh->hyr_key != dhost) {
607: rh++; i++;
608: if (rh > &r->hyr_hash[HYRSIZE])
609: rh = &r->hyr_hash[0];
610: if (rh->hyr_flags == 0 || i > HYRSIZE)
611: goto notfound;
612: }
613: if (rh->hyr_flags & HYR_GATE) {
614: loopback = 0; /* no hardware loopback on gateways */
615: i = rh->hyr_nextgate;
616: if (i >= rh->hyr_egate)
617: rh->hyr_nextgate = rh->hyr_pgate;
618: else
619: rh->hyr_nextgate++;
620: rh = &r->hyr_hash[r->hyr_gateway[i]];
621: if ((rh->hyr_flags & HYR_DIR) == 0)
622: goto notfound;
623: }
624: hym->hym_hdr.hyh_ctl = rh->hyr_ctl;
625: hym->hym_hdr.hyh_access = rh->hyr_access;
626: hym->hym_hdr.hyh_to = rh->hyr_dst;
627: } else {
628: hym->hym_hdr.hyh_ctl = H_XTRUNKS | H_RTRUNKS;
629: hym->hym_hdr.hyh_access = 0;
630: hym->hym_hdr.hyh_to = htons((u_short)dhost);
631: }
632: #else
633: hym->hym_hdr.hyh_ctl = H_XTRUNKS | H_RTRUNKS;
634: hym->hym_hdr.hyh_access = 0;
635: hym->hym_hdr.hyh_to = htons(dhost);
636: #endif
637:
638: if (hym->hym_mplen) {
639: hym->hym_hdr.hyh_ctl |= H_ASSOC;
640: #ifdef DEBUG
641: if (hy_nodebug & 16)
642: hy_debug_flag = 1;
643: #endif
644: } else
645: hym->hym_hdr.hyh_ctl &= ~H_ASSOC;
646: #ifdef DEBUG
647: printD("hy%d: output mplen=%x ctl=%x access=%x to=%x",
648: ifp->if_unit, hym->hym_mplen, hym->hym_hdr.hyh_ctl,
649: hym->hym_hdr.hyh_access, hym->hym_hdr.hyh_to);
650: printD(" (adapter %x) from=%x param=%x type=%x off=%x\n",
651: hym->hym_hdr.hyh_to_adapter,
652: hym->hym_hdr.hyh_from, hym->hym_hdr.hyh_param,
653: hym->hym_hdr.hyh_type, hym->hym_hdr.hyh_off);
654: #endif
655: s = splimp();
656: if (IF_QFULL(&ifp->if_snd)) {
657: IF_DROP(&ifp->if_snd);
658: error = ENOBUFS;
659: splx(s);
660: goto drop;
661: }
662: IF_ENQUEUE(&ifp->if_snd, m);
663: if (hy_softc[ifp->if_unit].hy_state == WAITING)
664: hyact(hyinfo[ifp->if_unit]);
665: splx(s);
666: return (0);
667: notfound:
668: error = ENETUNREACH; /* XXX */
669: drop:
670: m_freem(m);
671: return (error);
672: }
673:
674: hyact(ui)
675: register struct uba_device *ui;
676: {
677: register struct hy_softc *is = &hy_softc[ui->ui_unit];
678: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
679:
680: actloop:
681: #ifdef DEBUG
682: printD("hy%d: hyact, enter state \"%s\"\n", ui->ui_unit,
683: hy_state_names[is->hy_state]);
684: #endif
685: switch (is->hy_state) {
686:
687: case STARTUP:
688: goto endintr;
689:
690: case IDLE: {
691: register rq = is->hy_flags;
692:
693: if (rq & RQ_STATUS) {
694: is->hy_flags &= ~RQ_STATUS;
695: is->hy_state = STATSENT;
696: hystart(ui, HYF_STATUS, sizeof (is->hy_status),
697: is->hy_ifuba.ifu_r.ifrw_info);
698: } else if (rq & RQ_ENDOP) {
699: is->hy_flags &= ~RQ_ENDOP;
700: is->hy_state = ENDOPSENT;
701: hystart(ui, HYF_END_OP, 0, 0);
702: } else if (rq & RQ_STATISTICS) {
703: is->hy_flags &= ~RQ_STATISTICS;
704: is->hy_state = RSTATSENT;
705: hystart(ui, HYF_RSTATS, sizeof (is->hy_stat),
706: is->hy_ifuba.ifu_r.ifrw_info);
707: } else if (HYS_RECVDATA(addr)) {
708: is->hy_state = RECVSENT;
709: is->hy_retry = 0;
710: hystart(ui, HYF_INPUTMSG, MPSIZE,
711: is->hy_ifuba.ifu_r.ifrw_info);
712: } else if (rq & RQ_REISSUE) {
713: is->hy_flags &= ~RQ_REISSUE;
714: is->hy_state = is->hy_savedstate;
715: #ifdef DEBUG
716: printD("hy%d: reissue cmd=0x%x count=%d",
717: ui->ui_unit, is->hy_savedcmd, is->hy_savedcount);
718: printD(" ubaddr=0x%x retry=%d\n",
719: is->hy_savedaddr, is->hy_retry);
720: #endif
721: hystart(ui, is->hy_savedcmd, is->hy_savedcount,
722: is->hy_savedaddr);
723: } else {
724: register struct mbuf *m;
725:
726: IF_DEQUEUE(&is->hy_if.if_snd, m);
727: if (m != NULL) {
728: register struct hym_hdr *hym;
729: register int mplen;
730: register int cmd;
731:
732: is->hy_state = XMITSENT;
733: is->hy_retry = 0;
734: hym = mtod(m, struct hym_hdr *);
735: #ifdef HYLOG
736: hylog(HYL_XMIT, sizeof(struct hym_hdr),
737: (char *)hym);
738: #endif
739: mplen = hym->hym_mplen;
740: if (hym->hym_hdr.hyh_to_adapter ==
741: hym->hym_hdr.hyh_from_adapter)
742: cmd = HYF_XMITLOCMSG;
743: else
744: cmd = HYF_XMITMSG;
745: #ifdef DEBUG
746: printD("hy%d: hym_hdr = ", ui->ui_unit);
747: if (hy_debug_flag)
748: hyprintdata((char *)hym,
749: sizeof (struct hym_hdr));
750: #endif
751: /*
752: * Strip off the software part of
753: * the hyperchannel header
754: */
755: m->m_off += sizeof(struct hym_data);
756: m->m_len -= sizeof(struct hym_data);
757: is->hy_olen = if_wubaput(&is->hy_ifuba, m);
758: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
759: UBAPURGE(is->hy_ifuba.ifu_uba,
760: is->hy_ifuba.ifu_w.ifrw_bdp);
761: #ifdef DEBUG
762: printD(
763: "hy%d: sending packet (mplen = %d, hy_olen = %d) data = ",
764: ui->ui_unit, mplen, is->hy_olen);
765: if (hy_debug_flag)
766: hyprintdata(
767: is->hy_ifuba.ifu_w.ifrw_addr,
768: is->hy_olen);
769: #endif
770: hystart(ui, cmd,
771: (mplen == 0) ? is->hy_olen : mplen,
772: is->hy_ifuba.ifu_w.ifrw_info);
773: if (mplen != 0)
774: is->hy_flags |= RQ_XASSOC;
775: } else if (rq & RQ_MARKDOWN) {
776: is->hy_flags &= ~(RQ_MARKUP | RQ_MARKDOWN);
777: is->hy_state = MARKPORT;
778: is->hy_retry = 0;
779: /*
780: * Port number is taken from status data
781: */
782: hystart(ui,
783: (int)(HYF_MARKP0|(PORTNUM(&is->hy_status)<<2)),
784: 0, 0);
785: } else if (rq & RQ_MARKUP) {
786: register struct ifnet *ifp = &is->hy_if;
787: register struct sockaddr_in *sin =
788: (struct sockaddr_in *)&ifp->if_addr;
789:
790: is->hy_flags &= ~RQ_MARKUP;
791: is->hy_retry = 0;
792: /*
793: * Fill in the host number
794: * from the status buffer
795: */
796: printf(
797: "hy%d: unit number 0x%x port %d type %x microcode level 0x%x\n",
798: ui->ui_unit,
799: is->hy_stat.hyc_uaddr,
800: PORTNUM(&is->hy_status),
801: (is->hy_stat.hyc_atype[0]<<8) |
802: is->hy_stat.hyc_atype[1],
803: is->hy_stat.hyc_atype[2]);
804:
805: ifp->if_host[0] =
806: (is->hy_stat.hyc_uaddr << 8) |
807: PORTNUM(&is->hy_status);
808: sin->sin_addr =
809: if_makeaddr(ifp->if_net, ifp->if_host[0]);
810: ifp->if_flags |= IFF_UP;
811: if_rtinit(ifp, RTF_UP);
812: #ifdef HYLOG
813: hylog(HYL_UP, 0, (char *)0);
814: #endif
815: } else {
816: is->hy_state = WAITING;
817: is->hy_retry = 0;
818: hystart(ui, HYF_WAITFORMSG, 0, 0);
819: }
820: }
821: break;
822: }
823:
824: case STATSENT:
825: bcopy(is->hy_ifuba.ifu_r.ifrw_addr, (caddr_t)&is->hy_status,
826: sizeof (struct hy_status));
827: #ifdef DEBUG
828: printD("hy%d: status - %x %x %x %x %x %x %x %x\n",
829: ui->ui_unit, is->hy_status.hys_gen_status,
830: is->hy_status.hys_last_fcn,
831: is->hy_status.hys_resp_trunk,
832: is->hy_status.hys_status_trunk,
833: is->hy_status.hys_recd_resp,
834: is->hy_status.hys_error,
835: is->hy_status.hys_caddr,
836: is->hy_status.hys_pad);
837: #endif
838: is->hy_state = IDLE;
839: #ifdef HYLOG
840: hylog(HYL_STATUS, sizeof (struct hy_status),
841: (char *)&is->hy_status);
842: #endif
843: #ifdef HYELOG
844: {
845: register int i;
846:
847: i = is->hy_status.hys_error;
848: if (i < HYE_MAX)
849: i = HYE_MAX;
850: switch (is->hy_status.hys_last_fcn) {
851: case HYF_XMITLOCMSG:
852: i += HYE_MAX+1; /* fall through */
853: case HYF_XMITLSTDATA:
854: i += HYE_MAX+1; /* fall through */
855: case HYF_XMITMSG:
856: i += HYE_MAX+1;
857: }
858: hy_elog[i]++;
859: }
860: #endif
861: break;
862:
863: case RSTATSENT: {
864: register struct hy_stat *p =
865: (struct hy_stat *)is->hy_ifuba.ifu_r.ifrw_addr;
866:
867: is->hy_stat.hyc_msgcnt = ntohl(p->hyc_msgcnt);
868: is->hy_stat.hyc_dbcnt = ntohl(p->hyc_dbcnt);
869: is->hy_stat.hyc_tbusy = ntohl(p->hyc_tbusy);
870: is->hy_stat.hyc_hwret = ntohl(p->hyc_hwret);
871: is->hy_stat.hyc_crcbad = ntohl(p->hyc_crcbad);
872: is->hy_stat.hyc_mcret = ntohl(p->hyc_mcret);
873: is->hy_stat.hyc_tdabort = ntohl(p->hyc_tdabort);
874: is->hy_stat.hyc_atype[0] = p->hyc_atype[0];
875: is->hy_stat.hyc_atype[1] = p->hyc_atype[1];
876: is->hy_stat.hyc_atype[2] = p->hyc_atype[2];
877: is->hy_stat.hyc_uaddr = p->hyc_uaddr;
878: #ifdef DEBUG
879: printD(
880: "hy%d: statistics - msgcnt %d dbcnt %d hwret %d tbusy %d crcbad %d\n",
881: ui->ui_unit,
882: is->hy_stat.hyc_msgcnt, is->hy_stat.hyc_dbcnt,
883: is->hy_stat.hyc_tbusy, is->hy_stat.hyc_hwret,
884: is->hy_stat.hyc_crcbad);
885: printD(" mcret %d tdabort %d atype %x %x %x uaddr %x\n",
886: is->hy_stat.hyc_mcret, is->hy_stat.hyc_tdabort,
887: is->hy_stat.hyc_atype[0], is->hy_stat.hyc_atype[1],
888: is->hy_stat.hyc_atype[2], is->hy_stat.hyc_uaddr);
889: #endif
890: is->hy_state = IDLE;
891: #ifdef HYLOG
892: hylog(HYL_STATISTICS, sizeof (struct hy_stat),
893: (char *)&is->hy_stat);
894: #endif
895: break;
896: }
897:
898: case CLEARSENT:
899: is->hy_state = IDLE;
900: break;
901:
902: case ENDOPSENT:
903: is->hy_state = IDLE;
904: break;
905:
906: case RECVSENT: {
907: register struct hy_hdr *hyh;
908: register unsigned len;
909:
910: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
911: UBAPURGE(is->hy_ifuba.ifu_uba,
912: is->hy_ifuba.ifu_r.ifrw_bdp);
913: hyh = (struct hy_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr);
914: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
915: if (len > MPSIZE) {
916: printf("hy%d: RECVD MP > MPSIZE (%d)\n",
917: ui->ui_unit, len);
918: #ifdef DEBUG
919: hy_debug_flag = 1;
920: printD("hy%d: csr = 0x%b, bar = 0x%x, wcr = 0x%x\n",
921: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS,
922: addr->hyd_bar, addr->hyd_wcr);
923: #endif
924: }
925: #ifdef DEBUG
926: printD("hy%d: recvd mp, len = %d, data = ", ui->ui_unit, len);
927: if (hy_debug_flag)
928: hyprintdata((char *)hyh, len);
929: #endif
930: if (hyh->hyh_ctl & H_ASSOC) {
931: is->hy_state = RECVDATASENT;
932: is->hy_ilen = len;
933: is->hy_retry = 0;
934: hystart(ui, HYF_INPUTDATA,
935: (int)(HYMTU-len+sizeof (struct hy_hdr)),
936: (int)(is->hy_ifuba.ifu_r.ifrw_info + len));
937: } else {
938: hyrecvdata(ui, hyh, (int)len);
939: is->hy_state = IDLE;
940: }
941: break;
942: }
943:
944: case RECVDATASENT: {
945: register struct hy_hdr *hyh;
946: register unsigned len;
947:
948: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP)
949: UBAPURGE(is->hy_ifuba.ifu_uba,
950: is->hy_ifuba.ifu_r.ifrw_bdp);
951: hyh = (struct hy_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr);
952: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
953: #ifdef DEBUG
954: printD("hy%d: recvd assoc data, len = %d, data = ",
955: ui->ui_unit, len);
956: if (hy_debug_flag)
957: hyprintdata((char *)hyh + is->hy_ilen, len);
958: #endif
959: hyrecvdata(ui, hyh, (int)(len + is->hy_ilen));
960: is->hy_state = IDLE;
961: break;
962: }
963:
964: case XMITSENT:
965: if (is->hy_flags & RQ_XASSOC) {
966: register int len;
967:
968: is->hy_flags &= ~RQ_XASSOC;
969: is->hy_state = XMITDATASENT;
970: is->hy_retry = 0;
971: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1;
972: if (len > is->hy_olen) {
973: printf(
974: "hy%d: xmit error - len > hy_olen [%d > %d]\n",
975: ui->ui_unit, len, is->hy_olen);
976: #ifdef DEBUG
977: hy_debug_flag = 1;
978: #endif
979: }
980: hystart(ui, HYF_XMITLSTDATA, is->hy_olen - len,
981: is->hy_ifuba.ifu_w.ifrw_info + len);
982: break;
983: }
984: /* fall through to ... */
985:
986: case XMITDATASENT:
987: hyxmitdata(ui);
988: is->hy_state = IDLE;
989: break;
990:
991: case WAITING: /* wait for message complete or output requested */
992: if (HYS_RECVDATA(addr))
993: is->hy_state = IDLE;
994: else {
995: is->hy_state = CLEARSENT;
996: is->hy_retry = 0;
997: hystart(ui, HYF_CLRWFMSG, 0, 0);
998: }
999: break;
1000:
1001: case MARKPORT:
1002: is->hy_state = STARTUP;
1003: is->hy_if.if_flags &= ~IFF_UP;
1004: goto endintr;
1005:
1006: default:
1007: printf("hy%d: DRIVER BUG - INVALID STATE %d\n",
1008: ui->ui_unit, is->hy_state);
1009: panic("HYPERCHANNEL IN INVALID STATE");
1010: /*NOTREACHED*/
1011: }
1012: if (is->hy_state == IDLE)
1013: goto actloop;
1014: endintr:
1015: ;
1016: #ifdef DEBUG
1017: printD("hy%d: hyact, exit at \"%s\"\n", ui->ui_unit,
1018: hy_state_names[is->hy_state]);
1019: #endif
1020: }
1021:
1022: /*
1023: * Called from device interrupt when receiving data.
1024: * Examine packet to determine type. Decapsulate packet
1025: * based on type and pass to type specific higher-level
1026: * input routine.
1027: */
1028: hyrecvdata(ui, hyh, len)
1029: struct uba_device *ui;
1030: register struct hy_hdr *hyh;
1031: int len;
1032: {
1033: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1034: struct mbuf *m;
1035: register struct ifqueue *inq;
1036:
1037: is->hy_if.if_ipackets++;
1038: #ifdef DEBUG
1039: printD("hy%d: recieved packet, len = %d (actual %d)\n",
1040: ui->ui_unit, len,
1041: len - (hyh->hyh_off + sizeof (struct hy_hdr)));
1042: #endif
1043: #ifdef HYLOG
1044: {
1045: struct {
1046: short hlen;
1047: struct hy_hdr hhdr;
1048: } hh;
1049: hh.hlen = len;
1050: hh.hhdr = *hyh;
1051: hylog(HYL_RECV, sizeof(hh), (char *)&hh);
1052: }
1053: #endif
1054: if (len > HYMTU + MPSIZE || len == 0)
1055: return; /* sanity */
1056: /*
1057: * Pull packet off interface.
1058: */
1059: m = if_rubaget(&is->hy_ifuba, len, 0);
1060: if (m == NULL)
1061: return;
1062: switch (hyh->hyh_type) {
1063:
1064: #ifdef INET
1065: case HYLINK_IP:
1066: /*
1067: * Strip the variable portion of the hyperchannel header
1068: * (fixed portion stripped in if_rubaget).
1069: */
1070: m->m_len -= hyh->hyh_off;
1071: m->m_off += hyh->hyh_off;
1072: schednetisr(NETISR_IP);
1073: inq = &ipintrq;
1074: break;
1075: #endif
1076: default:
1077: m_freem(m);
1078: return;
1079: }
1080: if (IF_QFULL(inq)) {
1081: IF_DROP(inq);
1082: m_freem(m);
1083: } else
1084: IF_ENQUEUE(inq, m);
1085: }
1086:
1087: /*
1088: * Transmit done, release resources, bump counters.
1089: */
1090: hyxmitdata(ui)
1091: struct uba_device *ui;
1092: {
1093: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1094:
1095: is->hy_if.if_opackets++;
1096: if (is->hy_ifuba.ifu_xtofree) {
1097: m_freem(is->hy_ifuba.ifu_xtofree);
1098: is->hy_ifuba.ifu_xtofree = 0;
1099: }
1100: }
1101:
1102: hycancel(ui)
1103: register struct uba_device *ui;
1104: {
1105: register struct hy_softc *is = &hy_softc[ui->ui_unit];
1106:
1107: if (is->hy_ifuba.ifu_xtofree) {
1108: m_freem(is->hy_ifuba.ifu_xtofree);
1109: is->hy_ifuba.ifu_xtofree = 0;
1110: }
1111: #ifdef DEBUG
1112: if (hy_nodebug & 1)
1113: hy_debug_flag = 1;
1114: #endif
1115: #ifdef DEBUG
1116: printD("hy%d: cancel from state \"%s\" cmd=0x%x count=%d ptr=0x%x\n",
1117: ui->ui_unit, hy_state_names[is->hy_state], is->hy_savedcmd,
1118: is->hy_savedcount, is->hy_savedaddr);
1119: printD("\tflags 0x%x ilen %d olen %d lastwcr %d retry %d\n",
1120: is->hy_flags, is->hy_ilen, is->hy_olen, is->hy_lastwcr,
1121: is->hy_retry);
1122: printD("\tsaved: state %d count %d ptr 0x%x cmd 0x%x\n",
1123: is->hy_savedstate, is->hy_savedcount, is->hy_savedaddr,
1124: is->hy_savedcmd);
1125: #endif
1126: is->hy_state = IDLE;
1127: is->hy_flags |= (RQ_ENDOP | RQ_STATUS);
1128: hyact(ui);
1129: }
1130:
1131: #ifdef DEBUG
1132: hyprintdata(cp, len)
1133: register char *cp;
1134: register int len;
1135: {
1136: register int count = 16;
1137: register char *fmt;
1138: static char regfmt[] = "\n\t %x";
1139:
1140: fmt = ®fmt[2];
1141: while (--len >= 0) {
1142: printL(fmt, *cp++ & 0xff);
1143: fmt = ®fmt[2];
1144: if (--count <= 0) {
1145: fmt = ®fmt[0];
1146: count = 16;
1147: }
1148: }
1149: printL("\n");
1150: }
1151: #endif
1152:
1153: hywatch(unit)
1154: int unit;
1155: {
1156: register struct hy_softc *is = &hy_softc[unit];
1157: register struct uba_device *ui = hyinfo[unit];
1158: register struct hydevice *addr = (struct hydevice *)ui->ui_addr;
1159: int s;
1160:
1161: s = splimp();
1162: is->hy_if.if_timer = SCANINTERVAL;
1163: if (is->hy_ntime > 2 && is->hy_state != WAITING &&
1164: is->hy_state != STARTUP && is->hy_state != IDLE) {
1165: printf("hy%d: watchdog timer expired\n", unit);
1166: hycancel(ui);
1167: }
1168: #ifdef PI13
1169: if ((addr->hyd_csr & S_POWEROFF) != 0) {
1170: addr->hyd_csr |= S_POWEROFF;
1171: DELAY(100);
1172: if ((addr->hyd_csr & S_POWEROFF) == 0) {
1173: printf("hy%d: adapter power restored\n", unit);
1174: is->hy_state = IDLE;
1175: is->hy_flags |=
1176: (RQ_MARKUP | RQ_STATISTICS | RQ_ENDOP | RQ_STATUS);
1177: hyact(ui);
1178: }
1179: }
1180: #endif
1181: splx(s);
1182: }
1183:
1184: #ifdef HYLOG
1185: hylog(code, len, ptr)
1186: int code, len;
1187: char *ptr;
1188: {
1189: register unsigned char *p;
1190: int s;
1191:
1192: s = splimp();
1193: if (hy_log.hyl_self != &hy_log) {
1194: hy_log.hyl_eptr = &hy_log.hyl_buf[HYL_SIZE];
1195: hy_log.hyl_ptr = &hy_log.hyl_buf[0];
1196: hy_log.hyl_self = &hy_log;
1197: hy_log.hyl_enable = HYL_DISABLED;
1198: hy_log.hyl_onerr = HYL_CATCH1;
1199: }
1200: if (hy_log.hyl_enable == HYL_DISABLED ||
1201: hy_log.hyl_enable == HYL_CAUGHT1 ||
1202: hy_log.hyl_enable == HYL_CAUGHTSTATUS ||
1203: (hy_log.hyl_enable == HYL_CATCHSTATUS && code != HYL_STATUS))
1204: goto out;
1205: p = hy_log.hyl_ptr;
1206: if (p + len + 2 >= hy_log.hyl_eptr) {
1207: bzero((caddr_t)p, (unsigned)(hy_log.hyl_eptr - p));
1208: p = &hy_log.hyl_buf[0];
1209: if (hy_log.hyl_enable == HYL_CATCH1) {
1210: hy_log.hyl_enable = hy_log.hyl_onerr = HYL_CAUGHT1;
1211: goto out;
1212: }
1213: if (hy_log.hyl_enable == HYL_CATCHSTATUS) {
1214: hy_log.hyl_enable = hy_log.hyl_onerr = HYL_CAUGHTSTATUS;
1215: goto out;
1216: }
1217: }
1218: *p++ = code;
1219: *p++ = len;
1220: bcopy((caddr_t)ptr, (caddr_t)p, (unsigned)len);
1221: hy_log.hyl_ptr = p + len;
1222: out:
1223: splx(s);
1224: }
1225: #endif
1226:
1227: /*ARGSUSED*/
1228: hyioctl(ifp, cmd, data)
1229: register struct ifnet *ifp;
1230: int cmd;
1231: caddr_t data;
1232: {
1233: struct sockaddr_in *sin;
1234: struct ifreq *ifr = (struct ifreq *)data;
1235: int s = splimp(), error = 0;
1236:
1237: switch(cmd) {
1238:
1239: case SIOCSIFADDR:
1240: if (ifp->if_flags & IFF_RUNNING)
1241: if_rtinit(ifp, -1);
1242: sin = (struct sockaddr_in *)&ifr->ifr_addr;
1243: ifp->if_net = in_netof(sin->sin_addr);
1244: sin = (struct sockaddr_in *)&ifp->if_addr;
1245: sin->sin_family = AF_INET;
1246: sin->sin_addr = if_makeaddr(ifp->if_net, ifp->if_host[0]);
1247: if (ifp->if_flags & IFF_RUNNING)
1248: if_rtinit(ifp, RTF_UP);
1249: else
1250: hyinit(ifp->if_unit);
1251: break;
1252:
1253: case HYSETROUTE:
1254: if (!suser()) {
1255: error = EPERM;
1256: goto bad;
1257: }
1258: hy_route[ifp->if_unit] = *(struct hyroute *)ifr->ifr_data;
1259: hy_route[ifp->if_unit].hyr_lasttime = time;
1260: break;
1261:
1262: case HYGETROUTE:
1263: *(struct hyroute *)ifr->ifr_data = hy_route[ifp->if_unit];
1264: break;
1265:
1266: default:
1267: error = EINVAL;
1268: break;
1269: }
1270: bad:
1271: splx(s);
1272: return (error);
1273: }
1274: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.