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

/*
 * Ported for use with the UltraStor 14f by Gary Close (gclose@wvnvms.wvnet.edu)
 * Thanks to Julian Elischer for advice and help with this port.
 *
 * Written by Julian Elischer (julian@tfs.com)
 * for TRW Financial Systems for use under the MACH(2.5) operating system.
 *
 * TRW Financial Systems, in accordance with their agreement with Carnegie
 * Mellon University, makes this software available to CMU to distribute
 * or use in any manner that they see fit as long as this message is kept with
 * the software. For this reason TFS also grants any other persons or
 * organisations permission to use or modify this software.
 *
 * TFS supplies this software to be publicly redistributed
 * on the understanding that TFS is not responsible for the correct
 * functioning of this software in any circumstances.
 *
 *
 */

/*
 * HISTORY
 * $Log: ultra14f.c,v $
 * Revision 1.3  1993/07/29  11:55:37  nate
 * Syncing our sources back with Julian's, and removing PATCHKIT headers.
 *
 * Large Bustek changes, most everything else is minimal.
 *
 *
 * Revision 1.1  93/05/07  11:37:24  julian
 * fix SLEEPTIME calculation.
 *
 * slight mod to make work with 34F as well: Wed Jun  2 18:05:48 WST 1993
 */
 
#include <sys/types.h>
#include <uha.h>

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

#ifdef  MACH    /* EITHER CMU OR OSF */
#include <i386/ipl.h>
#include <i386at/scsi.h>
#include <i386at/scsiconf.h>

#ifdef  OSF     /* OSF ONLY */
#include <sys/table.h>
#include <i386/handler.h>
#include <i386/dispatcher.h>
#include <i386/AT386/atbus.h>

#else   OSF     /* CMU ONLY */
#include <i386at/atbus.h>
#include <i386/pio.h>
#endif  OSF
#endif  MACH    /* end of MACH specific */

#ifdef  __386BSD__      /* 386BSD specific */
#define isa_dev isa_device
#define dev_unit id_unit
#define dev_addr id_iobase

#include <i386/include/pio.h>
#include <i386/isa/isa_device.h>
#include <scsi/scsi_all.h>
#include <scsi/scsiconf.h>
#endif  __386BSD__

/**/

#ifdef  __386BSD__
#include "ddb.h"
#if     NDDB > 0
int     Debugger();
#else   NDDB
#define Debugger() panic("should call debugger here")
#endif  NDDB
#endif  __386BSD__

#ifdef  MACH
int     Debugger();
#endif  MACH

typedef struct {unsigned char addr[4]; } physaddr;
typedef struct {unsigned char len[4]; } physlen;


#ifdef        MACH
extern physaddr kvtophys();
#define PHYSTOKV(x)   phystokv(x)
#define KVTOPHYS(x)   kvtophys(x)
#endif MACH

#ifdef        __386BSD__
#define PHYSTOKV(x)   (x | 0xFE000000)
#define KVTOPHYS(x)   vtophys(x)
#endif        __386BSD__

extern int delaycount;  /* from clock setup code */
#define NUM_CONCURRENT	16	/* number of concurrent ops per board */
#define UHA_NSEG        33      /* number of dma segments supported     */
#define FUDGE(X)        (X>>1)  /* our loops are slower than spinwait() */
/**/
/************************** board definitions *******************************/
/*
 * I/O Port Interface
*/
 #define UHA_LMASK              (0x000)  /* local doorbell mask reg */
 #define UHA_LINT               (0x001)  /* local doorbell int/stat reg */
 #define UHA_SMASK              (0x002)  /* system doorbell mask reg */
 #define UHA_SINT               (0x003)  /* system doorbell int/stat reg */
 #define UHA_ID0                (0x004)  /* product id reg 0 */
 #define UHA_ID1                (0x005)  /* product id reg 1 */
 #define UHA_CONF1              (0x006)  /* config reg 1 */
 #define UHA_CONF2              (0x007)  /* config reg 2 */
 #define UHA_OGM0               (0x008)  /* outgoing mail ptr 0 least sig */
 #define UHA_OGM1               (0x009)  /* outgoing mail ptr 1 least mid */
 #define UHA_OGM2               (0x00a)  /* outgoing mail ptr 2 most mid  */
 #define UHA_OGM3               (0x00b)  /* outgoing mail ptr 3 most sig  */
 #define UHA_ICM0               (0x00c)  /* incoming mail ptr 0 */
 #define UHA_ICM1               (0x00d)  /* incoming mail ptr 1 */
 #define UHA_ICM2               (0x00e)  /* incoming mail ptr 2 */
 #define UHA_ICM3               (0x00f)  /* incoming mail ptr 3 */

 /*
* UHA_LMASK bits (read only) 
*/

#define UHA_LDIE                0x80    /* local doorbell int enabled */
#define UHA_SRSTE               0x40    /* soft reset enabled */
#define UHA_ABORTEN             0x10    /* abort MSCP enabled */
#define UHA_OGMINTEN            0x01    /* outgoing mail interrupt enabled */

