Subject: modified bt742a driver for bt747's
To: None <core@sun-lamp.cs.berkeley.edu>
From: Michael L. VanLoon -- Iowa State University <michaelv@iastate.edu>
List: current-users
Date: 02/18/1994 10:21:08
Sorry it took me so long to finish up this driver, but the demands of
employer, girlfriend, and professors actually expecting me to know
material for exams kept me too busy to squash all the bugs out in a
timely fashion.

Anyway, here is a beta of the new and improved bt742a.c driver for
NetBSD-current.  I'd like for as many people as possible to try it on
as many different BusLogic/BusTek controllers as they can and tell me
where it breaks.  It seems to be working fine on my system with my
BusLogic bt747s.

This is not the file I want incorporated into the current tree,
though, if it works.  I still have a little cosmetic cleaning up to do
on it.  But I would really appreciate feedback on bugs still
remaining.

Since the diff was several K bigger than the actual file, I've just
included the file itself:

     ---------- >8 ---------- snip ---------- 8< ----------
/*
 * Written by Julian Elischer (julian@tfs.com)
 * for TRW Financial Systems for use under the MACH(2.5) operating system.
 *
 * TRW Financial Systems, in accordance with their agreement with Carnegie
 * Mellon University, makes this software available to CMU to distribute
 * or use in any manner that they see fit as long as this message is kept with
 * the software. For this reason TFS also grants any other persons or
 * organisations permission to use or modify this software.
 *
 * TFS supplies this software to be publicly redistributed
 * on the understanding that TFS is not responsible for the correct
 * functioning of this software in any circumstances.
 *
 *	$Id: bt742a.c,v 1.13 1994/01/05 13:38:57 deraadt Exp $
 */

/*
 * BusTech/BusLogic bt742a EISA SCSI card driver
 */

#include "bt.h"

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/user.h>

#define isa_dev isa_device
#define dev_unit id_unit
#define dev_addr id_iobase

#include <machine/pio.h>

#include <scsi/scsi_all.h>
#include <scsi/scsiconf.h>

#include <i386/isa/isa_device.h>


#ifdef DDB
int	Debugger();
#else
#define	Debugger() panic("should call debugger here (bt742a.c)")
#endif	/*!DDB*/


extern int delaycount;	/* from clock setup code */
typedef unsigned long int physaddr;

/*
 * I/O Port Interface
 */

#define	BT_BASE		bt_base[unit]
#define	BT_CTRL_STAT_PORT	(BT_BASE + 0x0)	/* control & status */
#define	BT_CMD_DATA_PORT	(BT_BASE + 0x1)	/* cmds and datas */
#define	BT_INTR_PORT		(BT_BASE + 0x2)	/* Intr. stat */

/*
 * BT_CTRL_STAT bits (write)
 */

#define BT_HRST		0x80	/* Hardware reset */
#define BT_SRST		0x40	/* Software reset */
#define BT_IRST		0x20	/* Interrupt reset */
#define BT_SCRST	0x10	/* SCSI bus reset */

/*
 * BT_CTRL_STAT bits (read)
 */

#define BT_STST		0x80	/* Self test in Progress */
#define BT_DIAGF	0x40	/* Diagnostic Failure */
#define BT_INIT		0x20	/* Mbx Init required */
#define BT_IDLE		0x10	/* Host Adapter Idle */
#define BT_CDF		0x08	/* cmd/data out port full */
#define BT_DF		0x04	/* Data in port full */
#define BT_INVDCMD	0x01	/* Invalid command */

/*
 * BT_CMD_DATA bits (write)
 */

#define	BT_NOP			0x00	/* No operation */
#define BT_MBX_INIT		0x01	/* Mbx initialization */
#define BT_START_SCSI		0x02	/* start scsi command */
#define BT_START_BIOS		0x03	/* start bios command */
#define BT_INQUIRE		0x04	/* Adapter Inquiry */
#define BT_MBO_INTR_EN		0x05	/* Enable MBO available interrupt */
#define BT_SEL_TIMEOUT_SET	0x06	/* set selection time-out */
#define BT_BUS_ON_TIME_SET	0x07	/* set bus-on time */
#define BT_BUS_OFF_TIME_SET	0x08	/* set bus-off time */
#define BT_SPEED_SET		0x09	/* set transfer speed */
#define BT_DEV_GET		0x0a	/* return installed devices */
#define BT_CONF_GET		0x0b	/* return configuration data */
#define BT_TARGET_EN		0x0c	/* enable target mode */
#define BT_SETUP_GET		0x0d	/* return setup data */
#define BT_WRITE_CH2		0x1a	/* write channel 2 buffer */
#define BT_READ_CH2		0x1b	/* read channel 2 buffer */
#define BT_WRITE_FIFO		0x1c	/* write fifo buffer */
#define BT_READ_FIFO		0x1d	/* read fifo buffer */
#define BT_ECHO			0x1e	/* Echo command data */
#define BT_MBX_INIT_EXTENDED	0x81	/* Mbx initialization */
#define BT_INQUIRE_EXTENDED	0x8D	/* Adapter Setup Inquiry */

struct bt_cmd_buf {
	 u_char byte[16];	
};

/*
 * BT_INTR_PORT bits (read)
 */

#define BT_ANY_INTR		0x80	/* Any interrupt */
#define BT_SCRD		0x08	/* SCSI reset detected */
#define BT_HACC		0x04	/* Command complete */
#define BT_MBOA		0x02	/* MBX out empty */
#define BT_MBIF		0x01	/* MBX in full */

/*
 * Mail box defs 
 */

#define BT_MBX_SIZE		32	/* mail box size */
/* #define BT_MBX_SIZE		8	/* mail box size */

struct bt_mbx
{
	struct bt_mbx_out {
		physaddr	ccb_addr;
		unsigned char	dummy[3];
		unsigned char	cmd;
	} mbo [BT_MBX_SIZE];
	struct bt_mbx_in{
		physaddr	ccb_addr;
		unsigned char	btstat;
		unsigned char 	sdstat;
		unsigned char	dummy;
		unsigned char	stat;
	} mbi[BT_MBX_SIZE];
};

/*
 * mbo.cmd values
 */

#define BT_MBO_FREE	0x0	/* MBO entry is free */
#define BT_MBO_START	0x1	/* MBO activate entry */
#define BT_MBO_ABORT	0x2	/* MBO abort entry */

