Return to np.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / np100

Annotation of 43BSD/contrib/np100/np.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1986 MICOM-Interlan, Inc., Boxborough Mass
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)np.c        7.1 (Berkeley) 6/5/86
        !             7:  */
        !             8: 
        !             9:                /******************************************
        !            10:                *                                         *
        !            11:                *               NPDRIVER                  *
        !            12:                *                                         *
        !            13:                ******************************************/
        !            14: 
        !            15: /*
        !            16:  * The NP Driver is used to route requests, independent of protocol type,
        !            17:  * to the NP series Intelligent Board. The facilities it provides are
        !            18:  * used for board maintainance by the superuser and by protocol pseudo-drivers, 
        !            19:  * such as WN, for sending requests to a board. The board maintainance and
        !            20:  * control functions are accessed via npioctl() by the NP support utilities.
        !            21:  */
        !            22: 
        !            23: 
        !            24: /*
        !            25:  * Include Files
        !            26:  */
        !            27: 
        !            28: #include "np.h"
        !            29: #if NNP > 0
        !            30: #include "param.h"
        !            31: #include "buf.h"
        !            32: #include "signal.h"
        !            33: #include "systm.h"
        !            34: #include "dir.h"
        !            35: #include "user.h"
        !            36: #include "proc.h"
        !            37: #include "uio.h"
        !            38: #include "errno.h"
        !            39: 
        !            40: #include "../vaxuba/ubavar.h"
        !            41: #include "../vaxuba/npreg.h"
        !            42: 
        !            43: /*
        !            44:  * Global variables for pseudo-drivers.
        !            45:  */
        !            46: 
        !            47: int WnInitFlag;
        !            48: int IsInitFlag;
        !            49: 
        !            50: /*
        !            51:  * Debugging level.
        !            52:  */
        !            53: 
        !            54: int    NpDebug = 0;            
        !            55: 
        !            56: /* Driver Wide State used by the ICP */
        !            57: 
        !            58: int NpState = NPCLEAR;
        !            59: 
        !            60: 
        !            61: /*
        !            62:  * Master structure, one per board, contains request queue header,
        !            63:  * shared memory address, and memory mapping information.
        !            64:  */
        !            65: 
        !            66: struct npmaster npmasters[NNP];
        !            67: 
        !            68: /* Structure of the shared memory area */
        !            69: 
        !            70: static struct npspace npspaces[NNP];
        !            71: 
        !            72: /* Panic Message data structures */
        !            73: 
        !            74: static int panicmap;                   /* Mapping information */
        !            75: static char    NpPbuf[PANLEN] = 0;     /* Panic message buffer */
        !            76: static caddr_t pstring;                        /* Panic string address on board, absolute */
        !            77: static unsign16 panaddr[2];            /* Panic string address on board (seg/offset) */
        !            78: 
        !            79: /* Driver Wide Connection Table */
        !            80: 
        !            81: static struct npconn npcnxtab[NNP][NNPCNN];
        !            82: 
        !            83: /* Head of the request queue, one per board */
        !            84: 
        !            85: static struct npreq reqhdr[NNP];
        !            86: 
        !            87: /* The request structures, one pool per board */
        !            88: 
        !            89: static struct npreq npreqs[NNP][NUMCQE];
        !            90: 
        !            91: 
        !            92: /*
        !            93:  * Data structures needed for BSD 4.2 Device Drivers
        !            94:  */
        !            95: 
        !            96: int    npprobe(), npattach(), npintr();
        !            97: struct uba_device *npdinfo[NNP];
        !            98: 
        !            99: /* UNIBUS address of Network Processors */
        !           100: 
        !           101: u_short        npstd[] = { 0166000, 0166020, 0 };
        !           102: 
        !           103: /* Interrupt vectors used by the Network Processors */
        !           104: 
        !           105: static unsign16 npvectors[NNP];
        !           106: 
        !           107: struct uba_driver npdriver =
        !           108:     { npprobe, 0, npattach, 0, npstd, "np", npdinfo };
        !           109: struct buf     np_tab[NNP];
        !           110: 
        !           111: 
        !           112: /*
        !           113:  * External function and data structure declarations.
        !           114:  */
        !           115: 
        !           116: struct npreq * NpGetReq();
        !           117: struct npmaster        *NpBoardChange();
        !           118: int NpTimer();
        !           119: struct CQE * NpRemCQE();
        !           120: int (*IxAttach)();
        !           121: int (*IxReset)();
        !           122: 
        !           123: extern struct user u;
        !           124: 
        !           125: /*
        !           126:  * Np_init() is responsible for hardware initializiation and the software 
        !           127:  * initialization of the connection table and driver software data structures.
        !           128:  */
        !           129: 
        !           130: npinit(unit)
        !           131: int unit;
        !           132: {
        !           133:        register int j;
        !           134: 
        !           135: 
        !           136:                /* Software Initialization */
        !           137: 
        !           138:        npmasters[unit].flags = NPCLEAR;
        !           139: 
        !           140:        NpSWinit(unit);
        !           141: 
        !           142:                /* Hardware Initialization */
        !           143: 
        !           144:        NpHWinit(unit);         
        !           145: 
        !           146:                /* Connection Table Initialization */
        !           147: 
        !           148:        for(j=0;j<NNPCNN;j++) {
        !           149:                npcnxtab[unit][j].protocol = NPCLCONN;
        !           150:                npcnxtab[unit][j].unit = &npmasters[unit];
        !           151:        }
        !           152: }
        !           153: 
        !           154: /*
        !           155:  * Np_open establishes a connection to the NP Driver using the minor
        !           156:  * device number as an identifier. A default protocol, NPMAINT, is assigned
        !           157:  * with the specified unit. Protocol and unit may be changed using the 
        !           158:  * NpProtChange and NpBoardChange functions.
        !           159:  * Since the maintainance protocol does not need a working I-Board, entries
        !           160:  * are always made in the Connection Table, npcnxtab, if the board exists.
        !           161:  */
        !           162: 
        !           163: /*ARGSUSED*/
        !           164: npopen(dev,flag)
        !           165: dev_t dev;
        !           166: int flag;
        !           167: {
        !           168:        int unit;
        !           169:        unsign16 conn;
        !           170:        struct npmaster *mp;
        !           171:        int error;
        !           172: 
        !           173:        if(NpDebug & DEBENTRY)
        !           174:                printf("npopen\n");
        !           175: 
        !           176:        /* Clear error */
        !           177: 
        !           178:        error = 0;
        !           179: 
        !           180:        /* Make sure it's the superuser */
        !           181: 
        !           182:        if(u.u_uid) 
        !           183:                return(EPERM);
        !           184:        
        !           185:        /* Get the connection identifier */
        !           186: 
        !           187:        if(((conn = NPCONN(dev)) >= NNPCNN) ||
        !           188:            ((unit = NPUNIT(dev)) >= NNP)) 
        !           189:                return(ENODEV);
        !           190:        
        !           191: 
        !           192:        if(NpDebug  & DEBOPEN)
        !           193:                printf("conn = %x unit = %d\n",conn,unit);
        !           194: 
        !           195:        /* Get the board for the specified unit */
        !           196: 
        !           197:        mp = NpBoardChange(NPMAINT,unit);
        !           198: 
        !           199:        if(mp != (struct npmaster *) 0) {
        !           200:                npcnxtab[unit][conn].unit = mp;
        !           201:                npcnxtab[unit][conn].protocol = NPMAINT;
        !           202:        }
        !           203:        else error = ENXIO;
        !           204: 
        !           205:        if(NpDebug & DEBENTRY)
        !           206:                printf("npopen...\n");
        !           207: 
        !           208:        return(error);
        !           209: }
        !           210: 
        !           211: /*
        !           212:  * Np_close is responsible updating the connection table for
        !           213:  * that connection by marking it closed.
        !           214:  */
        !           215: 
        !           216: npclose(dev)
        !           217: dev_t dev;
        !           218: {
        !           219: 
        !           220:        if(NpDebug & DEBENTRY)
        !           221:                printf("npclose\n");
        !           222: 
        !           223:        /* Get the connection identifier */
        !           224: 
        !           225:        npcnxtab[NPUNIT(dev)][NPCONN(dev)].protocol = NPCLCONN;
        !           226: 
        !           227:        if(NpDebug & DEBENTRY)
        !           228:                printf("npclose...\n");
        !           229: 
        !           230:        return(0);
        !           231: 
        !           232: }
        !           233: 
        !           234: /*
        !           235:  * Npioctl is the main conduit of commands between the I-Board and the
        !           236:  * NP support utilities. Relevant information for the request is found in the
        !           237:  * cmd and addr parameters. Cmd specifies the function to perform, addr is 
        !           238:  * command specific. Npioctl returns 0 if successful, or an error number
        !           239:  * (which winds up in errno).
        !           240:  */
        !           241: 
        !           242: /*ARGSUSED*/
        !           243: npioctl(dev,cmd,addr,flag)
        !           244: dev_t dev;
        !           245: int cmd;
        !           246: caddr_t *addr;
        !           247: int flag;
        !           248: {
        !           249:        unsign16 protocol;
        !           250:        unsign16 conn;
        !           251:        unsign16 unit;
        !           252:        int error;
        !           253: 
        !           254:        register struct npmaster *mp;
        !           255:        register struct npreq *rp;
        !           256:        unsigned usrarg;
        !           257: 
        !           258:        if(NpDebug & DEBENTRY)
        !           259:                printf("npioctl\n");
        !           260: 
        !           261:        /* Clear error */
        !           262: 
        !           263:        error = 0;
        !           264: 
        !           265:        /* Strip off IOC_VOID bit */
        !           266: 
        !           267:        cmd &= CMDMASK;
        !           268: 
        !           269:        /* Get connection identifier */
        !           270: 
        !           271:        conn = NPCONN(dev);
        !           272:        unit = NPUNIT(dev);
        !           273: 
        !           274:        /* Master pointer for this unit */
        !           275: 
        !           276:        mp = npcnxtab[unit][conn].unit;
        !           277: 
        !           278:        protocol = npcnxtab[unit][conn].protocol;
        !           279: 
        !           280:        /* Get a request structure from the pool and initialize it */
        !           281: 
        !           282:        while((rp = NpGetReq(mp->reqtab)) == NULL) {
        !           283:                mp->reqtab->flags |= WANTREQ;
        !           284:                sleep((caddr_t)(mp->reqtab),PZERO -1);
        !           285:        }
        !           286: 
        !           287:        if(NpDebug & DEBREQ)
        !           288:                printf("NP Reqp is %x\n",rp);
        !           289: 
        !           290:        /* Initializations of request structure */
        !           291: 
        !           292:        rp->intr = (int (*)())0;        /* Do not call interrupt routine */
        !           293:        rp->bufoffset = 0;              /* Offset into data buffer */
        !           294:        rp->flags = NPCLEAR;            /* Clear flags */
        !           295:        rp->procp = u.u_procp;  /* Process structure for this user */
        !           296: 
        !           297:        /* Copy in user's argument to ioctl() call */
        !           298: 
        !           299:        if(error = copyin(*addr,&usrarg,sizeof(usrarg)))
        !           300:                return(error);
        !           301:        
        !           302: 
        !           303:        if(NpDebug & DEBIOCTL)
        !           304:                printf("arg = %x\n",usrarg);
        !           305: 
        !           306:        /* Execute the specified command */
        !           307: 
        !           308:        switch(cmd) {
        !           309: 
        !           310:            case NPSETPROT:
        !           311:                if((error = NpProtChange(usrarg,mp->unit)) == 0)
        !           312:                        npcnxtab[unit][conn].protocol = usrarg;
        !           313:                break;
        !           314:            case NPSETBOARD:
        !           315:                if(mp = NpBoardChange(protocol,usrarg))
        !           316:                        npcnxtab[unit][conn].unit = mp;
        !           317:                else {
        !           318:                        mp = npcnxtab[unit][conn].unit;
        !           319:                        error = ENXIO;
        !           320:                }
        !           321:                break;
        !           322:            case NPRESET:
        !           323:                error = NpReset(mp,rp);
        !           324:                break;
        !           325:            case NPSETNPDEB:
        !           326:                NpDebug = usrarg;
        !           327:                break;
        !           328:            case NPINIT:
        !           329:                error = NpSWinit(mp->unit);
        !           330:                break;
        !           331:            case NPSTART:
        !           332: 
        !           333: #ifdef OLDROM
        !           334:                /*
        !           335:                 * Kludge to work around I-Board boot from Host. Read two bytes
        !           336:                 * from the board into the Device Configuration Word
        !           337:                 * in Shared Memory.
        !           338:                 */
        !           339: 
        !           340:                NPIO(mp,(paddr_t)0x500,(paddr_t)(&mp->shmemp->statblock.sb_dcw),2,B_READ);
        !           341: 
        !           342:                mp->shmemp->statblock.sb_drw = 0;
        !           343: #endif
        !           344: 
        !           345:                /* Set the Address at which to begin On-Board execution */
        !           346: 
        !           347:                error = NpSetXeqAddr(mp,(caddr_t)usrarg);
        !           348:                break;
        !           349:            case NPSTATS:
        !           350:                error = NpStats();
        !           351:                break;
        !           352:            case NPGPANIC:
        !           353:                error = copyout((caddr_t)NpPbuf,*addr,PANLEN);
        !           354: 
        !           355:                /* Clear panic request flag and leave */
        !           356: 
        !           357:                mp->flags &= ~PANICREQ;
        !           358:                break;
        !           359:            case NPPOLL:
        !           360:                error = NpPoll(mp,*addr);
        !           361:                break;
        !           362:            case NPKILL:
        !           363:                error = NpKill(mp,rp);
        !           364:                break;
        !           365:            case NPSETADDR:
        !           366:                error = NpSetMemAddr(mp,*addr);
        !           367:                break;
        !           368:            case NPRCSR0:
        !           369:                usrarg = RCSR0(mp->iobase);
        !           370:                error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
        !           371:                break;
        !           372:            case NPRCSR1:
        !           373:                usrarg = RCSR1(mp->iobase);
        !           374:                error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
        !           375:                break;
        !           376:            case NPRCSR2:
        !           377:                usrarg = RCSR2(mp->iobase);
        !           378:                error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
        !           379:                break;
        !           380:            case NPRCSR3:
        !           381:                usrarg = RCSR3(mp->iobase);
        !           382:                error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
        !           383:                break;
        !           384:            case NPWCSR0:
        !           385:                WCSR0(mp->iobase,usrarg);
        !           386:                break;
        !           387:            case NPWCSR1:
        !           388:                WCSR1(mp->iobase,usrarg);
        !           389:                break;
        !           390:            case NPWCSR2:
        !           391:                WCSR2(mp->iobase,usrarg);
        !           392:                break;
        !           393:            case NPWCSR3:
        !           394:                WCSR3(mp->iobase,usrarg);
        !           395:                break;
        !           396:            case NPNETBOOT:
        !           397:                error = NpSetIntLevel(mp,mp->vector);
        !           398:                if(error) break;
        !           399:                error = NpSetXeqAddr(mp,(caddr_t)INETBOOT);
        !           400:                break;
        !           401:            default:
        !           402:                printf("Bad Maintenance command: %d!\n",cmd);
        !           403:                error = EIO;
        !           404:                break;
        !           405: 
        !           406:        }
        !           407:        if((cmd != NPRESET) && (cmd != NPINIT))
        !           408:                NpFreeReq(mp->reqtab,rp);
        !           409: 
        !           410:        if(NpDebug & DEBENTRY)
        !           411:                printf("npioctl...\n");
        !           412: 
        !           413:        return(error);
        !           414: }
        !           415: 
        !           416: /*
        !           417:  * np_start - start io activity
        !           418:  */
        !           419: npstart(mp)
        !           420: register struct npmaster *mp;
        !           421: {
        !           422: 
        !           423:        register struct buf     *bp;
        !           424:        register struct npreq   *rp;
        !           425: 
        !           426:        int error;                      /* Return from NPIO call */
        !           427: 
        !           428:        if(NpDebug & DEBENTRY)
        !           429:                printf("npstart\n");
        !           430: 
        !           431:        if((bp = np_tab[mp->unit].b_actf) == (struct buf *)0) {
        !           432:                np_tab[mp->unit].b_active = 0;
        !           433:                return;
        !           434:        }
        !           435:        if((rp = (struct npreq *)(bp->av_back)) == (struct npreq *)0) {
        !           436:                bp->b_flags = B_ERROR;
        !           437:                iodone(bp);
        !           438:                return;
        !           439:        }
        !           440:        np_tab[mp->unit].b_active = 1;
        !           441: 
        !           442:        if(NpDebug & DEBIO)
        !           443:                printf("NP IO src %x dst = %x cnt = %x\n",bp->b_un.b_addr,bp->b_blkno << DEV_BSHIFT,bp->b_bcount);
        !           444: 
        !           445:        /* Send the request to the board via the CSR0 command interface */
        !           446: 
        !           447:        if(bp->b_flags & B_READ) 
        !           448: 
        !           449:                error = NPIO(mp,(paddr_t)((long)bp->b_blkno << DEV_BSHIFT),(paddr_t)(rp->bufaddr),
        !           450:            bp->b_bcount,(bp->b_flags & B_READ)); 
        !           451: 
        !           452:        else
        !           453:                error = NPIO(mp,(paddr_t)(rp->bufaddr),(paddr_t)((long)bp->b_blkno << DEV_BSHIFT),
        !           454:            bp->b_bcount,(bp->b_flags & B_READ)); 
        !           455:        
        !           456: 
        !           457:        /* Check return from I/O */
        !           458: 
        !           459:        if(error) {
        !           460:                bp->b_flags |= B_ERROR;
        !           461:                np_tab[mp->unit].b_actf = bp->av_forw;
        !           462: 
        !           463:                if(NpDebug & DEBIO)
        !           464:                        printf("NPIO return error: b_flags is %x \n",bp->b_flags);
        !           465:                iodone(bp);
        !           466:        }
        !           467: 
        !           468:        if(NpDebug & DEBENTRY)
        !           469:                printf("npstart...\n");
        !           470: 
        !           471: }
        !           472: /*
        !           473:  * npstratagey - the strategy routine
        !           474:  */
        !           475: 
        !           476: npstrategy(bp)
        !           477: register struct buf *bp;
        !           478: {
        !           479: 
        !           480:        register struct buf *ip;        /* quick pointer */
        !           481:        register struct npmaster *mp;   /* master structure for this device */
        !           482:        register struct npreq *rp;      /* reqest struct pointer */
        !           483:        int s;                          /* priority to return to */
        !           484: 
        !           485:        if(NpDebug & DEBENTRY)
        !           486:                printf("npstrategy\n");
        !           487:        if(NpDebug & DEBIO)
        !           488:                printf("flag = %x count = %x paddr = %x %x blkno = %x %x\n",
        !           489:                    bp->b_flags,bp->b_bcount,bp->b_un.b_addr,bp->b_un.b_addr,bp->b_blkno,bp->b_blkno);
        !           490: 
        !           491:        /* get master structure */
        !           492: 
        !           493:        mp = npcnxtab[NPUNIT(bp->b_dev)][NPCONN(bp->b_dev)].unit;
        !           494: 
        !           495:        /* make sure the boards ok */
        !           496: 
        !           497:        if (mp->flags & BADBOARD) {
        !           498:                bp->b_flags |= B_ERROR;
        !           499: 
        !           500:                if(NpDebug & DEBMEM)
        !           501:                        printf("Bad Board %x bp %x\n",mp->flags,bp->b_flags);
        !           502: 
        !           503:                np_tab[mp->unit].b_actf = bp->av_forw;
        !           504:                iodone(bp);
        !           505:                return;
        !           506:        }
        !           507: 
        !           508:        /* Initializations of request structure */
        !           509: 
        !           510:        while((rp = NpGetReq(mp->reqtab)) == NULL) {
        !           511:                mp->reqtab->flags |= WANTREQ;
        !           512:                sleep((caddr_t)(mp->reqtab),PZERO -1);
        !           513:        }
        !           514: 
        !           515:        rp->bufoffset = 0;              /* This is the start of the buffer */
        !           516:        ip = &np_tab[mp->unit];
        !           517:        bp->av_forw = (struct buf *)0;
        !           518:        bp->av_back = (struct buf *)rp;
        !           519: 
        !           520:        rp->flags |= KERNREQ;           /* Mark it as kernel so not to map */
        !           521: 
        !           522:        rp->mapbase = ubasetup(mp->devp->ui_ubanum,bp,0);
        !           523:        rp->bufaddr = (caddr_t)((int)(rp->mapbase) & UBADDRMASK);
        !           524: 
        !           525:        s = spl5();
        !           526:        if(ip->b_actf ==(struct buf *)0)
        !           527:                ip->b_actf = bp;
        !           528:        else {
        !           529:                if(ip->b_actf->av_forw)
        !           530:                        printf("Panic NP100 bad buffer chain\n");
        !           531:                ip->b_actf->av_forw = bp;
        !           532:        }
        !           533:        ip->b_actl = bp;
        !           534: 
        !           535:        NpAddReq(mp->reqtab,rp);                /* Queue onto active list */
        !           536: 
        !           537:        if(ip->b_active == 0) {
        !           538: 
        !           539:                if(NpDebug & DEBIO)
        !           540:                        printf("calling npstart %x\n",mp);
        !           541: 
        !           542:                npstart(mp);
        !           543:        }
        !           544:        splx(s);
        !           545: 
        !           546:        if(NpDebug & DEBIO)
        !           547:                printf("back from npstart\n");
        !           548: 
        !           549:        /* Await completion of I/O */
        !           550: 
        !           551:        iowait(bp);
        !           552: 
        !           553:        if(NpDebug & DEBIO)
        !           554:                printf("after iowait in npstrategy\n");
        !           555: 
        !           556:        /* Remove request from queue */
        !           557: 
        !           558:        NpRemReq(rp);
        !           559: 
        !           560:        /* Release mapping registers */
        !           561: 
        !           562:        ubarelse(mp->devp->ui_ubanum,&rp->mapbase);
        !           563: 
        !           564:        /* Free up request structure */
        !           565: 
        !           566:        NpFreeReq(mp->reqtab,rp);
        !           567: 
        !           568:        if(NpDebug & DEBENTRY)
        !           569:                printf("Leaving npstrategy flags is %x\n",bp->b_flags);
        !           570: }
        !           571: 
        !           572: unsigned
        !           573: nptrim(bp)
        !           574: register struct buf *bp;
        !           575: {
        !           576: 
        !           577:        if(bp->b_bcount > NPMAXXFR)
        !           578:                bp->b_bcount = NPMAXXFR;
        !           579: }
        !           580: 
        !           581: /*
        !           582:  * Npread dumps data from the board to the user's buffer
        !           583:  */
        !           584: npread(dev,uio)
        !           585: dev_t dev;
        !           586: struct uio *uio;
        !           587: {
        !           588: 
        !           589:        if(NpDebug & DEBENTRY)
        !           590:                printf("in npread\n");
        !           591: 
        !           592:        return(physio(npstrategy,&npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_rbuf,dev,B_READ ,nptrim,uio));
        !           593: 
        !           594: }
        !           595: 
        !           596: /*
        !           597:  * Npwrite loads the np100 board from the user's buffer
        !           598:  */
        !           599: 
        !           600: npwrite(dev,uio)
        !           601: dev_t dev;
        !           602: struct uio *uio;
        !           603: {
        !           604:        struct buf *bp;
        !           605:        bp = &npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_wbuf;
        !           606: 
        !           607:        if(NpDebug & DEBENTRY)
        !           608:                printf("in npwrite \n");
        !           609: 
        !           610:        return(physio(npstrategy,bp,dev,B_WRITE ,nptrim,uio));
        !           611: }
        !           612: /*
        !           613: 
        !           614:  * npreset - called as result of a UNIBUS reset.
        !           615:  */
        !           616: 
        !           617: npreset(uban)
        !           618: int uban;
        !           619: {
        !           620: 
        !           621:        register struct npmaster *mp;
        !           622:        register struct npreq *rp;
        !           623:        register struct uba_device *ui;
        !           624:        int i;
        !           625: 
        !           626:        for(i = 0; i < NNP; i++) {
        !           627: 
        !           628:                if(((ui = npdinfo[i]) == (struct uba_device *)NULL) ||
        !           629:                        (ui->ui_ubanum != uban))
        !           630:                        continue;
        !           631: 
        !           632:                mp = &npmasters[i];
        !           633:                mp->iomapbase = 0;
        !           634:                NpReset(mp,0);
        !           635:        }
        !           636: }
        !           637: 
        !           638: /*
        !           639:  * Nppoll looks for work by polling each board. He goes to sleep if there are
        !           640:  * no outstanding requests for him but reminds the board that he's there when
        !           641:  * needed.
        !           642:  */
        !           643: 
        !           644: NpPoll(mp,addr)
        !           645: struct npmaster *mp;
        !           646: caddr_t        addr;
        !           647: {
        !           648:        int error;
        !           649: 
        !           650:        struct {
        !           651:                unsign16 request;
        !           652:                unsign16 unit;
        !           653:        }icpreq;
        !           654: 
        !           655:        if(NpDebug & DEBMAINT)
        !           656:                printf("NpPoll: flags is %x.\n",mp->flags);
        !           657: 
        !           658:        while(TRUE) {
        !           659: 
        !           660:                for(mp = npmasters; mp; mp = mp->next) {
        !           661: 
        !           662:                        if(mp->flags & BOARDREQ) {
        !           663: 
        !           664:                                /* Get request type from master structure */
        !           665: 
        !           666:                                if(mp->flags & BRDRESET) {
        !           667:                                        icpreq.request = ICPPOLL;
        !           668:                                        mp->reqtab->reqcnt--;
        !           669: 
        !           670:                                        if(NpDebug & DEBMAINT)
        !           671:                                                printf("Waking NpResetter!\n");
        !           672: 
        !           673:                                        wakeup((caddr_t)(&mp->reqtab));
        !           674:                                }
        !           675:                                else if(mp->flags & PANICREQ)
        !           676:                                        icpreq.request = ICPPANIC;
        !           677:                                else if(mp->flags & DUMPREQ)
        !           678:                                        icpreq.request = ICPDUMP;
        !           679:                                else if(mp->flags & LOADREQ)
        !           680:                                        icpreq.request = ICPLOAD;
        !           681:                                else {
        !           682:                                        mp->flags &= ~BOARDREQ;
        !           683:                                        continue;
        !           684:                                }
        !           685: 
        !           686:                                if(NpDebug & DEBMAINT)
        !           687:                                        printf("ProcICP servicing %d \n",icpreq.request );
        !           688: 
        !           689:                                /* Request and unit number to be sent */
        !           690: 
        !           691:                                icpreq.unit = mp->unit;
        !           692: 
        !           693:                                /* Copy service request to calling process */
        !           694: 
        !           695:                                error = copyout(&icpreq,addr,sizeof(icpreq));
        !           696: 
        !           697:                                /* Mark Poller as being unavailable */
        !           698: 
        !           699:                                NpState &= ~ICPAVAIL;
        !           700: 
        !           701:                                return(error);
        !           702:                        }
        !           703:                }
        !           704: 
        !           705:                /* Mark Poller as being available */
        !           706: 
        !           707:                NpState |= ICPAVAIL;
        !           708: 
        !           709:                sleep((caddr_t)&NpState, PZERO + 1);
        !           710: 
        !           711:                if(NpDebug & DEBMAINT)
        !           712:                        printf("wakeup in NpPoll\n");
        !           713: 
        !           714:        }
        !           715: }
        !           716: 
        !           717: /*
        !           718:  * Software initialization of Driver data structures for the specified unit.
        !           719:  */
        !           720: 
        !           721: NpSWinit(unit)
        !           722: int unit;
        !           723: {
        !           724: 
        !           725:        register int j;
        !           726:        register struct npmaster *mp;
        !           727:        register struct npspace *npsp;
        !           728:        register struct CmdQue *cqp;
        !           729:        int offset;
        !           730: 
        !           731:        if(NpDebug & DEBINIT)
        !           732:                printf("SW reset on unit %d.\n",unit);
        !           733: 
        !           734:        /* Initialize master structure pointer for this unit */
        !           735: 
        !           736:        mp = &npmasters[unit];
        !           737: 
        !           738:        /* Initialize unit buffer headers */
        !           739: 
        !           740:        np_tab[unit].b_active = 0;
        !           741:        np_tab[unit].b_actf = 0;
        !           742: 
        !           743:        /* UBA device structure for this unit */
        !           744: 
        !           745:        mp->devp = npdinfo[unit];
        !           746: 
        !           747:        /* Interrupt vector for this unit */
        !           748: 
        !           749:        mp->vector = npvectors[unit];
        !           750: 
        !           751:        if(unit == (NNP -1))
        !           752:                mp->next = (struct npmaster *)NULL;
        !           753:        else mp->next = &npmasters[unit + 1];
        !           754: 
        !           755:        /*
        !           756:         * Guarantee alignment of shared memory area on a
        !           757:          * 16 byte boundary as required by I-Board
        !           758:         */
        !           759: 
        !           760:        mp->shmemp = &npspaces[unit];
        !           761:        mp->shmemp = (struct npspace *)ROUND16((int)(mp->shmemp));
        !           762: 
        !           763:        /* Base address of this controller */
        !           764: 
        !           765:        mp->iobase = (struct NPREG *)(mp->devp->ui_addr);
        !           766: 
        !           767:        if(NpDebug & DEBMEM) { 
        !           768:                printf("Npspaces starts at %x.\n",npspaces);
        !           769:                printf("Shared memory starts at %x.\n",mp->shmemp);
        !           770:                printf("End of shared memory is %x.\n",&npspaces[unit + 1]);
        !           771:                printf("Iobase is %x.\n",mp->iobase);
        !           772:                printf("Npmasters start at %x\n",npmasters);
        !           773:                printf("Reqhdr start at %x\n",reqhdr);
        !           774:                printf("Npreqs start at %x\n",npreqs);
        !           775:        }
        !           776: 
        !           777:        /* Initialize the request header */
        !           778: 
        !           779:        mp->reqtab = &reqhdr[unit];
        !           780: 
        !           781:        /* Unit initialization */
        !           782: 
        !           783:        mp->unit = unit;
        !           784: 
        !           785:        /* Initialize Status Block */
        !           786: 
        !           787:        npsp = mp->shmemp;
        !           788:        offset = (int) (mp->shmemp);
        !           789: 
        !           790:        npsp->statblock.sb_drw = 0;
        !           791:        npsp->statblock.sb_hcw = HOSTCONF;
        !           792:        npsp->statblock.sb_dcw = 0;
        !           793:        npsp->statblock.sb_dpm = 0;
        !           794: 
        !           795:        npsp->statblock.sb_dcq = (unsign16)((int)(&npsp->devcq))-offset;
        !           796: 
        !           797:        npsp->statblock.sb_hcq = (unsign16)((int)(&npsp->hostcq))-offset;
        !           798: 
        !           799:        /* Initialize Device Command Queue */
        !           800: 
        !           801:        cqp = (struct CmdQue *) &npsp->devcq;
        !           802: 
        !           803:        if(NpDebug & DEBCQ) 
        !           804:                printf("Device CQ at %x\n",cqp);
        !           805: 
        !           806:        cqp->scanflag = NPCLEAR;
        !           807:        cqp->chngflag = NPCLEAR;
        !           808: 
        !           809:        cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
        !           810:        cqp->cq_rem = cqp->cq_add;
        !           811: 
        !           812:        cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;
        !           813: 
        !           814:        for(j = 0; j < NUMCQE; j++)
        !           815:                cqp->cq_cqe[j] = (unsign16)NULL;
        !           816: 
        !           817:        /* Initialize Host Command Queue */
        !           818: 
        !           819:        cqp = (struct CmdQue *) &npsp->hostcq;
        !           820: 
        !           821:        if(NpDebug & DEBCQ) 
        !           822:                printf("HOST CQ at %x\n",cqp);
        !           823: 
        !           824:        cqp->scanflag = NPCLEAR;
        !           825:        cqp->chngflag = NPCLEAR;
        !           826: 
        !           827:        cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
        !           828:        cqp->cq_rem = cqp->cq_add;
        !           829: 
        !           830:        cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;
        !           831: 
        !           832:        for(j = 0; j < NUMCQE; j++)
        !           833:                cqp->cq_cqe[j] = (unsign16)NULL;
        !           834: 
        !           835:        /*
        !           836:         * Initialize the reqid of the elements to the address
        !           837:         * of the corresponding Npreq structure. These don't change.
        !           838:         */
        !           839: 
        !           840:        for(j = 0; j < NUMCQE; j++)
        !           841:                npsp->elements[j].cqe_reqid = &npreqs[unit][j];
        !           842: 
        !           843:        /*
        !           844:         * Initialize the Request Header (reqhdr), free list of
        !           845:         * npreqs, and pointers to CQEs.
        !           846:         */
        !           847: 
        !           848:        reqhdr[unit].forw = reqhdr[unit].back = &reqhdr[unit];
        !           849:        reqhdr[unit].free = &npreqs[unit][0];
        !           850: 
        !           851:        for(j = 0; j < NUMCQE; j++) {
        !           852: 
        !           853:                npreqs[unit][j].free = &npreqs[unit][j + 1];
        !           854:                npreqs[unit][j].element = &npsp->elements[j];
        !           855:                npreqs[unit][j].forw = npreqs[unit][j].back = (struct npreq *)NULL;
        !           856:        }
        !           857:        npreqs[unit][--j].free = &reqhdr[unit];
        !           858: 
        !           859:        /*
        !           860:         * Set up the UNIBUS I/O Map Registers for the
        !           861:         * Shared memory area.
        !           862:         */
        !           863: 
        !           864:        mp->iomapbase = uballoc(mp->devp->ui_ubanum,(caddr_t)(mp->shmemp),sizeof(struct npspace),0);
        !           865: 
        !           866: 
        !           867:        if(NpDebug & DEBENTRY)
        !           868:                printf("SW_Init...\n");
        !           869: }
        !           870: 
        !           871: /*
        !           872:  * NpHWinit() issues a hardware reset to the specified board and waits
        !           873:  * for on-board diagnostics to complete. It returns 0 if the board is
        !           874:  * present and passed diagnostics, an error value otherwise.
        !           875:  */
        !           876: 
        !           877: NpHWinit(unit)
        !           878: int unit;
        !           879: {
        !           880:        register struct npmaster *mp;
        !           881:        struct NPREG *REG;
        !           882:        unsign16 status;
        !           883:        int dflag;
        !           884: 
        !           885:        if(unit >= NNP)
        !           886:                return(ENXIO);
        !           887: 
        !           888:        mp = &npmasters[unit];
        !           889: 
        !           890:        if(NpDebug & DEBENTRY)
        !           891:                printf("NpHWinit\n");
        !           892: 
        !           893:        /* See if the board is out there */
        !           894: 
        !           895:        REG = (struct NPREG *)mp->iobase;
        !           896: 
        !           897:        if(NpDebug & DEBINIT)
        !           898:                printf("REG in HWinit is %x.\n",mp->iobase);
        !           899: 
        !           900:        if(!(mp->flags & BRDRESET))
        !           901: 
        !           902:                if(badaddr(REG,2)) {
        !           903:                        mp->flags |= BADBOARD;
        !           904:                        printf("\nNP100 unit %d not found!\n",unit);
        !           905:                        return(ENXIO);
        !           906:                }
        !           907: 
        !           908: 
        !           909: #ifdef mc500
        !           910:        if(setjmp(u.u_tsav) == 0) {
        !           911:                u.u_nofault = TRUE;
        !           912:                status = RCSR1(mp->iobase);
        !           913:                u.u_nofault = FALSE;
        !           914:        }
        !           915:        else {
        !           916:                np__addr[unit] = 0;
        !           917:                mp->flags |= BADBOARD;
        !           918:                u.u_error = ENXIO;
        !           919:                printf("\nNP100 Unit %x not here!\n",unit);
        !           920:                return(0);
        !           921:        }
        !           922: #endif
        !           923: 
        !           924:        if(NpDebug & DEBENTRY)
        !           925:                printf("Resetting the NP100 Board at %x\n",mp->iobase);
        !           926: 
        !           927:        /* Reset the Board */
        !           928: 
        !           929:        RESET(mp);
        !           930: 
        !           931:        dflag = NPCLEAR;
        !           932: 
        !           933:        timeout(NpTimer,&dflag,DIAGTIME);
        !           934: 
        !           935:        /* Wait for Enable and Read Data Ready to go high */
        !           936: 
        !           937:        while(! ((RCSR1(mp->iobase) & NPENB) && (RCSR1(mp->iobase) & NPRDR))) {
        !           938:                if(dflag)
        !           939:                        break;
        !           940: 
        !           941:        }
        !           942: 
        !           943:        untimeout(NpTimer,&dflag);
        !           944: 
        !           945:        if(NpDebug & DEBINIT)
        !           946:                printf("np reset %d \n",dflag);
        !           947: 
        !           948:        if(dflag) {
        !           949:                mp->flags |= BADBOARD;
        !           950:                printf("NP100 Unit %d timed out!\n",unit);
        !           951:                return(EIO);
        !           952:        }
        !           953: 
        !           954:        status = RCSR0(mp->iobase);
        !           955: 
        !           956:        /* Check for Hardware OK */
        !           957: 
        !           958:        if(!(RCSR1(mp->iobase) & NPHOK)) {
        !           959:                mp->flags |= BADBOARD;
        !           960:                u.u_error = EIO;
        !           961:                printf("NP100 Unit %d Failed diagnostics!\n",unit);
        !           962:                printf("Status from CSR0: %x.\n",status);
        !           963:                return(EIO);
        !           964:        }
        !           965: 
        !           966:        if(NpDebug & DEBENTRY)
        !           967:                printf("HWinit...\n");
        !           968: 
        !           969:        return(0);
        !           970: }
        !           971: 
        !           972: /*
        !           973:  * NP Driver Interrupt Handler
        !           974:  */
        !           975: 
        !           976: npintr(unit)
        !           977: int unit;
        !           978: {
        !           979:        register struct npmaster *mp;
        !           980:        register struct buf     *bp;
        !           981: 
        !           982:        if(NpDebug & DEBENTRY)
        !           983:                printf("npintr on unit %d!\n",unit);
        !           984: 
        !           985:        mp = &npmasters[unit];
        !           986: 
        !           987:        if(NpDebug & DEBINTR)
        !           988:                printf("npintr mp->flags = %x\n",mp->flags);
        !           989: 
        !           990:        /* Wake up anyone sleeping on a CSR0 Command */
        !           991: 
        !           992:        if(mp->flags & CSRPEND) {
        !           993: 
        !           994:                mp->flags &= ~CSRPEND;
        !           995:                if(np_tab[mp->unit].b_active) {
        !           996:                        np_tab[mp->unit].b_active = 0;
        !           997:                        bp = np_tab[mp->unit].b_actf;
        !           998:                        np_tab[mp->unit].b_actf = bp->av_forw;
        !           999: 
        !          1000:                        if(NpDebug & DEBINTR)
        !          1001:                                printf("bp = %x resid = %d forw = %x\n",bp,
        !          1002:                                    bp->b_resid,bp->av_forw);
        !          1003: 
        !          1004:                        bp->b_resid = 0;
        !          1005:                        iodone(bp);
        !          1006:                }
        !          1007:                if(mp->flags & PANIC3) {
        !          1008:                        mp->flags &= ~PANIC3;
        !          1009:                        mp->flags = AVAILABLE;
        !          1010:                        ubarelse(mp->devp->ui_ubanum,&panicmap);
        !          1011:                }
        !          1012:                if(mp->flags & PANIC2) {
        !          1013:                        mp->flags &= ~PANIC2;
        !          1014:                        printf("Panic Message: %s",NpPbuf);
        !          1015:                        mp->flags |= PANIC3;
        !          1016:                        NpPbuf[0] = 0;
        !          1017:                        NPIO(mp,(paddr_t)((int) panicmap & UBADDRMASK),(paddr_t)pstring,sizeof(NpPbuf),B_WRITE);
        !          1018:                }
        !          1019:                if(mp->flags & PANIC1) {
        !          1020:                        mp->flags &= ~PANIC1;
        !          1021:                        mp->flags |= PANIC2;
        !          1022:                        ubarelse(mp->devp->ui_ubanum,&panicmap);
        !          1023:                        panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)NpPbuf,sizeof(NpPbuf),0);
        !          1024:                        pstring = (caddr_t)((panaddr[1] << 4) + panaddr[0]);
        !          1025:                        NPIO(mp,(paddr_t)pstring,(paddr_t)((int) panicmap & UBADDRMASK),sizeof(NpPbuf),B_READ);
        !          1026:                }
        !          1027: 
        !          1028:                wakeup((caddr_t)mp);
        !          1029:                goto out;
        !          1030:        }
        !          1031: 
        !          1032:        /* Mark unit as being available if Device Protocol Mask set */
        !          1033: 
        !          1034:        if(!(mp->flags & AVAILABLE)) {
        !          1035: 
        !          1036:                if((mp->shmemp->statblock.sb_dpm) && (!(mp->flags & BRDRESET))){
        !          1037: 
        !          1038:                        mp->flags = AVAILABLE;
        !          1039:                        printf("\nNP100 unit #%d available!\n",mp->unit);
        !          1040:                }
        !          1041:        }
        !          1042: 
        !          1043:        /* Honor service requests from the device */
        !          1044: 
        !          1045:        switch(mp->shmemp->statblock.sb_drw) {
        !          1046: 
        !          1047:            case NOREQ:
        !          1048:                break;
        !          1049: 
        !          1050:            case NPPANIC:
        !          1051: 
        !          1052:                printf("\nPanic from NP100 unit %d!\n",mp->unit);
        !          1053:                mp->flags &= ~AVAILABLE;
        !          1054:                mp->flags |= PANIC1;
        !          1055: 
        !          1056:                /* Clear device request word */
        !          1057: 
        !          1058:                mp->shmemp->statblock.sb_drw = 0;
        !          1059: 
        !          1060:                panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)panaddr,sizeof(panaddr),0);
        !          1061:                NPIO(mp,(paddr_t)NPPSADDR,(paddr_t)((int)panicmap & UBADDRMASK),sizeof(panaddr),B_READ);
        !          1062:                goto out;
        !          1063:                break;
        !          1064: 
        !          1065:            case NPDUMP:
        !          1066:                mp->flags |= (DUMPREQ | BOARDREQ);
        !          1067: 
        !          1068:                /* Clear device request word */
        !          1069: 
        !          1070:                mp->shmemp->statblock.sb_drw = 0;
        !          1071: 
        !          1072:                if(NpState & ICPAVAIL)
        !          1073:                        wakeup((caddr_t)&NpState);
        !          1074:                break;
        !          1075: 
        !          1076:            case NPLOAD:
        !          1077:                mp->flags |= (LOADREQ | BOARDREQ);
        !          1078: 
        !          1079:                /* Clear device request word */
        !          1080: 
        !          1081:                mp->shmemp->statblock.sb_drw = 0;
        !          1082: 
        !          1083:                if(NpState & ICPAVAIL)
        !          1084:                        wakeup((caddr_t)&NpState);
        !          1085:                break;
        !          1086: 
        !          1087:            default:
        !          1088:                printf("Bad Req: %x.\n",mp->shmemp->statblock.sb_drw);
        !          1089:                goto out;
        !          1090: 
        !          1091:        }
        !          1092: 
        !          1093:        /* Process the Host Command Queue for this device */
        !          1094: 
        !          1095:        NpProcQueue(mp);
        !          1096: 
        !          1097: out:
        !          1098:        CLEARINT(mp);   /* Clear the interrupt */
        !          1099: 
        !          1100:        if(NpDebug & DEBENTRY)
        !          1101:                printf("npintr...\n");
        !          1102: 
        !          1103:        return(1);      /* Interrupt serviced */
        !          1104: 
        !          1105: }
        !          1106: 
        !          1107: /*
        !          1108:  * This routine, called from the interrupt handler, is used to process the
        !          1109:  * Host Command Queue for the specified device.
        !          1110:  */
        !          1111: 
        !          1112: NpProcQueue(mp)
        !          1113: struct npmaster *mp;
        !          1114: {
        !          1115:        register struct CmdQue *cqp;
        !          1116:        register struct CQE *ep;
        !          1117:        register struct npreq *rp;
        !          1118:        register int base;
        !          1119: 
        !          1120:        if(NpDebug & DEBENTRY)
        !          1121:                printf("NpProcQueue\n");
        !          1122: 
        !          1123:        cqp = &mp->shmemp->hostcq;      /* Command Queue pointer */
        !          1124: 
        !          1125:        if(cqp->scanflag & ON)
        !          1126:                return;
        !          1127: 
        !          1128:        else cqp->scanflag | = ON;
        !          1129: 
        !          1130:        base = (int)mp->shmemp;         /* Shared memory base address */
        !          1131: 
        !          1132:        while(cqp->scanflag & ON) {
        !          1133: 
        !          1134:                while(ep = NpRemCQE(cqp,base)) {
        !          1135: 
        !          1136:                        rp = ep->cqe_reqid;
        !          1137: 
        !          1138:                        if(NpDebug & DEBCQE)
        !          1139:                                printf("cqe_sts is %x ep = %x\n",ep->cqe_sts,ep);
        !          1140: 
        !          1141:                        switch (ep->cqe_sts)  {
        !          1142: 
        !          1143:                            case NPDONE:
        !          1144:                                rp->flags |= REQDONE;   /* Normal completion */
        !          1145:                                break;
        !          1146:                            case NPIFC:                 /* IFC Request */
        !          1147:                                rp->flags |= IOIFC;
        !          1148:                                break;
        !          1149:                            case NPPERR:                /* Protocol Error */
        !          1150:                                rp->flags |= (NPPERR | REQDONE);
        !          1151:                                break;
        !          1152:                            case NPMERR:                /* Memory allocation */
        !          1153:                                rp->flags |= (NPMERR | REQDONE);
        !          1154:                                break;
        !          1155:                            default:                    /* Error on Board */
        !          1156:                                rp->flags |= (IOERR | REQDONE);
        !          1157:                                break;
        !          1158: 
        !          1159:                        }
        !          1160: 
        !          1161:                        if(NpDebug & DEBCQE) {
        !          1162:                                printf("flag is %x reqid = %x\n",rp->flags,ep->cqe_reqid);
        !          1163:                                printf("wakeup in procqueue\n");
        !          1164:                        }
        !          1165: 
        !          1166:                        if(rp->intr) {
        !          1167: 
        !          1168:                                if(NpDebug & DEBINTR)
        !          1169:                                        printf("calling usr intr at %x\n",
        !          1170:                                                rp->intr);
        !          1171: 
        !          1172:                                /* Call interrupt routine */
        !          1173: 
        !          1174:                                (*rp->intr)(mp,rp);
        !          1175: 
        !          1176:                        }
        !          1177:                        else {
        !          1178: 
        !          1179:                        if(NpDebug & DEBINTR)
        !          1180:                                printf("waking up %x\n",rp);
        !          1181: 
        !          1182:                                if(rp->flags & NPUIO)
        !          1183:                                        iodone(&rp->buf);
        !          1184:                                else    wakeup((caddr_t) (rp)); /* Awaken */
        !          1185: 
        !          1186:                        if(NpDebug & DEBINTR)
        !          1187:                                printf("AWAKE\n");
        !          1188:                        }
        !          1189: 
        !          1190:                }
        !          1191: 
        !          1192:                if(!(cqp->chngflag & ON))
        !          1193:                        cqp->scanflag &= ~ON;
        !          1194: 
        !          1195:        }
        !          1196: 
        !          1197:        if(NpDebug & DEBENTRY)
        !          1198:                printf("NpProcQueue...\n");
        !          1199: }
        !          1200: 
        !          1201: /*
        !          1202:  * NpIFC - processes an IFC (Internal Fuction Call) request 
        !          1203:  *             NOTE: this function must be called from the user context
        !          1204:  *                     on all virtual pageing systems
        !          1205:  *
        !          1206:  */
        !          1207: NpIFC(mp,rp)
        !          1208: register struct npmaster *mp;
        !          1209: register struct npreq *rp;
        !          1210: {
        !          1211:        register struct CQE     *ep;
        !          1212: 
        !          1213:        if(NpDebug & DEBENTRY)
        !          1214:                printf("NpIFC\n");
        !          1215: 
        !          1216:        ep = rp->element;
        !          1217:        rp->flags &= ~IOIFC;
        !          1218:        switch(ep->cqe_func) {
        !          1219: 
        !          1220:            case NPUNLOCK:      /* Unlock process, free up mapping registers  */
        !          1221: 
        !          1222:                if(NpDebug & DEBIFC)
        !          1223:                        printf("NPUNLOCK\n");
        !          1224: 
        !          1225:                if(rp->mapbase)
        !          1226:                        NpUnMapMem(mp,rp);
        !          1227:                break;
        !          1228: 
        !          1229:            case NPLOCK:        /* Lock process, get mapping registers */
        !          1230: 
        !          1231:                if(NpDebug & DEBIFC)
        !          1232:                        printf("NPLOCK\n");
        !          1233:                NpMapMem(mp,rp,rp->virtmem,rp->bytecnt);
        !          1234:                ep->cqe_dma[0] = LOWORD(rp->bufaddr);
        !          1235:                ep->cqe_dma[1] = HIWORD(rp->bufaddr);
        !          1236:                break;
        !          1237: 
        !          1238:            case NPREMAP:
        !          1239: 
        !          1240:                if(NpDebug & DEBIFC)
        !          1241:                        printf("NPREMAP\n");
        !          1242: 
        !          1243:                /* Remap user buffer and update buffer offset */
        !          1244: #ifdef USG
        !          1245:                np_remapmem(rp,rp->virtmem); 
        !          1246:                ep->cqe_dma[0] = LOWORD(rp->bufaddr);
        !          1247:                ep->cqe_dma[1] = HIWORD(rp->bufaddr);
        !          1248:                break;
        !          1249: #endif
        !          1250: 
        !          1251:            default:
        !          1252:                if(NpDebug & DEBIFC)
        !          1253:                        printf("Bad case %x in IFC\n", ep->cqe_func);
        !          1254: 
        !          1255:                rp->flags |= (REQDONE | IOERR);
        !          1256:                break;
        !          1257:        }
        !          1258: }
        !          1259: 
        !          1260: /*
        !          1261:  * The following contains various routines for allocating and deallocating
        !          1262:  * structures used by the NP Driver. Routines are also here for addding
        !          1263:  * and removing Command Queue Elements from a Command Queue.
        !          1264:  */
        !          1265: 
        !          1266: /*
        !          1267:  * Get a free NP Request structure from the list pointed to by head. Returns
        !          1268:  * a pointer to a npreq or NULL if none left.
        !          1269:  */
        !          1270: 
        !          1271: struct npreq *
        !          1272: NpGetReq(head)
        !          1273: struct npreq *head;
        !          1274: {
        !          1275: 
        !          1276:        register struct npreq *p;
        !          1277: 
        !          1278:        p = head->free;
        !          1279:        head->free = p->free;
        !          1280:        return(p==head ? (struct npreq *)NULL : p);
        !          1281: }
        !          1282: 
        !          1283: /*
        !          1284:  * Return a NP Request structure to the free list pointed to by head.
        !          1285:  */
        !          1286: 
        !          1287: NpFreeReq(head,nprp)
        !          1288: register struct npreq *head, *nprp;
        !          1289: {
        !          1290: 
        !          1291:        if(NpDebug & DEBREQ)
        !          1292:                printf("NpFreeReq, head is %x rp is %x\n",head,nprp);
        !          1293: 
        !          1294:        nprp->forw = nprp->back = (struct npreq *)NULL;
        !          1295:        nprp->free = head->free;
        !          1296:        head->free = nprp;
        !          1297: 
        !          1298:        /* Wake up any processes waiting for a request structure */
        !          1299: 
        !          1300:        if(head->flags & WANTREQ) {
        !          1301:                head->flags &= ~WANTREQ;
        !          1302:                wakeup((caddr_t)head);
        !          1303:        }
        !          1304: 
        !          1305:        if(NpDebug & DEBENTRY)
        !          1306:                printf("NpFreeReq...\n");
        !          1307: }
        !          1308: 
        !          1309: /*
        !          1310:  * Add a Command Queue Element onto the specified Command Queue and
        !          1311:  * update its Add offset.
        !          1312:  */
        !          1313: 
        !          1314: NpAddCQE(ep,cqp,mp)
        !          1315: struct CQE *ep;
        !          1316: struct CmdQue *cqp;
        !          1317: struct npmaster *mp;
        !          1318: {
        !          1319: 
        !          1320:        register unsign16 *temp;
        !          1321:        register unsign16 cqe_offset;
        !          1322:        register int base;
        !          1323: 
        !          1324:        base = (int)mp->shmemp;         /* Shared memory base address */
        !          1325: 
        !          1326:        temp = (unsign16 *)(base + cqp->cq_add); /* Offset to add element */
        !          1327: 
        !          1328:        cqe_offset = (unsign16)((int)ep - base);
        !          1329: 
        !          1330:        if(*temp) {                     /* Should never happen */
        !          1331: 
        !          1332:                printf("No more room on Command Queue!\n");
        !          1333:                u.u_error = EIO;
        !          1334:                return;
        !          1335:        }
        !          1336:        else *temp = cqe_offset;        /* Enter this request's offset */
        !          1337: 
        !          1338:        cqp->chngflag |= ON;            /* Set change flag unconditionally */
        !          1339: 
        !          1340:        /* Update cqe_add where next request is to be added */
        !          1341: 
        !          1342:        cqp->cq_add += sizeof(unsign16);
        !          1343: 
        !          1344:        if(cqp->cq_add == cqp->cq_wrap) /* Wrap if necessary */
        !          1345:                cqp->cq_add = (unsign16)((int)cqp->cq_cqe - base);
        !          1346: 
        !          1347:        /* Interrupt the Board if his scan flag isn't on */
        !          1348: 
        !          1349:        if(!(cqp->scanflag & ON))
        !          1350: 
        !          1351:                INTNI(mp);              /* Interrupt the Board */
        !          1352: 
        !          1353: }
        !          1354: 
        !          1355: /*
        !          1356:  * The NpRemCQE routine is used to remove the next CQE from the Command Queue
        !          1357:  * specified by cqp. The common offset of shared memory used by the device
        !          1358:  * is specified by base. NpRemCQE returns a pointer to the next CQE or
        !          1359:  * NULL if there are none left. This routine will also update the cqe_rem
        !          1360:  * offset which specifies where the next element to be removed from the
        !          1361:  * queue is located.
        !          1362:  */
        !          1363: 
        !          1364: struct CQE *
        !          1365: NpRemCQE(cqp,base)
        !          1366: struct CmdQue *cqp;
        !          1367: int base;
        !          1368: {
        !          1369: 
        !          1370:        register unsign16 *temp;
        !          1371:        register unsign16 cqe_offset;
        !          1372: 
        !          1373:        cqp->chngflag &= ~ON;                   /* Turn off unconditionally */
        !          1374: 
        !          1375:        /* Get address of element to remove */
        !          1376: 
        !          1377:        temp = (unsign16 *)(base +cqp->cq_rem);
        !          1378: 
        !          1379:        if(*temp == NULL)                       /* If none left, go home */
        !          1380:                return((struct CQE *) NULL);
        !          1381: 
        !          1382:        else cqe_offset = *temp;                /* Offset of CQE to remove */
        !          1383: 
        !          1384:        /* Update the Command Queue's cqe_rem offset */
        !          1385: 
        !          1386:        *temp = NULL;                           /* Clear out this entry */
        !          1387: 
        !          1388:        cqp->cq_rem += sizeof(unsign16);        /* Bump offset */
        !          1389: 
        !          1390:        if(cqp->cq_rem == cqp->cq_wrap)         /* Wrap if necessary */
        !          1391:                cqp->cq_rem = (unsign16)((int)cqp->cq_cqe - base);
        !          1392: 
        !          1393:        temp = (unsign16 *)(base + cqe_offset); /* CQE address */
        !          1394:        return((struct CQE *)temp);             /* is returned */
        !          1395: }
        !          1396: 
        !          1397: /*
        !          1398:  * NpAddReq will add the specified npreq structure to the queue controlled
        !          1399:  * by head.
        !          1400:  */
        !          1401: 
        !          1402: NpAddReq(head,rp)
        !          1403: register struct npreq *head, *rp;
        !          1404: {
        !          1405: 
        !          1406:        if(NpDebug & DEBENTRY)
        !          1407:                printf("NpAddReq\n");
        !          1408: 
        !          1409:        if(NpDebug & DEBREQ)
        !          1410:                printf("NpAddReq: %x\n",rp);
        !          1411: 
        !          1412:        rp->forw = head->forw;
        !          1413:        rp->forw->back = rp;
        !          1414:        rp->back = head;
        !          1415:        head->forw = rp;
        !          1416: 
        !          1417:        if(NpDebug & DEBENTRY)
        !          1418:                printf("NpAddReq...\n");
        !          1419: }
        !          1420: 
        !          1421: /*
        !          1422:  * NpRemReq is used to remove a npreq structure from the queue specified by
        !          1423:  * head.
        !          1424:  */
        !          1425: 
        !          1426: NpRemReq(rp)
        !          1427: register struct npreq *rp;
        !          1428: {
        !          1429: 
        !          1430:        if(NpDebug & DEBENTRY)
        !          1431:                printf("NpRemReq\n");
        !          1432: 
        !          1433:        if(NpDebug & DEBREQ)
        !          1434:                printf("NpRemReq: %x\n",rp);
        !          1435: 
        !          1436:        rp->back->forw = rp->forw;
        !          1437:        rp->forw->back = rp->back;
        !          1438: 
        !          1439:        if(NpDebug & DEBENTRY)
        !          1440:                printf("NpRemReq...\n");
        !          1441: }
        !          1442: 
        !          1443: 
        !          1444: /*
        !          1445:  * The following routines are used to communicate with the
        !          1446:  * NI Hardware via the CSR0 commands. These commands are issued during
        !          1447:  * the hardware initializtion process and may also be used subsequently
        !          1448:  * by privileged processes who wish to communicate in this way. The
        !          1449:  * convention for passing data as a Command Block is discussed in detail
        !          1450:  * in the NI1510 UNIBUS Compatible Ethernet Communications Processor
        !          1451:  * Hardware Specification.
        !          1452:  */
        !          1453: 
        !          1454: NpSendCSR0(iobase,src,bcount)
        !          1455: struct NPREG *iobase;
        !          1456: register unsign16 *src;
        !          1457: int bcount;
        !          1458: {
        !          1459:        register int wcount;
        !          1460:        int i;
        !          1461:        int csrflag;
        !          1462:        unsign16 tmp;
        !          1463: 
        !          1464:        if(NpDebug & DEBENTRY)
        !          1465:                printf("NpSendCSR0\n");
        !          1466: 
        !          1467:        /* Jolt the board into CSR0 command mode if necessary */
        !          1468: 
        !          1469:        if(!(RCSR1(iobase) & NPENB)){   
        !          1470:                tmp = NPCLEAR;          /* MC68000 clr reads before writing */
        !          1471:                WCSR0(iobase,tmp);      
        !          1472:        }
        !          1473: 
        !          1474:        wcount = (bcount +1) >> 1;      /* Convert byte count to word count */
        !          1475: 
        !          1476:        /* Clear timer flag before beginning the timer */
        !          1477: 
        !          1478:        csrflag = NPCLEAR;
        !          1479:        timeout(NpTimer,&csrflag,DIAGTIME);
        !          1480: 
        !          1481:        for(i = 0; (i < wcount) & (csrflag == NPCLEAR); i++) {
        !          1482:                while(! ((RCSR1(iobase) & NPENB) && (RCSR1(iobase) & NPRDY)))
        !          1483:                        if(csrflag) break;
        !          1484:                WCSR0(iobase,*src);
        !          1485:                src++;                  /* Better do this WCSR is a macro */
        !          1486:        }
        !          1487: 
        !          1488:        /* Clear the timer entry */
        !          1489: 
        !          1490:        untimeout(NpTimer,&csrflag);
        !          1491: 
        !          1492:        /* Error if timer went off */
        !          1493: 
        !          1494:        if(csrflag)
        !          1495:                return(EIO);    
        !          1496: 
        !          1497:        if(NpDebug & DEBENTRY)
        !          1498:                printf("NpSendCSR0...\n");
        !          1499:        return(0);
        !          1500: }
        !          1501: 
        !          1502: /*
        !          1503:  * NpSetIntLev sets the UNIBUS interrupt vector to be used by the NP board when
        !          1504:  * interupting the host. The board is specified by mp.
        !          1505:  */
        !          1506: 
        !          1507: NpSetIntLevel(mp,level)
        !          1508: struct npmaster *mp;
        !          1509: int level;
        !          1510: {
        !          1511: 
        !          1512:        struct {
        !          1513:                unsign16 cmd_word;
        !          1514:                unsign16 int_level;
        !          1515:        }cmd_block;
        !          1516: 
        !          1517:        cmd_block.cmd_word = NPCBI | CBICNT;
        !          1518:        cmd_block.int_level = level;
        !          1519: 
        !          1520:        return(NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block)));
        !          1521: }
        !          1522: 
        !          1523: /*
        !          1524:  * NpSetMemAddr is used to declare the shared memory area address to be used
        !          1525:  * for communication between the driver and the device. This address is used
        !          1526:  * to access data structures by acting as a base from which defined offsets
        !          1527:  * locate data. The board is specified by mp.
        !          1528:  */
        !          1529: 
        !          1530: NpSetMemAddr(mp,addr)
        !          1531: struct npmaster *mp;
        !          1532: caddr_t addr;
        !          1533: {
        !          1534: 
        !          1535:        caddr_t shmaddr;
        !          1536:        int error;
        !          1537: 
        !          1538:        struct {
        !          1539:                unsign16 cmd_word;
        !          1540:                unsign16 hi_addr;
        !          1541:                unsign16 lo_addr;
        !          1542:        } cmd_block;
        !          1543: 
        !          1544:        if(NpDebug & DEBENTRY)
        !          1545:                printf("NpSetMemAddr\n");
        !          1546: 
        !          1547:        shmaddr = addr;
        !          1548: 
        !          1549:        if(NpDebug & DEBMEM)
        !          1550:                printf("NpSetMemAddr, addr is %x shmaddr is %x.\n",addr,shmaddr);
        !          1551: 
        !          1552:        cmd_block.cmd_word = NPCMD | CMDCNT;
        !          1553:        cmd_block.hi_addr = HIWORD(shmaddr);
        !          1554:        cmd_block.lo_addr = LOWORD(shmaddr);
        !          1555: 
        !          1556:        error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
        !          1557: 
        !          1558:        if(NpDebug & DEBENTRY)
        !          1559:                printf("NpSetMemAddr...\n");
        !          1560: 
        !          1561:        return(error);
        !          1562: }
        !          1563: 
        !          1564: 
        !          1565: /*
        !          1566:  * NpSetXeqAddr specifies the address at which the board should begin
        !          1567:  * execution of its on-board software. It also indicates the shared memory
        !          1568:  * address to be used. The board is specified by mp.
        !          1569:  */
        !          1570: 
        !          1571: NpSetXeqAddr(mp,addr)
        !          1572: struct npmaster *mp;
        !          1573: caddr_t addr;
        !          1574: {
        !          1575:        caddr_t shmaddr;
        !          1576:        int error;
        !          1577: 
        !          1578:        struct {
        !          1579:                unsign16 cmd_word;
        !          1580:                unsign16 hi_addr;
        !          1581:                unsign16 lo_addr;
        !          1582:                unsign16 mhi_addr;
        !          1583:                unsign16 mlo_addr;
        !          1584:        } cmd_block;
        !          1585: 
        !          1586:        if(NpDebug & DEBENTRY)
        !          1587:                printf("NpSetXeqAddr\n");
        !          1588: 
        !          1589:        shmaddr = (caddr_t)((int)mp->iomapbase & UBADDRMASK);
        !          1590: 
        !          1591:        cmd_block.cmd_word = NPBGN | NPCMD | NPLST | (BGNCNT + CMDCNT);
        !          1592:        cmd_block.hi_addr = HIWORD(addr);
        !          1593:        cmd_block.lo_addr = LOWORD(addr);
        !          1594:        cmd_block.mhi_addr = HIWORD(shmaddr);
        !          1595:        cmd_block.mlo_addr = LOWORD(shmaddr);
        !          1596: 
        !          1597:        if(NpDebug & DEBINIT) {
        !          1598:                printf("NpSetXeqAdddr: hi: %x lo: %x\n",HIWORD(addr), LOWORD(addr));
        !          1599:                printf("NpSetXeqAdddr: mhi: %x mlo: %x\n",HIWORD(shmaddr),LOWORD(shmaddr));
        !          1600:        }
        !          1601: 
        !          1602:        error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
        !          1603: 
        !          1604:        if(NpDebug & DEBENTRY)
        !          1605:                printf("NpSetXeqAddr...\n");
        !          1606: 
        !          1607:        return(error);
        !          1608: }
        !          1609: 
        !          1610: /*
        !          1611:  * NPIO issues a CSR0 load or dump request to the I-Board after packaging a
        !          1612:  * CSR0 Command Block.
        !          1613:  */
        !          1614: 
        !          1615: NPIO(mp,src,dest,count,dir)
        !          1616: struct npmaster *mp;
        !          1617: paddr_t dest;
        !          1618: paddr_t src;
        !          1619: unsign16 count;
        !          1620: int dir;               /* Direction  READ/WRITE */
        !          1621: {
        !          1622: 
        !          1623:        int error;
        !          1624: 
        !          1625:        struct {
        !          1626:                unsign16 cmd_word;      /* Command Word */
        !          1627:                unsign16 shi_addr;      /* High word of Source Address */
        !          1628:                unsign16 slo_addr;      /* Low word of Source Address */
        !          1629:                unsign16 dhi_addr;      /* High word of Destination Address */
        !          1630:                unsign16 dlo_addr;      /* Low word of Destination Address */
        !          1631:                unsign16 count;         /* Byte count */
        !          1632:                unsign16 intlevel;      /* Interrupt level to host */
        !          1633:        } cmd_block;
        !          1634: 
        !          1635:        if(NpDebug & DEBENTRY)
        !          1636:                printf("NPIO\n");
        !          1637:        if(NpDebug & DEBMAINT) {
        !          1638:                printf("I/O src addr = %x, dest addr = %x \n",src,dest);
        !          1639:                printf("I/O count = %d \n",count);
        !          1640:        }
        !          1641: 
        !          1642:        cmd_block.cmd_word = NPCBI | NPLST | (CBICNT + IOCNT);
        !          1643:        cmd_block.intlevel = mp->vector;
        !          1644:        cmd_block.shi_addr = HIWORD(src);
        !          1645:        cmd_block.slo_addr = LOWORD(src);
        !          1646:        cmd_block.dhi_addr = HIWORD(dest);
        !          1647:        cmd_block.dlo_addr = LOWORD(dest);
        !          1648:        cmd_block.count = count;
        !          1649:        if(dir == B_READ)
        !          1650:                cmd_block.cmd_word |= NPDMP;
        !          1651:        else
        !          1652:                cmd_block.cmd_word |= NPLD;
        !          1653: 
        !          1654: 
        !          1655:        if(NpDebug & DEBIO) {
        !          1656:                printf("cmd: %x int: %o shi: %x slo: %x dhi: %x dlo: %x cnt: %x\n",
        !          1657:        cmd_block.cmd_word,cmd_block.intlevel,cmd_block.shi_addr,cmd_block.slo_addr,
        !          1658:        cmd_block.dhi_addr,cmd_block.dlo_addr,cmd_block.count);
        !          1659:        }
        !          1660:        
        !          1661:        mp->flags |= CSRPEND;           /* CSR0 command pending */
        !          1662: 
        !          1663:        error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
        !          1664:        if(NpDebug & DEBENTRY)
        !          1665:                printf("NPIO...\n");
        !          1666: 
        !          1667:        return(error);
        !          1668: }
        !          1669: 
        !          1670: 
        !          1671: /*
        !          1672:  * NpKill will terminate all outstanding requests for the specified board.
        !          1673:  */
        !          1674: 
        !          1675: NpKill(mp,curr_rp)
        !          1676: struct npmaster *mp;
        !          1677: struct npreq *curr_rp;
        !          1678: {
        !          1679:        struct npreq *rp;
        !          1680:        int s;
        !          1681: 
        !          1682:        if(NpDebug & DEBENTRY)
        !          1683:                printf("NpKill\n");
        !          1684: 
        !          1685:        mp->reqtab->reqcnt = 0;         /* Init request count */
        !          1686: 
        !          1687:        s = spl4();                     /* Disable interrupts */
        !          1688: 
        !          1689:        /* Mark each active request as having an error and wake him up */
        !          1690: 
        !          1691:        for(rp = mp->reqtab->forw;rp != mp->reqtab;rp = rp->forw) {
        !          1692: 
        !          1693:                if(rp == curr_rp) continue;
        !          1694: 
        !          1695:                rp->flags |= (IOABORT | REQDONE);
        !          1696:                mp->reqtab->reqcnt++;
        !          1697:                if(rp->flags & NPUIO)
        !          1698:                        iodone(&rp->buf);
        !          1699:                else wakeup((caddr_t)rp);
        !          1700:        }
        !          1701: 
        !          1702:        if(NpDebug & DEBMAINT)
        !          1703:                printf("NpKill, req count is %d\n",mp->reqtab->reqcnt);
        !          1704: 
        !          1705:        splx(s);
        !          1706: 
        !          1707:        if(NpDebug & DEBENTRY)
        !          1708:                printf("NpKill...\n");
        !          1709: 
        !          1710:        return(0);
        !          1711: 
        !          1712: }
        !          1713: 
        !          1714: /* Hardware and Software Initializations for the specified unit */
        !          1715: 
        !          1716: NpReset(mp,rp)
        !          1717: register struct npmaster *mp;
        !          1718: struct npreq *rp;
        !          1719: {
        !          1720:        int error;
        !          1721: 
        !          1722:        if(NpDebug & DEBENTRY)
        !          1723:                printf("NpReset!\n");
        !          1724: 
        !          1725:        /* Mark board as being reset and make unavailable */
        !          1726: 
        !          1727:        mp->flags = BRDRESET;
        !          1728: 
        !          1729:        /* Abort outstanding requests for this board */
        !          1730: 
        !          1731:        mp->reqtab->reqcnt = 0;         /* Init request count */
        !          1732: 
        !          1733:        /* Wakeup Poller if available and wait until he's gone */
        !          1734: 
        !          1735:        if(NpState & ICPAVAIL) {
        !          1736: 
        !          1737:                mp->flags |= BOARDREQ;
        !          1738:                mp->reqtab->reqcnt++;
        !          1739: 
        !          1740:                if(NpDebug & DEBMAINT)
        !          1741:                        printf("Waking ICP in reset!\n");
        !          1742: 
        !          1743:                wakeup((caddr_t)&NpState);
        !          1744: 
        !          1745:                while(mp->reqtab->reqcnt)
        !          1746:                        sleep((caddr_t)(&mp->reqtab),PZERO +1);
        !          1747: 
        !          1748:                if(NpDebug & DEBMAINT)
        !          1749:                        printf("Reset:awoken by ICP senior!\n");
        !          1750: 
        !          1751:        }
        !          1752: 
        !          1753:        /* Abort outstanding requests and wait till they're gone */
        !          1754: 
        !          1755:        NpKill(mp,rp);
        !          1756: 
        !          1757:        while(mp->reqtab->reqcnt) {
        !          1758: 
        !          1759:                if(NpDebug & DEBMAINT) {
        !          1760:                        printf("Sleeping in NpReset on reqtab!\n");
        !          1761:                        printf("Reqcnt is %d.\n",mp->reqtab->reqcnt);
        !          1762:                }
        !          1763: 
        !          1764:                sleep((caddr_t)(&mp->reqtab),PZERO +1);
        !          1765: 
        !          1766:        }
        !          1767: 
        !          1768:        /* Free up I/O Map registers if any allocated */
        !          1769: 
        !          1770:        if(mp->iomapbase) {
        !          1771: 
        !          1772:                if(NpDebug & DEBMEM)
        !          1773:                        printf("freeing shared memory map.\n");
        !          1774: 
        !          1775:                ubarelse(mp->devp->ui_ubanum,&mp->iomapbase);
        !          1776:                mp->iomapbase = 0;
        !          1777:        }
        !          1778: 
        !          1779:        /* Initialize S/W data structures in NP Driver */
        !          1780: 
        !          1781:        NpSWinit(mp->unit);             /* Software initialization */
        !          1782: 
        !          1783:        /* Hardware initialization of the board */
        !          1784: 
        !          1785:        error = NpHWinit(mp->unit);     /* Hardware initialization */
        !          1786: 
        !          1787:        mp->flags &= ~BRDRESET;         /* Initialization complete */
        !          1788: 
        !          1789:        /* Initialize Pseudo-Drivers */
        !          1790: 
        !          1791:        WnInitFlag = 0;                 /* WN Pseudo-Driver */
        !          1792:        IsInitFlag = 0;                 /* IS Pseudo-Driver */
        !          1793: 
        !          1794:        if (IxReset)
        !          1795:                (*IxReset)(mp->unit, mp->devp->ui_ubanum, rp);
        !          1796: 
        !          1797:        /* Clear Poller's State Flag */
        !          1798: 
        !          1799:        NpState = NPCLEAR;
        !          1800: 
        !          1801:        if(NpDebug & DEBENTRY)
        !          1802:                printf("NpReset...\n");
        !          1803:        
        !          1804:        return(error);
        !          1805: }
        !          1806: 
        !          1807: /*
        !          1808:  * General purpose timeout function which sets the flag passed to it
        !          1809:  * as argument.
        !          1810:  */
        !          1811: 
        !          1812: NpTimer(flagp)
        !          1813: int *flagp;
        !          1814: {
        !          1815:        *flagp = NPSET;
        !          1816: }
        !          1817: 
        !          1818: NpStats()
        !          1819: {
        !          1820:        if(NpDebug & DEBENTRY)
        !          1821:                printf("npstats\n");
        !          1822:        return(0);
        !          1823: }
        !          1824: 
        !          1825: /*
        !          1826:  * NpCloseConn is called to issue a close connection command to the I-Board.
        !          1827:  */
        !          1828: 
        !          1829: NpCloseConn(mp,protocol)
        !          1830: struct npmaster *mp;
        !          1831: unsign16 protocol;
        !          1832: {
        !          1833: 
        !          1834:        register struct npreq *rp;
        !          1835:        register struct CQE *ep;
        !          1836:        int pri;
        !          1837: 
        !          1838:        if(NpDebug & DEBENTRY)
        !          1839:                printf("NpCloseConn\n");
        !          1840: 
        !          1841:        /*
        !          1842:         * Don't issue the Close Connection command if the Board
        !          1843:          * isn't up.
        !          1844:          */
        !          1845: 
        !          1846:        if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol))) {
        !          1847:                return;
        !          1848:        }
        !          1849: 
        !          1850:        /* Get a Request structure */
        !          1851: 
        !          1852:        while((rp = NpGetReq(mp->reqtab)) == NULL) {
        !          1853:                mp->reqtab->flags |= WANTREQ;
        !          1854:                sleep((caddr_t)(mp->reqtab),PZERO -1);
        !          1855:        }
        !          1856: 
        !          1857:        rp->intr = (int (*)())0;        /* Do not call interrupt routine */
        !          1858:        rp->flags = NPCLEAR;
        !          1859:        rp->mapbase = 0;                /* Clear mapping information */
        !          1860: 
        !          1861:        ep = rp->element;               /* Handy pointer */
        !          1862: 
        !          1863:        /* Fill in CQE */
        !          1864: 
        !          1865:        ep->cqe_wind = 0;               /* Entire buffer mapped */
        !          1866:        ep->cqe_nbuf = 1;               /* Must be 1, no buffer chaining */
        !          1867:        ep->cqe_char = 0;               /* Set to 0 for now */
        !          1868: 
        !          1869:        ep->cqe_func = NPSTOP;          /* OS_STP to I-Board */
        !          1870: 
        !          1871:        ep->cqe_prot = protocol;        /* Protocol of this connection */
        !          1872:        ep->cqe_lenrpb = 0;             /* Parameter block length */
        !          1873: 
        !          1874:        ep->cqe_ust0 = ep->cqe_ust1 = NPCLEAR;  /* Clear status flags */
        !          1875: 
        !          1876:        ep->cqe_famid = (unsign32)u.u_procp->p_pid;  /* Process ID */
        !          1877: 
        !          1878:        NpAddReq(mp->reqtab,rp);        /* Queue onto active list */
        !          1879: 
        !          1880:        pri = spl4();                   /* Mask our interrupts */
        !          1881: 
        !          1882:        NpAddCQE(ep,&mp->shmemp->devcq,mp); /* Add CQE to device's queue */
        !          1883: 
        !          1884:        /* Wait for command to complete */
        !          1885: 
        !          1886:        while(!(rp->flags & REQDONE)) 
        !          1887:                sleep((caddr_t)rp,PZERO - 1);
        !          1888: 
        !          1889:        splx(pri);
        !          1890: 
        !          1891:        NpRemReq(rp);                   /* Remove request from active list */
        !          1892: 
        !          1893:        NpFreeReq(mp->reqtab,rp);       /* Deallocate request structure */
        !          1894: 
        !          1895:        if(NpDebug & DEBENTRY)
        !          1896:                printf("NpCloseConn...\n");
        !          1897: 
        !          1898: }
        !          1899: 
        !          1900: /*
        !          1901:  * This function allows the protocol to be changed for a given connection.
        !          1902:  * It returns 0 for success, error code otherwise.
        !          1903:  */
        !          1904: 
        !          1905: NpProtChange(protocol,unit)
        !          1906: register unsign16 protocol;
        !          1907: register int unit;
        !          1908: {
        !          1909: 
        !          1910:        register struct npmaster *mp;
        !          1911: 
        !          1912:        /* Privileged users only for Maintenance Protocol */
        !          1913: 
        !          1914:        if((protocol == NPMAINT) && (u.u_uid != 0)) 
        !          1915:                return(EPERM);
        !          1916: 
        !          1917:        if(NpDebug & DEBMAINT)
        !          1918:                printf("NpProtChange = %x\n",protocol);
        !          1919: 
        !          1920:        if(protocol != NPMAINT) {
        !          1921: 
        !          1922:                /* Make sure the I-Board supports the protocol */
        !          1923: 
        !          1924:                mp = &npmasters[unit];
        !          1925: 
        !          1926:                if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
        !          1927:                        return(ENXIO);
        !          1928:        }
        !          1929: 
        !          1930:        return(0);
        !          1931: }
        !          1932: 
        !          1933: /*
        !          1934:  * This function allows for the changing of the unit for a given connection.
        !          1935:  */
        !          1936: 
        !          1937: struct npmaster *
        !          1938: NpBoardChange(protocol,unit)
        !          1939: register unsign16 protocol;
        !          1940: register int unit;                     /* Unit number */
        !          1941: {
        !          1942:        register struct npmaster *mp;
        !          1943: 
        !          1944: 
        !          1945:        if(unit > NNP)
        !          1946:                return((struct npmaster *)0);
        !          1947: 
        !          1948:        if(protocol != NPMAINT) {
        !          1949: 
        !          1950:                /*
        !          1951:                 * Loop through the master structures finding a board which 
        !          1952:                 * supports the requested protocol.
        !          1953:                 */
        !          1954: 
        !          1955:                for(mp = npmasters; mp ; mp = mp->next) {
        !          1956: 
        !          1957:                        if(mp->flags & BADBOARD)
        !          1958:                                continue;
        !          1959: 
        !          1960:                        if(((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
        !          1961:                                return(mp);
        !          1962:                }
        !          1963:                return((struct npmaster *)0);
        !          1964:        }
        !          1965:        return(&npmasters[unit]);
        !          1966: }
        !          1967: 
        !          1968: /*
        !          1969:  * NpMapMem - maps the user's memory updating the fields in the npreq
        !          1970:  * structure and returning the mapped address in rp->buffaddr.
        !          1971:  */
        !          1972: NpMapMem(mp,rp,addr,count)
        !          1973: register struct npmaster *mp;
        !          1974: register struct npreq *rp;
        !          1975: caddr_t        addr;
        !          1976: int    count;
        !          1977: {
        !          1978: 
        !          1979:        if(NpDebug & DEBENTRY)
        !          1980:                printf("NpMapMem\n");
        !          1981:        if(NpDebug & DEBIO)
        !          1982:                printf("mp %x rp %x addr %x count %x\n",mp,rp,addr,count);
        !          1983: 
        !          1984:        rp->virtmem = addr;
        !          1985:        rp->bytecnt = count;
        !          1986: 
        !          1987:        rp->buf.b_un.b_addr = addr;
        !          1988:        rp->buf.b_flags = B_PHYS | B_BUSY;
        !          1989:        rp->buf.b_bcount = count;
        !          1990:        rp->buf.b_proc = rp->procp;
        !          1991:                
        !          1992:        rp->procp->p_flag |= SPHYSIO;
        !          1993:        vslock(addr,count);
        !          1994: 
        !          1995:        rp->mapbase = ubasetup(mp->devp->ui_ubanum,&rp->buf,0);
        !          1996: 
        !          1997:        rp->bufaddr = (caddr_t)(rp->mapbase & UBADDRMASK);
        !          1998: 
        !          1999:        if(NpDebug & DEBENTRY)
        !          2000:                printf("NpMapMem...\n");
        !          2001: }
        !          2002: 
        !          2003: /*
        !          2004:  * Unmap the user's memory and free up mapping registers 
        !          2005:  */
        !          2006: 
        !          2007: NpUnMapMem(mp,rp)
        !          2008: struct npmaster *mp;
        !          2009: struct npreq *rp;
        !          2010: {
        !          2011:        if(NpDebug & DEBENTRY)
        !          2012:                printf("NpUnMapMem\n");
        !          2013: 
        !          2014:        ubarelse(mp->devp->ui_ubanum,&rp->mapbase);
        !          2015:        rp->mapbase = 0;
        !          2016:        vsunlock(rp->virtmem,rp->bytecnt,B_READ);
        !          2017:        rp->procp->p_flag &= ~SPHYSIO;
        !          2018: 
        !          2019:        if(NpDebug & DEBENTRY)
        !          2020:                printf("NpUnMapMem...\n");
        !          2021: }
        !          2022: 
        !          2023: npprobe(reg, ui)
        !          2024: caddr_t reg;
        !          2025: struct uba_device *ui;
        !          2026: {
        !          2027: register int br,cvec;
        !          2028: u_short csraddr;
        !          2029: int i;
        !          2030: 
        !          2031: #ifdef lint
        !          2032:        br = 0; cvec = br; br = cvec;
        !          2033: #endif
        !          2034: 
        !          2035:        if(NpDebug & DEBINIT)
        !          2036:                printf("In npprobe, regaddr is %x!\n",reg);
        !          2037: 
        !          2038:        cvec = (uba_hd[numuba].uh_lastiv -= 4); 
        !          2039: 
        !          2040: #ifdef OLDBSD4_2
        !          2041:        /* Find unit number from npstd[] by matching the csr address */
        !          2042: 
        !          2043:        csraddr = (u_short)((int)reg & 0x0FFFF);
        !          2044: 
        !          2045:        for(i = 0; i < NNP; i++) {
        !          2046: 
        !          2047:                if(csraddr == npstd[i]) {
        !          2048:                        npvectors[i] = cvec;
        !          2049:                        break;
        !          2050:                }
        !          2051:        }
        !          2052:        if(i == NNP)
        !          2053:                printf("Couldn't find device in npstd[]!\n");
        !          2054: #else
        !          2055:        npvectors[ui->ui_unit] = cvec;
        !          2056: #endif
        !          2057:        br = 0x15;
        !          2058: 
        !          2059:        if(NpDebug & DEBINIT)
        !          2060:                printf("npprobe...\n");
        !          2061: 
        !          2062:        return(sizeof(struct NPREG));           /* CSR Registers */
        !          2063: 
        !          2064: }
        !          2065: 
        !          2066: npattach(ui)
        !          2067: register struct uba_device *ui;
        !          2068: {
        !          2069: 
        !          2070:        if(NpDebug & DEBINIT)
        !          2071:                printf("In npattach, ui is %x.\n",ui);
        !          2072: 
        !          2073:        npinit(ui->ui_unit);
        !          2074: 
        !          2075:        if (IxAttach)
        !          2076:                (*IxAttach)(ui);
        !          2077: 
        !          2078:        if(NpDebug & DEBINIT)
        !          2079:                printf("npattach...\n");
        !          2080: }
        !          2081: 
        !          2082: #endif

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