/*
* UHA_LINT bits (read)
*/

#define UHA_LDIP                0x80    /* local doorbell int pending */

/*
* UHA_LINT bits (write)
*/

#define UHA_ADRST               0x40    /* adapter soft reset */
#define UHA_SBRST               0x20    /* scsi bus reset */
#define UHA_ASRST               0x60    /* adapter and scsi reset */
#define UHA_ABORT               0x10    /* abort MSCP */
#define UHA_OGMINT              0x01    /* tell adapter to get mail */

/*
* UHA_SMASK bits (read)
*/

#define UHA_SINTEN              0x80    /* system doorbell interupt Enabled */
#define UHA_ABORT_COMPLETE_EN   0x10    /* abort MSCP command complete int Enabled */
#define UHA_ICM_ENABLED         0x01    /* ICM interrupt enabled

/*
* UHA_SMASK bits (write)
*/

#define UHA_ENSINT              0x80    /* enable system doorbell interrupt */
#define UHA_EN_ABORT_COMPLETE   0x10    /* enable abort MSCP complete int */
#define UHA_ENICM               0x01    /* enable ICM interrupt */

/*
* UHA_SINT bits (read)
*/

#define UHA_SINTP               0x80    /* system doorbell int pending */
#define UHA_ABORT_SUCC          0x10    /* abort MSCP successful */
#define UHA_ABORT_FAIL          0x18    /* abort MSCP failed */

/*
* UHA_SINT bits (write)
*/

#define UHA_ABORT_ACK           0x18    /* acknowledge status and clear */
#define UHA_ICM_ACK             0x01    /* acknowledge ICM and clear */

/* 
* UHA_CONF1 bits (read only)
*/

#define UHA_DMA_CH5             0x00    /* DMA channel 5 */
#define UHA_DMA_CH6             0x40    /* 6 */
#define UHA_DMA_CH7             0x80    /* 7 */
#define UHA_IRQ15               0x00    /* IRQ 15 */
#define UHA_IRQ14               0x10    /* 14 */
#define UHA_IRQ11               0x20    /* 11 */
#define UHA_IRQ10               0x30    /* 10 */

/***********************************
* ha_status error codes
\***********************************/

#define UHA_NO_ERR		0x00		/* No error supposedly */
#define UHA_SBUS_ABORT_ERR	0x84		/* scsi bus abort error */
#define UHA_SBUS_TIMEOUT	0x91		/* scsi bus selection timeout */
#define UHA_SBUS_OVER_UNDER	0x92		/* scsi bus over/underrun */
#define UHA_BAD_SCSI_CMD	0x96		/* illegal scsi command */
#define UHA_AUTO_SENSE_ERR	0x9b		/* auto request sense err */
#define UHA_SBUS_RES_ERR	0xa3		/* scsi bus reset error */
#define UHA_BAD_SG_LIST		0xff		/* invalid scatter gath list */

/**/

struct  uha_dma_seg
{
	physaddr			addr;
	physlen				len;
};
/**/

struct  mscp
{
	unsigned char		opcode:3;
	#define U14_HAC		0x01 		/*host adapter command*/
	#define U14_TSP		0x02		/*target scsi pass through command*/
	#define U14_SDR		0x04		/*scsi device reset*/
	unsigned char		xdir:2;		/*xfer direction*/
	#define U14_SDET	0x00		/*determined by scsi command*/
	#define U14_SDIN	0x01		/*scsi data in*/
	#define U14_SDOUT	0x02		/*scsi data out*/
	#define U14_NODATA	0x03		/*no data xfer*/
	unsigned char		dcn:1;		/*disable disconnect for this command*/
	unsigned char		ca:1;		/*Cache control*/
	unsigned char		sgth:1;		/*scatter gather flag*/
	unsigned char		target:3;
	unsigned char		chan:2;		/*scsi channel (always 0 for 14f)*/
	unsigned char		lun:3;
	physaddr		data;
	physlen			datalen;
	physaddr		link;
	unsigned char		link_id;
	unsigned char		sg_num;		/*number of scat gath segs */
						/*in s-g list if sg flag is*/
						/*set. starts at 1, 8bytes per*/
	unsigned char		senselen;
	unsigned char		cdblen;
	unsigned char		cdb[12];
	unsigned char		ha_status;
	unsigned char		targ_status;
	physaddr		sense;		/* if 0 no auto sense */
	/*-----------------end of hardware supported fields----------------*/
	struct  mscp     *next;  /* in free list */
	struct  scsi_xfer *xs; /* the scsi_xfer for this cmd */
	long    int     delta;  /* difference from previous*/
	struct  mscp     *later,*sooner;
	int             flags;
#define MSCP_FREE        0
#define MSCP_ACTIVE      1
#define MSCP_ABORTED     2
	struct  uha_dma_seg     uha_dma[UHA_NSEG];
	struct  scsi_sense_data mscp_sense;
};

