freebsd-dev/sys/i386/isa/ncr5380.c

/*
 * FreeBSD generic NCR-5380/NCR-53C400 SCSI driver
 *
 * Copyright (C) 1994 Serge Vakulenko (vak@cronyx.ru)
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``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 DEVELOPERS 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.
 */

/*
 * Tested on the following hardware:
 *  Adapter: Trantor T130
 * Streamer: Archive Viper 150,
 *   CD-ROM: NEC CDR-25
 */
#undef DEBUG

#include "nca.h"
#if NNCA > 0

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

#include <machine/clock.h>

#include <i386/isa/isa_device.h>
#include <i386/isa/ic/ncr5380.h>
#include <i386/isa/ic/ncr53400.h>

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

#include "ioconf.h"

#ifdef DEBUG
#   define PRINT(s)     printf s
#else
#   define PRINT(s)     /*void*/
#endif

#define SCB_TABLE_SIZE	8	/* start with 8 scb entries in table */
#define BLOCK_SIZE	512	/* size of READ/WRITE areas on SCSI card */
#define HOST_SCSI_ADDR  7       /* address of the adapter on the SCSI bus */

/*
 * Defice config flags
 */
#define FLAG_NOPARITY   0x01    /* disable SCSI bus parity check */

/*
 * ProAudioSpectrum registers
 */
#define PAS16_DATA              8       /* Data Register */
#define PAS16_STAT              9       /* Status Register */
#define PAS16_STAT_DREQ         0x80    /* Pseudo-DMA ready bit */
#define PAS16_REG(r)            (((r) & 0xc) << 11 | ((r) & 3))

static u_char pas16_irq_magic[] =
    { 0,  0,  1,  2,  3,  4,  5,  6, 0,  0,  7,  8,  9,  0, 10, 11 };

/*
 * SCSI bus phases
 */
#define PHASE_MASK              (CSBR_MSG | CSBR_CD | CSBR_IO)
#define PHASE_DATAOUT           0
#define PHASE_DATAIN            CSBR_IO
#define PHASE_CMDOUT            CSBR_CD
#define PHASE_STATIN            (CSBR_CD | CSBR_IO)
#define PHASE_MSGOUT            (CSBR_MSG | CSBR_CD)
#define PHASE_MSGIN             (CSBR_MSG | CSBR_CD | CSBR_IO)
#define PHASE_NAME(ph)          phase_name[(ph)>>2]
#define PHASE_TO_TCR(ph)        ((ph) >> 2)

static char *phase_name[] = {
	"DATAOUT", "DATAIN",  "CMDOUT", "STATIN",
	"Phase4?", "Phase5?", "MSGOUT", "MSGIN",
};

/*
 * SCSI message codes
 */
#define MSG_COMMAND_COMPLETE	0x00
#define MSG_SAVE_POINTERS	0x02
#define MSG_RESTORE_POINTERS	0x03
#define MSG_DISCONNECT          0x04
#define MSG_ABORT               0x06
#define	MSG_MESSAGE_REJECT	0x07
#define MSG_NOP                 0x08
#define MSG_BUS_DEV_RESET	0x0c
#define MSG_IDENTIFY(lun)       (0xc0 | ((lun) & 0x7))
#define MSG_ISIDENT(m)          ((m) & 0x80)

/*
 * SCSI control block used to keep info about a scsi command
 */
typedef struct scb {
	int flags;                      /* status of the instruction */
#define SCB_FREE        0x00
#define SCB_ACTIVE      0x01
#define SCB_ABORTED     0x02
#define SCB_TIMEOUT     0x04
#define SCB_ERROR       0x08
#define SCB_TIMECHK     0x10            /* we have set a timeout on this one */
#define SCB_SENSE       0x20            /* sensed data available */
#define SCB_TBUSY       0x40            /* target busy */
	struct scb *next;               /* in free list */
	struct scsi_xfer *xfer;		/* the scsi_xfer for this cmd */
	u_char *data;                   /* position in data buffer so far */
	int32_t datalen;			/* bytes remaining to transfer */;
} scb_t;

typedef enum {
	CTLR_NONE,
	CTLR_NCR_5380,
	CTLR_NCR_53C400,
	CTLR_PAS_16,
} ctlr_t;

/*
 * Data structure describing the target state.
 */
typedef struct {
	u_char  busy;                   /* mask of busy luns at device target */
	u_long  perrcnt;                /* counter of target parity errors */
} target_t;

/*
 * Data structure describing current status of the scsi bus. One for each
 * controller card.
 */
typedef struct {
	ctlr_t  type;                   /* Seagate or Future Domain */
	char    *name;                  /* adapter name */

	/* NCR-5380 controller registers */
	u_short ODR;            /* (wo-0) Output Data Register */
	u_short CSDR;           /* (ro-0) Current SCSI Data Register */
	u_short ICR;            /* (rw-1) Initiator Command Register */
	u_short MR;             /* (rw-2) Mode Register */
	u_short TCR;            /* (rw-3) Target Command Register */
	u_short SER;            /* (wo-4) Select Enable Register */
	u_short CSBR;           /* (ro-4) Current SCSI Bus Status Register */
	u_short BSR;            /* (ro-5) Bus and Status Register */
	u_short SDSR;           /* (wo-5) Start DMA Send Register */
	u_short SDIR;           /* (wo-7) Start DMA Initiator Receive Register */
	u_short RPIR;           /* (ro-7) Reset Parity/Interrupt Register */

	/* NCR-53C400 controller registers */
	u_short CSR;            /* (rw-0) Control and Status Register */
	u_short CCR;            /* (rw-1) Clock Counter Register */
	u_short HBR;            /* (rw-4) Host Buffer Register */

	/* ProAudioSpectrum controller registers */
	u_short PDATA;          /* (rw) Pseudo-DMA Data Register */
	u_short PSTAT;          /* (rw) Pseudo-DMA Status Register */

	u_char  scsi_addr;              /* our scsi address, 0..7 */
	u_char  scsi_id;                /* our scsi id mask */
	u_char  parity;                 /* parity flag: CMD_EN_PARITY or 0 */
	u_char  irq;                    /* IRQ number used or 0 if no IRQ */
	u_int   timeout_active : 1;     /* timeout() active (requested) */

	struct scsi_link sc_link;	/* struct connecting different data */
	scb_t   *queue;                 /* waiting to be issued */
	scb_t   *disconnected_queue;    /* waiting to reconnect */

	int     numscb;                 /* number of scsi control blocks */
	scb_t   *free_scb;              /* free scb list */
	scb_t   scbs[SCB_TABLE_SIZE];

	target_t target[8];             /* target state data */
} adapter_t;

static adapter_t ncadata[NNCA];

#define IS_BUSY(a,b)    ((a)->target[(b)->xfer->sc_link->target].busy &\
				(1 << (b)->xfer->sc_link->lun))
#define SET_BUSY(a,b)   ((a)->target[(b)->xfer->sc_link->target].busy |=\
				(1 << (b)->xfer->sc_link->lun))
#define CLEAR_BUSY(a,b) ((a)->target[(b)->xfer->sc_link->target].busy &=\
				~(1 << (b)->xfer->sc_link->lun))

