![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba|
Return to mp.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba |
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: * Computer Consoles 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: * @(#)mp.c 7.15 (Berkeley) 6/28/90
24: */
25:
26: #include "mp.h"
27: #if NMP > 0
28: /*
29: * Multi Protocol Communications Controller (MPCC).
30: * Asynchronous Terminal Protocol Support.
31: */
32: #include "param.h"
33: #include "ioctl.h"
34: #include "tty.h"
35: #include "user.h"
36: #include "map.h"
37: #include "buf.h"
38: #include "conf.h"
39: #include "file.h"
40: #include "errno.h"
41: #include "syslog.h"
42: #include "vmmac.h"
43: #include "kernel.h"
44: #include "clist.h"
45:
46: #include "machine/pte.h"
47: #include "machine/mtpr.h"
48:
49: #include "../tahoevba/vbavar.h"
50: #include "../tahoevba/mpreg.h"
51:
52: #define MPCHUNK 16
53: #define MPPORT(n) ((n) & 0xf)
54: #define MPUNIT(n) ((n) >> 4)
55:
56: /*
57: * Driver information for auto-configuration stuff.
58: */
59: int mpprobe(), mpattach(), mpintr();
60: struct vba_device *mpinfo[NMP];
61: long mpstd[] = { 0 };
62: struct vba_driver mpdriver =
63: { mpprobe, 0, mpattach, 0, mpstd, "mp", mpinfo };
64:
65: int mpstart();
66: int mpparam();
67: struct mpevent *mpparam2();
68: struct mpevent *mp_getevent();
69:
70: /*
71: * The following structure is needed to deal with mpcc's convoluted
72: * method for locating it's mblok structures (hold your stomach).
73: * When an mpcc is reset at boot time it searches host memory
74: * looking for a string that says ``ThIs Is MpCc''. The mpcc
75: * then reads the structure to locate the pointer to it's mblok
76: * structure (you can wretch now).
77: */
78: struct mpbogus {
79: char s[12]; /* `ThIs Is MpCc'' */
80: u_char status;
81: u_char unused;
82: u_short magic;
83: struct mblok *mb;
84: struct mblok *mbloks[NMP]; /* can support at most 16 mpcc's */
85: } mpbogus = { 'T','h','I','s',' ','I','s',' ','M','p','C','c' };
86:
87: /*
88: * Software state per unit.
89: */
90: struct mpsoftc {
91: u_int ms_ivec; /* interrupt vector */
92: u_int ms_softCAR; /* software carrier for async */
93: struct mblok *ms_mb; /* mpcc status area */
94: struct vb_buf ms_buf; /* vba resources for ms_mb */
95: struct hxmtl ms_hxl[MPMAXPORT];/* host transmit list */
96: struct asyncparam ms_async[MPMAXPORT][MPINSET];/* async structs */
97: char ms_cbuf[MPMAXPORT][MPOUTSET][CBSIZE];/* input character buffers */
98: } mp_softc[NMP];
99:
100: struct speedtab
101: mpspeedtab[] = {
102: 9600, M9600, /* baud rate = 9600 */
103: 4800, M4800, /* baud rate = 4800 */
104: 2400, M2400, /* baud rate = 2400 */
105: 1800, M1800, /* baud rate = 1800 */
106: 1200, M1200, /* baud rate = 1200 */
107: 600, M600, /* baud rate = 600 */
108: 300, M300, /* baud rate = 300 */
109: 200, M200, /* baud rate = 200 */
110: 150, M150, /* baud rate = 150 */
111: 134, M134_5, /* baud rate = 134.5 */
112: 110, M110, /* baud rate = 110 */
113: 75, M75, /* baud rate = 75 */
114: 50, M50, /* baud rate = 50 */
115: 0, M0, /* baud rate = 0 */
116: 2000, M2000, /* baud rate = 2000 */
117: 3600, M3600, /* baud rate = 3600 */
118: 7200, M7200, /* baud rate = 7200 */
119: 19200, M19200, /* baud rate = 19,200 */
120: 24000, M24000, /* baud rate = 24,000 */
121: 28400, M28400, /* baud rate = 28,400 */
122: 37800, M37800, /* baud rate = 37,800 */
123: 40300, M40300, /* baud rate = 40,300 */
124: 48000, M48000, /* baud rate = 48,000 */
125: 52000, M52000, /* baud rate = 52,000 */
126: 56800, M56800, /* baud rate = 56,800 */
127: EXTA, MEXTA, /* baud rate = Ext A */
128: EXTB, MEXTB, /* baud rate = Ext B */
129: -1, -1,
130: };
131:
132: struct tty mp_tty[NMP*MPCHUNK];
133: #ifndef lint
134: int nmp = NMP*MPCHUNK;
135: #endif
136:
137: int ttrstrt();
138:
139: mpprobe(reg, vi)
140: caddr_t reg;
141: struct vba_device *vi;
142: {
143: register int br, cvec;
144: register struct mpsoftc *ms;
145:
146: #ifdef lint
147: br = 0; cvec = br; br = cvec;
148: mpintr(0);
149: mpdlintr(0);
150: #endif
151: if (badaddr(reg, 2))
152: return (0);
153: ms = &mp_softc[vi->ui_unit];
154: /*
155: * Allocate page tables and mblok
156: * structure (mblok in non-cached memory).
157: */
158: if (vbainit(&ms->ms_buf, sizeof (struct mblok), VB_32BIT) == 0) {
159: printf("mp%d: vbainit failed\n", vi->ui_unit);
160: return (0);
161: }
162: ms->ms_mb = (struct mblok *)ms->ms_buf.vb_rawbuf;
163: ms->ms_ivec = MPINTRBASE + 2*vi->ui_unit; /* XXX */
164: br = 0x14, cvec = ms->ms_ivec; /* XXX */
165: return (sizeof (*reg));
166: }
167:
168: mpattach(vi)
169: register struct vba_device *vi;
170: {
171: register struct mpsoftc *ms = &mp_softc[vi->ui_unit];
172:
173: ms->ms_softCAR = vi->ui_flags;
174: /*
175: * Setup pointer to mblok, initialize bogus
176: * status block used by mpcc to locate the pointer
177: * and then poke the mpcc to get it to search host
178: * memory to find mblok pointer.
179: */
180: mpbogus.mbloks[vi->ui_unit] = (struct mblok *)ms->ms_buf.vb_physbuf;
181: *(short *)vi->ui_addr = 0x100; /* magic */
182: }
183:
184: /*
185: * Open an mpcc port.
186: */
187: /* ARGSUSED */
188: mpopen(dev, mode)
189: dev_t dev;
190: {
191: register struct tty *tp;
192: register struct mpsoftc *ms;
193: int error, s, port, unit, mpu;
194: struct vba_device *vi;
195: struct mpport *mp;
196: struct mpevent *ev;
197:
198: unit = minor(dev);
199: mpu = MPUNIT(unit);
200: if (mpu >= NMP || (vi = mpinfo[mpu]) == 0 || vi->ui_alive == 0)
201: return (ENXIO);
202: tp = &mp_tty[unit];
203: if (tp->t_state & TS_XCLUDE && u.u_uid != 0)
204: return (EBUSY);
205: ms = &mp_softc[mpu];
206: port = MPPORT(unit);
207: if (ms->ms_mb->mb_proto[port] != MPPROTO_ASYNC ||
208: ms->ms_mb->mb_status != MP_OPOPEN)
209: return (ENXIO);
210: mp = &ms->ms_mb->mb_port[port]; /* host mpcc struct */
211: s = spl8();
212: /*
213: * serialize open and close events
214: */
215: while ((mp->mp_flags & MP_PROGRESS) || ((tp->t_state & TS_WOPEN) &&
216: !(mode&O_NONBLOCK) && !(tp->t_cflag&CLOCAL)))
217: if (error = tsleep((caddr_t)&tp->t_canq, TTIPRI | PCATCH,
218: ttopen, 0)) {
219: splx(s);
220: return (error);
221: }
222: restart:
223: tp->t_state |= TS_WOPEN;
224: tp->t_addr = (caddr_t)ms;
225: tp->t_oproc = mpstart;
226: tp->t_param = mpparam;
227: tp->t_dev = dev;
228: if ((tp->t_state & TS_ISOPEN) == 0) {
229: ttychars(tp);
230: if (tp->t_ispeed == 0) {
231: tp->t_ispeed = TTYDEF_SPEED;
232: tp->t_ospeed = TTYDEF_SPEED;
233: tp->t_iflag = TTYDEF_IFLAG;
234: tp->t_oflag = TTYDEF_OFLAG;
235: tp->t_lflag = TTYDEF_LFLAG;
236: tp->t_cflag = TTYDEF_CFLAG;
237: }
238: /*
239: * Initialize port state: init MPCC interface
240: * structures for port and setup modem control.
241: */
242: error = mpportinit(ms, mp, port);
243: if (error)
244: goto bad;
245: ev = mpparam2(tp, &tp->t_termios);
246: if (ev == 0) {
247: error = ENOBUFS;
248: goto bad;
249: }
250: mp->mp_flags |= MP_PROGRESS;
251: mpcmd(ev, EVCMD_OPEN, 0, ms->ms_mb, port);
252: /*
253: * wait for port to start
254: */
255: while (mp->mp_proto != MPPROTO_ASYNC)
256: if (error = tsleep((caddr_t)&tp->t_canq,
257: TTIPRI | PCATCH, ttopen, 0))
258: goto bad;
259: ttsetwater(tp);
260: mp->mp_flags &= ~MP_PROGRESS;
261: }
262: while ((mode&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 &&
263: (tp->t_state & TS_CARR_ON) == 0) {
264: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH,
265: ttopen, 0))
266: goto bad;
267: /*
268: * a mpclose() might have disabled port. if so restart
269: */
270: if (mp->mp_proto != MPPROTO_ASYNC)
271: goto restart;
272: tp->t_state |= TS_WOPEN;
273: }
274: error = (*linesw[tp->t_line].l_open)(dev,tp);
275: done:
276: splx(s);
277: /*
278: * wakeup those processes waiting for the open to complete
279: */
280: wakeup((caddr_t)&tp->t_canq);
281: return (error);
282: bad:
283: tp->t_state &= ~TS_WOPEN;
284: goto done;
285: }
286:
287: /*
288: * Close an mpcc port.
289: */
290: /* ARGSUSED */
291: mpclose(dev, flag)
292: dev_t dev;
293: {
294: register struct tty *tp;
295: register struct mpport *mp;
296: register struct mpevent *ev;
297: int s, port, unit, error = 0;
298: struct mblok *mb;
299:
300: unit = minor(dev);
301: tp = &mp_tty[unit];
302: port = MPPORT(unit);
303: mb = mp_softc[MPUNIT(unit)].ms_mb;
304: mp = &mb->mb_port[port];
305: s = spl8();
306: if (mp->mp_flags & MP_PROGRESS) {
307: if (mp->mp_flags & MP_REMBSY) {
308: mp->mp_flags &= ~MP_REMBSY;
309: splx(s);
310: return (0);
311: }
312: while (mp->mp_flags & MP_PROGRESS)
313: if (error = tsleep((caddr_t)&tp->t_canq,
314: TTIPRI | PCATCH, ttclos, 0)) {
315: splx(s);
316: return (error);
317: }
318: }
319: mp->mp_flags |= MP_PROGRESS;
320: (*linesw[tp->t_line].l_close)(tp);
321: ev = mp_getevent(mp, unit, 1);
322: if (ev == 0) {
323: error = ENOBUFS;
324: mp->mp_flags &= ~MP_PROGRESS;
325: goto out;
326: }
327: if (tp->t_state & TS_HUPCLS || (tp->t_state & TS_ISOPEN) == 0)
328: mpmodem(unit, MMOD_OFF);
329: else
330: mpmodem(unit, MMOD_ON);
331: mpcmd(ev, EVCMD_CLOSE, 0, mb, port);
332: error = ttyclose(tp);
333: out:
334: if (mp->mp_flags & MP_REMBSY)
335: mpclean(mb, port);
336: else
337: while (mp->mp_flags & MP_PROGRESS && error == 0)
338: error = tsleep((caddr_t)&tp->t_canq, TTIPRI | PCATCH,
339: ttclos, 0);
340: splx(s);
341: return (error);
342: }
343:
344: /*
345: * Read from an mpcc port.
346: */
347: mpread(dev, uio, flag)
348: dev_t dev;
349: struct uio *uio;
350: {
351: struct tty *tp;
352:
353: tp = &mp_tty[minor(dev)];
354: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
355: }
356:
357: /*
358: * Write to an mpcc port.
359: */
360: mpwrite(dev, uio, flag)
361: dev_t dev;
362: struct uio *uio;
363: {
364: struct tty *tp;
365:
366: tp = &mp_tty[minor(dev)];
367: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
368: }
369:
370: /*
371: * Ioctl for a mpcc port
372: */
373: mpioctl(dev, cmd, data, flag)
374: dev_t dev;
375: caddr_t data;
376: {
377: register struct tty *tp;
378: register struct mpsoftc *ms;
379: register struct mpport *mp;
380: register struct mpevent *ev;
381: int s, port, error, unit;
382: struct mblok *mb;
383:
384: unit = minor(dev);
385: tp = &mp_tty[unit];
386: ms = &mp_softc[MPUNIT(unit)];
387: mb = ms->ms_mb;
388: port = MPPORT(unit);
389: mp = &mb->mb_port[port];
390: if (mp->mp_proto != MPPROTO_ASYNC)
391: return(ENXIO);
392: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
393: if (error >= 0)
394: return (error);
395: error = ttioctl(tp, cmd, data, flag);
396: if (error >= 0)
397: return (error);
398: switch (cmd) {
399: case TIOCSBRK: /* send break */
400: case TIOCCBRK: /* clear break */
401: s = spl8();
402: while (mp->mp_flags & MP_IOCTL) {
403: if (error = tsleep((caddr_t)&tp->t_canq,
404: TTIPRI | PCATCH, ttyout, 0)) {
405: splx(s);
406: return (error);
407: }
408: if (mp->mp_proto != MPPROTO_ASYNC) {
409: splx(s);
410: return (ENXIO);
411: }
412: }
413: ev = mp_getevent(mp, unit, 0);
414: if (ev) {
415: mp->mp_flags |= MP_IOCTL;
416: mpcmd(ev, EVCMD_IOCTL,
417: (cmd == TIOCSBRK ? A_BRKON : A_BRKOFF), mb, port);
418: } else
419: error = ENOBUFS;
420: splx(s);
421: break;
422: case TIOCSDTR: /* set dtr control line */
423: break;
424: case TIOCCDTR: /* clear dtr control line */
425: break;
426: default:
427: error = ENOTTY;
428: break;
429: }
430: return (error);
431: }
432:
433: mpparam(tp, t)
434: struct tty *tp;
435: struct termios *t;
436: {
437: register struct mpevent *ev;
438: int unit = minor(tp->t_dev);
439: struct mpsoftc *ms = &mp_softc[MPUNIT(unit)];
440: struct mblok *mb = ms->ms_mb;
441:
442: ev = mpparam2(tp, t);
443: if (ev == 0)
444: return (ENOBUFS);
445: mpcmd(ev, EVCMD_IOCTL, A_CHGALL, mb, MPPORT(unit));
446: return (0);
447: }
448:
449: struct mpevent *
450: mpparam2(tp, t)
451: register struct tty *tp;
452: struct termios *t;
453: {
454: register struct mpevent *ev;
455: register struct mpport *mp;
456: int unit = minor(tp->t_dev);
457: struct mblok *mb;
458: struct mpsoftc *ms;
459: register struct asyncparam *asp;
460: int port, speedcode;
461:
462: ms = &mp_softc[MPUNIT(unit)];
463: mb = ms->ms_mb;
464: port = MPPORT(unit);
465: mp = &mb->mb_port[port];
466: ev = mp_getevent(mp, unit, 0); /* XXX */
467: speedcode = ttspeedtab(t->c_ospeed, mpspeedtab);
468: if (ev == 0 || speedcode < 0) {
469: printf("mp mpunit %d port %d param2 failed ev: %x speed %d, wanted %d\n",
470: MPUNIT(unit), port, ev, speedcode, t->c_ospeed);
471: return (0); /* XXX */
472: }
473: /* YUCK */
474: asp = &ms->ms_async[port][mp->mp_on?mp->mp_on-1:MPINSET-1];
475: asp->ap_xon = t->c_cc[VSTART];
476: asp->ap_xoff = t->c_cc[VSTOP];
477: if (!(t->c_iflag&IXON) || (asp->ap_xon == _POSIX_VDISABLE) ||
478: (asp->ap_xoff == _POSIX_VDISABLE))
479: asp->ap_xena = MPA_DIS;
480: else
481: asp->ap_xena = MPA_ENA;
482: asp->ap_xany = ((t->c_iflag & IXANY) ? MPA_ENA : MPA_DIS);
483: #ifdef notnow
484: if (t->t_cflag&CSIZE) == CS8) {
485: #endif
486: asp->ap_data = MPCHAR_8;
487: asp->ap_parity = MPPAR_NONE;
488: #ifdef notnow
489: } else {
490: asp->ap_data = MPCHAR_7;
491: if ((t->c_flags & (EVENP|ODDP)) == ODDP) /* XXX */
492: asp->ap_parity = MPPAR_ODD;
493: else
494: asp->ap_parity = MPPAR_EVEN;
495: }
496: #endif
497: asp->ap_loop = MPA_DIS; /* disable loopback */
498: asp->ap_rtimer = A_RCVTIM; /* default receive timer */
499: if (t->c_ospeed == B110)
500: asp->ap_stop = MPSTOP_2;
501: else
502: asp->ap_stop = MPSTOP_1;
503: if (t->c_ospeed == 0) {
504: tp->t_state |= TS_HUPCLS;
505: setm(&asp->ap_modem, 0, DROP);
506: seti(&asp->ap_intena, A_DCD);
507: return (ev);
508: }
509: if (t->c_ospeed == EXTA || t->c_ospeed == EXTB)
510: asp->ap_baud = M19200;
511: else
512: asp->ap_baud = speedcode;
513: if (1 || ms->ms_softCAR & (1<<port)) /* XXX HARDWIRE FOR NOW */
514: setm(&asp->ap_modem, A_DTR, ASSERT);
515: else
516: setm(&asp->ap_modem, A_DTR, AUTO);
517: seti(&asp->ap_intena, A_DCD);
518: return(ev);
519: }
520:
521: mpstart(tp)
522: register struct tty *tp;
523: {
524: register struct mpevent *ev;
525: register struct mpport *mp;
526: struct mblok *mb;
527: struct mpsoftc *ms;
528: int port, unit, xcnt, n, s, i;
529: struct hxmtl *hxp;
530: struct clist outq;
531:
532: s = spl8();
533: unit = minor(tp->t_dev);
534: ms = &mp_softc[MPUNIT(unit)];
535: mb = ms->ms_mb;
536: port = MPPORT(unit);
537: mp = &mb->mb_port[port];
538: hxp = &ms->ms_hxl[port];
539: xcnt = 0;
540: outq = tp->t_outq;
541: for (i = 0; i < MPXMIT; i++) {
542: if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
543: break;
544: if (outq.c_cc <= tp->t_lowat) {
545: if (tp->t_state & TS_ASLEEP) {
546: tp->t_state &= ~TS_ASLEEP;
547: wakeup((caddr_t)&tp->t_outq);
548: }
549: if (tp->t_wsel) {
550: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
551: tp->t_wsel = 0;
552: tp->t_state &= ~TS_WCOLL;
553: }
554: }
555: if (outq.c_cc == 0)
556: break;
557: /*
558: * If we're not currently busy outputting,
559: * and there is data to be output, set up
560: * port transmit structure to send to mpcc.
561: */
562: if (1) /* || tp->t_flags & (RAW|LITOUT)) XXX FIX */
563: n = ndqb(&outq, 0);
564: else {
565: n = ndqb(&outq, 0200);
566: if (n == 0) {
567: if (xcnt > 0)
568: break;
569: n = getc(&outq);
570: timeout(ttrstrt, (caddr_t)tp, (n&0177)+6);
571: tp->t_state |= TS_TIMEOUT;
572: break;
573: }
574: }
575: hxp->dblock[i] = (caddr_t)kvtophys(outq.c_cf);
576: hxp->size[i] = n;
577: xcnt++; /* count of xmts to send */
578: ndadvance(&outq, n);
579: }
580: /*
581: * If data to send, poke mpcc.
582: */
583: if (xcnt) {
584: ev = mp_getevent(mp, unit, 0);
585: if (ev == 0) {
586: tp->t_state &= ~(TS_BUSY|TS_TIMEOUT);
587: } else {
588: tp->t_state |= TS_BUSY;
589: ev->ev_count = xcnt;
590: mpcmd(ev, EVCMD_WRITE, 0, mb, MPPORT(unit));
591: }
592: }
593: splx(s);
594: }
595:
596: /*
597: * Advance cc bytes from q but don't free memory.
598: */
599: ndadvance(q, cc)
600: register struct clist *q;
601: register cc;
602: {
603: register struct cblock *bp;
604: char *end;
605: int rem, s;
606:
607: s = spltty();
608: if (q->c_cc <= 0)
609: goto out;
610: while (cc>0 && q->c_cc) {
611: bp = (struct cblock *)((int)q->c_cf & ~CROUND);
612: if ((int)bp == (((int)q->c_cl-1) & ~CROUND)) {
613: end = q->c_cl;
614: } else {
615: end = (char *)((int)bp + sizeof (struct cblock));
616: }
617: rem = end - q->c_cf;
618: if (cc >= rem) {
619: cc -= rem;
620: q->c_cc -= rem;
621: q->c_cf = bp->c_next->c_info;
622: } else {
623: q->c_cc -= cc;
624: q->c_cf += cc;
625: break;
626: }
627: }
628: if (q->c_cc <= 0) {
629: q->c_cf = q->c_cl = NULL;
630: q->c_cc = 0;
631: }
632: out:
633: splx(s);
634: }
635:
636: /*
637: * Stop output on a line, e.g. for ^S/^Q or output flush.
638: */
639: /* ARGSUSED */
640: mpstop(tp, rw)
641: register struct tty *tp;
642: int rw;
643: {
644: register struct mpport *mp;
645: register struct mpevent *ev;
646: int unit = minor(tp->t_dev);
647: int port;
648: struct mblok *mb;
649: int s;
650:
651: s = spl8();
652: if (tp->t_state & TS_BUSY) {
653: if ((tp->t_state & TS_TTSTOP) == 0) {
654: tp->t_state |= TS_FLUSH;
655: port = MPPORT(unit);
656: mb = mp_softc[MPUNIT(unit)].ms_mb;
657: mp = &mb->mb_port[port];
658: ev = mp_getevent(mp, unit, 0);
659: if (ev == 0) {
660: splx(s);
661: return;
662: }
663: mpcmd(ev, EVCMD_WRITE, A_FLUSH, mb, port);
664: }
665: }
666: splx(s);
667: }
668:
669: /*
670: * Initialize an async port's MPCC state.
671: */
672: mpportinit(ms, mp, port)
673: register struct mpsoftc *ms;
674: register struct mpport *mp;
675: int port;
676: {
677: register struct mpevent *ev;
678: register int i;
679: caddr_t ptr;
680:
681: mp->mp_on = mp->mp_off = 0;
682: mp->mp_nextrcv = 0;
683: mp->mp_flags = 0;
684: ev = &mp->mp_recvq[0];
685: for (i = 0; ev < &mp->mp_recvq[MPINSET]; ev++, i++) {
686: ev->ev_status = EVSTATUS_FREE;
687: ev->ev_cmd = 0;
688: ev->ev_opts = 0;
689: ev->ev_error = 0;
690: ev->ev_flags = 0;
691: ev->ev_count = 0;
692: ev->ev_un.hxl = (struct hxmtl *) kvtophys(&ms->ms_hxl[port]);
693: ev->ev_params = (caddr_t) kvtophys(&ms->ms_async[port][i]);
694: }
695: ev = &mp->mp_sendq[0];
696: for (i = 0; ev < &mp->mp_sendq[MPOUTSET]; ev++, i++) {
697: /* init so that L2 can't send any events */
698: /* to host until open has completed */
699: ev->ev_status = EVSTATUS_FREE;
700: ev->ev_cmd = 0;
701: ev->ev_opts = 0;
702: ev->ev_error = 0;
703: ev->ev_flags = 0;
704: ev->ev_count = 0;
705: ptr = (caddr_t) &ms->ms_cbuf[port][i][0];
706: ev->ev_un.rcvblk = (u_char *)kvtophys(ptr);
707: ev->ev_params = (caddr_t) kvtophys(ptr);
708: }
709: return (0);
710: }
711:
712: /*
713: * Send an event to an mpcc.
714: */
715: mpcmd(ev, cmd, flags, mb, port)
716: register struct mpevent *ev;
717: struct mblok *mb;
718: {
719: int s;
720:
721: s = spl8();
722: /* move host values to inbound entry */
723: ev->ev_cmd = cmd;
724: ev->ev_opts = flags;
725: /* show event ready for mpcc */
726: ev->ev_status = EVSTATUS_GO;
727: mpintmpcc(mb, port);
728: splx(s);
729: }
730:
731: /*
732: * Return the next available event entry for the indicated port.
733: */
734: struct mpevent *
735: mp_getevent(mp, unit, cls_req)
736: register struct mpport *mp;
737: int unit;
738: int cls_req;
739: {
740: register struct mpevent *ev;
741: int i, s;
742:
743: s = spl8();
744: ev = &mp->mp_recvq[mp->mp_on];
745: if (ev->ev_status != EVSTATUS_FREE)
746: goto bad;
747: /*
748: * If not a close request, verify one extra
749: * event is available for closing the port.
750: */
751: if (!cls_req) {
752: if ((i = mp->mp_on + 1) >= MPINSET)
753: i = 0;
754: if (mp->mp_recvq[i].ev_status != EVSTATUS_FREE)
755: goto bad;
756: }
757: /* init inbound fields marking this entry as busy */
758: ev->ev_cmd = 0;
759: ev->ev_opts = 0;
760: ev->ev_error = 0;
761: ev->ev_flags = 0;
762: ev->ev_count = 0;
763: ev->ev_status = EVSTATUS_BUSY;
764: /* adjust pointer to next available inbound entry */
765: adjptr(mp->mp_on, MPINSET);
766: splx(s);
767: return (ev);
768: bad:
769: splx(s);
770: log(LOG_ERR, "mp%d: port%d, out of events\n",
771: MPUNIT(unit), MPPORT(unit));
772: return ((struct mpevent *)0);
773: }
774:
775: mpmodem(unit, flag)
776: int unit, flag;
777: {
778: struct mpsoftc *ms = &mp_softc[MPUNIT(unit)];
779: int port = MPPORT(unit);
780: register struct mpport *mp;
781: register struct asyncparam *asp;
782:
783: mp = &ms->ms_mb->mb_port[port];
784: asp = &ms->ms_async[port][mp->mp_on?mp->mp_on-1:MPINSET-1];
785: if (flag == MMOD_ON) {
786: if (1 || ms->ms_softCAR & (1 << port))/* XXX HARDWIRE FOR NOW */
787: setm(&asp->ap_modem, A_DTR, ASSERT);
788: else
789: setm(&asp->ap_modem, A_DTR, AUTO);
790: seti(&asp->ap_intena, A_DCD);
791: } else {
792: setm(&asp->ap_modem, 0, DROP);
793: seti(&asp->ap_intena, 0);
794: }
795: }
796:
797: /*
798: * Set up the modem control structure according to mask.
799: * Each set bit in the mask means assert the corresponding
800: * modem control line, otherwise, it will be dropped.
801: * RTS is special since it can either be asserted, dropped
802: * or put in auto mode for auto modem control.
803: */
804: static
805: setm(mc, mask, rts)
806: register struct mdmctl *mc;
807: register int mask;
808: {
809:
810: mc->mc_rngdsr = (mask & A_RNGDSR) ? ASSERT : DROP;
811: mc->mc_rate = (mask & A_RATE) ? ASSERT : DROP;
812: mc->mc_dcd = (mask & A_DCD) ? ASSERT : DROP;
813: mc->mc_sectx = (mask & A_SECTX) ? ASSERT : DROP;
814: mc->mc_cts = (mask & A_CTS) ? ASSERT : DROP;
815: mc->mc_secrx = (mask & A_SECRX) ? ASSERT : DROP;
816: mc->mc_dtr = (mask & A_DTR) ? ASSERT : DROP;
817: mc->mc_rts = rts;
818: }
819:
820: /*
821: * Set up the status change enable field from mask.
822: * When a signal is enabled in this structure and
823: * and a change in state on a corresponding modem
824: * control line occurs, a status change event will
825: * be delivered to the host.
826: */
827: static
828: seti(mc, mask)
829: register struct mdmctl *mc;
830: register int mask;
831: {
832:
833: mc->mc_rngdsr = (mask & A_RNGDSR) ? MDM_ON : MDM_OFF;
834: mc->mc_rate = (mask & A_RATE) ? MDM_ON : MDM_OFF;
835: mc->mc_dcd = (mask & A_DCD) ? MDM_ON : MDM_OFF;
836: mc->mc_sectx = (mask & A_SECTX) ? MDM_ON : MDM_OFF;
837: mc->mc_cts = (mask & A_CTS) ? MDM_ON : MDM_OFF;
838: mc->mc_secrx = (mask & A_SECRX) ? MDM_ON : MDM_OFF;
839: mc->mc_dtr = (mask & A_DTR) ? MDM_ON : MDM_OFF;
840: mc->mc_rts = (mask & A_RTS) ? MDM_ON : MDM_OFF;
841: }
842:
843: mpcleanport(mb, port)
844: struct mblok *mb;
845: int port;
846: {
847: register struct mpport *mp;
848: register struct tty *tp;
849:
850: mp = &mb->mb_port[port];
851: if (mp->mp_proto == MPPROTO_ASYNC) {
852: mp->mp_flags = MP_REMBSY;
853: /* signal loss of carrier and close */
854: tp = &mp_tty[mb->mb_unit*MPCHUNK+port];
855: ttyflush(tp, FREAD|FWRITE);
856: (void) (*linesw[tp->t_line].l_modem)(tp, 0);
857: }
858: }
859:
860: mpclean(mb, port)
861: register struct mblok *mb;
862: int port;
863: {
864: register struct mpport *mp;
865: register struct mpevent *ev;
866: register int i;
867: u_char list[2];
868: int unit;
869:
870: mp = &mb->mb_port[port];
871: unit = mb->mb_unit;
872: for (i = mp->mp_off; i != mp->mp_on; i = (i+1 % MPINSET)) {
873: ev = &mp->mp_recvq[i];
874: ev->ev_error = ENXIO;
875: ev->ev_status = EVSTATUS_DONE;
876: }
877: list[0] = port, list[1] = MPPORT_EOL;
878: mpxintr(unit, list);
879: mprintr(unit, list);
880: /* Clear async for port */
881: mp->mp_proto = MPPROTO_UNUSED;
882: mp->mp_flags = 0;
883: mp->mp_on = 0;
884: mp->mp_off = 0;
885: mp->mp_nextrcv = 0;
886:
887: mp_tty[unit*MPCHUNK + port].t_state = 0;
888: for (ev = &mp->mp_sendq[0]; ev < &mp->mp_sendq[MPOUTSET]; ev++) {
889: ev->ev_status = EVSTATUS_FREE;
890: ev->ev_cmd = 0;
891: ev->ev_error = 0;
892: ev->ev_un.rcvblk = 0;
893: ev->ev_params = 0;
894: }
895: for (ev = &mp->mp_recvq[0]; ev < &mp->mp_recvq[MPINSET]; ev++) {
896: ev->ev_status = EVSTATUS_FREE;
897: ev->ev_cmd = 0;
898: ev->ev_error = 0;
899: ev->ev_params = 0;
900: }
901: }
902:
903: /*
904: * MPCC interrupt handler.
905: */
906: mpintr(mpcc)
907: int mpcc;
908: {
909: register struct mblok *mb;
910: register struct his *his;
911:
912: mb = mp_softc[mpcc].ms_mb;
913: if (mb == 0) {
914: printf("mp%d: stray interrupt\n", mpcc);
915: return;
916: }
917: his = &mb->mb_hostint;
918: his->semaphore &= ~MPSEMA_AVAILABLE;
919: /*
920: * Check for events to be processed.
921: */
922: if (his->proto[MPPROTO_ASYNC].outbdone[0] != MPPORT_EOL)
923: mprintr(mpcc, his->proto[MPPROTO_ASYNC].outbdone);
924: if (his->proto[MPPROTO_ASYNC].inbdone[0] != MPPORT_EOL)
925: mpxintr(mpcc, his->proto[MPPROTO_ASYNC].inbdone);
926: if (mb->mb_harderr || mb->mb_softerr)
927: mperror(mb, mpcc);
928: his->semaphore |= MPSEMA_AVAILABLE;
929: }
930:
931: /*
932: * Handler for processing completion of transmitted events.
933: */
934: mpxintr(unit, list)
935: register u_char *list;
936: {
937: register struct mpport *mp;
938: register struct mpevent *ev;
939: register struct mblok *mb;
940: register struct tty *tp;
941: register struct asyncparam *ap;
942: struct mpsoftc *ms;
943: int port, i, j;
944: # define nextevent(mp) &mp->mp_recvq[mp->mp_off]
945:
946: ms = &mp_softc[unit];
947: mb = mp_softc[unit].ms_mb;
948: for (j = 0; j < MPMAXPORT && ((port = *list++) != MPPORT_EOL); j++) {
949: /*
950: * Process each completed entry in the inbound queue.
951: */
952: mp = &mb->mb_port[port];
953: tp = &mp_tty[unit*MPCHUNK + port];
954: ev = nextevent(mp);
955: for (; ev->ev_status & EVSTATUS_DONE; ev = nextevent(mp)) {
956: /* YUCK */
957: ap = &ms->ms_async[port][mp->mp_off];
958: mppurge((caddr_t)ap, (int)sizeof (*ap));
959: switch (ev->ev_cmd) {
960: case EVCMD_OPEN:
961: /*
962: * Open completion, start all reads and
963: * assert modem status information.
964: */
965: for (i = 0; i < MPOUTSET; i++)
966: mp->mp_sendq[i].ev_status = EVSTATUS_GO;
967: (*linesw[tp->t_line].l_modem)
968: (tp, ap->ap_modem.mc_dcd == ASSERT);
969: mp_freein(ev);
970: adjptr(mp->mp_off, MPINSET);
971: mp->mp_proto = MPPROTO_ASYNC; /* XXX */
972: wakeup((caddr_t)&tp->t_canq);
973: break;
974: case EVCMD_CLOSE:
975: /*
976: * Close completion, flush all pending
977: * transmissions, free resources, and
978: * cleanup mpcc port state.
979: */
980: for (i = 0; i < MPOUTSET; i++) {
981: mp->mp_sendq[i].ev_status =
982: EVSTATUS_FREE;
983: mp->mp_sendq[i].ev_un.rcvblk = 0;
984: mp->mp_sendq[i].ev_params = 0;
985: }
986: mp_freein(ev);
987: adjptr(mp->mp_off, MPINSET);
988: tp->t_state &= ~(TS_CARR_ON|TS_BUSY|TS_FLUSH);
989: mp->mp_on = mp->mp_off = mp->mp_nextrcv = 0;
990: mp->mp_flags &= ~MP_PROGRESS;
991: mp->mp_proto = MPPROTO_UNUSED;
992: wakeup((caddr_t)&tp->t_canq);
993: break;
994: case EVCMD_IOCTL:
995: mp_freein(ev);
996: adjptr(mp->mp_off, MPINSET);
997: mp->mp_flags &= ~MP_IOCTL;
998: wakeup((caddr_t)&tp->t_canq);
999: break;
1000: case EVCMD_WRITE:
1001: /*
1002: * Transmission completed, update tty
1003: * state and restart output.
1004: */
1005: if (ev->ev_opts != A_FLUSH) {
1006: tp->t_state &= ~TS_BUSY;
1007: if (tp->t_state & TS_FLUSH)
1008: tp->t_state &= ~TS_FLUSH;
1009: else {
1010: register int cc = 0, n;
1011: struct hxmtl *hxp;
1012:
1013: hxp = &ms->ms_hxl[port];
1014: for (n=0;n < ev->ev_count; n++)
1015: cc += hxp->size[n];
1016: ndflush(&tp->t_outq, cc);
1017: }
1018: }
1019: switch (ev->ev_error) {
1020: case A_SIZERR: /*# error in xmt data size */
1021: mplog(unit, port, A_XSIZE, 0);
1022: break;
1023: case A_NXBERR: /*# no more xmt evt buffers */
1024: mplog(unit, port, A_NOXBUF, 0);
1025: break;
1026: }
1027: mp_freein(ev);
1028: adjptr(mp->mp_off, MPINSET);
1029: mpstart(tp);
1030: break;
1031: default:
1032: mplog(unit, port, A_INVCMD, (int)ev->ev_cmd);
1033: mp_freein(ev);
1034: adjptr(mp->mp_off, MPINSET);
1035: break;
1036: }
1037: }
1038: }
1039: #undef nextevent
1040: }
1041:
1042: mp_freein(ev)
1043: register struct mpevent *ev;
1044: {
1045: /* re-init all values in this entry */
1046: ev->ev_cmd = 0;
1047: ev->ev_opts = 0;
1048: ev->ev_error = 0;
1049: ev->ev_flags = 0;
1050: ev->ev_count = 0;
1051: /* show this entry is available for use */
1052: ev->ev_status = EVSTATUS_FREE;
1053: }
1054:
1055: /*
1056: * Handler for processing received events.
1057: */
1058: mprintr(unit, list)
1059: u_char *list;
1060: {
1061: register struct tty *tp;
1062: register struct mpport *mp;
1063: register struct mpevent *ev;
1064: struct mblok *mb;
1065: register int cc;
1066: register char *cp;
1067: struct mpsoftc *ms;
1068: caddr_t ptr;
1069: char *rcverr;
1070: int port, i;
1071:
1072: ms = &mp_softc[unit];
1073: mb = mp_softc[unit].ms_mb;
1074: for (i = 0; i < MPMAXPORT && (port = *list++) != MPPORT_EOL; i++) {
1075: tp = &mp_tty[unit*MPCHUNK + port];
1076: mp = &mb->mb_port[port];
1077: ev = &mp->mp_sendq[mp->mp_nextrcv];
1078: while (ev->ev_status & EVSTATUS_DONE) {
1079: switch(ev->ev_cmd) {
1080: case EVCMD_STATUS:
1081: /*
1082: * Status change, look for carrier changes.
1083: */
1084: switch(ev->ev_opts) {
1085: case DCDASRT:
1086: (*linesw[tp->t_line].l_modem)(tp, 1);
1087: wakeup((caddr_t)&tp->t_canq);
1088: break;
1089: case DCDDROP:
1090: (*linesw[tp->t_line].l_modem)(tp, 0);
1091: wakeup((caddr_t)&tp->t_canq);
1092: break;
1093: case NORBUF:
1094: case NOEBUF:
1095: mplog(unit, port,
1096: "out of receive events", 0);
1097: break;
1098: default:
1099: mplog(unit, port,
1100: "unexpect status command",
1101: (int)ev->ev_opts);
1102: break;
1103: }
1104: break;
1105: case EVCMD_READ:
1106: /*
1107: * Process received data.
1108: */
1109: if ((tp->t_state & TS_ISOPEN) == 0) {
1110: wakeup((caddr_t)&tp->t_rawq);
1111: break;
1112: }
1113: if ((cc = ev->ev_count) == 0)
1114: break;
1115: cp = ms->ms_cbuf[port][mp->mp_nextrcv];
1116: mppurge(cp, CBSIZE);
1117: while (cc-- > 0) {
1118: /*
1119: * A null character is inserted,
1120: * potentially when a break or framing
1121: * error occurs. If we're not in raw
1122: * mode, substitute the interrupt
1123: * character.
1124: */
1125: /*** XXX - FIXUP ***/
1126: if (*cp == 0 &&
1127: (ev->ev_error == BRKASRT ||
1128: ev->ev_error == FRAMERR))
1129: if ((tp->t_flags&RAW) == 0)
1130: ;
1131: /* XXX was break */
1132: (*linesw[tp->t_line].l_rint)(*cp++, tp);
1133: }
1134: /* setup for next read */
1135: ptr = (caddr_t)&mp_softc[unit].ms_cbuf[port][mp->mp_nextrcv][0];
1136: ev->ev_un.rcvblk = (u_char *)kvtophys(ptr);
1137: ev->ev_params = (caddr_t) kvtophys(ptr);
1138: switch(ev->ev_error) {
1139: case RCVDTA:
1140: /* Normal (good) rcv data do not
1141: * report the following they are
1142: * "normal" errors
1143: */
1144: case FRAMERR:
1145: /* frame error */
1146: case BRKASRT:
1147: /* Break condition */
1148: case PARERR:
1149: /* parity error */
1150: rcverr = (char *)0;
1151: break;
1152: case OVRNERR:
1153: /* Overrun error */
1154: rcverr = "overrun error";
1155: break;
1156: case OVFERR:
1157: /* Overflow error */
1158: rcverr = "overflow error";
1159: break;
1160: default:
1161: rcverr = "undefined rcv error";
1162: break;
1163: }
1164: if (rcverr != (char *)0)
1165: mplog(unit, port, rcverr,
1166: (int)ev->ev_error);
1167: break;
1168: default:
1169: mplog(unit, port, "unexpected command",
1170: (int)ev->ev_cmd);
1171: break;
1172: }
1173: ev->ev_cmd = 0;
1174: ev->ev_opts = 0;
1175: ev->ev_error = 0;
1176: ev->ev_flags = 0;
1177: ev->ev_count = 0;
1178: ev->ev_status = EVSTATUS_GO; /* start next read */
1179: adjptr(mp->mp_nextrcv, MPOUTSET);
1180: ev = &mp->mp_sendq[mp->mp_nextrcv];
1181: }
1182: }
1183: }
1184:
1185: /*
1186: * Log an mpcc diagnostic.
1187: */
1188: mplog(unit, port, cp, flags)
1189: char *cp;
1190: {
1191:
1192: if (flags)
1193: log(LOG_ERR, "mp%d: port%d, %s (%d)\n",
1194: unit, port, cp, flags);
1195: else
1196: log(LOG_ERR, "mp%d: port%d, %s\n", unit, port, cp);
1197: }
1198:
1199: int MPHOSTINT = 1;
1200:
1201: mptimeint(mb)
1202: register struct mblok *mb;
1203: {
1204:
1205: mb->mb_mpintcnt = 0;
1206: mb->mb_mpintclk = (caddr_t)0;
1207: *(u_short *)mpinfo[mb->mb_unit]->ui_addr = 2;
1208: }
1209:
1210: /*
1211: * Interupt mpcc
1212: */
1213: mpintmpcc(mb, port)
1214: register struct mblok *mb;
1215: {
1216:
1217: mb->mb_intr[port] |= MPSEMA_WORK;
1218: if (++mb->mb_mpintcnt == MPHOSTINT) {
1219: mb->mb_mpintcnt = 0;
1220: *(u_short *)mpinfo[mb->mb_unit]->ui_addr = 2;
1221: if (mb->mb_mpintclk) {
1222: untimeout(mptimeint, (caddr_t)mb);
1223: mb->mb_mpintclk = 0;
1224: }
1225: } else {
1226: if (mb->mb_mpintclk == 0) {
1227: timeout(mptimeint, (caddr_t)mb, 4);
1228: mb->mb_mpintclk = (caddr_t)1;
1229: }
1230: }
1231: }
1232:
1233: static char *mpherrmsg[] = {
1234: "",
1235: "Bus error", /* MPBUSERR */
1236: "Address error", /* ADDRERR */
1237: "Undefined ecc interrupt", /* UNDECC */
1238: "Undefined interrupt", /* UNDINT */
1239: "Power failure occurred", /* PWRFL */
1240: "Stray transmit done interrupt", /* NOXENTRY */
1241: "Two fast timers on one port", /* TWOFTMRS */
1242: "Interrupt queue full", /* INTQFULL */
1243: "Interrupt queue ack error", /* INTQERR */
1244: "Uncorrectable dma parity error", /* CBPERR */
1245: "32 port ACAP failed power up", /* ACPDEAD */
1246: };
1247: #define NHERRS (sizeof (mpherrmsg) / sizeof (mpherrmsg[0]))
1248:
1249: mperror(mb, unit)
1250: register struct mblok *mb;
1251: int unit;
1252: {
1253: register char *cp;
1254: register int i;
1255:
1256: if (mb->mb_softerr) {
1257: switch (mb->mb_softerr) {
1258: case DMAPERR: /* dma parity error */
1259: cp = "dma parity error";
1260: break;
1261: case ECCERR:
1262: cp = "local memory ecc error";
1263: break;
1264: default:
1265: cp = "unknown error";
1266: break;
1267: }
1268: log(LOG_ERR, "mp%d: soft error, %s", unit, cp);
1269: mb->mb_softerr = 0;
1270: }
1271: if (mb->mb_harderr) {
1272: if (mb->mb_harderr < NHERRS)
1273: cp = mpherrmsg[mb->mb_harderr];
1274: else
1275: cp = "unknown error";
1276: log(LOG_ERR, "mp%d: hard error, %s", unit, cp);
1277: if (mb->mb_status == MP_OPOPEN) {
1278: for (i = 0; i < MPMAXPORT; i++) {
1279: mpcleanport(mb, i);
1280: mb->mb_proto[i] = MPPROTO_UNUSED;
1281: }
1282: }
1283: mb->mb_harderr = 0;
1284: mb->mb_status = 0;
1285: }
1286: }
1287:
1288: mppurge(addr, cc)
1289: register caddr_t addr;
1290: register int cc;
1291: {
1292:
1293: for (; cc >= 0; addr += NBPG, cc -= NBPG)
1294: mtpr(P1DC, addr);
1295: }
1296:
1297: /*
1298: * MPCC Download Pseudo-device.
1299: */
1300: char mpdlbuf[MPDLBUFSIZE];
1301: int mpdlbusy; /* interlock on download buffer */
1302: int mpdlerr;
1303:
1304: mpdlopen(dev)
1305: dev_t dev;
1306: {
1307: int unit, mpu;
1308: struct vba_device *vi;
1309:
1310: unit = minor(dev);
1311: mpu = MPUNIT(unit);
1312: if (mpu >= NMP || (vi = mpinfo[mpu]) == 0 || vi->ui_alive == 0)
1313: return (ENODEV);
1314: return (0);
1315: }
1316:
1317: mpdlwrite(dev, uio)
1318: dev_t dev;
1319: struct uio *uio;
1320: {
1321: register struct mpsoftc *ms = &mp_softc[MPUNIT(minor(dev))];
1322: register struct mpdl *dl;
1323: int error;
1324:
1325: if (ms->ms_mb == 0 || ms->ms_mb->mb_status != MP_DLOPEN)
1326: return (EFAULT);
1327: dl = &ms->ms_mb->mb_dl;
1328: dl->mpdl_count = uio->uio_iov->iov_len;
1329: dl->mpdl_data = (caddr_t) kvtophys(mpdlbuf);
1330: if (error = uiomove(mpdlbuf, (int)dl->mpdl_count, uio))
1331: return (error);
1332: uio->uio_resid -= dl->mpdl_count; /* set up return from write */
1333: dl->mpdl_cmd = MPDLCMD_NORMAL;
1334: error = mpdlwait(dl);
1335: return (error);
1336: }
1337:
1338: mpdlclose(dev)
1339: dev_t dev;
1340: {
1341: register struct mblok *mb = mp_softc[MPUNIT(minor(dev))].ms_mb;
1342:
1343: if (mb == 0 || mb->mb_status != MP_DLDONE) {
1344: mpbogus.status = 0;
1345: if (mpbogus.mb == mpbogus.mbloks[MPUNIT(minor(dev))])
1346: mpdlbusy--;
1347: return (EEXIST);
1348: }
1349: mb->mb_status = MP_OPOPEN;
1350: mpbogus.status = 0;
1351: /* set to dead, for board handshake */
1352: mb->mb_hostint.imok = MPIMOK_DEAD;
1353: return (0);
1354: }
1355:
1356: /* ARGSUSED */
1357: mpdlioctl(dev, cmd, data, flag)
1358: dev_t dev;
1359: caddr_t data;
1360: {
1361: register struct mblok *mb;
1362: register struct mpdl *dl;
1363: int unit, error = 0, s, i;
1364:
1365: mb = mp_softc[unit=MPUNIT(minor(dev))].ms_mb;
1366: if (mb == 0)
1367: return (EEXIST);
1368: dl = &mb->mb_dl;
1369: error = 0;
1370: switch (cmd) {
1371: case MPIOPORTMAP:
1372: bcopy(data, (caddr_t)mb->mb_proto, sizeof (mb->mb_proto));
1373: break;
1374: case MPIOHILO:
1375: bcopy(data, (caddr_t)&mb->mb_hiport, 2*(sizeof(mb->mb_hiport)));
1376: break;
1377: case MPIOENDDL:
1378: dl->mpdl_count = 0;
1379: dl->mpdl_data = 0;
1380: dl->mpdl_cmd = MPIOENDDL&IOCPARM_MASK;
1381: error = mpdlwait(dl);
1382: mpccinit(unit);
1383: mb->mb_status = MP_DLDONE;
1384: mpdlbusy--;
1385: break;
1386: case MPIOENDCODE:
1387: dl->mpdl_count = 0;
1388: dl->mpdl_data = 0;
1389: dl->mpdl_cmd = MPIOENDCODE&IOCPARM_MASK;
1390: error = mpdlwait(dl);
1391: break;
1392: case MPIOASYNCNF:
1393: bcopy(data, mpdlbuf, sizeof (struct abdcf));
1394: dl->mpdl_data = (caddr_t) kvtophys(mpdlbuf);
1395: dl->mpdl_count = sizeof (struct abdcf);
1396: dl->mpdl_cmd = MPIOASYNCNF&IOCPARM_MASK;
1397: error = mpdlwait(dl);
1398: break;
1399: case MPIOSTARTDL:
1400: s = spl8();
1401: while (mpdlbusy)
1402: if (error = tsleep((caddr_t)&mpdlbusy,
1403: (PZERO+1) | PCATCH, devioc, 0))
1404: break;
1405: splx(s);
1406: if (error)
1407: break;
1408: mpdlbusy++;
1409: /* initialize the downloading interface */
1410: mpbogus.magic = MPMAGIC;
1411: mpbogus.mb = mpbogus.mbloks[unit];
1412: mpbogus.status = 1;
1413: dl->mpdl_status = EVSTATUS_FREE;
1414: dl->mpdl_count = 0;
1415: dl->mpdl_cmd = 0;
1416: dl->mpdl_data = (char *) 0;
1417: mpdlerr = 0;
1418: mb->mb_magic = MPMAGIC;
1419: mb->mb_ivec = mp_softc[unit].ms_ivec+1; /* download vector */
1420: mb->mb_status = MP_DLPEND;
1421: mb->mb_diagswitch[0] = 'A';
1422: mb->mb_diagswitch[1] = 'P';
1423: s = spl8();
1424: *(u_short *)mpinfo[unit]->ui_addr = 2;
1425: error = tsleep((caddr_t)&mb->mb_status, (PZERO+1) | PCATCH,
1426: devio, 30*hz);
1427: splx(s);
1428: if (error == EWOULDBLOCK)
1429: error = ETIMEDOUT;
1430: if (error)
1431: mpbogus.status = 0;
1432: bzero((caddr_t)mb->mb_port, sizeof (mb->mb_port));
1433: break;
1434: case MPIORESETBOARD:
1435: s = spl8();
1436: if (mb->mb_imokclk)
1437: mb->mb_imokclk = 0;
1438: *(u_short *)mpinfo[unit]->ui_addr = 0x100;
1439: if (mb->mb_status == MP_DLOPEN || mb->mb_status == MP_DLDONE) {
1440: mpdlerr = MP_DLERROR;
1441: dl->mpdl_status = EVSTATUS_FREE;
1442: wakeup((caddr_t)&dl->mpdl_status);
1443: mpbogus.status = 0;
1444: }
1445: for (i = 0; i < MPMAXPORT; i++) {
1446: if (mb->mb_harderr || mb->mb_softerr)
1447: mperror(mb, i);
1448: mpcleanport(mb, i);
1449: mb->mb_proto[i] = MPPROTO_UNUSED;
1450: }
1451: mb->mb_status = 0;
1452: splx(s);
1453: break;
1454: default:
1455: error = EINVAL;
1456: break;
1457: }
1458: return (error);
1459: }
1460:
1461: mpccinit(unit)
1462: int unit;
1463: {
1464: register struct mblok *mb = mp_softc[unit].ms_mb;
1465: register struct his *his;
1466: register int i, j;
1467:
1468: mb->mb_status = MP_DLDONE;
1469: mb->mb_ivec = mp_softc[unit].ms_ivec;
1470: mb->mb_magic = MPMAGIC;
1471: /* Init host interface structure */
1472: his = &mb->mb_hostint;
1473: his->semaphore = MPSEMA_AVAILABLE;
1474: for (i = 0; i < NMPPROTO; i++)
1475: for (j = 0; j < MPMAXPORT; j++) {
1476: his->proto[i].inbdone[j] = MPPORT_EOL;
1477: his->proto[i].outbdone[j] = MPPORT_EOL;
1478: }
1479: mb->mb_unit = unit;
1480: }
1481:
1482: mpdlintr(mpcc)
1483: int mpcc;
1484: {
1485: register struct mblok *mb;
1486: register struct mpdl *dl;
1487:
1488: mb = mp_softc[mpcc].ms_mb;
1489: if (mb == 0) {
1490: printf("mp%d: stray download interrupt\n", mpcc);
1491: return;
1492: }
1493: dl = &mb->mb_dl;
1494: switch (mb->mb_status) {
1495: case MP_DLOPEN:
1496: if (dl->mpdl_status != EVSTATUS_DONE)
1497: mpdlerr = MP_DLERROR;
1498: dl->mpdl_status = EVSTATUS_FREE;
1499: wakeup((caddr_t)&dl->mpdl_status);
1500: return;
1501: case MP_DLPEND:
1502: mb->mb_status = MP_DLOPEN;
1503: wakeup((caddr_t)&mb->mb_status);
1504: /* fall thru... */
1505: case MP_DLTIME:
1506: return;
1507: case MP_OPOPEN:
1508: if (mb->mb_imokclk)
1509: mb->mb_imokclk = 0;
1510: mb->mb_nointcnt = 0; /* reset no interrupt count */
1511: mb->mb_hostint.imok = MPIMOK_DEAD;
1512: mb->mb_imokclk = (caddr_t)1;
1513: break;
1514: default:
1515: log(LOG_ERR, "mp%d: mpdlintr, status %x\n",
1516: mpcc, mb->mb_status);
1517: break;
1518: }
1519: }
1520:
1521: /*
1522: * Wait for a transfer to complete or a timeout to occur.
1523: */
1524: mpdlwait(dl)
1525: register struct mpdl *dl;
1526: {
1527: int s, error = 0;
1528:
1529: s = spl8();
1530: dl->mpdl_status = EVSTATUS_GO;
1531: while (dl->mpdl_status != EVSTATUS_FREE) {
1532: error = tsleep((caddr_t)&dl->mpdl_status, (PZERO+1) | PCATCH,
1533: devout, 0);
1534: if (mpdlerr == MP_DLERROR)
1535: error = EIO;
1536: if (error)
1537: break;
1538: }
1539: splx(s);
1540: return (error);
1541: }
1542: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.