#define BT_MBI_FREE	0x0	/* MBI entry is free */
#define BT_MBI_OK	0x1	/* completed without error */
#define BT_MBI_ABORT	0x2	/* aborted ccb */
#define BT_MBI_UNKNOWN	0x3	/* Tried to abort invalid CCB */
#define BT_MBI_ERROR	0x4	/* Completed with error */

#define	BT_NSEG	32

struct	bt_scat_gath
	{
		unsigned long	seg_len;
		physaddr	seg_addr;
	};

struct bt_ccb {
	unsigned char		opcode;
	unsigned char		:3,data_in:1,data_out:1,:3;
	unsigned char		scsi_cmd_length;
	unsigned char		req_sense_length;
	/*------------------------------------longword boundary */
	unsigned long		data_length;
	/*------------------------------------longword boundary */
	physaddr		data_addr;
	/*------------------------------------longword boundary */
	unsigned char		dummy[2];
	unsigned char		host_stat;
	unsigned char		target_stat;
	/*------------------------------------longword boundary */
	unsigned char		target;
	unsigned char		lun;
	unsigned char 		scsi_cmd[12];	/* 12 bytes (bytes only)*/
	unsigned char		dummy2[1];
	unsigned char		link_id;
	/*------------------------------------4 longword boundary */
	physaddr		link_addr;
	/*------------------------------------longword boundary */
	physaddr		sense_ptr;
	/*------------------------------------longword boundary */
	struct	scsi_sense_data	scsi_sense;
	/*------------------------------------longword boundary */
	struct	bt_scat_gath	scat_gath[BT_NSEG];
	/*------------------------------------longword boundary */
	struct	bt_ccb		*next;
	/*------------------------------------longword boundary */
	struct	scsi_xfer	*xfer;		/* the scsi_xfer for this cmd */
	/*------------------------------------longword boundary */
	struct	bt_mbx_out	*mbx;		/* pointer to mail box */
	/*------------------------------------longword boundary */
	long    delta;	/* difference from previous*/
	struct bt_ccb	*later,*sooner;
	int		flags;
#define	CCB_FREE	0
#define CCB_ACTIVE	1
#define	CCB_ABORTED	2
	unsigned char           dummy3[24];
};

struct	bt_ccb *bt_soonest = (struct bt_ccb *)0;
struct	bt_ccb *bt_latest = (struct bt_ccb *)0;
long int	bt_furthest = 0;	/* longest time in the timeout queue */
/*
 * opcode fields
 */

#define BT_INITIATOR_CCB	0x00	/* SCSI Initiator CCB */
#define BT_TARGET_CCB		0x01	/* SCSI Target CCB */
#define BT_INIT_SCAT_GATH_CCB	0x02	/* SCSI Initiator with scattter gather*/
#define BT_RESET_CCB		0x81	/* SCSI Bus reset */


/*
 * bt_ccb.host_stat values
 */

#define BT_OK		0x00	/* cmd ok */
#define BT_LINK_OK	0x0a	/* Link cmd ok */
#define BT_LINK_IT	0x0b	/* Link cmd ok + int */
#define BT_SEL_TIMEOUT	0x11	/* Selection time out */
#define BT_OVER_UNDER	0x12	/* Data over/under run */
#define BT_BUS_FREE	0x13	/* Bus dropped at unexpected time */
#define BT_INV_BUS	0x14	/* Invalid bus phase/sequence */
#define BT_BAD_MBO	0x15	/* Incorrect MBO cmd */
#define BT_BAD_CCB	0x16	/* Incorrect ccb opcode */
#define BT_BAD_LINK	0x17	/* Not same values of LUN for links */
#define BT_INV_TARGET	0x18	/* Invalid target direction */
#define BT_CCB_DUP	0x19	/* Duplicate CCB received */
#define BT_INV_CCB	0x1a	/* Invalid CCB or segment list */
#define BT_ABORTED	42	/* pseudo value from driver */



struct bt_setup
{
	u_char	sync_neg:1;
	u_char	parity:1;
	u_char	:6;
	u_char	speed;
	u_char	bus_on;
	u_char	bus_off;
	u_char	num_mbx;
	u_char	mbx[4];
	struct
	{
		u_char	offset:4;
		u_char	period:3;
		u_char	valid:1;
	}sync[8];
	u_char	disc_sts;
};

struct	bt_config
{
	u_char	chan;
	u_char	intr;
	u_char	scsi_dev:3;
	u_char	:5;
};

#define INT9	0x01
#define INT10	0x02
#define INT11	0x04
#define INT12	0x08
#define INT14	0x20
#define INT15	0x40

#define EISADMA	0x00
#define CHAN0	0x01
#define CHAN5	0x20
#define CHAN6	0x40
#define CHAN7	0x80


/* #define PHYSTOKV(x)	((x) + KERNBASE) */
#define KVTOPHYS(x)	vtophys(x)

#define PAGESIZ 	NBPG
#define INVALIDATE_CACHE {asm volatile( ".byte	0x0F ;.byte 0x08" ); }

short			bt_base[NBT];		/* base port for each board */
struct	isa_dev		*btinfo[NBT];
struct	bt_ccb		*bt_get_ccb();
int			bt_int[NBT];
int			bt_dma[NBT];
int			bt_scsi_dev[NBT];
int			bt_initialized[NBT];

struct bt_data {  /* we'll malloc memory for these in bt_init() */
        struct bt_mbx bt_mbx;
	struct bt_ccb bt_ccb[BT_MBX_SIZE];
	struct scsi_xfer bt_scsi_xfer;
	int    sleepers;
} *btdata[NBT];

struct bt_ccb_lookup {
        struct bt_ccb *kv_addr;
	physaddr phys_addr;
} bt_ccb_lookup_table[NBT][BT_MBX_SIZE];

struct {  /* mbo and mbi last used */
        u_char mbo;
	u_char mbi;
} bt_last[NBT];

/***********debug values *************/
#define	BT_SHOWCCBS 0x01
#define	BT_SHOWINTS 0x02
#define	BT_SHOWCMDS 0x04
#define	BT_SHOWMISC 0x08
int	bt_debug = 0;

int btprobe(), btattach();
int btintr();

struct	isa_driver	btdriver = { btprobe, btattach, "bt"};

static	int	btunit = 0;

#define bt_abortmbx(mbx) \
	(mbx)->cmd = BT_MBO_ABORT; \
	outb(BT_CMD_DATA_PORT, BT_START_SCSI);
#define bt_startmbx(mbx) \
	(mbx)->cmd = BT_MBO_START; \
	outb(BT_CMD_DATA_PORT, BT_START_SCSI);

int	bt_scsi_cmd();
int	bt_timeout();
void	btminphys();
long int bt_adapter_info();

