NetBSD/sys/arch/amiga/dev/sfas.c

/*
 * Copyright (c) 1995 Daniel Widenfalk
 * Copyright (c) 1994 Christian E. Hopps
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Van Jacobson of Lawrence Berkeley Laboratory.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	@(#)scsi.c	7.5 (Berkeley) 5/4/91
 */

/*
 * AMIGA Emulex FAS216 scsi adaptor driver
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <scsi/scsi_all.h>
#include <scsi/scsiconf.h>
#include <vm/vm.h>
#include <vm/vm_kern.h>
#include <vm/vm_page.h>
#include <machine/pmap.h>
#include <machine/cpu.h>
#include <amiga/amiga/device.h>
#include <amiga/amiga/cc.h>
#include <amiga/amiga/custom.h>
#include <amiga/amiga/isr.h>
#include <amiga/dev/sfasreg.h>
#include <amiga/dev/sfasvar.h>
#include <amiga/dev/zbusvar.h>

void sfasinitialize __P((struct sfas_softc *));
void sfas_minphys   __P((struct buf *bp));
int  sfas_scsicmd   __P((struct scsi_xfer *xs));
int  sfas_donextcmd __P((struct sfas_softc *dev, struct sfas_pending *pendp));
void sfas_scsidone  __P((struct sfas_softc *dev, struct scsi_xfer *xs,
			 int stat));
void sfasintr	    __P((struct sfas_softc *dev));
void sfasiwait	    __P((struct sfas_softc *dev));
void sfasreset	    __P((struct sfas_softc *dev, int how));
int  sfasselect	    __P((struct sfas_softc *dev, struct sfas_pending *pendp,
			 unsigned char *cbuf, int clen, 
			 unsigned char *buf, int len, int mode));
void sfasicmd	    __P((struct sfas_softc *dev, struct sfas_pending *pendp));

/*
 * Initialize these to make 'em patchable. Defaults to enable sync and discon.
 */
