path: root/sys/i386/scsi/advansys.c

/*
 * Generic driver for the Advanced Systems Inc. SCSI controllers
 * Product specific probe and attach routines can be found in:
 * 
 * i386/isa/adv_isa.c	ABP5140, ABP542, ABP5150, ABP842, ABP852
 *
 * Copyright (c) 1996 Justin T. Gibbs.
 * All rights reserved.
 *
 * 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 immediately at the beginning of the file, without modification,
 *    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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 *      $FreeBSD$
 */
/*
 * Ported from:
 * advansys.c - Linux Host Driver for AdvanSys SCSI Adapters
 *     
 * Copyright (c) 1995-1996 Advanced System Products, Inc.
 * All Rights Reserved.
 *   
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that redistributions of source
 * code retain the above copyright notice and this comment without
 * modification.
 */
 
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/buf.h>

#include <machine/clock.h>

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

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/pmap.h>

#include <i386/scsi/advansys.h>

static void	adv_scsi_cmd __P((struct scsi_xfer *xs));
static void	advminphys __P((struct buf *bp));
static timeout_t
                adv_timeout;
static int	adv_qdone __P((struct adv_softc *adv));
static void	adv_done __P((struct adv_softc *adv,
			      struct adv_q_done_info *qdonep));
static int	adv_poll __P((struct adv_softc *ahc, struct scsi_xfer *xs));

struct adv_softc *advsoftcs[NADV];   /* XXX Config should handle this */

static struct scsi_adapter adv_switch =
{
	adv_scsi_cmd,
	advminphys,
	NULL,
	NULL,
	"adv"
};

static void
adv_scsi_cmd(xs)
	struct scsi_xfer *xs;
{
	struct adv_softc *adv;
	struct adv_scsi_q scsiq;
	struct adv_sg_head sghead;

	SC_DEBUG(xs->sc_link, SDEV_DB2, ("adv_scsi_cmd\n"));	

	adv = (struct adv_softc *)xs->sc_link->scsibus->adpt_link.adpt_softc;

	/*
	 * Build up the request
	 */
	scsiq.q1.cntl = 0;
	scsiq.q1.sg_queue_cnt = 0;
	scsiq.q1.status = 0;
	scsiq.q1.q_no = 0;
	scsiq.q1.target_id = ADV_TID_TO_TARGET_ID(xs->sc_link->target);
	scsiq.q1.target_lun = xs->sc_link->lun;
	scsiq.q1.sense_addr = (u_int32_t)vtophys(&xs->sense);
	scsiq.q1.sense_len = sizeof(xs->sense);
	scsiq.q1.data_cnt = 0;
	scsiq.q1.data_addr = 0;	
	scsiq.q1.user_def = 0;
	scsiq.q2.xs_ptr = (u_int32_t)xs;
	scsiq.q2.target_ix = ADV_TIDLUN_TO_IX(xs->sc_link->target, xs->sc_link->lun);
	scsiq.q2.flag = 0;
	scsiq.q2.cdb_len = xs->cmdlen;
	scsiq.q2.tag_code = xs->tag_type;
	scsiq.q2.vm_id = 0;
	scsiq.sg_head = NULL;
	scsiq.cdbptr = &xs->cmd;

