xref: /csrg-svn/sys/hp300/dev/st.c (revision 60897)
146286Smckusick /*
246286Smckusick  * Copyright (c) 1990 University of Utah.
346286Smckusick  * Copyright (c) 1990 The Regents of the University of California.
446286Smckusick  * All rights reserved.
546286Smckusick  *
646286Smckusick  * This code is derived from software contributed to Berkeley by
746286Smckusick  * the Systems Programming Group of the University of Utah Computer
846286Smckusick  * Science Department.
946286Smckusick  *
1046286Smckusick  * %sccs.include.redist.c%
1146286Smckusick  *
1253930Shibler  * from: Utah $Hdr: st.c 1.11 92/01/21$
1346286Smckusick  *
14*60897Smarc  *      @(#)st.c	7.10 (Berkeley) 06/01/93
1546286Smckusick  */
1646286Smckusick 
1746286Smckusick /*
1846286Smckusick  * SCSI CCS (Command Command Set) tape driver.
1946286Smckusick  *
2046286Smckusick  * Specific to Exabyte:
2146286Smckusick  * mt status: residual="Mbytes to LEOM"
2246286Smckusick  * minor bit 4 [b1bbbb] (aka /dev/rst16) selects short filemarks
2346286Smckusick  * minor bit 5 [1bbbbb] (aka /dev/rst32) selects fix block mode, 1k blocks.
2446286Smckusick  *
2546286Smckusick  * Archive drive:
2646286Smckusick  * can read both QIC-24 and QIC-II. But only writes
2746286Smckusick  * QIC-24.
2846286Smckusick  *
2946286Smckusick  * Supports Archive Viper QIC-150 tape drive, but scsi.c reports selection
3046286Smckusick  * errors.
3146286Smckusick  *
3246286Smckusick  * Supports Archive Python DAT drive, but will sometimes hang machine.
3346286Smckusick  *
3446286Smckusick  * Supports HP 35450A DAT drive, but will sometimes hang machine.
3546286Smckusick  * Partitioning of tape not supported.
3646286Smckusick  * Vendor unique support has not been added.
3746286Smckusick  *
3846286Smckusick  *
3946286Smckusick  * Supports Archive VIPER (QIC-150).
4046286Smckusick  * Mostly Supports Archive PYTHON (DAT).
4146286Smckusick  *     Hangs if write after spin down.
4246286Smckusick  *     Need scsi.c that does connect/disconnect.
4346286Smckusick  */
4446286Smckusick 
4546286Smckusick /*
4646286Smckusick  * support for the block device not implemented
4746286Smckusick  */
4846286Smckusick 
4946286Smckusick #include "st.h"
5046286Smckusick #if NST > 0
5146286Smckusick 
5256507Sbostic #include <sys/param.h>
5356507Sbostic #include <sys/systm.h>
5456507Sbostic #include <sys/buf.h>
5556507Sbostic #include <sys/file.h>
5656507Sbostic #include <sys/proc.h>
5756507Sbostic #include <sys/ioctl.h>
5856507Sbostic #include <sys/tty.h>
5956507Sbostic #include <sys/mtio.h>
6056507Sbostic #include <sys/kernel.h>
6156507Sbostic #include <sys/tprintf.h>
6246286Smckusick 
6356507Sbostic #include <hp/dev/device.h>
6456507Sbostic #include <hp300/dev/scsireg.h>
6556507Sbostic #include <hp300/dev/stvar.h>
6646286Smckusick 
6746286Smckusick extern int scsi_test_unit_rdy();
6846286Smckusick extern int scsi_request_sense();
6946286Smckusick extern int scsiustart();
7046286Smckusick extern int scsigo();
7146286Smckusick extern void scsifree();
7246286Smckusick extern void scsireset();
7346286Smckusick extern void scsi_delay();
7446286Smckusick extern int scsi_tt_oddio();
7546286Smckusick 
7646286Smckusick extern int scsi_immed_command();
7746286Smckusick 
7846286Smckusick int	stinit(), ststart(), stgo(), stintr();
7946286Smckusick struct	driver stdriver = {
8046286Smckusick 	stinit, "st", ststart, stgo, stintr,
8146286Smckusick };
8246286Smckusick 
8346286Smckusick struct	st_softc {
8446286Smckusick 	struct	hp_device *sc_hd;
8546286Smckusick 	struct	devqueue sc_dq;
8646286Smckusick 	long	sc_blkno;       /* (possible block device support?) */
8746286Smckusick 	long	sc_resid;	/* (possible block device support?) */
8846286Smckusick 	int	sc_flags;
8946286Smckusick 	int	sc_blklen;	/* 0 = variable len records */
9046286Smckusick 	int	sc_filepos;	/* file position on tape */
9146286Smckusick 	long	sc_numblks;	/* number of blocks on tape */
9246286Smckusick 	short	sc_type;	/* ansi scsi type */
9346286Smckusick 	short	sc_punit;	/* physical unit (scsi lun) */
9446286Smckusick 	short	sc_tapeid;	/* tape drive id */
9546286Smckusick 	char	sc_datalen[32];	/* additional data length on some commands */
9646286Smckusick 	short	sc_tticntdwn;	/* interrupts between TTi display updates */
9749132Skarels 	tpr_t	sc_ctty;
9846286Smckusick 	struct	buf *sc_bp;
9946286Smckusick 	u_char	sc_cmd;
10046286Smckusick } st_softc[NST];
10146286Smckusick 
10246286Smckusick /* softc flags */
10346286Smckusick #define STF_ALIVE	0x0001
10446286Smckusick #define STF_OPEN	0x0002
10546286Smckusick #define STF_WMODE	0x0004
10646286Smckusick #define STF_WRTTN	0x0008
10746286Smckusick #define STF_CMD		0x0010
10846286Smckusick #define STF_LEOT	0x0020
10946286Smckusick #define STF_MOVED	0x0040
11046286Smckusick 
11146286Smckusick struct	st_mode st_mode[NST];
11246286Smckusick 
11346286Smckusick /*
11446286Smckusick  * Maybe this should not be global, but gives chance to get
11546286Smckusick  * tape remaining, Rewrites/ECC, etc outside the driver
11646286Smckusick  */
11746286Smckusick static struct st_xsense {
11846286Smckusick 	struct	scsi_xsense sc_xsense;	/* data from sense */
11946286Smckusick 	struct	exb_xsense exb_xsense;	/* additional info from exabyte */
12046286Smckusick } st_xsense[NST];
12146286Smckusick 
12246286Smckusick static struct scsi_fmt_cdb stcmd[NST];
12346286Smckusick 
12446286Smckusick static struct scsi_fmt_cdb st_read_cmd = { 6, CMD_READ };
12546286Smckusick static struct scsi_fmt_cdb st_write_cmd = { 6, CMD_WRITE };
12646286Smckusick 
12746286Smckusick struct buf sttab[NST];
12846286Smckusick struct buf stbuf[NST];
12946286Smckusick 
13046286Smckusick #define UNIT(x)		(minor(x) & 3)
13146286Smckusick #define stpunit(x)	((x) & 7)
13246286Smckusick 
13346286Smckusick #define STDEV_NOREWIND	0x04
13446286Smckusick #define STDEV_HIDENSITY	0x08
13546286Smckusick #define STDEV_EXSFMK	0x10
13646286Smckusick #define STDEV_FIXEDBLK	0x20
13746286Smckusick 
13846286Smckusick #ifdef DEBUG
13946286Smckusick int st_debug = 0x0000;
14046286Smckusick #define ST_OPEN		0x0001
14146286Smckusick #define ST_GO		0x0002
14246286Smckusick #define ST_FMKS		0x0004
14346286Smckusick #define ST_OPENSTAT	0x0008
14446286Smckusick #define ST_BRESID	0x0010
14546286Smckusick #define ST_ODDIO	0x0020
14646286Smckusick #endif
14746286Smckusick 
14846286Smckusick /*
14946286Smckusick  * Patchable variable.  If an even length read is requested a dma transfer is
15046286Smckusick  * used.  Only after the read will we find out if the read had an odd number
15146286Smckusick  * of bytes.  The HP98658 hardware cannot do odd length transfers, the last
15246286Smckusick  * byte of the data will always be 0x00.  Normally, the driver will complain
15346286Smckusick  * about such transfers and return EIO.  However, if st_dmaoddretry is non-
15446286Smckusick  * zero, the driver will try and issue a BSR and then re-read the data using
15546286Smckusick  * 'programmed transfer mode'.  In most cases this works, however for unknown
15646286Smckusick  * reasons it will hang the machine in certain cases.
15746286Smckusick  *
15846286Smckusick  * Note:
15946286Smckusick  * Odd length read requests are always done using programmed transfer mode.
16046286Smckusick  */
16146286Smckusick int st_dmaoddretry = 0;
16246286Smckusick 
16346286Smckusick /*
16446286Smckusick  * Exabyte only:
16546286Smckusick  * From adb can have access to fixed vs. variable length modes.
16646286Smckusick  * Use 0x400 for 1k (best capacity) fixed length records.
16746286Smckusick  * In st_open, if minor bit 4 set then 1k records are used.
16846286Smckusick  * If st_exblken is set to anything other then 0 we are in fixed length mode.
16953020Smarc  * Minor bit 5 requests 1K fixed-length, overriding any setting of st_exblklen.
17046286Smckusick  */
17146286Smckusick int st_exblklen = 0;
17246286Smckusick 
17346286Smckusick /* exabyte here for adb access, set at open time */
17446286Smckusick #define EX_CT 	0x80		/* international cart - more space W/P6  */
17546286Smckusick #define EX_ND	0x20		/* no disconnect  */
17646286Smckusick #define EX_NBE	0x08		/* no busy enable  */
17746286Smckusick #define EX_EBD	0x04		/* even byte disconnect  */
17846286Smckusick #define EX_PE	0x02		/* parity enable  */
17946286Smckusick #define EX_NAL	0x01		/* no auto load  */
18046286Smckusick int st_exvup = (EX_CT|EX_ND|EX_NBE); /* vendor unique parameters */
18146286Smckusick 
18246286Smckusick /*
18346286Smckusick  * motion and reconnect thresholds guidelines:
18446286Smckusick  * write operation; lower motion threshold for faster transfer
18546286Smckusick  *                  raise reconnect threshold for slower transfer
18646286Smckusick  * read operation; lower motion threshold for slower transfer
18746286Smckusick  *                 raise reconnect threshold for faster transfer
18846286Smckusick  */
18946286Smckusick int st_exmotthr = 0x80;		/* motion threshold, 0x80 default */
19046286Smckusick int st_exreconthr = 0xa0;	/* reconnect threshold, 0xa0 default */
19146286Smckusick int st_exgapthr = 7;		/* gap threshold, 7 default */
19246286Smckusick #ifdef TTI
19346286Smckusick int st_extti = 0x01;		/* bitmask of unit numbers, do extra */
19446286Smckusick 				/* sensing so TTi display gets updated */
19546286Smckusick #endif
19646286Smckusick 
19746286Smckusick stinit(hd)
19846286Smckusick 	register struct hp_device *hd;
19946286Smckusick {
20046286Smckusick 	register struct st_softc *sc = &st_softc[hd->hp_unit];
20156389Smckusick 	register struct buf *bp;
20246286Smckusick 
20356389Smckusick 	for (bp = sttab; bp < &sttab[NST]; bp++)
20456389Smckusick 		bp->b_actb = &bp->b_actf;
20546286Smckusick 	sc->sc_hd = hd;
20646286Smckusick 	sc->sc_punit = stpunit(hd->hp_flags);
20746286Smckusick 	sc->sc_type = stident(sc, hd);
20846286Smckusick 	if (sc->sc_type < 0)
20946286Smckusick 		return(0);
21046286Smckusick 	sc->sc_dq.dq_ctlr = hd->hp_ctlr;
21146286Smckusick 	sc->sc_dq.dq_unit = hd->hp_unit;
21246286Smckusick 	sc->sc_dq.dq_slave = hd->hp_slave;
21346286Smckusick 	sc->sc_dq.dq_driver = &stdriver;
21446286Smckusick 	sc->sc_blkno = 0;
21546286Smckusick 	sc->sc_flags = STF_ALIVE;
21646286Smckusick 	return(1);
21746286Smckusick }
21846286Smckusick 
21946286Smckusick stident(sc, hd)
22046286Smckusick 	register struct st_softc *sc;
22146286Smckusick 	register struct hp_device *hd;
22246286Smckusick {
22346286Smckusick 	int unit;
22446286Smckusick 	int ctlr, slave;
22546286Smckusick 	int i, stat, inqlen;
22646286Smckusick 	char idstr[32];
22746286Smckusick 	static int havest = 0;
22846286Smckusick 	struct st_inquiry {
22946286Smckusick 		struct	scsi_inquiry inqbuf;
23046286Smckusick 		struct  exb_inquiry exb_inquiry;
23146286Smckusick 	} st_inqbuf;
23246286Smckusick 	static struct scsi_fmt_cdb st_inq = {
23346286Smckusick 		6,
23446286Smckusick 		CMD_INQUIRY, 0, 0, 0, sizeof(st_inqbuf), 0
23546286Smckusick 	};
23646286Smckusick 
23746286Smckusick 	ctlr = hd->hp_ctlr;
23846286Smckusick 	slave = hd->hp_slave;
23946286Smckusick 	unit = sc->sc_punit;
24046286Smckusick 	scsi_delay(-1);
24146286Smckusick 
24246286Smckusick 	inqlen = 0x05; /* min */
24346286Smckusick 	st_inq.cdb[4] = 0x05;
24446286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &st_inq,
24546286Smckusick 				  (u_char *)&st_inqbuf, inqlen, B_READ);
24646286Smckusick 	/* do twice as first command on some scsi tapes always fails */
24746286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &st_inq,
24846286Smckusick 				  (u_char *)&st_inqbuf, inqlen, B_READ);
24946286Smckusick 	if (stat == -1)
25046286Smckusick 		goto failed;
25146286Smckusick 
25251141Skarels 	if ((st_inqbuf.inqbuf.type != 0x01 ||  /* sequential access device */
25346286Smckusick 	    st_inqbuf.inqbuf.qual != 0x80 ||  /* removable media */
25446286Smckusick 	    (st_inqbuf.inqbuf.version != 0x01 && /* current ANSI SCSI spec */
25551141Skarels 	     st_inqbuf.inqbuf.version != 0x02)) /* 0x02 is for HP DAT */
25651141Skarels 	    &&
25751141Skarels 	    (st_inqbuf.inqbuf.type != 0x01 ||	/* M4 ??! */
25851141Skarels 	     /*
25951141Skarels 	      * the M4 is a little too smart (ass?) for its own good:
26051141Skarels 	      * qual codes:
26151141Skarels 	      * 0x80: you can take the tape out (unit not online)
26251141Skarels 	      * 0xf8: online and at 6250bpi
26351141Skarels 	      * 0xf9: online and at 1600bpi
26451141Skarels 	      */
26551141Skarels 	     st_inqbuf.inqbuf.version != 0x09))	/* M4 tape */
26651141Skarels {
26751141Skarels printf("st: wrong specs: type %x qual %x version %d\n", st_inqbuf.inqbuf.type,
26851141Skarels st_inqbuf.inqbuf.qual, st_inqbuf.inqbuf.version);
26946286Smckusick 		goto failed;
27051141Skarels }
27146286Smckusick 
27246286Smckusick 	/* now get additonal info */
27346286Smckusick 	inqlen = 0x05 + st_inqbuf.inqbuf.len;
27446286Smckusick 	st_inq.cdb[4] = inqlen;
27546286Smckusick 	bzero(&st_inqbuf, sizeof(st_inqbuf));
27646286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &st_inq,
27746286Smckusick 				  (u_char *)&st_inqbuf, inqlen, B_READ);
27846286Smckusick 
27946286Smckusick 	if (st_inqbuf.inqbuf.len >= 28) {
28046286Smckusick 		bcopy((caddr_t)&st_inqbuf.inqbuf.vendor_id, (caddr_t)idstr, 28);
28146286Smckusick 		for (i = 27; i > 23; --i)
28246286Smckusick 			if (idstr[i] != ' ')
28346286Smckusick 				break;
28446286Smckusick 		idstr[i+1] = 0;
28546286Smckusick 		for (i = 23; i > 7; --i)
28646286Smckusick 			if (idstr[i] != ' ')
28746286Smckusick 				break;
28846286Smckusick 		idstr[i+1] = 0;
28946286Smckusick 		for (i = 7; i >= 0; --i)
29046286Smckusick 			if (idstr[i] != ' ')
29146286Smckusick 				break;
29246286Smckusick 		idstr[i+1] = 0;
293*60897Smarc 		printf("st%d: %s, %s rev %s\n", hd->hp_unit, idstr, &idstr[8],
29446286Smckusick 		       &idstr[24]);
29546286Smckusick 	} else if (inqlen == 5)
29646286Smckusick 		/* great it's a stupid device, doesn't know it's know name */
29746286Smckusick 		idstr[0] = idstr[8] = '\0';
29846286Smckusick 	else
29946286Smckusick 		idstr[8] = '\0';
30046286Smckusick 
30146286Smckusick 	if (stat == 0xff) {
30246286Smckusick 		printf("st%d: Cant handle this tape drive\n", hd->hp_unit);
30346286Smckusick 		goto failed;
30446286Smckusick 	}
30546286Smckusick 
30646286Smckusick 	if (bcmp("EXB-8200", &idstr[8], 8) == 0) {
30746286Smckusick 		sc->sc_tapeid = MT_ISEXABYTE;
30846286Smckusick 		sc->sc_datalen[CMD_REQUEST_SENSE] = 26;
30946286Smckusick 		sc->sc_datalen[CMD_INQUIRY] = 52;
31046286Smckusick 		sc->sc_datalen[CMD_MODE_SELECT] = 17;
31146286Smckusick 		sc->sc_datalen[CMD_MODE_SENSE] = 17;
31246286Smckusick 	} else if (bcmp("VIPER 150", &idstr[8], 9) == 0) {
31346286Smckusick 		sc->sc_tapeid = MT_ISVIPER1;
31446286Smckusick 		sc->sc_datalen[CMD_REQUEST_SENSE] = 14;
31546286Smckusick 		sc->sc_datalen[CMD_INQUIRY] = 36;
31646286Smckusick 		sc->sc_datalen[CMD_MODE_SELECT] = 12;
31746286Smckusick 		sc->sc_datalen[CMD_MODE_SENSE] = 12;
31846286Smckusick 	} else if (bcmp("Python 25501", &idstr[8], 12) == 0) {
31946286Smckusick 		sc->sc_tapeid = MT_ISPYTHON;
32046286Smckusick 		sc->sc_datalen[CMD_REQUEST_SENSE] = 14;
32146286Smckusick 		sc->sc_datalen[CMD_INQUIRY] = 36;
32246286Smckusick 		sc->sc_datalen[CMD_MODE_SELECT] = 12;
32346286Smckusick 		sc->sc_datalen[CMD_MODE_SENSE] = 12;
32446286Smckusick 	} else if (bcmp("HP35450A", &idstr[8], 8) == 0) {
32546286Smckusick 		/* XXX "extra" stat makes the HP drive happy at boot time */
32646286Smckusick 		stat = scsi_test_unit_rdy(ctlr, slave, unit);
32746286Smckusick 		sc->sc_tapeid = MT_ISHPDAT;
32846286Smckusick 		sc->sc_datalen[CMD_REQUEST_SENSE] = 14;
32946286Smckusick 		sc->sc_datalen[CMD_INQUIRY] = 36;
33046286Smckusick 		sc->sc_datalen[CMD_MODE_SELECT] = 12;
33146286Smckusick 		sc->sc_datalen[CMD_MODE_SENSE] = 12;
332*60897Smarc 	} else if (bcmp("123107 SCSI", &idstr[8], 11) == 0 ||
333*60897Smarc 		   bcmp("OPEN REEL TAPE", &idstr[8], 14) == 0) {
33451141Skarels 		sc->sc_tapeid = MT_ISMFOUR;
33551141Skarels 		sc->sc_datalen[CMD_REQUEST_SENSE] = 8;
33651141Skarels 		sc->sc_datalen[CMD_INQUIRY] = 5;
33751141Skarels 		sc->sc_datalen[CMD_MODE_SELECT] = 12;
33851141Skarels 		sc->sc_datalen[CMD_MODE_SENSE] = 12;
33946286Smckusick 	} else {
34046286Smckusick 		if (idstr[8] == '\0')
34146286Smckusick 			printf("st%d: No ID, assuming Archive\n", hd->hp_unit);
34246286Smckusick 		else
34346286Smckusick 			printf("st%d: Unsupported tape device\n", hd->hp_unit);
34446286Smckusick 		sc->sc_tapeid = MT_ISAR;
34546286Smckusick 		sc->sc_datalen[CMD_REQUEST_SENSE] = 8;
34646286Smckusick 		sc->sc_datalen[CMD_INQUIRY] = 5;
34746286Smckusick 		sc->sc_datalen[CMD_MODE_SELECT] = 12;
34846286Smckusick 		sc->sc_datalen[CMD_MODE_SENSE] = 12;
34946286Smckusick 	}
35046286Smckusick 
35146286Smckusick 	sc->sc_filepos = 0;
35246286Smckusick 
35346286Smckusick 	/* load xsense */
35446286Smckusick 	stxsense(ctlr, slave, unit, sc);
35546286Smckusick 
35646286Smckusick 	scsi_delay(0);
35746286Smckusick 	/* XXX if we have a tape, we must up the delays in the HA driver */
35846286Smckusick 	if (!havest) {
35946286Smckusick 		havest = 1;
36046286Smckusick 		scsi_delay(20000);
36146286Smckusick 	}
36246286Smckusick 	return(st_inqbuf.inqbuf.type);
36346286Smckusick failed:
36446286Smckusick 	scsi_delay(0);
36546286Smckusick 	return(-1);
36646286Smckusick }
36746286Smckusick 
36849132Skarels stopen(dev, flag, type, p)
36946286Smckusick 	dev_t dev;
37049132Skarels 	int flag, type;
37149132Skarels 	struct proc *p;
37246286Smckusick {
37346286Smckusick 	register struct st_softc *sc = &st_softc[UNIT(dev)];
37446286Smckusick 	register struct st_xsense *xsense;
37546286Smckusick 	register int count;
37646286Smckusick 	register int stat;
37746286Smckusick 	int ctlr, slave, unit;
37846286Smckusick 	struct mode_select_data msd;
37946286Smckusick 	struct mode_sense mode;
38046286Smckusick 	int modlen;
38151141Skarels 	int error;
38246286Smckusick 	static struct scsi_fmt_cdb modsel = {
38346286Smckusick 		6,
38446286Smckusick 		CMD_MODE_SELECT, 0, 0, 0, sizeof(msd), 0
38546286Smckusick 	};
38646286Smckusick 	static struct scsi_fmt_cdb unitready = {
38746286Smckusick 		6,
38846286Smckusick 		CMD_TEST_UNIT_READY, 0, 0, 0, 0, 0
38946286Smckusick 	};
39046286Smckusick 	static struct scsi_fmt_cdb modsense = {
39146286Smckusick 		6,
39246286Smckusick 		CMD_MODE_SENSE, 0, 0, 0, sizeof(mode), 0
39346286Smckusick 	};
39446286Smckusick 
39546286Smckusick 	ctlr = sc->sc_dq.dq_ctlr;
39646286Smckusick 	slave = sc->sc_dq.dq_slave;
39746286Smckusick 	unit = sc->sc_punit;
39846286Smckusick 	xsense = &st_xsense[UNIT(dev)];
39946286Smckusick 
40046286Smckusick 	if (UNIT(dev) > NST || (sc->sc_flags & STF_ALIVE) == 0)
40146286Smckusick 		return(ENXIO);
40246286Smckusick 	if (sc->sc_flags & STF_OPEN)
40346286Smckusick 		return(EBUSY);
40446286Smckusick 
40546286Smckusick 	/* do a mode sense to get current */
40646286Smckusick 	modlen = sc->sc_datalen[CMD_MODE_SENSE];
40746286Smckusick 	modsense.cdb[4] = modlen;
40846286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &modsense,
40946286Smckusick 				  (u_char *)&mode, modlen, B_READ);
41046286Smckusick 
41146286Smckusick 	/* do a mode sense to get current */
41246286Smckusick 	modlen = sc->sc_datalen[CMD_MODE_SENSE];
41346286Smckusick 	modsense.cdb[4] = modlen;
41446286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &modsense,
41546286Smckusick 				  (u_char *)&mode, modlen, B_READ);
41646286Smckusick 
41746286Smckusick 	/* set record length */
41846286Smckusick 	switch (sc->sc_tapeid) {
41946286Smckusick 	case MT_ISAR:
42046286Smckusick 		sc->sc_blklen = 512;
42146286Smckusick 		break;
42246286Smckusick 	case MT_ISEXABYTE:
42346286Smckusick 		if (minor(dev) & STDEV_FIXEDBLK)
42446286Smckusick 			sc->sc_blklen = 0x400;
42546286Smckusick 		else
42646286Smckusick 			sc->sc_blklen = st_exblklen;
42746286Smckusick 		break;
42846286Smckusick 	case MT_ISHPDAT:
42946286Smckusick 		sc->sc_blklen = 512;
43046286Smckusick 		break;
43146286Smckusick 	case MT_ISVIPER1:
43246286Smckusick 		sc->sc_blklen = 512;
43346286Smckusick 		break;
43446286Smckusick 	case MT_ISPYTHON:
43546286Smckusick 		sc->sc_blklen = 512;
43646286Smckusick 		break;
43751141Skarels 	case MT_ISMFOUR:
43851141Skarels 		sc->sc_blklen = 0;
43951141Skarels 		break;
44046286Smckusick 	default:
44146286Smckusick 		if ((mode.md.blklen2 << 16 |
44246286Smckusick 		     mode.md.blklen1 << 8 |
44346286Smckusick 		     mode.md.blklen0) != 0)
44446286Smckusick 			sc->sc_blklen = mode.md.blklen2 << 16 |
44546286Smckusick 					mode.md.blklen1 << 8 |
44646286Smckusick 					mode.md.blklen0;
44746286Smckusick 		else
44846286Smckusick 			sc->sc_blklen = 512;
44946286Smckusick 	}
45046286Smckusick 
45146286Smckusick 	/* setup for mode select */
45246286Smckusick 	msd.rsvd1 = 0;
45346286Smckusick 	msd.rsvd2 = 0;
45446286Smckusick 	msd.rsvd3 = 0;
45546286Smckusick 	msd.buff = 1;
45646286Smckusick 	msd.speed = 0;
45746286Smckusick 	msd.blkdeslen = 0x08;
45846286Smckusick 	msd.density = 0;
45946286Smckusick 	msd.blks2 = 0;
46046286Smckusick 	msd.blks1 = 0;
46146286Smckusick 	msd.blks0 = 0;
46246286Smckusick 	msd.rsvd4 = 0;
46346286Smckusick 	msd.blklen2 = (sc->sc_blklen >> 16) & 0xff;
46446286Smckusick 	msd.blklen1 = (sc->sc_blklen >> 8) & 0xff;
46546286Smckusick 	msd.blklen0 = sc->sc_blklen & 0xff;
46646286Smckusick 
46751141Skarels 	/*
46851141Skarels 	 * Do we have any density problems?
46951141Skarels 	 */
47051141Skarels 
47146286Smckusick 	switch (sc->sc_tapeid) {
47246286Smckusick 	case MT_ISAR:
47346286Smckusick 		if (minor(dev) & STDEV_HIDENSITY)
47446286Smckusick 			msd.density = 0x5;
47546286Smckusick 		else {
47646286Smckusick 			if (flag & FWRITE) {
47746286Smckusick 				uprintf("Can only write QIC-24\n");
47846286Smckusick 				return(EIO);
47946286Smckusick 			}
48046286Smckusick 			msd.density = 0x4;
48146286Smckusick 		}
48246286Smckusick 		break;
48346286Smckusick 	case MT_ISEXABYTE:
48446286Smckusick 		if (minor(dev) & STDEV_HIDENSITY)
48546286Smckusick 			uprintf("EXB-8200 density support only\n");
48646286Smckusick 		msd.vupb = (u_char)st_exvup;
48746286Smckusick 		msd.rsvd5 = 0;
48846286Smckusick 		msd.p5 = 0;
48946286Smckusick 		msd.motionthres = (u_char)st_exmotthr;
49046286Smckusick 		msd.reconthres = (u_char)st_exreconthr;
49146286Smckusick 		msd.gapthres = (u_char)st_exgapthr;
49246286Smckusick 		break;
49346286Smckusick 	case MT_ISHPDAT:
49446286Smckusick 	case MT_ISVIPER1:
49546286Smckusick 	case MT_ISPYTHON:
49646286Smckusick 		if (minor(dev) & STDEV_HIDENSITY)
49746286Smckusick 			uprintf("Only one density supported\n");
49846286Smckusick 		break;
49953020Smarc 	case MT_ISMFOUR:
50053020Smarc 		break;		/* XXX could do density select? */
50146286Smckusick 	default:
50246286Smckusick 		uprintf("Unsupported drive\n");
50346286Smckusick 		return(EIO);
50446286Smckusick 	}
50546286Smckusick 
50646286Smckusick 	modlen = sc->sc_datalen[CMD_MODE_SELECT];
50746286Smckusick 	modsel.cdb[4] = modlen;
50846286Smckusick 
50946286Smckusick 	/* mode select */
51046286Smckusick 	count = 0;
51146286Smckusick retryselect:
51246286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &modsel,
51346286Smckusick 				  (u_char *)&msd, modlen, B_WRITE);
51446286Smckusick 	/*
51546286Smckusick 	 * First command after power cycle, bus reset or tape change
51646286Smckusick 	 * will error. Try command again
51746286Smckusick 	 */
51846286Smckusick 	if (stat == STS_CHECKCOND) {
51946286Smckusick 		sc->sc_filepos = 0;
52046286Smckusick 		stxsense(ctlr, slave, unit, sc);
52146286Smckusick 		stat = scsi_immed_command(ctlr, slave, unit, &modsel,
52246286Smckusick 					  (u_char *)&msd, modlen, B_WRITE);
52346286Smckusick #ifdef DEBUG
52446286Smckusick 		if (stat && (st_debug & ST_OPEN))
52546286Smckusick 			printf("stopen: stat on mode select 0x%x second try\n", stat);
52646286Smckusick #endif
52746286Smckusick 		if (stat == STS_CHECKCOND) {
52846286Smckusick 			stxsense(ctlr, slave, unit, sc);
52946286Smckusick 			prtkey(UNIT(dev), sc);
53046286Smckusick 		}
53146286Smckusick 		if (stat)
53246286Smckusick 			return(EIO);
53346286Smckusick 	}
53446286Smckusick 	if (stat == -1 || stat == STS_BUSY) {
53546286Smckusick 		/*
53646286Smckusick 		 * XXX it might just be that the bus is busy because
53746286Smckusick 		 * another tape is doing a command. This would change
53846286Smckusick 		 * with connect/disconnect, ie. the other drive would
53946286Smckusick 		 * not hold onto the bus.
54046286Smckusick 		 *
54146286Smckusick 		 * Sleep on lbolt for up to 20 minutes (max time to FSF
54246286Smckusick 		 * an exabyte to EOT: 16:xx minutes)
54346286Smckusick 		 */
54446286Smckusick 		if (++count > 60*20) {
54546286Smckusick 			uprintf("SCSI bus timeout\n");
54646286Smckusick 			return(EBUSY);
54746286Smckusick 		}
54851141Skarels 		if (error = tsleep((caddr_t)&lbolt, PZERO | PCATCH,
54951141Skarels 		    "st_scsiwait", 0))
55051141Skarels 			return (error);
55146286Smckusick 		goto retryselect;
55246286Smckusick 	}
55346286Smckusick 
55446286Smckusick 	/* drive ready ? */
55546286Smckusick 	stat = scsi_test_unit_rdy(ctlr, slave, unit);
55646286Smckusick 
55746286Smckusick 	if (stat == STS_CHECKCOND) {
55846286Smckusick 		stxsense(ctlr, slave, unit, sc);
55946286Smckusick 		switch (sc->sc_tapeid) {
56046286Smckusick 		case MT_ISEXABYTE:
56146286Smckusick 			if ((xsense->sc_xsense.key & XSK_NOTRDY) &&
56246286Smckusick 			    xsense->exb_xsense.tnp)
56346286Smckusick 				uprintf("no cartridge\n");
56446286Smckusick 			else if (xsense->sc_xsense.key & XSK_NOTRDY)
56546286Smckusick 				uprintf("cartridge not loaded\n");
56646286Smckusick 			else if (xsense->sc_xsense.key & XSK_UNTATTEN) {
56746286Smckusick 				uprintf("new cart/power interrupt\n");
56846286Smckusick 				stat = 0;
56946286Smckusick 			} else if ((xsense->sc_xsense.key & XSK_UNTATTEN) &&
57046286Smckusick 				   xsense->exb_xsense.tnp)
57146286Smckusick 				uprintf("cartridge unloading\n");
57246286Smckusick 			else
57346286Smckusick 				prtkey(UNIT(dev), sc);
57446286Smckusick 			break;
57551141Skarels 		case MT_ISMFOUR:
57646286Smckusick 		case MT_ISAR:
57746286Smckusick 			if (xsense->sc_xsense.key & XSK_UNTATTEN)
57846286Smckusick 				stat = scsi_test_unit_rdy(ctlr, slave, unit);
57946286Smckusick 			if (stat == STS_CHECKCOND) {
58046286Smckusick 				stxsense(ctlr, slave, unit, sc);
58146286Smckusick 				if (xsense->sc_xsense.key)
58246286Smckusick 					prtkey(UNIT(dev), sc);
58346286Smckusick 			} else {
58446286Smckusick 				sc->sc_filepos = 0; /* new tape */
58546286Smckusick 				stat = 0;
58646286Smckusick 			}
58746286Smckusick 			break;
58846286Smckusick 		case MT_ISHPDAT:
58946286Smckusick 		case MT_ISVIPER1:
59046286Smckusick 		case MT_ISPYTHON:
59146286Smckusick 			if (xsense->sc_xsense.key & XSK_UNTATTEN)
59246286Smckusick 				stat = scsi_test_unit_rdy(ctlr, slave, unit);
59346286Smckusick 			if (stat == STS_CHECKCOND) {
59446286Smckusick 				stxsense(ctlr, slave, unit, sc);
59546286Smckusick 				if (xsense->sc_xsense.key)
59646286Smckusick 					prtkey(UNIT(dev), sc);
59746286Smckusick 			}
59846286Smckusick 			break;
59946286Smckusick 		default:
60046286Smckusick 			uprintf("st%d: not ready\n", UNIT(dev));
60146286Smckusick 			prtkey(UNIT(dev), sc);
60246286Smckusick 			break;
60346286Smckusick 		}
60446286Smckusick 	}
60546286Smckusick 	if (stat)
60646286Smckusick 		return(EIO);
60746286Smckusick 
60846286Smckusick 	/* mode sense */
60946286Smckusick 	modlen = sc->sc_datalen[CMD_MODE_SENSE];
61046286Smckusick 	modsense.cdb[4] = modlen;
61146286Smckusick 	stat = scsi_immed_command(ctlr, slave, unit, &modsense,
61246286Smckusick 				  (u_char *)&mode, modlen, B_READ);
61346286Smckusick #ifdef DEBUG
61446286Smckusick 	if (st_debug & ST_OPENSTAT)
61546286Smckusick 		prtmodstat(&mode);
61646286Smckusick #endif
61746286Smckusick 
61846286Smckusick 	if (stat == STS_CHECKCOND) {
61946286Smckusick 		stxsense(ctlr, slave, unit, sc);
62046286Smckusick #ifdef DEBUG
62146286Smckusick 		if (st_debug & ST_OPEN)
62246286Smckusick 			dumpxsense(xsense);
62346286Smckusick #endif
62446286Smckusick 	}
62546286Smckusick 	if (stat)
62646286Smckusick 		return(EIO);
62746286Smckusick 
62846286Smckusick 	if ((flag & FWRITE) && mode.md.wp) {
62946286Smckusick 		uprintf("st:%d write protected\n", UNIT(dev));
63046286Smckusick 		return(EACCES);
63146286Smckusick 	}
63246286Smckusick 
63349132Skarels 	sc->sc_ctty = tprintf_open(p);
63446286Smckusick 	/* save total number of blocks on tape */
63546286Smckusick 	sc->sc_numblks = mode.md.numblk2 << 16 |
63646286Smckusick 			 mode.md.numblk1 << 8 |
63746286Smckusick 			 mode.md.numblk0;
63846286Smckusick 
63946286Smckusick 	if (xsense->sc_xsense.eom && !(sc->sc_flags & STF_LEOT))
64046286Smckusick 		sc->sc_filepos = 0;
64146286Smckusick #ifdef DEBUG
64246286Smckusick 	if (st_debug & ST_FMKS)
64346286Smckusick 		printf("st%d: open filepos = %d\n", UNIT(dev), sc->sc_filepos);
64446286Smckusick #endif
64546286Smckusick 
64646286Smckusick 	sc->sc_flags |= (STF_OPEN);
64746286Smckusick 	if (flag & FWRITE)
64846286Smckusick 		sc->sc_flags |= STF_WMODE;
64946286Smckusick 	sc->sc_flags &= ~STF_MOVED;
65046286Smckusick 
65146286Smckusick #ifdef TTI
65246286Smckusick 	/* make stats available, also lit up TTi display */
65346286Smckusick 	sc->sc_tticntdwn = 100;
65446286Smckusick #endif
65546286Smckusick 	stxsense(ctlr, slave, unit, sc);
65646286Smckusick 
65746286Smckusick 	return(0);
65846286Smckusick }
65946286Smckusick 
66046286Smckusick /*ARGSUSED*/
66146286Smckusick stclose(dev, flag)
66246286Smckusick 	dev_t dev;
66346286Smckusick 	int flag;
66446286Smckusick {
66546286Smckusick 	register struct st_softc *sc = &st_softc[UNIT(dev)];
66646286Smckusick 	register int hit = 0;
66746286Smckusick 
66846286Smckusick 	if ((sc->sc_flags & (STF_WMODE|STF_WRTTN)) == (STF_WMODE|STF_WRTTN)) {
66946286Smckusick 		/*
67046286Smckusick 		 * Cartridge tapes don't do double EOFs on EOT.
67153020Smarc 		 * We assume that variable-block devices use double EOF.
67246286Smckusick 		 */
67346286Smckusick 		stcommand(dev, MTWEOF, 1);
67453020Smarc 		if (sc->sc_blklen == 0) {
67553020Smarc 			stcommand(dev, MTWEOF, 1);
67653020Smarc 			stcommand(dev, MTBSR, 1);
67753020Smarc 		}
67846286Smckusick 		hit++;
67946286Smckusick 	}
68046286Smckusick 	if ((minor(dev) & STDEV_NOREWIND) == 0) {
68146286Smckusick 		stcommand(dev, MTREW, 1);
68246286Smckusick 		hit++;
68346286Smckusick 	}
68446286Smckusick #ifdef NOTDEF
68546286Smckusick 	/* wait until more stable before trying [XXX Needed ?] */
68646286Smckusick 	if (!hit && (sc->sc_flags & SFT_WMODE))
68746286Smckusick 		/* force out any any bufferd write data */
68846286Smckusick 		stcommand(dev, MTFSR, 0);
68946286Smckusick #endif
69046286Smckusick 	/* make stats available */
69146286Smckusick 	stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave, sc->sc_punit, sc);
69246286Smckusick 
69346286Smckusick 	sc->sc_flags &= ~(STF_OPEN|STF_WMODE|STF_WRTTN);
69449132Skarels 	tprintf_close(sc->sc_ctty);
69546286Smckusick 	return(0);	/* XXX */
69646286Smckusick }
69746286Smckusick 
69846286Smckusick ststrategy(bp)
69946286Smckusick 	register struct buf *bp;
70046286Smckusick {
70146286Smckusick 	struct buf *dp;
70246286Smckusick 	int unit, s;
70346286Smckusick 
70446286Smckusick 	unit = UNIT(bp->b_dev);
70546286Smckusick 	dp = &sttab[unit];
70656389Smckusick 	bp->b_actf = NULL;
70746286Smckusick 	s = splbio();
70856389Smckusick 	bp->b_actb = dp->b_actb;
70956389Smckusick 	*dp->b_actb = bp;
71056389Smckusick 	dp->b_actb = &bp->b_actf;
71146286Smckusick 	if (dp->b_active == 0) {
71246286Smckusick 		dp->b_active = 1;
71346286Smckusick 		stustart(unit);
71446286Smckusick 	}
71546286Smckusick 	splx(s);
71646286Smckusick }
71746286Smckusick 
71846286Smckusick stustart(unit)
71946286Smckusick 	int unit;
72046286Smckusick {
72146286Smckusick 	if (scsireq(&st_softc[unit].sc_dq))
72246286Smckusick 		ststart(unit);
72346286Smckusick }
72446286Smckusick 
72546286Smckusick ststart(unit)
72646286Smckusick 	int unit;
72746286Smckusick {
72846286Smckusick 	struct hp_device *hp = st_softc[unit].sc_hd;
72946286Smckusick 
73046286Smckusick 	if (scsiustart(hp->hp_ctlr))
73146286Smckusick 		stgo(unit);
73246286Smckusick }
73346286Smckusick 
73446286Smckusick stgo(unit)
73546286Smckusick 	int unit;
73646286Smckusick {
73746286Smckusick 	register struct st_softc *sc = &st_softc[unit];
73846286Smckusick 	register struct scsi_fmt_cdb *cmd;
73946286Smckusick 	register struct buf *bp = sttab[unit].b_actf;
74046286Smckusick 	struct hp_device *hp = sc->sc_hd;
74146286Smckusick 	int pad, stat;
74246286Smckusick 	long nblks;
74346286Smckusick 
74446286Smckusick 	if (sc->sc_flags & STF_CMD) {
74546286Smckusick 		cmd = &stcmd[unit];
74646286Smckusick 		pad = 0;
74746286Smckusick 	} else {
74846286Smckusick 		cmd = bp->b_flags & B_READ ? &st_read_cmd : &st_write_cmd;
74946286Smckusick 		if (sc->sc_blklen)
75046286Smckusick 			cmd->cdb[1] |= 0x01; /* fixed mode */
75146286Smckusick 		else
75246286Smckusick 			cmd->cdb[1] &= 0xfe;
75346286Smckusick 		if (bp->b_flags & B_READ)
75446286Smckusick 			sc->sc_flags &= ~STF_WRTTN;
75546286Smckusick 		else
75646286Smckusick 			sc->sc_flags |= STF_WRTTN;
75746286Smckusick 
75846286Smckusick 		if (sc->sc_blklen) { /* fixed mode */
75946286Smckusick 			nblks = bp->b_bcount / sc->sc_blklen;
76046286Smckusick 			if (bp->b_bcount % sc->sc_blklen) {
76146286Smckusick 				tprintf(sc->sc_ctty,
76246286Smckusick 					"st%d: I/O not block aligned %d/%ld\n",
76346286Smckusick 					unit, sc->sc_blklen, bp->b_bcount);
76446286Smckusick 				cmd->cdb[1] &= 0xfe; /* force error */
76546286Smckusick 			}
76646286Smckusick 		} else	/* variable len */
76746286Smckusick 			nblks = bp->b_bcount;
76846286Smckusick 
76946286Smckusick 		*(u_char *)(&cmd->cdb[2]) = (u_char) (nblks >> 16);
77046286Smckusick 		*(u_char *)(&cmd->cdb[3]) = (u_char) (nblks >> 8);
77146286Smckusick 		*(u_char *)(&cmd->cdb[4]) = (u_char) nblks;
77246286Smckusick 		/*
77346286Smckusick 		 * Always Zero. We are either writing in variable
77446286Smckusick 		 * length mode we are writing in fixed block mode,
77546286Smckusick 		 * or we are going to do odd length IO and are not
77646286Smckusick 		 * going to use DMA.
77746286Smckusick 		 */
77846286Smckusick 		pad = 0;
77946286Smckusick 	}
78046286Smckusick 
78146286Smckusick #ifdef DEBUG
78246286Smckusick 	if (st_debug & ST_GO)
78346286Smckusick 		printf("stgo: cmd len %d [0]0x%x [1]0x%x [2]0x%x [3]0x%x [4]0x%x [5]0x%x\n",
78446286Smckusick 		       cmd->len, cmd->cdb[0], cmd->cdb[1], cmd->cdb[2],
78546286Smckusick 		       cmd->cdb[3], cmd->cdb[4], cmd->cdb[5]);
78646286Smckusick #endif
78746286Smckusick 
78846286Smckusick 	sc->sc_flags |= STF_MOVED;
78946286Smckusick 	if (bp->b_bcount & 1) {
79046286Smckusick #ifdef DEBUG
79146286Smckusick 		if (st_debug & ST_ODDIO)
79246286Smckusick 			printf("stgo%d: odd count %d using manual transfer\n",
79346286Smckusick 			       unit, bp->b_bcount);
79446286Smckusick #endif
79546286Smckusick 		stat = scsi_tt_oddio(hp->hp_ctlr, hp->hp_slave, sc->sc_punit,
79646286Smckusick 				     bp->b_un.b_addr, bp->b_bcount,
79746286Smckusick 				     bp->b_flags, 1);
79846286Smckusick 		if (stat == 0) {
79946286Smckusick 			bp->b_resid = 0;
80046286Smckusick 			stfinish(unit, sc, bp);
80146286Smckusick 		}
80246286Smckusick 	} else
80346286Smckusick 		stat = scsigo(hp->hp_ctlr, hp->hp_slave, sc->sc_punit,
80446286Smckusick 			      bp, cmd, pad);
80546286Smckusick 	if (stat) {
80646286Smckusick 		bp->b_error = EIO;
80746286Smckusick 		bp->b_flags |= B_ERROR;
80846286Smckusick 		stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave,
80946286Smckusick 			 sc->sc_punit, sc);
81046286Smckusick 		sterror(unit, sc, stat);
81146286Smckusick 		stfinish(unit, sc, bp);
81246286Smckusick 	}
81346286Smckusick }
81446286Smckusick 
81546286Smckusick stfinish(unit, sc, bp)
81646286Smckusick 	int unit;
81746286Smckusick 	struct st_softc *sc;
81846286Smckusick 	struct buf *bp;
81946286Smckusick {
82056389Smckusick 	register struct buf *dp;
82156389Smckusick 
82246286Smckusick 	sttab[unit].b_errcnt = 0;
82356389Smckusick 	if (dp = bp->b_actf)
82456389Smckusick 		dp->b_actb = bp->b_actb;
82556389Smckusick 	else
82656389Smckusick 		sttab[unit].b_actb = bp->b_actb;
82756389Smckusick 	*bp->b_actb = dp;
82846286Smckusick 	iodone(bp);
82946286Smckusick 	scsifree(&sc->sc_dq);
83046286Smckusick 	if (sttab[unit].b_actf)
83146286Smckusick 		stustart(unit);
83246286Smckusick 	else
83346286Smckusick 		sttab[unit].b_active = 0;
83446286Smckusick }
83546286Smckusick 
83646286Smckusick stread(dev, uio)
83746286Smckusick 	dev_t dev;
83846286Smckusick 	struct uio *uio;
83946286Smckusick {
84046286Smckusick 	int unit = UNIT(dev);
84146286Smckusick 
84246286Smckusick 	return(physio(ststrategy, &stbuf[unit], dev, B_READ, minphys, uio));
84346286Smckusick }
84446286Smckusick 
84546286Smckusick stwrite(dev, uio)
84646286Smckusick 	dev_t dev;
84746286Smckusick 	struct uio *uio;
84846286Smckusick {
84946286Smckusick 	int unit = UNIT(dev);
85046286Smckusick 
85146286Smckusick 	return(physio(ststrategy, &stbuf[unit], dev, B_WRITE, minphys, uio));
85246286Smckusick }
85346286Smckusick 
85446286Smckusick /*ARGSUSED*/
85546286Smckusick stdump(dev)
85646286Smckusick 	dev_t dev;
85746286Smckusick {
85846286Smckusick 	return(ENXIO);
85946286Smckusick }
86046286Smckusick 
86146286Smckusick /*ARGSUSED*/
86246286Smckusick stioctl(dev, cmd, data, flag)
86346286Smckusick 	dev_t dev;
86446286Smckusick 	int cmd;
86546286Smckusick 	caddr_t data;
86646286Smckusick 	int flag;
86746286Smckusick {
86846286Smckusick 	register struct st_softc *sc = &st_softc[UNIT(dev)];
86946286Smckusick 	register int cnt;
87046286Smckusick 	register struct mtget *mtget;
87146286Smckusick 	register struct st_xsense *xp = &st_xsense[UNIT(dev)];
87246286Smckusick 	register struct mtop *op;
87346286Smckusick 	long resid;
87446286Smckusick 
87546286Smckusick 	switch (cmd) {
87646286Smckusick 
87746286Smckusick 	/* tape operation */
87846286Smckusick 	case MTIOCTOP:
87946286Smckusick 		op = (struct mtop *)data;
88046286Smckusick 		switch (op->mt_op) {
88146286Smckusick 
88246286Smckusick 		case MTBSR:
88346286Smckusick 		case MTFSR:
88446286Smckusick 			if (sc->sc_tapeid == MT_ISAR)
88546286Smckusick 				return(ENXIO);
88646286Smckusick 		case MTWEOF:
88746286Smckusick 		case MTFSF:
88846286Smckusick 		case MTBSF:
88946286Smckusick 			cnt = (int)op->mt_count;
89046286Smckusick 			break;
89146286Smckusick 
89246286Smckusick 		case MTREW:
89346286Smckusick 		case MTOFFL:
89446286Smckusick 			cnt = 1;
89546286Smckusick 			break;
89646286Smckusick 
89746286Smckusick 		case MTNOP:
89846286Smckusick 			return(0);
89946286Smckusick 		default:
90046286Smckusick 			return(EINVAL);
90146286Smckusick 		}
90246286Smckusick 		if (cnt <= 0)
90346286Smckusick 			return(EINVAL);
90446286Smckusick 		stcommand(dev, (u_int)op->mt_op, cnt);
90546286Smckusick 		break;
90646286Smckusick 
90746286Smckusick 	/* drive status */
90846286Smckusick 	case MTIOCGET:
90946286Smckusick 		mtget = (struct mtget *)data;
91046286Smckusick 		stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave,
91146286Smckusick 			 sc->sc_punit, sc);
91246286Smckusick 		mtget->mt_type = sc->sc_tapeid;
91346286Smckusick 		mtget->mt_dsreg = 0;
91446286Smckusick 		mtget->mt_erreg = ((xp->sc_xsense.valid << 15) |
91546286Smckusick 				   (xp->sc_xsense.filemark << 14) |
91646286Smckusick 				   (xp->sc_xsense.eom << 13) |
91746286Smckusick 				   (xp->sc_xsense.ili << 12) |
91846286Smckusick 				   (xp->sc_xsense.key << 8));
91946286Smckusick 
92046286Smckusick 		if (sc->sc_tapeid == MT_ISEXABYTE) {
92146286Smckusick 			mtget->mt_dsreg = sc->sc_flags;
92246286Smckusick 			resid = (xp->exb_xsense.tplft2 << 16 |
92346286Smckusick 				 xp->exb_xsense.tplft1 << 8 |
92446286Smckusick 				 xp->exb_xsense.tplft0);
92546286Smckusick 			mtget->mt_resid = resid / 1000;
92646286Smckusick 			mtget->mt_erreg |= (((xp->exb_xsense.rwerrcnt2 << 16 |
92746286Smckusick 					      xp->exb_xsense.rwerrcnt1 << 8 |
92846286Smckusick 					      xp->exb_xsense.rwerrcnt0) * 100) /
92946286Smckusick 					    (sc->sc_numblks - resid)) & 0xff;
93046286Smckusick 		} else if (xp->sc_xsense.valid) {
93146286Smckusick 			resid = ((xp->sc_xsense.info1 << 24) |
93246286Smckusick 				 (xp->sc_xsense.info2 << 16) |
93346286Smckusick 				 (xp->sc_xsense.info3 << 8) |
93446286Smckusick 				 (xp->sc_xsense.info4));
93546286Smckusick 			if (sc->sc_blklen) /* if fixed mode */
93646286Smckusick 				resid *= sc->sc_blklen;
93746286Smckusick 			mtget->mt_resid = resid;
93846286Smckusick 		} else
93946286Smckusick 			mtget->mt_resid = 0;
94046286Smckusick 		break;
94146286Smckusick 
94246286Smckusick 	default:
94346286Smckusick 		return(ENXIO);
94446286Smckusick 	}
94546286Smckusick 	return(0);
94646286Smckusick }
94746286Smckusick 
94846286Smckusick stintr(unit, stat)
94946286Smckusick 	int unit, stat;
95046286Smckusick {
95146286Smckusick 	register struct st_softc *sc = &st_softc[unit];
95246286Smckusick 	register struct st_xsense *xp = &st_xsense[unit];
95346286Smckusick 	register struct buf *bp = sttab[unit].b_actf;
95446286Smckusick 	struct hp_device *hp = sc->sc_hd;
95546286Smckusick 
95646286Smckusick #ifdef DEBUG
95746286Smckusick 	if (bp == NULL) {
95846286Smckusick 		printf("st%d: bp == NULL\n", unit);
95946286Smckusick 		return;
96046286Smckusick 	}
96146286Smckusick #endif
96246286Smckusick 	switch (stat) {
96346286Smckusick 	/* scsi command completed ok */
96446286Smckusick 	case 0:
96546286Smckusick 		bp->b_resid = 0;
96646286Smckusick 		break;
96746286Smckusick 
96846286Smckusick 	/* more status */
96946286Smckusick 	case STS_CHECKCOND:
97046286Smckusick 		stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave,
97146286Smckusick 			 sc->sc_punit, sc);
97246286Smckusick 		if (xp->sc_xsense.valid) {
97346286Smckusick 			bp->b_resid = (u_long)((xp->sc_xsense.info1 << 24) |
97446286Smckusick 					      (xp->sc_xsense.info2 << 16) |
97546286Smckusick 					      (xp->sc_xsense.info3 << 8) |
97646286Smckusick 					      (xp->sc_xsense.info4));
97746286Smckusick 			if (sc->sc_blklen) /* fixed mode */
97846286Smckusick 				bp->b_resid *= sc->sc_blklen;
97946286Smckusick 		}
98046286Smckusick 		if (xp->sc_xsense.filemark) {
98146286Smckusick 			sc->sc_filepos++;
98246286Smckusick 			break;
98346286Smckusick 		}
98451141Skarels 		if (xp->sc_xsense.key != XSK_NOSENCE
98551141Skarels 		    && xp->sc_xsense.key != XSK_NOTUSED1
98651141Skarels 		    && xp->sc_xsense.key != XSK_NOTUSEDC
98751141Skarels 		    && xp->sc_xsense.key != XSK_NOTUSEDE) {
98846286Smckusick 			sterror(unit, sc, stat);
98946286Smckusick 			bp->b_flags |= B_ERROR;
99046286Smckusick 			bp->b_error = EIO;
99146286Smckusick 			break;
99246286Smckusick 		}
99346286Smckusick 		if (xp->sc_xsense.ili) {
99446286Smckusick 			/*
99546286Smckusick 			 * Fixed length blocks, an error.
99646286Smckusick 			 */
99746286Smckusick 			if (sc->sc_blklen) {
99846286Smckusick 				tprintf(sc->sc_ctty,
99946286Smckusick 					"st%d: Incorrect Length Indicator, blkcnt diff %d\n",
100046286Smckusick 					unit, sc->sc_blklen - bp->b_resid);
100146286Smckusick 				bp->b_flags |= B_ERROR;
100246286Smckusick 				bp->b_error = EIO;
100346286Smckusick 				break;
100446286Smckusick 			}
100546286Smckusick 			/*
100646286Smckusick 			 * Variable length but read more than requested,
100753020Smarc 			 * an error.  (XXX ??? wrong for 9 track?)
100846286Smckusick 			 */
100946286Smckusick 			if (bp->b_resid < 0) {
101046286Smckusick 				bp->b_resid = 0;
101146286Smckusick 				bp->b_flags |= B_ERROR;
101246286Smckusick 				bp->b_error = ENOMEM;
101346286Smckusick 				break;
101446286Smckusick 			}
101546286Smckusick 			/*
101646286Smckusick 			 * Variable length and odd, may require special
101746286Smckusick 			 * handling.
101846286Smckusick 			 */
101953020Smarc 			if (bp->b_resid & 1 && (sc->sc_tapeid != MT_ISAR)) {
102046286Smckusick 				/*
102146286Smckusick 				 * Normal behavior, treat as an error.
102246286Smckusick 				 */
102346286Smckusick 				if (!st_dmaoddretry) {
102446286Smckusick 					tprintf(sc->sc_ctty,
102546286Smckusick 						"st%d: Odd length read %d\n",
102646286Smckusick 						UNIT(bp->b_dev),
102746286Smckusick 						bp->b_bcount - bp->b_resid);
102846286Smckusick 					bp->b_error = EIO;
102946286Smckusick 					bp->b_flags |= B_ERROR;
103046286Smckusick 					break;
103146286Smckusick 				}
103246286Smckusick 				/*
103346286Smckusick 				 * Attempt to back up and re-read using oddio.
103446286Smckusick 				 */
103546286Smckusick #ifdef DEBUG
103646286Smckusick 				if (st_debug & ST_ODDIO)
103746286Smckusick 					printf("st%d: stintr odd count %d, do BSR then oddio\n",
103846286Smckusick 					       UNIT(bp->b_dev),
103946286Smckusick 					       bp->b_bcount - bp->b_resid);
104046286Smckusick #endif
104146286Smckusick 				stat = scsi_tt_oddio(hp->hp_ctlr, hp->hp_slave,
104246286Smckusick 						     sc->sc_punit, 0, -1, 0, 0);
104346286Smckusick 				if (stat == 0)
104446286Smckusick 					stat = scsi_tt_oddio(hp->hp_ctlr,
104546286Smckusick 							     hp->hp_slave,
104646286Smckusick 							     sc->sc_punit,
104746286Smckusick 							     bp->b_un.b_addr,
104846286Smckusick 							     bp->b_bcount - bp->b_resid,
104946286Smckusick 							     bp->b_flags, 0);
105046286Smckusick 				if (stat) {
105146286Smckusick 					bp->b_error = EIO;
105246286Smckusick 					bp->b_flags |= B_ERROR;
105346286Smckusick 					stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave,
105446286Smckusick 						 sc->sc_punit, sc);
105546286Smckusick 					sterror(unit, sc, stat);
105646286Smckusick 				}
105746286Smckusick 			}
105846286Smckusick 			break;
105946286Smckusick 		}
106046286Smckusick 		if (xp->sc_xsense.eom) {
106146286Smckusick 			bp->b_flags |= B_ERROR;
106246286Smckusick 			bp->b_error = ENOSPC;
106346286Smckusick 			break;
106446286Smckusick 		}
106546286Smckusick 		tprintf(sc->sc_ctty, "st%d: unknown scsi error\n", unit);
106646286Smckusick 		bp->b_flags |= B_ERROR;
106746286Smckusick 		bp->b_error = EIO;
106846286Smckusick 		break;
106946286Smckusick 
107046286Smckusick 	default:
107146286Smckusick 		printf("st%d: stintr unknown stat 0x%x\n", unit, stat);
107246286Smckusick 		break;
107346286Smckusick 	}
107446286Smckusick #ifdef DEBUG
107546286Smckusick 	if ((st_debug & ST_BRESID) && bp->b_resid != 0)
107646286Smckusick 		printf("b_resid %d b_flags 0x%x b_error 0x%x\n",
107746286Smckusick 		       bp->b_resid, bp->b_flags, bp->b_error);
107846286Smckusick #endif
107946286Smckusick 	/* asked for more filemarks then on tape */
108046286Smckusick 	if (bp->b_resid != 0 &&
108146286Smckusick 	    (sc->sc_flags & STF_CMD) && sc->sc_cmd == CMD_SPACE) {
108246286Smckusick 		sc->sc_filepos -= bp->b_resid;
108346286Smckusick 		if (sc->sc_filepos < 0)
108446286Smckusick 			sc->sc_filepos = 0;
108546286Smckusick 	}
108646286Smckusick 
108746286Smckusick #ifdef TTI
108846286Smckusick 	if (st_extti & (1<<unit) &&
108946286Smckusick 	    sc->sc_type == MT_ISEXABYTE) /* to make display lit up */
109046286Smckusick 		/*
109146286Smckusick 		 * XXX severe performance penality for this.
109246286Smckusick 		 * Try and throttle by not calling stxsense on every intr.
109346286Smckusick 		 * Mostly for TTi we, get a stxsense call in open and close.
109446286Smckusick 		 */
109546286Smckusick 		if (sc->sc_tticntdwn-- == 0) {
109646286Smckusick 			stxsense(sc->sc_dq.dq_ctlr, sc->sc_dq.dq_slave,
109746286Smckusick 				 sc->sc_punit, sc);
109846286Smckusick 			sc->sc_tticntdwn = 100;
109946286Smckusick 		}
110046286Smckusick #endif
110146286Smckusick 
110246286Smckusick 	stfinish(unit, sc, bp);
110346286Smckusick }
110446286Smckusick 
110546286Smckusick stcommand(dev, command, cnt)
110646286Smckusick 	dev_t dev;
110746286Smckusick 	u_int command;
110846286Smckusick 	int cnt;
110946286Smckusick {
111046286Smckusick 	register struct st_softc *sc = &st_softc[UNIT(dev)];
111146286Smckusick 	register struct buf *bp = &stbuf[UNIT(dev)];
111246286Smckusick 	register struct scsi_fmt_cdb *cmd = &stcmd[UNIT(dev)];
111346286Smckusick 	register cmdcnt;
111446286Smckusick 	int s;
111546286Smckusick 
111646286Smckusick 	cmd->len = 6; /* all tape commands are cdb6 */
111746286Smckusick 	cmd->cdb[1] = sc->sc_punit;
111846286Smckusick 	cmd->cdb[2] = cmd->cdb[3] = cmd->cdb[4] = cmd->cdb[5] = 0;
111946286Smckusick 	cmdcnt = 0;
112046286Smckusick 
112146286Smckusick 	/*
112246286Smckusick 	 * XXX Assumption is that everything except Archive can take
112346286Smckusick 	 * repeat count in cdb block.
112446286Smckusick 	 */
112546286Smckusick 	switch (command) {
112646286Smckusick 	case MTWEOF:
112746286Smckusick 		cmd->cdb[0] = CMD_WRITE_FILEMARK;
112846286Smckusick 		if (sc->sc_tapeid != MT_ISAR) {
112946286Smckusick 			cmdcnt = cnt;
113046286Smckusick 			cnt = 1;
113146286Smckusick 		} else
113246286Smckusick 			cmdcnt = 1;
113346286Smckusick 		*(u_char *)(&cmd->cdb[2]) = (u_char) (cmdcnt >> 16);
113446286Smckusick 		*(u_char *)(&cmd->cdb[3]) = (u_char) (cmdcnt >> 8);
113546286Smckusick 		*(u_char *)(&cmd->cdb[4]) = (u_char) cmdcnt;
113646286Smckusick 
113746286Smckusick 		if (sc->sc_tapeid == MT_ISEXABYTE &&
113846286Smckusick 		    (minor(dev) & STDEV_EXSFMK)) /* short filemarks */
113946286Smckusick 			cmd->cdb[5] |= 0x80;
114046286Smckusick 		else
114146286Smckusick 			cmd->cdb[5] &= 0x7f;
114246286Smckusick 		break;
114346286Smckusick 	case MTBSF:
114446286Smckusick 		/* Archive can't back up, will not get to BSR case */
114546286Smckusick 		if (sc->sc_tapeid == MT_ISAR) {
114646286Smckusick 			if ((sc->sc_filepos - cnt) < 0) {
114746286Smckusick 				stcommand(dev, MTREW, 1);
114846286Smckusick 				return;
114946286Smckusick 			}
115046286Smckusick 			cmdcnt = sc->sc_filepos - cnt + 1;
115146286Smckusick 			stcommand(dev, MTREW, 1);
115246286Smckusick 			stcommand(dev, MTFSF, cmdcnt);
115346286Smckusick 			return;
115446286Smckusick 		}
115546286Smckusick 	case MTBSR:
115646286Smckusick 	case MTFSR:
115746286Smckusick 	case MTFSF:
115846286Smckusick 		if (command == MTBSF || command == MTBSR)
115946286Smckusick 			cnt = cnt * (-1); /* backward move */
116046286Smckusick 		if (command == MTFSF || command == MTBSF)
116146286Smckusick 			cmd->cdb[1] |= 0x01; /* filemarks */
116246286Smckusick 		else
116346286Smckusick 			cmd->cdb[1] |= 0x00; /* logical blocks */
116446286Smckusick 		if (sc->sc_tapeid != MT_ISAR) {
116546286Smckusick 			cmdcnt = cnt;
116646286Smckusick 			cnt = 1;
116746286Smckusick 		} else
116846286Smckusick 			cmdcnt = 1;
116946286Smckusick 		*(u_char *)(&cmd->cdb[2]) = (u_char) (cmdcnt >> 16);
117046286Smckusick 		*(u_char *)(&cmd->cdb[3]) = (u_char) (cmdcnt >> 8);
117146286Smckusick 		*(u_char *)(&cmd->cdb[4]) = (u_char) cmdcnt;
117246286Smckusick 		cmd->cdb[0] = CMD_SPACE;
117346286Smckusick 		break;
117446286Smckusick 	case MTREW:
117546286Smckusick 		cmd->cdb[0] = CMD_REWIND;
117646286Smckusick 		sc->sc_filepos = 0;
117746286Smckusick 		break;
117846286Smckusick 	case MTOFFL:
117946286Smckusick 		cmd->cdb[0] = CMD_LOADUNLOAD;
118046286Smckusick 		sc->sc_filepos = 0;
118146286Smckusick 		break;
118246286Smckusick 	default:
118346286Smckusick 		printf("st%d: stcommand bad command 0x%x\n",
118446286Smckusick 		       UNIT(dev), command);
118546286Smckusick 	}
118646286Smckusick 
118746286Smckusick 	sc->sc_flags |= STF_CMD;
118846286Smckusick 	sc->sc_cmd = cmd->cdb[0];
118946286Smckusick 
119046286Smckusick 	sc->sc_bp = bp;
119146286Smckusick again:
119246286Smckusick #ifdef DEBUG
119346286Smckusick 	if (st_debug & ST_FMKS)
119446286Smckusick 		printf("st%d: stcommand filepos %d cmdcnt %d cnt %d\n",
119546286Smckusick 		       UNIT(dev), sc->sc_filepos, cmdcnt, cnt);
119646286Smckusick #endif
119746286Smckusick 	s = splbio();
119846286Smckusick 	while (bp->b_flags & B_BUSY) {
119946286Smckusick 		if (bp->b_flags & B_DONE)
120046286Smckusick 			break;
120146286Smckusick 		bp->b_flags |= B_WANTED;
120246286Smckusick 		sleep((caddr_t)bp, PRIBIO);
120346286Smckusick 	}
120446286Smckusick 	bp->b_flags = B_BUSY|B_READ;
120546286Smckusick 	splx(s);
120646286Smckusick 	bp->b_dev = dev;
120746286Smckusick 	bp->b_bcount = 0;
120846286Smckusick 	bp->b_resid = 0;
120946286Smckusick 	bp->b_blkno = 0;
121046286Smckusick 	bp->b_error = 0;
121146286Smckusick 	ststrategy(bp);
121246286Smckusick 	iowait(bp);
121346286Smckusick 	if (bp->b_flags & B_WANTED)
121446286Smckusick 		wakeup((caddr_t)bp);
121546286Smckusick 	bp->b_flags &= B_ERROR;
121646286Smckusick 
121746286Smckusick 	if (command == MTWEOF || command == MTFSF || command == MTBSF)
121846286Smckusick 		sc->sc_filepos += cmdcnt;
121946286Smckusick 
122046286Smckusick 	if (--cnt > 0)
122146286Smckusick 		goto again;
122246286Smckusick 
122346286Smckusick 	sc->sc_flags |= STF_MOVED;
122446286Smckusick 	sc->sc_flags &= ~(STF_CMD|STF_WRTTN);
122546286Smckusick }
122646286Smckusick 
122746286Smckusick sterror(unit, sc, stat)
122846286Smckusick 	int unit, stat;
122946286Smckusick 	struct st_softc *sc;
123046286Smckusick {
123146286Smckusick 	/* stxsense must have been called before sterror() */
123246286Smckusick 	if (stat & STS_CHECKCOND)
123346286Smckusick 		prtkey(unit, sc);
123446286Smckusick 	else if (stat)
123546286Smckusick 		tprintf(sc->sc_ctty,
123646286Smckusick 			"st%d: bad scsi status 0x%x\n", unit, stat);
123746286Smckusick 
123846286Smckusick 	if ((sc->sc_flags & STF_CMD) && sc->sc_cmd == CMD_SPACE) /* fsf */
123946286Smckusick 		sc->sc_filepos--;
124046286Smckusick }
124146286Smckusick 
124246286Smckusick stxsense(ctlr, slave, unit, sc)
124346286Smckusick 	int ctlr, slave, unit;
124446286Smckusick 	struct st_softc *sc;
124546286Smckusick {
124646286Smckusick 	u_char *sensebuf;
124746286Smckusick 	unsigned len;
124846286Smckusick 
124946286Smckusick 	sensebuf = (u_char *)&st_xsense[sc->sc_dq.dq_unit];
125046286Smckusick 	len = sc->sc_datalen[CMD_REQUEST_SENSE];
125146286Smckusick 	scsi_request_sense(ctlr, slave, unit, sensebuf, len);
125246286Smckusick }
125346286Smckusick 
125446286Smckusick prtkey(unit, sc)
125546286Smckusick 	int unit;
125646286Smckusick 	struct st_softc *sc;
125746286Smckusick {
125846286Smckusick 	register struct st_xsense *xp = &st_xsense[unit];
125946286Smckusick 
126046286Smckusick 	switch (xp->sc_xsense.key) {
126146286Smckusick 	case XSK_NOSENCE:
126246286Smckusick 		break;
126346286Smckusick 	case XSK_NOTUSED1:
126446286Smckusick 	case XSK_NOTUSEDC:
126546286Smckusick 	case XSK_NOTUSEDE:
126646286Smckusick 		break;
126746286Smckusick 	case XSK_REVERVED:
126846286Smckusick 		tprintf(sc->sc_ctty, "st%d: Reserved sense key 0x%x\n",
126946286Smckusick 			unit, xp->sc_xsense.key);
127046286Smckusick 		break;
127146286Smckusick 	case XSK_NOTRDY:
127246286Smckusick 		tprintf(sc->sc_ctty, "st%d: NOT READY\n", unit);
127346286Smckusick 		break;
127446286Smckusick 	case XSK_MEDERR:
127546286Smckusick 		tprintf(sc->sc_ctty, "st%d: MEDIUM ERROR\n", unit);
127646286Smckusick 		break;
127746286Smckusick 	case XSK_HRDWERR:
127846286Smckusick 		tprintf(sc->sc_ctty, "st%d: HARDWARE ERROR\n", unit);
127946286Smckusick 		break;
128046286Smckusick 	case XSK_ILLREQ:
128146286Smckusick 		tprintf(sc->sc_ctty, "st%d: ILLEGAL REQUEST\n", unit);
128246286Smckusick 		break;
128346286Smckusick 	case XSK_UNTATTEN:
128446286Smckusick 		tprintf(sc->sc_ctty, "st%d: UNIT ATTENTION\n", unit);
128546286Smckusick 		break;
128646286Smckusick 	case XSK_DATAPROT:
128746286Smckusick 		tprintf(sc->sc_ctty, "st%d: DATA PROTECT\n", unit);
128846286Smckusick 		break;
128946286Smckusick 	case XSK_BLNKCHK:
129046286Smckusick 		tprintf(sc->sc_ctty, "st%d: BLANK CHECK\n", unit);
129146286Smckusick 		break;
129246286Smckusick 	case XSK_VENDOR:
129346286Smckusick 		tprintf(sc->sc_ctty, "st%d: VENDER UNIQUE SENSE KEY ", unit);
129446286Smckusick 		switch (sc->sc_tapeid) {
129546286Smckusick 		case MT_ISEXABYTE:
129646286Smckusick 			tprintf(sc->sc_ctty, "Exabyte: ");
129746286Smckusick 			if (xp->exb_xsense.xfr)
129846286Smckusick 				tprintf(sc->sc_ctty,
129946286Smckusick 					"Transfer Abort Error\n");
130046286Smckusick 			if (xp->exb_xsense.tmd)
130146286Smckusick 				tprintf(sc->sc_ctty,
130246286Smckusick 					"Tape Mark Detect Error\n");
130346286Smckusick 			break;
130446286Smckusick 		default:
130546286Smckusick 			tprintf(sc->sc_ctty, "\n");
130646286Smckusick 		}
130746286Smckusick 		break;
130846286Smckusick 	case XSK_CPYABORT:
130946286Smckusick 		tprintf(sc->sc_ctty, "st%d: COPY ABORTED\n", unit);
131046286Smckusick 		break;
131146286Smckusick 	case XSK_ABORTCMD:
131246286Smckusick 		tprintf(sc->sc_ctty, "st%d: ABORTED COMMAND\n", unit);
131346286Smckusick 		break;
131446286Smckusick 	case XSK_VOLOVER:
131546286Smckusick 		tprintf(sc->sc_ctty, "st%d: VOLUME OVERFLOW\n", unit);
131646286Smckusick 		break;
131746286Smckusick 	default:
131846286Smckusick 		tprintf(sc->sc_ctty, "st%d: unknown sense key 0x%x\n",
131946286Smckusick 			unit, xp->sc_xsense.key);
132046286Smckusick 	}
132146286Smckusick 	if (sc->sc_tapeid == MT_ISEXABYTE) {
132246286Smckusick 		if (xp->exb_xsense.bpe)
132346286Smckusick 			tprintf(sc->sc_ctty, "st%d: Bus Parity Errorn", unit);
132446286Smckusick 		if (xp->exb_xsense.fpe)
132546286Smckusick 			tprintf(sc->sc_ctty,
132646286Smckusick 				"st%d: Formatted Buffer Parity Errorn", unit);
132746286Smckusick 		if (xp->exb_xsense.eco)
132846286Smckusick 			tprintf(sc->sc_ctty, "st%d: Error Counter Overflown",
132946286Smckusick 				unit);
133046286Smckusick 		if (xp->exb_xsense.tme)
133146286Smckusick 			tprintf(sc->sc_ctty, "st%d: Tape Motion Errorn", unit);
133246286Smckusick 		if (xp->exb_xsense.xfr)
133346286Smckusick 			tprintf(sc->sc_ctty, "st%d: Transfer About Errorn",
133446286Smckusick 				unit);
133546286Smckusick 		if (xp->exb_xsense.tmd)
133646286Smckusick 			tprintf(sc->sc_ctty, "st%d: Tape Mark Detect Errorn",
133746286Smckusick 				unit);
133846286Smckusick 		if (xp->exb_xsense.fmke)
133946286Smckusick 			tprintf(sc->sc_ctty, "st%d: Filemark Errorn", unit);
134046286Smckusick 		if (xp->exb_xsense.ure)
134146286Smckusick 			tprintf(sc->sc_ctty, "st%d: Under Run Errorn", unit);
134246286Smckusick 		if (xp->exb_xsense.sse)
134346286Smckusick 			tprintf(sc->sc_ctty, "st%d: Servo System Errorn",
134446286Smckusick 				unit);
134546286Smckusick 		if (xp->exb_xsense.fe)
134646286Smckusick 			tprintf(sc->sc_ctty, "st%d: Formatter Errorn", unit);
134746286Smckusick 		if (xp->exb_xsense.wseb)
134846286Smckusick 			tprintf(sc->sc_ctty, "st%d: WSEB Errorn", unit);
134946286Smckusick 		if (xp->exb_xsense.wseo)
135046286Smckusick 			tprintf(sc->sc_ctty, "st%d: WSEO Errorn", unit);
135146286Smckusick 	}
135246286Smckusick }
135346286Smckusick 
135446286Smckusick #ifdef DEBUG
135546286Smckusick 
135646286Smckusick dumpxsense(sensebuf)
135746286Smckusick 	struct st_xsense *sensebuf;
135846286Smckusick {
135946286Smckusick         struct st_xsense *xp = sensebuf;
136046286Smckusick 
136146286Smckusick 	printf("valid 0x%x errorclass 0x%x errorcode 0x%x\n",
136246286Smckusick 	       xp->sc_xsense.valid,
136346286Smckusick 	       xp->sc_xsense.class, xp->sc_xsense.code);
136446286Smckusick 	printf("seg number 0x%x\n", xp->sc_xsense.segment);
136546286Smckusick 	printf("FMK 0x%x EOM 0x%x ILI 0x%x RSVD 0x%x sensekey 0x%x\n",
136646286Smckusick 	       xp->sc_xsense.filemark, xp->sc_xsense.eom, xp->sc_xsense.ili,
136746286Smckusick 	       xp->sc_xsense.rsvd, xp->sc_xsense.key);
136846286Smckusick 	printf("info 0x%lx\n",
136946286Smckusick 	       (u_long)((xp->sc_xsense.info1<<24)|(xp->sc_xsense.info2<<16)|
137046286Smckusick 			(xp->sc_xsense.info3<<8)|(xp->sc_xsense.info4)) );
137146286Smckusick 	printf("ASenseL 0x%x\n", xp->sc_xsense.len);
137246286Smckusick 
137346286Smckusick 	if (xp->sc_xsense.len != 0x12) /* MT_ISEXB Exabyte only ?? */
137446286Smckusick 		return;			/* What about others */
137546286Smckusick 
137646286Smckusick 	printf("ASenseC 0x%x\n", xp->exb_xsense.addsens);
137746286Smckusick 	printf("AsenseQ 0x%x\n", xp->exb_xsense.addsensq);
137846286Smckusick 	printf("R/W Errors 0x%lx\n",
137946286Smckusick 	       (u_long)((xp->exb_xsense.rwerrcnt2<<16)|
138046286Smckusick 			(xp->exb_xsense.rwerrcnt1<<8)|
138146286Smckusick 			(xp->exb_xsense.rwerrcnt1)) );
138246286Smckusick 	printf("PF   0x%x BPE  0x%x FPE 0x%x ME   0x%x ECO 0x%x TME 0x%x TNP 0x%x BOT 0x%x\n",
138346286Smckusick 	       xp->exb_xsense.pf, xp->exb_xsense.bpe, xp->exb_xsense.fpe,
138446286Smckusick 	       xp->exb_xsense.me, xp->exb_xsense.eco, xp->exb_xsense.tme,
138546286Smckusick 	       xp->exb_xsense.tnp, xp->exb_xsense.bot);
138646286Smckusick 	printf("XFR  0x%x TMD  0x%x WP  0x%x FMKE 0x%x URE 0x%x WE1 0x%x SSE 0x%x FE  0x%x\n",
138746286Smckusick 	       xp->exb_xsense.xfr, xp->exb_xsense.tmd, xp->exb_xsense.wp,
138846286Smckusick 	       xp->exb_xsense.fmke, xp->exb_xsense.ure, xp->exb_xsense.we1,
138946286Smckusick 	       xp->exb_xsense.sse, xp->exb_xsense.fe);
139046286Smckusick 	printf("WSEB 0x%x WSEO 0x%x\n",
139146286Smckusick 	       xp->exb_xsense.wseb, xp->exb_xsense.wseo);
139246286Smckusick 	printf("Remaining Tape 0x%lx\n",
139346286Smckusick 	       (u_long)((xp->exb_xsense.tplft2<<16)|
139446286Smckusick 			(xp->exb_xsense.tplft1<<8)|
139546286Smckusick 			(xp->exb_xsense.tplft0)) );
139646286Smckusick }
139746286Smckusick 
139846286Smckusick prtmodsel(msd, modlen)
139946286Smckusick 	struct mode_select_data *msd;
140046286Smckusick 	int modlen;
140146286Smckusick {
140246286Smckusick 	printf("Modsel command. len is 0x%x.\n", modlen);
140346286Smckusick 	printf("rsvd1 0x%x rsvd2 0x%x rsvd3 0x%x bufferd 0x%x speed 0x%x bckdeslen 0x%x\n",
140446286Smckusick 	       msd->rsvd1,msd->rsvd2,msd->rsvd3,msd->buff,msd->speed,msd->blkdeslen);
140546286Smckusick 	printf("density 0x%x blks2 0x%x blks1 0x%x blks0 0x%x rsvd 0x%x blklen2 0x%x blklen1 0x%x blklen0 0x%x\n",
140646286Smckusick 	       msd->density,msd->blks2,msd->blks1,msd->blks0,msd->rsvd4,msd->blklen2,msd->blklen1,msd->blklen0);
140746286Smckusick 	printf("vupb 0x%x rsvd 0x%x p5 0x%x motionthres 0x%x reconthres 0x%x gapthres 0x%x \n",
140846286Smckusick 	       msd->vupb,msd->rsvd5,msd->p5,msd->motionthres,msd->reconthres,msd->gapthres);
140946286Smckusick }
141046286Smckusick 
141146286Smckusick prtmodstat(mode)
141246286Smckusick 	struct mode_sense *mode;
141346286Smckusick {
141446286Smckusick 	printf("Mode Status\n");
141546286Smckusick 	printf("sdl 0x%x medtype 0x%x wp 0x%x bfmd 0x%x speed 0x%x bdl 0x%x\n",
141646286Smckusick 	       mode->md.sdl, mode->md.medtype, mode->md.wp, mode->md.bfmd,
141746286Smckusick 	       mode->md.speed, mode->md.bdl);
141846286Smckusick 	printf("dencod 0x%x numblk 0x%x blklen 0x%x\n",
141946286Smckusick 	       mode->md.dencod,
142046286Smckusick 	       (mode->md.numblk2<<16)|(mode->md.numblk1<<8)|(mode->md.numblk0),
142146286Smckusick 	       (mode->md.blklen2<<16)|(mode->md.blklen1<<8)|(mode->md.blklen0) );
142246286Smckusick 	printf("ct 0x%x nd 0x%x nbe 0x%x edb 0x%x pe 0x%x nal 0x%x p5 0x%x\n",
142346286Smckusick 	       mode->ex.ct, mode->ex.nd, mode->ex.nbe,
142446286Smckusick 	       mode->ex.ebd, mode->ex.pe, mode->ex.nal, mode->ex.p5);
142546286Smckusick 	printf("motionthres 0x%x reconthres 0x%x gapthres 0x%x\n",
142646286Smckusick 	       mode->ex.motionthres, mode->ex.reconthres,  mode->ex.gapthres);
142746286Smckusick }
142846286Smckusick #endif /* DEBUG */
142946286Smckusick 
143046286Smckusick #endif
1431