struct  mscp     *uha_soonest    = (struct mscp *)0;
struct  mscp     *uha_latest     = (struct mscp *)0;
long    int     uha_furtherest  = 0; /* longest time in the timeout queue */
/**/

struct  uha_data
{
	int     flags;
#define UHA_INIT        0x01;
	int     baseport;
	struct  mscp mscps[NUM_CONCURRENT];
	struct  mscp *free_mscp;
	int     our_id;                 /* our scsi id */
	int     vect;
	int	dma;
} uha_data[NUHA];

int     uhaprobe();
int     uha_attach();
int     uhaintr();
int     uha_scsi_cmd();
int     uha_timeout();
int	uha_abort();
struct  mscp *cheat;
void    uhaminphys();
long int uha_adapter_info();

unsigned long int scratch;

#ifdef  MACH
struct  isa_driver      uhadriver = { uhaprobe, 0, uha_attach, "uha", 0, 0, 0};
int (*uhaintrs[])() = {uhaintr, 0};
#endif  MACH

#ifdef  __386BSD__
struct  isa_driver      uhadriver = { uhaprobe, uha_attach, "uha"};
#endif  __386BSD__

static	uha_unit = 0;
int     uha_debug = 0;
#define UHA_SHOWMSCPS 0x01
#define UHA_SHOWINTS 0x02
#define UHA_SHOWCMDS 0x04
#define UHA_SHOWMISC 0x08
#define FAIL    1
#define SUCCESS 0
#define PAGESIZ 4096

struct  scsi_switch     uha_switch = 
{
	uha_scsi_cmd,
	uhaminphys,
	0,
	0,
	uha_adapter_info,
	0,0,0
};

/**/
/***********************************************************************\
* Function to send a command out through a mailbox                      *
\***********************************************************************/
uha_send_mbox(  int             unit
		,struct mscp     *mscp)
{
	int     port = uha_data[unit].baseport;
	int     spincount = FUDGE(delaycount) * 1000; /* 1s should be enough */
	int     s = splbio();
		
	while(      ((inb(port + UHA_LINT) & (UHA_LDIP))
					!= (0))
		&& (spincount--));
	if(spincount == -1)
	{
		printf("uha%d: board not responding\n",unit);
		Debugger();
	}

	outl(port + UHA_OGM0,KVTOPHYS(mscp)); 
	outb(port + UHA_LINT, (UHA_OGMINT));
	splx(s);
}

/***********************************************************************\
* Function to send abort to 14f                                         *
\***********************************************************************/

uha_abort(	int		unit
		,struct mscp	*mscp)
{
	int	port = uha_data[unit].baseport;
	int	spincount = FUDGE(delaycount) * 1;
	int	abortcount = FUDGE(delaycount) * 2000;
	int	s = splbio();
	
	while(((inb(port + UHA_LINT) & (UHA_LDIP))
				!= (0))
		&& (spincount--));
	if(spincount == -1);
	{
		printf("uha%d: board not responding\n",unit);
		Debugger();
	}

	outl(port + UHA_OGM0,KVTOPHYS(mscp));
	outb(port + UHA_LINT,UHA_ABORT);

	while((abortcount--) && (!(inb(port + UHA_SINT) & UHA_ABORT_FAIL)));
	if(abortcount == -1)
	{
		printf("uha%d: board not responding\n",unit);
		Debugger();
	}
	if((inb(port + UHA_SINT) & 0x10) != 0)
	{
		outb(port + UHA_SINT,UHA_ABORT_ACK);
		return(1);
	}
	else
	{
		outb(port + UHA_SINT,UHA_ABORT_ACK);
		return(0);
	}
}

/***********************************************************************\
* Function to poll for command completion when in poll mode             *
\***********************************************************************/
uha_poll(int unit ,int wait) /* in msec  */
{
	int     port = uha_data[unit].baseport;
	int     spincount = FUDGE(delaycount) * wait; /* in msec */
	int     stport = port + UHA_SINT;
	int     start = spincount;

retry:
	while( (spincount--) && (!(inb(stport) &  UHA_SINTP)));
	if(spincount == -1)
	{
		printf("uha%d: board not responding\n",unit);
		return(EIO);
	}
if ((int)cheat != PHYSTOKV(inl(port + UHA_ICM0)))
{
	printf("discarding %x ",inl(port + UHA_ICM0));
	outb(port + UHA_SINT, UHA_ICM_ACK);
	spinwait(50);
	goto retry;
}/* don't know this will work */
	uhaintr(unit);
	return(0);
}

/*******************************************************\
* Check if the device can be found at the port given    *
* and if so, set it up ready for further work           *
* as an argument, takes the isa_dev structure from      *
* autoconf.c                                            *
\*******************************************************/
uhaprobe(dev)
struct isa_dev *dev;
{
	int	unit = uha_unit;
	dev->dev_unit = unit;
	uha_data[unit].baseport = dev->dev_addr;
	if(unit >= NUHA)
	{
		printf("uha: unit number (%d) too high\n",unit);
		return(0);
	}
	