/*
 * Wait for condition, given as an boolean expression.
 * Print the message on timeout.
 */
#define WAITFOR(condition,count,message) {\
	register u_long cnt = count; char *msg = message;\
	while (cnt-- && ! (condition)) continue;\
	if (cnt == -1 && msg)\
		printf ("nca: %s timeout\n", msg); }

static int nca_probe (struct isa_device *dev);
static int nca_attach (struct isa_device *dev);
static int32_t nca_scsi_cmd (struct scsi_xfer *xs);
static u_int32_t nca_adapter_info (int unit);
static void nca_timeout (void *scb);
static void ncaminphys (struct buf *bp);
static void nca_done (adapter_t *z, scb_t *scb);
static void nca_start (adapter_t *z);
static void nca_information_transfer (adapter_t *z, scb_t *scb);
static int nca_poll (adapter_t *z, scb_t *scb);
static int nca_init (adapter_t *z);
static int nca_reselect (adapter_t *z);
static int nca_select (adapter_t *z, scb_t *scb);
static int nca_abort (adapter_t *z, scb_t *scb);
static void nca_send_abort (adapter_t *z);
static u_char nca_msg_input (adapter_t *z);
static void nca_tick (void *arg);
static int nca_sense (adapter_t *z, scb_t *scb);
static void nca_data_output (adapter_t *z, u_char **pdata, u_long *plen);
static void nca_data_input (adapter_t *z, u_char **pdata, u_long *plen);
static void nca_cmd_output (adapter_t *z, u_char *cmd, int cmdlen);
static void nca_53400_dma_xfer (adapter_t *z, int r, u_char **dat, u_long *len);
static void nca_pas_dma_xfer (adapter_t *z, int r, u_char **dat, u_long *len);

static struct scsi_adapter nca_switch = {
	nca_scsi_cmd, ncaminphys, 0, 0, nca_adapter_info, "nca", {0},
};
static struct scsi_device nca_dev = { NULL, NULL, NULL, NULL, "nca", 0, {0} };
struct isa_driver ncadriver = { nca_probe, nca_attach, "nca" };

/*
 * Check if the device can be found at the port given and if so,
 * detect the type of board. Set it up ready for further work.
 * Takes the isa_dev structure from autoconf as an argument.
 * Returns 1 if card recognized, 0 if errors.
 */
int nca_probe (struct isa_device *dev)
{
	adapter_t *z = &ncadata[dev->id_unit];
	int i;

	/* Init fields used by our routines */
	z->parity = (dev->id_flags & FLAG_NOPARITY) ? 0 :
		MR_ENABLE_PARITY_CHECKING;
	z->scsi_addr = HOST_SCSI_ADDR;
	z->scsi_id = 1 << z->scsi_addr;
	z->irq = dev->id_irq ? ffs (dev->id_irq) - 1 : 0;
	z->queue = 0;
	z->disconnected_queue = 0;
	for (i=0; i<8; i++)
		z->target[i].busy = 0;

	/* Link up the free list of scbs */
	z->numscb = SCB_TABLE_SIZE;
	z->free_scb = z->scbs;
	for (i=1; i<SCB_TABLE_SIZE; i++)
		z->scbs[i-1].next = z->scbs + i;
	z->scbs[SCB_TABLE_SIZE-1].next = 0;

	/* Try NCR 5380. */
	z->type  = CTLR_NCR_5380;
	z->name  = "NCR-5380";
	z->ODR   = dev->id_iobase + C80_ODR;
	z->CSDR  = dev->id_iobase + C80_CSDR;
	z->ICR   = dev->id_iobase + C80_ICR;
	z->MR    = dev->id_iobase + C80_MR;
	z->TCR   = dev->id_iobase + C80_TCR;
	z->SER   = dev->id_iobase + C80_SER;
	z->CSBR  = dev->id_iobase + C80_CSBR;
	z->BSR   = dev->id_iobase + C80_BSR;
	z->SDSR  = dev->id_iobase + C80_SDSR;
	z->SDIR  = dev->id_iobase + C80_SDIR;
	z->RPIR  = dev->id_iobase + C80_RPIR;
	z->CSR   = 0;
	z->CCR   = 0;
	z->HBR   = 0;
	z->PDATA = 0;
	z->PSTAT = 0;
	if (nca_init (z) == 0)
		return (8);

	/* Try NCR 53C400. */
	z->type  = CTLR_NCR_53C400;
	z->name  = "NCR-53C400";
	z->ODR   = dev->id_iobase + C400_5380_REG_OFFSET + C80_ODR;
	z->CSDR  = dev->id_iobase + C400_5380_REG_OFFSET + C80_CSDR;
	z->ICR   = dev->id_iobase + C400_5380_REG_OFFSET + C80_ICR;
	z->MR    = dev->id_iobase + C400_5380_REG_OFFSET + C80_MR;
	z->TCR   = dev->id_iobase + C400_5380_REG_OFFSET + C80_TCR;
	z->SER   = dev->id_iobase + C400_5380_REG_OFFSET + C80_SER;
	z->CSBR  = dev->id_iobase + C400_5380_REG_OFFSET + C80_CSBR;
	z->BSR   = dev->id_iobase + C400_5380_REG_OFFSET + C80_BSR;
	z->SDSR  = dev->id_iobase + C400_5380_REG_OFFSET + C80_SDSR;
	z->SDIR  = dev->id_iobase + C400_5380_REG_OFFSET + C80_SDIR;
	z->RPIR  = dev->id_iobase + C400_5380_REG_OFFSET + C80_RPIR;
	z->CSR   = dev->id_iobase + C400_CSR;
	z->CCR   = dev->id_iobase + C400_CCR;
	z->HBR   = dev->id_iobase + C400_HBR;
	z->PDATA = 0;
	z->PSTAT = 0;
	if (nca_init (z) == 0)
		return (16);

	/* Try ProAudioSpectrum-16. */
	z->type  = CTLR_PAS_16;
	z->name  = "ProAudioSpectrum"; /* changed later */
	z->ODR   = dev->id_iobase ^ PAS16_REG (C80_ODR);
	z->CSDR  = dev->id_iobase ^ PAS16_REG (C80_CSDR);
	z->ICR   = dev->id_iobase ^ PAS16_REG (C80_ICR);
	z->MR    = dev->id_iobase ^ PAS16_REG (C80_MR);
	z->TCR   = dev->id_iobase ^ PAS16_REG (C80_TCR);
	z->SER   = dev->id_iobase ^ PAS16_REG (C80_SER);
	z->CSBR  = dev->id_iobase ^ PAS16_REG (C80_CSBR);
	z->BSR   = dev->id_iobase ^ PAS16_REG (C80_BSR);
	z->SDSR  = dev->id_iobase ^ PAS16_REG (C80_SDSR);
	z->SDIR  = dev->id_iobase ^ PAS16_REG (C80_SDIR);
	z->RPIR  = dev->id_iobase ^ PAS16_REG (C80_RPIR);
	z->CSR   = 0;
	z->CCR   = 0;
	z->HBR   = 0;
	z->PDATA = dev->id_iobase ^ PAS16_REG (PAS16_DATA);
	z->PSTAT = dev->id_iobase ^ PAS16_REG (PAS16_STAT);
	if (nca_init (z) == 0)
		return (4);

	bzero (z, sizeof (*z));
	return (0);
}