u_char	sfas_inhibit_sync[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
u_char	sfas_inhibit_disc[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

#ifdef DEBUG
#define QPRINTF(a) if (sfas_debug > 1) printf a
int	sfas_debug = 0;
#else
#define QPRINTF
#endif

/*
 * default minphys routine for sfas based controllers
 */
void sfas_minphys(bp)
	struct buf *bp;
{
/* no max transfer at this level */
}

/*
 * Initialize the nexus structs.
 */
void
sfas_init_nexus(dev, nexus)
	struct sfas_softc *dev;
	struct nexus	  *nexus;
{
	bzero(nexus, sizeof(struct nexus));

	nexus->state	= SFAS_NS_IDLE;
	nexus->period	= 200;
	nexus->offset	= 0;
	nexus->syncper	= 5;
	nexus->syncoff	= 0;
	nexus->config3	= dev->sc_config3 & ~SFAS_CFG3_FASTSCSI;
}

void
sfasinitialize(dev)
	struct sfas_softc *dev;
{
	sfas_regmap_p	 rp;
	u_int		*pte, page;
	int		 i;

	dev->sc_led_status = 0;

	TAILQ_INIT(&dev->sc_xs_pending);
	TAILQ_INIT(&dev->sc_xs_free);

/*
 * Initialize the sfas_pending structs and link them into the free list. We
 * have to set vm_link_data.pages to 0 or the vm FIX won't work.
 */
	for(i=0; i<MAXPENDING; i++) {
#ifdef SFAS_NEED_VM_PATCH
		dev->sc_xs_store[i].vm_link_data.pages = 0;
#endif
		TAILQ_INSERT_TAIL(&dev->sc_xs_free, &dev->sc_xs_store[i],
				  link);
	}

/*
 * Calculate the correct clock conversion factor 2 <= factor <= 8, i.e. set
 * the factor to clock_freq / 5 (int).
 */
	if (dev->sc_clock_freq <= 10)
		dev->sc_clock_conv_fact = 2;
	if (dev->sc_clock_freq <= 40)
		dev->sc_clock_conv_fact = 2+((dev->sc_clock_freq-10)/5);
	else
		panic("sfasinitialize: Clock frequence too high");

/* Setup and save the basic configuration registers */
	dev->sc_config1 = (dev->sc_host_id & SFAS_CFG1_BUS_ID_MASK);
	dev->sc_config2 = SFAS_CFG2_FEATURES_ENABLE;
	dev->sc_config3 = (dev->sc_clock_freq > 25 ? SFAS_CFG3_FASTCLK : 0);

/* Precalculate timeout value and clock period. */
	dev->sc_timeout_val  = 1+dev->sc_timeout*dev->sc_clock_freq/
				 (7.682*dev->sc_clock_conv_fact);
	dev->sc_clock_period = 1000/dev->sc_clock_freq;

	sfasreset(dev, 1 | 2);	/* Reset Chip and Bus */

	dev->sc_units_disconnected = 0;
	dev->sc_msg_in_len = 0;
	dev->sc_msg_out_len = 0;

	dev->sc_flags = 0;

	for(i=0; i<8; i++)
		sfas_init_nexus(dev, &dev->sc_nexus[i]);

/*
 * Setup bump buffer. If dev->sc_bump_pa has the upper bits set, we should
 * allocate z2-mem else we can allocate "any" memory. This code should check
 * that the bump-buffer is LW aligned, but I think alloc_z2mem/kmem_alloc
 * does that.
 */
	if (dev->sc_bump_pa & 0xFF000000) {
		dev->sc_bump_va = (u_char *)alloc_z2mem(dev->sc_bump_sz);
		if (isztwomem(dev->sc_bump_va))
			dev->sc_bump_pa = kvtop(dev->sc_bump_va);
		else
			dev->sc_bump_pa = (vm_offset_t)
					  PREP_DMA_MEM(dev->sc_bump_va);
	} else {
		dev->sc_bump_va = (u_char *)kmem_alloc(kernel_map,
						       dev->sc_bump_sz);
		dev->sc_bump_pa = kvtop(dev->sc_bump_va);
	}

/*
 * Setup pages to noncachable, that way we don't have to flush the cache
 * every time we need "bumped" transfer.
 */
	pte = kvtopte(dev->sc_bump_va);
	page= (u_int)dev->sc_bump_pa & PG_FRAME;

	*pte = PG_V | PG_RW | PG_CI | page;
	TBIAS();

	printf(": dmabuf 0x%x", dev->sc_bump_pa);

/*
 * FIX
 * The scsi drivers tend to allocate buffers from the kernel stacks. When the
 * kernel goes to sleep, it does a contect-switch thus removing the mapping
 * to the stack. To work around this we allocate MAXPHYS+alignment bytes
 * of virtual memory to which we can later map physical memory to.
 */
#ifdef SFAS_NEED_VM_PATCH
	vm_map_lock(kernel_map);

/* Locate available space. */
	if (vm_map_findspace(kernel_map, 0, MAXPHYS+NBPG,
			     (vm_offset_t *)&dev->sc_vm_link)) {
		vm_map_unlock(kernel_map);
		panic("SFAS_SCSICMD: No VM space available.");
	} else {
		int	offset;
      
/*
 * Map space to virtual memory in kernel_map. This vm will always be available
 * to us during interrupt time.
 */
		offset = (vm_offset_t)dev->sc_vm_link - VM_MIN_KERNEL_ADDRESS;
		printf(" vmlnk %x", dev->sc_vm_link);
		vm_object_reference(kernel_object);
		vm_map_insert(kernel_map, kernel_object, offset,
			      (vm_offset_t)dev->sc_vm_link,
			      (vm_offset_t)dev->sc_vm_link+(MAXPHYS+NBPG));
		vm_map_unlock(kernel_map);
	}

	dev->sc_vm_link_pages = 0;
#endif
}

#ifdef SFAS_NEED_VM_PATCH
/*
 * Remove our memory-FIX mapping
 */
void
sfas_unlink_vm_link(dev)
	struct sfas_softc *dev;
{
	if (dev->sc_flags & SFAS_HAS_VM_LINK) {
		physunaccess(dev->sc_vm_link, dev->sc_vm_link_pages*NBPG);
		dev->sc_vm_link_pages = 0;
		dev->sc_flags &= ~SFAS_HAS_VM_LINK;
	}
}

/*
 * Setup a physical-to-virtual mapping to work around the above mentioned
 * bug in the scsi drivers
 */
void
sfas_link_vm_link(dev, vm_link_data)
	struct sfas_softc	*dev;
	struct vm_link_data	*vm_link_data;
{
	int	i;

	if (dev->sc_flags & SFAS_HAS_VM_LINK)
		sfas_unlink_vm_link(dev);

	dev->sc_vm_link_pages = vm_link_data->pages;

	if (vm_link_data->pages) {
		for(i=0; i<vm_link_data->pages; i++)
			physaccess(dev->sc_vm_link+i*NBPG, vm_link_data->pa[i],
				   NBPG, PG_CI);
      
		dev->sc_flags |= SFAS_HAS_VM_LINK;
	}
}
#endif

/*
 * used by specific sfas controller
 */
int
sfas_scsicmd(struct scsi_xfer *xs)
{
	struct sfas_softc	*dev;
	struct scsi_link	*slp;
	struct sfas_pending	*pendp;
	int			 flags, s, target;
#ifdef SFAS_NEED_VM_PATCH
	struct vm_link_data	 vm_link_data;
#endif

	slp = xs->sc_link;
	dev = slp->adapter_softc;
	flags = xs->flags;
	target = slp->target;

	if (flags & SCSI_DATA_UIO)
		panic("sfas: scsi data uio requested");

	if ((flags & SCSI_POLL) && (dev->sc_flags & SFAS_ACTIVE))
		panic("sfas_scsicmd: busy");

/* Get hold of a sfas_pending block. */
	s = splbio();
	pendp = dev->sc_xs_free.tqh_first;
	if (pendp == NULL) {
		splx(s);
		return(TRY_AGAIN_LATER);
	}
	TAILQ_REMOVE(&dev->sc_xs_free, pendp, link);
	pendp->xs = xs;
	splx(s);

#ifdef SFAS_NEED_VM_PATCH
	pendp->vm_link_data.offset = 0;
	pendp->vm_link_data.pages = 0;

/*
 * We need our FIX vm-link if:
 *  1) We are NOT using polled IO.
 *  2) Out data source/destination is not in the u-stack area.
 */
	if (!(flags & SCSI_POLL) && (
#ifdef M68040
	    (cpu040 && ((vm_offset_t)xs->data >= 0xFFFC0000)) &&
#endif
		       ((vm_offset_t)xs->data >= 0xFF000000))) {
		vm_offset_t	 sva;
		short		 n;

/* Extract and store the physical adresses of the data block */
		sva = (vm_offset_t)xs->data & PG_FRAME;

		pendp->vm_link_data.offset = (vm_offset_t)xs->data & PGOFSET;
		pendp->vm_link_data.pages  = round_page(xs->data+xs->datalen-
							sva)/NBPG;
	    
		for(n=0; n<pendp->vm_link_data.pages; n++)
			pendp->vm_link_data.pa[n] = kvtop(sva + n*NBPG);
	}
#endif

/* If the chip if busy OR the unit is busy, we have to wait for out turn. */
	if ((dev->sc_flags & SFAS_ACTIVE) || 
	    (dev->sc_nexus[target].flags & SFAS_NF_UNIT_BUSY)) {
		s = splbio();
		TAILQ_INSERT_TAIL(&dev->sc_xs_pending, pendp, link);
		splx(s);
	} else
		sfas_donextcmd(dev, pendp);

	return((flags & SCSI_POLL) ? COMPLETE : SUCCESSFULLY_QUEUED);
}

/*
 * Actually select the unit, whereby the whole scsi-process is started.
 */
int
sfas_donextcmd(dev, pendp)
	struct sfas_softc	*dev;
	struct sfas_pending	*pendp;
{
	int	s;

/*
 * Special case for scsi unit reset. I think this is waterproof. We first
 * select the unit during splbio. We then cycle through the generated
 * interrupts until the interrupt routine signals that the unit has
 * acknowledged the reset. After that we have to wait a reset to select
 * delay before anything else can happend.
 */
	if (pendp->xs->flags & SCSI_RESET) {
		struct nexus	*nexus;

		s = splbio();
		while(!sfasselect(dev, pendp, 0, 0, 0, 0, SFAS_SELECT_K)) {
			splx(s);
			delay(10);
			s = splbio();
		}

		nexus = dev->sc_cur_nexus;
		while(nexus->flags & SFAS_NF_UNIT_BUSY) {
			sfasiwait(dev);
			sfasintr(dev);
		}

		nexus->flags |= SFAS_NF_UNIT_BUSY;
		splx(s);

		sfasreset(dev, 0);

		s = splbio();
		nexus->flags &= ~SFAS_NF_UNIT_BUSY;
		splx(s);
	}

/*
 * If we are polling, go to splbio and perform the command, else we poke
 * the scsi-bus via sfasgo to get the interrupt machine going.
 */
	if (pendp->xs->flags & SCSI_POLL) {
		s = splbio();
		sfasicmd(dev, pendp);
		TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link);
		splx(s);
	} else {
		sfasgo(dev, pendp);
		return;
	}
}

void
sfas_scsidone(dev, xs, stat)
	struct sfas_softc *dev;
	struct scsi_xfer *xs;
	int		 stat;
{
	struct sfas_pending	*pendp;
	int			 s;

	xs->status = stat;

	if (stat == 0)
		xs->resid = 0;
	else {
		switch(stat) {
		case SCSI_CHECK:
		/* If we get here we have valid sense data. Faults during
		 * sense is handeled elsewhere and will generate a
		 * XS_DRIVER_STUFFUP. */
			xs->error = XS_SENSE;
			break;
		case SCSI_BUSY:
			xs->error = XS_BUSY;
			break;
		case -1:
			xs->error = XS_DRIVER_STUFFUP;
			QPRINTF(("sfas_scsicmd() bad %x\n", stat));
			break;
		default:
			xs->error = XS_TIMEOUT;
			break;
		}
	}

	xs->flags |= ITSDONE;

/* Steal the next command from the queue so that one unit can't hog the bus. */
	s = splbio();
	pendp = dev->sc_xs_pending.tqh_first;
	while(pendp) {
		if (!(dev->sc_nexus[pendp->xs->sc_link->target].flags &
		      SFAS_NF_UNIT_BUSY))
			break;
		pendp = pendp->link.tqe_next;
	}

	if (pendp != NULL) {
		TAILQ_REMOVE(&dev->sc_xs_pending, pendp, link);
	}
	
	splx(s);
	scsi_done(xs);

	if (pendp)
		sfas_donextcmd(dev, pendp);
}

/*
 * There are two kinds of reset:
 *  1) CHIP-bus reset. This also implies a SCSI-bus reset.
 *  2) SCSI-bus reset.
 * After the appropriate resets have been performed we wait a reset to select
 * delay time.
 */
void
sfasreset(dev, how)
	struct sfas_softc *dev;
	int		 how;
{
	sfas_regmap_p	rp;
	int		i, s;

	rp = dev->sc_fas;

	if (how & 1) {
		for(i=0; i<8; i++)
			sfas_init_nexus(dev, &dev->sc_nexus[i]);

		*rp->sfas_command = SFAS_CMD_RESET_CHIP;
		delay(1);
		*rp->sfas_command = SFAS_CMD_NOP;

		*rp->sfas_config1 = dev->sc_config1;
		*rp->sfas_config2 = dev->sc_config2;
		*rp->sfas_config3 = dev->sc_config3;
		*rp->sfas_timeout = dev->sc_timeout_val;
		*rp->sfas_clkconv = dev->sc_clock_conv_fact & 
					SFAS_CLOCK_CONVERSION_MASK;
	}

	if (how & 2) {
		for(i=0; i<8; i++)
			sfas_init_nexus(dev, &dev->sc_nexus[i]);

		s = splbio();

		*rp->sfas_command = SFAS_CMD_RESET_SCSI_BUS;
		delay(100);

/* Skip interrupt generated by RESET_SCSI_BUS */
		while(*rp->sfas_status & SFAS_STAT_INTERRUPT_PENDING) {
			dev->sc_status = *rp->sfas_status;
			dev->sc_interrupt = *rp->sfas_interrupt;
			
			delay(100);
		}

		dev->sc_status = *rp->sfas_status;
		dev->sc_interrupt = *rp->sfas_interrupt;

		splx(s);
	}

	if (dev->sc_config_flags & SFAS_SLOW_START)
		delay(4*250000); /* RESET to SELECT DELAY*4 for slow devices */
	else
		delay(250000);	 /* RESET to SELECT DELAY */
}

/*
 * Save active data pointers to the nexus block currently active.
 */
void
sfas_save_pointers(dev)
	struct sfas_softc *dev;
{
	struct nexus	*nx;

	nx = dev->sc_cur_nexus;
	if (nx) {
		nx->cur_link	= dev->sc_cur_link;
		nx->max_link	= dev->sc_max_link;
		nx->buf		= dev->sc_buf;
		nx->len		= dev->sc_len;
		nx->dma_len	= dev->sc_dma_len;
		nx->dma_buf	= dev->sc_dma_buf;
		nx->dma_blk_flg	= dev->sc_dma_blk_flg;
		nx->dma_blk_len	= dev->sc_dma_blk_len;
		nx->dma_blk_ptr	= dev->sc_dma_blk_ptr;
	}
}

/*
 * Restore data pointers from the currently active nexus block.
 */
void
sfas_restore_pointers(dev)
	struct sfas_softc *dev;
{
	struct nexus	*nx;

	nx = dev->sc_cur_nexus;
	if (nx) {
		dev->sc_cur_link    = nx->cur_link;
		dev->sc_max_link    = nx->max_link;
		dev->sc_buf	    = nx->buf;
		dev->sc_len	    = nx->len;
		dev->sc_dma_len	    = nx->dma_len;
		dev->sc_dma_buf	    = nx->dma_buf;
		dev->sc_dma_blk_flg = nx->dma_blk_flg;
		dev->sc_dma_blk_len = nx->dma_blk_len;
		dev->sc_dma_blk_ptr = nx->dma_blk_ptr;
		dev->sc_chain	    = nx->dma;
		dev->sc_unit	    = (nx->lun_unit & 0x0F);
		dev->sc_lun	    = (nx->lun_unit & 0xF0) >> 4;
	}
}

/* 
 * sfasiwait is used during interrupt and polled IO to wait for an event from
 * the FAS chip. This function MUST NOT BE CALLED without interrupt disabled.
 */
void
sfasiwait(dev)
	struct sfas_softc *dev;
{
	sfas_regmap_p	rp;

/*
 * If SFAS_DONT_WAIT is set, we have already grabbed the interrupt info
 * elsewhere. So we don't have to wait for it.
 */
	if (dev->sc_flags & SFAS_DONT_WAIT) {
		dev->sc_flags &= ~SFAS_DONT_WAIT;
		return;
	}

	rp = dev->sc_fas;

/* Wait for FAS chip to signal an interrupt. */
	while(!(*rp->sfas_status & SFAS_STAT_INTERRUPT_PENDING))
		delay(1);

/* Grab interrupt info from chip. */
	dev->sc_status = *rp->sfas_status;
	dev->sc_interrupt = *rp->sfas_interrupt;
	if (dev->sc_interrupt & SFAS_INT_RESELECTED) {
		dev->sc_resel[0] = *rp->sfas_fifo;
		dev->sc_resel[1] = *rp->sfas_fifo;
	}
}

/*
 * Transfer info to/from device. sfas_ixfer uses polled IO+sfasiwait so the
 * rules that apply to sfasiwait also applies here.
 */
void
sfas_ixfer(dev)
	struct sfas_softc *dev;
{
	sfas_regmap_p	 rp;
	u_char		*buf;
	int		 len, mode, phase;

	rp = dev->sc_fas;
	buf = dev->sc_buf;
	len = dev->sc_len;

/*
 * Decode the scsi phase to determine whether we are reading or writing.
 * mode == 1 => READ, mode == 0 => WRITE
 */
	phase = dev->sc_status & SFAS_STAT_PHASE_MASK;
	mode = (phase == SFAS_PHASE_DATA_IN);

	while(len && ((dev->sc_status & SFAS_STAT_PHASE_MASK) == phase))
		if (mode) {
			*rp->sfas_command = SFAS_CMD_TRANSFER_INFO;
	
			sfasiwait(dev);
	
			*buf++ = *rp->sfas_fifo;
			len--;
		} else {
			len--;
			*rp->sfas_fifo = *buf++;
			*rp->sfas_command = SFAS_CMD_TRANSFER_INFO;

			sfasiwait(dev);
		}

/* Update buffer pointers to reflect the sent/recieved data. */
	dev->sc_buf = buf;
	dev->sc_len = len;

/*
 * Since the last sfasiwait will be a phase-change, we can't wait for it
 * again later, so  we have to signal that.
 */
	dev->sc_flags |= SFAS_DONT_WAIT;
}

/*
 * Build a Synchronous Data Transfer Request message
 */
void
sfas_build_sdtrm(dev, period, offset)
	struct sfas_softc *dev;
	int		  period;
	int		  offset;
{
	dev->sc_msg_out[0] = 0x01;
	dev->sc_msg_out[1] = 0x03;
	dev->sc_msg_out[2] = 0x01;
	dev->sc_msg_out[3] = period/4;
	dev->sc_msg_out[4] = offset;
	dev->sc_msg_out_len= 5;
}

/*
 * Arbitate the scsi bus and select the unit
 */
int
sfas_select_unit(dev, target)
	struct sfas_softc *dev;
	short		  target;
{
	sfas_regmap_p	 rp;
	struct nexus	*nexus;
	int		 s, retcode, i;
	u_char		 cmd;

	s = splbio();	/* Do this at splbio so that we won't be disturbed. */

	retcode = 0;

	nexus = &dev->sc_nexus[target];

/*
 * Check if the chip is busy. If not the we mark it as so and hope that nobody
 * reselects us until we have grabbed the bus.
 */
	if (!(dev->sc_flags & SFAS_ACTIVE) && !dev->sc_sel_nexus) {
		dev->sc_flags |= SFAS_ACTIVE;

		rp = dev->sc_fas;

		*rp->sfas_syncper = nexus->syncper;
		*rp->sfas_syncoff = nexus->syncoff;
		*rp->sfas_config3 = nexus->config3;

		*rp->sfas_config1 = dev->sc_config1;
		*rp->sfas_timeout = dev->sc_timeout_val;
		*rp->sfas_dest_id = target;

/* If nobody has stolen the bus, we can send a select command to the chip. */
		if (!(*rp->sfas_status & SFAS_STAT_INTERRUPT_PENDING)) {
			*rp->sfas_fifo = nexus->ID;
			if ((nexus->flags & (SFAS_NF_DO_SDTR | SFAS_NF_RESET))
			    || (dev->sc_msg_out_len != 0))
				cmd = SFAS_CMD_SEL_ATN_STOP;
			else {
				for(i=0; i<nexus->clen; i++)
					*rp->sfas_fifo = nexus->cbuf[i];

				cmd = SFAS_CMD_SEL_ATN;
			}

			dev->sc_sel_nexus = nexus;
		  
			*rp->sfas_command = cmd;
			retcode = 1;
		}
	}

	splx(s);
	return(retcode);
}

/*
 * Grab the nexus if available else return 0.
 */
struct nexus *
sfas_arbitate_target(dev, target)
	struct sfas_softc *dev;
	int		  target;
{
	struct nexus	*nexus;
	int		 s;

/*
 * This is realy simple. Raise interrupt level to splbio. Grab the nexus and
 * leave.
 */
	nexus = &dev->sc_nexus[target];

	s = splbio();

	if (nexus->flags & SFAS_NF_UNIT_BUSY)
		nexus = 0;
	else
		nexus->flags |= SFAS_NF_UNIT_BUSY;

	splx(s);
	return(nexus);
}

/*
 * Setup a nexus for use. Initializes command, buffer pointers and dma chain.
 */
void
sfas_setup_nexus(dev, nexus, pendp, cbuf, clen, buf, len, mode)
	struct sfas_softc	*dev;
	struct nexus		*nexus;
	struct sfas_pending	*pendp;
	unsigned char		*cbuf;
	int			 clen;
	unsigned char		*buf;
	int			 len;
	int			 mode;
{
	char	sync, target, lun;

	target = pendp->xs->sc_link->target;
	lun    = pendp->xs->sc_link->lun;

/*
 * Adopt mode to reflect the config flags.
 * If we can't use DMA we can't use synch transfer. Also check the 
 * sfas_inhibit_xxx[target] flags.
 */
	if ((dev->sc_config_flags & (SFAS_NO_SYNCH | SFAS_NO_DMA)) || 
	    sfas_inhibit_sync[target])
		mode &= ~SFAS_SELECT_S;

	if ((dev->sc_config_flags & SFAS_NO_RESELECT) ||
	    sfas_inhibit_disc[target])
		mode &= ~SFAS_SELECT_R;

	nexus->xs		= pendp->xs;
#ifdef SFAS_NEED_VM_PATCH
	nexus->vm_link_data	= pendp->vm_link_data;
#endif

/* Setup the nexus struct. */
	nexus->ID	   = ((mode & SFAS_SELECT_R) ? 0xC0 : 0x80) | lun;
	nexus->clen	   = clen;
	bcopy(cbuf, nexus->cbuf, nexus->clen);
	nexus->cbuf[1] |= lun << 5;		/* Fix the lun bits */
	nexus->cur_link	   = 0;
	nexus->dma_len	   = 0;
	nexus->dma_buf	   = 0;
	nexus->dma_blk_len = 0;
	nexus->dma_blk_ptr = 0;
	nexus->len	   = len;
	nexus->buf	   = buf;
	nexus->lun_unit	   = (lun << 4) | target;
	nexus->state	   = SFAS_NS_SELECTED;

/* We must keep these flags. All else must be zero. */
	nexus->flags	  &= SFAS_NF_UNIT_BUSY	 | SFAS_NF_REQUEST_SENSE
			   | SFAS_NF_SYNC_TESTED | SFAS_NF_SELECT_ME;

/*
 * If we are requesting sense, reflect that in the flags so that we can handle
 * error in sense data correctly
 */
	if (nexus->flags & SFAS_NF_REQUEST_SENSE) {
		nexus->flags &= ~SFAS_NF_REQUEST_SENSE;
		nexus->flags |=  SFAS_NF_SENSING;
	}

	if (mode & SFAS_SELECT_I)
		nexus->flags |= SFAS_NF_IMMEDIATE;
	if (mode & SFAS_SELECT_K)
		nexus->flags |= SFAS_NF_RESET;

	sync  = ((mode & SFAS_SELECT_S) ? 1 : 0);

/* We can't use sync during polled IO. */
	if (sync && (mode & SFAS_SELECT_I))
		sync = 0;

	if (!sync &&
	    ((nexus->flags & SFAS_NF_SYNC_TESTED) && (nexus->offset != 0))) {
		/*
		 * If the scsi unit is set to synch transfer and we don't want
		 * that, we have to renegotiate.
		 */

		nexus->flags |= SFAS_NF_DO_SDTR;
		nexus->period = 200;
		nexus->offset = 0;
	} else if (sync && !(nexus->flags & SFAS_NF_SYNC_TESTED)) {
		/*
		 * If the scsi unit is not set to synch transfer and we want
		 * that, we have to negotiate. This should realy base the
		 * period on the clock frequence rather than just check if
		 * >25Mhz
		 */

		nexus->flags |= SFAS_NF_DO_SDTR;
		nexus->period = ((dev->sc_clock_freq>25) ? 100 : 200);
		nexus->offset = 8;

		/* If the user has a long cable, we want to limit the period */
		if ((nexus->period == 100) &&
		    (dev->sc_config_flags & SFAS_SLOW_CABLE))
			nexus->period = 200;
	}

/*
 * Fake a dma-block for polled IO. This way we can use the same code to handle
 * reselection. Much nicer this way.
 */
	if ((mode & SFAS_SELECT_I) || (dev->sc_config_flags & SFAS_NO_DMA)) {
		nexus->dma[0].ptr = (vm_offset_t)buf;
		nexus->dma[0].len = len;
		nexus->dma[0].flg = SFAS_CHAIN_PRG;
		nexus->max_link   = 1;
	} else {
#ifdef SFAS_NEED_VM_PATCH
		if (nexus->vm_link_data.pages)
			sfas_link_vm_link(dev, &nexus->vm_link_data);
#endif
		nexus->max_link = dev->sc_build_dma_chain(dev, nexus->dma,
							  buf, len);
	}

/* Flush the caches. (If needed) */
	if (cpu040 && len && !(mode & SFAS_SELECT_I))
		dma_cachectl(buf, len);
}

int
sfasselect(dev, pendp, cbuf, clen, buf, len, mode)
	struct sfas_softc	*dev;
	struct sfas_pending	*pendp;
	unsigned char		*cbuf;
	int			 clen; 
	unsigned char		*buf;
	int			 len;
	int			 mode;
{
	struct nexus	*nexus;

/* Get the nexus struct. */
	nexus = sfas_arbitate_target(dev, pendp->xs->sc_link->target);
	if (nexus == NULL)
		return(0);

/* Setup the nexus struct. */
	sfas_setup_nexus(dev, nexus, pendp, cbuf, clen, buf, len, mode);

/* Post it to the interrupt machine. */
	sfas_select_unit(dev, pendp->xs->sc_link->target);

	return(1);
}

void
sfas_request_sense(dev, nexus)
	struct sfas_softc *dev;
	struct nexus	 *nexus;
{
	struct scsi_xfer	*xs;
	struct sfas_pending	 pend;
	struct scsi_sense	 rqs;
	int			 stat, mode;

	xs = nexus->xs;

/* Fake a sfas_pending structure. */
	pend.vm_link_data.pages	= 0;
	pend.xs			= xs;

	rqs.opcode = REQUEST_SENSE;
	rqs.byte2 = xs->sc_link->lun << 5;
#ifdef not_yet
	rqs.length=xs->req_sense_length?xs->req_sense_length:sizeof(xs->sense);
#else
	rqs.length=sizeof(xs->sense);
#endif
  
	rqs.unused[0] = rqs.unused[1] = rqs.control = 0;

/*
 * If we are requesting sense during polled IO, we have to sense with polled
 * IO too.
 */
	mode = SFAS_SELECT_RS;
	if (nexus->flags & SFAS_NF_IMMEDIATE)
		mode = SFAS_SELECT_I;

/* Setup the nexus struct for sensing. */
	sfas_setup_nexus(dev, nexus, &pend, (char *)&rqs, sizeof(rqs),
			(char *)&xs->sense, rqs.length, mode);

/* Post it to the interrupt machine. */
	sfas_select_unit(dev, xs->sc_link->target);
}

int
sfasgo(dev, pendp)
	struct sfas_softc   *dev;
	struct sfas_pending *pendp;
{
	int	 s;
	char	*buf;

	buf    = pendp->xs->data;

/*
 * If we need the vm FIX, make buf reflect that.
 */
#ifdef SFAS_NEED_VM_PATCH
	if (pendp->vm_link_data.pages)
		buf = dev->sc_vm_link + pendp->vm_link_data.offset;
#endif

	if (sfasselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen,
		      buf, pendp->xs->datalen, SFAS_SELECT_RS)) {
		/*
		 * We got the command going so the sfas_pending struct is now
		 * free to reuse.
		 */

		s = splbio();
		TAILQ_INSERT_TAIL(&dev->sc_xs_free, pendp, link);
		splx(s);
	} else {
		/*
		 * We couldn't make the command fly so we have to wait. The
		 * struct MUST be inserted at the head to keep the order of
		 * the commands.
		 */

		s = splbio();
		TAILQ_INSERT_HEAD(&dev->sc_xs_pending, pendp, link);
		splx(s);
	}

	return(0);
}