	/*try and initialize unit at this location*/
	if (uha_init(unit) != 0)
	{
		return(0);
	}

	/* if its there put in it's interrupt and DRQ vectors */

	dev->id_irq = (1 << uha_data[unit].vect);
	dev->id_drq = uha_data[unit].dma;

	
	uha_unit ++;
return(1);
}

/***********************************************\
* Attach all the sub-devices we can find        *
\***********************************************/
uha_attach(dev)
struct  isa_dev *dev;
{
	int     unit = dev->dev_unit;


#ifdef  __386BSD__
	printf("uha%d: **probing for scsi devices**\n", unit);
#endif  __386BSD__

	/***********************************************\
	* ask the adapter what subunits are present     *
	\***********************************************/
	scsi_attachdevs( unit, uha_data[unit].our_id, &uha_switch);

#if defined(OSF)
	uha_attached[unit]=1;
#endif /* defined(OSF) */
	if(!unit)  /* only one for all boards */
	{
		uha_timeout(0);
	}


#ifdef  __386BSD__
	printf("uha%d",unit);
#endif  __386BSD__
	return;
}

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

/***********************************************\
* Catch an interrupt from the adaptor           *
\***********************************************/
uhaintr(unit)
{
	struct mscp      *mscp;
	u_char          uhastat;
	unsigned long int        mboxval;

	int     port = uha_data[unit].baseport;


	if(scsi_debug & PRINTROUTINES)
		printf("uhaintr ");

#if defined(OSF)
	if (!uha_attached[unit])
	{
		return(1);
	}
#endif /* defined(OSF) */
	while(inb(port + UHA_SINT) & UHA_SINTP)
	{
		/***********************************************\
		* First get all the information and then        *
		* acknowlege the interrupt                      *
		\***********************************************/
		uhastat = inb(port + UHA_SINT);
		mboxval = inl(port + UHA_ICM0);
		outb(port + UHA_SINT,UHA_ICM_ACK);

		if(scsi_debug & TRACEINTERRUPTS)
			printf("status = 0x%x ",uhastat);
		/***********************************************\
		* Process the completed operation               *
		\***********************************************/
	
			mscp = (struct mscp *)(PHYSTOKV(mboxval)); 

			if(uha_debug & UHA_SHOWCMDS )
			{
				uha_show_scsi_cmd(mscp->xs);
			}
			if((uha_debug & UHA_SHOWMSCPS) && mscp)
				printf("<int mscp(%x)>",mscp);
			uha_remove_timeout(mscp);

			uha_done(unit,mscp);
	}
	return(1);
}

/***********************************************\
* We have a mscp which has been processed by the *
* adaptor, now we look to see how the operation *
* went.                                         *
\***********************************************/

uha_done(unit,mscp)
int     unit;
struct mscp *mscp;
{
	struct  scsi_sense_data *s1,*s2;
	struct  scsi_xfer *xs = mscp->xs;

	if(scsi_debug & (PRINTROUTINES | TRACEINTERRUPTS))
		printf("uha_done ");
	/***********************************************\
	* Otherwise, put the results of the operation   *
	* into the xfer and call whoever started it     *
	\***********************************************/
	if ( (mscp->ha_status == UHA_NO_ERR) || (xs->flags & SCSI_ERR_OK))
	{               /* All went correctly  OR errors expected */
		xs->resid = 0;
		xs->error = 0;
	}
	else
	{

		s1 = &(mscp->mscp_sense);
		s2 = &(xs->sense);

		if(mscp->ha_status != UHA_NO_ERR)
		{
			switch(mscp->ha_status)
			{
			case    UHA_SBUS_TIMEOUT:           /* No response */
				if (uha_debug & UHA_SHOWMISC)
				{
					printf("timeout reported back\n");
				}
				xs->error = XS_TIMEOUT;
				break;
			case	UHA_SBUS_OVER_UNDER:
				if (uha_debug & UHA_SHOWMISC)
				{
					printf("scsi bus xfer over/underrun\n");
				}
				xs->error = XS_DRIVER_STUFFUP;
				break;
			case	UHA_BAD_SG_LIST:
				if (uha_debug & UHA_SHOWMISC)
				{
					printf("bad sg list reported back\n");
				}
				xs->error = XS_DRIVER_STUFFUP;
				break;
			default:        /* Other scsi protocol messes */
				xs->error = XS_DRIVER_STUFFUP;
				if (uha_debug & UHA_SHOWMISC)
				{
					printf("unexpected ha_status: %x\n",
						mscp->ha_status);
				}
			}

		}
		else
		{

			if (mscp->targ_status != 0)
/**************************************************************************\
* I have no information for any possible value of target status field     *
* other than 0 means no error!! So I guess any error is unexpected in that *
* event!! 								   *
\**************************************************************************/

			{	
				if (uha_debug & UHA_SHOWMISC)
				{
					printf("unexpected targ_status: %x\n",
						mscp->targ_status);
				}
				xs->error = XS_DRIVER_STUFFUP;
			}
		}
	}
done:   xs->flags |= ITSDONE;
	uha_free_mscp(unit,mscp, xs->flags);
	if(xs->when_done)
		(*(xs->when_done))(xs->done_arg,xs->done_arg2);
}

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

	mscp->next = uha_data[unit].free_mscp;
	uha_data[unit].free_mscp = mscp;
	mscp->flags = MSCP_FREE;
	/***********************************************\
	* If there were none, wake abybody waiting for  *
	* one to come free, starting with queued entries*
	\***********************************************/
	if (!mscp->next) {
		wakeup(&uha_data[unit].free_mscp);
	}
	if (!(flags & SCSI_NOMASK)) 
		splx(opri);
}