/*
 * Probe the adapter, and if found, reset the board and the scsi bus.
 * Return 0 if the adapter found.
 */
int nca_init (adapter_t *z)
{
	int i, c;

	if (z->type == CTLR_NCR_53C400) {
		if (inb (z->CSR) == 0xFF)
			return (100);

		/* Reset 53C400. */
		outb (z->CSR, CSR_5380_ENABLE);

		/* Enable interrupts. */
		outb (z->CSR, z->irq ? CSR_5380_INTR : 0);
	}

	if (z->type == CTLR_PAS_16) {
		u_short base = z->PDATA & 0x3FF;

		outb (0x9a01, 0xbc + (z-ncadata));      /* unit number */
		outb (0x9a01, base >> 2);

		if (inb (base^0x803) == 0xFF)
			return (200);

		if (inb (z->CSDR) == 0xFF && inb (z->CSDR^0x2000) == 0xFF &&
		    inb (z->CSDR) == 0xFF && inb (z->CSDR^0x2000) == 0xFF &&
		    inb (z->CSDR) == 0xFF && inb (z->CSDR^0x2000) == 0xFF &&
		    inb (z->CSDR) == 0xFF && inb (z->CSDR^0x2000) == 0xFF)
			return (201);

		i = inb (base^0x803);
		outb (base^0x803, i ^ 0xE0);
		c = inb (base^0x803);
		outb (base^0x803, 1);
		if (i != c)
			return (202);

		/* Various magic. */
		outb (base^0x4000, 0x30);  /* Timeout counter */
		outb (base^0x4001, 0x01);  /* Reset TC */
		outb (base^0xbc00, 0x01);  /* 1 Wait state */
		outb (base^0x8003, 0x4d);  /* sysconfig_4 */
		i = pas16_irq_magic[z->irq];
		if (!i) {
		    z->irq = 0;
		} else {
		    outb (base^0xf002, i << 4);
		    outb (base^0x8003, 0x6d);  /* sysconfig_4 */
		}

		switch (inb (base^0xEC03) & 0xF) {
		case 6:  z->name = "ProAudioSpectrum-Plus"; break;
		case 12: z->name = "ProAudioSpectrum-16D";  break;
		case 14: z->name = "ProAudioSpectrum-CDPC"; break;
		case 15: z->name = "ProAudioSpectrum-16";   break;
		default: return (203);
		}
	}

	/* Read RPI port, resetting parity/interrupt state. */
	inb (z->RPIR);

	/* Test BSR: parity error, interrupt request and busy loss state
	 * should be cleared. */
	if (inb (z->BSR) & (BSR_PARITY_ERROR |
	    BSR_INTERRUPT_REQUEST_ACTIVE | BSR_BUSY_ERROR)) {
		PRINT (("nca: invalid bsr[0x%x]=%b\n", z->BSR,
			inb (z->BSR), BSR_BITS));
		return (1);
	}

	/* Reset the SCSI bus. */
	outb (z->ICR, ICR_ASSERT_RST);
	outb (z->ODR, 0);
	/* Hold reset for at least 25 microseconds. */
	DELAY (25);
	/* Check that status cleared. */
	if (inb (z->CSBR) != CSBR_RST) {
		PRINT (("nca: invalid csbr[0x%x]=%b\n", z->CSBR,
			inb (z->CSBR), CSBR_BITS));
		outb (z->ICR, 0);
		return (2);
	}
	/* Clear reset. */
	outb (z->ICR, 0);
	/* Wait a Bus Clear Delay (800 ns + bus free delay 800 ns). */
	DELAY (2);

	/* Enable data drivers. */
	outb (z->ICR, ICR_ASSERT_DATA_BUS);

	/* Check that data register is writable. */
	for (i=0; i<256; ++i) {
		outb (z->ODR, i);
		DELAY (1);
		if (inb (z->CSDR) != i) {
			PRINT (("nca: ODR[0x%x] not writable: 0x%x should be 0x%x\n",
				z->ODR, inb (z->CSDR), i));
			outb (z->ICR, 0);
			return (3);
		}
	}

	/* Disable data drivers. */
	outb (z->ICR, 0);

	/* Check that data register is NOT writable. */
	c = inb (z->CSDR);
	for (i=0; i<256; ++i) {
		outb (z->ODR, i);
		DELAY (1);
		if (inb (z->CSDR) != c) {
			PRINT (("nca: ODR[0x%x] writable: 0x%x should be 0x%x\n",
				z->ODR, inb (z->CSDR), c));
			return (4);
		}
	}

	/* Initialize the controller. */
	outb (z->MR, z->parity);
	outb (z->TCR, 0);
	outb (z->SER, z->scsi_id);
	return (0);
}

/*
 * Attach all sub-devices we can find.
 */
int nca_attach (struct isa_device *dev)
{
	int unit = dev->id_unit;
	adapter_t *z = &ncadata[unit];
	struct scsibus_data *scbus;

	printf ("nca%d: type %s%s\n", unit, z->name,
		(dev->id_flags & FLAG_NOPARITY) ? ", no parity" : "");

	/* fill in the prototype scsi_link */
	z->sc_link.adapter_unit = unit;
	z->sc_link.adapter_targ = z->scsi_addr;
	z->sc_link.adapter_softc = z;
	z->sc_link.adapter = &nca_switch;
	z->sc_link.device = &nca_dev;

	/*
	 * Prepare the scsibus_data area for the upperlevel
	 * scsi code.
	 */
	scbus = scsi_alloc_bus();
	if(!scbus)
	        return 0;
	scbus->adapter_link = &z->sc_link;

	/* ask the adapter what subunits are present */
	scsi_attachdevs (scbus);

	return (1);
}

/*
 * Return some information to the caller about
 * the adapter and its capabilities.
 */
u_int32_t nca_adapter_info (int unit)
{
	return (1);
}

void ncaminphys (struct buf *bp)
{
}

/*
 * Catch an interrupt from the adaptor.
 */
void ncaintr (int unit)
{
	adapter_t *z = &ncadata[unit];

	PRINT (("nca%d: interrupt bsr=%b csbr=%b\n", unit,
		inb (z->BSR), BSR_BITS, inb (z->CSBR), CSBR_BITS));
	nca_start (z);
	/* Reset interrupt state. */
	inb (z->RPIR);
}

/*
 * This routine is used in the case when we have no IRQ line (z->irq == 0).
 * It is called every timer tick and polls for reconnect from target.
 */
void nca_tick (void *arg)
{
	adapter_t *z = arg;
	int x = splbio ();

	z->timeout_active = 0;
	nca_start (z);
	/* Reset interrupt state. */
	inb (z->RPIR);
	if (z->disconnected_queue && ! z->timeout_active) {
		timeout (nca_tick, z, 1);
		z->timeout_active = 1;
	}
	splx (x);
}