/*
 * Part one of the interrupt machine. Error checks and reselection test.
 * We don't know if we have an active nexus here!
 */
int
sfas_pretests(dev, rp)
	struct sfas_softc *dev;
	sfas_regmap_p	  rp;
{
	struct nexus	*nexus;
	int		 i, s;

	if (dev->sc_interrupt & SFAS_INT_SCSI_RESET_DETECTED) {
		/*
		 * Cleanup and notify user. Lets hope that this is all we
		 * have to do
		 */

		for(i=0; i<8; i++) {
			if (dev->sc_nexus[i].xs)
				sfas_scsidone(dev, dev->sc_nexus[i].xs, -2);

			sfas_init_nexus(dev, &dev->sc_nexus[i]);
		}
		printf("sfasintr: SCSI-RESET detected!");
		return(-1);
	}

	if (dev->sc_interrupt & SFAS_INT_ILLEGAL_COMMAND) {
		/* Something went terrible wrong! Dump some data and panic! */

		printf("FIFO:");
		while(*rp->sfas_fifo_flags & SFAS_FIFO_COUNT_MASK)
			printf(" %x", *rp->sfas_fifo);
		printf("\n");

		printf("CMD: %x\n", *rp->sfas_command);
		panic("sfasintr: ILLEGAL COMMAND!");
	}

	if (dev->sc_interrupt & SFAS_INT_RESELECTED) {
		/* We were reselected. Set the chip as busy */

		s = splbio();
		dev->sc_flags |= SFAS_ACTIVE;
		if (dev->sc_sel_nexus) {
			dev->sc_sel_nexus->flags |= SFAS_NF_SELECT_ME;
			dev->sc_sel_nexus = 0;
		}
		splx(s);

		if (dev->sc_units_disconnected) {
			/* Find out who reselected us. */

			dev->sc_resel[0] &= ~(1<<dev->sc_host_id);

			for(i=0; i<8; i++)
				if (dev->sc_resel[0] & (1<<i))
					break;

			if (i == 8)
				panic("Illegal reselection!");

			if (dev->sc_nexus[i].state == SFAS_NS_DISCONNECTED) {
				/*
				 * This unit had disconnected, so we reconnect
				 * it.
				 */

				dev->sc_cur_nexus = &dev->sc_nexus[i];
				nexus = dev->sc_cur_nexus;

				*rp->sfas_syncper = nexus->syncper;
				*rp->sfas_syncoff = nexus->syncoff;
				*rp->sfas_config3 = nexus->config3;

				*rp->sfas_dest_id = i & 7;

				dev->sc_units_disconnected--;
				dev->sc_msg_in_len= 0;

#ifdef SFAS_NEED_VM_PATCH
				if (nexus->vm_link_data.pages)
				  sfas_link_vm_link(dev, &nexus->vm_link_data);
#endif

				/* Restore active pointers. */
				sfas_restore_pointers(dev);

				nexus->state = SFAS_NS_RESELECTED;

				*rp->sfas_command = SFAS_CMD_MESSAGE_ACCEPTED;

				return(1);
			}
		}

		/* Somehow we got an illegal reselection. Dump and panic. */
		printf("sfasintr: resel[0] %x resel[1] %x disconnected %d\n",
		       dev->sc_resel[0], dev->sc_resel[1],
		       dev->sc_units_disconnected);
		panic("sfasintr: Unexpected reselection!");
	}

	return(0);
}