struct	scsi_switch	bt_switch[NBT];

#define BT_CMD_TIMEOUT_FUDGE 200 /* multiplied to get Secs */
#define BT_RESET_TIMEOUT 1000000 /* */
#define BT_SCSI_TIMEOUT_FUDGE 20 /* divided by for mSecs */


/***********************************************************************\
* bt_cmd(unit,icnt, ocnt,wait, retval, opcode, args)			*
* Activate Adapter command						*
*	icnt:	number of args (outbound bytes written after opcode)	*
*	ocnt:	number of expected returned bytes			*
*	wait:   number of seconds to wait for response			*
*	retval:	buffer where to place returned bytes			*
*	opcode:	opcode BT_NOP, BT_MBX_INIT, BT_START_SCSI ...		*
*	args:	parameters						*
*									*
* Performs an adapter command through the ports. Not to be confused	*
*	with a scsi command, which is read in via the dma		*
* One of the adapter commands tells it to read in a scsi command	*
\***********************************************************************/
bt_cmd(unit,icnt, ocnt, wait,retval, opcode, args)

u_char *retval;
unsigned opcode;
u_char args;
{
	unsigned *ic = &opcode;
	u_char oc;
	register i;
	int	sts;
	struct bt_data *bt = btdata[unit];

	/*******************************************************\
	* multiply the wait argument by a big constant		*
	* zero defaults to 1					*
	\*******************************************************/
	if (!wait) 
		wait = BT_CMD_TIMEOUT_FUDGE * delaycount; 
	else
		wait *= BT_CMD_TIMEOUT_FUDGE * delaycount; 
	/*******************************************************\
	* Wait for the adapter to go idle, unless it's one of	*
	* the commands which don't need this			*
	\*******************************************************/
	if (opcode != BT_MBX_INIT && opcode != BT_START_SCSI)
	{
		i = BT_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec?*/
		while (--i)
		{
			sts = inb(BT_CTRL_STAT_PORT);
			if (sts & BT_IDLE)
			{
				break;
			}
		}
		if (!i)
		{
			printf("bt_cmd: bt742a host not idle(0x%x)\n",sts);
			return(ENXIO);
		}
	}
	/*******************************************************\
	* Now that it is idle, if we expect output, preflush the*
	* queue feeding to us.					*
	\*******************************************************/
	if (ocnt)
	{
		while ((inb(BT_CTRL_STAT_PORT)) & BT_DF)
			inb(BT_CMD_DATA_PORT);
	}
			
	/*******************************************************\
	* Output the command and the number of arguments given	*
	* for each byte, first check the port is empty.		*
	\*******************************************************/
	icnt++;		/* include the command */
	while (icnt--)
	{
		sts = inb(BT_CTRL_STAT_PORT);
		for (i=0; i< wait; i++)
		{
			sts = inb(BT_CTRL_STAT_PORT);
			if (!(sts & BT_CDF))
				break;
		}
		if (i >=  wait)
		{
			printf("bt_cmd: bt742a cmd/data port full\n");
			outb(BT_CTRL_STAT_PORT, BT_SRST); 
			return(ENXIO);
		}
		outb(BT_CMD_DATA_PORT, (u_char)(*ic++));
	}
	/*******************************************************\
	* If we expect input, loop that many times, each time,	*
	* looking for the data register to have valid data	*
	\*******************************************************/
	while (ocnt--)
	{
		sts = inb(BT_CTRL_STAT_PORT);
		for (i=0; i< wait; i++)
		{
			sts = inb(BT_CTRL_STAT_PORT);
			if (sts  & BT_DF)
				break;
		}
		if (i >=  wait)
		{
			printf("bt_cmd: bt742a cmd/data port empty %d\n",ocnt);
			return(ENXIO);
		}
		oc = inb(BT_CMD_DATA_PORT);
		if (retval)
			*retval++ = oc;
	}
	/*******************************************************\
	* Wait for the board to report a finised instruction	*
	\*******************************************************/
	i=BT_CMD_TIMEOUT_FUDGE * delaycount;	/* 1 sec? */
	while (--i)
	{
		sts = inb(BT_INTR_PORT);
		if (sts & BT_HACC)
		{
			break;
		}
	}
	if (!i)
	{
		printf("bt_cmd: bt742a host not finished(0x%x)\n",sts);
		return(ENXIO);
	}
	outb(BT_CTRL_STAT_PORT, BT_IRST);
	return(0);
}

/*******************************************************\
* Check if the device can be found at the port given	*
* and if so, set it up ready for further work		*
* as an argument, takes the isa_dev structure from	*
* autoconf.c						*
\*******************************************************/

btprobe(dev)
struct isa_dev *dev;
{
	/***********************************************\
	* find unit and check we have that many defined	*
	\***********************************************/
	int     unit = btunit;
	struct bt_data *bt = btdata[unit];

	dev->dev_unit = unit;
	bt_base[unit] = dev->dev_addr;
	if (unit >= NBT) 
	{
		printf("bt: unit number (%d) too high\n",unit);
		return(0);
	}
	/***********************************************\
	* Try initialise a unit at this location	*
	* sets up dma and bus speed, loads bt_int[unit]*
	\***********************************************/
	if (bt_init(unit) != 0)
	{
		return(0);
	}

	/***********************************************\
	* If it's there, put in it's interrupt vectors	*
	\***********************************************/
        dev->id_irq = (1 << bt_int[unit]);
        dev->id_drq = bt_dma[unit];

	btunit++;
	return(8);
}

/***********************************************\
* Attach all the sub-devices we can find	*
\***********************************************/
btattach(dev)
struct	isa_dev	*dev;
{
	static int firsttime;
	static int firstswitch[NBT];
	int masunit = dev->id_masunit;
	int r;

	if (!firstswitch[masunit]) {
		firstswitch[masunit] = 1;
		bt_switch[masunit].name = "bt";
		bt_switch[masunit].scsi_cmd = bt_scsi_cmd;
		bt_switch[masunit].scsi_minphys = btminphys;
		bt_switch[masunit].open_target_lu = 0;
		bt_switch[masunit].close_target_lu = 0;
		bt_switch[masunit].adapter_info = bt_adapter_info;
		for (r = 0; r < 8; r++) {
			bt_switch[masunit].empty[r] = 0;
			bt_switch[masunit].used[r] = 0;
			bt_switch[masunit].printed[r] = 0;
		}
	}
	r = scsi_attach(masunit, bt_scsi_dev[masunit], &bt_switch[masunit],
		&dev->id_physid, &dev->id_unit, dev->id_flags);