/*
 * Start a scsi operation given the command and the data address.
 * Also needs the unit, target and lu.  Get a free scb and set it up.
 * Call send_scb.  Either start timer or wait until done.
 */
int32_t nca_scsi_cmd (struct scsi_xfer *xs)
{
	int unit = xs->sc_link->adapter_unit, flags = xs->flags, x = 0;
	adapter_t *z = (adapter_t *)xs->sc_link->adapter_softc;
	scb_t *scb;

	/* PRINT (("nca%d/%d/%d command 0x%x\n", unit, xs->sc_link->target,
		xs->sc_link->lun, xs->cmd->opcode)); */
	if (xs->bp)
		flags |= SCSI_NOSLEEP;
	if (flags & ITSDONE) {
		printf ("nca%d: already done?", unit);
		xs->flags &= ~ITSDONE;
	}
	if (! (flags & INUSE)) {
		printf ("nca%d: not in use?", unit);
		xs->flags |= INUSE;
	}
	if (flags & SCSI_RESET)
		printf ("nca%d: SCSI_RESET not implemented\n", unit);

	if (! (flags & SCSI_NOMASK))
		x = splbio ();

	/* Get a free scb.
	 * If we can and have to, sleep waiting for one to come free. */
	while (! (scb = z->free_scb)) {
		if (flags & SCSI_NOSLEEP) {
			xs->error = XS_DRIVER_STUFFUP;
			if (! (flags & SCSI_NOMASK))
				splx (x);
			return (TRY_AGAIN_LATER);
		}
		tsleep ((caddr_t)&z->free_scb, PRIBIO, "ncascb", 0);
	}
	/* Get scb from free list. */
	z->free_scb = scb->next;
	scb->next = 0;
	scb->flags = SCB_ACTIVE;

	/* Put all the arguments for the xfer in the scb */
	scb->xfer = xs;
	scb->datalen = xs->datalen;
	scb->data = xs->data;

	/* Setup the scb to contain necessary values.
	 * The interesting values can be read from the xs that is saved.
	 * I therefore think that the structure can be kept very small.
	 * The driver doesn't use DMA so the scatter/gather is not needed? */
	if (! z->queue) {
		scb->next = z->queue;
		z->queue = scb;
	} else {
		scb_t *q;

		for (q=z->queue; q->next; q=q->next)
			continue;
		q->next = scb;
		scb->next = 0;  /* placed at the end of the queue */
	}

	/* Try to send this command to the board. */
	nca_start (z);

	/* Usually return SUCCESSFULLY QUEUED. */
	if (! (flags & SCSI_NOMASK)) {
		splx (x);
		if (xs->flags & ITSDONE)
			/* Timeout timer not started, already finished.
			 * Tried to return COMPLETE but the machine hanged
			 * with this. */
			return (SUCCESSFULLY_QUEUED);
		timeout (nca_timeout, (caddr_t) scb, (xs->timeout * hz) / 1000);
		scb->flags |= SCB_TIMECHK;
		PRINT (("nca%d/%d/%d command queued\n", unit,
			xs->sc_link->target, xs->sc_link->lun));
		return (SUCCESSFULLY_QUEUED);
	}

	/* If we can't use interrupts, poll on completion. */
	if (! nca_poll (z, scb)) {
		/* We timed out, so call the timeout handler manually,
		 * accounting for the fact that the clock is not running yet
		 * by taking out the clock queue entry it makes. */
		nca_timeout ((void*) scb);

		/* Because we are polling, take out the timeout entry
		 * nca_timeout made. */
		untimeout (nca_timeout, (void*) scb);

		if (! nca_poll (z, scb))
			/* We timed out again... This is bad. Notice that
			 * this time there is no clock queue entry to remove. */
			nca_timeout ((void*) scb);
	}
	/* PRINT (("nca%d/%d/%d command %s\n", unit,
		xs->sc_link->target, xs->sc_link->lun,
		xs->error ? "failed" : "done")); */
	return (xs->error ? HAD_ERROR : COMPLETE);
}

/*
 * Coroutine that runs as long as more work can be done.
 * Both scsi_cmd() and intr() will try to start it in
 * case it is not running.
 * Always called with interrupts disabled.
 */
void nca_start (adapter_t *z)
{
	scb_t *q, *prev;
again:
	/* First check that if any device has tried
	 * a reconnect while we have done other things
	 * with interrupts disabled. */
	if (nca_reselect (z))
		goto again;

	/* Search through the queue for a command
	 * destined for a target that's not busy. */
	for (q=z->queue, prev=0; q; prev=q, q=q->next) {
		/* Attempt to establish an I_T_L nexus here. */
		if (IS_BUSY (z, q) || ! nca_select (z, q))
			continue;

		/* Remove the command from the issue queue. */
		if (prev)
			prev->next = q->next;
		else
			z->queue = q->next;
		q->next = 0;

		/* We are connected. Do the task. */
		nca_information_transfer (z, q);
		goto again;
	}
}

void nca_timeout (void *arg)
{
	scb_t *scb = (scb_t*) arg;
	int unit = scb->xfer->sc_link->adapter_unit;
	adapter_t *z = (adapter_t *)scb->xfer->sc_link->adapter_softc;
	int x = splbio ();

	if (! (scb->xfer->flags & SCSI_NOMASK))
		printf ("nca%d/%d/%d (%s%d) timed out\n", unit,
			scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun,
			scb->xfer->sc_link->device->name,
			scb->xfer->sc_link->dev_unit);

	/* If it has been through before, then a previous abort has failed,
	 * don't try abort again. */
	if (! (scb->flags & SCB_ABORTED)) {
		nca_abort (z, scb);
		/* 2 seconds for the abort */
		timeout (nca_timeout, (caddr_t)scb, 2*hz);
		scb->flags |= (SCB_ABORTED | SCB_TIMECHK);
	} else {
		/* abort timed out */
		scb->flags |= SCB_ABORTED;
		scb->xfer->retries = 0;
		nca_done (z, scb);
	}
	splx (x);
}

static inline void nca_sendbyte (adapter_t *z, u_char data)
{
	outb (z->ODR, data);
	outb (z->ICR, ICR_ASSERT_DATA_BUS | ICR_ASSERT_ACK);
	WAITFOR (! (inb (z->CSBR) & CSBR_REQ), 10000, "sendbyte");
	outb (z->ICR, ICR_ASSERT_DATA_BUS);
}

static inline u_char nca_recvbyte (adapter_t *z)
{
	u_char data;

	data = inb (z->CSDR);
	outb (z->ICR, ICR_ASSERT_ACK);
	WAITFOR (! (inb (z->CSBR) & CSBR_REQ), 10000, "recvbyte");
	outb (z->ICR, 0);
	return (data);
}

/*
 * Establish I_T_L or I_T_L_Q nexus for new or existing command
 * including ARBITRATION, SELECTION, and initial message out
 * for IDENTIFY and queue messages.
 * Return 1 if selection succeded.
 */