/*
 * Part two of the interrupt machine. Handle disconnection and post command
 * processing. We know that we have an active nexus here.
 */
int
sfas_midaction(dev, rp, nexus)
	struct sfas_softc *dev;
	sfas_regmap_p	  rp;
	struct nexus	 *nexus;
{
	int	i, left, len, s;
	u_char	status, msg;

	if (dev->sc_interrupt & SFAS_INT_DISCONNECT) {
		s = splbio();
		dev->sc_cur_nexus = 0;

		/* Mark chip as busy and clean up the chip FIFO. */
		dev->sc_flags &= ~SFAS_ACTIVE;
		*rp->sfas_command = SFAS_CMD_FLUSH_FIFO;

#ifdef SFAS_NEED_VM_PATCH
		sfas_unlink_vm_link(dev);
#endif

		/* Let the nexus state reflect what we have to do. */
		switch(nexus->state) {
		case SFAS_NS_SELECTED:
			dev->sc_sel_nexus = 0;
			nexus->flags &= ~SFAS_NF_SELECT_ME;

			/*
			 * We were trying to select the unit. Probably no unit
			 * at this ID.
			 */
			nexus->xs->resid = dev->sc_len;

			nexus->status = -2;
			nexus->flags &= ~SFAS_NF_UNIT_BUSY;
			nexus->state = SFAS_NS_FINISHED;
			break;
	  
		case SFAS_NS_SENSE:
			/*
			 * Oops! We have to request sense data from this unit.
			 * Do so.
			 */
			dev->sc_led(dev, 0);
			nexus->flags |= SFAS_NF_REQUEST_SENSE;
			sfas_request_sense(dev, nexus);
			break;
	  
		case SFAS_NS_DONE:
			/* All done. */
			nexus->xs->resid = dev->sc_len;

			nexus->flags &= ~SFAS_NF_UNIT_BUSY;
			nexus->state  = SFAS_NS_FINISHED;
			dev->sc_led(dev, 0);
			break;

		case SFAS_NS_DISCONNECTING:
			/*
			 * We have recieved a DISCONNECT message, so we are
			 * doing a normal disconnection.
			 */
			nexus->state = SFAS_NS_DISCONNECTED;

			dev->sc_units_disconnected++;
			break;

		case SFAS_NS_RESET:
			/*
			 * We were reseting this SCSI-unit. Clean up the
			 * nexus struct.
			 */
			dev->sc_led(dev, 0);
			sfas_init_nexus(dev, nexus);
			break;

		default:
			/*
			 * Unexpected disconnection! Cleanup and exit. This
			 * shouldn't cause any problems.
			 */
			printf("sfasintr: Unexpected disconnection\n");
			printf("sfasintr: u %x s %d p %d f %x c %x\n",
			       nexus->lun_unit, nexus->state, 
			       dev->sc_status & SFAS_STAT_PHASE_MASK,
			       nexus->flags, nexus->cbuf[0]);
			
			nexus->xs->resid = dev->sc_len;

			nexus->flags &= ~SFAS_NF_UNIT_BUSY;
			nexus->state = SFAS_NS_FINISHED;
			nexus->status = -3;
	      
			dev->sc_led(dev, 0);
			break;
		}

		/*
		 * If we have disconnected units, we MUST enable reselection
		 * within 250ms.
		 */
		if (dev->sc_units_disconnected &&
		    !(dev->sc_flags & SFAS_ACTIVE))
			*rp->sfas_command = SFAS_CMD_ENABLE_RESEL;

		splx(s);

		/* Select the first pre-initialized nexus we find. */
		for(i=0; i<8; i++)
			if (dev->sc_nexus[i].flags & SFAS_NF_SELECT_ME)
				if (sfas_select_unit(dev, i) == 2)
					break;

		/* Does any unit need sense data? */
		for(i=0; i<8; i++)
			if (dev->sc_nexus[i].flags & SFAS_NF_REQUEST_SENSE) {
				sfas_request_sense(dev, &dev->sc_nexus[i]);
				break;
			}
      
		/* We are done with this nexus! */
		if (nexus->state == SFAS_NS_FINISHED)
			sfas_scsidone(dev, nexus->xs, nexus->status);

		return(1);
	}