	if (xs->datalen) {
		/*
		 * Determin the number of segments needed for this
		 * transfer.  We should only use SG if we need more
		 * than one.
		 */
		int		seg;
		u_int32_t	datalen;
		vm_offset_t	vaddr;
		u_int32_t	paddr;
		u_int32_t	nextpaddr;
		struct		adv_sg_entry *sg;

		seg = 0;
		datalen = xs->datalen;
		vaddr = (vm_offset_t)xs->data;
		paddr = vtophys(vaddr);
		sg = &sghead.sg_list[0];

		while ((datalen > 0) && (seg < ADV_MAX_SG_LIST)) {
			/* put in the base address and length */
			sg->addr = paddr;
			sg->bytes = 0;
			
			/* do it at least once */
			nextpaddr = paddr;
			
			while ((datalen > 0) && (paddr == nextpaddr)) {
				u_int32_t	size;
				/*
				 * This page is contiguous (physically)
				 * with the the last, just extend the
				 * length
				 */
				/* how far to the end of the page */
				nextpaddr = (paddr & (~PAGE_MASK)) + PAGE_SIZE;

				/*
				 * Compute the maximum size
				 */
				size = nextpaddr - paddr;
				if (size > datalen)
					size = datalen;

				sg->bytes += size;
				vaddr	  += size;
				datalen   -= size;
				if (datalen > 0)
					paddr = vtophys(vaddr);
			}
			/*
			 * next page isn't contiguous, finish the seg
			 */
			seg++;
			sg++;
		}
		if (seg > 1) {
			scsiq.q1.cntl |= QC_SG_HEAD;
			scsiq.sg_head = &sghead;
			sghead.entry_cnt = sghead.entry_to_copy = seg;
			sghead.res = 0;
		}
		scsiq.q1.data_addr = sghead.sg_list[0].addr;
		scsiq.q1.data_cnt = sghead.sg_list[0].bytes;
	}
	
	if (adv_execute_scsi_queue(adv, &scsiq) != 0) {
		xs->error = XS_QUEUE_RESOURCE_SHORTAGE;
		scsi_done(xs);
	} else if ((xs->flags & SCSI_POLL) != 0) {
		/*
		 * If we can't use interrupts, poll for completion
		 */		
		int s;
		
		s = splbio();
		if (adv_poll(adv, xs)) {
			if (!(xs->flags & SCSI_SILENT))
				printf("cmd fail\n");
			adv_timeout(xs);
		}
		splx(s);
	} 
}


static void
advminphys(bp)
	struct	buf *bp;
{
	if (bp->b_bcount > ((ADV_MAX_SG_LIST - 1) * PAGE_SIZE))
		bp->b_bcount = ((ADV_MAX_SG_LIST - 1) * PAGE_SIZE);
}

static void
adv_timeout(arg)
	void *arg;
{
	printf("adv: Ooops. Had a timeout\n");
}

struct adv_softc *
adv_alloc(unit, iobase)
	int	unit;
	u_long	iobase;
{
        struct  adv_softc *adv;
	int	i;
   
	if (unit >= NADV) {
		printf("adv: unit number (%d) too high\n", unit);
		return NULL;
	}

	/*
	 * Allocate a storage area for us
	 */
	if (advsoftcs[unit]) {
		printf("adv%d: memory already allocated\n", unit);
		return NULL;
	}

	adv = malloc(sizeof(struct adv_softc), M_DEVBUF, M_NOWAIT);
	if (!adv) {
		printf("adv%d: cannot malloc!\n", unit);
		return NULL;
	}
	bzero(adv, sizeof(struct adv_softc));
	advsoftcs[unit] = adv;
	adv->unit = unit;
	adv->iobase = iobase;
	
	/* Set reasonable defaults incase we can't read the EEPROM */
	adv->max_openings = ADV_DEF_MAX_TOTAL_QNG;
        adv->start_motor = TARGET_BIT_VECTOR_SET;
        adv->disc_enable = TARGET_BIT_VECTOR_SET;
	adv->cmd_qng_enabled = TARGET_BIT_VECTOR_SET;
        adv->scsi_id = 7;

	for (i = 0; i <= ADV_MAX_TID; i++)
		adv->sdtr_data[i] = ADV_DEF_SDTR_OFFSET | (ADV_DEF_SDTR_INDEX << 4);

	return(adv);
}

void
adv_free(adv)
	struct adv_softc *adv;
{
	if (adv->sense_buffers != NULL)
		free(adv->sense_buffers, M_DEVBUF);
	free(adv, M_DEVBUF);
}

int
adv_init(adv)
	struct adv_softc *adv;
{
	struct	  adv_eeprom_config eeprom_config;
	int	  checksum, i;
	u_int16_t config_lsw;
	u_int16_t config_msw;

