Initial import, 0.1 + pk 0.2.4-B1

1 files changed, 1015 insertions, 0 deletions

diff --git a/sys/scsi/ch.c b/sys/scsi/ch.c
new file mode 100644
index 0000000..1e7469b
--- /dev/null
+++ b/sys/scsi/ch.c
@@ -0,0 +1,1015 @@
+/* 
+ */
+/*
+ * HISTORY
+ * 
+ *
+ * PATCHES MAGIC                LEVEL   PATCH THAT GOT US HERE
+ * --------------------         -----   ----------------------
+ * CURRENT PATCH LEVEL:         1       00098
+ * --------------------         -----   ----------------------
+ *
+ * 16 Feb 93	Julian Elischer		ADDED for SCSI system
+ * 
+ */
+
+#include	<sys/types.h>
+#include	<ch.h>
+
+#include <sys/param.h>
+#include <sys/systm.h>
+
+#include <sys/errno.h>
+#include <sys/ioctl.h>
+#include <sys/buf.h>
+#include <sys/proc.h>
+#include <sys/user.h>
+#include <sys/chio.h>
+
+#if defined(OSF)
+#define SECSIZE	512
+#endif /* defined(OSF) */
+
+#include <scsi/scsi_all.h>
+#include <scsi/scsi_changer.h>
+#include <scsi/scsiconf.h>
+
+
+struct  scsi_xfer ch_scsi_xfer[NCH];
+int     ch_xfer_block_wait[NCH];
+
+
+#define PAGESIZ 	4096
+#define STQSIZE		4
+#define	CH_RETRIES	4
+
+
+#define MODE(z)		(  (minor(z) & 0x0F) )
+#define UNIT(z)		(  (minor(z) >> 4) )
+
+#ifndef	MACH
+#define ESUCCESS 0
+#endif	MACH
+
+int	ch_info_valid[NCH];	/* the info about the device is valid */
+int	ch_initialized[NCH] ;
+int	ch_debug = 1;
+
+int chattach();
+int ch_done();
+struct	ch_data
+{
+	int	flags;
+	struct	scsi_switch *sc_sw;	/* address of scsi low level switch */
+	int	ctlr;			/* so they know which one we want */
+	int	targ;			/* our scsi target ID */
+	int	lu;			/* out scsi lu */
+	short	chmo;			/* Offset of first CHM */
+	short	chms;			/* No. of CHM */
+	short	slots;			/* No. of Storage Elements */
+	short	sloto;			/* Offset of first SE */
+	short	imexs;			/* No. of Import/Export Slots */
+	short	imexo;			/* Offset of first IM/EX */
+	short	drives;			/* No. of CTS */
+	short	driveo;			/* Offset of first CTS */
+	short	rot;			/* CHM can rotate */
+	u_long	op_matrix;		/* possible opertaions */
+	u_short lsterr;		/* details of lasterror */
+	u_char	stor;			/* posible Storage locations */
+}ch_data[NCH];
+
+#define CH_OPEN		0x01
+#define CH_KNOWN	0x02
+
+static	int	next_ch_unit = 0;
+/***********************************************************************\
+* The routine called by the low level scsi routine when it discovers	*
+* A device suitable for this driver					*
+\***********************************************************************/
+
+int	chattach(ctlr,targ,lu,scsi_switch)
+struct	scsi_switch *scsi_switch;
+{
+	int	unit,i,stat;
+	unsigned char *tbl;
+
+	if(scsi_debug & PRINTROUTINES) printf("chattach: ");
+	/*******************************************************\
+	* Check we have the resources for another drive		*
+	\*******************************************************/
+	unit = next_ch_unit++;
+	if( unit >= NCH)
+	{
+		printf("Too many scsi changers..(%d > %d) reconfigure kernel",(unit + 1),NCH);
+		return(0);
+	}
+	/*******************************************************\
+	* Store information needed to contact our base driver	*
+	\*******************************************************/
+	ch_data[unit].sc_sw	=	scsi_switch;
+	ch_data[unit].ctlr	=	ctlr;
+	ch_data[unit].targ	=	targ;
+	ch_data[unit].lu	=	lu;
+
+	/*******************************************************\
+	* Use the subdriver to request information regarding	*
+	* the drive. We cannot use interrupts yet, so the	*
+	* request must specify this.				*
+	\*******************************************************/
+	if((ch_mode_sense(unit,  SCSI_NOSLEEP |  SCSI_NOMASK /*| SCSI_SILENT*/)))
+	{
+		printf("	ch%d: scsi changer, %d slot(s) %d drive(s) %d arm(s) %d i/e-slot(s) \n",
+			unit, ch_data[unit].slots, ch_data[unit].drives, ch_data[unit].chms, ch_data[unit].imexs);
+		stat=CH_KNOWN;
+	}
+	else
+	{
+		printf("	ch%d: scsi changer :- offline\n", unit);
+		stat=CH_OPEN;
+	}
+	ch_initialized[unit] = stat;
+
+	return;
+
+}
+
+
+
+/*******************************************************\
+*	open the device.				*
+\*******************************************************/
+chopen(dev)
+{
+	int errcode = 0;
+	int unit,mode;
+
+	unit = UNIT(dev);
+	mode = MODE(dev);
+
+	/*******************************************************\
+	* Check the unit is legal                               *
+	\*******************************************************/
+	if ( unit >= NCH )
+	{
+		printf("ch %d  > %d\n",unit,NCH);
+		errcode = ENXIO;
+		return(errcode);
+	}
+	/*******************************************************\
+	* Only allow one at a time				*
+	\*******************************************************/
+	if(ch_data[unit].flags & CH_OPEN)
+	{
+		printf("CH%d already open\n",unit);
+		errcode = ENXIO;
+		goto bad;
+	}
+	
+	if(ch_debug||(scsi_debug & (PRINTROUTINES | TRACEOPENS)))
+		printf("chopen: dev=0x%x (unit %d (of %d))\n"
+				,   dev,      unit,   NCH);
+	/*******************************************************\
+	* Make sure the device has been initialised		*
+	\*******************************************************/
+
+	if (!ch_initialized[unit])
+		return(ENXIO);
+	if (ch_initialized[unit]!=CH_KNOWN) {
+		if((ch_mode_sense(unit,  SCSI_NOSLEEP |  SCSI_NOMASK /*| SCSI_SILENT*/)))
+		{
+			ch_initialized[unit]=CH_KNOWN;
+		}
+	  else
+		{
+			printf("  ch%d: scsi changer :- offline\n", unit);
+			return(ENXIO);
+		}
+	}
+	/*******************************************************\
+	* Check that it is still responding and ok.		*
+	\*******************************************************/
+
+	if(ch_debug || (scsi_debug & TRACEOPENS))
+		printf("device is ");
+	if (!(ch_req_sense(unit, 0)))
+	{
+		errcode = ENXIO;
+		if(ch_debug || (scsi_debug & TRACEOPENS))
+			printf("not responding\n");
+		goto bad;
+	}
+	if(ch_debug || (scsi_debug & TRACEOPENS))
+		printf("ok\n");
+
+	if(!(ch_test_ready(unit,0)))
+	{
+		printf("ch%d not ready\n",unit);
+		return(EIO);
+	}
+
+	ch_info_valid[unit] = TRUE;
+
+	/*******************************************************\
+	* Load the physical device parameters			*
+	\*******************************************************/
+
+	ch_data[unit].flags = CH_OPEN;
+	return(errcode);
+bad:
+	return(errcode);
+}
+
+/*******************************************************\
+* close the device.. only called if we are the LAST	*
+* occurence of an open device				*
+\*******************************************************/
+chclose(dev)
+{
+	unsigned char unit,mode;
+
+	unit = UNIT(dev);
+	mode = MODE(dev);
+
+	if(scsi_debug & TRACEOPENS)
+		printf("Closing device");
+	ch_data[unit].flags = 0;
+	return(0);
+}
+
+
+
+/***************************************************************\
+* chstart                                                       *
+* This routine is also called after other non-queued requests	*
+* have been made of the scsi driver, to ensure that the queue	*
+* continues to be drained.					*
+\***************************************************************/
+/* chstart() is called at splbio */
+chstart(unit)
+{
+	int			drivecount;
+	register struct buf	*bp = 0;
+	register struct buf	*dp;
+	struct	scsi_xfer	*xs;
+	int			blkno, nblk;
+
+
+	if(scsi_debug & PRINTROUTINES) printf("chstart%d ",unit);
+	/*******************************************************\
+	* See if there is a buf to do and we are not already	*
+	* doing one						*
+	\*******************************************************/
+	xs=&ch_scsi_xfer[unit];
+	if(xs->flags & INUSE)
+	{
+		return;    /* unit already underway */
+	}
+	if(ch_xfer_block_wait[unit]) /* a special awaits, let it proceed first */
+	{
+		wakeup(&ch_xfer_block_wait[unit]);
+		return;
+	}
+
+	return;
+
+}
+
+
+/*******************************************************\
+* This routine is called by the scsi interrupt when	*
+* the transfer is complete.
+\*******************************************************/
+int	ch_done(unit,xs)
+int	unit;
+struct	scsi_xfer	*xs;
+{
+	struct	buf		*bp;
+	int	retval;
+
+	if(ch_debug||(scsi_debug & PRINTROUTINES)) printf("ch_done%d ",unit);
+	if (! (xs->flags & INUSE))
+		panic("scsi_xfer not in use!");
+	wakeup(xs);
+}
+/*******************************************************\
+* Perform special action on behalf of the user		*
+* Knows about the internals of this device		*
+\*******************************************************/
+chioctl(dev, cmd, arg, mode)
+dev_t dev;
+int cmd;
+caddr_t arg;
+{
+	/* struct ch_cmd_buf *args;*/
+	union scsi_cmd *scsi_cmd;
+	register i,j;
+	unsigned int opri;
+	int errcode = 0;
+	unsigned char unit;
+	int number,flags,ret;
+
+	/*******************************************************\
+	* Find the device that the user is talking about	*
+	\*******************************************************/
+	flags = 0;	/* give error messages, act on errors etc. */
+	unit = UNIT(dev);
+
+	switch(cmd)
+	{
+		case CHIOOP: {
+			struct chop *ch=(struct chop *) arg;
+			if (ch_debug)
+				printf("[chtape_chop: %x]\n", ch->ch_op);
+
+			 switch ((short)(ch->ch_op)) {
+				case CHGETPARAM:
+					ch->u.getparam.chmo=	 ch_data[unit].chmo;
+					ch->u.getparam.chms=   ch_data[unit].chms;
+					ch->u.getparam.sloto=  ch_data[unit].sloto;
+					ch->u.getparam.slots=  ch_data[unit].slots;
+					ch->u.getparam.imexo=  ch_data[unit].imexo;
+					ch->u.getparam.imexs=  ch_data[unit].imexs;
+					ch->u.getparam.driveo= ch_data[unit].driveo;
+					ch->u.getparam.drives= ch_data[unit].drives;
+					ch->u.getparam.rot=    ch_data[unit].rot;
+					ch->result=0;
+					return 0;
+					break;
+				case CHPOSITION: 
+				 return ch_position(unit,&ch->result,ch->u.position.chm,
+						ch->u.position.to,
+						flags);
+				case CHMOVE: 
+				 return ch_move(unit,&ch->result, ch->u.position.chm,
+					ch->u.move.from, ch->u.move.to,
+								flags);
+				case CHGETELEM:
+				 return ch_getelem(unit,&ch->result, ch->u.get_elem_stat.type,
+					ch->u.get_elem_stat.from, &ch->u.get_elem_stat.elem_data,
+									flags);
+				default:
+				 return EINVAL;
+		}
+
+	 }
+	default:
+		return EINVAL;
+	}
+
+	return(ret?ESUCCESS:EIO);
+}
+
+ch_getelem(unit,stat,type,from,data,flags)
+int unit,from,flags;
+short *stat;
+char *data;
+{
+	struct scsi_read_element_status scsi_cmd;
+	char elbuf[32];
+	int ret;
+
+	bzero(&scsi_cmd, sizeof(scsi_cmd));
+	scsi_cmd.op_code = READ_ELEMENT_STATUS;
+	scsi_cmd.element_type_code=type;
+	scsi_cmd.starting_element_addr[0]=(from>>8)&0xff;
+	scsi_cmd.starting_element_addr[1]=from&0xff;
+	scsi_cmd.number_of_elements[1]=1;
+	scsi_cmd.allocation_length[2]=32;
+	
+	if ((ret=ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(scsi_cmd),
+			elbuf,
+			32,
+			100000,
+			flags) !=ESUCCESS)) {
+			*stat=ch_data[unit].lsterr;
+			bcopy(elbuf+16,data,16);
+			return ret;
+			}
+	bcopy(elbuf+16,data,16); /*Just a hack sh */
+	return ret;
+}
+
+ch_move(unit,stat,chm,from,to,flags)
+int unit,chm,from,to,flags;
+short *stat;
+{
+	struct scsi_move_medium scsi_cmd;
+	int ret;
+
+	bzero(&scsi_cmd, sizeof(scsi_cmd));
+	scsi_cmd.op_code = MOVE_MEDIUM;
+	scsi_cmd.transport_element_address[0]=(chm>>8)&0xff;
+	scsi_cmd.transport_element_address[1]=chm&0xff;
+	scsi_cmd.source_address[0]=(from>>8)&0xff;
+	scsi_cmd.source_address[1]=from&0xff;
+	scsi_cmd.destination_address[0]=(to>>8)&0xff;
+	scsi_cmd.destination_address[1]=to&0xff;
+	scsi_cmd.invert=(chm&CH_INVERT)?1:0;
+	if ((ret=ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(scsi_cmd),
+			NULL,
+			0,
+			100000,
+			flags) !=ESUCCESS)) {
+			*stat=ch_data[unit].lsterr;
+			return ret;
+			}
+	return ret;
+}
+
+ch_position(unit,stat,chm,to,flags)
+int unit,chm,to,flags;
+short *stat;
+{
+	struct scsi_position_to_element scsi_cmd;
+	int ret;
+
+	bzero(&scsi_cmd, sizeof(scsi_cmd));
+	scsi_cmd.op_code = POSITION_TO_ELEMENT;
+	scsi_cmd.transport_element_address[0]=(chm>>8)&0xff;
+	scsi_cmd.transport_element_address[1]=chm&0xff;
+	scsi_cmd.source_address[0]=(to>>8)&0xff;
+	scsi_cmd.source_address[1]=to&0xff;
+	scsi_cmd.invert=(chm&CH_INVERT)?1:0;
+	if ((ret=ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(scsi_cmd),
+			NULL,
+			0,
+			100000,
+			flags) !=ESUCCESS)) {
+			*stat=ch_data[unit].lsterr;
+			return ret;
+			}
+	return ret;
+}
+
+/*******************************************************\
+* Check with the device that it is ok, (via scsi driver)*
+\*******************************************************/
+ch_req_sense(unit, flags)
+int	flags;
+{
+	struct	scsi_sense_data sense;
+	struct scsi_sense scsi_cmd;
+
+	bzero(&scsi_cmd, sizeof(scsi_cmd));
+	scsi_cmd.op_code = REQUEST_SENSE;
+	scsi_cmd.length = sizeof(sense);
+
+	if (ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(struct	scsi_sense),
+			&sense,
+			sizeof(sense),
+			100000,
+			flags | SCSI_DATA_IN) != 0)
+	{
+		return(FALSE);
+	}
+	else 
+		return(TRUE);
+}
+
+/*******************************************************\
+* Get scsi driver to send a "are you ready" command	*
+\*******************************************************/
+ch_test_ready(unit,flags)
+int	unit,flags;
+{
+	struct scsi_test_unit_ready scsi_cmd;
+
+	bzero(&scsi_cmd, sizeof(scsi_cmd));
+	scsi_cmd.op_code = TEST_UNIT_READY;
+
+	if (ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(struct	scsi_test_unit_ready),
+			0,
+			0,
+			100000,
+			flags) != 0) {
+		return(FALSE);
+	} else 
+		return(TRUE);
+}
+
+
+#ifdef	__STDC__
+#define b2tol(a)	(((unsigned)(a##_1) << 8) + (unsigned)a##_0 )
+#else
+#define b2tol(a)	(((unsigned)(a/**/_1) << 8) + (unsigned)a/**/_0 )
+#endif
+
+/*******************************************************\
+* Get the scsi driver to send a full inquiry to the	*
+* device and use the results to fill out the global 	*
+* parameter structure.					*
+\*******************************************************/
+ch_mode_sense(unit, flags)
+int	unit,flags;
+{
+	struct scsi_mode_sense scsi_cmd;
+	u_char scsi_sense[128];	/* Can't use scsi_mode_sense_data because of */
+				/* missing block descriptor 		     */
+	u_char *b;
+	int i,l;
+
+	/*******************************************************\
+	* First check if we have it all loaded			*
+	\*******************************************************/
+	if (ch_info_valid[unit]==CH_KNOWN) return(TRUE);
+	/*******************************************************\
+	* First do a mode sense 				*
+	\*******************************************************/
+	ch_info_valid[unit] &= ~CH_KNOWN;
+	for(l=1;l>=0;l--) {
+		bzero(&scsi_cmd, sizeof(scsi_cmd));
+		scsi_cmd.op_code = MODE_SENSE;
+		scsi_cmd.dbd = l;
+		scsi_cmd.page_code = 0x3f;	/* All Pages */
+		scsi_cmd.length = sizeof(scsi_sense);
+	/*******************************************************\
+	* do the command, but we don't need the results		*
+	* just print them for our interest's sake		*
+	\*******************************************************/
+		if (ch_scsi_cmd(unit,
+			&scsi_cmd,
+			sizeof(struct	scsi_mode_sense),
+			&scsi_sense,
+			sizeof(scsi_sense),
+			5000,
+			flags | SCSI_DATA_IN) == 0) {
+				ch_info_valid[unit] = CH_KNOWN;
+				break;
+			}
+	}
+	if (ch_info_valid[unit]!=CH_KNOWN)   {
+		if(!(flags & SCSI_SILENT))
+			printf("could not mode sense for unit %d\n", unit);
+		return(FALSE);
+	}
+	l=scsi_sense[0]-3;
+	b=&scsi_sense[4];
+	/*****************************\
+	* To avoid alignment problems *
+	\*****************************/
+/*FIX THIS FOR MSB */
+#define p2copy(valp)	 (valp[1]+ (valp[0]<<8));valp+=2
+#define p4copy(valp)	 (valp[3]+ (valp[2]<<8) + (valp[1]<<16) + (valp[0]<<24));valp+=4
+#if 0
+	printf("\nmode_sense %d\n",l);
+	for(i=0;i<l+4;i++) {
+		printf("%x%c",scsi_sense[i],i%8==7?'\n':':');
+	}
+	printf("\n");
+#endif
+	for(i=0;i<l;) {
+		int pc=(*b++)&0x3f;
+		int pl=*b++;
+		u_char *bb=b;
+		switch(pc) {
+			case 0x1d:
+				ch_data[unit].chmo  =p2copy(bb);
+				ch_data[unit].chms  =p2copy(bb);
+				ch_data[unit].sloto =p2copy(bb);
+				ch_data[unit].slots =p2copy(bb);
+				ch_data[unit].imexo =p2copy(bb);
+				ch_data[unit].imexs =p2copy(bb);
+				ch_data[unit].driveo =p2copy(bb);
+				ch_data[unit].drives =p2copy(bb);
+				break;
+			case 0x1e:
+				ch_data[unit].rot = (*b)&1;
+				break;
+			case 0x1f:
+				ch_data[unit].stor = *b&0xf;
+				bb+=2;
+				ch_data[unit].stor =p4copy(bb);
+				break;
+			default:
+				break;
+		}
+		b+=pl;
+		i+=pl+2;
+	}
+	if (ch_debug)
+	{
+		printf("unit %d: cht(%d-%d)slot(%d-%d)imex(%d-%d)cts(%d-%d) %s rotate\n",
+				unit,
+				ch_data[unit].chmo,
+				ch_data[unit].chms,
+				ch_data[unit].sloto,
+				ch_data[unit].slots,
+				ch_data[unit].imexo,
+				ch_data[unit].imexs,
+				ch_data[unit].driveo,
+				ch_data[unit].drives,
+				ch_data[unit].rot?"can":"can't");
+	}
+	return(TRUE);
+}
+
+/*******************************************************\
+* ask the scsi driver to perform a command for us.	*
+* Call it through the switch table, and tell it which	*
+* sub-unit we want, and what target and lu we wish to	*
+* talk to. Also tell it where to find the command	*
+* how long int is.					*
+* Also tell it where to read/write the data, and how	*
+* long the data is supposed to be			*
+\*******************************************************/
+int	ch_scsi_cmd(unit,scsi_cmd,cmdlen,data_addr,datalen,timeout,flags)
+
+int	unit,flags;
+struct	scsi_generic *scsi_cmd;
+int	cmdlen;
+int	timeout;
+u_char	*data_addr;
+int	datalen;
+{
+	struct	scsi_xfer *xs;
+	int	retval;
+	int	s;
+
+	if(ch_debug||(scsi_debug & PRINTROUTINES)) printf("\nch_scsi_cmd%d %x",
+				unit,scsi_cmd->opcode);
+	if(ch_data[unit].sc_sw)	/* If we have a scsi driver */
+	{
+
+		xs = &(ch_scsi_xfer[unit]);
+		if(!(flags & SCSI_NOMASK))
+			s = splbio();
+		ch_xfer_block_wait[unit]++;	/* there is someone waiting */
+		while (xs->flags & INUSE)
+		{
+			sleep(&ch_xfer_block_wait[unit],PRIBIO+1);
+		}
+		ch_xfer_block_wait[unit]--;
+		xs->flags = INUSE;
+		if(!(flags & SCSI_NOMASK))
+			splx(s);
+
+		/*******************************************************\
+		* Fill out the scsi_xfer structure			*
+		\*******************************************************/
+		xs->flags	|=	flags;
+		xs->adapter	=	ch_data[unit].ctlr;
+		xs->targ	=	ch_data[unit].targ;
+		xs->lu		=	ch_data[unit].lu;
+		xs->retries	=	CH_RETRIES;
+		xs->timeout	=	timeout;
+		xs->cmd		=	scsi_cmd;
+		xs->cmdlen	=	cmdlen;
+		xs->data	=	data_addr;
+		xs->datalen	=	datalen;
+		xs->resid	=	datalen;
+		xs->when_done	=	(flags & SCSI_NOMASK)
+					?(int (*)())0
+					:ch_done;
+		xs->done_arg	=	unit;
+		xs->done_arg2	=	(int)xs;
+retry:		xs->error	=	XS_NOERROR;
+		xs->bp		=	0;
+		ch_data[unit].lsterr=0;
+		retval = (*(ch_data[unit].sc_sw->scsi_cmd))(xs);
+		switch(retval)
+		{
+		case	SUCCESSFULLY_QUEUED:
+			while(!(xs->flags & ITSDONE))
+				sleep(xs,PRIBIO+1);
+
+		case	HAD_ERROR:
+		case	COMPLETE:
+			switch(xs->error)
+			{
+			case	XS_NOERROR:
+				retval = ESUCCESS;
+				break;
+			case	XS_SENSE:
+				retval = (ch_interpret_sense(unit,xs));
+				break;
+			case	XS_DRIVER_STUFFUP:
+				retval = EIO;
+				break;
+			case    XS_TIMEOUT:
+				if(xs->retries-- )
+				{
+					xs->flags &= ~ITSDONE;
+					goto retry;
+				}
+				retval = EIO;
+				break;
+			case    XS_BUSY:
+				if(xs->retries-- )
+				{
+					xs->flags &= ~ITSDONE;
+					goto retry;
+				}
+				retval = EIO;
+				break;
+			default:
+				retval = EIO;
+				printf("st%d: unknown error category from scsi driver\n"
+					,unit);
+				break;
+			}	
+			break;
+		case 	TRY_AGAIN_LATER:
+			if(xs->retries-- )
+			{
+				xs->flags &= ~ITSDONE;
+				goto retry;
+			}
+			retval = EIO;
+			break;
+		default:
+			retval = EIO;
+		}
+		xs->flags = 0;	/* it's free! */
+		chstart(unit);
+	}
+	else
+	{
+		printf("chd: not set up\n",unit);
+		return(EINVAL);
+	}
+	return(retval);
+}
+/***************************************************************\
+* Look at the returned sense and act on the error and detirmine	*
+* The unix error number to pass back... (0 = report no error)	*
+\***************************************************************/
+
+int	ch_interpret_sense(unit,xs)
+int	unit;
+struct	scsi_xfer	*xs;
+{
+	struct	scsi_sense_data *sense;
+	int	key;
+	int	silent = xs->flags & SCSI_SILENT;
+
+	/***************************************************************\
+	* If errors are ok, report a success				*
+	\***************************************************************/
+	if(xs->flags & SCSI_ERR_OK) return(ESUCCESS);
+
+	/***************************************************************\
+	* Get the sense fields and work out what CLASS			*
+	\***************************************************************/
+	sense = &(xs->sense);
+	switch(sense->error_class)
+	{
+	/***************************************************************\
+	* If it's class 7, use the extended stuff and interpret the key	*
+	\***************************************************************/
+	case 7:
+		{
+		key=sense->ext.extended.sense_key;
+		if(sense->ext.extended.ili)
+			if(!silent)
+			{
+				printf("length error ");
+			}
+			if(sense->valid)
+				xs->resid = ntohl(*((long *)sense->ext.extended.info));
+				if(xs->bp)
+				{
+					xs->bp->b_flags |= B_ERROR;
+					return(ESUCCESS);
+				}
+		if(sense->ext.extended.eom)
+			if(!silent) printf("end of medium ");
+		if(sense->ext.extended.filemark)
+			if(!silent) printf("filemark ");
+		if(ch_debug)
+		{
+			printf("code%x class%x valid%x\n"
+					,sense->error_code
+					,sense->error_class
+					,sense->valid);
+			printf("seg%x key%x ili%x eom%x fmark%x\n"
+					,sense->ext.extended.segment
+					,sense->ext.extended.sense_key
+					,sense->ext.extended.ili
+					,sense->ext.extended.eom
+					,sense->ext.extended.filemark);
+			printf("info: %x %x %x %x followed by %d extra bytes\n"
+					,sense->ext.extended.info[0]
+					,sense->ext.extended.info[1]
+					,sense->ext.extended.info[2]
+					,sense->ext.extended.info[3]
+					,sense->ext.extended.extra_len);
+			printf("extra: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x\n"
+					,sense->ext.extended.extra_bytes[0]
+					,sense->ext.extended.extra_bytes[1]
+					,sense->ext.extended.extra_bytes[2]
+					,sense->ext.extended.extra_bytes[3]
+					,sense->ext.extended.extra_bytes[4]
+					,sense->ext.extended.extra_bytes[5]
+					,sense->ext.extended.extra_bytes[6]
+					,sense->ext.extended.extra_bytes[7]
+					,sense->ext.extended.extra_bytes[8]
+					,sense->ext.extended.extra_bytes[9]
+					,sense->ext.extended.extra_bytes[10]
+					,sense->ext.extended.extra_bytes[11]
+					,sense->ext.extended.extra_bytes[12]
+					,sense->ext.extended.extra_bytes[13]
+					,sense->ext.extended.extra_bytes[14]
+					,sense->ext.extended.extra_bytes[15]);
+				    
+		}
+		switch(key)
+		{
+		case	0x0:
+			return(ESUCCESS);
+		case	0x1:
+			if(!silent)
+			{
+				printf("st%d: soft error(corrected) ", unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(ESUCCESS);
+		case	0x2:
+			if(!silent) printf("st%d: not ready\n ", unit); 
+			ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
+								sense->ext.extended.info[13] ;
+			return(ENODEV);
+		case	0x3:
+			if(!silent)
+			{
+				printf("st%d: medium error ", unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(EIO);
+		case	0x4:
+			if(!silent) printf("st%d: non-media hardware failure\n ",
+				unit); 
+			ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
+								sense->ext.extended.info[13] ;
+			return(EIO);
+		case	0x5:
+			if(!silent) printf("st%d: illegal request\n ", unit); 
+			ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
+								sense->ext.extended.info[13] ;
+			return(EINVAL);
+		case	0x6:
+			if(!silent) printf("st%d: Unit attention.\n ", unit); 
+			ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
+								sense->ext.extended.info[13] ;
+			ch_info_valid[unit] = FALSE;
+			if (ch_data[unit].flags & CH_OPEN) /* TEMP!!!! */
+				return(EIO);
+			else
+				return(ESUCCESS);
+		case	0x7:
+			if(!silent)
+			{
+				printf("st%d: attempted protection violation "
+								, unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(EACCES);
+		case	0x8:
+			if(!silent)
+			{
+				printf("st%d: block wrong state (worm)\n "
+							, unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(EIO);
+		case	0x9:
+			if(!silent) printf("st%d: vendor unique\n",
+				unit); 
+			return(EIO);
+		case	0xa:
+			if(!silent) printf("st%d: copy aborted\n ",
+				unit); 
+			return(EIO);
+		case	0xb:
+			if(!silent) printf("st%d: command aborted\n ",
+				unit); 
+			ch_data[unit].lsterr=(sense->ext.extended.info[12]<<8)|
+								sense->ext.extended.info[13] ;
+			return(EIO);
+		case	0xc:
+			if(!silent)
+			{
+				printf("st%d: search returned\n ", unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(ESUCCESS);
+		case	0xd:
+			if(!silent) printf("st%d: volume overflow\n ",
+				unit); 
+			return(ENOSPC);
+		case	0xe:
+			if(!silent)
+			{
+			 	printf("st%d: verify miscompare\n ", unit); 
+				if(sense->valid)
+				{
+			   		printf("block no. %d (decimal)\n",
+			  		(sense->ext.extended.info[0] <<24)|
+			  		(sense->ext.extended.info[1] <<16)|
+			  		(sense->ext.extended.info[2] <<8)|
+			  		(sense->ext.extended.info[3] ));
+				}
+			 	else
+				{
+			 		printf("\n");
+				}
+			}
+			return(EIO);
+		case	0xf:
+			if(!silent) printf("st%d: unknown error key\n ",
+				unit); 
+			return(EIO);
+		}
+		break;
+	}
+	/***************************************************************\
+	* If it's NOT class 7, just report it.				*
+	\***************************************************************/
+	case 0:
+	case 1:
+	case 2:
+	case 3:
+	case 4:
+	case 5:
+	case 6:
+		{
+			if(!silent) printf("st%d: error class %d code %d\n",
+				unit,
+				sense->error_class,
+				sense->error_code);
+		if(sense->valid)
+			if(!silent) printf("block no. %d (decimal)\n",
+			(sense->ext.unextended.blockhi <<16),
+			+ (sense->ext.unextended.blockmed <<8),
+			+ (sense->ext.unextended.blocklow ));
+		}
+		return(EIO);
+	}
+}
+
+
+