	switch(nexus->state) {
	case SFAS_NS_SELECTED:
		dev->sc_cur_nexus = nexus;
		dev->sc_sel_nexus = 0;

		nexus->flags &= ~SFAS_NF_SELECT_ME;

		/*
		 * We have selected a unit. Setup chip, restore pointers and
		 * light the led.
		 */
		*rp->sfas_syncper = nexus->syncper;
		*rp->sfas_syncoff = nexus->syncoff;
		*rp->sfas_config3 = nexus->config3;
		
		sfas_restore_pointers(dev);

		if (!(nexus->flags & SFAS_NF_SENSING))
			nexus->status	= 0xFF;
		dev->sc_msg_in[0] = 0xFF;
		dev->sc_msg_in_len= 0;
		
		dev->sc_led(dev, 1);

		break;

	case SFAS_NS_DATA_IN:
	case SFAS_NS_DATA_OUT:
		/* We have transfered data. */
		if (dev->sc_dma_len)
			if (dev->sc_cur_link < dev->sc_max_link) {
				/*
				 * Clean up dma and at the same time get how
				 * many bytes that were NOT transfered.
				 */
			  left = dev->sc_setup_dma(dev, 0, 0, SFAS_DMA_CLEAR);
			  len  = dev->sc_dma_len;

			  if (nexus->state == SFAS_NS_DATA_IN) {
			    /*
			     * If we were bumping we may have had an odd length
			     * which means that there may be bytes left in the
			     * fifo. We also need to move the data from the
			     * bump buffer to the actual memory.
			     */
			    if (dev->sc_dma_buf == dev->sc_bump_pa)
			    {
			      while((*rp->sfas_fifo_flags&SFAS_FIFO_COUNT_MASK)
				    && left)
				dev->sc_bump_va[len-(left--)] = *rp->sfas_fifo;
		    
			      bcopy(dev->sc_bump_va, dev->sc_buf, len-left);
			    }
			  } else {
			    /* Count any unsent bytes and flush them. */
			    left+= *rp->sfas_fifo_flags & SFAS_FIFO_COUNT_MASK;
			    *rp->sfas_command = SFAS_CMD_FLUSH_FIFO;
			  }

			  /*
			   * Update pointers/length to reflect the transfered
			   * data.
			   */
			  dev->sc_len -= len-left;
			  dev->sc_buf += len-left;
			  
			  dev->sc_dma_buf += len-left;
			  dev->sc_dma_len  = left;
			  
			  dev->sc_dma_blk_ptr += len-left;
			  dev->sc_dma_blk_len -= len-left;

			  /*
			   * If it was the end of a dma block, we select the
			   * next to begin with.
			   */	    
			  if (!dev->sc_dma_blk_len)
			    dev->sc_cur_link++;
			}
		break;

	case SFAS_NS_STATUS:
		/*
		 * If we were not sensing, grab the status byte. If we were
		 * sensing and we got a bad status, let the user know.
		 */

		status = *rp->sfas_fifo;
		msg = *rp->sfas_fifo;

		if (!(nexus->flags & SFAS_NF_SENSING))
			nexus->status = status;
		else if (status != 0)
			nexus->status = -1;

		/*
		 * Preload the command complete message. Handeled in
		 * sfas_postaction.
		 */
		dev->sc_msg_in[0] = msg;
		dev->sc_msg_in_len = 1;
		nexus->flags |= SFAS_NF_HAS_MSG;
		break;

	default:
		break;
	}

