/*
 * Adaptech 1542 SCSI driver for 386bsd
 *
 * Pace Willisson     pace@blitz.com    March 28, 1992
 *
 * Placed in the public domain with NO WARRANTIES, not even the
 * implied warranties for MERCHANTABILITY or FITNESS FOR A 
 * PARTICULAR PURPOSE.
 *
 *
 * This is a very early version - use with care.
 *
 * Here is the config info:
 *
 * controller	as0	at isa? port 0x330 bio irq 11 drq 5 vector asintr
 * disk		dk6	at as0 drive 0 
 *
 * Also, don't forget to update sys/i386/conf/files.i386.
 *
 * So far, used with:
 *
 *   CDC WREN 5 600 Megabyte magnetic disk
 *   EXABYTE EXB-8200 8mm tape drive
 *   SONY CDU-541 cdrom
 *
 * The the tape stuff still needs a lot of working concerning
 * file marks, end of tape handling and rewinding, but I have
 * extracted tar tapes to a file system mounted on the CDC disk.
 *
 * minor number bits:
 *
 *      7  6  5  4  3  2  1  0
 *                     +-----+  partition number
 *            +-----+           scsi target number
 *      +--+                    unused (should be 0)
 *
 * For tape drives, set the partition number to 0 for regular,
 * 1 for no rewind.
 *
 * Only supports LUN 0.
 *
 * To use with a read-write disk, first use diskpart to create
 * a disktab entry, then use disklabel.  Since I don't have
 * the boot programs done yet, I faked it with:
 *
 *		# cd /usr/mdec
 *		# cp wdboot asboot
 *		# cp bootwd bootas
 *
 * Now you can run disklabel, newfs, etc.
 *
 * Please send patches and names other perpherials that work to
 * pace@blitz.com.  If you have trouble that you can't fix, please
 * wait for the next release before contacting me.
 */

#include "as.h"
#if NAS > 0

#include "param.h"
#include "dkbad.h"
#include "systm.h"
#include "conf.h"
#include "file.h"
#include "stat.h"
#include "ioctl.h"
#include "disklabel.h"
#include "buf.h"
#include "uio.h"
#include "i386/isa/isa_device.h"
#include "i386/isa/icu.h"
#include "syslog.h"
#include "vm/vm.h"
#include "kernel.h"

#include "asreg.h"

int asstrategy ();
int asabort ();
extern int hz;

int asverbose = 0;


/* target id 7 is the controller itself */
#define NTARGETS 7

struct mailbox_entry mailboxes[NTARGETS * 2] = {0};

#define b_cylin	b_resid /* fake cylinder number for disksort */

/* maximum scatter list size for Adaptech controller */
#define NSCATTER 17

/* this array must reside in contiguous physical memory */
struct asinfo {
	dev_t dev;
	struct buf requests;
	struct mailbox_entry *mailbox;
	int active;
	struct ccb ccb;
	unsigned int ccb_phys;
	char scatter_list[NSCATTER * 6];

	struct disklabel label;
	struct dos_partition dospart[NDOSPART];
	int have_label;

	int scsi_lock;
	struct buf *scsi_bp;
	int scsi_cdb_len;
	unsigned char scsi_cdb[MAXCDB];

	int tape;		/* sequential */
	int disk;		/* nonsequential */
	int read_only;		/* CDROM */
	int removable;		/* unsupported and tested */
	char vendor[9];
	char model[17];
	char revision[5];
	int bs;			/* device block size */

	int open_lock;
	int open;
	int units_open;

	int wlabel;

	int retry_count;
	int start_time;
	int restart_pending;

} asinfo[NTARGETS] = {0};

#define dev_part(dev) (minor (dev) & 7)
#define dev_target(dev) ((minor (dev) >> 3) & 7)
#define dev_rewind(dev) ((minor (dev) & 1) == 0)

#define makeasdev(major, target, part) \
	makedev ((major), ((target) << 3) | (part))

int as_port;

int	asprobe(struct isa_device *), asattach(struct isa_device *),
	asintr(dev_t);

struct	isa_driver asdriver = {
	asprobe, asattach, "as",
};

int
asprobe (struct isa_device *dvp)
{
	int val;

	as_port = dvp->id_iobase;

	outb (as_port + AS_CONTROL, AS_CONTROL_SRST);
	DELAY (30000);
	val = inb (as_port + AS_STATUS);

	if (val == (AS_STATUS_INIT | AS_STATUS_IDLE))
		return (1);
	as_port = 0;
	return (0);
}

