4.3BSD - /usr/src/sys/vaxuba/tmscp.c

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

Defined functions

Defined variables

Defined struct's

Defined macros