	return(0);
}

/*
 * Part three of the interrupt machine. Handle phase changes (and repeated
 * phase passes). We know that we have an active nexus here.
 */
int
sfas_postaction(dev, rp, nexus)
	struct sfas_softc *dev;
	sfas_regmap_p	  rp;
	struct nexus	 *nexus;
{
	int	i, left, len;
	u_char	cmd;
	short	offset, period;

	cmd = 0;

	switch(dev->sc_status & SFAS_STAT_PHASE_MASK) {
	case SFAS_PHASE_DATA_OUT:
	case SFAS_PHASE_DATA_IN:
		if ((dev->sc_status & SFAS_STAT_PHASE_MASK) ==
		    SFAS_PHASE_DATA_OUT)
			nexus->state = SFAS_NS_DATA_OUT;
		else
			nexus->state = SFAS_NS_DATA_IN;

		/* Make DMA ready to accept new data. Load active pointers
		 * from the DMA block. */
		dev->sc_setup_dma(dev, 0, 0, SFAS_DMA_CLEAR);
		if (dev->sc_cur_link < dev->sc_max_link) {
		  if (!dev->sc_dma_blk_len) {
		    dev->sc_dma_blk_ptr = dev->sc_chain[dev->sc_cur_link].ptr;
		    dev->sc_dma_blk_len = dev->sc_chain[dev->sc_cur_link].len;
		    dev->sc_dma_blk_flg = dev->sc_chain[dev->sc_cur_link].flg;
		  }

		  /* We should use polled IO here. */
		  if (dev->sc_dma_blk_flg == SFAS_CHAIN_PRG) {
			sfas_ixfer(dev);
			dev->sc_cur_link++;
			dev->sc_dma_len = 0;
			break;
		  }
		  else if (dev->sc_dma_blk_flg == SFAS_CHAIN_BUMP)
			len = dev->sc_dma_blk_len;
		  else
			len = dev->sc_need_bump(dev, dev->sc_dma_blk_ptr,
						dev->sc_dma_blk_len);

		  /*
		   * If len != 0 we must bump the data, else we just DMA it
		   * straight into memory.
		   */
		  if (len) {
			dev->sc_dma_buf = dev->sc_bump_pa;
			dev->sc_dma_len = len;
	      
			if (nexus->state == SFAS_NS_DATA_OUT)
			  bcopy(dev->sc_buf, dev->sc_bump_va, dev->sc_dma_len);
		  } else {
			dev->sc_dma_buf = dev->sc_dma_blk_ptr;
			dev->sc_dma_len = dev->sc_dma_blk_len;
		  }

		  /* Load DMA with adress and length of transfer. */
		  dev->sc_setup_dma(dev, dev->sc_dma_buf, dev->sc_dma_len,
				    ((nexus->state == SFAS_NS_DATA_OUT) ?
				     SFAS_DMA_WRITE : SFAS_DMA_READ));

		  cmd = SFAS_CMD_TRANSFER_INFO | SFAS_CMD_DMA;
		} else {
			/*
			 * Hmmm, the unit wants more info than we have or has
			 * more than we want. Let the chip handle that.
			 */

			*rp->sfas_tc_low = 256;
			*rp->sfas_tc_mid = 0;
			*rp->sfas_tc_high = 0;
			cmd = SFAS_CMD_TRANSFER_PAD;
		}
		break;

	case SFAS_PHASE_COMMAND:
		/* The scsi unit wants the command, send it. */
		nexus->state = SFAS_NS_SVC;

		*rp->sfas_command = SFAS_CMD_FLUSH_FIFO;
		for(i=0; i<5; i++);

		for(i=0; i<nexus->clen; i++)
			*rp->sfas_fifo = nexus->cbuf[i];
		cmd = SFAS_CMD_TRANSFER_INFO;
		break;

	case SFAS_PHASE_STATUS:
		/*
		 * We've got status phase. Request status and command
		 * complete message.
		 */
		nexus->state = SFAS_NS_STATUS;
		cmd = SFAS_CMD_COMMAND_COMPLETE;
		break;

	case SFAS_PHASE_MESSAGE_OUT:
		/*
		 * Either the scsi unit wants us to send a message or we have
		 * asked for it by seting the ATN bit.
		 */
		nexus->state = SFAS_NS_MSG_OUT;

		*rp->sfas_command = SFAS_CMD_FLUSH_FIFO;
		
		if (nexus->flags & SFAS_NF_DO_SDTR) {
			/* Send a Synchronous Data Transfer Request. */

			sfas_build_sdtrm(dev, nexus->period, nexus->offset);
			nexus->flags |= SFAS_NF_SDTR_SENT;
			nexus->flags &= ~SFAS_NF_DO_SDTR;
		} else if (nexus->flags & SFAS_NF_RESET) {
			/* Send a reset scsi unit message. */

			dev->sc_msg_out[0] = 0x0C;
			dev->sc_msg_out_len = 1;
			nexus->state = SFAS_NS_RESET;
			nexus->flags &= ~SFAS_NF_RESET;
		} else if (dev->sc_msg_out_len == 0) {
			/* Don't know what to send so we send a NOP message. */

			dev->sc_msg_out[0] = 0x08;
			dev->sc_msg_out_len = 1;
		}

		cmd = SFAS_CMD_TRANSFER_INFO;

		for(i=0; i<dev->sc_msg_out_len; i++)
			*rp->sfas_fifo = dev->sc_msg_out[i];
		dev->sc_msg_out_len = 0;

		break;

	case SFAS_PHASE_MESSAGE_IN:
		/* Receive a message from the scsi unit. */
		nexus->state = SFAS_NS_MSG_IN;

		while(!(nexus->flags & SFAS_NF_HAS_MSG)) {
			*rp->sfas_command = SFAS_CMD_TRANSFER_INFO;
			sfasiwait(dev);

			dev->sc_msg_in[dev->sc_msg_in_len++] = *rp->sfas_fifo;

			/* Check if we got all the bytes in the message. */
			if (dev->sc_msg_in[0] >= 0x80)       ;
			else if (dev->sc_msg_in[0] >= 0x30)  ;
			else if (((dev->sc_msg_in[0] >= 0x20) &&
				  (dev->sc_msg_in_len == 2)) ||
				 ((dev->sc_msg_in[0] != 0x01) &&
				  (dev->sc_msg_in_len == 1))) {
				nexus->flags |= SFAS_NF_HAS_MSG;
				break;
			} else {
			  if (dev->sc_msg_in_len >= 2)
			    if ((dev->sc_msg_in[1]+2) == dev->sc_msg_in_len) {
				nexus->flags |= SFAS_NF_HAS_MSG;
				break;
			    }
			}

			*rp->sfas_command = SFAS_CMD_MESSAGE_ACCEPTED;
			sfasiwait(dev);

			if ((dev->sc_status & SFAS_STAT_PHASE_MASK) !=
			    SFAS_PHASE_MESSAGE_IN)
				break;
		}

		cmd = SFAS_CMD_MESSAGE_ACCEPTED;
		if (nexus->flags & SFAS_NF_HAS_MSG) {
			/* We have a message. Decode it. */

			switch(dev->sc_msg_in[0]) {
			case 0x00:	/* COMMAND COMPLETE */
				if ((nexus->status == SCSI_CHECK) &&
				    !(nexus->flags & SFAS_NF_SENSING))
					nexus->state = SFAS_NS_SENSE;
				else
					nexus->state = SFAS_NS_DONE;
				break;
			case 0x04:	/* DISCONNECT */
				nexus->state = SFAS_NS_DISCONNECTING;
				break;
			case 0x02:	/* SAVE DATA POINTER */
				sfas_save_pointers(dev);
				break;
			case 0x03:	/* RESTORE DATA POINTERS */
				sfas_restore_pointers(dev);
				break;
			case 0x07:	/* MESSAGE REJECT */
				/*
				 * If we had sent a SDTR and we got a message
				 * reject, the scsi docs say that we must go
				 * to async transfer.
				 */
				if (nexus->flags & SFAS_NF_SDTR_SENT) {
					nexus->flags &= ~SFAS_NF_SDTR_SENT;

					nexus->config3 &= ~SFAS_CFG3_FASTSCSI;
					nexus->syncper = 5;
					nexus->syncoff = 0;
					
					*rp->sfas_syncper = nexus->syncper;
					*rp->sfas_syncoff = nexus->syncoff;
					*rp->sfas_config3 = nexus->config3;
				} else
				/*
				 * Something was rejected but we don't know
				 * what! PANIC!
				 */
				  panic("sfasintr: Unknown message rejected!");
				break;
			case 0x08:	/* MO OPERATION */
				break;
			case 0x01:	/* EXTENDED MESSAGE */
				switch(dev->sc_msg_in[2]) {
				case 0x01:/* SYNC. DATA TRANSFER REQUEST */
					/* Decode the SDTR message. */
					period = 4*dev->sc_msg_in[3];
					offset = dev->sc_msg_in[4];

					/*
					 * Make sure that the specs are within
					 * chip limits. Note that if we
					 * initiated the negotiation the specs
					 * WILL be withing chip limits. If it
					 * was the scsi unit that initiated
					 * the negotiation, the specs may be
					 * to high.
					 */
					if (offset > 16)
						offset = 16;
					if ((period < 200) &&
					    (dev->sc_clock_freq <= 25))
						period = 200;

					if (offset == 0)
					       period = 5*dev->sc_clock_period;

					nexus->syncper = period/
							  dev->sc_clock_period;
					nexus->syncoff = offset;

					if (period < 200)
					  nexus->config3 |= SFAS_CFG3_FASTSCSI;
					else
					  nexus->config3 &=~SFAS_CFG3_FASTSCSI;

					nexus->flags |= SFAS_NF_SYNC_TESTED;

					*rp->sfas_syncper = nexus->syncper;
					*rp->sfas_syncoff = nexus->syncoff;
					*rp->sfas_config3 = nexus->config3;
					
					/*
					 * Hmmm, it seems that the scsi unit
					 * initiated sync negotiation, so lets
					 * reply acording to scsi-2 standard.
					 */
					if (!(nexus->flags& SFAS_NF_SDTR_SENT))
					{
					  if ((dev->sc_config_flags &
					       SFAS_NO_SYNCH) ||
					      (dev->sc_config_flags &
					       SFAS_NO_DMA) ||
					      sfas_inhibit_sync[
							nexus->lun_unit & 7]) {
					          period = 200;
					          offset = 0;
					  }

					  nexus->offset = offset;
					  nexus->period = period;
					  nexus->flags |= SFAS_NF_DO_SDTR;
					  *rp->sfas_command = SFAS_CMD_SET_ATN;
					}

					nexus->flags &= ~SFAS_NF_SDTR_SENT;
					break;

				case 0x00: /* MODIFY DATA POINTERS */
				case 0x02: /* EXTENDED IDENTIFY (SCSI-1) */
				case 0x03: /* WIDE DATA TRANSFER REQUEST */
			        default:
					/* Reject any unhandeled messages. */

					dev->sc_msg_out[0] = 0x07;
					dev->sc_msg_out_len = 1;
					*rp->sfas_command = SFAS_CMD_SET_ATN;
					cmd = SFAS_CMD_MESSAGE_ACCEPTED;
					break;
				}
				break;

			default:
				/* Reject any unhandeled messages. */

				dev->sc_msg_out[0] = 0x07;
				dev->sc_msg_out_len = 1;
				*rp->sfas_command = SFAS_CMD_SET_ATN;
				cmd = SFAS_CMD_MESSAGE_ACCEPTED;
				break;
			}
			nexus->flags &= ~SFAS_NF_HAS_MSG;
			dev->sc_msg_in_len = 0;
		}
		break;
	default:
		printf("SFASINTR: UNKNOWN PHASE! phase: %d\n",
		       dev->sc_status & SFAS_STAT_PHASE_MASK);
		dev->sc_led(dev, 0);
		sfas_scsidone(dev, nexus->xs, -4);

		return(-1);
	}