asattach (struct isa_device *dvp)
{
	int i;
	unsigned int physaddr;
	int val;
	int s;

	for (i = 0; i < NTARGETS; i++) {
		asinfo[i].mailbox = &mailboxes[i];
		asinfo[i].ccb_phys = vtophys (&asinfo[i].ccb);
	}

	isa_dmacascade(dvp->id_drq);
	
	physaddr = vtophys (mailboxes);
	
	s = splbio ();
	if (as_put_byte (AS_CMD_MAILBOX_INIT) < 0
	    || as_put_byte (NTARGETS) < 0
	    || as_put_byte (physaddr >> 16) < 0
	    || as_put_byte (physaddr >> 8) < 0
	    || as_put_byte (physaddr) < 0) {
		splx (s);
		return (EIO);
	}
	splx (s);
	DELAY (300);
	val = inb (as_port + AS_STATUS);

	if (val & AS_STATUS_INIT)
		printf ("as: mailbox init error: 0x%x\n", val);
}

int
ascmd (as, bp, direction, count, retrycount)
struct asinfo *as;
struct buf *bp;
int direction;
int count;
int retrycount;
{
	int err;

	do {
		if (asverbose)
			printf ("ascmd ");
		bp->b_bcount = count;
		bp->b_error = 0;
		bp->b_flags &= ~(B_READ | B_ERROR | B_DONE);
		if (direction == B_READ)
			bp->b_flags |= B_READ;

		bp->b_dev = as->dev;
		bp->b_blkno = 0;

		as->scsi_bp = bp;
		/* scsi_cdb, scsi_cdb_len set up by caller */

		asstrategy (bp);
		err = biowait (bp);
		as->scsi_bp = NULL;
		
	} while (err && --retrycount);

	return (err);
}

asstring (dest, src, size)
char *dest;
char *src;
int size;
{
	size--;
	bcopy (src, dest, size);
	while (size > 0 && dest[size - 1] == ' ')
		size--;
	dest[size] = 0;
}

asopen (dev, flag)
dev_t dev;
int flag;
{
	struct asinfo *as;
	unsigned int physaddr;
	struct buf *bp = NULL;
	int retry;
	unsigned char *cdb;
	char *p, *q;
	int n;
	int error;
	char vendor[9];
	char model[17];
	int disksize;

	if (as_port == 0 || dev_target (dev) >= NTARGETS)
		return (ENXIO);

	as = &asinfo[dev_target (dev)];
	as->dev = dev;

	while (as->open_lock)
		if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsiopen", 0))
			return (error);

	if (as->open) {
		if (as->tape)
			return (EBUSY);

		if (as->have_label == 0 && dev_part (dev) != 3)
			return (ENXIO);
		
		as->units_open |= 1 << dev_part (dev);
		return (0);
	}

	as->open_lock = 1;

	/* it seems like we might have to block here in case someone
	 * opens the device just after someone else closes
	 */
	while (as->scsi_lock)
		if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsicmd", 0))
			return (error);

	as->scsi_lock = 1;

	error = EIO;

	as->have_label = 0;
	as->tape = 0;
	as->disk = 0;
	as->read_only = 0;
	as->removable = 0;
	bcopy(as->vendor, vendor, sizeof(vendor));
	bcopy(as->model, model, sizeof(model));
	as->vendor[0] = 0;
	as->model[0] = 0;
	as->revision[0] = 0;

	bp = geteblk (DEV_BSIZE);

	if (asverbose) {
		printf ("openbuf = 0x%x phys 0x%x\n",
			bp->b_un.b_addr, vtophys (bp->b_un.b_addr));
		printf ("mailboxes = 0x%x\n", mailboxes);
	}

	/* first, find out if a device is present, and just what it is */
	as->scsi_cdb_len = 6;
	cdb = as->scsi_cdb;
	bzero (cdb, 6);
	cdb[0] = 0x12; /* INQUIRY */
	cdb[4] = 255; /* allocation length */
	if (error = ascmd (as, bp, B_READ, DEV_BSIZE, 2))
		/* does not respond to inquiry, obviously not CCS, give up */
		goto done;

	
	/* blather on console about it */
	p = bp->b_un.b_addr;
	if (asverbose) {
		printf ("inquiry: ");
		for (n = 0; n < 20; n++)
			printf ("%x ", p[n] & 0xff);
		printf ("\n");
		for (n = 0; n < 40; n++) {
			if (p[n] >= ' ' && p[n] < 0177)
				printf ("%c", p[n]);
			else
				printf (".");
		}
		printf ("\n");
	}

	switch (p[0]) {
	case 0: /* normal disk */
	case 4: /* write once disk */
		as->disk = 1;
		break;
	case 5: /* read only disk */
		as->read_only = 1;
		as->disk = 1;
		break;
	case 1: /* tape */
		as->tape = 1;
		break;
	case 0x7f:
		printf ("logical unit not present\n");
		goto done;
	default:
		printf ("unknown peripheral device type: 0x%x\n", p[0]);
		goto done;
	}

	as->removable = (p[1] & 0x80) ? 1 : 0;

	n = p[4] & 0xff;
	if (n >= 31) {
		asstring (as->vendor, p + 8, sizeof as->vendor);
		asstring (as->model, p + 16, sizeof as->model);
		asstring (as->revision, p + 32, sizeof as->revision);
	}

	if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
		bcmp(as->model,model, sizeof(model)) != 0) {
		printf("as%d: attached tgt %d <%s %s %s> ",  0, dev_target(dev),
			as->vendor, as->model, as->revision);
		if (as->read_only) printf("readonly ");
		if (!as->removable) printf("winchester ");
		if (as->tape) printf("tape ");
		if (as->disk) printf("disk ");
		printf("\n");
	}

	/* probe for desired block size */

	/* assume default of 512, except if CDROM (2048) */
	if (as->read_only)
		as->bs = 2048;
	else
		as->bs = 512;

	bzero(cdb, 6);
	cdb[0] = 0x1A;  /* SCSI_MDSENSE */
	cdb[4] = 255;
	if (as->tape && ascmd (as, bp, B_READ, 12, 2) == 0)  {
		int minblk, maxblk;

#ifdef notdef
		/* blather about device more */
		if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
			bcmp(as->model,model, sizeof(model)) != 0) {
			p = bp->b_un.b_addr;
			printf("as%d: data len %d medium %d speed/bufmode 0x%x desc len %d\n",
				dev_target(dev), p[0], p[1], p[2], p[3]);
			printf("as%d: density %d nblocks %d block len %d\n",
				dev_target(dev), p[4],
				(long)p[5]*65536+p[6]*256+p[7],
				(long)p[9]*65536+p[10]*256+p[11]);
		}