	adv_get_board_type(adv);
	
	/*
	 * Stop script execution.
	 */
	adv_write_lram_16(adv, ADV_HALTCODE_W, 0x00FE);
	adv_stop_execution(adv);
	adv_reset_chip_and_scsi_bus(adv);
	/*
	 * The generic SCSI code does a minimum delay for us
	 * already.
	 */
	/* DELAY(3 * 1000 * 1000);*/	/* 3 Second Delay */
	if (adv_is_chip_halted(adv) == 0) {
		printf("adv%d: Unable to halt adapter. Initialization"
		       "failed\n", adv->unit);
		return (1);
	}
	ADV_OUTW(adv, ADV_REG_PROG_COUNTER, ADV_MCODE_START_ADDR);
	if (ADV_INW(adv, ADV_REG_PROG_COUNTER) != ADV_MCODE_START_ADDR) {
		printf("adv%d: Unable to set program counter. Initialization"
		       "failed\n", adv->unit);
		return (1);
	}

	config_lsw = ADV_INW(adv, ADV_CONFIG_LSW);
	config_msw = ADV_INW(adv, ADV_CONFIG_MSW);

#if 0
	/* XXX Move to PCI probe code */
	if (adv->type & ADV_PCI) {
#if CC_DISABLE_PCI_PARITY_INT
		config_msw &= 0xFFC0;
		ADV_OUTW(adv, ADV_CONFIG_MSW, config_msw);
#endif

		if (asc_dvc->cfg->pci_device_id == ASC_PCI_DEVICE_ID_REV_A) {
			asc_dvc->bug_fix_cntl |= ASC_BUG_FIX_ADD_ONE_BYTE;
		}
	}
#endif		
	if ((config_msw & ADV_CFG_MSW_CLR_MASK) != 0) {
		config_msw &= (~(ADV_CFG_MSW_CLR_MASK));
		/*
		 * XXX The Linux code flags this as an error,
		 * but what should we report to the user???
		 * It seems that clearing the config register
		 * makes this error recoverable.
		 */
		ADV_OUTW(adv, ADV_CONFIG_MSW, config_msw);
	}

	/* Suck in the configuration from the EEProm */
	checksum = adv_get_eeprom_config(adv, &eeprom_config);

	eeprom_config.cfg_msw &= (~(ADV_CFG_MSW_CLR_MASK));