/***********************************************\
* Get a free mscp (and hence mbox-out entry)     *
\***********************************************/
struct mscp *
uha_get_mscp(unit,flags)
{
	unsigned opri;
	struct mscp *rc;

	if(scsi_debug & PRINTROUTINES)
		printf("<mscp%d(0x%x) ",unit,flags);
	if (!(flags & SCSI_NOMASK)) 
		opri = splbio();
	/***********************************************\
	* If we can and have to, sleep waiting for one  *
	* to come free                                  *
	\***********************************************/
	while ((!(rc = uha_data[unit].free_mscp)) && (!(flags & SCSI_NOSLEEP)))
	{
		sleep(&uha_data[unit].free_mscp, PRIBIO);
	}
	if (rc) 
	{
		uha_data[unit].free_mscp = rc->next;
		rc->flags = MSCP_ACTIVE;
	}
	if (!(flags & SCSI_NOMASK)) 
		splx(opri);
	return(rc);
}
		


/***********************************************\
* Start the board, ready for normal operation   *
\***********************************************/

uha_init(unit)
int	unit;
{	
	unsigned char ad[4];
	volatile unsigned char model;
	volatile unsigned char submodel;
	unsigned char config_reg1;
	unsigned char config_reg2;
	unsigned char dma_ch;
	unsigned char irq_ch;
	unsigned char uha_id;
	int	port = uha_data[unit].baseport;
	int	i;
	int	resetcount = FUDGE(delaycount) * 4000;

	model = inb(port + UHA_ID0);
	submodel = inb(port + UHA_ID1);
		 if ((model != 0x56) & (submodel != 0x40))
		      { printf("ultrastor 14f not responding\n");
			return(ENXIO); }

	printf("uha%d reading board settings, ",unit);

	config_reg1 = inb(port + UHA_CONF1);
	config_reg2 = inb(port + UHA_CONF2);
	dma_ch = (config_reg1 & 0xc0);
	irq_ch = (config_reg1 & 0x30);
	uha_id = (config_reg2 & 0x07);

	switch(dma_ch)
	{
	case	UHA_DMA_CH5:
		uha_data[unit].dma = 5;
		printf("dma=5 ");
		break;
	case	UHA_DMA_CH6:
		uha_data[unit].dma = 6;
		printf("dma=6 ");
		break;
	case	UHA_DMA_CH7:
		uha_data[unit].dma = 7;
		printf("dma=7 ");
		break;
	default:
		printf("illegal dma jumper setting\n");
		return(EIO);
	}
	switch(irq_ch)
	{
	case	UHA_IRQ10:
		uha_data[unit].vect = 10;
		printf("int=10 ");
		break;
	case	UHA_IRQ11:
		uha_data[unit].vect = 11;
		printf("int=11 ");
		break;
	case	UHA_IRQ14:
		uha_data[unit].vect = 14;
		printf("int=14 ");
		break;
	case	UHA_IRQ15:
		uha_data[unit].vect = 15;
		printf("int=15 ");
		break;
	default:
		printf("illegal int jumper setting\n");
		return(EIO);
	}
	/* who are we on the scsi bus */
	printf("id=%x\n",uha_id);
	uha_data[unit].our_id = uha_id;

	
	/***********************************************\
	* link up all our MSCPs into a free list         *
	\***********************************************/
	for (i=0; i < NUM_CONCURRENT; i++)
	{
		uha_data[unit].mscps[i].next = uha_data[unit].free_mscp;
		uha_data[unit].free_mscp = &uha_data[unit].mscps[i];
		uha_data[unit].free_mscp->flags = MSCP_FREE;
	}

	/***********************************************\
	* Note that we are going and return (to probe)  *
	\***********************************************/
	outb(port + UHA_LINT, UHA_ASRST);	
	while( (resetcount--) && (!(inb(port + UHA_LINT))));
	if(resetcount == -1)
	{
		printf("uha%d: board timed out during reset\n",unit);
		return(ENXIO);
	}

	outb(port + UHA_SMASK, 0x81); /* make sure interrupts are enabled */
	uha_data[unit].flags |= UHA_INIT;
	return(0);
}



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


void uhaminphys(bp)
struct  buf *bp;
{
#ifdef  MACH
#if     !defined(OSF)
	bp->b_flags |= B_NPAGES;                /* can support scat/gather */
#endif  /* defined(OSF) */
#endif  MACH
	if(bp->b_bcount > ((UHA_NSEG-1) * PAGESIZ))
	{
		bp->b_bcount = ((UHA_NSEG-1) * PAGESIZ);
	}
}

