Return to mp.c CVS log

Up to [Net/2] / Net2 / arch / tahoe / vba

Annotation of Net2/arch/tahoe/vba/mp.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.