	if (ADV_INW(adv, ADV_CHIP_STATUS) & ADV_CSW_AUTO_CONFIG) {
		/*
		 * XXX The Linux code sets a warning level for this
		 * condition, yet nothing of meaning is printed to
		 * the user.  What does this mean???
		 */
		if (adv->chip_version == 3) {
			if (eeprom_config.cfg_lsw != config_lsw) {
				/* XXX Yet another supposed Warning */
				eeprom_config.cfg_lsw =
						ADV_INW(adv, ADV_CONFIG_LSW);
			}
			if (eeprom_config.cfg_msw != config_msw) {
				/* XXX Yet another supposed Warning */
				eeprom_config.cfg_msw =
						ADV_INW(adv, ADV_CONFIG_MSW);
			}
		}
	}
	eeprom_config.cfg_lsw |= ADV_CFG_LSW_HOST_INT_ON;
	if (checksum == eeprom_config.chksum) {
		if (adv_test_external_lram(adv) == 0) {
			if (adv->type & ADV_PCI) {
				eeprom_config.cfg_msw |= 0x0800;
				config_msw |= 0x0800;
				ADV_OUTW(adv, ADV_CONFIG_MSW, config_msw);
				eeprom_config.max_total_qng = ADV_MAX_PCI_INRAM_TOTAL_QNG;
				eeprom_config.max_tag_qng = ADV_MAX_INRAM_TAG_QNG;
			}
		}
		/* XXX What about wide bussed cards?? */
		for (i = 0; i <= 7; i++)
			adv->sdtr_data[i] = eeprom_config.sdtr_data[i];
		
		/* Range/Sanity checking */
		if (eeprom_config.max_total_qng < ADV_MIN_TOTAL_QNG) {
			eeprom_config.max_total_qng = ADV_MIN_TOTAL_QNG;
		}
		if (eeprom_config.max_total_qng > ADV_MAX_TOTAL_QNG) {
			eeprom_config.max_total_qng = ADV_MAX_TOTAL_QNG;
		}
		if (eeprom_config.max_tag_qng > eeprom_config.max_total_qng) {
			eeprom_config.max_tag_qng = eeprom_config.max_total_qng;
		}
		if (eeprom_config.max_tag_qng < ADV_MIN_TAG_Q_PER_DVC) {
			eeprom_config.max_tag_qng = ADV_MIN_TAG_Q_PER_DVC;
		}
		adv->max_openings = eeprom_config.max_total_qng;

		if ((eeprom_config.use_cmd_qng & eeprom_config.disc_enable) !=
		    eeprom_config.use_cmd_qng) {
			eeprom_config.disc_enable |= eeprom_config.use_cmd_qng;
			printf("adv:%d: WARNING! One or more targets with tagged "
			       "queuing enabled have the disconnection priveledge "
			       "disabled.\n"
			       "adv:%d: Overriding disconnection settings to "
			       "allow tagged queueing devices to disconnect.\n ",
			       adv->unit, adv->unit);
		}
#if 0
		/*
		 * XXX We should range check our target ID
		 * based on the width of our bus
		 */
		EEPROM_SET_SCSIID(eeprom_config,
				  EEPROM_SCSIID(eeprom_config) & ADV_MAX_TID);
#endif		
		adv->initiate_sdtr = eeprom_config.init_sdtr;
		adv->disc_enable = eeprom_config.disc_enable;
		adv->cmd_qng_enabled = eeprom_config.use_cmd_qng;
		adv->isa_dma_speed = EEPROM_DMA_SPEED(eeprom_config);
		adv->scsi_id = EEPROM_SCSIID(eeprom_config);
		adv->start_motor = eeprom_config.start_motor;
		adv->control = eeprom_config.cntl;
		adv->no_scam = eeprom_config.no_scam;
	} else {
		/*
		 * Use the defaults that adv was initialized with.
		 */
		/*
		 * XXX Fixup EEPROM with default values???
		 */
		printf("adv%d: Warning EEPROM Checksum mismatch. "
		       "Using default device parameters\n", adv->unit);
	}

#if 0
	/* XXX Do this in the PCI probe */
	if ((adv->btype & ADV_PCI) &&
		!(asc_dvc->dvc_cntl & ASC_CNTL_NO_PCI_FIX_ASYN_XFER)) {
		if ((asc_dvc->cfg->pci_device_id == ASC_PCI_DEVICE_ID_REV_A) ||
			(asc_dvc->cfg->pci_device_id == ASC_PCI_DEVICE_ID_REV_B)) {
			asc_dvc->pci_fix_asyn_xfer = ASC_ALL_DEVICE_BIT_SET;
		}
	}
#endif
	if (adv_set_eeprom_config(adv, &eeprom_config) != 0)
		printf("adv:%d: WARNING! Failure writing to EEPROM.\n");

	/* Allocate space for our sense buffers */
	/* XXX this should really be done by the generic SCSI layer by ensuring
	 * that all scsi_xfer structs are allocated below 16M if any controller
	 * needs to bounce.
	 */
	if (adv->type & ADV_ISA) {
		adv->sense_buffers = (struct scsi_sense_data *)contigmalloc(sizeof(struct scsi_sense_data) * adv->max_openings,
									 M_DEVBUF, M_NOWAIT, 0ul, 0xfffffful, 1ul,
									 0x10000ul);
		if (adv->sense_buffers == NULL) {
			printf("adv%d: Unable to allocate sense buffer space.\n");
			return (1);
		}

	}
	
	if (adv_init_lram_and_mcode(adv))
		return (1);

	return (0);
}