/***********************************************\
* start a scsi operation given the command and  *
* the data address. Also needs the unit, target *
* and lu                                        *
\***********************************************/
int     uha_scsi_cmd(xs)
struct scsi_xfer *xs;
{
	struct  scsi_sense_data *s1,*s2;
	struct mscp *mscp;
	struct uha_dma_seg *sg;
	int     seg;    /* scatter gather seg being worked on */
	int i   = 0;
	int rc  =  0;
	int     thiskv;
	unsigned long int        thisphys,nextphys;
	int     unit =xs->adapter;
	int     bytes_this_seg,bytes_this_page,datalen,flags;
	struct  iovec   *iovp;
	int     s;
	unsigned int stat;
	int	port = uha_data[unit].baseport;
	unsigned long int templen;


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

cheat = mscp;
	if(uha_debug & UHA_SHOWMSCPS)
				printf("<start mscp(%x)>",mscp);
	if(scsi_debug & SHOWCOMMANDS)
	{
		uha_show_scsi_cmd(xs);
	}
	mscp->xs = xs;
	/***********************************************\
	* Put all the arguments for the xfer in the mscp *
	\***********************************************/

	if (flags & SCSI_RESET)
	{
		mscp->opcode = 0x04;
		mscp->ca = 0x01;
	}
	else
	{
		mscp->opcode = 0x02;
		mscp->ca = 0x01;
	}		

	if (flags & SCSI_DATA_IN)
	{
		mscp->xdir = 0x01;
	}
	if (flags & SCSI_DATA_OUT)
	{
		mscp->xdir = 0x02;
	}

	if (xs->lu != 0)
	{
		xs->error = XS_DRIVER_STUFFUP;
		uha_free_mscp(unit,mscp,flags);
		return(HAD_ERROR);
	}
	
	mscp->dcn	= 0x00;
	mscp->chan	= 0x00;
	mscp->target	= xs->targ;
	mscp->lun	= xs->lu;
	mscp->link.addr[0]	= 0x00;
	mscp->link.addr[1]	= 0x00;
	mscp->link.addr[2]	= 0x00;
	mscp->link.addr[3]	= 0x00;
	mscp->link_id	= 0x00;
	mscp->cdblen             =       xs->cmdlen;
	scratch			=	KVTOPHYS(&(mscp->mscp_sense));
	mscp->sense.addr[0]     =	(scratch & 0xff);
	mscp->sense.addr[1]	=	((scratch >> 8) & 0xff);
	mscp->sense.addr[2]	=	((scratch >> 16) & 0xff);
	mscp->sense.addr[3]	=	((scratch >> 24) & 0xff);
	mscp->senselen          =       sizeof(mscp->mscp_sense);
	mscp->ha_status		=	0x00;
	mscp->targ_status	=	0x00;