	/* only one for all boards */
	if (firsttime==0) {
		firsttime = 1;
		bt_timeout(0);
	}
	return r;
}

/***********************************************\
* Return some information to the caller about   *
* the adapter and it's capabilities             *
\***********************************************/
long bt_adapter_info(unit)
        int unit;
{
	return(2);	/* 2 outstanding requests at a time per device */
}


/***********************************************\
* Catch an interrupt from the adaptor		*
\***********************************************/
btintr(unit)
{
	struct bt_ccb *ccb;
	unsigned char stat;
	register int i, j;
	u_char found_one = 0, done = 0;
	struct bt_data *bt = btdata[unit];

	if ((scsi_debug & PRINTROUTINES) || bt_debug)
		printf("btintr ");
	/***********************************************\
	* First acknowlege the interrupt, Then if it's	*
	* not telling about a completed operation	*
	* just return. 					*
	\***********************************************/
	stat = inb(BT_INTR_PORT);
	outb(BT_CTRL_STAT_PORT, BT_IRST);
	if ((scsi_debug & TRACEINTERRUPTS) || bt_debug)
		printf("int = 0x%x ",stat);
	if (! (stat & BT_MBIF))
		return 1;
	if (scsi_debug & TRACEINTERRUPTS)
		printf("mbxi ");

	/***********************************************\
	* If it IS then process the competed operation	*
	\***********************************************/
	for (i = bt_last[unit].mbi; !done && (i < BT_MBX_SIZE); i++) {
		if (bt->bt_mbx.mbi[i].stat != BT_MBI_FREE) {
		        found_one++;
		        for (j = BT_MBX_SIZE - 1; j >= 0; j--)
			        if (bt_ccb_lookup_table[unit][j].phys_addr ==
				    bt->bt_mbx.mbi[i].ccb_addr) {
				        ccb = bt_ccb_lookup_table[unit][j].
					              kv_addr;
					break;
				}
			if ((bt_debug & BT_SHOWCCBS) && ccb)
				printf("<int ccb(%x(%x))> ",ccb,KVTOPHYS(ccb));
			if ((stat =  bt->bt_mbx.mbi[i].stat) != BT_MBI_OK) {
				switch(stat) {
				case	BT_MBI_ABORT:
					if (bt_debug & BT_SHOWMISC)
						printf("abort ");
					ccb->host_stat = BT_ABORTED;
					break;
				case	BT_MBI_UNKNOWN:
					ccb = (struct bt_ccb *)0;
					if (bt_debug & BT_SHOWMISC)
					      printf("unknown ccb for abort");
					break;
				case	BT_MBI_ERROR:
					break;
				default:
					printf("Impossible mbxi status %d, in mbx at 0x%x (0x%x)\n", stat, &bt->bt_mbx.mbi[i], KVTOPHYS(&bt->bt_mbx.mbi[i]));
					Debugger();
				}
				if ((bt_debug & BT_SHOWCMDS) && ccb) {
					u_char	*cp;
					cp = ccb->scsi_cmd;
					printf("op=%x %x %x %x %x %x\n", 
					       cp[0], cp[1], cp[2],
					       cp[3], cp[4], cp[5]);
					printf("stat %x for mbi[%d]\n",
					       bt->bt_mbx.mbi[i].stat, i);
					printf("addr = 0x%x\n", ccb);
				}
			}
			if (ccb) {
				bt_remove_timeout(ccb);
				bt_done(unit, ccb);
			}
			bt->bt_mbx.mbi[i].stat = BT_MBI_FREE;
		} else {  /* free mailbox -- done if following a used mbi */
		        if (found_one)
			        done++;
		}  /* if/else */
	}  /* for (i) */
	if (done) {
	        bt_last[unit].mbi = i % BT_MBX_SIZE;
		return(1);
	}
	for (i = 0; !done && (i < bt_last[unit].mbi); i++) {
		if (bt->bt_mbx.mbi[i].stat != BT_MBI_FREE) {
		        found_one++;
		        for (j = BT_MBX_SIZE - 1; j >= 0; j--)
			        if (bt_ccb_lookup_table[unit][j].phys_addr ==
				    bt->bt_mbx.mbi[i].ccb_addr) {
				        ccb = bt_ccb_lookup_table[unit][j].
					              kv_addr;
					break;
				}
			if ((bt_debug & BT_SHOWCCBS) && ccb)
				printf("<int ccb(%x(%x))> ",ccb,KVTOPHYS(ccb));
			if ((stat =  bt->bt_mbx.mbi[i].stat) != BT_MBI_OK) {
				switch(stat) {
				case	BT_MBI_ABORT:
					if (bt_debug & BT_SHOWMISC)
						printf("abort ");
					ccb->host_stat = BT_ABORTED;
					break;
				case	BT_MBI_UNKNOWN:
					ccb = (struct bt_ccb *)0;
					if (bt_debug & BT_SHOWMISC)
					      printf("unknown ccb for abort");
					break;
				case	BT_MBI_ERROR:
					break;
				default:
					printf("Impossible mbxi status %d, in mbx at 0x%x (0x%x)\n", stat, &bt->bt_mbx.mbi[i], KVTOPHYS(&bt->bt_mbx.mbi[i]));
					Debugger();
				}
				if ((bt_debug & BT_SHOWCMDS) && ccb) {
					u_char	*cp;
					cp = ccb->scsi_cmd;
					printf("op=%x %x %x %x %x %x\n", 
					       cp[0], cp[1], cp[2],
					       cp[3], cp[4], cp[5]);
					printf("stat %x for mbi[%d]\n",
					       bt->bt_mbx.mbi[i].stat, i);
					printf("addr = 0x%x\n", ccb);
				}
			}
			if (ccb) {
				bt_remove_timeout(ccb);
				bt_done(unit, ccb);
			}
			bt->bt_mbx.mbi[i].stat = BT_MBI_FREE;
		} else {  /* free mailbox -- done if following a used mbi */
		        if (found_one)
			        done++;
		}  /* if/else */
	}  /* for (i) */
	bt_last[unit].mbi = i % BT_MBX_SIZE;
	return(1);
}

/***********************************************\
* A ccb (and hence a mbx-out is put onto the 	*
* free list.					*
\***********************************************/
bt_free_ccb(unit, ccb, flags)
struct bt_ccb *ccb;
{
	unsigned int opri;
	struct bt_data *bt = btdata[unit];
	
	if (scsi_debug & PRINTROUTINES)
		printf("ccb%d(0x%x)> ", unit, flags);
	if (!(flags & SCSI_NOMASK)) 
	  	opri = splbio();