void
adv_intr(arg)
	void *arg;
{
	struct	  adv_softc *adv;
	u_int16_t chipstat;
	u_int16_t saved_ram_addr;
	u_int8_t  ctrl_reg;
	u_int8_t  saved_ctrl_reg;
	int	  status;
	u_int8_t  host_flag;

	adv = (struct adv_softc *)arg;

	ctrl_reg = ADV_INB(adv, ADV_CHIP_CTRL);
	saved_ctrl_reg = ctrl_reg & (~(ADV_CC_SCSI_RESET | ADV_CC_CHIP_RESET |
				       ADV_CC_SINGLE_STEP | ADV_CC_DIAG | ADV_CC_TEST));


	if ((chipstat = ADV_INW(adv, ADV_CHIP_STATUS)) & ADV_CSW_INT_PENDING) {
		
		adv_ack_interrupt(adv);

		host_flag = adv_read_lram_8(adv, ADVV_HOST_FLAG_B);
		adv_write_lram_8(adv, ADVV_HOST_FLAG_B,
				 host_flag | ADV_HOST_FLAG_IN_ISR);
		saved_ram_addr = ADV_INW(adv, ADV_LRAM_ADDR);

		if ((chipstat & ADV_CSW_HALTED)
		    && (ctrl_reg & ADV_CC_SINGLE_STEP)) {
			adv_isr_chip_halted(adv);
			saved_ctrl_reg &= ~ADV_CC_HALT;
		} else {
			if ((adv->control & ADV_CNTL_INT_MULTI_Q) != 0) {
				while (((status = adv_qdone(adv)) & 0x01) != 0)
					;
			} else {
				do {
					status = adv_qdone(adv);
				} while (status == 0x11);
			}
		}
		ADV_OUTW(adv, ADV_LRAM_ADDR, saved_ram_addr);
#ifdef DIAGNOSTIC	
		if (ADV_INW(adv, ADV_LRAM_ADDR) != saved_ram_addr)
			panic("adv_intr: Unable to set LRAM addr");
#endif	
		adv_write_lram_8(adv, ADVV_HOST_FLAG_B, host_flag);
	}
	
	ADV_OUTB(adv, ADV_CHIP_CTRL, saved_ctrl_reg);
}

int
adv_qdone(adv)
	struct adv_softc *adv;
{
	u_int8_t	  next_qp;
	u_int8_t	  i;
	u_int8_t	  n_q_used;
	u_int8_t	  sg_list_qp;
	u_int8_t	  sg_queue_cnt;
	u_int8_t	  done_q_tail;
	u_int8_t	  tid_no;
	target_bit_vector target_id;
	u_int16_t	  q_addr;
	u_int16_t	  sg_q_addr;
	struct adv_q_done_info scsiq_buf;
	struct adv_q_done_info *scsiq;
	int               false_overrun;
	u_int8_t	  tag_code;