	if(xs->datalen)
	{ /* should use S/G only if not zero length */
		scratch			=	KVTOPHYS(mscp->uha_dma);
		mscp->data.addr[0]      =	(scratch & 0xff);
		mscp->data.addr[1]	=	((scratch >> 8) & 0xff);
		mscp->data.addr[2]	=	((scratch >> 16) & 0xff);
		mscp->data.addr[3]	=	((scratch >> 24) & 0xff);
		sg              =       mscp->uha_dma ;
		seg             =       0;
		mscp->sgth	=	0x01;

		if(flags & SCSI_DATA_UIO)
		{
			iovp = ((struct uio *)xs->data)->uio_iov;
			datalen = ((struct uio *)xs->data)->uio_iovcnt;
			xs->datalen = 0;
			while ((datalen) && (seg < UHA_NSEG))
			{
				scratch  = (unsigned long)iovp->iov_base;
				sg->addr.addr[0] = (scratch & 0xff); 
				sg->addr.addr[1] = ((scratch >> 8) & 0xff);
				sg->addr.addr[2] = ((scratch >> 16) & 0xff);
				sg->addr.addr[3] = ((scratch >> 24) & 0xff);
				xs->datalen += *(unsigned long *)sg->len.len = iovp->iov_len; 
				if(scsi_debug & SHOWSCATGATH)
					printf("(0x%x@0x%x)"
							,iovp->iov_len
							,iovp->iov_base);
				sg++;
				iovp++;
				seg++;
				datalen--;
			}
		}
		else
		{
			/***********************************************\
			* Set up the scatter gather block               *
			\***********************************************/
		
			if(scsi_debug & SHOWSCATGATH)
				printf("%d @0x%x:- ",xs->datalen,xs->data);
			datalen         =       xs->datalen;
			thiskv          =       (int)xs->data;
			thisphys        =       KVTOPHYS(thiskv);
			templen		=	0;
		
			while ((datalen) && (seg < UHA_NSEG))
			{
				bytes_this_seg  = 0;
	
				/* put in the base address */
				sg->addr.addr[0] = (thisphys & 0xff);
				sg->addr.addr[1] = ((thisphys >> 8) & 0xff);
				sg->addr.addr[2] = ((thisphys >> 16) & 0xff);
				sg->addr.addr[3] = ((thisphys >> 24) & 0xff);
		
				if(scsi_debug & SHOWSCATGATH)
					printf("0x%x",thisphys);
	
				/* do it at least once */
				nextphys = thisphys;    
				while ((datalen) && (thisphys == nextphys))
				/*********************************************\
				* This page is contiguous (physically) with   *
				* the the last, just extend the length        *
				\*********************************************/
				{
					/* how far to the end of the page */
					nextphys = (thisphys & (~(PAGESIZ - 1)))
								+ PAGESIZ;
					bytes_this_page = nextphys - thisphys;
					/**** or the data ****/
					bytes_this_page = min(bytes_this_page
								,datalen);
					bytes_this_seg  += bytes_this_page;
					datalen         -= bytes_this_page;
		
					/* get more ready for the next page */
					thiskv  = (thiskv & (~(PAGESIZ - 1)))
								+ PAGESIZ;
					if(datalen)
						thisphys = KVTOPHYS(thiskv);
				}
				/********************************************\
				* next page isn't contiguous, finish the seg *
				\********************************************/
				if(scsi_debug & SHOWSCATGATH)
					printf("(0x%x)",bytes_this_seg);
				sg->len.len[0] = (bytes_this_seg & 0xff);
				sg->len.len[1] = ((bytes_this_seg >> 8) & 0xff);
				sg->len.len[2] = ((bytes_this_seg >> 16) & 0xff);
				sg->len.len[3] = ((bytes_this_seg >> 24) & 0xff);
				templen += bytes_this_seg;
				sg++;
				seg++;
			}
		} /*end of iov/kv decision */
		mscp->datalen.len[0] = (templen & 0xff);
		mscp->datalen.len[1] = ((templen >> 8) & 0xff);
		mscp->datalen.len[2] = ((templen >> 16) & 0xff);
		mscp->datalen.len[3] = ((templen >> 24) & 0xff);
		mscp->sg_num = seg;

		if(scsi_debug & SHOWSCATGATH)
			printf("\n");
		if (datalen)
		{ /* there's still data, must have run out of segs! */
			printf("uha_scsi_cmd%d: more than %d DMA segs\n",
				unit,UHA_NSEG);
			xs->error = XS_DRIVER_STUFFUP;
			uha_free_mscp(unit,mscp,flags);
			return(HAD_ERROR);
		}

	}
	else
	{       /* No data xfer, use non S/G values */
		mscp->data.addr[0] = 0x00;
		mscp->data.addr[1] = 0x00;
		mscp->data.addr[2] = 0x00;
		mscp->data.addr[3] = 0x00;
		mscp->datalen.len[0] = 0x00;
		mscp->datalen.len[1] = 0x00;
		mscp->datalen.len[2] = 0x00;
		mscp->datalen.len[3] = 0x00;
		mscp->xdir = 0x03;
		mscp->sgth = 0x00;
		mscp->sg_num = 0x00;	
	}

	/***********************************************\
	* Put the scsi command in the mscp and start it  *
	\***********************************************/
	bcopy(xs->cmd, mscp->cdb, xs->cmdlen); 

	/***********************************************\
	* Usually return SUCCESSFULLY QUEUED            *
	\***********************************************/
	if (!(flags & SCSI_NOMASK))
	{
		s = splbio();
		uha_send_mbox(unit,mscp);
		uha_add_timeout(mscp,xs->timeout);
		splx(s);
		if(scsi_debug & TRACEINTERRUPTS)
			printf("cmd_sent ");
		return(SUCCESSFULLY_QUEUED);
	}
	/***********************************************\
	* If we can't use interrupts, poll on completion*
	\***********************************************/
	uha_send_mbox(unit,mscp);
	if(scsi_debug & TRACEINTERRUPTS)
		printf("cmd_wait ");
	do
	{
		if(uha_poll(unit,xs->timeout))
		{
			if (!(xs->flags & SCSI_SILENT)) printf("cmd fail\n");
			if(!(uha_abort(unit,mscp)))
			{
				printf("abort failed in wait\n");
				uha_free_mscp(unit,mscp,flags);
			}
			xs->error = XS_DRIVER_STUFFUP;
			splx(s);
			return(HAD_ERROR);
		}
	} while (!(xs->flags & ITSDONE));/* something (?) else finished */
	splx(s);
scsi_debug = 0;uha_debug = 0;
	if(xs->error)
	{
		return(HAD_ERROR);
	}
	return(COMPLETE);
}

/*
 *                +----------+    +----------+    +----------+
 * uha_soonest--->|    later |--->|     later|--->|     later|--->0
 *                | [Delta]  |    | [Delta]  |    | [Delta]  |
 *           0<---|sooner    |<---|sooner    |<---|sooner    |<---uha_latest
 *                +----------+    +----------+    +----------+
 *
 *     uha_furtherest = sum(Delta[1..n])
 */