	ccb->flags = CCB_FREE;
	/***********************************************\
	* If there were none, wake abybody waiting for	*
	* one to come free, starting with queued entries*
	\***********************************************/
	if (bt->sleepers) {
	        bt->sleepers = 0;
		wakeup((caddr_t)&bt->sleepers);
	}
	if (!(flags & SCSI_NOMASK)) 
		splx(opri);
}

/***********************************************\
* Get a free ccb (and hence mbox-out entry)	*
\***********************************************/
struct bt_ccb *
bt_get_ccb(unit, flags)
{
	unsigned int opri;
	struct bt_ccb *rc = NULL;
	struct bt_data *bt = btdata[unit];
	int next_mbx = bt_last[unit].mbo;

	if (scsi_debug & PRINTROUTINES)
		printf("<ccb%d(0x%x) ", unit, flags);
	if (!(flags & SCSI_NOMASK)) 
	  	opri = splbio();
	/***********************************************\
	* If we can and have to, sleep waiting for one	*
	* to come free					*
	\***********************************************/
	while (!(bt->bt_ccb[next_mbx].flags == CCB_FREE) &&
	       !(flags & SCSI_NOSLEEP)) {
	        bt->sleepers = 1;
	        sleep((caddr_t)&bt->sleepers, PRIBIO);
	}
	if (bt->bt_ccb[next_mbx].flags == CCB_FREE) {
	        rc = &bt->bt_ccb[next_mbx];
		bt_last[unit].mbo = (bt_last[unit].mbo + 1) % BT_MBX_SIZE;
		rc->flags = CCB_ACTIVE;
	}
	if (!(flags & SCSI_NOMASK)) 
		splx(opri);
	return(rc);
}
		

/***********************************************\
* We have a ccb which has been processed by the	*
* adaptor, now we look to see how the operation	*
* went. Wake up the owner if waiting		*
\***********************************************/
bt_done(unit,ccb)
struct bt_ccb *ccb;
{
	struct	scsi_sense_data *s1,*s2;
	struct	scsi_xfer *xs = ccb->xfer;
	struct  bt_data *bt = btdata[unit];

	if (scsi_debug & (PRINTROUTINES | TRACEINTERRUPTS))
		printf("bt_done ");
	/***********************************************\
	* Otherwise, put the results of the operation	*
	* into the xfer and call whoever started it	*
	\***********************************************/
	if (  	(	ccb->host_stat != BT_OK 
			|| ccb->target_stat != SCSI_OK)
	      && (!(xs->flags & SCSI_ERR_OK)))
	{

		s1 = &(ccb->scsi_sense);
		s2 = &(xs->sense);

		if (ccb->host_stat)
		{
			switch(ccb->host_stat)
			{
			case	BT_ABORTED:	/* No response */
			case	BT_SEL_TIMEOUT:	/* No response */
				if (bt_debug & BT_SHOWMISC)
				{
					printf("timeout reported back\n");
				}
				xs->error = XS_TIMEOUT;
				break;
			default:	/* Other scsi protocol messes */
				xs->error = XS_DRIVER_STUFFUP;
				if (bt_debug & BT_SHOWMISC)
				{
					printf("unexpected host_stat: %x\n",
						ccb->host_stat);
				}
			}

		}
		else
		{
			switch(ccb->target_stat)
			{
			case 0x02:
				/* structure copy!!!!!*/
				*s2=*s1;
				xs->error = XS_SENSE;
				break;
			case 0x08:
				xs->error = XS_BUSY;
				break;
			default:
				if (bt_debug & BT_SHOWMISC)
				{
					printf("unexpected target_stat: %x\n",
						ccb->target_stat);
				}
				xs->error = XS_DRIVER_STUFFUP;
			}
		}
	}
	else		/* All went correctly  OR errors expected */
	{
		xs->resid = 0;
	}
	xs->flags |= ITSDONE;
	bt_free_ccb(unit, ccb, xs->flags);
	if (xs->when_done)
		(*(xs->when_done))(xs->done_arg,xs->done_arg2);
}