	if (cmd)
		*rp->sfas_command = cmd;

	return(0);
}

/*
 * Stub for interrupt machine.
 */
void
sfasintr(dev)
	struct sfas_softc *dev;
{
	sfas_regmap_p	 rp;
	struct nexus	*nexus;
	int		 s;

	rp = dev->sc_fas;

	if (!sfas_pretests(dev, rp)) {
		nexus = dev->sc_cur_nexus;
		if (nexus == NULL)
			nexus = dev->sc_sel_nexus;

		if (nexus)
			if (!sfas_midaction(dev, rp, nexus))
				sfas_postaction(dev, rp, nexus);
	}
}

/*
 * sfasicmd is used to perform IO when we can't use interrupts. sfasicmd
 * emulates the normal environment by waiting for the chip and calling
 * sfasintr.
 */
void
sfasicmd(dev, pendp)
	struct sfas_softc   *dev;
	struct sfas_pending *pendp;
{
	sfas_regmap_p	 rp;
	struct nexus	*nexus;

	nexus = &dev->sc_nexus[pendp->xs->sc_link->target];
	rp = dev->sc_fas;

	if (!sfasselect(dev, pendp, (char *)pendp->xs->cmd, pendp->xs->cmdlen,
			(char *)pendp->xs->data, pendp->xs->datalen,
			SFAS_SELECT_I))
		panic("sfasicmd: Couldn't select unit");

	while(nexus->state != SFAS_NS_FINISHED) {
		sfasiwait(dev);
		sfasintr(dev);
	}

	nexus->flags &= ~SFAS_NF_SYNC_TESTED;
}