	n_q_used = 1;
	scsiq = &scsiq_buf;
	done_q_tail = adv_read_lram_16(adv, ADVV_DONE_Q_TAIL_W) & 0xFF;
	q_addr = ADV_QNO_TO_QADDR(done_q_tail);
	next_qp = adv_read_lram_8(adv, q_addr + ADV_SCSIQ_B_FWD);
	if (next_qp != ADV_QLINK_END) {
		adv_write_lram_16(adv, ADVV_DONE_Q_TAIL_W, next_qp);
		q_addr = ADV_QNO_TO_QADDR(next_qp);

		sg_queue_cnt = adv_copy_lram_doneq(adv, q_addr, scsiq, adv->max_dma_count);

		adv_write_lram_8(adv, q_addr + ADV_SCSIQ_B_STATUS,
				 scsiq->q_status & ~(QS_READY | QS_ABORTED));
		tid_no = ADV_TIX_TO_TID(scsiq->d2.target_ix);
		target_id = ADV_TIX_TO_TARGET_ID(scsiq->d2.target_ix);
		if ((scsiq->cntl & QC_SG_HEAD) != 0) {
			sg_q_addr = q_addr;
			sg_list_qp = next_qp;
			for (i = 0; i < sg_queue_cnt; i++) {
				sg_list_qp = adv_read_lram_8(adv,
							     sg_q_addr + ADV_SCSIQ_B_FWD);
				sg_q_addr = ADV_QNO_TO_QADDR(sg_list_qp);
#ifdef DIAGNOSTIC				
				if (sg_list_qp == ASC_QLINK_END) {
					panic("adv_qdone: Corrupted SG list encountered");
				}
#endif				
				adv_write_lram_8(adv, sg_q_addr + ADV_SCSIQ_B_STATUS,
						 QS_FREE);
			}

			n_q_used = sg_queue_cnt + 1;
			adv_write_lram_16(adv, ADVV_DONE_Q_TAIL_W, sg_list_qp);
		}
#if 0
		/* XXX Fix later */
		if (adv->queue_full_or_busy & target_id) {
			cur_target_qng = adv_read_lram_8(adv,
							 ADV_QADR_BEG + scsiq->d2.target_ix);
			if (cur_target_qng < adv->max_dvc_qng[tid_no]) {
				scsi_busy = adv_read_lram_8(adv, ADVV_SCSIBUSY_B);
				scsi_busy &= ~target_id;
				adv_write_lram_8(adv, ADVV_SCSIBUSY_B, scsi_busy);
				adv->queue_full_or_busy &= ~target_id;
			}
		}
#endif
#ifdef DIAGNOSTIC
		if (adv->cur_total_qng < n_q_used)
			panic("adv_qdone: Attempting to free more queues than are active");
#endif		
		adv->cur_active -= n_q_used;

		if ((scsiq->d2.xs_ptr == 0) ||
		    ((scsiq->q_status & QS_ABORTED) != 0))
			return (0x11);
		else if (scsiq->q_status == QS_DONE) {

			false_overrun = FALSE;

			if (adv->bug_fix_control & ADV_BUG_FIX_ADD_ONE_BYTE) {
				tag_code = adv_read_lram_8(adv, q_addr + ADV_SCSIQ_B_TAG_CODE);
				if (tag_code & ADV_TAG_FLAG_ADD_ONE_BYTE) {
					if (scsiq->remain_bytes != 0) {
						scsiq->remain_bytes--;
						if (scsiq->remain_bytes == 0)
							false_overrun = TRUE;
					}
				}
			}
			if ((scsiq->d3.done_stat == QD_WITH_ERROR) &&
			    (scsiq->d3.host_stat == QHSTA_M_DATA_OVER_RUN)) {
				if ((scsiq->cntl & (QC_DATA_IN | QC_DATA_OUT)) == 0) {
					scsiq->d3.done_stat = QD_NO_ERROR;
					scsiq->d3.host_stat = QHSTA_NO_ERROR;
				} else if (false_overrun) {
					scsiq->d3.done_stat = QD_NO_ERROR;
					scsiq->d3.host_stat = QHSTA_NO_ERROR;
				}
			}

			if ((scsiq->cntl & QC_NO_CALLBACK) == 0)
				adv_done(adv, scsiq);
			else {
				if ((adv_read_lram_8(adv, q_addr + ADV_SCSIQ_CDB_BEG) ==
				     START_STOP)) {
					adv->unit_not_ready &= ~target_id;
					if (scsiq->d3.done_stat != QD_NO_ERROR)
						adv->start_motor &= ~target_id;
				}
			}
			return (1);
		} else {
			panic("adv_qdone: completed scsiq with unknown status");
#if 0
			/*
			 * XXX Doesn't this simply indicate a software bug?
			 *     What does setting the lram error code do for
			 *     you.  Would we even recover?
			 */
			AscSetLibErrorCode(asc_dvc, ASCQ_ERR_Q_STATUS);

		  FATAL_ERR_QDONE:
			if ((scsiq->cntl & QC_NO_CALLBACK) == 0) {
				(*asc_isr_callback) (asc_dvc, scsiq);
			}
			return (0x80);
#endif
		}
	}
	return (0);
}