/***********************************************\
* Start the board, ready for normal operation	*
\***********************************************/
bt_init(unit)
int	unit;
{
	unsigned char ad[4];
	volatile int i,sts;
	struct	bt_config conf;
	struct  bt_data *bt;

	/***********************************************\
	* reset board, If it doesn't respond, assume 	*
	* that it's not there.. good for the probe	*
	\***********************************************/

	outb(BT_CTRL_STAT_PORT, BT_HRST|BT_SRST);

	for (i=0; i < BT_RESET_TIMEOUT; i++)
	{
		sts = inb(BT_CTRL_STAT_PORT) ;
		if ( sts == (BT_IDLE | BT_INIT))
			break;
	}
	if (i >= BT_RESET_TIMEOUT)
	{
		if (bt_debug & BT_SHOWMISC)
			printf("bt_init: No answer from bt742a board\n");
		return(ENXIO);
	}

	/***********************************************\
	* Assume we have a board at this stage		*
	* setup dma channel from jumpers and save int	*
	* level						*
	\***********************************************/

	DELAY(200);

	bt_cmd(unit,0, sizeof(conf), 0 ,&conf, BT_CONF_GET);
	switch(conf.chan) {
	case EISADMA:
		bt_dma[unit] = -1;
		break;
	case CHAN0:
		outb(0x0b, 0x0c);
		outb(0x0a, 0x00);
		bt_dma[unit] = 0;
		break;
	case CHAN5:
		outb(0xd6, 0xc1);
		outb(0xd4, 0x01);
		bt_dma[unit] = 5;
		break;
	case CHAN6:
		outb(0xd6, 0xc2);
		outb(0xd4, 0x02);
		bt_dma[unit] = 6;
		break;
	case CHAN7:
		outb(0xd6, 0xc3);
		outb(0xd4, 0x03);
		bt_dma[unit] = 7;
		break;
	default:
		printf("illegal dma setting %x\n",conf.chan);
		return(EIO);
	}
	switch(conf.intr) {
	case INT9:
		bt_int[unit] = 9;
		break;
	case INT10:
		bt_int[unit] = 10;
		break;
	case INT11:
		bt_int[unit] = 11;
		break;
	case INT12:
		bt_int[unit] = 12;
		break;
	case INT14:
		bt_int[unit] = 14;
		break;
	case INT15:
		bt_int[unit] = 15;
		break;
	default:
		printf("illegal int setting\n");
		return(EIO);
	}
	/* who are we on the scsi bus */
	bt_scsi_dev[unit] = conf.scsi_dev;

        printf("bt%d: mbx %d * %d, ccb %d * %d, xs %d, bt %d bytes\n", unit,
	       BT_MBX_SIZE, sizeof(struct bt_mbx),
	       BT_MBX_SIZE, sizeof(struct bt_ccb),
	       sizeof(struct scsi_xfer), sizeof(struct bt_data));
	bt = malloc(sizeof(struct bt_data), M_DEVBUF, M_NOWAIT);
	if (!bt) {
	        printf("bt%d: cannot malloc buffers\n", unit);
		return(0);
	}
	/* if (bt_debug) */
	        printf("bt%d: buffer allocated at 0x%x (0x%x)\n",
		       unit, bt, KVTOPHYS(bt));
	bzero(bt, sizeof(struct bt_data));
	btdata[unit] = bt;
	 
	/***********************************************\
	* Initialize mail box 				*
	\***********************************************/

	*((physaddr *)ad) = KVTOPHYS(&bt->bt_mbx);
	if (1 /*bt_debug*/) {
	        printf("bt%d: mailbox struct at 0x%x (0x%x)\n",
		       unit, &bt->bt_mbx, *(physaddr*)ad);
	        printf("bt%d: ccb struct at 0x%x (0x%x)\n",
		       unit, bt->bt_ccb, KVTOPHYS(bt->bt_ccb));
	        printf("bt%d: xs struct at 0x%x (0x%x)\n",
		       unit, &bt->bt_scsi_xfer, KVTOPHYS(&bt->bt_scsi_xfer));
	        printf("bt%d: sleepers at 0x%x (0x%x)\n",
		       unit, &bt->sleepers, KVTOPHYS(&bt->sleepers));
	}
	bt_cmd(unit, 5, 0, 0, 0, BT_MBX_INIT_EXTENDED
		, BT_MBX_SIZE
		, ad[0]
		, ad[1]
		, ad[2] 
		, ad[3]);

	/***********************************************\
	* link the ccb's with the mbox-out entries and	*
	* into a free-list				*
	\***********************************************/
	bt_last[unit].mbo = bt_last[unit].mbi = 0;
	for (i = 0; i < (BT_MBX_SIZE - 1); i++) {
		bt->bt_ccb[i].next = &bt->bt_ccb[i+1];
		bt->bt_ccb[i].flags = CCB_FREE;
		bt->bt_ccb[i].mbx = &bt->bt_mbx.mbo[i];
		bt->bt_mbx.mbo[i].ccb_addr = KVTOPHYS(&bt->bt_ccb[i]) ;
		bt_ccb_lookup_table[unit][i].kv_addr = &bt->bt_ccb[i];
		bt_ccb_lookup_table[unit][i].phys_addr =
		        bt->bt_mbx.mbo[i].ccb_addr;
	}
	bt->bt_ccb[i].next = &bt->bt_ccb[0];  /* loop around to first ccb */
	bt->bt_ccb[i].flags = CCB_FREE;
	bt->bt_ccb[i].mbx = &bt->bt_mbx.mbo[i];
	bt->bt_mbx.mbo[i].ccb_addr = KVTOPHYS(&bt->bt_ccb[i]) ;
	bt_ccb_lookup_table[unit][i].kv_addr = &bt->bt_ccb[i];
	bt_ccb_lookup_table[unit][i].phys_addr =
	        bt->bt_mbx.mbo[i].ccb_addr;

	/***********************************************\
	* Note that we are going and return (to probe)	*
	\***********************************************/
	bt_initialized[unit]++;
	return(0);
}


#ifndef	min
#define min(x,y) (x < y ? x : y)
#endif	min


void btminphys(bp)
struct	buf *bp;
{
#ifdef	MACH
#if	!defined(OSF)
	bp->b_flags |= B_NPAGES;		/* can support scat/gather */
#endif	/* defined(OSF) */
#endif	MACH
	if (bp->b_bcount > ((BT_NSEG-1) * PAGESIZ))
	{
		bp->b_bcount = ((BT_NSEG-1) * PAGESIZ);
	}
}
	
/***********************************************\
* start a scsi operation given the command and	*
* the data address. Also needs the unit, target	*
* and lu					*
\***********************************************/
int	bt_scsi_cmd(xs)
struct scsi_xfer *xs;
{
	struct	scsi_sense_data *s1,*s2;
	struct bt_ccb *ccb;
	struct bt_scat_gath *sg;
	int	seg;	/* scatter gather seg being worked on */
	int i	= 0;
	int rc	=  0;
	int	thiskv;
	physaddr	thisphys,nextphys;
	int	unit =xs->adapter;
	int	bytes_this_seg,bytes_this_page,datalen,flags;
	struct	iovec	*iovp;
	struct  bt_data *bt = btdata[unit];

	if (scsi_debug & PRINTROUTINES)
		printf("bt_scsi_cmd ");
	/***********************************************\
	* get a ccb (mbox-out) to use. If the transfer	*
	* is from a buf (possibly from interrupt time)	*
	* then we can't allow it to sleep		*
	\***********************************************/
	flags = xs->flags;
	if (xs->bp)
	        flags |= (SCSI_NOSLEEP); /* just to be sure */
	if (flags & ITSDONE) {
		printf("Already done?");
		xs->flags &= ~ITSDONE;
	}
	if (!(flags & INUSE)) {
		printf("Not in use?");
		xs->flags |= INUSE;
	}
	if (!(ccb = bt_get_ccb(unit, flags))) {
		xs->error = XS_DRIVER_STUFFUP;
		return(TRY_AGAIN_LATER);
	}

	if (bt_debug & BT_SHOWCCBS)
	        printf("<start ccb(%x(%x))>", ccb, KVTOPHYS(ccb));
	if (ccb->mbx->cmd != BT_MBO_FREE)
		printf("MBO not free (%x(%x))\n",
		       ccb->mbx, KVTOPHYS(ccb->mbx));

	/***********************************************\
	* Put all the arguments for the xfer in the ccb	*
	\***********************************************/
	ccb->xfer		=	xs;
	if (flags & SCSI_RESET) {
		ccb->opcode	=	BT_RESET_CCB;
	} else {
		/* can't use S/G if zero length */
		ccb->opcode	=	(xs->datalen ? BT_INIT_SCAT_GATH_CCB
					 : BT_INITIATOR_CCB);
	}
	ccb->target		=	xs->targ;;
	ccb->data_out		=	0;
	ccb->data_in		=	0;
	ccb->lun		=	xs->lu;
	ccb->scsi_cmd_length	=	xs->cmdlen;
	ccb->sense_ptr		=	KVTOPHYS(&(ccb->scsi_sense));
	ccb->req_sense_length	=	sizeof(ccb->scsi_sense);