int nca_select (adapter_t *z, scb_t *scb)
{
	/* Set the phase bits to 0, otherwise the NCR5380 won't drive the
	 * data bus during SELECTION. */
	outb (z->TCR, 0);

	/* Start arbitration. */
	outb (z->ODR, z->scsi_id);
	outb (z->MR, MR_ARBITRATE);

	/* Wait for arbitration logic to complete (20 usec) */
	WAITFOR (inb (z->ICR) & ICR_ARBITRATION_IN_PROGRESS, 200, 0);
	if (! (inb (z->ICR) & ICR_ARBITRATION_IN_PROGRESS)) {
		PRINT (("nca%d/%d/%d no arbitration progress, bsr=%b csbr=%b\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun, inb (z->BSR), BSR_BITS,
			inb (z->CSBR), CSBR_BITS));
		outb (z->MR, z->parity);
		return (0);
	}
	DELAY (3);

	/* Check for lost arbitration. */
	if ((inb (z->ICR) & ICR_LOST_ARBITRATION) ||
	    (inb (z->CSDR) >> 1 >> z->scsi_addr) ||
	    (inb (z->ICR) & ICR_LOST_ARBITRATION)) {
		PRINT (("nca%d/%d/%d arbitration lost\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun));
		outb (z->MR, z->parity);
		return (0);
	}

	outb (z->ICR, ICR_ASSERT_SEL);
	if (inb (z->ICR) & ICR_LOST_ARBITRATION) {
		PRINT (("nca%d/%d/%d arbitration lost after SEL\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun));
		outb (z->ICR, 0);
		outb (z->MR, z->parity);
		return (0);
	}
	DELAY (2);

	/* Start selection, asserting the host and target ID's on the bus. */
	outb (z->SER, 0);
	outb (z->ODR, z->scsi_id | (1 << scb->xfer->sc_link->target));
	outb (z->ICR, ICR_ASSERT_DATA_BUS | ICR_ASSERT_BSY |
		ICR_ASSERT_SEL);

	/* Finish arbitration, drop BSY. */
	outb (z->MR, 0);
	outb (z->ICR, ICR_ASSERT_DATA_BUS | ICR_ASSERT_SEL |
		ICR_ASSERT_ATN);
	DELAY (1);

	/* The SCSI specification calls for a 250 ms timeout for the actual
	 * selection. */
	WAITFOR (inb (z->CSBR) & CSBR_BSY, 100000, 0);
	if (! (inb (z->CSBR) & CSBR_BSY)) {
		/* The target does not respond.  Not an error, though. */
		PRINT (("nca%d/%d/%d target does not respond\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun));
		outb (z->ICR, 0);
		outb (z->SER, z->scsi_id);
		outb (z->MR, z->parity);
		scb->flags |= SCB_TIMEOUT;
		return (0);
	}

	/* Clear SEL and SCSI id.
	 * Wait for start of REQ/ACK handshake. */
	outb (z->ICR, ICR_ASSERT_DATA_BUS | ICR_ASSERT_ATN);
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 100000, 0);
	if (! (inb (z->CSBR) & CSBR_REQ)) {
		PRINT (("nca%d/%d/%d timeout waiting for REQ\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun));
		outb (z->ICR, 0);
		outb (z->SER, z->scsi_id);
		outb (z->MR, z->parity);
		scb->flags |= SCB_ERROR;
		return (0);
	}

	/* Check for phase mismatch. */
	if ((inb (z->CSBR) & PHASE_MASK) != PHASE_MSGOUT) {
		/* This should not be taken as an error, but more like
		 * an unsupported feature!
		 * Should set a flag indicating that the target don't support
		 * messages, and continue without failure.
		 * (THIS IS NOT AN ERROR!) */
		PRINT (("nca%d/%d/%d waiting for MSGOUT: invalid phase %s\n",
			z->sc_link.adapter_unit, scb->xfer->sc_link->target,
			scb->xfer->sc_link->lun,
			PHASE_NAME (inb (z->CSBR) & PHASE_MASK)));
		outb (z->ICR, 0);
		outb (z->SER, z->scsi_id);
		outb (z->MR, z->parity);
		scb->flags |= SCB_ERROR;
		return (0);
	}

	/* Allow disconnects. */
	outb (z->TCR, PHASE_TO_TCR (PHASE_MSGOUT));
	outb (z->ICR, ICR_ASSERT_DATA_BUS);
	nca_sendbyte (z, MSG_IDENTIFY (scb->xfer->sc_link->lun));
	outb (z->ICR, 0);
	outb (z->SER, z->scsi_id);
	outb (z->MR, z->parity);

	SET_BUSY (z, scb);
	return (1);
}

int nca_reselect (adapter_t *z)
{
	scb_t *q = 0, *prev = 0;
	u_char msg, target_mask, lun;
again:
	/* Wait for a device to win the reselection phase. */
	/* Signals this by asserting the I/O signal. */
	if ((inb (z->CSBR) & (CSBR_SEL | CSBR_IO | CSBR_BSY)) !=
	    (CSBR_SEL | CSBR_IO))
		return (0);

	/* The data bus contains original initiator id ORed with target id. */
	/* See that we really are the initiator. */
	target_mask = inb (z->CSDR);
	if (! (target_mask & z->scsi_id)) {
		PRINT (("nca%d reselect not for me: mask=0x%x, csbr=%b\n",
			z->sc_link.adapter_unit, target_mask,
			inb (z->CSBR), CSBR_BITS));
		goto again;
	}

	/* Find target who won. */
	/* Host responds by asserting the BSY signal. */
	/* Target should respond by deasserting the SEL signal. */
	target_mask &= ~z->scsi_id;
	outb (z->ICR, ICR_ASSERT_BSY);
	WAITFOR (! (inb (z->CSBR) & CSBR_SEL), 10000, "SEL deassert");

	/* Remove the busy status. */
	/* Target should set the MSGIN phase. */
	outb (z->ICR, 0);
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 10000, "MSGIN");

	/* Hope we get an IDENTIFY message. */
	msg = nca_msg_input (z);
	if (MSG_ISIDENT (msg)) {
		/* Find the command corresponding to the I_T_L or I_T_L_Q
		 * nexus we just restablished, and remove it from
		 * the disconnected queue. */
		lun = (msg & 7);
		for (q=z->disconnected_queue; q; prev=q, q=q->next) {
			if (target_mask != (1 << q->xfer->sc_link->target))
				continue;
			if (lun != q->xfer->sc_link->lun)
				continue;
			if (prev)
				prev->next = q->next;
			else
				z->disconnected_queue = q->next;
			q->next = 0;
			PRINT (("nca%d/%d/%d reselect done\n",
				z->sc_link.adapter_unit,
				ffs (target_mask) - 1, lun));
			nca_information_transfer (z, q);
			WAITFOR (! (inb (z->CSBR) & CSBR_BSY), 100000, "reselect !busy");
			return (1);
		}
	} else
		printf ("nca%d reselect: expecting IDENTIFY, got 0x%x\n",
			z->sc_link.adapter_unit, msg);

	/* Since we have an established nexus that we can't
	 * do anything with, we must abort it. */
	nca_send_abort (z);
	PRINT (("nca%d reselect aborted\n", z->sc_link.adapter_unit));
	WAITFOR (! (inb (z->CSBR) & CSBR_BSY), 100000, "reselect abort !busy");
	goto again;
}

/*
 * Send an abort to the target.
 * Return 1 success, 0 on failure.
 * Called on splbio level.
 */
int nca_abort (adapter_t *z, scb_t *scb)
{
	scb_t *q, **prev;

	/* If the command hasn't been issued yet, we simply remove it
	 * from the issue queue. */
	prev = &z->queue;
	for (q=z->queue; q; q=q->next) {
		if (scb == q) {
			(*prev) = q->next;
			q->next = 0;
			return (1);
		}
		prev = &q->next;
	}

	/* If the command is currently disconnected from the bus,
	 * we reconnect the I_T_L or I_T_L_Q nexus associated with it,
	 * go into message out, and send an abort message. */
	for (q=z->disconnected_queue; q; q=q->next) {
		if (scb != q)
			continue;

		if (! nca_select (z, scb))
			return (0);
		nca_send_abort (z);

		prev = &z->disconnected_queue;
		for (q=z->disconnected_queue; q; q=q->next) {
			if (scb == q) {
				*prev = q->next;
				q->next = 0;
				/* Set some type of error result
				 * for the operation. */
				return (1);
			}
			prev = &q->next;
		}
	}

	/* Command not found in any queue. */
	return (0);
}

/*
 * The task accomplished, mark the i/o control block as done.
 * Always called with interrupts disabled.
 */
void nca_done (adapter_t *z, scb_t *scb)
{
	struct scsi_xfer *xs = scb->xfer;

	if (scb->flags & SCB_TIMECHK)
		untimeout (nca_timeout, (caddr_t) scb);

	/* How much of the buffer was not touched. */
	xs->resid = scb->datalen;

	if (scb->flags != SCB_ACTIVE && ! (xs->flags & SCSI_ERR_OK))
		if (scb->flags & (SCB_TIMEOUT | SCB_ABORTED))
			xs->error = XS_TIMEOUT;
		else if (scb->flags & SCB_ERROR)
			xs->error = XS_DRIVER_STUFFUP;
		else if (scb->flags & SCB_TBUSY)
			xs->error = XS_BUSY;
		else if (scb->flags & SCB_SENSE)
			xs->error = XS_SENSE;

	xs->flags |= ITSDONE;

	/* Free the control block. */
	scb->next = z->free_scb;
	z->free_scb = scb;
	scb->flags = SCB_FREE;

	/* If there were none, wake anybody waiting for one to come free,
	 * starting with queued entries. */
	if (! scb->next)
		wakeup ((caddr_t) &z->free_scb);

	scsi_done (xs);
}

/*
 * Wait for completion of command in polled mode.
 * Always called with interrupts masked out.
 */
int nca_poll (adapter_t *z, scb_t *scb)
{
	int count;

	for (count=0; count<30; ++count) {
		DELAY (1000);                   /* delay for a while */
		nca_start (z);                  /* retry operation */
		if (scb->xfer->flags & ITSDONE)
			return (1);             /* all is done */
		if (scb->flags & SCB_TIMEOUT)
			return (0);             /* no target present */
	}
	return (0);
}

/*
 * Perform NCR-53C400 pseudo-dma data transfer.
 */
void nca_53400_dma_xfer (adapter_t *z, int read, u_char **pdata, u_long *plen)
{
	/* Set dma direction. */
	outb (z->CSR, read ? CSR_TRANSFER_DIRECTION : 0);

	/* Enable dma mode. */
	outb (z->MR, MR_DMA_MODE | (read ? z->parity : 0));

	/* Start dma transfer. */
	outb (read ? z->SDIR : z->SDSR, 0);

	/* Set up clock counter. */
	outb (z->CCR, *plen/128);

	for (; *plen>=128; *plen-=128, *pdata+=128) {
		/* Wait for 53C400 host buffer ready. */
		WAITFOR (! (inb (z->CSR) & CSR_HOST_BUF_NOT_READY), 100000, 0);
		if (inb (z->CSR) & CSR_HOST_BUF_NOT_READY)
			break;

		/* Transfer 128 bytes of data. */
		if (read)
			insw (z->HBR, *pdata, 64);
		else
			outsw (z->HBR, *pdata, 64);
	}

	/* Wait for 5380 registers ready. */
	WAITFOR (inb (z->CSR) & CSR_5380_ENABLE, 10000, 0);
	if (! (inb (z->CSR) & CSR_5380_ENABLE)) {
		/* Reset 53C400. */
		PRINT (("nca%d: reset: pseudo-dma incomplete, csr=%b\n",
			z->sc_link.adapter_unit, inb (z->CSR), CSR_BITS));
		outb (z->CSR, CSR_5380_ENABLE);
		outb (z->CSR, 0);
	}

	/* Wait for FIFO flush on write. */
	if (! read)
		WAITFOR (inb (z->TCR) & TCR_LAST_BYTE_SENT, 10000, "last byte");

	/* Clear dma mode. */
	outb (z->MR, z->parity);

	/* Re-enable interrupts. */
	outb (z->CSR, z->irq ? CSR_5380_INTR : 0);
}

/*
 * Perform PAS-16 pseudo-dma data transfer.
 */
void nca_pas_dma_xfer (adapter_t *z, int read, u_char **pdata, u_long *plen)
{
	/* Enable dma mode. */
	outb (z->MR, MR_DMA_MODE | (read ? z->parity : 0));

	/* Start dma transfer. */
	outb (read ? z->SDIR : z->SDSR, 0);

	for (; *plen>=512; *plen-=512, *pdata+=512) {
		/* Wait for pseudo-DMA request. */
		WAITFOR (inb (z->PSTAT) & PAS16_STAT_DREQ, 10000, "pseudo-dma");
		if (! (inb (z->PSTAT) & PAS16_STAT_DREQ))
			break;

		/* Transfer 512 bytes of data. */
		if (read)
			insb (z->PDATA, *pdata, 512);
		else
			outsb (z->PDATA, *pdata, 512);
	}

	/* Clear dma mode. */
	outb (z->MR, z->parity);
}

/*
 * Send data to the target.
 */
void nca_data_output (adapter_t *z, u_char **pdata, u_long *plen)
{
	u_char *data = *pdata;
	u_long len = *plen;

	outb (z->ICR, ICR_ASSERT_DATA_BUS);
	if (z->type == CTLR_NCR_53C400 && len%128 == 0)
		/* Use NCR-53C400 pseudo-dma for data transfer. */
		nca_53400_dma_xfer (z, 0, &data, &len);
	else if (z->type == CTLR_PAS_16 && len%512 == 0)
		/* Use PAS-16 pseudo-dma for data transfer. */
		nca_pas_dma_xfer (z, 0, &data, &len);
	else
		for (;;) {
			/* Check SCSI bus phase. */
			u_char s = inb (z->CSBR) ^ (CSBR_BSY | PHASE_DATAOUT);
			if (s & (CSBR_BSY | PHASE_MASK))
				break;

			/* Wait for REQ. */
			if (! (s & CSBR_REQ))
				continue;

			/* Output data. */
			outb (z->ODR, *data++);

			/* Assert ACK and wait for REQ deassert,
			 * with irqs disabled. */
			disable_intr ();
			outb (z->ICR, ICR_ASSERT_ACK | ICR_ASSERT_DATA_BUS);
			WAITFOR (! (inb (z->CSBR) & CSBR_REQ), 1000, 0);
			enable_intr ();

			/* Deassert ACK. */
			outb (z->ICR, ICR_ASSERT_DATA_BUS);
			--len;
		}
	outb (z->ICR, 0);
	PRINT (("nca (DATAOUT) send %ld bytes\n", *plen - len));
	*plen = len;
	*pdata = data;
}

/*
 * Receive data from the target.
 */
void nca_data_input (adapter_t *z, u_char **pdata, u_long *plen)
{
	u_char *data = *pdata;
	u_long len = *plen;

	if (z->type == CTLR_NCR_53C400 && len%128 == 0)
		/* Use NCR-53C400 pseudo-dma for data transfer. */
		nca_53400_dma_xfer (z, 1, &data, &len);
	else if (z->type == CTLR_PAS_16 && len%512 == 0)
		/* Use PAS-16 pseudo-dma for data transfer. */
		nca_pas_dma_xfer (z, 1, &data, &len);
	else
		for (;;) {
			/* Check SCSI bus phase. */
			u_char s = inb (z->CSBR) ^ (CSBR_BSY | PHASE_DATAIN);
			if (s & (CSBR_BSY | PHASE_MASK))
				break;

			/* Wait for REQ. */
			if (! (s & CSBR_REQ))
				continue;

			/* Input data. */
			*data++ = inb (z->CSDR);

			/* Assert ACK and wait for REQ deassert,
			 * with irqs disabled. */
			disable_intr ();
			outb (z->ICR, ICR_ASSERT_ACK);
			WAITFOR (! (inb (z->CSBR) & CSBR_REQ), 1000, 0);
			enable_intr ();

			/* Deassert ACK. */
			outb (z->ICR, 0);
			--len;
		}
	PRINT (("nca (DATAIN) got %ld bytes\n", *plen - len));
	*plen = len;
	*pdata = data;
}

/*
 * Send the command to the target.
 */
void nca_cmd_output (adapter_t *z, u_char *cmd, int cmdlen)
{
	PRINT (("nca%d send command (%d bytes) ", z->sc_link.adapter_unit,
		cmdlen));

	outb (z->ICR, ICR_ASSERT_DATA_BUS);
	while (cmdlen) {
		/* Check for target disconnect. */
		u_char sts = inb (z->CSBR);
		if (! (sts & CSBR_BSY))
			break;

		/* Check for phase mismatch. */
		if ((sts & PHASE_MASK) != PHASE_CMDOUT) {
			printf ("nca: sending command: invalid phase %s\n",
				PHASE_NAME (sts & PHASE_MASK));
			break;
		}

		/* Wait for REQ. */
		if (! (sts & CSBR_REQ))
			continue;

		PRINT (("-%x", *cmd));
		nca_sendbyte (z, *cmd++);
		--cmdlen;
	}
	outb (z->ICR, 0);
	PRINT (("\n"));
}

/*
 * Send the message to the target.
 */
void nca_send_abort (adapter_t *z)
{
	u_char sts;

	outb (z->ICR, ICR_ASSERT_ATN);

	/* Wait for REQ, after which the phase bits will be valid. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 1000000, "abort message");
	sts = inb (z->CSBR);
	if (! (sts & CSBR_REQ))
		goto ret;

	/* Check for phase mismatch. */
	if ((sts & PHASE_MASK) != PHASE_MSGOUT) {
		printf ("nca: sending MSG_ABORT: invalid phase %s\n",
			PHASE_NAME (sts & PHASE_MASK));
		goto ret;
	}

	outb (z->ICR, ICR_ASSERT_DATA_BUS);
	outb (z->TCR, PHASE_TO_TCR (PHASE_MSGOUT));
	nca_sendbyte (z, MSG_ABORT);

	PRINT (("nca%d send MSG_ABORT\n", z->sc_link.adapter_unit));
ret:    outb (z->ICR, 0);
}

/*
 * Get the message from the target.
 * Return the length of the received message.
 */
u_char nca_msg_input (adapter_t *z)
{
	u_char sts, msg;

	/* Wait for REQ, after which the phase bits will be valid. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 1000000, "message input");
	sts = inb (z->CSBR);
	if (! (sts & CSBR_REQ))
		return (MSG_ABORT);

	/* Check for phase mismatch.
	 * Reached if the target decides that it has finished the transfer. */
	if ((sts & PHASE_MASK) != PHASE_MSGIN) {
		printf ("nca: sending message: invalid phase %s\n",
			PHASE_NAME (sts & PHASE_MASK));
		return (MSG_ABORT);
	}

	/* Do actual transfer from SCSI bus to memory. */
	outb (z->TCR, PHASE_TO_TCR (PHASE_MSGIN));
	msg = nca_recvbyte (z);
	PRINT (("nca%d (MSG_INPUT) got 0x%x\n", z->sc_link.adapter_unit, msg));
	return (msg);
}

/*
 * Send request-sense op to the target.
 * Return 1 success, 0 on failure.
 * Called on splbio level.
 */
int nca_sense (adapter_t *z, scb_t *scb)
{
	u_char cmd[6], status, msg, *data;
	u_long len;

	/* Wait for target to disconnect. */
	WAITFOR (! (inb (z->CSBR) & CSBR_BSY), 100000, "sense bus free");
	if (inb (z->CSBR) & CSBR_BSY)
		return (0);

	/* Select the target again. */
	if (! nca_select (z, scb))
		return (0);

	/* Wait for CMDOUT phase. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 100000, "sense CMDOUT");
	if (! (inb (z->CSBR) & CSBR_REQ) ||
	    (inb (z->CSBR) & PHASE_MASK) != PHASE_CMDOUT)
		return (0);
	outb (z->TCR, PHASE_TO_TCR (PHASE_CMDOUT));

	/* Send command. */
	len = sizeof (scb->xfer->sense);
	cmd[0] = REQUEST_SENSE;
	cmd[1] = scb->xfer->sc_link->lun << 5;
	cmd[2] = 0;
	cmd[3] = 0;
	cmd[4] = len;
	cmd[5] = 0;
	nca_cmd_output (z, cmd, sizeof (cmd));

	/* Wait for DATAIN phase. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 100000, "sense DATAIN");
	if (! (inb (z->CSBR) & CSBR_REQ) ||
	    (inb (z->CSBR) & PHASE_MASK) != PHASE_DATAIN)
		return (0);
	outb (z->TCR, PHASE_TO_TCR (PHASE_DATAIN));

	data = (u_char*) &scb->xfer->sense;
	nca_data_input (z, &data, &len);
	PRINT (("nca%d sense %x-%x-%x-%x-%x-%x-%x-%x\n",
		z->sc_link.adapter_unit, scb->xfer->sense.error_code,
		scb->xfer->sense.ext.extended.segment,
		scb->xfer->sense.ext.extended.flags,
		scb->xfer->sense.ext.extended.info[0],
		scb->xfer->sense.ext.extended.info[1],
		scb->xfer->sense.ext.extended.info[2],
		scb->xfer->sense.ext.extended.info[3],
		scb->xfer->sense.ext.extended.extra_len));

	/* Wait for STATIN phase. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 100000, "sense STATIN");
	if (! (inb (z->CSBR) & CSBR_REQ) ||
	    (inb (z->CSBR) & PHASE_MASK) != PHASE_STATIN)
		return (0);
	outb (z->TCR, PHASE_TO_TCR (PHASE_STATIN));

	status = nca_recvbyte (z);

	/* Wait for MSGIN phase. */
	WAITFOR (inb (z->CSBR) & CSBR_REQ, 100000, "sense MSGIN");
	if (! (inb (z->CSBR) & CSBR_REQ) ||
	    (inb (z->CSBR) & PHASE_MASK) != PHASE_MSGIN)
		return (0);
	outb (z->TCR, PHASE_TO_TCR (PHASE_MSGIN));

	msg = nca_recvbyte (z);

	if (status != 0 || msg != 0)
		printf ("nca%d: bad sense status=0x%x, msg=0x%x\n",
			z->sc_link.adapter_unit, status, msg);
	return (1);
}

/*
 * Do the transfer. We know we are connected. Update the flags,
 * call nca_done when task accomplished. Dialog controlled by the target.
 * Always called with interrupts disabled.
 */
void nca_information_transfer (adapter_t *z, scb_t *scb)
{
	u_char *data = scb->data;               /* current data buffer */
	u_long datalen = scb->datalen;          /* current data transfer size */
	register u_char sts;
	u_char msg;

	while ((sts = inb (z->CSBR)) & CSBR_BSY) {
		/* We only have a valid SCSI phase when REQ is asserted. */
		if (! (sts & CSBR_REQ))
			continue;
		if (inb (z->BSR) & BSR_PARITY_ERROR) {
			int target = scb->xfer->sc_link->target;
			if (++z->target[target].perrcnt <= 8)
				printf ("nca%d/%d/%d parity error\n",
					z->sc_link.adapter_unit, target,
					scb->xfer->sc_link->lun);
			if (z->target[target].perrcnt == 8)
				printf ("nca%d/%d/%d too many parity errors, not logging any more\n",
					z->sc_link.adapter_unit, target,
					scb->xfer->sc_link->lun);
			/* Clear parity error. */
			inb (z->RPIR);
		}
		outb (z->TCR, PHASE_TO_TCR (sts & PHASE_MASK));
		switch (sts & PHASE_MASK) {
		case PHASE_DATAOUT:
			if (datalen <= 0) {
				printf ("nca%d/%d/%d data length underflow\n",
					z->sc_link.adapter_unit,
					scb->xfer->sc_link->target,
					scb->xfer->sc_link->lun);
				/* send zero byte */
				outb (z->ICR, ICR_ASSERT_DATA_BUS);
				nca_sendbyte (z, 0);
				outb (z->ICR, 0);
				break;
			}
			nca_data_output (z, &data, &datalen);
			break;
		case PHASE_DATAIN:
			if (datalen <= 0) {
				/* Get extra data.  Some devices (e.g. CDROMs)
				 * use fixed-length blocks (e.g. 2k),
				 * even if we need less. */
				PRINT (("@"));
				nca_recvbyte (z);
				break;
			}
			nca_data_input (z, &data, &datalen);
			break;
		case PHASE_CMDOUT:
			nca_cmd_output (z, (u_char*) scb->xfer->cmd,
				scb->xfer->cmdlen);
			break;
		case PHASE_STATIN:
			scb->xfer->status = nca_recvbyte (z);
			PRINT (("nca%d/%d/%d (STATIN) got 0x%x\n",
				z->sc_link.adapter_unit,
				scb->xfer->sc_link->target,
				scb->xfer->sc_link->lun,
				(u_char) scb->xfer->status));
			break;
		case PHASE_MSGOUT:
			/* Send no-op message. */
			outb (z->ICR, ICR_ASSERT_DATA_BUS);
			nca_sendbyte (z, MSG_NOP);
			outb (z->ICR, 0);
			PRINT (("nca%d/%d/%d (MSGOUT) send NOP\n",
				z->sc_link.adapter_unit,
				scb->xfer->sc_link->target,
				scb->xfer->sc_link->lun));
			break;
		case PHASE_MSGIN:
			/* Don't handle multi-byte messages here, because they
			 * should not be present here. */
			msg = nca_recvbyte (z);
			PRINT (("nca%d/%d/%d (MSGIN) got 0x%x\n",
				z->sc_link.adapter_unit,
				scb->xfer->sc_link->target,
				scb->xfer->sc_link->lun, msg));
			switch (msg) {
			case MSG_COMMAND_COMPLETE:
				scb->data = data;
				scb->datalen = datalen;
				/* In the case of check-condition status,
				 * perform the request-sense op. */
				switch (scb->xfer->status & 0x1e) {
				case SCSI_CHECK:
					if (nca_sense (z, scb))
						scb->flags = SCB_SENSE;
					break;
				case SCSI_BUSY:
					scb->flags = SCB_TBUSY;
					break;
				}
				goto done;
			case MSG_ABORT:
				printf ("nca: command aborted by target\n");
				scb->flags = SCB_ABORTED;
				goto done;
			case MSG_MESSAGE_REJECT:
				printf ("nca: message rejected\n");
				scb->flags = SCB_ABORTED;
				goto done;
			case MSG_DISCONNECT:
				scb->next = z->disconnected_queue;
				z->disconnected_queue = scb;
				if (! z->irq && ! z->timeout_active) {
					timeout (nca_tick, z, 1);
					z->timeout_active = 1;
				}
				PRINT (("nca%d/%d/%d disconnected\n",
					z->sc_link.adapter_unit,
					scb->xfer->sc_link->target,
					scb->xfer->sc_link->lun));
				goto ret;
			case MSG_SAVE_POINTERS:
				scb->data = data;
				scb->datalen = datalen;
				break;
			case MSG_RESTORE_POINTERS:
				data = scb->data;
				datalen = scb->datalen;
				break;
			default:
				printf ("nca%d/%d/%d unknown message: 0x%x\n",
					z->sc_link.adapter_unit,
					scb->xfer->sc_link->target,
					scb->xfer->sc_link->lun, msg);
				break;
			}
			break;
		default:
			printf ("nca: unknown phase: %b\n", sts, CSBR_BITS);
			break;
		}
	}
	printf ("nca%d/%d/%d unexpected target disconnect\n",
		z->sc_link.adapter_unit, scb->xfer->sc_link->target,
		scb->xfer->sc_link->lun);
	scb->flags = SCB_ERROR;
done:
	CLEAR_BUSY (z, scb);
	nca_done (z, scb);
ret:
	outb (z->ICR, 0);
	outb (z->TCR, 0);
	outb (z->SER, z->scsi_id);
	WAITFOR (! (inb (z->CSBR) & CSBR_BSY), 100000, "xfer bus free");
}
#endif /* NNCA */