#endif
		
		/* obtain possible block sizes */
		bzero(cdb, 6);
		cdb[0] = 0x05; /* SCSI_RDLIMITS; */
		if (ascmd (as, bp, B_READ, 12, 2) == 0) {
			p = bp->b_un.b_addr;
			minblk = p[4]*256+p[5];
			maxblk = p[1]*65536+p[2]*256+p[3];
#ifdef notdef
			if(bcmp(as->vendor,vendor, sizeof(vendor)) != 0 ||
				bcmp(as->model,model, sizeof(model)) != 0) {
				printf("as%d: limits: min block len %ld  max block len %ld\n",
					dev_target(dev), minblk, maxblk);
			}
#endif
			if ( minblk == maxblk )
				as->bs = minblk;
			else if (as->tape)
				as->bs = 1;
		}
	}
	
	if (as->tape &&  dev_part(dev)) {
		error = EIO;
		goto done;
	}

	as->scsi_cdb_len = 10;
	bzero(cdb, 10);
	cdb[0] = 0x25;  /* SCSI_READCAPACITY */
	disksize = 0;
	if (as->disk && ascmd (as, bp, B_READ, 12, 2) == 0)  {
		p = bp->b_un.b_addr;
		disksize = ntohl(*(long *)p);
		as->bs = ntohl(*(long *)(p+4));
		
	}