	if ((xs->datalen) && (!(flags & SCSI_RESET)))
	{ /* can use S/G only if not zero length */
		ccb->data_addr = KVTOPHYS(ccb->scat_gath);
		sg		=	ccb->scat_gath ;
		seg 		=	0;
		if (flags & SCSI_DATA_UIO)
		{
			iovp = ((struct uio *)xs->data)->uio_iov;
			datalen = ((struct uio *)xs->data)->uio_iovcnt;
			xs->datalen = 0;
			while (datalen && (seg < BT_NSEG))
			{
				sg->seg_addr = (physaddr)iovp->iov_base;
				xs->datalen += sg->seg_len = iovp->iov_len;	
				if (scsi_debug & SHOWSCATGATH)
					printf("(0x%x@0x%x)",
					       iovp->iov_len,
					       iovp->iov_base);
				sg++;
				iovp++;
				seg++;
				datalen--;
			}
		}
		else
		{
			/***********************************************\
			* Set up the scatter gather block		*
			\***********************************************/
		
			if (scsi_debug & SHOWSCATGATH)
				printf("%d @0x%x:- ",xs->datalen,xs->data);
			datalen		=	xs->datalen;
			thiskv		=	(int)xs->data;
			thisphys	=	KVTOPHYS(thiskv);
		
			while ((datalen) && (seg < BT_NSEG))
			{
				bytes_this_seg	= 0;
	
				/* put in the base address */
				sg->seg_addr = thisphys;
		
				if (scsi_debug & SHOWSCATGATH)
					printf("0x%x",thisphys);
	
				/* do it at least once */
				nextphys = thisphys;	
				while ((datalen) && (thisphys == nextphys))
				/*********************************************\
				* This page is contiguous (physically) with   *
				* the the last, just extend the length	      *
				\*********************************************/
				{
					/* how far to the end of the page */
					nextphys= (thisphys & (~(PAGESIZ - 1)))
								+ PAGESIZ;
					bytes_this_page	= nextphys - thisphys;
					/**** or the data ****/
					bytes_this_page	= min(bytes_this_page
								,datalen);
					bytes_this_seg	+= bytes_this_page;
					datalen		-= bytes_this_page;
		
					/* get more ready for the next page */
					thiskv	= (thiskv & (~(PAGESIZ - 1)))
								+ PAGESIZ;
					if (datalen)
						thisphys = KVTOPHYS(thiskv);
				}
				/********************************************\
				* next page isn't contiguous, finish the seg *
				\********************************************/
				if (scsi_debug & SHOWSCATGATH)
					printf("(0x%x)",bytes_this_seg);
				sg->seg_len = bytes_this_seg;	
				sg++;
				seg++;
			}
		} /*end of iov/kv decision */
		ccb->data_length = seg * sizeof(struct bt_scat_gath);
		if (scsi_debug & SHOWSCATGATH)
			printf("\n");
		if (datalen)
		{ /* there's still data, must have run out of segs! */
			printf("bt_scsi_cmd%d: more than %d DMA segs\n",
				unit,BT_NSEG);
			xs->error = XS_DRIVER_STUFFUP;
			bt_free_ccb(unit, ccb, flags);
			return(HAD_ERROR);
		}
	}
	else
	{	/* No data xfer, use non S/G values */
		ccb->data_addr = (physaddr)0;
		ccb->data_length = 0;
	}
	ccb->link_id = 0;
	ccb->link_addr = (physaddr)0;
	/***********************************************\
	* Put the scsi command in the ccb and start it	*
	\***********************************************/
	if (!(flags & SCSI_RESET))
	{
		bcopy(xs->cmd, ccb->scsi_cmd, ccb->scsi_cmd_length);
	}
	if (scsi_debug & SHOWCOMMANDS)
	{
		u_char	*b = ccb->scsi_cmd;
		if (!(flags & SCSI_RESET))
		{
			int i = 0;
			printf("bt%d:%d:%d-"
				,unit
				,ccb->target
				,ccb->lun);
			while (i < ccb->scsi_cmd_length )
			{
				if (i) printf(",");
				printf("%x",b[i++]);
			}
			printf("-\n");
		}
		else
		{
			printf("bt%d:%d:%d-RESET- " 
				,unit 
				,ccb->target
				,ccb->lun
			);
		}
	}
	bt_startmbx(ccb->mbx);
	/***********************************************\
	* Usually return SUCCESSFULLY QUEUED		*
	\***********************************************/
	if (scsi_debug & TRACEINTERRUPTS)
		printf("cmd_sent ");
	if (!(flags & SCSI_NOMASK)) {
		bt_add_timeout(ccb, xs->timeout);
		return(SUCCESSFULLY_QUEUED);
	}
	/***********************************************\
	* If we can't use interrupts, poll on completion*
	\***********************************************/
	{
		int done = 0;
		int count = delaycount * xs->timeout / BT_SCSI_TIMEOUT_FUDGE;

		if (scsi_debug & TRACEINTERRUPTS)
			printf("wait ");
		while ((!done) && count) {
			i = 0;
			while (!done && i < BT_MBX_SIZE)
			{
			        struct bt_ccb *mbx_ccb = NULL;
				int j;

			        for (j = BT_MBX_SIZE - 1; j >= 0; j--)
				        if (bt_ccb_lookup_table[unit][j].
					    phys_addr ==
					    bt->bt_mbx.mbi[i].ccb_addr) {
					        mbx_ccb = bt_ccb_lookup_table
						        [unit][j].kv_addr;
						break;
					}
				if ((bt->bt_mbx.mbi[i].stat != BT_MBI_FREE )
				    && mbx_ccb == ccb) {
					bt->bt_mbx.mbi[i].stat = BT_MBI_FREE;
					bt_done(unit, ccb);
					done++;
				}
				i++;
			}
			count--;
		}
		if (!count) {
			if (!(xs->flags & SCSI_SILENT))
				printf("cmd fail\n");
			bt_abortmbx(ccb->mbx);
			count = delaycount * 2000 / BT_SCSI_TIMEOUT_FUDGE;
			while (!done && count) {
				i = 0;
				while (!done && i < BT_MBX_SIZE) {
				        struct bt_ccb *mbx_ccb = NULL;
					int j;

				        for (j = BT_MBX_SIZE - 1; j >= 0; j--)
					    if (bt_ccb_lookup_table
						[unit][j].phys_addr ==
						bt->bt_mbx.mbi[i].ccb_addr){
					            mbx_ccb = bt_ccb_lookup_table[unit][j].kv_addr;
						    break;
					    }
					if ((bt->bt_mbx.mbi[i].stat !=
					     BT_MBI_FREE) && mbx_ccb == ccb) {
						bt->bt_mbx.mbi[i].stat =
						        BT_MBI_FREE;
						bt_done(unit, ccb);
						done++;
					}
					i++;
				}
				count--;
			}
			if (!count) {
				printf("abort failed in wait\n");
				ccb->mbx->cmd = BT_MBO_FREE;
			}
			bt_free_ccb(unit, ccb, flags);
			btintr(unit);
			xs->error = XS_DRIVER_STUFFUP;
			return(HAD_ERROR);
		}
		btintr(unit);
		if (xs->error)
		        return(HAD_ERROR);
		return(COMPLETE);
	} 
}

