Return to tmscp.c CVS log

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

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

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

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