if(asverbose)
	printf("block size %d disksize %d ", as->bs, disksize);


	/* for standard disk, negotiate block size */
	if (as->read_only == 0 && as->disk) {
		/* do mode select to set the logical block size */
		as->scsi_cdb_len = 6;
		cdb = as->scsi_cdb;
		bzero (cdb, 6);
		cdb[0] = 0x15; /* MODE SELECT */
		cdb[4] = 12; /* parameter list length */
	
		p = bp->b_un.b_addr;
		bzero (p, 12);
		p[3] = 8; /* block descriptor length */
		n = as->bs == 1 ? 0 : as->bs;
		p[9] = n >> 16;
		p[10] = n >> 8;
		p[11] = n;
	
		(void) ascmd (as, bp, B_WRITE, 12, 2);
	}

	/* device online and ready? */
	as->scsi_cdb_len = 6;
	bzero(cdb, 6);
	cdb[0] = 0x00;  /* SCSI_UNITRDY */
	if (error = ascmd (as, bp, B_READ, 12, 2)) {
		printf("as%d: drive not online\n", dev_target(dev));
		goto done;
	}

	if (as->disk && as->read_only == 0) {
		/* read disk label */
		bzero ((caddr_t)&as->label, sizeof as->label);
		as->label.d_secsize = as->bs;
		as->label.d_secpercyl = 64*32;
		as->label.d_type = DTYPE_SCSI;

		
		/* read label using "d" partition */
		if ((p = readdisklabel (
			makeasdev (major (dev), dev_target (dev), 3),
			asstrategy, &as->label, as->dospart, 0, 0)) == NULL){
			as->have_label = 1;
		} else {
			if (disksize) {
				as->label.d_subtype = DSTYPE_GEOMETRY;
				as->label.d_npartitions = 3;
				/* partition 0  holds bios, partition 1 ESDI */
				as->label.d_partitions[2].p_size = disksize;
				as->label.d_partitions[2].p_offset = 0;
			}
			if (asverbose || dev_part (dev) != 3)
				printf ("error reading label: %s\n", p);
			if (dev_part (dev) != 3) {
				error = EINVAL;
				goto done;
			}
		}
	}

	/* may want to set logical block size here ? */
	error = 0;

 done:
	if (bp) {
		bp->b_flags |= B_INVAL | B_AGE;
		brelse (bp);
	}

	if (error == 0)
		as->open = 1;

	as->open_lock = 0;
	as->scsi_lock = 0;
	wakeup (as);

	return (error);
}

asclose (dev, flag)
dev_t dev;
{
	struct asinfo *as;
	int error = 0;
	unsigned char *cdb;
	struct buf *bp;
	int n;

	as = &asinfo[dev_target (dev)];

	while (as->open_lock)
		if (error = tsleep ((caddr_t)as, PZERO|PCATCH, "scsiclose", 0))
			return (error);

	as->open_lock = 1;

	if (as->tape) {
		while (as->scsi_lock)
			if (error = tsleep ((caddr_t)as, PZERO|PCATCH,
					    "scsicmd", 0))
				return (error);

		as->scsi_lock = 1;
		
		bp = geteblk (DEV_BSIZE);

             if (0 && (flag & FWRITE) != 0) {
                             /* presume user will use tape again */
                     as->scsi_cdb_len = 6;
                     cdb = as->scsi_cdb;
                     bzero (cdb, 6);
                     cdb[0] = 0x10; /* write filemarks */
                     cdb[4] = 1; /* one of them */
                     error = ascmd (as, bp, B_READ, 0, 1);
             }
             if (dev_rewind (dev) || error) {
                     if ( error == 0 && (flag & FWRITE) != 0) {
                                     /* presumption error correction */
                             as->scsi_cdb_len = 6;
                             cdb = as->scsi_cdb;
                             bzero (cdb, 6);
                             cdb[0] = 0x10; /* write filemarks */
                             cdb[4] = 1; /* one of them */
                             error |= ascmd (as, bp, B_READ, 0, 1);
                     }
                     as->scsi_cdb_len = 6;
                     cdb = as->scsi_cdb;
                     bzero (cdb, 6);
                     cdb[0] = 0x1; /* rewind */
                     cdb[1] = 1; /* don't wait until done */
                     error |= ascmd (as, bp, B_READ, 0, 1);
             }
#ifdef notdef
		} else {
			cdb[0] = 0x11; /* backspace */
			cdb[1] = 1; /* look at filemarks (instead of blocks) */
			n = -1;
			cdb[2] = n >> 16;
			cdb[3] = n >> 8;
			cdb[4] = n;
			error = ascmd (as, bp, B_READ, 0, 1);
		} 
#endif

		bp->b_flags |= B_INVAL | B_AGE;
		brelse (bp);

		as->scsi_lock = 0;
	}

	as->units_open &= ~(1 << dev_part (dev));

	if (as->units_open == 0)
		as->open = 0;

	as->open_lock = 0;

	wakeup (as);

	return (error);
}