/*
 *               +----------+     +----------+     +----------+
 * bt_soonest--->|    later |---->|     later|---->|     later|--->0
 *               | [Delta]  |     | [Delta]  |     | [Delta]  |
 *        0<-----|sooner    |<----|sooner    |<----|sooner    |<----bt_latest
 *               +----------+     +----------+     +----------+
 *
 *     bt_furthest = sum(Delta[1..n])
 */
bt_add_timeout(ccb, time)
struct	bt_ccb	*ccb;
int	time;
{
	int	timeprev;
	struct bt_ccb *prev;
	int	s = splbio();

	if (prev = bt_latest) {  /* yes, an assign */
		timeprev = bt_furthest;
	} else {
		timeprev = 0;
	}
	while (prev && (timeprev > time)) {
		timeprev -= prev->delta;
		prev = prev->sooner;
	}
	if (prev) {
		ccb->delta = time - timeprev;
		if (ccb->later = prev->later) {  /* yes an assign */
			ccb->later->sooner = ccb;
			ccb->later->delta -= ccb->delta;
		} else {
			bt_furthest = time;
			bt_latest = ccb;
		}
		ccb->sooner = prev;
		prev->later = ccb;
	} else {
		if (ccb->later = bt_soonest) {  /* yes, an assign*/
			ccb->later->sooner = ccb;
			ccb->later->delta -= time;
		} else {
			bt_furthest = time;
			bt_latest = ccb;
		}
		ccb->delta = time;
		ccb->sooner = (struct bt_ccb *)0;
		bt_soonest = ccb;
	}
	splx(s);
}

bt_remove_timeout(ccb)
struct	bt_ccb	*ccb;
{
	int	s = splbio();

	if (ccb->sooner) {
		ccb->sooner->later = ccb->later;
	} else {
		bt_soonest = ccb->later;
	}
	if (ccb->later) {
		ccb->later->sooner = ccb->sooner;
		ccb->later->delta += ccb->delta;
	} else {
		bt_latest = ccb->sooner;
		bt_furthest -= ccb->delta;
	}
	ccb->sooner = ccb->later = (struct bt_ccb *)0;
	splx(s);
}


extern int 	hz;
/* #define ONETICK 500 /* milliseconds */
#define ONETICK 250 /* milliseconds */
#define SLEEPTIME ((hz * 1000) / ONETICK)
bt_timeout(arg)
int	arg;
{
	struct  bt_ccb  *ccb;
	int	unit;
	int	s	= splbio();

	while (ccb = bt_soonest) {
		if (ccb->delta <= ONETICK) {
		        /*******************************************\
		        * It has timed out, we need to do some work *
		        \*******************************************/
			unit = ccb->xfer->adapter;
			btintr(unit);
			printf("bt%d:%d device timed out\n",unit
					,ccb->xfer->targ);
			if (bt_debug & BT_SHOWCCBS)
				tfs_print_active_ccbs();

			/***************************************\
			* Unlink it from the queue		*
			\***************************************/
			bt_remove_timeout(ccb);

			/***************************************\
			* If The ccb's mbx is not free, then	*
			* the board has gone south		*
			\***************************************/
			if (ccb->mbx->cmd != BT_MBO_FREE) {
				printf("bt%d not taking commands!\n", unit);
				printf("bt: ccb->mbx->cmd = %x\n",
				       ccb->mbx->cmd);
				tfs_print_ccb(ccb);
				Debugger();
			}
			/***************************************\
			* If it has been through before, then	*
			* a previous abort has failed, don't	*
			* try abort again			*
			\***************************************/
			if (ccb->flags == CCB_ABORTED) {  /* abort timed out */
				printf("AGAIN");
				ccb->xfer->retries = 0; /* I MEAN IT ! */
				ccb->host_stat = BT_ABORTED;
				bt_done(unit,ccb);
			} else {  /* abort the operation that has timed out */
				printf("abort mbx\n");
				bt_abortmbx(ccb->mbx);
					/* 2 secs for the abort */
				bt_add_timeout(ccb,2000 + ONETICK);
				ccb->flags = CCB_ABORTED;
			}
		} else {
		        /***********************************************\
			* It has not timed out, adjust and leave	*
			\***********************************************/
			ccb->delta -= ONETICK;
			bt_furthest -= ONETICK;
			break;
		}
	}
	splx(s);
	timeout((timeout_t)bt_timeout,(caddr_t)arg,SLEEPTIME);
}

tfs_print_ccb(ccb)
struct	bt_ccb *ccb;
{
	printf("ccb:%x op:%x cmdlen:%d senlen:%d\n"
		,ccb
		,ccb->opcode
		,ccb->scsi_cmd_length
		,ccb->req_sense_length);
	printf("	datlen:%d hstat:%x tstat:%x delta:%d flags:%x\n"
		,ccb->data_length
		,ccb->host_stat
		,ccb->target_stat
		,ccb->delta
		,ccb->flags);
}

tfs_print_active_ccbs()
{
	struct	bt_ccb *ccb;
	ccb = bt_soonest;

	while (ccb)
	{
		tfs_print_ccb(ccb);
		ccb = ccb->later;
	}
	printf("Furthest = %d\n",bt_furthest);
}
     ---------- >8 ---------- snip ---------- 8< ----------

------------------------------------------------------------------------------
    Michael L. VanLoon  --  michaelv@iastate.edu  --  gg.mlv@isumvs.bitnet
 Iowa State University of Science and Technology -- The way cool place to be!
   Project Vincent Systems Staff, Iowa State University Computation Center
------------------------------------------------------------------------------



------------------------------------------------------------------------------