uha_add_timeout(mscp,time)
struct  mscp     *mscp;
int     time;
{
	int     timeprev;
	struct mscp *prev;
	int     s = splbio();

	if(prev = uha_latest) /* yes, an assign */
	{
		timeprev = uha_furtherest;
	}
	else
	{
		timeprev = 0;
	}
	while(prev && (timeprev > time)) 
	{
		timeprev -= prev->delta;
		prev = prev->sooner;
	}
	if(prev)
	{
		mscp->delta = time - timeprev;
		if( mscp->later = prev->later) /* yes an assign */
		{
			mscp->later->sooner = mscp;
			mscp->later->delta -= mscp->delta;
		}
		else
		{
			uha_furtherest = time;
			uha_latest = mscp;
		}
		mscp->sooner = prev;
		prev->later = mscp;
	}
	else
	{
		if( mscp->later = uha_soonest) /* yes, an assign*/
		{
			mscp->later->sooner = mscp;
			mscp->later->delta -= time;
		}
		else
		{
			uha_furtherest = time;
			uha_latest = mscp;
		}
		mscp->delta = time;
		mscp->sooner = (struct mscp *)0;
		uha_soonest = mscp;
	}
	splx(s);
}

uha_remove_timeout(mscp)
struct  mscp     *mscp;
{
	int     s = splbio();

	if(mscp->sooner)
	{
		mscp->sooner->later = mscp->later;
	}
	else
	{
		uha_soonest = mscp->later;
	}
	if(mscp->later)
	{
		mscp->later->sooner = mscp->sooner;
		mscp->later->delta += mscp->delta;
	}
	else
	{
		uha_latest = mscp->sooner;
		uha_furtherest -= mscp->delta;
	}
	mscp->sooner = mscp->later = (struct mscp *)0;
	splx(s);
}


extern int      hz;
#define ONETICK 500 /* milliseconds */
#define SLEEPTIME ((hz * ONETICK) / 1000)
uha_timeout(arg)
int     arg;
{
	struct  mscp  *mscp;
	int     unit;
	int     s       = splbio();
	unsigned int stat;
	int	port = uha_data[unit].baseport;

	while( mscp = uha_soonest )
	{
		if(mscp->delta <= ONETICK)
		/***********************************************\
		* It has timed out, we need to do some work     *
		\***********************************************/
		{
			unit = mscp->xs->adapter;
			printf("uha%d:%d device timed out\n",unit
					,mscp->xs->targ);
			if(uha_debug & UHA_SHOWMSCPS)
				uha_print_active_mscp();

			/***************************************\
			* Unlink it from the queue              *
			\***************************************/
			uha_remove_timeout(mscp);

			if((uha_abort(unit,mscp) !=1) || (mscp->flags = MSCP_ABORTED))
			{
				printf("AGAIN");
				mscp->xs->retries = 0; /* I MEAN IT ! */
				uha_done(unit,mscp,FAIL);
			}
			else    /* abort the operation that has timed out */
			{
				printf("\n");
				uha_add_timeout(mscp,2000 + ONETICK);
				mscp->flags = MSCP_ABORTED;
			}
		}
		else
		/***********************************************\
		* It has not timed out, adjust and leave        *
		\***********************************************/
		{
			mscp->delta -= ONETICK;
			uha_furtherest -= ONETICK;
			break;
		}
	}
	splx(s);
	timeout(uha_timeout,arg,SLEEPTIME);
}

uha_show_scsi_cmd(struct scsi_xfer *xs)
{
	u_char  *b = (u_char *)xs->cmd;
	int i = 0;
	if(!(xs->flags & SCSI_RESET))
	{
		printf("uha%d:%d:%d-"
			,xs->adapter
			,xs->targ
			,xs->lu);
		while(i < xs->cmdlen )
		{
			if(i) printf(",");
			printf("%x",b[i++]);
		}
		printf("-\n");
	}
	else
	{
		printf("uha%d:%d:%d-RESET-\n" 
			,xs->adapter 
			,xs->targ
			,xs->lu
		);
	}
}
uha_print_mscp(mscp)
struct  mscp *mscp;
{
	printf("mscp:%x op:%x cmdlen:%d senlen:%d\n"
		,mscp
		,mscp->opcode
		,mscp->cdblen
		,mscp->senselen);
	printf("	sg:%d sgnum:%x datlen:%d hstat:%x tstat:%x delta:%d flags:%x\n"
		,mscp->sgth
		,mscp->sg_num
		,mscp->datalen
		,mscp->ha_status
		,mscp->targ_status
		,mscp->delta
		,mscp->flags);
	uha_show_scsi_cmd(mscp->xs);
}

uha_print_active_mscp()
{
	struct  mscp *mscp;
	mscp = uha_soonest;

	while(mscp)
	{
		uha_print_mscp(mscp);
		mscp = mscp->later;
	}
	printf("Furtherest = %d\n",uha_furtherest);
}