int
asioctl (dev, cmd, addr, flag)
dev_t dev;
int cmd;
caddr_t addr;
int flag;
{
	struct scsicmd *cmdp;
	struct asinfo *as;
	int ccblen;
	struct buf *bp;
	int error = 0;
	int direction;
	struct disklabel *dl;
	int old_wlabel;

	as = &asinfo[dev_target (dev)];

	switch (cmd) {
	case DIOCGDINFO:
		*(struct disklabel *)addr = as->label;
		break;

        case DIOCSDINFO:
                if ((flag & FWRITE) == 0) {
                        error = EBADF;
			break;
		}
		dl = (struct disklabel *)addr;
		if (error = setdisklabel(&as->label, dl, 0, as->dospart))
			break;
		as->have_label = 1;
                break;

        case DIOCWLABEL:
                if ((flag & FWRITE) == 0) {
                        error = EBADF;
			break;
		}
		as->wlabel = *(int *)addr;
                break;

        case DIOCWDINFO:
                if ((flag & FWRITE) == 0) {
                        error = EBADF;
			break;
		}

		dl = (struct disklabel *)addr;

		if (error = setdisklabel (&as->label, dl, 0, as->dospart))
			break;

		as->have_label = 1;

		old_wlabel = as->wlabel;
		as->wlabel = 1;
		error = writedisklabel(dev, asstrategy, &as->label,
				as->dospart);
		as->wlabel = old_wlabel;
                break;

	case SCSICMD:
		cmdp = (struct scsicmd *)addr;

		/* limited by max sizeof of geteblk */
		if (cmdp->datalen >= 8192 
		    || cmdp->cdblen >= MAXCDB) {
			error = EINVAL;
			break;
		}

		ccblen = cmdp->ccblen;
		if (ccblen > sizeof (struct ccb))
			ccblen = sizeof (struct ccb);

		while (as->scsi_lock)
			if (error = tsleep ((caddr_t)as, PZERO|PCATCH,
					    "scsicmd", 0))
				break;

		as->scsi_lock = 1;
			
		bp = geteblk (cmdp->datalen);

		as->scsi_cdb_len = cmdp->cdblen;
		if (error = copyin (cmdp->cdb, as->scsi_cdb, cmdp->cdblen))
			goto done;
		
		direction = cmdp->readflag ? B_READ : B_WRITE;

		if (direction == B_WRITE)
			if (error = copyin (cmdp->data,
					    bp->b_un.b_addr, cmdp->datalen))
				goto done;
		
		ascmd (as, bp, direction, cmdp->datalen, 1);

		copyout (&as->ccb, cmdp->ccb, ccblen);
		if (direction == B_READ)
			copyout (bp->b_un.b_addr, cmdp->data, cmdp->datalen);
	done:
		bp->b_flags |= B_INVAL | B_AGE;
		brelse (bp);
		as->scsi_lock = 0;
		wakeup (as);
		break;
	default:
		error = ENOTTY;
		break;
	}
	return (error);
}

int
asstrategy (bp)
struct buf *bp;
{
	struct asinfo *as;
	int s;

	if (asverbose)
		printf ("asstrategy %d %d ", bp->b_blkno, bp->b_bcount);
	s = splbio ();

	as = &asinfo[dev_target (bp->b_dev)];
	
	if (as->tape) {
		bp->av_forw = NULL;
		if (as->requests.b_actf)
			as->requests.b_actl->av_forw = bp;
		else
			as->requests.b_actf = bp;
		as->requests.b_actl = bp;
	} else {
		if (bp != as->scsi_bp
		    && as->have_label == 0
		    && dev_part (bp->b_dev) != 3)
			goto bad;

		bp->b_cylin = bp->b_blkno;
		disksort (&as->requests, bp);
	}
	
	if (as->active == 0)
		asstart (as);

	splx (s);
	return;

 bad:
	bp->b_flags |= B_ERROR;
	biodone (bp);
}

asrestart (as)
struct asinfo *as;
{
	int s;
	s = splbio ();
	as->restart_pending = 0;
	as->retry_count++;
	asstart (as);
	splx (s);
}

asstart (as)
struct asinfo *as;
{
	struct buf *bp;
	int blknum;
	unsigned int physaddr;
	struct ccb *ccb;
	unsigned char *cdb;
	int target;
	char *p;
	int n;
	char *sp;
	int nscatter;
	int thistime;
	int nbytes;
	struct partition *part;
	int blkno;
	int nblocks;
	int total;
	int bs = as->bs;


	if (as->restart_pending) {
		as->restart_pending = 0;
		untimeout (asrestart, as);
	}

 again:
	if ((bp = as->requests.b_actf) == NULL)
		return;

	bp->b_error = 0;

	if (asverbose)
		printf ("asstart %x ", bp);

	if (as->mailbox->cmd != 0) {
		/* this can't happen, unless the card flakes */
		printf ("asstart: mailbox not available\n");
		bp->b_error = EIO;
		goto bad;
	}

	if (as->retry_count == 0) {
		as->start_time = time.tv_sec;
	} else {
		if (time.tv_sec - as->start_time > 60) {
			printf ("as: command timed out\n");
			bp->b_error = EIO;
			goto done;
		}
	}

