Return to tmscp.c CVS log

Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba

Annotation of 43BSD/sys/vaxuba/tmscp.c, revision 1.1

1.1     ! root        1: /*     @(#)tmscp.c     7.1 (Berkeley) 6/5/86 */
        !             2: 
        !             3: #ifndef lint
        !             4: static char    *sccsid = "@(#)tmscp.c  1.24    (ULTRIX)        1/21/86";
        !             5: #endif lint
        !             6: 
        !             7: 
        !             8: /************************************************************************
        !             9:  *                                                                     *
        !            10:  *        Licensed from Digital Equipment Corporation                  *
        !            11:  *                       Copyright (c)                                         *
        !            12:  *               Digital Equipment Corporation                         *
        !            13:  *                   Maynard, Massachusetts                            *
        !            14:  *                         1985, 1986                                  *
        !            15:  *                    All rights reserved.                             *
        !            16:  *                                                                     *
        !            17:  *        The Information in this software is subject to change        *
        !            18:  *   without notice and should not be construed as a commitment        *
        !            19:  *   by  Digital  Equipment  Corporation.   Digital   makes  no        *
        !            20:  *   representations about the suitability of this software for        *
        !            21:  *   any purpose.  It is supplied "As Is" without expressed  or        *
        !            22:  *   implied  warranty.                                                *
        !            23:  *                                                                     *
        !            24:  *        If the Regents of the University of California or its        *
        !            25:  *   licensees modify the software in a manner creating                *
        !            26:  *   diriviative copyright rights, appropriate copyright               *
        !            27:  *   legends may be placed on  the drivative work in addition                  *
        !            28:  *   to that set forth above.                                          *
        !            29:  *                                                                     *
        !            30:  ************************************************************************
        !            31:  * 
        !            32:  * tmscp.c - TMSCP (TK50/TU81) tape device driver
        !            33:  * 
        !            34:  * Modification History:
        !            35:  *
        !            36:  * 06-Jan-86 - afd
        !            37:  *     Changed the probe routine to use DELAY (not TODR).  This now
        !            38:  *     works for MicroVAXen as well.  This eliminates the busy-wait
        !            39:  *     for MicroVAXen so a dead TK50 controller will not hang autoconf.
        !            40:  *
        !            41:  * 06-Dec-85 - afd
        !            42:  *     Fixed a bug in density selection.  The "set unit characteristics"
        !            43:  *     command to select density, was clearing the "unit flags" field
        !            44:  *     where the CACHE bit was for TU81-E.  Now the unit's "format" and
        !            45:  *     "unitflgs" are saved in tms_info struct.  And are used on STUNT
        !            46:  *     commands.
        !            47:  *
        !            48:  * 19-Oct-85 - afd
        !            49:  *     Added support to the open routine to allow drives to be opened
        !            50:  *     for low density (800 or 1600 bpi) use.  When the slave routine
        !            51:  *     initiates a "get-unit-char" cmd, the format menu for the unit
        !            52:  *     is saved in the tms_info structure. The format menu is used in the
        !            53:  *     start routine to select the proper low density.
        !            54:  *
        !            55:  * 02-Oct-85 - afd
        !            56:  *     When a tmscp-type controller is initializing, it is possible for
        !            57:  *     the sa reg to become 0 between states.  Thus the init code in
        !            58:  *     the interrupt routine had to be modified to reflect this.
        !            59:  *
        !            60:  * 21-Sep-85 - afd
        !            61:  *     The TK50 declares a serious exception when a tape mark is encountered.
        !            62:  *     This causes problems to dd (& other UN*X utilities).  So a flag
        !            63:  *     is set in the rsp() routine when a tape mark is encountered.  If
        !            64:  *     this flag is set, the start() routine appends the Clear Serious
        !            65:  *     Exception modifier to the next command.
        !            66:  *
        !            67:  * 03-Sep-85 -- jaw
        !            68:  *     messed up previous edit..
        !            69:  *
        !            70:  * 29-Aug-85 - jaw
        !            71:  *     fixed bugs in 8200 and 750 buffered datapath handling.
        !            72:  *
        !            73:  * 06-Aug-85 - afd
        !            74:  *   1. When repositioning records or files, the count of items skipped
        !            75:  *     does NOT HAVE to be returned by controllers (& the TU81 doesn't).
        !            76:  *     So tmscprsp() had to be modified to stop reporting
        !            77:  *     residual count errors on reposition commands.
        !            78:  *
        !            79:  *   2. Fixed bug in the open routine which allowed multiple opens.
        !            80:  *
        !            81:  * 18-Jul-85 - afd
        !            82:  *   1. Need to return status when mt status (or corresponding ioctl) is done.
        !            83:  *     Save resid, flags, endcode & status in tmscprsp() routine (except on
        !            84:  *     clear serious exception no-op).  Return these fields when status
        !            85:  *     ioctl is done (in tmscpcommand()).  How they are returned:
        !            86:  *             mt_resid = resid
        !            87:  *             mt_dsreg = flags|endcode
        !            88:  *             mt_erreg = status
        !            89:  *
        !            90:  *   2. Added latent support for enabling/disabling caching.  This is
        !            91:  *     handled along with all other ioctl commands.
        !            92:  *
        !            93:  *   3. Need to issue a no-op on unrecognized ioctl in tmscpstart(), since
        !            94:  *     we have already commited to issuing a command at that point.
        !            95:  *
        !            96:  *   4. In tmscprsp() routine if encode is 0200 (invalid command issued);
        !            97:  *     We need to: Unlink the buffer from the I/O wait queue,
        !            98:  *     and signal iodone, so the higher level command can exit!
        !            99:  *     Just as if it were a valid command.
        !           100:  *
        !           101:  * 11-jul-85 -- jaw
        !           102:  *     fix bua/bda map registers.
        !           103:  *
        !           104:  * 19-Jun-85 -- jaw
        !           105:  *     VAX8200 name change.
        !           106:  *
        !           107:  * 06-Jun-85 - jaw
        !           108:  *     fixes for 8200.
        !           109:  *
        !           110:  * 9-Apr-85 - afd
        !           111:  *     Added timeout code to the probe routine, so if the controller
        !           112:  *     fails to init in 10 seconds we return failed status.
        !           113:  *
        !           114:  * 13-Mar-85 -jaw
        !           115:  *     Changes for support of the VAX8200 were merged in.
        !           116:  *
        !           117:  * 27-Feb-85 -tresvik
        !           118:  *     Changes for support of the VAX8600 were merged in.
        !           119:  *
        !           120:  */
        !           121: 
        !           122: #include "tms.h"
        !           123: #if NTMSCP > 0
        !           124: 
        !           125: #include "../vax/pte.h"
        !           126: 
        !           127: #include "param.h"
        !           128: #include "systm.h"
        !           129: #include "buf.h"
        !           130: #include "conf.h"
        !           131: #include "dir.h"
        !           132: #include "user.h"
        !           133: #include "file.h"
        !           134: #include "map.h"
        !           135: #include "vm.h"
        !           136: #include "ioctl.h"
        !           137: #include "syslog.h"
        !           138: #include "mtio.h"
        !           139: #include "cmap.h"
        !           140: #include "uio.h"
        !           141: #include "tty.h"
        !           142: 
        !           143: #include "../vax/cpu.h"
        !           144: #include "../vax/mtpr.h"
        !           145: #include "ubareg.h"
        !           146: #include "ubavar.h"
        !           147: 
        !           148: #define TENSEC (1000)
        !           149: #define        TMS_PRI LOG_INFO
        !           150: 
        !           151: #define NRSPL2  3               /* log2 number of response packets */
        !           152: #define NCMDL2  3               /* log2 number of command packets */
        !           153: #define NRSP    (1<<NRSPL2)
        !           154: #define NCMD    (1<<NCMDL2)
        !           155: 
        !           156: #include "tmscpreg.h"
        !           157: #include "../vax/tmscp.h"
        !           158: 
        !           159: /* Software state per controller */
        !           160: 
        !           161: struct tmscp_softc {
        !           162:        short   sc_state;       /* state of controller */
        !           163:        short   sc_mapped;      /* Unibus map allocated for tmscp struct? */
        !           164:        int     sc_ubainfo;     /* Unibus mapping info */
        !           165:        struct  tmscp *sc_tmscp;   /* Unibus address of tmscp struct */
        !           166:        int     sc_ivec;        /* interrupt vector address */
        !           167:        short   sc_credits;     /* transfer credits */
        !           168:        short   sc_lastcmd;     /* pointer into command ring */
        !           169:        short   sc_lastrsp;     /* pointer into response ring */
        !           170: } tmscp_softc[NTMSCP];
        !           171: 
        !           172: struct tmscp {
        !           173:        struct tmscpca  tmscp_ca;         /* communications area */
        !           174:        struct mscp     tmscp_rsp[NRSP];  /* response packets */
        !           175:        struct mscp     tmscp_cmd[NCMD];  /* command packets */
        !           176: } tmscp[NTMSCP];
        !           177: 
        !           178: /*
        !           179:  * Per drive-unit info
        !           180:  */
        !           181: struct tms_info {
        !           182:        daddr_t         tms_dsize;      /* Max user size from online pkt */
        !           183:        unsigned        tms_type;       /* Drive type int field  */
        !           184:        int             tms_resid;      /* residual from last xfer */
        !           185:        u_char          tms_endcode;    /* last command endcode */
        !           186:        u_char          tms_flags;      /* last command end flags */
        !           187:        unsigned        tms_status;     /* Command status from last command */
        !           188:        char            tms_openf;      /* lock against multiple opens */
        !           189:        char            tms_lastiow;    /* last op was a write */
        !           190:        char            tms_serex;      /* set when serious exception occurs */
        !           191:        char            tms_clserex;    /* set when serex being cleared by no-op */
        !           192:        short           tms_fmtmenu;    /* the unit's format (density) menu */
        !           193:        short           tms_unitflgs;   /* unit flag parameters */
        !           194:        short           tms_format;     /* the unit's current format (density) */
        !           195:        struct tty      *tms_ttyp;      /* record user's tty for errors */
        !           196: } tms_info[NTMS];
        !           197: struct uba_ctlr *tmscpminfo[NTMSCP];
        !           198: struct uba_device *tmsdinfo[NTMS];
        !           199: /* 
        !           200:  * ifdef other tmscp devices here if they allow more than 1 unit/controller
        !           201:  */
        !           202: struct uba_device *tmscpip[NTMSCP][1];
        !           203: struct buf rtmsbuf[NTMS];              /* raw i/o buffer */
        !           204: struct buf ctmscpbuf[NTMSCP];          /* internal cmd buffer (for ioctls) */
        !           205: struct buf tmsutab[NTMS];              /* Drive queue */
        !           206: struct buf tmscpwtab[NTMSCP];          /* I/O wait queue, per controller */
        !           207: int    tmscpmicro[NTMSCP];             /* to store microcode level */
        !           208: short  utoctlr[NTMS];                  /* Slave unit to controller mapping */
        !           209:                                        /* filled in by the slave routine */
        !           210: 
        !           211: /* Bits in minor device */
        !           212: #define        TMSUNIT(dev)    (minor(dev)&03)
        !           213: #define        T_NOREWIND      04
        !           214: #define        T_HIDENSITY     010
        !           215: 
        !           216: /* Slave unit to controller mapping */
        !           217: #define TMSCPCTLR(dev) (utoctlr[TMSUNIT(dev)])
        !           218: 
        !           219: /*
        !           220:  * Internal (ioctl) command codes (these must also be declared in the
        !           221:  * tmscpioctl routine).  These correspond to ioctls in mtio.h
        !           222:  */
        !           223: #define TMS_WRITM      0               /* write tape mark */
        !           224: #define TMS_FSF                1               /* forward space file */
        !           225: #define TMS_BSF                2               /* backward space file */
        !           226: #define TMS_FSR                3               /* forward space record */
        !           227: #define TMS_BSR                4               /* backward space record */
        !           228: #define TMS_REW                5               /* rewind tape */
        !           229: #define TMS_OFFL       6               /* rewind tape & mark unit offline */
        !           230: #define TMS_SENSE      7               /* noop - do a get unit status */
        !           231: #define TMS_CACHE      8               /* enable cache */
        !           232: #define TMS_NOCACHE    9               /* disable cache */
        !           233: /* These go last: after all real mt cmds, just bump the numbers up */
        !           234: #define TMS_CSE                10              /* clear serious exception */
        !           235: #define TMS_LOWDENSITY 11              /* set unit to low density */
        !           236: #define TMS_HIDENSITY  12              /* set unit to high density */
        !           237: 
        !           238: /*
        !           239:  * Controller states
        !           240:  */
        !           241: #define S_IDLE  0               /* hasn't been initialized */
        !           242: #define S_STEP1 1               /* doing step 1 init */
        !           243: #define S_STEP2 2               /* doing step 2 init */
        !           244: #define S_STEP3 3               /* doing step 3 init */
        !           245: #define S_SCHAR 4               /* doing "set controller characteristics" */
        !           246: #define S_RUN   5               /* running */
        !           247: 
        !           248: int     tmscperror = 0;                /* causes hex dump of packets */
        !           249: int    tmscp_cp_wait = 0;      /* Something to wait on for command */
        !           250:                                /* packets and or credits. */
        !           251: int    wakeup();
        !           252: extern int     hz;             /* Should find the right include */
        !           253: 
        !           254: #ifdef DEBUG
        !           255: #define printd if (tmscpdebug) printf
        !           256: int tmscpdebug = 1;
        !           257: #define        printd10 if(tmscpdebug >= 10) printf
        !           258: #endif 
        !           259: 
        !           260: int     tmscpprobe(), tmscpslave(), tmscpattach(), tmscpintr();
        !           261: struct  mscp *tmscpgetcp();
        !           262: 
        !           263: #define DRVNAME "tms"
        !           264: #define CTRLNAME "tmscp"
        !           265: 
        !           266: u_short tmscpstd[] = { 0174500, 0 };
        !           267: struct  uba_driver tmscpdriver =
        !           268: { tmscpprobe, tmscpslave, tmscpattach, 0, tmscpstd, DRVNAME, tmsdinfo, CTRLNAME
        !           269: , tmscpminfo, 0};
        !           270: 
        !           271: #define b_qsize         b_resid         /* queue size per drive, in tmsutab */
        !           272: #define b_ubinfo        b_resid         /* Unibus mapping info, per buffer */
        !           273: 
        !           274: 
        !           275: /*************************************************************************/
        !           276: 
        !           277: #define DELAYTEN 1000
        !           278: 
        !           279: tmscpprobe(reg, ctlr)
        !           280:        caddr_t reg;            /* address of the IP register */
        !           281:        int ctlr;               /* index of controller in the tmscp_softc array */
        !           282: {
        !           283:        register int br, cvec;  /* MUST be 1st (r11 & r10): IPL and intr vec */
        !           284:        register struct tmscp_softc *sc = &tmscp_softc[ctlr];
        !           285:                                /* ptr to software controller structure */
        !           286:        struct tmscpdevice *tmscpaddr; /* ptr to tmscpdevice struct (IP & SA) */
        !           287:        int count;              /* for probe delay time out */
        !           288: 
        !           289: #      ifdef lint
        !           290:        br = 0; cvec = br; br = cvec; reg = reg;
        !           291:        tmscpreset(0); tmscpintr(0);
        !           292: #      endif
        !           293: 
        !           294:        tmscpaddr = (struct tmscpdevice *) reg;
        !           295:        /* 
        !           296:         * Set host-settable interrupt vector.
        !           297:         * Assign 0 to the ip register to start the tmscp-device initialization.
        !           298:         * The device is not really initialized at this point, this is just to
        !           299:         * find out if the device exists.
        !           300:         */
        !           301:        sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4);
        !           302:        tmscpaddr->tmscpip = 0;
        !           303: 
        !           304:        count=0;
        !           305:        while(count < DELAYTEN)
        !           306:                {       /* wait for at most 10 secs */
        !           307:                if((tmscpaddr->tmscpsa & TMSCP_STEP1) != 0)
        !           308:                        break;
        !           309:                DELAY(10000);
        !           310:                count=count+1;
        !           311:                }
        !           312:        if (count == DELAYTEN)
        !           313:                return(0);              
        !           314: 
        !           315:        tmscpaddr->tmscpsa = TMSCP_ERR|(NCMDL2<<11)|(NRSPL2<<8)|TMSCP_IE|(sc->sc_ivec/4);
        !           316: 
        !           317:        count=0;
        !           318:        while(count < DELAYTEN)
        !           319:                {
        !           320:                if((tmscpaddr->tmscpsa & TMSCP_STEP2) != 0)
        !           321:                        break;
        !           322:                DELAY(10000);
        !           323:                count = count+1;
        !           324:                }
        !           325:        if (count == DELAYTEN)
        !           326:                return(0);
        !           327: 
        !           328:        return(sizeof (struct tmscpdevice));
        !           329: }
        !           330: 
        !           331: /*
        !           332:  * Try to find a slave (a drive) on the controller.
        !           333:  * If the controller is not in the run state, call init to initialize it.
        !           334:  */
        !           335: tmscpslave (ui, reg)
        !           336:        struct uba_device *ui;  /* ptr to the uba device structure */
        !           337:        caddr_t reg;            /* addr of the device controller */
        !           338: {
        !           339:        register struct uba_ctlr *um = tmscpminfo[ui->ui_ctlr];
        !           340:        register struct tmscp_softc *sc = &tmscp_softc[ui->ui_ctlr];
        !           341:        register struct tms_info *tms = &tms_info[ui->ui_unit];
        !           342:        struct   tmscpdevice *tmscpaddr;        /* ptr to IP & SA */
        !           343:        struct   mscp *mp;
        !           344:        int      i;                     /* Something to write into to start */
        !           345:                                        /* the tmscp polling */
        !           346: 
        !           347: #      ifdef lint
        !           348:        reg = reg;
        !           349: #      endif
        !           350:        tmscpaddr = (struct tmscpdevice *)um->um_addr;
        !           351:        /* 
        !           352:         * If its not in the run state, start the initialization process
        !           353:         * (tmscpintr will complete it);  if the initialization doesn't start;
        !           354:         * then return.
        !           355:         */
        !           356:        if(sc->sc_state != S_RUN)
        !           357:                {
        !           358: #              ifdef DEBUG
        !           359:                printd("tmscpslave: ctlr not running: calling init \n");
        !           360: #              endif   
        !           361:                if(!tmscpinit(ui->ui_ctlr))
        !           362:                        return(0);
        !           363:                }
        !           364:        /*
        !           365:         * Wait for the controller to come into the run state or go idle.
        !           366:         * If it goes idle return.
        !           367:         */
        !           368: #      ifdef DEBUG
        !           369:        i=1;
        !           370: #      endif   
        !           371:        while(sc->sc_state != S_RUN && sc->sc_state != S_IDLE)
        !           372: #              ifdef DEBUG
        !           373:                if (tmscpaddr->tmscpsa & TMSCP_ERR && i)
        !           374:                        {
        !           375:                        printd("tmscp-device: fatal error (%o)\n", tmscpaddr->tmscpsa&0xffff);
        !           376:                        i=0;
        !           377:                         }
        !           378: #              endif   
        !           379:                ;       /* wait */
        !           380:        if(sc->sc_state == S_IDLE)
        !           381:                {       /* The tmscp device failed to initialize */
        !           382:                printf("tmscp controller failed to init\n");
        !           383:                return(0);
        !           384:                }
        !           385:        /* The controller is up so see if the drive is there */
        !           386:        if(0 == (mp = tmscpgetcp(um)))
        !           387:                {
        !           388:                printf("tmscp can't get command packet\n");
        !           389:                return(0);
        !           390:                }
        !           391:        /* Need to determine the drive type for generic driver */
        !           392:        mp->mscp_opcode = M_OP_GTUNT;   /* This should give us the device type */
        !           393:        mp->mscp_unit = ui->ui_slave;
        !           394:        mp->mscp_cmdref = (long) ui->ui_slave;
        !           395:        tms->tms_status = 0;    /* set to zero */
        !           396:        tmscpip[ui->ui_ctlr][ui->ui_slave] = ui;
        !           397:        *((long *) mp->mscp_dscptr ) |= TMSCP_OWN | TMSCP_INT;/* maybe we should poll*/
        !           398:        i = tmscpaddr->tmscpip;
        !           399: #ifdef lint
        !           400:        i = i;
        !           401: #endif
        !           402:        while(!tms->tms_status)
        !           403:                ;                               /* Wait for some status */
        !           404: #      ifdef DEBUG
        !           405:        printd("tmscpslave: status = %o\n",tms->tms_status & M_ST_MASK);
        !           406: #      endif
        !           407:        tmscpip[ui->ui_ctlr][ui->ui_slave] = 0;
        !           408:        if(!tms->tms_type)                      /* packet from a GTUNT */
        !           409:                return(0);                      /* Failed No such drive */
        !           410:        else
        !           411:                return(1);                      /* Got it and it is there */
        !           412: }
        !           413: 
        !           414: 
        !           415: /* 
        !           416:  * Set ui flags to zero to show device is not online & set tmscpip.
        !           417:  * Unit to Controller mapping is set up here.
        !           418:  * Open routine will issue the online command, later.
        !           419:  */
        !           420: tmscpattach (ui)
        !           421:        register struct uba_device *ui;         /* ptr to unibus dev struct */
        !           422: {
        !           423: 
        !           424:        ui->ui_flags = 0;
        !           425:        tmscpip[ui->ui_ctlr][ui->ui_slave] = ui;
        !           426: #      ifdef DEBUG
        !           427:        /* 
        !           428:         * Check to see if the drive is available.
        !           429:         * If not then just print debug.
        !           430:         */
        !           431:        if(tms_info[ui->ui_unit].tms_status != M_ST_AVLBL)
        !           432:                printd("tmscpattach: unavailable \n");
        !           433: #      endif   
        !           434:        utoctlr[ui->ui_unit] = ui->ui_ctlr;
        !           435: }
        !           436: 
        !           437: 
        !           438: /*
        !           439:  * TMSCP interrupt routine.
        !           440:  */
        !           441: tmscpintr (d)
        !           442:        int d;          /* index to the controller */
        !           443: {
        !           444:        register struct uba_ctlr *um = tmscpminfo[d];
        !           445:        register struct tmscpdevice *tmscpaddr = (struct tmscpdevice *)um->um_addr;
        !           446:        struct buf *bp;
        !           447:        register int i;
        !           448:        register struct tmscp_softc *sc = &tmscp_softc[d];
        !           449:        register struct tmscp *tm = &tmscp[d];
        !           450:        struct tmscp *ttm;
        !           451:        struct mscp *mp;
        !           452: 
        !           453: #      ifdef DEBUG
        !           454:        printd10("tmscpintr: state %d, tmscpsa %o\n", sc->sc_state, tmscpaddr->tmscpsa);
        !           455: #      endif   
        !           456: 
        !           457:        /*
        !           458:         * How the interrupt is handled depends on the state of the controller.
        !           459:         */
        !           460:        switch (sc->sc_state) {
        !           461: 
        !           462:        case S_IDLE:
        !           463:                printf("tmscp%d: random interrupt ignored\n", d);
        !           464:                return;
        !           465: 
        !           466:        /* Controller was in step 1 last, see if its gone to step 2 */
        !           467:        case S_STEP1:
        !           468: #              define STEP1MASK 0174377
        !           469: #              define STEP1GOOD (TMSCP_STEP2|TMSCP_IE|(NCMDL2<<3)|NRSPL2)
        !           470:                for (i = 0; i < 150; i++)
        !           471:                        {
        !           472:                        if ((tmscpaddr->tmscpsa&STEP1MASK) != STEP1GOOD)
        !           473:                                { /* still in step 1 (wait 1/100 sec) */
        !           474:                                DELAY(10000);
        !           475: #                              ifdef DEBUG
        !           476:                                printd("still in step 1, delaying\n");
        !           477: #                              endif DEBUG
        !           478:                                }
        !           479:                        else
        !           480:                                break;
        !           481:                        }
        !           482:                if (i > 149)
        !           483:                        {
        !           484:                        sc->sc_state = S_IDLE;
        !           485:                        printf("failed to initialize, in step1: sa 0x%x", tmscpaddr->tmscpsa);
        !           486:                        wakeup((caddr_t)um);
        !           487:                        return;
        !           488:                        }
        !           489:                tmscpaddr->tmscpsa = ((int)&sc->sc_tmscp->tmscp_ca.ca_ringbase)
        !           490:                        | ((cpu == VAX_780 || cpu == VAX_8600) ? TMSCP_PI : 0);
        !           491:                sc->sc_state = S_STEP2;
        !           492:                return;
        !           493: 
        !           494:        /* Controller was in step 2 last, see if its gone to step 3 */
        !           495:        case S_STEP2:
        !           496: #              define STEP2MASK 0174377
        !           497: #              define STEP2GOOD (TMSCP_STEP3|TMSCP_IE|(sc->sc_ivec/4))
        !           498:                for (i = 0; i < 150; i++)
        !           499:                        {
        !           500:                        if ((tmscpaddr->tmscpsa&STEP2MASK) != STEP2GOOD)
        !           501:                                { /* still in step 2 (wait 1/100 sec) */
        !           502:                                DELAY(10000);
        !           503: #                              ifdef DEBUG
        !           504:                                printd("still in step 2, delaying\n");
        !           505: #                              endif DEBUG
        !           506:                                }
        !           507:                        else
        !           508:                                break;
        !           509:                        }
        !           510:                if (i > 149)
        !           511:                        {
        !           512:                        sc->sc_state = S_IDLE;
        !           513:                        printf("failed to initialize, in step2: sa 0x%x", tmscpaddr->tmscpsa);
        !           514:                        wakeup((caddr_t)um);
        !           515:                        return;
        !           516:                        }
        !           517:                tmscpaddr->tmscpsa = ((int)&sc->sc_tmscp->tmscp_ca.ca_ringbase)>>16;
        !           518:                sc->sc_state = S_STEP3;
        !           519:                return;
        !           520: 
        !           521:        /* Controller was in step 3 last, see if its gone to step 4 */
        !           522:        case S_STEP3:
        !           523: #              define STEP3MASK 0174000
        !           524: #              define STEP3GOOD TMSCP_STEP4
        !           525:                for (i = 0; i < 150; i++)
        !           526:                        {
        !           527:                        if ((tmscpaddr->tmscpsa&STEP3MASK) != STEP3GOOD)
        !           528:                                { /* still in step 3 (wait 1/100 sec) */
        !           529:                                DELAY(10000);
        !           530: #                              ifdef DEBUG
        !           531:                                printd("still in step 3, delaying\n");
        !           532: #                              endif DEBUG
        !           533:                                }
        !           534:                        else
        !           535:                                break;
        !           536:                        }
        !           537:                if (i > 149)
        !           538:                        {
        !           539:                        sc->sc_state = S_IDLE;
        !           540:                        printf("failed to initialize, in step3: sa 0x%x", tmscpaddr->tmscpsa);
        !           541:                        wakeup((caddr_t)um);
        !           542:                        return;
        !           543:                        }
        !           544:                /*
        !           545:                 * Get microcode version and model number of controller;
        !           546:                 * Signal initialization complete (_GO) (to the controller);
        !           547:                 *    ask for Last Fail response if tmscperror is set;
        !           548:                 * Set state to "set controller characteristics".
        !           549:                 */
        !           550:                tmscpmicro[d] = tmscpaddr->tmscpsa;
        !           551:                tmscpaddr->tmscpsa = TMSCP_GO | (tmscperror? TMSCP_LF : 0);
        !           552:                sc->sc_state = S_SCHAR;
        !           553: #              ifdef DEBUG
        !           554:                printd("tmscpintr: completed state %d \n", sc->sc_state);
        !           555:                printd("tmscp%d Version %d model %d\n",d,tmscpmicro[d]&0xF,
        !           556:                        (tmscpmicro[d]>>4) & 0xF);
        !           557: #              endif
        !           558: 
        !           559:            /*
        !           560:             * Initialize the data structures (response and command queues).
        !           561:             */
        !           562:            ttm = sc->sc_tmscp;
        !           563:            for (i = 0; i < NRSP; i++)
        !           564:                    {
        !           565:                    tm->tmscp_ca.ca_rspdsc[i] = TMSCP_OWN | TMSCP_INT | 
        !           566:                           (long)&ttm->tmscp_rsp[i].mscp_cmdref;
        !           567:                    tm->tmscp_rsp[i].mscp_dscptr = &tm->tmscp_ca.ca_rspdsc[i];
        !           568:                    tm->tmscp_rsp[i].mscp_header.tmscp_msglen = mscp_msglen;
        !           569:                    }
        !           570:            for (i = 0; i < NCMD; i++)
        !           571:                    {
        !           572:                    tm->tmscp_ca.ca_cmddsc[i] = TMSCP_INT | 
        !           573:                                        (long)&ttm->tmscp_cmd[i].mscp_cmdref;
        !           574:                    tm->tmscp_cmd[i].mscp_dscptr = &tm->tmscp_ca.ca_cmddsc[i];
        !           575:                    tm->tmscp_cmd[i].mscp_header.tmscp_msglen = mscp_msglen;
        !           576:                    tm->tmscp_cmd[i].mscp_header.tmscp_vcid = 1;
        !           577:                    }
        !           578:            bp = &tmscpwtab[d];
        !           579:            bp->av_forw = bp->av_back = bp;
        !           580:            sc->sc_lastcmd = 1;
        !           581:            sc->sc_lastrsp = 0;
        !           582:            mp = &tmscp[um->um_ctlr].tmscp_cmd[0];
        !           583:            mp->mscp_unit = mp->mscp_modifier = 0;
        !           584:            mp->mscp_flags = 0;
        !           585:            mp->mscp_version = 0;
        !           586:            mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS;
        !           587:            /*
        !           588:             * A host time out value of 0 means that the controller will not
        !           589:             * time out.  This is ok for the TK50.
        !           590:             */
        !           591:            mp->mscp_hsttmo = 0;
        !           592:            mp->mscp_time.val[0] = 0;
        !           593:            mp->mscp_time.val[1] = 0;
        !           594:            mp->mscp_cntdep = 0;
        !           595:            mp->mscp_opcode = M_OP_STCON;
        !           596:            *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
        !           597:            i = tmscpaddr->tmscpip;      /* initiate polling */
        !           598:            return;
        !           599: 
        !           600:        case S_SCHAR:
        !           601:        case S_RUN:
        !           602:                break;
        !           603: 
        !           604:        default:
        !           605:            printf("tmscp%d: interrupt in unknown state %d ignored\n",d,sc->sc_state);
        !           606:            return;
        !           607:        }       /* end switch */
        !           608: 
        !           609:        /*
        !           610:         * The controller state is S_SCHAR or S_RUN
        !           611:         */
        !           612: 
        !           613:        /*
        !           614:         * If the error bit is set in the SA register then print an error
        !           615:         * message and reinitialize the controller.
        !           616:         */
        !           617:        if (tmscpaddr->tmscpsa&TMSCP_ERR)
        !           618:                {
        !           619:                printf("tmscp%d: fatal error (%o)\n", d, tmscpaddr->tmscpsa&0xffff);
        !           620:                tmscpaddr->tmscpip = 0;
        !           621:                wakeup((caddr_t)um);
        !           622:                }
        !           623:        /*
        !           624:         * Check for a buffer purge request. (Won't happen w/ TK50 on Q22 bus)
        !           625:         */
        !           626:        if (tm->tmscp_ca.ca_bdp)
        !           627:                {
        !           628:                UBAPURGE(um->um_hd->uh_uba, tm->tmscp_ca.ca_bdp);
        !           629:                tm->tmscp_ca.ca_bdp = 0;
        !           630:                tmscpaddr->tmscpsa = 0;      /* signal purge complete */
        !           631:                }
        !           632: 
        !           633:        /*
        !           634:         * Check for response ring transition.
        !           635:         */
        !           636:        if (tm->tmscp_ca.ca_rspint)
        !           637:                {
        !           638:                tm->tmscp_ca.ca_rspint = 0;
        !           639:                for (i = sc->sc_lastrsp;; i++)
        !           640:                        {
        !           641:                        i %= NRSP;
        !           642:                        if (tm->tmscp_ca.ca_rspdsc[i]&TMSCP_OWN)
        !           643:                            break;
        !           644:                        tmscprsp(um, tm, sc, i);
        !           645:                        tm->tmscp_ca.ca_rspdsc[i] |= TMSCP_OWN;
        !           646:                        }
        !           647:                sc->sc_lastrsp = i;
        !           648:                }
        !           649: 
        !           650:        /*
        !           651:         * Check for command ring transition.
        !           652:         */
        !           653:        if (tm->tmscp_ca.ca_cmdint)
        !           654:                {
        !           655: #              ifdef DEBUG
        !           656:                printd("tmscpintr: command ring transition\n");
        !           657: #              endif           
        !           658:                tm->tmscp_ca.ca_cmdint = 0;
        !           659:                }
        !           660:        if(tmscp_cp_wait)
        !           661:                wakeup((caddr_t)&tmscp_cp_wait);
        !           662:        (void) tmscpstart(um);
        !           663: }
        !           664: 
        !           665: 
        !           666: /*
        !           667:  * Open a tmscp device and set the unit online.  If the controller is not 
        !           668:  * in the run state, call init to initialize the tmscp controller first.
        !           669:  */
        !           670: 
        !           671: /* ARGSUSED */
        !           672: tmscpopen(dev, flag)
        !           673:        dev_t dev;
        !           674:        int flag;
        !           675: {
        !           676:        register int unit;
        !           677:        register struct uba_device *ui;
        !           678:        register struct tmscp_softc *sc;
        !           679:        register struct tms_info *tms;
        !           680:        register struct mscp *mp;
        !           681:        register struct uba_ctlr *um;
        !           682:        struct tmscpdevice *tmscpaddr;
        !           683:        int s,i;
        !           684:        
        !           685:        unit = TMSUNIT(dev);
        !           686: #      ifdef DEBUG
        !           687:        printd("tmscpopen unit %d\n",unit);
        !           688:        if(tmscpdebug)DELAY(10000);
        !           689: #      endif
        !           690:        if (unit >= NTMS || (ui = tmsdinfo[unit]) == 0 || ui->ui_alive == 0)
        !           691:                return (ENXIO);
        !           692:        tms = &tms_info[ui->ui_unit];
        !           693:        if (tms->tms_openf)
        !           694:                return (EBUSY);
        !           695:        sc = &tmscp_softc[ui->ui_ctlr];
        !           696:        tms->tms_openf = 1;
        !           697:        tms->tms_ttyp = u.u_ttyp;
        !           698:        s = spl5();
        !           699:        if (sc->sc_state != S_RUN)
        !           700:                {
        !           701:                if (sc->sc_state == S_IDLE)
        !           702:                        if(!tmscpinit(ui->ui_ctlr))
        !           703:                                {
        !           704:                                printf("tmscp controller failed to init\n");
        !           705:                                (void) splx(s);
        !           706:                                return(ENXIO);
        !           707:                                }
        !           708:                /* 
        !           709:                 * Wait for initialization to complete
        !           710:                 */
        !           711:                timeout(wakeup,(caddr_t)ui->ui_mi,11*hz);       /* to be sure*/
        !           712:                sleep((caddr_t)ui->ui_mi, 0);
        !           713:                if (sc->sc_state != S_RUN)
        !           714:                        {
        !           715:                        (void) splx(s);
        !           716:                        tms->tms_openf = 0;
        !           717:                        return (EIO);
        !           718:                        }
        !           719:                }
        !           720:        /*
        !           721:         * Check to see if the device is really there.
        !           722:         * this code was taken from Fred Canters 11 driver
        !           723:         */
        !           724:        um = ui->ui_mi;
        !           725:        tmscpaddr = (struct tmscpdevice *) um->um_addr;
        !           726:        (void) splx(s);
        !           727:        if(ui->ui_flags == 0)
        !           728:                {
        !           729:                s = spl5();
        !           730:                while(0 ==(mp = tmscpgetcp(um)))
        !           731:                        {
        !           732:                        tmscp_cp_wait++;
        !           733:                        sleep((caddr_t)&tmscp_cp_wait,PSWP+1);
        !           734:                        tmscp_cp_wait--;
        !           735:                        }
        !           736:                (void) splx(s);
        !           737:                mp->mscp_opcode = M_OP_ONLIN;
        !           738:                mp->mscp_unit = ui->ui_slave;
        !           739:                mp->mscp_cmdref = (long) & tms->tms_type;
        !           740:                                            /* need to sleep on something */
        !           741: #              ifdef DEBUG
        !           742:                printd("tmscpopen: bring unit %d online\n",ui->ui_unit);
        !           743: #              endif   
        !           744:                *((long *) mp->mscp_dscptr ) |= TMSCP_OWN | TMSCP_INT;
        !           745:                i = tmscpaddr->tmscpip;
        !           746: #ifdef lint
        !           747:                i = i;
        !           748: #endif
        !           749:                /* 
        !           750:                 * To make sure we wake up, timeout in 240 seconds.
        !           751:                 * Wakeup in tmscprsp routine.
        !           752:                 * 240 seconds (4 minutes) is necessary since a rewind
        !           753:                 * can take a few minutes.
        !           754:                 */
        !           755:                timeout(wakeup,(caddr_t) mp->mscp_cmdref,240 * hz);
        !           756:                sleep((caddr_t) mp->mscp_cmdref,PSWP+1);
        !           757:                }
        !           758:        if(ui->ui_flags == 0) {
        !           759:                tms->tms_openf = 0;
        !           760:                return(ENXIO);  /* Didn't go online */
        !           761:        }
        !           762:        tms->tms_lastiow = 0;
        !           763:        /*
        !           764:         * If the high density device is not specified, set unit to low
        !           765:         * density.  This is done as an "internal" ioctl command so
        !           766:         * that the command setup and response handling
        !           767:         * is done thru "regular" command routines.
        !           768:         */
        !           769:        if ((minor(dev) & T_HIDENSITY) == 0)
        !           770:                tmscpcommand(dev, TMS_LOWDENSITY, 1);
        !           771:        else
        !           772:                tmscpcommand(dev, TMS_HIDENSITY, 1);
        !           773:        return (0);
        !           774: }
        !           775: 
        !           776: 
        !           777: /*
        !           778:  * Close tape device.
        !           779:  *
        !           780:  * If tape was open for writing or last operation was
        !           781:  * a write, then write two EOF's and backspace over the last one.
        !           782:  * Unless this is a non-rewinding special file, rewind the tape.
        !           783:  *
        !           784:  * NOTE:
        !           785:  *     We want to be sure that any serious exception is cleared on the
        !           786:  *     close. A Clear Serious Exception (CSE) modifier is always done on
        !           787:  *     the rewind command.  For the non-rewind case we check to see if the
        !           788:  *     "serex" field is set in the softc struct; if it is then issue a noop
        !           789:  *     command with the CSE modifier.
        !           790:  * Make the tape available to others, by clearing openf flag.
        !           791:  */
        !           792: tmscpclose(dev, flag)
        !           793:        register dev_t dev;
        !           794:        register flag;
        !           795: {
        !           796:        register struct tms_info *tms;
        !           797:        register struct uba_device *ui;
        !           798: 
        !           799:        ui = tmsdinfo[TMSUNIT(dev)];
        !           800: #      ifdef DEBUG
        !           801:        printd("tmscpclose: ctlr =  %d\n",TMSCPCTLR(dev));
        !           802:        printd("tmscpclose: unit = %d\n",TMSUNIT(dev));
        !           803:        if(tmscpdebug)DELAY(10000);
        !           804: #      endif
        !           805:        tms = &tms_info[ui->ui_unit];
        !           806:        if (flag == FWRITE || (flag&FWRITE) && tms->tms_lastiow)
        !           807:                {
        !           808:                /*         device, command, count */
        !           809:                tmscpcommand (dev, TMS_WRITM, 1);
        !           810:                tmscpcommand (dev, TMS_WRITM, 1);
        !           811:                tmscpcommand (dev, TMS_BSR, 1);
        !           812:                }
        !           813:        if ((minor(dev)&T_NOREWIND) == 0)
        !           814:                /*
        !           815:                 * Don't hang waiting for rewind complete.
        !           816:                 */
        !           817:                tmscpcommand(dev, TMS_REW, 0);
        !           818:        else
        !           819:                if (tms->tms_serex)
        !           820:                        {
        !           821: #                      ifdef DEBUG
        !           822:                        printd("tmscpclose: clearing serex\n");
        !           823:                        if(tmscpdebug)DELAY(10000);
        !           824: #                      endif
        !           825:                        tmscpcommand(dev, TMS_CSE, 1);
        !           826:                        }
        !           827:        tms->tms_openf = 0;
        !           828: }
        !           829: 
        !           830: 
        !           831: /*
        !           832:  * Execute a command on the tape drive a specified number of times.
        !           833:  * This routine sets up a buffer and calls the strategy routine which
        !           834:  * links the buffer onto the drive's buffer queue.
        !           835:  * The start routine will take care of creating a tmscp command packet
        !           836:  * with the command.  The start routine is called by the strategy or the
        !           837:  * interrupt routine.
        !           838:  */
        !           839: 
        !           840: tmscpcommand (dev, com, count)
        !           841:        register dev_t dev;
        !           842:        int com, count;
        !           843: {
        !           844:        register struct uba_device *ui;
        !           845:        register struct buf *bp;
        !           846:        register int s;
        !           847:        int unit = TMSUNIT(dev);
        !           848: 
        !           849:        ui = tmsdinfo[unit];
        !           850:        bp = &ctmscpbuf[ui->ui_ctlr];
        !           851: 
        !           852:        s = spl5();
        !           853:        while (bp->b_flags&B_BUSY)
        !           854:                {
        !           855:                /*
        !           856:                 * This special check is because B_BUSY never
        !           857:                 * gets cleared in the non-waiting rewind case.
        !           858:                 */
        !           859:                if (bp->b_bcount == 0 && (bp->b_flags&B_DONE))
        !           860:                        break;
        !           861:                bp->b_flags |= B_WANTED;
        !           862:                sleep((caddr_t)bp, PRIBIO);
        !           863:                }
        !           864:        bp->b_flags = B_BUSY|B_READ;
        !           865:        splx(s);
        !           866:        /*
        !           867:         * Load the buffer.  The b_count field gets used to hold the command
        !           868:         * count.  the b_resid field gets used to hold the command mneumonic.
        !           869:         * These 2 fields are "known" to be "safe" to use for this purpose.
        !           870:         * (Most other drivers also use these fields in this way.)
        !           871:         */
        !           872:        bp->b_dev = dev;
        !           873:        bp->b_bcount = count;
        !           874:        bp->b_resid = com;
        !           875:        bp->b_blkno = 0;
        !           876:        tmscpstrategy(bp);
        !           877:        /*
        !           878:         * In case of rewind from close, don't wait.
        !           879:         * This is the only case where count can be 0.
        !           880:         */
        !           881:        if (count == 0)
        !           882:                return;
        !           883:        iowait(bp);
        !           884:        if (bp->b_flags&B_WANTED)
        !           885:                wakeup((caddr_t)bp);
        !           886:        bp->b_flags &= B_ERROR;
        !           887: }
        !           888: 
        !           889: /*
        !           890:  * Find an unused command packet
        !           891:  */
        !           892: struct mscp *
        !           893: tmscpgetcp(um)
        !           894:        struct uba_ctlr *um;
        !           895: {
        !           896:        register struct mscp *mp;
        !           897:        register struct tmscpca *cp;
        !           898:        register struct tmscp_softc *sc;
        !           899:        register int i;
        !           900:        int     s;
        !           901: 
        !           902:        s = spl5();
        !           903:        cp = &tmscp[um->um_ctlr].tmscp_ca;
        !           904:        sc = &tmscp_softc[um->um_ctlr];
        !           905:        /*
        !           906:         * If no credits, can't issue any commands
        !           907:         * until some outstanding commands complete.
        !           908:         */
        !           909:        i = sc->sc_lastcmd;
        !           910: #      ifdef DEBUG
        !           911:        printd10("tmscpgetcp: %d credits remain\n", sc->sc_credits);
        !           912: #      endif
        !           913:        if(((cp->ca_cmddsc[i]&(TMSCP_OWN|TMSCP_INT))==TMSCP_INT) &&
        !           914:          (sc->sc_credits >= 2))
        !           915:                {
        !           916:                sc->sc_credits--;       /* This commits to issuing a command */
        !           917:                cp->ca_cmddsc[i] &= ~TMSCP_INT;
        !           918:                mp = &tmscp[um->um_ctlr].tmscp_cmd[i];
        !           919:                mp->mscp_unit = mp->mscp_modifier = 0;
        !           920:                mp->mscp_opcode = mp->mscp_flags = 0;
        !           921:                mp->mscp_bytecnt = mp->mscp_buffer = 0;
        !           922:                sc->sc_lastcmd = (i + 1) % NCMD;
        !           923:                (void) splx(s);
        !           924:                return(mp);
        !           925:                }
        !           926:        (void) splx(s);
        !           927:        return(NULL);
        !           928: }
        !           929: 
        !           930: 
        !           931: /*
        !           932:  * Initialize a TMSCP device.  Set up UBA mapping registers,
        !           933:  * initialize data structures, and start hardware
        !           934:  * initialization sequence.
        !           935:  */
        !           936: tmscpinit (d)
        !           937:        int d;                  /* index to the controller */
        !           938: {
        !           939:        register struct tmscp_softc *sc;
        !           940:        register struct tmscp *t;  /* communications area; cmd & resp packets */
        !           941:        struct tmscpdevice *tmscpaddr;
        !           942:        struct uba_ctlr *um;
        !           943: 
        !           944:        sc = &tmscp_softc[d];
        !           945:        um = tmscpminfo[d];
        !           946:        um->um_tab.b_active++;
        !           947:        t = &tmscp[d];
        !           948:        tmscpaddr = (struct tmscpdevice *)um->um_addr;
        !           949:        if (sc->sc_mapped == 0)
        !           950:                {
        !           951:                /*
        !           952:                 * Map the communications area and command
        !           953:                 * and response packets into Unibus address
        !           954:                 * space.
        !           955:                 */
        !           956:                sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)t, sizeof (struct tmscp), 0);
        !           957: #              ifdef MVAX
        !           958:                if (cpu == MVAX_I)
        !           959:                        sc->sc_tmscp = (struct tmscp *)(sc->sc_ubainfo & 0x3fffff);
        !           960:                else
        !           961: #              endif MVAX
        !           962:                        sc->sc_tmscp = (struct tmscp *)(sc->sc_ubainfo & 0x3ffff);
        !           963:                sc->sc_mapped = 1;
        !           964:                }
        !           965: 
        !           966:        /*
        !           967:         * Start the hardware initialization sequence.
        !           968:         */
        !           969:        tmscpaddr->tmscpip = 0;              /* start initialization */
        !           970: 
        !           971:        while((tmscpaddr->tmscpsa & TMSCP_STEP1) == 0)
        !           972:                {
        !           973: #              ifdef DEBUG
        !           974:                printd("tmscpinit: tmscpsa = 0%o\n",tmscpaddr->tmscpsa);
        !           975:                DELAY(100000);
        !           976: #              endif
        !           977:                if(tmscpaddr->tmscpsa & TMSCP_ERR)
        !           978:                        return(0);      /* CHECK */
        !           979:                }
        !           980:        tmscpaddr->tmscpsa=TMSCP_ERR|(NCMDL2<<11)|(NRSPL2<<8)|TMSCP_IE|(sc->sc_ivec/4);
        !           981:        /*
        !           982:         * Initialization continues in the interrupt routine.
        !           983:         */
        !           984:        sc->sc_state = S_STEP1;
        !           985:        sc->sc_credits = 0;
        !           986:        return(1);
        !           987: }
        !           988: 
        !           989: 
        !           990: /*
        !           991:  * Start I/O operation
        !           992:  * This code is convoluted.  The majority of it was copied from the uda driver.
        !           993:  */
        !           994: 
        !           995: tmscpstart(um)
        !           996:        register struct uba_ctlr *um;
        !           997: {
        !           998:        register struct buf *bp, *dp;
        !           999:        register struct mscp *mp;
        !          1000:        register struct tmscp_softc *sc;
        !          1001:        register struct tms_info *tms;
        !          1002:        register struct uba_device *ui;
        !          1003:        struct   tmscpdevice *tmscpaddr;
        !          1004:        struct   tmscp *tm = &tmscp[um->um_ctlr];
        !          1005:        int i,tempi;
        !          1006:        char ioctl;             /* flag: set true if its an IOCTL command */
        !          1007: 
        !          1008:        sc = &tmscp_softc[um->um_ctlr];
        !          1009:        
        !          1010:     for(;;)
        !          1011:        {
        !          1012:        if ((dp = um->um_tab.b_actf) == NULL)
        !          1013:                {
        !          1014:                /*
        !          1015:                 * Release unneeded UBA resources and return
        !          1016:                 * (drive was inactive)
        !          1017:                 */
        !          1018:                um->um_tab.b_active = 0;
        !          1019:                break;
        !          1020:                }
        !          1021:        if ((bp = dp->b_actf) == NULL)
        !          1022:                {
        !          1023:                /*
        !          1024:                 * No more requests for this drive, remove
        !          1025:                 * from controller queue and look at next drive.
        !          1026:                 * We know we're at the head of the controller queue.
        !          1027:                 */
        !          1028:                dp->b_active = 0;
        !          1029:                um->um_tab.b_actf = dp->b_forw;
        !          1030:                continue;               /* Need to check for loop */
        !          1031:                }
        !          1032:        um->um_tab.b_active++;
        !          1033:        tmscpaddr = (struct tmscpdevice *)um->um_addr;
        !          1034:        ui = tmsdinfo[(TMSUNIT(bp->b_dev))];
        !          1035:        tms = &tms_info[ui->ui_unit];
        !          1036:        if ((tmscpaddr->tmscpsa&TMSCP_ERR) || sc->sc_state != S_RUN)
        !          1037:                {
        !          1038:                tprintf(tms->tms_ttyp,
        !          1039:                    "tms%d: hard error bn%d\n",
        !          1040:                    minor(bp->b_dev)&03, bp->b_blkno);
        !          1041:                log(TMS_PRI, "tmscp%d: sa 0%o, state %d\n",um->um_ctlr,
        !          1042:                                tmscpaddr->tmscpsa&0xffff, sc->sc_state);
        !          1043:                (void)tmscpinit(um->um_ctlr);
        !          1044:                /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE TMSCPRESET */
        !          1045:                break;
        !          1046:                }
        !          1047:        /*
        !          1048:         * Default is that last command was NOT a write command;
        !          1049:         * if a write command is done it will be detected in tmscprsp.
        !          1050:         */
        !          1051:        tms->tms_lastiow = 0;
        !          1052:        if (ui->ui_flags == 0)
        !          1053:                {        /* not online */
        !          1054:                if ((mp = tmscpgetcp(um)) == NULL)
        !          1055:                        break;
        !          1056:                mp->mscp_opcode = M_OP_ONLIN;
        !          1057:                mp->mscp_unit = ui->ui_slave;
        !          1058:                dp->b_active = 2;
        !          1059:                um->um_tab.b_actf = dp->b_forw; /* remove from controller q */
        !          1060:                *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
        !          1061:                if (tmscpaddr->tmscpsa&TMSCP_ERR)
        !          1062:                        printf("tmscp%d fatal error (0%o)\n",um->um_ctlr,
        !          1063:                                        tmscpaddr->tmscpsa&0xffff);
        !          1064:                i = tmscpaddr->tmscpip;
        !          1065:                continue;
        !          1066:                }
        !          1067:        switch (cpu) {
        !          1068: 
        !          1069:        case VAX_8600:
        !          1070:        case VAX_780:
        !          1071:                i = UBA_NEEDBDP|UBA_CANTWAIT;
        !          1072:                break;
        !          1073:        case VAX_750:
        !          1074:                i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT;
        !          1075:                break;
        !          1076:        case VAX_730:
        !          1077:                i = UBA_CANTWAIT;
        !          1078:                break;
        !          1079:        }   /* end switch (cpu) */
        !          1080:        /*
        !          1081:         * If command is an ioctl command then set the ioctl flag for later use.
        !          1082:         * If not (i.e. it is a read or write) then attempt
        !          1083:         * to set up a buffer pointer.
        !          1084:         */
        !          1085:        ioctl = 0;
        !          1086:        if (bp == &ctmscpbuf[um->um_ctlr])
        !          1087:                ioctl = 1;
        !          1088:        else
        !          1089:                if ((i = ubasetup(um->um_ubanum, bp, i)) == 0)
        !          1090:                        {
        !          1091:                        if(dp->b_qsize != 0)
        !          1092:                                break; /* When a command completes and */
        !          1093:                                     /* frees a bdp tmscpstart will be called */
        !          1094:                        if ((mp = tmscpgetcp(um)) == NULL)
        !          1095:                                break;
        !          1096: #                      ifdef DEBUG
        !          1097:                        printd("tmscpstart: GTUNT %d ubasetup = %d\n",ui->ui_unit, i);
        !          1098:                        if(tmscpdebug)DELAY(10000);
        !          1099: #                      endif
        !          1100:                        mp->mscp_opcode = M_OP_GTUNT;
        !          1101:                        mp->mscp_unit = ui->ui_slave;
        !          1102:                        *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
        !          1103:                        if (tmscpaddr->tmscpsa&TMSCP_ERR)
        !          1104:                                printf("tmscp%d: fatal error (0%o)\n",um->um_ctlr,
        !          1105:                                            tmscpaddr->tmscpsa&0xffff);
        !          1106:                        i = tmscpaddr->tmscpip; /* initiate polling */
        !          1107:                        break;
        !          1108:                        }
        !          1109: #      if defined(VAX750)
        !          1110:        if (cpu == VAX_750)
        !          1111:                tempi = i & 0xfffffff;                  /* mask off bdp */
        !          1112:        else
        !          1113: #      endif
        !          1114:                tempi = i;
        !          1115:        if ((mp = tmscpgetcp(um)) == NULL)
        !          1116:                {
        !          1117:                if (!ioctl)             /* only need to release if NOT ioctl */
        !          1118:                        ubarelse(um->um_ubanum,&tempi);
        !          1119:                break;
        !          1120:                }
        !          1121:        mp->mscp_cmdref = (long)bp;             /* pointer to get back */
        !          1122:        mp->mscp_unit = ui->ui_slave;
        !          1123:        /*
        !          1124:         * If its an ioctl-type command then set up the appropriate
        !          1125:         * tmscp command;  by doing a switch on the "b_resid" field where
        !          1126:         * the command mneumonic is stored.
        !          1127:         */
        !          1128:        if (ioctl)
        !          1129:                {
        !          1130: #              ifdef DEBUG
        !          1131:                printd("tmscpstart: doing ioctl cmd %d\n", bp->b_resid);
        !          1132: #              endif
        !          1133:                /*
        !          1134:                 * The reccnt and tmkcnt fields are set to zero by the getcp
        !          1135:                 * routine (as bytecnt and buffer fields).  Thus reccnt and
        !          1136:                 * tmkcnt are only modified here if they need to be set to
        !          1137:                 * a non-zero value.
        !          1138:                 */
        !          1139:                switch ((int)bp->b_resid) {
        !          1140: 
        !          1141:                case TMS_WRITM:
        !          1142:                        mp->mscp_opcode = M_OP_WRITM;
        !          1143:                        break;
        !          1144:                case TMS_FSF:
        !          1145:                        mp->mscp_opcode = M_OP_REPOS;
        !          1146:                        mp->mscp_tmkcnt = bp->b_bcount;
        !          1147:                        break;
        !          1148:                case TMS_BSF:
        !          1149:                        mp->mscp_opcode = M_OP_REPOS;
        !          1150:                        mp->mscp_modifier = M_MD_REVRS;
        !          1151:                        mp->mscp_tmkcnt = bp->b_bcount;
        !          1152:                        break;
        !          1153:                case TMS_FSR:
        !          1154:                        mp->mscp_opcode = M_OP_REPOS;
        !          1155:                        mp->mscp_modifier = M_MD_OBJCT;
        !          1156:                        mp->mscp_reccnt = bp->b_bcount;
        !          1157:                        break;
        !          1158:                case TMS_BSR:
        !          1159:                        mp->mscp_opcode = M_OP_REPOS;
        !          1160:                        mp->mscp_modifier = M_MD_REVRS | M_MD_OBJCT;
        !          1161:                        mp->mscp_reccnt = bp->b_bcount;
        !          1162:                        break;
        !          1163:                /*
        !          1164:                 * Clear serious exception is done for Rewind & Available cmds
        !          1165:                 */
        !          1166:                case TMS_REW:
        !          1167:                        mp->mscp_opcode = M_OP_REPOS;
        !          1168:                        mp->mscp_modifier = M_MD_REWND | M_MD_CLSEX;
        !          1169:                        if (bp->b_bcount == 0)
        !          1170:                                mp->mscp_modifier |= M_MD_IMMED;
        !          1171:                        tms->tms_serex = 0;
        !          1172:                        break;
        !          1173:                case TMS_OFFL:
        !          1174:                        mp->mscp_opcode = M_OP_AVAIL;
        !          1175:                        mp->mscp_modifier = M_MD_UNLOD | M_MD_CLSEX;
        !          1176:                        tms->tms_serex = 0;
        !          1177:                        break;
        !          1178:                case TMS_SENSE:
        !          1179:                        mp->mscp_opcode = M_OP_GTUNT;
        !          1180:                        break;
        !          1181:                case TMS_CACHE:
        !          1182:                        mp->mscp_opcode = M_OP_STUNT;
        !          1183:                        tms->tms_unitflgs |= M_UF_WBKNV;
        !          1184:                        mp->mscp_unitflgs = tms->tms_unitflgs;
        !          1185:                        mp->mscp_format = tms->tms_format;
        !          1186:                        /* default device dependant parameters */
        !          1187:                        mp->mscp_mediaid = 0;
        !          1188:                        break;
        !          1189:                case TMS_NOCACHE:
        !          1190:                        mp->mscp_opcode = M_OP_STUNT;
        !          1191:                        tms->tms_unitflgs &= ~(M_UF_WBKNV);
        !          1192:                        mp->mscp_unitflgs = tms->tms_unitflgs;
        !          1193:                        mp->mscp_format = tms->tms_format;
        !          1194:                        /* default device dependant parameters */
        !          1195:                        mp->mscp_mediaid = 0;
        !          1196:                        break;
        !          1197:                case TMS_CSE:
        !          1198:                        /*
        !          1199:                         * This is a no-op command. It performs a 
        !          1200:                         * clear serious exception only.  (Done on a
        !          1201:                         * non-rewinding close after a serious exception.)
        !          1202:                         */
        !          1203:                        mp->mscp_opcode = M_OP_REPOS;
        !          1204:                        mp->mscp_modifier = M_MD_CLSEX;
        !          1205:                        tms->tms_serex = 0;
        !          1206:                        tms->tms_clserex = 1;
        !          1207:                        break;
        !          1208:                case TMS_LOWDENSITY:
        !          1209:                        /*
        !          1210:                         * Set the unit to low density
        !          1211:                         */
        !          1212:                        mp->mscp_opcode = M_OP_STUNT;
        !          1213:                        mp->mscp_unitflgs = tms->tms_unitflgs;
        !          1214:                        mp->mscp_mediaid = 0;   /* default device dependant parameters */
        !          1215:                        if ((tms->tms_fmtmenu & M_TF_800) != 0)
        !          1216:                                mp->mscp_format = M_TF_800;
        !          1217:                        else
        !          1218:                                mp->mscp_format = M_TF_PE & tms->tms_fmtmenu;
        !          1219:                        tms->tms_format = mp->mscp_format;
        !          1220:                        break;
        !          1221:                case TMS_HIDENSITY:
        !          1222:                        /*
        !          1223:                         * Set the unit to high density (format == 0)
        !          1224:                         */
        !          1225:                        mp->mscp_opcode = M_OP_STUNT;
        !          1226:                        mp->mscp_unitflgs = tms->tms_unitflgs;
        !          1227:                        mp->mscp_mediaid = 0;   /* default device dependant parameters */
        !          1228:                        mp->mscp_format = 0;
        !          1229:                        tms->tms_format = 0;
        !          1230:                        break;
        !          1231:                default:
        !          1232:                        printf("Bad ioctl on tms unit %d\n", ui->ui_unit);
        !          1233:                        /* Need a no-op. Reposition no amount */
        !          1234:                        mp->mscp_opcode = M_OP_REPOS;
        !          1235:                        break;
        !          1236:                }   /* end switch (bp->b_resid) */
        !          1237:                }
        !          1238:        else    /* Its a read/write command (not an ioctl) */
        !          1239:                {
        !          1240:                mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE;
        !          1241:                mp->mscp_bytecnt = bp->b_bcount;
        !          1242: #              if MVAX
        !          1243:                if (cpu == MVAX_I)
        !          1244:                        {
        !          1245:                        mp->mscp_buffer = (i & 0x3ffff) | TMSCP_MAP;
        !          1246:                        mp->mscp_mapbase = (long)&(uba_hd[um->um_ubanum].uh_physuba->uba_map[0]);
        !          1247:                        }
        !          1248:                else
        !          1249: #              endif MVAX
        !          1250:                        mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24);
        !          1251: 
        !          1252:                bp->b_ubinfo = tempi;                   /* save mapping info */
        !          1253:                }
        !          1254:        if (tms->tms_serex == 2)                        /* if tape mark read */
        !          1255:                {
        !          1256:                mp->mscp_modifier |= M_MD_CLSEX;        /*  clear serious exc */
        !          1257:                tms->tms_serex = 0;
        !          1258:                }
        !          1259:        *((long *)mp->mscp_dscptr) |= TMSCP_OWN|TMSCP_INT;
        !          1260: #      ifdef DEBUG
        !          1261:        printd("tmscpstart: opcode 0%o mod %o unit %d cnt %d\n",mp->mscp_opcode,mp->mscp_modifier,mp->mscp_unit,mp->mscp_bytecnt);
        !          1262:        if(tmscpdebug)DELAY(100000);
        !          1263: #      endif
        !          1264:        i = tmscpaddr->tmscpip;              /* initiate polling */
        !          1265:        dp->b_qsize++;
        !          1266:        /*
        !          1267:         * Move drive to the end of the controller queue
        !          1268:         */
        !          1269:        if (dp->b_forw != NULL)
        !          1270:                {
        !          1271:                um->um_tab.b_actf = dp->b_forw;
        !          1272:                um->um_tab.b_actl->b_forw = dp;
        !          1273:                um->um_tab.b_actl = dp;
        !          1274:                dp->b_forw = NULL;
        !          1275:                }
        !          1276:        /*
        !          1277:         * Move buffer to I/O wait queue
        !          1278:         */
        !          1279:        dp->b_actf = bp->av_forw;
        !          1280:        dp = &tmscpwtab[um->um_ctlr];
        !          1281:        bp->av_forw = dp;
        !          1282:        bp->av_back = dp->av_back;
        !          1283:        dp->av_back->av_forw = bp;
        !          1284:        dp->av_back = bp;
        !          1285:        if (tmscpaddr->tmscpsa&TMSCP_ERR)
        !          1286:                {
        !          1287:                printf("tmscp%d: fatal error (0%o)\n", um->um_ctlr, tmscpaddr->tmscpsa&0xffff);
        !          1288:                (void)tmscpinit(um->um_ctlr);
        !          1289:                break;
        !          1290:                }
        !          1291:     }   /* end for */
        !          1292:     /*
        !          1293:      * Check for response ring transitions lost in the
        !          1294:      * Race condition
        !          1295:      */
        !          1296:     for (i = sc->sc_lastrsp;; i++)
        !          1297:            {
        !          1298:            i %= NRSP;
        !          1299:            if (tm->tmscp_ca.ca_rspdsc[i]&TMSCP_OWN)
        !          1300:                    break;
        !          1301:            tmscprsp(um, tm, sc, i);
        !          1302:            tm->tmscp_ca.ca_rspdsc[i] |= TMSCP_OWN;
        !          1303:            }
        !          1304:     sc->sc_lastrsp = i;
        !          1305: }
        !          1306: 
        !          1307: 
        !          1308: /*
        !          1309:  * Process a response packet
        !          1310:  */
        !          1311: tmscprsp(um, tm, sc, i)
        !          1312:        register struct uba_ctlr *um;
        !          1313:        register struct tmscp *tm;
        !          1314:        register struct tmscp_softc *sc;
        !          1315:        int i;
        !          1316: {
        !          1317:        register struct mscp *mp;
        !          1318:        register struct tms_info *tms;
        !          1319:        struct uba_device *ui;
        !          1320:        struct buf *dp, *bp;
        !          1321:        int st;
        !          1322: 
        !          1323:        mp = &tm->tmscp_rsp[i];
        !          1324:        mp->mscp_header.tmscp_msglen = mscp_msglen;
        !          1325:        sc->sc_credits += mp->mscp_header.tmscp_credits & 0xf;  /* low 4 bits */
        !          1326:        if ((mp->mscp_header.tmscp_credits & 0xf0) > 0x10)      /* Check */
        !          1327:                return;
        !          1328: #      ifdef DEBUG
        !          1329:        printd("tmscprsp, opcode 0%o status 0%o\n",mp->mscp_opcode,mp->mscp_status&M_ST_MASK);
        !          1330: #      endif   
        !          1331:        /*
        !          1332:         * If it's an error log message (datagram),
        !          1333:         * pass it on for more extensive processing.
        !          1334:         */
        !          1335:        if ((mp->mscp_header.tmscp_credits & 0xf0) == 0x10)
        !          1336:                {       /* check */
        !          1337:                tmserror(um, (struct mslg *)mp);
        !          1338:                return;
        !          1339:                }
        !          1340:        st = mp->mscp_status&M_ST_MASK;
        !          1341:        /*
        !          1342:         * The controller interrupts as drive 0.
        !          1343:         * This means that you must check for controller interrupts
        !          1344:         * before you check to see if there is a drive 0.
        !          1345:         */
        !          1346:        if((M_OP_STCON|M_OP_END) == mp->mscp_opcode)
        !          1347:                {
        !          1348:                if (st == M_ST_SUCC)
        !          1349:                        {
        !          1350: #                      ifdef DEBUG
        !          1351:                        printd("ctlr has %d credits\n", mp->mscp_header.tmscp_credits & 0xf);
        !          1352:                        printd("ctlr timeout = %d\n", mp->mscp_cnttmo);
        !          1353: #                      endif
        !          1354:                        sc->sc_state = S_RUN;
        !          1355:                        }
        !          1356:                else
        !          1357:                        sc->sc_state = S_IDLE;
        !          1358:                um->um_tab.b_active = 0;
        !          1359:                wakeup((caddr_t)um);
        !          1360:                return;
        !          1361:                }
        !          1362:        if (mp->mscp_unit >= NTMS)
        !          1363:                return;
        !          1364:        if ((ui = tmscpip[um->um_ctlr][mp->mscp_unit]) == 0)
        !          1365:                return;
        !          1366:        tms = &tms_info[ui->ui_unit];
        !          1367:        /*
        !          1368:         * Save endcode, endflags, and status for mtioctl get unit status.
        !          1369:         * NOTE: Don't do this on Clear serious exception (reposition no-op);
        !          1370:         *    which is done on close since this would
        !          1371:         *    overwrite the real status we want.
        !          1372:         */
        !          1373:        if (tms->tms_clserex != 1)
        !          1374:                {
        !          1375:                tms->tms_endcode = mp->mscp_opcode;
        !          1376:                tms->tms_flags = mp->mscp_flags;
        !          1377:                tms->tms_status = st;
        !          1378:                }
        !          1379:        else tms->tms_clserex = 0;
        !          1380: 
        !          1381:        switch (mp->mscp_opcode) {
        !          1382:        case M_OP_ONLIN|M_OP_END:
        !          1383:                tms->tms_type = mp->mscp_mediaid;
        !          1384:                dp = &tmsutab[ui->ui_unit];
        !          1385:                if (st == M_ST_SUCC)
        !          1386:                        {
        !          1387:                        /*
        !          1388:                         * Link the drive onto the controller queue
        !          1389:                         */
        !          1390:                        dp->b_forw = NULL;
        !          1391:                        if (um->um_tab.b_actf == NULL)
        !          1392:                                um->um_tab.b_actf = dp;
        !          1393:                        else
        !          1394:                                um->um_tab.b_actl->b_forw = dp;
        !          1395:                        um->um_tab.b_actl = dp;
        !          1396:                        ui->ui_flags = 1;       /* mark it online */
        !          1397:                        tms->tms_dsize=(daddr_t)mp->mscp_maxwrt;
        !          1398: #                      ifdef DEBUG
        !          1399:                        printd("tmscprsp: unit %d online\n", mp->mscp_unit);
        !          1400: #                      endif                   
        !          1401:                        /* 
        !          1402:                         * This define decodes the Media type identifier
        !          1403:                         */
        !          1404: #                      define F_to_C(x,i)     ( ((x)->mscp_mediaid) >> (i*5+7) & 0x1f ? ( ( (((x)->mscp_mediaid) >>( i*5 + 7)) & 0x1f) + 'A' - 1): ' ')
        !          1405: #                      ifdef DEBUG
        !          1406:                        printd("tmscprsp: unit %d online %x %c%c %c%c%c%d\n"
        !          1407:                                ,mp->mscp_unit, mp->mscp_mediaid ,F_to_C(mp,4)
        !          1408:                                ,F_to_C(mp,3), F_to_C(mp,2)
        !          1409:                                ,F_to_C(mp,1), F_to_C(mp,0), mp->mscp_mediaid & 0x7f);
        !          1410: #                      endif                           
        !          1411:                        dp->b_active = 1;
        !          1412:                        }       /* end if st == M_ST_SUCC */
        !          1413:                else 
        !          1414:                        {
        !          1415:                        if (bp = dp->b_actf)
        !          1416:                                tprintf(tms->tms_ttyp,
        !          1417:                                    "tms%d: hard error bn%d: OFFLINE\n",
        !          1418:                                    minor(bp->b_dev)&03, bp->b_blkno);
        !          1419:                        else
        !          1420:                                tprintf(tms->tms_ttyp,
        !          1421:                                    "tms%d: hard error: OFFLINE\n",
        !          1422:                                    ui->ui_unit);
        !          1423:                        while (bp = dp->b_actf)
        !          1424:                                {
        !          1425:                                dp->b_actf = bp->av_forw;
        !          1426:                                bp->b_flags |= B_ERROR;
        !          1427:                                iodone(bp);
        !          1428:                                }
        !          1429:                        }
        !          1430:                if(mp->mscp_cmdref!=NULL)
        !          1431:                        /* Seems to get lost sometimes in uda */
        !          1432:                        wakeup((caddr_t)mp->mscp_cmdref);
        !          1433:                break;
        !          1434:        /*
        !          1435:         * The AVAILABLE ATTENTION message occurs when the
        !          1436:         * unit becomes available after loading,
        !          1437:         * marking the unit offline (ui_flags = 0) will force an
        !          1438:         * online command prior to using the unit.
        !          1439:         */
        !          1440:        case M_OP_AVATN:
        !          1441:                ui->ui_flags = 0;
        !          1442:                tms->tms_type = mp->mscp_mediaid;
        !          1443:                break;
        !          1444:        case M_OP_END:
        !          1445:                /*
        !          1446:                 * An endcode without an opcode (0200) is an invalid command.
        !          1447:                 * The mscp specification states that this would be a protocol
        !          1448:                 * type error, such as illegal opcodes. The mscp spec. also
        !          1449:                 * states that parameter error type of invalid commands should
        !          1450:                 * return the normal end message for the command. This does not appear
        !          1451:                 * to be the case. An invalid logical block number returned an endcode
        !          1452:                 * of 0200 instead of the 0241 (read) that was expected.
        !          1453:                 */
        !          1454:                        
        !          1455:                printf("tmscp%d: invalid cmd, endcode = %o, status=%o\n",
        !          1456:                        um->um_ctlr, mp->mscp_opcode, st);
        !          1457:                bp = (struct buf *)mp->mscp_cmdref;
        !          1458:                /*
        !          1459:                 * Unlink buffer from I/O wait queue.
        !          1460:                 * And signal iodone, so the higher level command can exit!
        !          1461:                 *
        !          1462:                 */
        !          1463:                bp->av_back->av_forw = bp->av_forw;
        !          1464:                bp->av_forw->av_back = bp->av_back;
        !          1465:                dp = &tmsutab[ui->ui_unit];
        !          1466:                dp->b_qsize--;
        !          1467:                iodone(bp);
        !          1468:                break;
        !          1469:        case M_OP_WRITE|M_OP_END:
        !          1470:                /* mark the last io op as a write */
        !          1471:                tms->tms_lastiow = 1;
        !          1472:        case M_OP_READ|M_OP_END:
        !          1473:        case M_OP_WRITM|M_OP_END:
        !          1474:        case M_OP_REPOS|M_OP_END:
        !          1475:        case M_OP_STUNT|M_OP_END:
        !          1476:        /*
        !          1477:         * The AVAILABLE message occurs when the mt ioctl "rewoffl" is
        !          1478:         * issued.  For the ioctl, "rewoffl", a tmscp AVAILABLE command is
        !          1479:         * done with the UNLOAD modifier.  This performs a rewind, followed
        !          1480:         * by marking the unit offline.  So mark the unit offline
        !          1481:         * software wise as well (ui_flags = 0 and 
        !          1482:         * tms->tms_openf = 0).
        !          1483:         */
        !          1484:        case M_OP_AVAIL|M_OP_END:
        !          1485: #              ifdef DEBUG
        !          1486:                printd("tmscprsp: position = %d\n", mp->mscp_lbn);
        !          1487: #              endif
        !          1488:                bp = (struct buf *)mp->mscp_cmdref;
        !          1489:                /*
        !          1490:                 * Only need to release buffer if the command was read or write.
        !          1491:                 * No ubasetup was done in "tmscpstart" if it was an ioctl cmd.
        !          1492:                 */
        !          1493:                if (mp->mscp_opcode == (M_OP_READ|M_OP_END) || 
        !          1494:                    mp->mscp_opcode == (M_OP_WRITE|M_OP_END))
        !          1495:                        ubarelse(um->um_ubanum, (int *)&bp->b_ubinfo);
        !          1496:                /*
        !          1497:                 * Unlink buffer from I/O wait queue.
        !          1498:                 */
        !          1499:                bp->av_back->av_forw = bp->av_forw;
        !          1500:                bp->av_forw->av_back = bp->av_back;
        !          1501: #              if defined(VAX750)
        !          1502:                if (cpu == VAX_750) { 
        !          1503:                    if ((tmscpwtab[um->um_ctlr].av_forw == &tmscpwtab[um->um_ctlr]) &&
        !          1504:                                        (um->um_ubinfo != 0)) {
        !          1505:                        ubarelse(um->um_ubanum, &um->um_ubinfo);
        !          1506:                    }
        !          1507:                    else {
        !          1508:                        if (mp->mscp_opcode == (M_OP_READ|M_OP_END) ||
        !          1509:                            mp->mscp_opcode == (M_OP_WRITE|M_OP_END))
        !          1510:                                UBAPURGE(uba_hd[um->um_ubanum].uh_uba,(um->um_ubinfo >>28) & 0x0f);
        !          1511:                    }
        !          1512:                }
        !          1513: #              endif
        !          1514:                dp = &tmsutab[ui->ui_unit];
        !          1515:                dp->b_qsize--;
        !          1516:                if (st == M_ST_OFFLN || st == M_ST_AVLBL)
        !          1517:                        {
        !          1518:                        ui->ui_flags = 0;       /* mark unit offline */
        !          1519:                        tms->tms_openf = 0;
        !          1520:                        tms->tms_type = mp->mscp_mediaid;
        !          1521:                        /*
        !          1522:                         * Link the buffer onto the front of the drive queue
        !          1523:                         */
        !          1524:                        if ((bp->av_forw = dp->b_actf) == 0)
        !          1525:                                dp->b_actl = bp;
        !          1526:                        dp->b_actf = bp;
        !          1527:                        /*
        !          1528:                         * Link the drive onto the controller queue
        !          1529:                         */
        !          1530:                        if (dp->b_active == 0)
        !          1531:                                {
        !          1532:                                dp->b_forw = NULL;
        !          1533:                                if (um->um_tab.b_actf == NULL)
        !          1534:                                        um->um_tab.b_actf = dp;
        !          1535:                                else
        !          1536:                                        um->um_tab.b_actl->b_forw = dp;
        !          1537:                                um->um_tab.b_actl = dp;
        !          1538:                                dp->b_active = 1;
        !          1539:                                }
        !          1540: #                      if defined(VAX750)
        !          1541:                        if (cpu == VAX_750 && um->um_ubinfo == 0)
        !          1542:                                um->um_ubinfo = uballoc(um->um_ubanum, (caddr_t)0, 0, UBA_NEEDBDP);
        !          1543: #                      endif
        !          1544:                        return;
        !          1545:                        }
        !          1546:                if (st != M_ST_SUCC)
        !          1547:                        {
        !          1548:                        if (mp->mscp_flags & M_EF_SEREX)
        !          1549:                                tms->tms_serex = 1;
        !          1550:                        if (st != M_ST_TAPEM)
        !          1551:                                {
        !          1552:                                tprintf(tms->tms_ttyp,
        !          1553:                                    "tms%d: hard error bn%d\n",
        !          1554:                                    minor(bp->b_dev)&03, bp->b_blkno);
        !          1555:                                errinfo(st);            /* produces more info */
        !          1556: #                              ifdef DEBUG
        !          1557:                                printd("tmscprsp: error; status sub-code = 0%o, flags = 0%o\n",
        !          1558:                                        (mp->mscp_status & 177740)>>5, mp->mscp_flags);
        !          1559: #                              endif
        !          1560:                                bp->b_flags |= B_ERROR;
        !          1561:                                }
        !          1562:                        else
        !          1563:                                /* Hit a tape mark - Set serex flag to
        !          1564:                                 * a special value so we can clear the
        !          1565:                                 * serious exception on the next command.
        !          1566:                                 */
        !          1567:                                tms->tms_serex = 2;
        !          1568:                        }
        !          1569:                /*
        !          1570:                 * The tmscp spec states that controllers do not have to
        !          1571:                 * report the number of records or files skipped.  So on
        !          1572:                 * reposition commands we go strictly by cmd status.
        !          1573:                 */
        !          1574:                if (mp->mscp_opcode != (M_OP_REPOS|M_OP_END))
        !          1575:                        bp->b_resid = bp->b_bcount - mp->mscp_bytecnt;
        !          1576:                else
        !          1577:                        bp->b_resid = 0;
        !          1578:                tms->tms_resid = bp->b_resid;
        !          1579:                iodone(bp);
        !          1580:                break;
        !          1581: 
        !          1582:        case M_OP_GTUNT|M_OP_END:
        !          1583: #              ifdef DEBUG
        !          1584:                printd("tmscprsp: GTUNT end packet status = 0%o\n",st);
        !          1585:                printd("tmscprsp: unit %d mediaid %x %c%c %c%c%c%d %x %x t=%d\n"
        !          1586:                    ,mp->mscp_unit, mp->mscp_mediaid
        !          1587:                    ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2)
        !          1588:                    ,F_to_C(mp,1),F_to_C(mp,0)
        !          1589:                    ,mp->mscp_mediaid & 0x7f
        !          1590:                    ,mp->mscp_unitid.val[0]
        !          1591:                    ,mp->mscp_unitid.val[1]
        !          1592:                    ,mp->mscp_format);
        !          1593: #              endif           
        !          1594:                tms->tms_type = mp->mscp_mediaid;
        !          1595:                tms->tms_fmtmenu = mp->mscp_fmtmenu;
        !          1596:                tms->tms_unitflgs = mp->mscp_unitflgs;
        !          1597:                break;
        !          1598: 
        !          1599:        default:
        !          1600:                printf("tmscp unknown packet\n");
        !          1601:                tmserror(um, (struct mslg *)mp);
        !          1602:        }       /* end switch mp->mscp_opcode */
        !          1603: }
        !          1604: 
        !          1605: 
        !          1606: /* 
        !          1607:  * Give a meaningful error when the mscp_status field returns an error code.
        !          1608:  */
        !          1609: 
        !          1610: errinfo(st)
        !          1611:        int st;                 /* the status code */
        !          1612: {
        !          1613:        switch(st) {
        !          1614:        case M_ST_ICMD:
        !          1615:                printf("invalid command\n");
        !          1616:                break;
        !          1617:        case M_ST_ABRTD:
        !          1618:                printf("command aborted\n");
        !          1619:                break;
        !          1620:        case M_ST_OFFLN:
        !          1621:                printf("unit offline\n");
        !          1622:                break;
        !          1623:        case M_ST_WRTPR:
        !          1624:                printf("unit write protected\n");
        !          1625:                break;
        !          1626:        case M_ST_COMP:
        !          1627:                printf("compare error\n");
        !          1628:                break;
        !          1629:        case M_ST_DATA:
        !          1630:                printf("data error\n");
        !          1631:                break;
        !          1632:        case M_ST_HSTBF:
        !          1633:                printf("host buffer access error\n");
        !          1634:                break;
        !          1635:        case M_ST_CNTLR:
        !          1636:                printf("controller error\n");
        !          1637:                break;
        !          1638:        case M_ST_DRIVE:
        !          1639:                printf("drive error\n");
        !          1640:                break;
        !          1641:        case M_ST_FMTER:
        !          1642:                printf("formatter error\n");
        !          1643:                break;
        !          1644:        case M_ST_BOT:
        !          1645:                printf("BOT encountered\n");
        !          1646:                break;
        !          1647:        case M_ST_TAPEM:
        !          1648:                printf("tape mark encountered\n");
        !          1649:                break;
        !          1650:        case M_ST_RDTRN:
        !          1651:                printf("record data truncated\n");
        !          1652:                break;
        !          1653:        case M_ST_PLOST:
        !          1654:                printf("position lost\n");
        !          1655:                break;
        !          1656:        case M_ST_SEX:
        !          1657:                printf("serious exception\n");
        !          1658:                break;
        !          1659:        case M_ST_LED:
        !          1660:                printf("LEOT detected\n");
        !          1661:                break;
        !          1662:        }
        !          1663: }
        !          1664: 
        !          1665: 
        !          1666: /*
        !          1667:  * Manage buffers and perform block mode read and write operations.
        !          1668:  */
        !          1669: 
        !          1670: tmscpstrategy (bp)
        !          1671:        register struct buf *bp;
        !          1672: {
        !          1673:        register struct uba_device *ui;
        !          1674:        register struct uba_ctlr *um;
        !          1675:        register struct buf *dp;
        !          1676:        register int unit = TMSUNIT(bp->b_dev);
        !          1677:        int s;
        !          1678: 
        !          1679:        if (unit >= NTMS)
        !          1680:                {
        !          1681: #              ifdef DEBUG
        !          1682:                printd ("tmscpstrategy: bad unit # %d\n",unit);
        !          1683: #              endif
        !          1684:                bp->b_flags |= B_ERROR;
        !          1685:                iodone(bp);
        !          1686:                return;
        !          1687:                }
        !          1688:        ui = tmsdinfo[unit];
        !          1689:        um = ui->ui_mi;
        !          1690:        if (ui == 0 || ui->ui_alive == 0)
        !          1691:                {
        !          1692:                bp->b_flags |= B_ERROR;
        !          1693:                iodone(bp);
        !          1694:                return;
        !          1695:                }
        !          1696:        s = spl5();
        !          1697:        /*
        !          1698:         * Link the buffer onto the drive queue
        !          1699:         */
        !          1700:        dp = &tmsutab[ui->ui_unit];
        !          1701:        if (dp->b_actf == 0)
        !          1702:                dp->b_actf = bp;
        !          1703:        else
        !          1704:                dp->b_actl->av_forw = bp;
        !          1705:        dp->b_actl = bp;
        !          1706:        bp->av_forw = 0;
        !          1707:        /*
        !          1708:         * Link the drive onto the controller queue
        !          1709:         */
        !          1710:        if (dp->b_active == 0)
        !          1711:                {
        !          1712:                dp->b_forw = NULL;
        !          1713:                if (um->um_tab.b_actf == NULL)
        !          1714:                        um->um_tab.b_actf = dp;
        !          1715:                else
        !          1716:                        um->um_tab.b_actl->b_forw = dp;
        !          1717:                um->um_tab.b_actl = dp;
        !          1718:                dp->b_active = 1;
        !          1719:                }
        !          1720:        /*
        !          1721:         * If the controller is not active, start it.
        !          1722:         */
        !          1723:        if (um->um_tab.b_active == 0)
        !          1724:                {
        !          1725: #              if defined(VAX750)
        !          1726:                if (cpu == VAX_750
        !          1727:                                 && tmscpwtab[um->um_ctlr].av_forw == &tmscpwtab[um->um_ctlr])
        !          1728:                        {
        !          1729:                        if (um->um_ubinfo != 0)
        !          1730:                                log(TMS_PRI, "tmscpstrategy: ubinfo 0x%x\n",
        !          1731:                                    um->um_ubinfo);
        !          1732:                        else
        !          1733:                                um->um_ubinfo = uballoc(um->um_ubanum, (caddr_t)0, 0, UBA_NEEDBDP);
        !          1734:                        }
        !          1735: #              endif
        !          1736: #              ifdef DEBUG
        !          1737:                printd10("tmscpstrategy: Controller not active, starting it\n");
        !          1738: #              endif
        !          1739:                (void) tmscpstart(um);
        !          1740:                }
        !          1741:        splx(s);
        !          1742:        return;
        !          1743: }
        !          1744: 
        !          1745: #define DBSIZE 32
        !          1746: 
        !          1747: #define ca_Rspdsc       ca_rspdsc[0]
        !          1748: #define ca_Cmddsc       ca_rspdsc[1]
        !          1749: #define tmscp_Rsp       tmscp_rsp[0]
        !          1750: #define tmscp_Cmd       tmscp_cmd[0]
        !          1751: 
        !          1752: struct  tmscp     tmscpd[NTMSCP];
        !          1753: 
        !          1754: tmscpdump(dev)
        !          1755:        dev_t dev;
        !          1756: {
        !          1757:        struct tmscpdevice *tmscpaddr;
        !          1758:        struct tmscp *tmscp_ubaddr;
        !          1759:        char *start;
        !          1760:        int num, blk, unit;
        !          1761:        register struct uba_regs *uba;
        !          1762:        register struct uba_device *ui;
        !          1763:        register struct tmscp *tmscpp;
        !          1764:        register struct pte *io;
        !          1765:        register int i;
        !          1766: 
        !          1767:        unit = minor(dev) & 03;
        !          1768:        if (unit >= NTMS)
        !          1769:                return (ENXIO);
        !          1770: #      define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
        !          1771:        ui = phys(struct uba_device *, tmsdinfo[unit]);
        !          1772:        if (ui->ui_alive == 0)
        !          1773:                return (ENXIO);
        !          1774:        uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
        !          1775:        ubainit(uba);
        !          1776:        tmscpaddr = (struct tmscpdevice *)ui->ui_physaddr;
        !          1777:        DELAY(2000000);
        !          1778:        tmscpp = phys(struct tmscp *, &tmscpd[ui->ui_ctlr]);
        !          1779: 
        !          1780:        num = btoc(sizeof(struct tmscp)) + 1;
        !          1781:        io = &uba->uba_map[NUBMREG-num];
        !          1782:        for(i = 0; i<num; i++)
        !          1783:                *(int *)io++ = UBAMR_MRV|(btop(tmscpp)+i);
        !          1784:        tmscp_ubaddr = (struct tmscp *)(((int)tmscpp & PGOFSET)|((NUBMREG-num)<<9));
        !          1785: 
        !          1786:        tmscpaddr->tmscpip = 0;
        !          1787:        while ((tmscpaddr->tmscpsa & TMSCP_STEP1) == 0)
        !          1788:                if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
        !          1789:        tmscpaddr->tmscpsa = TMSCP_ERR;
        !          1790:        while ((tmscpaddr->tmscpsa & TMSCP_STEP2) == 0)
        !          1791:                if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
        !          1792:        tmscpaddr->tmscpsa = (short)&tmscp_ubaddr->tmscp_ca.ca_ringbase;
        !          1793:        while ((tmscpaddr->tmscpsa & TMSCP_STEP3) == 0)
        !          1794:                if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
        !          1795:        tmscpaddr->tmscpsa = (short)(((int)&tmscp_ubaddr->tmscp_ca.ca_ringbase) >> 16);
        !          1796:        while ((tmscpaddr->tmscpsa & TMSCP_STEP4) == 0)
        !          1797:                if(tmscpaddr->tmscpsa & TMSCP_ERR) return(EFAULT);
        !          1798:        tmscpaddr->tmscpsa = TMSCP_GO;
        !          1799:        tmscpp->tmscp_ca.ca_Rspdsc = (long)&tmscp_ubaddr->tmscp_Rsp.mscp_cmdref;
        !          1800:        tmscpp->tmscp_ca.ca_Cmddsc = (long)&tmscp_ubaddr->tmscp_Cmd.mscp_cmdref;
        !          1801:        tmscpp->tmscp_Cmd.mscp_header.tmscp_vcid = 1;   /* for tape */
        !          1802:        tmscpp->tmscp_Cmd.mscp_cntflgs = 0;
        !          1803:        tmscpp->tmscp_Cmd.mscp_version = 0;
        !          1804:        if (tmscpcmd(M_OP_STCON, tmscpp, tmscpaddr) == 0) {
        !          1805:                return(EFAULT);
        !          1806:        }
        !          1807:        tmscpp->tmscp_Cmd.mscp_unit = ui->ui_slave;
        !          1808:        if (tmscpcmd(M_OP_ONLIN, tmscpp, tmscpaddr) == 0) {
        !          1809:                return(EFAULT);
        !          1810:        }
        !          1811: 
        !          1812:        num = maxfree;
        !          1813:        start = 0;
        !          1814:        while (num > 0)
        !          1815:                {
        !          1816:                blk = num > DBSIZE ? DBSIZE : num;
        !          1817:                io = uba->uba_map;
        !          1818:                for (i = 0; i < blk; i++)
        !          1819:                        *(int *)io++ = (btop(start)+i) | UBAMR_MRV;
        !          1820:                *(int *)io = 0;
        !          1821:                tmscpp->tmscp_Cmd.mscp_lbn = btop(start);
        !          1822:                tmscpp->tmscp_Cmd.mscp_unit = ui->ui_slave;
        !          1823:                tmscpp->tmscp_Cmd.mscp_bytecnt = blk*NBPG;
        !          1824: #              ifdef   MVAX
        !          1825:                if( cpu == MVAX_I )
        !          1826:                        tmscpp->tmscp_Cmd.mscp_buffer = (long) start;
        !          1827:                else
        !          1828: #              endif   MVAX
        !          1829:                        tmscpp->tmscp_Cmd.mscp_buffer = 0;
        !          1830:                if (tmscpcmd(M_OP_WRITE, tmscpp, tmscpaddr) == 0)
        !          1831:                        return(EIO);
        !          1832:                start += blk*NBPG;
        !          1833:                num -= blk;
        !          1834:                }
        !          1835:        return (0);
        !          1836: }
        !          1837: 
        !          1838: 
        !          1839: /*
        !          1840:  * Perform a standalone tmscp command.  This routine is only used by tmscpdump.
        !          1841:  */
        !          1842: 
        !          1843: tmscpcmd(op, tmscpp, tmscpaddr)
        !          1844:        int op;
        !          1845:        register struct tmscp *tmscpp;
        !          1846:        struct tmscpdevice *tmscpaddr;
        !          1847: {
        !          1848:        int i;
        !          1849: 
        !          1850: 
        !          1851:        tmscpp->tmscp_Cmd.mscp_opcode = op;
        !          1852:        tmscpp->tmscp_Rsp.mscp_header.tmscp_msglen = mscp_msglen;
        !          1853:        tmscpp->tmscp_Cmd.mscp_header.tmscp_msglen = mscp_msglen;
        !          1854:        tmscpp->tmscp_ca.ca_Rspdsc |= TMSCP_OWN|TMSCP_INT;
        !          1855:        tmscpp->tmscp_ca.ca_Cmddsc |= TMSCP_OWN|TMSCP_INT;
        !          1856:        if (tmscpaddr->tmscpsa&TMSCP_ERR)
        !          1857:                printf("tmscp fatal error (0%o)\n", tmscpaddr->tmscpsa&0xffff);
        !          1858:        i = tmscpaddr->tmscpip;
        !          1859: #ifdef lint
        !          1860:        i = i;
        !          1861: #endif
        !          1862:        for (;;)
        !          1863:                {
        !          1864:                if (tmscpp->tmscp_ca.ca_cmdint)
        !          1865:                        tmscpp->tmscp_ca.ca_cmdint = 0;
        !          1866:                if (tmscpp->tmscp_ca.ca_rspint)
        !          1867:                        break;
        !          1868:                }
        !          1869:        tmscpp->tmscp_ca.ca_rspint = 0;
        !          1870:        if (tmscpp->tmscp_Rsp.mscp_opcode != (op|M_OP_END) ||
        !          1871:            (tmscpp->tmscp_Rsp.mscp_status&M_ST_MASK) != M_ST_SUCC)
        !          1872:                {
        !          1873:                printf("error: com %d opc 0x%x stat 0x%x\ndump ", op,
        !          1874:                        tmscpp->tmscp_Rsp.mscp_opcode, tmscpp->tmscp_Rsp.mscp_status);
        !          1875:                return(0);
        !          1876:                }
        !          1877:        return(1);
        !          1878: }
        !          1879: 
        !          1880: 
        !          1881: /*
        !          1882:  * Perform raw read
        !          1883:  */
        !          1884: 
        !          1885: tmscpread(dev, uio)
        !          1886:        dev_t dev;
        !          1887:        struct uio *uio;
        !          1888: {
        !          1889:        register int unit = TMSUNIT(dev);
        !          1890: 
        !          1891:        if (unit >= NTMS)
        !          1892:                return (ENXIO);
        !          1893:        return (physio(tmscpstrategy, &rtmsbuf[unit], dev, B_READ, minphys, uio));
        !          1894: }
        !          1895: 
        !          1896: 
        !          1897: /*
        !          1898:  * Perform raw write
        !          1899:  */
        !          1900: 
        !          1901: tmscpwrite(dev, uio)
        !          1902:        dev_t dev;
        !          1903:        struct uio *uio;
        !          1904: {
        !          1905:        register int unit = TMSUNIT(dev);
        !          1906: 
        !          1907:        if (unit >= NTMS)
        !          1908:                return (ENXIO);
        !          1909:        return (physio(tmscpstrategy, &rtmsbuf[unit], dev, B_WRITE, minphys, uio));
        !          1910: }
        !          1911: 
        !          1912: 
        !          1913: /*
        !          1914:  * Catch ioctl commands, and call the "command" routine to do them.
        !          1915:  */
        !          1916: 
        !          1917: /* ARGSUSED */
        !          1918: tmscpioctl(dev, cmd, data, flag)
        !          1919:        dev_t dev;
        !          1920:        int cmd;
        !          1921:        caddr_t data;
        !          1922:        int flag;
        !          1923: {
        !          1924:        register struct buf *bp = &ctmscpbuf[TMSCPCTLR(dev)];
        !          1925:        register callcount;     /* number of times to call cmd routine */
        !          1926:        register struct uba_device *ui;
        !          1927:        register struct tms_info *tms;
        !          1928:        int fcount;             /* number of files (or records) to space */
        !          1929:        register struct mtop *mtop;     /* mag tape cmd op to perform */
        !          1930:        register struct mtget *mtget;   /* mag tape struct to get info in */
        !          1931: 
        !          1932:        /* we depend of the values and order of the TMS ioctl codes here */
        !          1933:        static tmsops[] =
        !          1934:         {TMS_WRITM,TMS_FSF,TMS_BSF,TMS_FSR,TMS_BSR,TMS_REW,TMS_OFFL,TMS_SENSE,
        !          1935:          TMS_CACHE,TMS_NOCACHE};
        !          1936: 
        !          1937:        switch (cmd) {
        !          1938:        case MTIOCTOP:  /* tape operation */
        !          1939:                mtop = (struct mtop *)data;
        !          1940:                switch (mtop->mt_op) {
        !          1941: 
        !          1942:                case MTWEOF:
        !          1943:                        callcount = mtop->mt_count;
        !          1944:                        fcount = 1;
        !          1945:                        break;
        !          1946:                case MTFSF: case MTBSF:
        !          1947:                case MTFSR: case MTBSR:
        !          1948:                        callcount = 1;
        !          1949:                        fcount = mtop->mt_count;
        !          1950:                        break;
        !          1951:                case MTREW: case MTOFFL: case MTNOP:
        !          1952:                case MTCACHE: case MTNOCACHE:
        !          1953:                        callcount = 1;
        !          1954:                        fcount = 1;             /* wait for this rewind */
        !          1955:                        break;
        !          1956:                default:
        !          1957:                        return (ENXIO);
        !          1958:                }       /* end switch mtop->mt_op */
        !          1959: 
        !          1960:                if (callcount <= 0 || fcount <= 0)
        !          1961:                        return (EINVAL);
        !          1962:                while (--callcount >= 0)
        !          1963:                        {
        !          1964:                        tmscpcommand(dev, tmsops[mtop->mt_op], fcount);
        !          1965:                        if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) &&
        !          1966:                            bp->b_resid)
        !          1967:                                return (EIO);
        !          1968:                        if (bp->b_flags & B_ERROR)      /* like hitting BOT */
        !          1969:                                break;
        !          1970:                        }
        !          1971:                return (geterror(bp));
        !          1972: 
        !          1973:        case MTIOCGET:
        !          1974:                /*
        !          1975:                 * Return status info associated with the particular UNIT.
        !          1976:                 */
        !          1977:                ui = tmsdinfo[TMSUNIT(dev)];
        !          1978:                tms = &tms_info[ui->ui_unit];
        !          1979:                mtget = (struct mtget *)data;
        !          1980:                mtget->mt_type = MT_ISTMSCP;
        !          1981:                mtget->mt_dsreg = tms->tms_flags << 8;
        !          1982:                mtget->mt_dsreg |= tms->tms_endcode;
        !          1983:                mtget->mt_erreg = tms->tms_status;
        !          1984:                mtget->mt_resid = tms->tms_resid;
        !          1985:                break;
        !          1986: 
        !          1987:        default:
        !          1988:                return (ENXIO);
        !          1989:        }
        !          1990:        return (0);
        !          1991: }
        !          1992: 
        !          1993: 
        !          1994: /*
        !          1995:  * Reset (for raw mode use only).
        !          1996:  */
        !          1997: 
        !          1998: tmscpreset (uban)
        !          1999:        int uban;
        !          2000: {
        !          2001:        register struct uba_ctlr *um;
        !          2002:        register struct uba_device *ui;
        !          2003:        register struct buf *bp, *dp;
        !          2004:        register int unit;
        !          2005:        struct buf *nbp;
        !          2006:        int d;
        !          2007: 
        !          2008:        for (d = 0; d < NTMSCP; d++)
        !          2009:                {
        !          2010:                if ((um = tmscpminfo[d]) == 0 || um->um_ubanum != uban ||
        !          2011:                    um->um_alive == 0)
        !          2012:                        continue;
        !          2013:                printf(" tmscp%d", d);
        !          2014:                um->um_tab.b_active = 0;
        !          2015:                um->um_tab.b_actf = um->um_tab.b_actl = 0;
        !          2016:                tmscp_softc[d].sc_state = S_IDLE;
        !          2017:                tmscp_softc[d].sc_mapped = 0;
        !          2018:                for (unit = 0; unit < NTMS; unit++)
        !          2019:                        {
        !          2020:                        if ((ui = tmsdinfo[unit]) == 0)
        !          2021:                                continue;
        !          2022:                        if (ui->ui_alive == 0 || ui->ui_mi != um)
        !          2023:                                continue;
        !          2024:                        tmsutab[unit].b_active = 0;
        !          2025:                        tmsutab[unit].b_qsize = 0;
        !          2026:                        }
        !          2027:                for (bp = tmscpwtab[d].av_forw; bp != &tmscpwtab[d]; bp = nbp)
        !          2028:                        {
        !          2029:                        nbp = bp->av_forw;
        !          2030:                        bp->b_ubinfo = 0;
        !          2031:                        /*
        !          2032:                         * Link the buffer onto the drive queue
        !          2033:                         */
        !          2034:                        dp = &tmsutab[TMSUNIT(bp->b_dev)];
        !          2035:                        if (dp->b_actf == 0)
        !          2036:                                dp->b_actf = bp;
        !          2037:                        else
        !          2038:                                dp->b_actl->av_forw = bp;
        !          2039:                        dp->b_actl = bp;
        !          2040:                        bp->av_forw = 0;
        !          2041:                        /*
        !          2042:                         * Link the drive onto the controller queue
        !          2043:                         */
        !          2044:                        if (dp->b_active == 0)
        !          2045:                                {
        !          2046:                                dp->b_forw = NULL;
        !          2047:                                if (um->um_tab.b_actf == NULL)
        !          2048:                                        um->um_tab.b_actf = dp;
        !          2049:                                else
        !          2050:                                        um->um_tab.b_actl->b_forw = dp;
        !          2051:                                um->um_tab.b_actl = dp;
        !          2052:                                dp->b_active = 1;
        !          2053:                                }
        !          2054:                        }
        !          2055:                (void)tmscpinit(d);
        !          2056:                }
        !          2057: }
        !          2058: 
        !          2059: 
        !          2060: /*
        !          2061:  * Process an error log message
        !          2062:  *
        !          2063:  * Only minimal decoding is done, only "useful"
        !          2064:  * information is printed.  Eventually should
        !          2065:  * send message to an error logger.
        !          2066:  */
        !          2067: 
        !          2068: tmserror(um, mp)
        !          2069:        register struct uba_ctlr *um;
        !          2070:        register struct mslg *mp;
        !          2071: {
        !          2072:        register i;
        !          2073: 
        !          2074: #      ifdef DEBUG
        !          2075:        printd("tmserror:\n");
        !          2076: #      endif
        !          2077:        if(!(mp->mslg_flags & (M_LF_SUCC | M_LF_CONT)))
        !          2078:                log(TMS_PRI, "tmscp%d: %s error, ", um->um_ctlr,
        !          2079:                mp->mslg_flags & ( M_LF_SUCC | M_LF_CONT ) ? "soft" : "hard");
        !          2080: 
        !          2081:        switch (mp->mslg_format) {
        !          2082: 
        !          2083:        case M_FM_CNTERR:
        !          2084:                log(TMS_PRI, "controller error, event 0%o\n", mp->mslg_event);
        !          2085:                break;
        !          2086:        case M_FM_BUSADDR:
        !          2087:                log(TMS_PRI, "host memory access error, event 0%o, addr 0%o\n",
        !          2088:                        mp->mslg_event, mp->mslg_busaddr);
        !          2089:                break;
        !          2090:        case M_FM_TAPETRN:
        !          2091:                log(TMS_PRI, "tape transfer error, unit %d, grp 0x%x, event 0%o\n",
        !          2092:                        mp->mslg_unit, mp->mslg_group, mp->mslg_event);
        !          2093:                break;
        !          2094:        case M_FM_STIERR:
        !          2095:                log(TMS_PRI, "STI error, unit %d, event 0%o\n",
        !          2096:                        mp->mslg_unit, mp->mslg_event);
        !          2097: #ifdef notdef
        !          2098:                /* too painful to do with log() */
        !          2099:                for(i = 0; i < 62;i++)
        !          2100:                        mprintf("\t0x%x",mp->mslg_stiunsucc[i] & 0xff);
        !          2101:                mprintf("\n");
        !          2102: #endif
        !          2103:                break;
        !          2104:        case M_FM_STIDEL:
        !          2105:                log(TMS_PRI, "STI Drive Error Log, unit %d, event 0%o\n",
        !          2106:                        mp->mslg_unit, mp->mslg_event);
        !          2107:                break;
        !          2108:        case M_FM_STIFEL:
        !          2109:                log(TMS_PRI, "STI Formatter Error Log, unit %d, event 0%o\n",
        !          2110:                        mp->mslg_unit, mp->mslg_event);
        !          2111:                break;
        !          2112:        default:
        !          2113:                log(TMS_PRI, "unknown error, unit %d, format 0%o, event 0%o\n",
        !          2114:                        mp->mslg_unit, mp->mslg_format, mp->mslg_event);
        !          2115:        }
        !          2116: 
        !          2117:        if (tmscperror)
        !          2118:                {
        !          2119:                register long *p = (long *)mp;
        !          2120: 
        !          2121:                for (i = 0; i < mp->mslg_header.tmscp_msglen; i += sizeof(*p))
        !          2122:                        printf("%x ", *p++);
        !          2123:                printf("\n");
        !          2124:                }
        !          2125: }
        !          2126: #endif

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