void
adv_done(adv, qdonep)
	struct adv_softc *adv;
	struct adv_q_done_info *qdonep;
{
	struct	scsi_xfer *xs;

	xs = (struct scsi_xfer *)qdonep->d2.xs_ptr;

	xs->status = qdonep->d3.scsi_stat;
	/*
	 * 'qdonep' contains the command's ending status.
	 */
	switch (qdonep->d3.done_stat) {
	case QD_NO_ERROR:
		switch (qdonep->d3.host_stat) {
		case QHSTA_NO_ERROR:
			break;
		case QHSTA_M_SEL_TIMEOUT:
			xs->error = XS_SELTIMEOUT;
			break;
		default:
			/* QHSTA error occurred */
#if 0
			/* XXX Can I get more explicit information here? */
			xs->error = XS_DRIVER_STUFFUP;
#endif
			break;
		}
		break;

	case QD_WITH_ERROR:
		switch (qdonep->d3.host_stat) {
		case QHSTA_NO_ERROR:
			if ((qdonep->d3.scsi_stat == STATUS_CHECK_CONDITION)
			 || (qdonep->d3.scsi_stat == STATUS_COMMAND_TERMINATED)) {
				/* We have valid sense information to return */
				xs->error = XS_SENSE;
				if (adv->sense_buffers != NULL)
					/* Structure copy */
					xs->sense = adv->sense_buffers[qdonep->q_no];
			}
			break;
		case QHSTA_M_SEL_TIMEOUT:
			xs->error = XS_SELTIMEOUT;
			break;
		default:
#if 0
			/* XXX Can I get more explicit information here? */
			xs->error = XS_DRIVER_STUFFUP;
#endif
			break;
		}
		break;

	case QD_ABORTED_BY_HOST:
		/* XXX Should have an explicit ABORTED error code */
		xs->error = XS_ABORTED;
		break;

	default:
#if 0
		printf("adv_done: Unknown done status 0x%x\n",
			qdonep->d3.done_stat);
		xs->error = XS_DRIVER_STUFFUP;
#endif
		break;
	}
	xs->flags |= SCSI_ITSDONE;
	scsi_done(xs);
	return;
}

/*
 * Function to poll for command completion when
 * interrupts are disabled (crash dumps)
 */
static int
adv_poll(adv, xs)
	struct	adv_softc *adv;
	struct	scsi_xfer *xs;
{
	int	wait;

	wait = xs->timeout;
	do {
		DELAY(1000);
		adv_intr((void *)adv);
	} while (--wait && ((xs->flags & SCSI_ITSDONE) == 0));
	if (wait == 0) {
		printf("adv%d: board is not responding\n", adv->unit);
		return (EIO);
	}
	return (0);
}

/*
 * Attach all the sub-devices we can find
 */
int
adv_attach(adv)
	struct adv_softc *adv;
{
	struct scsi_bus *scbus;
	struct scsi_queue *scsiq;

	scsiq = scsi_alloc_queue(adv->max_openings);
	if (scsiq == NULL)
		return 0;

	/*
	 * Prepare the scsi_bus area for the upperlevel scsi code.
	 */
	scbus = scsi_alloc_bus(&adv_switch, adv, adv->unit, scsiq);
	if (scbus == NULL) {
		scsi_free_queue(scsiq);
		return 0;
	}

	/* Override defaults */
	if ((adv->type & ADV_ISA) != 0)
		scbus->adpt_link.adpt_flags |= SADPT_BOUNCE;
	scbus->adpt_link.adpt_target = adv->scsi_id;
	scbus->adpt_link.adpt_openings = 2;  /* XXX Is this correct for these cards? */
	scbus->adpt_link.adpt_tagged_openings = adv->max_openings;

	/*
	 * ask the adapter what subunits are present
	 */
	if(bootverbose)
		printf("adv%d: Probing SCSI bus\n", adv->unit);

	scsi_attachdevs(scbus);

	return 1;
}