	if (bp != as->scsi_bp) {
		if (bp->b_bcount == 0)
			goto done;

		if ((bp->b_bcount % bs) != 0) {
			printf("as: partial block read\n");
			bp->b_error = EIO;
			goto bad;
		}
	}

	if (bp != as->scsi_bp) {

		blkno = bp->b_blkno;
		nblocks = bp->b_bcount / bs;

		if (as->have_label && dev_part(bp->b_dev) != 3) {
			part = &as->label.d_partitions[dev_part (bp->b_dev)];
			
			if (blkno > part->p_size) {
				bp->b_error = EINVAL;
				goto bad;
			}
			if (blkno == part->p_size) {
				bp->b_resid = bp->b_bcount;
				goto done;
			}
			
			if (blkno + nblocks >= part->p_size)
				nblocks = part->p_size - blkno;
			
			blkno += part->p_offset;
		} else
			blkno = (blkno * DEV_BSIZE)/bs;
if(asverbose)
	printf("trans %d ", blkno);
		if (nblocks > 255)
			nblocks = 255;
		total = nblocks * bs;
if(asverbose)
printf("total %d nblocks %d ", total, nblocks);
		/*bp->b_bcount = total;	/* XXX partial tape block read - wrong */
	} else {
#ifdef nomore
		if (as->fixed == 0) {
			total = bp->b_bcount;
		} else {
			total = bp->b_bcount;
			blkno = bp->b_blkno;
			nblocks = bp->b_bcount / as->fixed;
		}
#else
		total = bp->b_bcount;
#endif
	}

	p = bp->b_un.b_addr;
	n = 0;
	sp = as->scatter_list;
	nscatter = 0;
	while (n < total && nscatter < NSCATTER) {
		thistime = page_size - ((vm_offset_t)p - trunc_page (p));

		if (n + thistime > total)
			thistime = total - n;

		physaddr = vtophys (p);
		
		if (asverbose)
			printf ("%d bytes to %x (%x)\n",
				thistime, p, physaddr);
		sp[0] = thistime >> 16;
		sp[1] = thistime >> 8;
		sp[2] = thistime;
		sp[3] = physaddr >> 16;
		sp[4] = physaddr >> 8;
		sp[5] = physaddr;
		
		p += thistime;
		n += thistime;
		sp += 6;
		nscatter++;
	}
	
	if (nscatter == NSCATTER) {
		printf("out of range, cannot happen?");
		bp->b_error = ENXIO;
		goto bad;
	}

	ccb = &as->ccb;

	/* this only needed to make debugging easier */
	bzero ((caddr_t)ccb, sizeof *ccb); 

	if (nscatter)
		ccb->ccb_opcode = 4; /* scatter cmd, return resid */
	else
		ccb->ccb_opcode = 3;
	target = dev_target (bp->b_dev);
	ccb->ccb_addr_and_control = target << 5;
	if (bp->b_bcount != 0)
		ccb->ccb_addr_and_control |= (bp->b_flags & B_READ) ? 8 : 0x10;
	else
		ccb->ccb_addr_and_control |= 0x18;

	nbytes = nscatter * 6;
	ccb->ccb_data_len_msb = nbytes >> 16;
	ccb->ccb_data_len_mid = nbytes >> 8;
	ccb->ccb_data_len_lsb = nbytes;

	ccb->ccb_requst_sense_allocation_len = MAXSENSE;

	physaddr = vtophys (as->scatter_list);
	ccb->ccb_data_ptr_msb = physaddr >> 16;
	ccb->ccb_data_ptr_mid = physaddr >> 8;
	ccb->ccb_data_ptr_lsb = physaddr;

	ccb->ccb_link_msb = 0;
	ccb->ccb_link_mid = 0;
	ccb->ccb_link_lsb = 0;
	ccb->ccb_link_id = 0;
	ccb->ccb_host_status = 0;
	ccb->ccb_target_status = 0;
	ccb->ccb_zero1 = 0;
	ccb->ccb_zero2 = 0;

	cdb = ccb->ccb_cdb;
	if (bp == as->scsi_bp) {
		ccb->ccb_scsi_command_len = as->scsi_cdb_len;
		bcopy (as->scsi_cdb, cdb, as->scsi_cdb_len);
	} else if (as->tape) {
		ccb->ccb_scsi_command_len = 6;
		cdb[0] = (bp->b_flags & B_READ) ? 8 : 0xa;
		if (as->bs == 1) {
			cdb[1] = 0; /* logical unit 0, variable block size */
			cdb[2] = bp->b_bcount >> 16;
			cdb[3] = bp->b_bcount >> 8;
			cdb[4] = bp->b_bcount;
		} else {
			cdb[1] = 1;     /* fixed block size */
			cdb[2] = nblocks >> 16;
			cdb[3] = nblocks >> 8;
			cdb[4] = nblocks;
		}
		cdb[5] = 0; /* control byte (used in linking) */
	} else {
		ccb->ccb_scsi_command_len = 10;
		cdb[0] = (bp->b_flags & B_READ) ? 0x28 : 0x2a;
		cdb[1] = 0;
		*(long *) (cdb+2) = htonl(blkno);
		*(short *) (cdb+7) = htons(nblocks);
		cdb[9] = 0; /* control byte (used in linking) */
	}

#ifdef notdef
	if (asverbose) {
		printf ("ccb: ");
		for (n = 0; n < 48; n++)
			printf ("%02x ", ((unsigned char *)ccb)[n]);
		printf ("\n");
	}
#endif

	physaddr = vtophys (ccb);
	as->mailbox->msb = physaddr >> 16;
	as->mailbox->mid = physaddr >> 8;
	as->mailbox->lsb = physaddr;
	as->mailbox->cmd = 1;
	
	/* tell controller to look in its mailbox */
	as_put_byte (AS_CMD_START_SCSI_COMMAND);
	as->active = 1;
	timeout (asabort, as, hz * 60 * 2);
	return;

 bad:
	bp->b_flags |= B_ERROR;
 done:
	asdone (as, 0);
	goto again;
}

asabort (as)
struct asinfo *as;
{
	int s;
	int physaddr;
	struct buf *bp;

	s = splbio ();
	if (as->active) {
		printf ("asabort %d\n", as - asinfo);
		physaddr = vtophys (&as->ccb);
		as->mailbox->msb = physaddr >> 16;
		as->mailbox->mid = physaddr >> 8;
		as->mailbox->lsb = physaddr;
		as->mailbox->cmd = 2;
		as_put_byte (AS_CMD_START_SCSI_COMMAND);

		as->active = 0;
		bp = as->requests.b_actf;
		if (bp) {
			bp->b_flags |= B_ERROR;
			asdone (as, 1);
		}
	}
	splx (s);
}

asintr (dev_t dev)
{
	int didwork;
	int i, j;
	struct mailbox_entry *mp;
	unsigned int physaddr;
	int val;

	outb (as_port + AS_CONTROL, AS_CONTROL_IRST);
#ifdef notdef
	if (asverbose)
		printf ("asintr %x ", cpl);
#endif
 again:
	didwork = 0;
	for (i = NTARGETS; i < NTARGETS * 2; i++) {
		mp = &mailboxes[i];
		
		if ((val = mp->cmd) == 0)
			continue;
		
		didwork = 1;

		physaddr = (mp->msb << 16)
			| (mp->mid << 8)
				| mp->lsb;
		
		for (j = 0; j < NTARGETS; j++) {
			if (asinfo[j].ccb_phys == physaddr) {
				mp->cmd = 0;
				asintr1 (&asinfo[j], val);
				break;
			}
		}
		if (j == NTARGETS) {
			printf ("as: unknown mailbox paddr 0x%x\n", physaddr);
			mp->cmd = 0;
		}
	}

	if (didwork)
		goto again;
}

asintr1 (as, val)
struct asinfo *as;
int val;
{
	struct buf *bp;
	struct ccb *ccb;
	int n;
	int bad;
	char *msg;
	char msgbuf[100];
	unsigned char *sp;
	int i,key;

	if (asverbose)
		printf ("asintr1 %x ", val);
	if (as->active == 0) {
		printf ("as: stray intr 0x%x\n", as->dev);
		return;
	}

	as->active = 0;
	untimeout (asabort, as);
	
	bp = as->requests.b_actf;
	ccb = &as->ccb;

	if (bp == as->scsi_bp) {
		/* no fancy error recovery in this case */
		if (asverbose)
			printf ("asintr1:scsicmd ");
#if 0
		if (val != 1)
			bp->b_flags |= B_ERROR;
		goto next;
#endif
	}

	bad = 0;
	msg = NULL;

	if (val != 1 && val != 4) {
		bad = 1;
		sprintf (msgbuf, "funny mailbox message 0x%x\n", val);
		msg = msgbuf;
		goto wrapup;
	}

	if (ccb->ccb_host_status != 0) {
		bad = 1;
		sprintf (msgbuf, "controller error 0x%x",
			 ccb->ccb_host_status);
		msg = msgbuf;
		goto wrapup;
	}

	if (ccb->ccb_target_status == 0)
		/* good transfer */
		goto wrapup;

	if (ccb->ccb_target_status == 8) {
		/* target rejected command because it is busy
		 * and wants us to try again later.  We'll wait 1 second
		 */
		as->restart_pending = 1;
		timeout (asrestart, as, hz);
		return;
	}

	if (ccb->ccb_target_status != 2) {
		bad = 1;
		sprintf (msgbuf, "target error 0x%x",
			 ccb->ccb_target_status);
		msg = msgbuf;
		goto wrapup;
	}

	/* normal path for errors */

	sp = ccb_sense (ccb);
	/* check for extended sense information */
	if ((sp[0] & 0x7f) != 0x70) {
		/* none */
		bad = 1;
		sprintf (msgbuf, "scsi error 0x%x", sp[0] & 0x7f);
		msg = msgbuf;
		goto wrapup;
	}
	
	if (as->tape && (sp[2] & 0xf) == 0) {
		if (sp[2] & 0xe0) {
			/* either we read a file mark, the early warning EOT,
			 * or the block size did not match.  In any case, the
			 * normal residue handling will work (I think)
			 */
			goto wrapup;
		}
	}

	bad = 1;

	switch (key = sp[2] & 0xf) {
	case 1: 
		msg = "soft error";
		bad = 0;
		break;
	case 2:
		msg = "not ready";
		break;
	case 3:
		msg = "hard error";
		break;
	case 4:
		msg = "target hardware error";
		break;
	case 5:
		msg = "illegal request";
		break;
	case 6:
		msg = "unit attention error";
		break;
	case 7: 
		msg = "write protect error";
		break;
	case 0xd:
		msg = "volume overflow";
		break;
	default:
		sprintf (msgbuf, "scsi extended error 0x%x", sp[2] & 0xf);
		msg = msgbuf;
		break;
	}

 wrapup:

	if (bad && msg == NULL)
		msg = "unknown error";

	if (msg && key != 6) {
		diskerr (bp, "as", msg,
			 LOG_PRINTF,
			 -1, /* number of successful blks */
			 as->have_label ? &as->label : NULL);
		printf ("\n");
	}

	if (bad && key != 6) {
		bp->b_flags |= B_ERROR;
		printf ("scsi sense: ");
		sp = ccb_sense (ccb);
		for (i = 0; i < 30; i++)
			printf ("%x ", sp[i] & 0xff);
		printf ("\n");
	}

	bp->b_resid = (ccb->ccb_data_len_msb << 16)
		| (ccb->ccb_data_len_mid << 8)
			| ccb->ccb_data_len_lsb;
	if (bp != as->scsi_bp && bp->b_resid != 0)
		printf ("scsi resid = %d\n", bp->b_resid);

 next:
	asdone (as, 1);
}

asdone (as, restart)
struct asinfo *as;
int restart;
{
	struct buf *bp;

	bp = as->requests.b_actf;
	as->requests.b_actf = bp->av_forw;
	biodone (bp);
	as->retry_count = 0;
	if (restart && as->requests.b_actf)
		asstart (as);
}

int
assize (dev)
dev_t dev;
{
	struct asinfo *as;
	struct disklabel *lp;
	int val;

	if (as_port == 0 || dev_target (dev) >= NTARGETS)
		return (ENXIO);

	as = &asinfo[dev_target (dev)];

	if (as->open == 0
	    && asopen (dev, FREAD, S_IFBLK, NULL) != 0)
		return (0);

	if (as->have_label == 0)
		return (0);

	lp = &as->label;
	val = lp->d_partitions[dev_part (dev)].p_size
		* lp->d_secsize / DEV_BSIZE;
	(void) asclose(dev, FREAD, S_IFBLK, NULL);
	return (val);
}

int
as_put_byte (val)
int val;
{
	int i;

	for (i = 100; i > 0; i--) {
		if ((inb (as_port + AS_STATUS) & AS_STATUS_CDF) == 0)
			break;
		DELAY (100);
	}
	if (i == 0) {
		printf ("as: put byte timed out\n");
		return (-1);
	}
	outb (as_port + AS_DATA_OUT, val);
	return (0);
}
		
int
as_get_byte (as)
{
	int i;

	for (i = 100; i > 0; i--) {
		if ((inb (as_port + AS_STATUS) & AS_STATUS_DF) != 0)
			break;
		DELAY (100);
	}
	if (i == 0) {
		printf ("as_get_byte timed out\n");
		return (-1);
	}
	return (inb (as_port + AS_DATA_OUT) & 0xff);
}
#endif /* NAS */