From: julian@tfs.com (Julian Elischer)
Subject: New scsi system beta3 (part 9 of       10)
Organization: TRW Financial Systems
Date: Sat, 3 Oct 1992 04:02:45 GMT

# This is a shell archive.  Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file".  Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
#	scsi/README.AHA1742
#	i386/conf/AHBTEST
#	i386/isa/aha1742.c
#
echo x - scsi/README.AHA1742
sed 's/^X//' >scsi/README.AHA1742 << 'END-of-scsi/README.AHA1742'
XJust a note:
X
XThe new bootblocks do not work with the 1742 in extended mode:
XThey DO however love it in standard mode.
X
XThe driver  automatically switches the board to extended mode when
Xit finds it
Xso leave your 1742 board in standard mode and just boot with the new bootblocks.
X
XWhen unix starts the board will magically be in extended mode 
Xand when it is rebooted the bios will take it back to standard mode again.
X
XEventually I will fix the bootblocks, but this works just as well.
X
Xjulian
X
X
END-of-scsi/README.AHA1742
echo x - i386/conf/AHBTEST
sed 's/^X//' >i386/conf/AHBTEST << 'END-of-i386/conf/AHBTEST'
X
X#
X# SCSITEST -- Generic ISA machine -- scsi test kernel
X#
Xmachine		"i386"
Xcpu		"i386"
Xident		SCSITEST
Xtimezone	8 dst
Xmaxusers	10
Xoptions		INET,ISOFS,NFS
Xoptions		"COMPAT_43"
Xoptions		"TCP_COMPAT_42"
X
Xconfig		"386bsd"	root on sd0 swap on sd0
X
Xcontroller	isa0
Xcontroller	wd0	at isa? port "IO_WD1" bio irq 14 vector wdintr
Xdisk		wd0	at wd0 drive 0
Xdisk		wd0	at wd0 drive 1
X
Xcontroller	fd0	at isa? port "IO_FD1" bio irq 6 drq 2 vector fdintr
Xdisk		fd0	at fd0 drive 0
Xdisk		fd1	at fd0 drive 1
X
Xdevice		pc0	at isa? port "IO_KBD" tty irq 1 vector pcrint
Xdevice		npx0	at isa? port "IO_NPX" irq 13 vector npxintr
Xdevice		com1	at isa? port "IO_COM1" tty irq 4 vector comintr
Xdevice		com2	at isa? port "IO_COM2" tty irq 3 vector comintr
X
X#controller	aha0	at isa? port "IO_AHA0" bio irq 11 drq 5 vector ahaintr
X#controller	aha1	at isa? port "IO_AHA1" bio irq 12 drq 7 vector ahaintr
X#controller	bt0	at isa? port "IO_BT0" bio irq 12  vector btintr
Xcontroller	ahb0	at isa? bio irq 12  vector ahbintr
Xcontroller	scbus0
X
Xdevice		sd0
Xdevice		sd1
Xdevice		sd2
Xdevice		sd3
X
Xdevice		st0
Xdevice		st1
Xdevice		st2
Xdevice		st3
X
Xdevice		cd0
Xdevice		cd1
X
Xdevice		we0 at isa? port 0x280 net irq 2 iomem 0xd0000 iosiz 8192 vector weintr
X
X
Xpseudo-device	loop
Xpseudo-device	ether
Xpseudo-device	sl	2
Xpseudo-device	log
Xpseudo-device	ddb
Xpseudo-device	pty	4
X
Xpseudo-device	swappager
Xpseudo-device	vnodepager
Xpseudo-device	devpager
END-of-i386/conf/AHBTEST
echo x - i386/isa/aha1742.c
sed 's/^X//' >i386/isa/aha1742.c << 'END-of-i386/isa/aha1742.c'
X/*
X * Written by Julian Elischer (julian@tfs.com)
X * for TRW Financial Systems for use under the MACH(2.5) operating system.
X *
X * TRW Financial Systems, in accordance with their agreement with Carnegie
X * Mellon University, makes this software available to CMU to distribute
X * or use in any manner that they see fit as long as this message is kept with
X * the software. For this reason TFS also grants any other persons or
X * organisations permission to use or modify this software.
X *
X * TFS supplies this software to be publicly redistributed
X * on the understanding that TFS is not responsible for the correct
X * functioning of this software in any circumstances.
X *
X * commenced: Sun Sep 27 18:14:01 PDT 1992
X */
X
X#include <sys/types.h>
X#include <ahb.h>
X
X#include <sys/param.h>
X#include <sys/systm.h>
X#include <sys/errno.h>
X#include <sys/ioctl.h>
X#include <sys/buf.h>
X#include <sys/proc.h>
X#include <sys/user.h>
X
X#ifdef  MACH    /* EITHER CMU OR OSF */
X#include <i386/ipl.h>
X#include <i386at/scsi.h>
X#include <i386at/scsiconf.h>
X
X#ifdef  OSF     /* OSF ONLY */
X#include <sys/table.h>
X#include <i386/handler.h>
X#include <i386/dispatcher.h>
X#include <i386/AT386/atbus.h>
X
X#else   OSF     /* CMU ONLY */
X#include <i386at/atbus.h>
X#include <i386/pio.h>
X#endif  OSF
X#endif  MACH    /* end of MACH specific */
X
X#ifdef  __386BSD__      /* 386BSD specific */
X#define isa_dev isa_device
X#define dev_unit id_unit
X#define dev_addr id_iobase
X
X#include <i386/include/pio.h>
X#include <i386/isa/isa_device.h>
X#include <scsi/scsi_all.h>
X#include <scsi/scsiconf.h>
X#endif  __386BSD__
X
X/**/
X
X#ifdef  __386BSD__
X#include "ddb.h"
X#if     NDDB > 0
Xint     Debugger();
X#else   NDDB
X#define Debugger() panic("should call debugger here (adaptec.c)")
X#endif  NDDB
X#endif  __386BSD__
X
X#ifdef  MACH
Xint     Debugger();
X#endif  MACH
X
Xtypedef unsigned long int physaddr;
X
X#ifdef        MACH
Xextern physaddr kvtophys();
X#define PHYSTOKV(x)   phystokv(x)
X#define KVTOPHYS(x)   kvtophys(x)
X#endif MACH
X
X#ifdef        __386BSD__
X#define PHYSTOKV(x)   (x | 0xFE000000)
X#define KVTOPHYS(x)   vtophys(x)
X#endif        __386BSD__
X
Xextern int delaycount;  /* from clock setup code */
X#define	NUM_CONCURRENT	16	/* number of concurrent ops per board */
X#define	AHB_NSEG	33	/* number of dma segments supported	*/
X#define FUDGE(X)	(X>>1)	/* our loops are slower than spinwait() */
X/**/
X/***********************************************************************\
X* AHA1740 standard EISA Host ID regs  (Offset from slot base)		*
X\***********************************************************************/
X#define HID0		0xC80 /* 0,1: msb of ID2, 3-7: ID1	*/
X#define HID1		0xC81 /* 0-4: ID3, 4-7: LSB ID2		*/
X#define HID2		0xC82 /* product, 0=174[20] 1 = 1744	*/
X#define HID3		0xC83 /* firmware revision		*/
X
X#define CHAR1(B1,B2) (((B1>>2) & 0x1F) | '@')
X#define CHAR2(B1,B2) (((B1<<3) & 0x18) | ((B2>>5) & 0x7)|'@')
X#define CHAR3(B1,B2) ((B2 & 0x1F) | '@')
X
X/* AHA1740 EISA board control registers (Offset from slot base) */
X#define	EBCTRL		0xC84
X#define  CDEN		0x01
X/***********************************************************************\
X* AHA1740 EISA board mode registers (Offset from slot base)		*
X\***********************************************************************/
X#define PORTADDR	0xCC0
X#define	 PORTADDR_ENHANCED	0x80
X#define BIOSADDR	0xCC1
X#define	INTDEF		0xCC2
X#define	SCSIDEF		0xCC3
X#define	BUSDEF		0xCC4
X#define	RESV0		0xCC5
X#define	RESV1		0xCC6
X#define	RESV2		0xCC7
X/**** bit definitions for INTDEF ****/
X#define	INT9	0x00
X#define	INT10	0x01
X#define	INT11	0x02
X#define	INT12	0x03
X#define	INT14	0x05
X#define	INT15	0x06
X#define INTHIGH 0x08    /* int high=ACTIVE (else edge) */
X#define	INTEN	0x10
X/**** bit definitions for SCSIDEF ****/
X#define	HSCSIID	0x0F	/* our SCSI ID */
X#define	RSTPWR	0x10	/* reset scsi bus on power up or reset */
X/**** bit definitions for BUSDEF ****/
X#define	B0uS	0x00	/* give up bus immediatly */
X#define	B4uS	0x01	/* delay 4uSec. */
X#define	B8uS	0x02
X/***********************************************************************\
X* AHA1740 ENHANCED mode mailbox control regs (Offset from slot base)	*
X\***********************************************************************/
X#define MBOXOUT0	0xCD0
X#define MBOXOUT1	0xCD1
X#define MBOXOUT2	0xCD2
X#define MBOXOUT3	0xCD3
X
X#define	ATTN		0xCD4
X#define	G2CNTRL		0xCD5
X#define	G2INTST		0xCD6
X#define G2STAT		0xCD7
X
X#define	MBOXIN0		0xCD8
X#define	MBOXIN1		0xCD9
X#define	MBOXIN2		0xCDA
X#define	MBOXIN3		0xCDB
X
X#define G2STAT2		0xCDC
X
X/*******************************************************\
X* Bit definitions for the 5 control/status registers	*
X\*******************************************************/
X#define	ATTN_TARGET		0x0F
X#define	ATTN_OPCODE		0xF0
X#define  OP_IMMED		0x10
X#define	  AHB_TARG_RESET	0x80
X#define  OP_START_ECB		0x40
X#define  OP_ABORT_ECB		0x50
X
X#define	G2CNTRL_SET_HOST_READY	0x20
X#define	G2CNTRL_CLEAR_EISA_INT	0x40
X#define	G2CNTRL_HARD_RESET	0x80
X
X#define	G2INTST_TARGET		0x0F
X#define	G2INTST_INT_STAT	0xF0
X#define	 AHB_ECB_OK		0x10
X#define	 AHB_ECB_RECOVERED	0x50
X#define	 AHB_HW_ERR		0x70
X#define	 AHB_IMMED_OK		0xA0
X#define	 AHB_ECB_ERR		0xC0
X#define	 AHB_ASN		0xD0	/* for target mode */
X#define	 AHB_IMMED_ERR		0xE0
X
X#define	G2STAT_BUSY		0x01
X#define	G2STAT_INT_PEND		0x02
X#define	G2STAT_MBOX_EMPTY	0x04
X
X#define	G2STAT2_HOST_READY	0x01
X/**/
X
Xstruct	ahb_dma_seg
X{
X	physaddr	addr;
X	long		len;
X};
X
Xstruct	ahb_ecb_status
X{
X	u_short	status;
X#	 define	ST_DON	0x0001
X#	 define	ST_DU	0x0002
X#	 define	ST_QF	0x0008
X#	 define	ST_SC	0x0010
X#	 define	ST_DO	0x0020
X#	 define	ST_CH	0x0040
X#	 define	ST_INT	0x0080
X#	 define	ST_ASA	0x0100
X#	 define	ST_SNS	0x0200
X#	 define	ST_INI	0x0800
X#	 define	ST_ME	0x1000
X#	 define	ST_ECA	0x4000
X	u_char	ha_status;
X#	 define	HS_OK			0x00
X#	 define	HS_CMD_ABORTED_HOST	0x04
X#	 define	HS_CMD_ABORTED_ADAPTER	0x05
X#	 define	HS_TIMED_OUT		0x11
X#	 define	HS_HARDWARE_ERR		0x20
X#	 define	HS_SCSI_RESET_ADAPTER	0x22
X#	 define	HS_SCSI_RESET_INCOMING	0x23
X	u_char	targ_status;
X#	 define	TS_OK			0x00
X#	 define	TS_CHECK_CONDITION	0x02
X#	 define	TS_BUSY			0x08
X	u_long	resid_count;
X	u_long	resid_addr;
X	u_short	addit_status;
X	u_char	sense_len;
X	u_char	unused[9];
X	u_char	cdb[6];
X};
X
X/**/
X
Xstruct	ecb
X{
X	u_char	opcode;
X#	 define	ECB_SCSI_OP	0x01
X	u_char	:4;
X	u_char	options:3;
X	u_char	:1;
X	short opt1;
X#	 define	ECB_CNE	0x0001
X#	 define	ECB_DI	0x0080
X#	 define	ECB_SES	0x0400
X#	 define	ECB_S_G	0x1000
X#	 define	ECB_DSB	0x4000
X#	 define	ECB_ARS	0x8000
X	short opt2;
X#	 define	ECB_LUN	0x0007
X#	 define	ECB_TAG	0x0008
X#	 define	ECB_TT	0x0030
X#	 define	ECB_ND	0x0040
X#	 define	ECB_DAT	0x0100
X#	 define	ECB_DIR	0x0200
X#	 define	ECB_ST	0x0400
X#	 define	ECB_CHK	0x0800
X#	 define	ECB_REC	0x4000
X#	 define	ECB_NRB	0x8000
X	u_short		unused1;
X	physaddr	data;
X	u_long		datalen;
X	physaddr	status;
X	physaddr	chain;
X	short		unused2;
X	short		unused3;
X	physaddr	sense;
X	u_char		senselen;
X	u_char		cdblen;
X	short		cksum;
X	u_char		cdb[12];
X	/*-----------------end of hardware supported fields----------------*/
X	struct	ecb	*next;	/* in free list */
X	struct	scsi_xfer *xs; /* the scsi_xfer for this cmd */
X	long	int	delta;  /* difference from previous*/
X	struct	ecb	*later,*sooner;
X	int		flags;
X#define ECB_FREE	0
X#define ECB_ACTIVE	1
X#define ECB_ABORTED	2
X#define ECB_IMMED	4
X#define ECB_IMMED_FAIL	8
X	struct	ahb_dma_seg	ahb_dma[AHB_NSEG];
X	struct	ahb_ecb_status	ecb_status;
X	struct	scsi_sense_data	ecb_sense;
X};
X
Xstruct	ecb	*ahb_soonest	= (struct ecb *)0;
Xstruct	ecb	*ahb_latest	= (struct ecb *)0;
Xlong	int	ahb_furtherest	= 0; /* longest time in the timeout queue */
X/**/
X
Xstruct	ahb_data
X{
X	int	flags;
X#define	AHB_INIT	0x01;
X	int	baseport;
X	struct	ecb ecbs[NUM_CONCURRENT];
X	struct	ecb *free_ecb;
X	int	our_id;			/* our scsi id */
X	int	vect;
X	struct	ecb *immed_ecb; 	/* an outstanding immediete command */
X} ahb_data[NAHB];
X
Xint	ahbprobe();
Xint	ahb_attach();
Xint	ahbintr();
Xint	ahb_scsi_cmd();
Xint	ahb_timeout();
Xstruct	ecb *cheat;
Xvoid	ahbminphys();
Xlong int ahb_adapter_info();
X
X#ifdef  MACH
Xstruct  isa_driver      ahbdriver = { ahbprobe, 0, ahb_attach, "ahb", 0, 0, 0};
Xint (*ahbintrs[])() = {ahbintr, 0};
X#endif  MACH
X
X#ifdef  __386BSD__
Xstruct  isa_driver      ahbdriver = { ahbprobe, ahb_attach, "ahb"};
X#endif  __386BSD__
X
X#define	MAX_SLOTS	8
Xstatic	ahb_slot = 0;	/* slot last board was found in */
Xstatic	ahb_unit = 0;
Xint	ahb_debug = 0;
X#define AHB_SHOWECBS 0x01
X#define AHB_SHOWINTS 0x02
X#define AHB_SHOWCMDS 0x04
X#define AHB_SHOWMISC 0x08
X#define FAIL	1
X#define SUCCESS 0
X#define PAGESIZ 4096
X
Xstruct	scsi_switch	ahb_switch = 
X{
X	ahb_scsi_cmd,
X	ahbminphys,
X	0,
X	0,
X	ahb_adapter_info,
X	0,0,0
X};
X
X/**/
X/***********************************************************************\
X* Function to send a command out through a mailbox			*
X\***********************************************************************/
Xahb_send_mbox(	int		unit
X		,int		opcode
X		,int		target
X		,struct ecb	*ecb)
X{
X	int	port = ahb_data[unit].baseport;
X	int	spincount = FUDGE(delaycount) * 1; /* 1ms should be enough */
X	int	s = splbio();
X	int	stport = port + G2STAT;
X
X	while(      ((inb(stport) & (G2STAT_BUSY | G2STAT_MBOX_EMPTY))
X					!= (G2STAT_MBOX_EMPTY))
X		&& (spincount--));
X	if(spincount == -1)
X	{
X		printf("ahb%d: board not responding\n",unit);
X		Debugger();
X	}
X
X	outl(port + MBOXOUT0,KVTOPHYS(ecb));	/* don't know this will work */
X	outb(port + ATTN, opcode|target);
X
X	splx(s);
X}
X
X/***********************************************************************\
X* Function to poll for command completion when in poll mode		*
X\***********************************************************************/
Xahb_poll(int unit ,int wait) /* in msec  */
X{
X	int	port = ahb_data[unit].baseport;
X	int	spincount = FUDGE(delaycount) * wait; /* in msec */
X	int	stport = port + G2STAT;
Xint	start = spincount;
X
Xretry:
X	while( (spincount--) && (!(inb(stport) &  G2STAT_INT_PEND)));
X	if(spincount == -1)
X	{
X		printf("ahb%d: board not responding\n",unit);
X		return(EIO);
X	}
Xif ((int)cheat != PHYSTOKV(inl(port + MBOXIN0)))
X{
X	printf("discarding %x ",inl(port + MBOXIN0));
X	outb(port + G2CNTRL, G2CNTRL_CLEAR_EISA_INT);
X	spinwait(50);
X	goto retry;
X}/* don't know this will work */
X	ahbintr(unit);
X	return(0);
X}
X/***********************************************************************\
X* Function to  send an immediate type command to the adapter		*
X\***********************************************************************/
Xahb_send_immed(	int		unit
X		,int		target
X		,u_long		cmd)
X{
X	int	port = ahb_data[unit].baseport;
X	int	spincount = FUDGE(delaycount) * 1; /* 1ms should be enough */
X	int	s = splbio();
X	int	stport = port + G2STAT;
X
X	while(      ((inb(stport) & (G2STAT_BUSY | G2STAT_MBOX_EMPTY))
X					!= (G2STAT_MBOX_EMPTY))
X		&& (spincount--));
X	if(spincount == -1)
X	{
X		printf("ahb%d: board not responding\n",unit);
X		Debugger();
X	}
X
X	outl(port + MBOXOUT0,cmd);	/* don't know this will work */
X	outb(port + G2CNTRL, G2CNTRL_SET_HOST_READY);
X	outb(port + ATTN, OP_IMMED | target);
X	splx(s);
X}
X
X/**/
X
X/*******************************************************\
X* Check  the slots looking for a board we recognise	*
X* If we find one, note it's address (slot) and call	*
X* the actual probe routine to check it out.		*
X\*******************************************************/
Xahbprobe(dev)
Xstruct isa_dev *dev;
X{
X	int	port;
X	u_char	byte1,byte2,byte3;
X	ahb_slot++;
X	while (ahb_slot<8)
X	{
X		port = 0x1000 * ahb_slot;
X		byte1 = inb(port + HID0);
X		byte2 = inb(port + HID1);
X		byte3 = inb(port + HID2);
X		if(byte1 == 0xff)
X		{
X			ahb_slot++;
X			continue;
X		}
X		if ((CHAR1(byte1,byte2) == 'A')
X		 && (CHAR2(byte1,byte2) == 'D')
X		 && (CHAR3(byte1,byte2) == 'P')
X		 && ((byte3 == 0 ) || (byte3 == 1)))
X		{
X			dev->dev_addr = port;
X			return(ahbprobe1(dev));
X		}
X		ahb_slot++;
X	}
X	return(0);
X}
X/*******************************************************\
X* Check if the device can be found at the port given    *
X* and if so, set it up ready for further work           *
X* as an argument, takes the isa_dev structure from      *
X* autoconf.c                                            *
X\*******************************************************/
Xahbprobe1(dev)
Xstruct isa_dev *dev;
X{
X	/***********************************************\
X	* find unit and check we have that many defined	*
X	\***********************************************/
X	int     unit = ahb_unit;
X#if defined(OSF)
X	static ihandler_t ahb_handler[NAHB];
X	static ihandler_id_t *ahb_handler_id[NAHB];
X	register ihandler_t *chp = &ahb_handler[unit];;
X#endif /* defined(OSF) */
X
X	dev->dev_unit = unit;
X	ahb_data[unit].baseport = dev->dev_addr;
X	if(unit >= NAHB) 
X	{
X		printf("ahb: unit number (%d) too high\n",unit);
X		return(0);
X	}
X	/***********************************************\
X	* Try initialise a unit at this location	*
X	* sets up dma and bus speed, loads ahb_data[unit].vect*
X	\***********************************************/
X	if (ahb_init(unit) != 0)
X	{
X		return(0);
X	}
X
X	/***********************************************\
X	* If it's there, put in it's interrupt vectors	*
X	\***********************************************/
X#ifdef	MACH
X#if defined(OSF)				/* OSF */
X	chp->ih_level = dev->dev_pic;
X	chp->ih_handler = dev->dev_intr[0];
X	chp->ih_resolver = i386_resolver;
X	chp->ih_rdev = dev;
X	chp->ih_stats.intr_type = INTR_DEVICE;
X	chp->ih_stats.intr_cnt = 0;
X	chp->ih_hparam[0].intparam = unit;
X	if ((ahb_handler_id[unit] = handler_add(chp)) != NULL)
X		handler_enable(ahb_handler_id[unit]);
X	else
X		panic("Unable to add ahb interrupt handler");
X#else 						/* CMU */
X	dev->dev_pic = ahb_data[unit].vect;
X	take_dev_irq(dev);
X#endif /* !defined(OSF) */
X	printf("port=%x spl=%d\n", dev->dev_addr, dev->dev_spl);
X#endif	MACH
X#ifdef  __386BSD__				/* 386BSD */
X        dev->id_irq = (1 << ahb_data[unit].vect);
X        dev->id_drq = -1; /* use EISA dma */
X	printf("\n  **");
X#endif  __386BSD__
X
X	ahb_unit++;
X	return(1);
X}
X
X/***********************************************\
X* Attach all the sub-devices we can find	*
X\***********************************************/
Xahb_attach(dev)
Xstruct	isa_dev	*dev;
X{
X	int	unit = dev->dev_unit;
X
X
X#ifdef  __386BSD__
X	printf(" probing for scsi devices**\n");
X#endif  __386BSD__
X
X	/***********************************************\
X	* ask the adapter what subunits are present	*
X	\***********************************************/
X	scsi_attachdevs( unit, ahb_data[unit].our_id, &ahb_switch);
X#if defined(OSF)
X	ahb_attached[unit]=1;
X#endif /* defined(OSF) */
X	if(!unit) /* only one for all boards */
X	{
X		ahb_timeout(0);
X	}
X#ifdef  __386BSD__
X	printf("ahb%d",unit);
X#endif  __386BSD__
X	return;
X}
X
X/***********************************************\
X* Return some information to the caller about   *
X* the adapter and it's capabilities             *
X\***********************************************/
Xlong int ahb_adapter_info(unit)
Xint	unit;
X{
X	return(2);      /* 2 outstanding requests at a time per device */
X}
X
X/***********************************************\
X* Catch an interrupt from the adaptor		*
X\***********************************************/
Xahbintr(unit)
X{
X	struct ecb	*ecb;
X	unsigned char	stat;
X	register	i;
X	u_char		ahbstat;
X	int		target;
X	long int 	mboxval;
X
X	int	port = ahb_data[unit].baseport;
X
X	if(scsi_debug & PRINTROUTINES)
X		printf("ahbintr ");
X
X#if defined(OSF)
X	if (!ahb_attached[unit])
X	{
X		return(1);
X	}
X#endif /* defined(OSF) */
X	while(inb(port + G2STAT) & G2STAT_INT_PEND)
X	{
X		/***********************************************\
X		* First get all the information and then 	*
X		* acknowlege the interrupt			*
X		\***********************************************/
X		ahbstat = inb(port + G2INTST);
X		target = ahbstat & G2INTST_TARGET;
X		stat = ahbstat & G2INTST_INT_STAT;
X		mboxval = inl(port + MBOXIN0);/* don't know this will work */
X		outb(port + G2CNTRL, G2CNTRL_CLEAR_EISA_INT);
X		if(scsi_debug & TRACEINTERRUPTS)
X			printf("status = 0x%x ",stat);
X		/***********************************************\
X		* Process the completed operation		*
X		\***********************************************/
X	
X		if(stat == AHB_ECB_OK) /* common case is fast */
X		{
X			ecb = (struct ecb *)PHYSTOKV(mboxval); 
X		}
X		else
X		{
X			switch(stat)
X			{
X			case	AHB_IMMED_OK:
X				ecb = ahb_data[unit].immed_ecb;
X				ahb_data[unit].immed_ecb = 0;
X				break;
X			case	AHB_IMMED_ERR:
X				ecb = ahb_data[unit].immed_ecb;
X				ecb->flags |= ECB_IMMED_FAIL;
X				ahb_data[unit].immed_ecb = 0;
X				break;
X			case	AHB_ASN:	/* for target mode */
X				ecb = 0;
X				break;
X			case	AHB_HW_ERR:
X				ecb = 0;
X				break;
X			case	AHB_ECB_RECOVERED:
X				ecb = (struct ecb *)PHYSTOKV(mboxval); 
X				break;
X			case	AHB_ECB_ERR:
X				ecb = (struct ecb *)PHYSTOKV(mboxval); 
X				break;
X			default:
X				printf(" Unknown return from ahb%d(%x)\n",unit,ahbstat);
X				ecb=0;
X			}
X		}
X		if(ecb)
X		{
X			if(ahb_debug & AHB_SHOWCMDS )
X			{
X				ahb_show_scsi_cmd(ecb->xs);
X			}
X			if((ahb_debug & AHB_SHOWECBS) && ecb)
X				printf("<int ecb(%x)>",ecb);
X			ahb_remove_timeout(ecb);
X			ahb_done(unit,ecb,((stat == AHB_ECB_OK)?SUCCESS:FAIL));
X		}
X	}
X	return(1);
X}
X
X/***********************************************\
X* We have a ecb which has been processed by the	*
X* adaptor, now we look to see how the operation	*
X* went.						*
X\***********************************************/
Xahb_done(unit,ecb,state)
Xint	unit,state;
Xstruct ecb *ecb;
X{
X	struct	ahb_ecb_status	*stat = &ecb->ecb_status;
X	struct	scsi_sense_data *s1,*s2;
X	struct	scsi_xfer *xs = ecb->xs;
X
X	if(scsi_debug & (PRINTROUTINES | TRACEINTERRUPTS))
X		printf("ahb_done ");
X	/***********************************************\
X	* Otherwise, put the results of the operation	*
X	* into the xfer and call whoever started it	*
X	\***********************************************/
X	if(ecb->flags & ECB_IMMED)
X	{
X		if(ecb->flags & ECB_IMMED_FAIL)
X		{
X			xs->error = XS_DRIVER_STUFFUP;
X		}
X		goto done;
X	}
X	if ( (state == SUCCESS) || (xs->flags & SCSI_ERR_OK))
X	{		/* All went correctly  OR errors expected */
X		xs->resid = 0;
X		xs->error = 0;
X	}
X	else
X	{
X
X		s1 = &(ecb->ecb_sense);
X		s2 = &(xs->sense);
X
X		if(stat->ha_status)
X		{
X			switch(stat->ha_status)
X			{
X			case	HS_SCSI_RESET_ADAPTER:
X				break;
X			case	HS_SCSI_RESET_INCOMING:
X				break;
X			case	HS_CMD_ABORTED_HOST:	/* No response */
X			case	HS_CMD_ABORTED_ADAPTER:	/* No response */
X				break;
X			case	HS_TIMED_OUT:		/* No response */
X				if (ahb_debug & AHB_SHOWMISC)
X				{
X					printf("timeout reported back\n");
X				}
X				xs->error = XS_TIMEOUT;
X				break;
X			default:	/* Other scsi protocol messes */
X				xs->error = XS_DRIVER_STUFFUP;
X				if (ahb_debug & AHB_SHOWMISC)
X				{
X					printf("unexpected ha_status: %x\n",
X						stat->ha_status);
X				}
X			}
X
X		}
X		else
X		{
X			switch(stat->targ_status)
X			{
X			case TS_CHECK_CONDITION:
X				/* structure copy!!!!!*/
X				*s2=*s1;
X				xs->error = XS_SENSE;
X				break;
X			case TS_BUSY:
X				xs->error = XS_BUSY;
X				break;
X			default:
X				if (ahb_debug & AHB_SHOWMISC)
X				{
X					printf("unexpected targ_status: %x\n",
X						stat->targ_status);
X				}
X				xs->error = XS_DRIVER_STUFFUP;
X			}
X		}
X	}
Xdone:	xs->flags |= ITSDONE;
X	ahb_free_ecb(unit,ecb, xs->flags);
X	if(xs->when_done)
X		(*(xs->when_done))(xs->done_arg,xs->done_arg2);
X}
X
X/***********************************************\
X* A ecb (and hence a mbx-out is put onto the 	*
X* free list.					*
X\***********************************************/
Xahb_free_ecb(unit,ecb, flags)
Xstruct ecb *ecb;
X{
X	unsigned int opri;
X	
X	if(scsi_debug & PRINTROUTINES)
X		printf("ecb%d(0x%x)> ",unit,flags);
X	if (!(flags & SCSI_NOMASK)) 
X	  	opri = splbio();
X
X	ecb->next = ahb_data[unit].free_ecb;
X	ahb_data[unit].free_ecb = ecb;
X	ecb->flags = ECB_FREE;
X	/***********************************************\
X	* If there were none, wake abybody waiting for	*
X	* one to come free, starting with queued entries*
X	\***********************************************/
X	if (!ecb->next) {
X		wakeup(&ahb_data[unit].free_ecb);
X	}
X	if (!(flags & SCSI_NOMASK)) 
X		splx(opri);
X}
X
X/***********************************************\
X* Get a free ecb (and hence mbox-out entry)	*
X\***********************************************/
Xstruct ecb *
Xahb_get_ecb(unit,flags)
X{
X	unsigned opri;
X	struct ecb *rc;
X
X	if(scsi_debug & PRINTROUTINES)
X		printf("<ecb%d(0x%x) ",unit,flags);
X	if (!(flags & SCSI_NOMASK)) 
X	  	opri = splbio();
X	/***********************************************\
X	* If we can and have to, sleep waiting for one	*
X	* to come free					*
X	\***********************************************/
X	while ((!(rc = ahb_data[unit].free_ecb)) && (!(flags & SCSI_NOSLEEP)))
X	{
X		sleep(&ahb_data[unit].free_ecb, PRIBIO);
X	}
X	if (rc) 
X	{
X		ahb_data[unit].free_ecb = rc->next;
X		rc->flags = ECB_ACTIVE;
X	}
X	if (!(flags & SCSI_NOMASK)) 
X		splx(opri);
X	return(rc);
X}
X		
X
X
X/***********************************************\
X* Start the board, ready for normal operation	*
X\***********************************************/
Xahb_init(unit)
Xint	unit;
X{
X	int	port = ahb_data[unit].baseport;
X	int	intdef;
X	int	spincount = FUDGE(delaycount) * 1000; /* 1 sec enough? */
X	int	i;
X	int	stport = port + G2STAT;
X#define	NO_NO 1
X#ifdef NO_NO
X	/***********************************************\
X	* reset board, If it doesn't respond, assume 	*
X	* that it's not there.. good for the probe	*
X	\***********************************************/
X	outb(port + EBCTRL,CDEN);	/* enable full card */
X	outb(port + PORTADDR,PORTADDR_ENHANCED);
X
X	outb(port + G2CNTRL,G2CNTRL_HARD_RESET);
X	spinwait(1);
X	outb(port + G2CNTRL,0);
X	spinwait(10);
X	while(      ((inb(stport) & G2STAT_BUSY ))
X		&& (spincount--));
X	if(spincount == -1)
X	{
X		if (ahb_debug & AHB_SHOWMISC)
X			printf("ahb_init: No answer from bt742a board\n");
X		return(ENXIO);
X	}
X	i = inb(port + MBOXIN0) & 0xff;
X	if(i)
X	{
X		printf("self test failed, val = 0x%x\n",i);
X		return(EIO);
X	}
X#endif
X	while( inb(stport) &  G2STAT_INT_PEND)
X	{
X		printf(".");
X		outb(port + G2CNTRL, G2CNTRL_CLEAR_EISA_INT);
X		spinwait(10);
X	}
X	outb(port + EBCTRL,CDEN);	/* enable full card */
X	outb(port + PORTADDR,PORTADDR_ENHANCED);
X	/***********************************************\
X	* Assume we have a board at this stage		*
X	* setup dma channel from jumpers and save int	*
X	* level						*
X	\***********************************************/
X#ifdef	__386BSD__
X	printf("ahb%d reading board settings, ",unit);
X#define	PRNT(x)
X#else	__386BSD__
X	printf("ahb%d:",unit);
X#define	PRNT(x) printf(x)
X#endif	__386BSD__
X
X	intdef = inb(port + INTDEF);
X	switch(intdef & 0x07)
X	{
X	case	INT9:
X		ahb_data[unit].vect = 9;
X		PRNT("int=9 ");
X		break;
X	case	INT10:
X		ahb_data[unit].vect = 10;
X		PRNT("int=10 ");
X		break;
X	case	INT11:
X		ahb_data[unit].vect = 11;
X		PRNT("int=11 ");
X		break;
X	case	INT12:
X		ahb_data[unit].vect = 12;
X		PRNT("int=12 ");
X		break;
X	case	INT14:
X		ahb_data[unit].vect = 14;
X		PRNT("int=14 ");
X		break;
X	case	INT15:
X		ahb_data[unit].vect = 15;
X		PRNT("int=15 ");
X		break;
X	default:
X		printf("illegal int setting\n");
X		return(EIO);
X	}
X	outb(port + INTDEF ,(intdef | INTEN)); /* make sure we can interrupt */
X	/* who are we on the scsi bus */
X	ahb_data[unit].our_id = (inb(port + SCSIDEF) & HSCSIID);
X
X	/***********************************************\
X	* link up all our ECBs into a free list		*
X	\***********************************************/
X	for (i=0; i < NUM_CONCURRENT; i++)
X	{
X		ahb_data[unit].ecbs[i].next = ahb_data[unit].free_ecb;
X		ahb_data[unit].free_ecb = &ahb_data[unit].ecbs[i];
X		ahb_data[unit].free_ecb->flags = ECB_FREE;
X	}
X
X	/***********************************************\
X	* Note that we are going and return (to probe)	*
X	\***********************************************/
X	ahb_data[unit].flags |= AHB_INIT;
X	return( 0 );
X}
X
X
X#ifndef	min
X#define min(x,y) (x < y ? x : y)
X#endif	min
X
X
Xvoid ahbminphys(bp)
Xstruct	buf *bp;
X{
X#ifdef	MACH
X#if	!defined(OSF)
X	bp->b_flags |= B_NPAGES;		/* can support scat/gather */
X#endif	/* defined(OSF) */
X#endif	MACH
X	if(bp->b_bcount > ((AHB_NSEG-1) * PAGESIZ))
X	{
X		bp->b_bcount = ((AHB_NSEG-1) * PAGESIZ);
X	}
X}
X	
X/***********************************************\
X* start a scsi operation given the command and	*
X* the data address. Also needs the unit, target	*
X* and lu					*
X\***********************************************/
Xint	ahb_scsi_cmd(xs)
Xstruct scsi_xfer *xs;
X{
X	struct	scsi_sense_data *s1,*s2;
X	struct ecb *ecb;
X	struct ahb_dma_seg *sg;
X	int	seg;	/* scatter gather seg being worked on */
X	int i	= 0;
X	int rc	=  0;
X	int	thiskv;
X	physaddr	thisphys,nextphys;
X	int	unit =xs->adapter;
X	int	bytes_this_seg,bytes_this_page,datalen,flags;
X	struct	iovec	*iovp;
X	int	s;
X	if(scsi_debug & PRINTROUTINES)
X		printf("ahb_scsi_cmd ");
X	/***********************************************\
X	* get a ecb (mbox-out) to use. If the transfer	*
X	* is from a buf (possibly from interrupt time)	*
X	* then we can't allow it to sleep		*
X	\***********************************************/
X	flags = xs->flags;
X	if(xs->bp) flags |= (SCSI_NOSLEEP); /* just to be sure */
X	if(flags & ITSDONE)
X	{
X		printf("Already done?");
X		xs->flags &= ~ITSDONE;
X	}
X	if(!(flags & INUSE))
X	{
X		printf("Not in use?");
X		xs->flags |= INUSE;
X	}
X	if (!(ecb = ahb_get_ecb(unit,flags)))
X	{
X		xs->error = XS_DRIVER_STUFFUP;
X		return(TRY_AGAIN_LATER);
X	}
X
Xcheat = ecb;
X	if(ahb_debug & AHB_SHOWECBS)
X				printf("<start ecb(%x)>",ecb);
X	if(scsi_debug & SHOWCOMMANDS)
X	{
X		ahb_show_scsi_cmd(xs);
X	}
X	ecb->xs = xs;
X	/***********************************************\
X	* If it's a reset, we need to do an 'immediate'	*
X	* command, and store it's ccb for later		*
X	* if there is already an immediate waiting, 	*
X	* then WE must wait				*
X	\***********************************************/
X	if(flags & SCSI_RESET)
X	{
X		ecb->flags |= ECB_IMMED;
X		if(ahb_data[unit].immed_ecb)
X		{
X			return(TRY_AGAIN_LATER);
X		}
X		ahb_data[unit].immed_ecb = ecb;
X		if (!(flags & SCSI_NOMASK))
X		{
X			s = splbio();
X			ahb_send_immed(unit,xs->targ,AHB_TARG_RESET);
X			ahb_add_timeout(ecb,xs->timeout);
X			splx(s);
X			return(SUCCESSFULLY_QUEUED);
X		}
X		else
X		{
X			ahb_send_immed(unit,xs->targ,AHB_TARG_RESET);
X			/***********************************************\
X			* If we can't use interrupts, poll on completion*
X			\***********************************************/
X			if(scsi_debug & TRACEINTERRUPTS)
X				printf("wait ");
X			if( ahb_poll(unit,xs->timeout))
X			{
X				ahb_free_ecb(unit,ecb,flags);
X				xs->error = XS_TIMEOUT;
X				return(HAD_ERROR);
X			}
X			return(COMPLETE);
X		}
X	}	
X	/***********************************************\
X	* Put all the arguments for the xfer in the ecb	*
X	\***********************************************/
X	ecb->opcode = ECB_SCSI_OP;
X	ecb->opt1 = ECB_SES|ECB_DSB|ECB_ARS;
X	if(xs->datalen)
X	{
X		ecb->opt1 |= ECB_S_G;
X	}
X	ecb->opt2 		=	xs->lu | ECB_NRB;
X	ecb->cdblen		=	xs->cmdlen;
X	ecb->sense		=	KVTOPHYS(&(ecb->ecb_sense));
X	ecb->senselen		=	sizeof(ecb->ecb_sense);
X	ecb->status		=	KVTOPHYS(&(ecb->ecb_status));
X
X	if(xs->datalen)
X	{ /* should use S/G only if not zero length */
X		ecb->data 	=	KVTOPHYS(ecb->ahb_dma);
X		sg		=	ecb->ahb_dma ;
X		seg 		=	0;
X		if(flags & SCSI_DATA_UIO)
X		{
X			iovp = ((struct uio *)xs->data)->uio_iov;
X			datalen = ((struct uio *)xs->data)->uio_iovcnt;
X			xs->datalen = 0;
X			while ((datalen) && (seg < AHB_NSEG))
X			{
X				sg->addr = (physaddr)iovp->iov_base;
X				xs->datalen += sg->len = iovp->iov_len;	
X				if(scsi_debug & SHOWSCATGATH)
X					printf("(0x%x@0x%x)"
X							,iovp->iov_len
X							,iovp->iov_base);
X				sg++;
X				iovp++;
X				seg++;
X				datalen--;
X			}
X		}
X		else
X		{
X			/***********************************************\
X			* Set up the scatter gather block		*
X			\***********************************************/
X		
X			if(scsi_debug & SHOWSCATGATH)
X				printf("%d @0x%x:- ",xs->datalen,xs->data);
X			datalen		=	xs->datalen;
X			thiskv		=	(int)xs->data;
X			thisphys	=	KVTOPHYS(thiskv);
X		
X			while ((datalen) && (seg < AHB_NSEG))
X			{
X				bytes_this_seg	= 0;
X	
X				/* put in the base address */
X				sg->addr = thisphys;
X		
X				if(scsi_debug & SHOWSCATGATH)
X					printf("0x%x",thisphys);
X	
X				/* do it at least once */
X				nextphys = thisphys;	
X				while ((datalen) && (thisphys == nextphys))
X				/*********************************************\
X				* This page is contiguous (physically) with   *
X				* the the last, just extend the length	      *
X				\*********************************************/
X				{
X					/* how far to the end of the page */
X					nextphys= (thisphys & (~(PAGESIZ - 1)))
X								+ PAGESIZ;
X					bytes_this_page	= nextphys - thisphys;
X					/**** or the data ****/
X					bytes_this_page	= min(bytes_this_page
X								,datalen);
X					bytes_this_seg	+= bytes_this_page;
X					datalen		-= bytes_this_page;
X		
X					/* get more ready for the next page */
X					thiskv	= (thiskv & (~(PAGESIZ - 1)))
X								+ PAGESIZ;
X					if(datalen)
X						thisphys = KVTOPHYS(thiskv);
X				}
X				/********************************************\
X				* next page isn't contiguous, finish the seg *
X				\********************************************/
X				if(scsi_debug & SHOWSCATGATH)
X					printf("(0x%x)",bytes_this_seg);
X				sg->len = bytes_this_seg;	
X				sg++;
X				seg++;
X			}
X		} /*end of iov/kv decision */
X		ecb->datalen = seg * sizeof(struct ahb_dma_seg);
X		if(scsi_debug & SHOWSCATGATH)
X			printf("\n");
X		if (datalen)
X		{ /* there's still data, must have run out of segs! */
X			printf("ahb_scsi_cmd%d: more than %d DMA segs\n",
X				unit,AHB_NSEG);
X			xs->error = XS_DRIVER_STUFFUP;
X			ahb_free_ecb(unit,ecb,flags);
X			return(HAD_ERROR);
X		}
X
X	}
X	else
X	{	/* No data xfer, use non S/G values */
X		ecb->data = (physaddr)0;
X		ecb->datalen = 0;
X	}
X	ecb->chain = (physaddr)0;
X	/***********************************************\
X	* Put the scsi command in the ecb and start it	*
X	\***********************************************/
X	bcopy(xs->cmd, ecb->cdb, xs->cmdlen);
X	/***********************************************\
X	* Usually return SUCCESSFULLY QUEUED		*
X	\***********************************************/
X	if (!(flags & SCSI_NOMASK))
X	{
X		s = splbio();
X		ahb_send_mbox(unit,OP_START_ECB,xs->targ,ecb);
X		ahb_add_timeout(ecb,xs->timeout);
X		splx(s);
X		if(scsi_debug & TRACEINTERRUPTS)
X			printf("cmd_sent ");
X		return(SUCCESSFULLY_QUEUED);
X	}
X	/***********************************************\
X	* If we can't use interrupts, poll on completion*
X	\***********************************************/
X	ahb_send_mbox(unit,OP_START_ECB,xs->targ,ecb);
X	if(scsi_debug & TRACEINTERRUPTS)
X		printf("cmd_wait ");
X	do
X	{
X		if(ahb_poll(unit,xs->timeout))
X		{
X			if (!(xs->flags & SCSI_SILENT)) printf("cmd fail\n");
X			ahb_send_mbox(unit,OP_ABORT_ECB,xs->targ,ecb);
X			if(ahb_poll(unit,2000))
X			{
X				printf("abort failed in wait\n");
X				ahb_free_ecb(unit,ecb,flags);
X			}
X			xs->error = XS_DRIVER_STUFFUP;
X			splx(s);
X			return(HAD_ERROR);
X		}
X	} while (!(xs->flags & ITSDONE));/* something (?) else finished */
X	splx(s);
Xscsi_debug = 0;ahb_debug = 0;
X	if(xs->error)
X	{
X		return(HAD_ERROR);
X	}
X	return(COMPLETE);
X}
X
X/*
X *                +----------+    +----------+    +----------+
X * ahb_soonest--->|    later |--->|     later|--->|     later|--->0
X *                | [Delta]  |    | [Delta]  |    | [Delta]  |
X *           0<---|sooner    |<---|sooner    |<---|sooner    |<---ahb_latest
X *                +----------+    +----------+    +----------+
X *
X *     ahb_furtherest = sum(Delta[1..n])
X */
Xahb_add_timeout(ecb,time)
Xstruct	ecb	*ecb;
Xint	time;
X{
X	int	timeprev;
X	struct ecb *prev;
X	int	s = splbio();
X
X	if(prev = ahb_latest) /* yes, an assign */
X	{
X		timeprev = ahb_furtherest;
X	}
X	else
X	{
X		timeprev = 0;
X	}
X	while(prev && (timeprev > time)) 
X	{
X		timeprev -= prev->delta;
X		prev = prev->sooner;
X	}
X	if(prev)
X	{
X		ecb->delta = time - timeprev;
X		if( ecb->later = prev->later) /* yes an assign */
X		{
X			ecb->later->sooner = ecb;
X			ecb->later->delta -= ecb->delta;
X		}
X		else
X		{
X			ahb_furtherest = time;
X			ahb_latest = ecb;
X		}
X		ecb->sooner = prev;
X		prev->later = ecb;
X	}
X	else
X	{
X		if( ecb->later = ahb_soonest) /* yes, an assign*/
X		{
X			ecb->later->sooner = ecb;
X			ecb->later->delta -= time;
X		}
X		else
X		{
X			ahb_furtherest = time;
X			ahb_latest = ecb;
X		}
X		ecb->delta = time;
X		ecb->sooner = (struct ecb *)0;
X		ahb_soonest = ecb;
X	}
X	splx(s);
X}
X
Xahb_remove_timeout(ecb)
Xstruct	ecb	*ecb;
X{
X	int	s = splbio();
X
X	if(ecb->sooner)
X	{
X		ecb->sooner->later = ecb->later;
X	}
X	else
X	{
X		ahb_soonest = ecb->later;
X	}
X	if(ecb->later)
X	{
X		ecb->later->sooner = ecb->sooner;
X		ecb->later->delta += ecb->delta;
X	}
X	else
X	{
X		ahb_latest = ecb->sooner;
X		ahb_furtherest -= ecb->delta;
X	}
X	ecb->sooner = ecb->later = (struct ecb *)0;
X	splx(s);
X}
X
X
Xextern int 	hz;
X#define ONETICK 500 /* milliseconds */
X#define SLEEPTIME ((hz * 1000) / ONETICK)
Xahb_timeout(arg)
Xint	arg;
X{
X	struct  ecb  *ecb;
X	int	unit;
X	int	s	= splbio();
X
X	while( ecb = ahb_soonest )
X	{
X		if(ecb->delta <= ONETICK)
X		/***********************************************\
X		* It has timed out, we need to do some work	*
X		\***********************************************/
X		{
X			unit = ecb->xs->adapter;
X			printf("ahb%d:%d device timed out\n",unit
X					,ecb->xs->targ);
X			if(ahb_debug & AHB_SHOWECBS)
X				ahb_print_active_ecb();
X
X			/***************************************\
X			* Unlink it from the queue		*
X			\***************************************/
X			ahb_remove_timeout(ecb);
X
X			/***************************************\
X			* If it's immediate, don't try abort it *
X			\***************************************/
X			if(ecb->flags & ECB_IMMED)
X			{
X				ecb->xs->retries = 0; /* I MEAN IT ! */
X				ecb->flags |= ECB_IMMED_FAIL;
X                                ahb_done(unit,ecb,FAIL);
X				continue;
X			}
X			/***************************************\
X			* If it has been through before, then	*
X			* a previous abort has failed, don't	*
X			* try abort again			*
X			\***************************************/
X			if(ecb->flags == ECB_ABORTED) /* abort timed out */
X			{
X				printf("AGAIN");
X				ecb->xs->retries = 0; /* I MEAN IT ! */
X				ecb->ecb_status.ha_status = HS_CMD_ABORTED_HOST;
X				ahb_done(unit,ecb,FAIL);
X			}
X			else	/* abort the operation that has timed out */
X			{
X				printf("\n");
X				ahb_send_mbox(unit,OP_ABORT_ECB,ecb->xs->targ,ecb);
X					/* 2 secs for the abort */
X				ahb_add_timeout(ecb,2000 + ONETICK);
X				ecb->flags = ECB_ABORTED;
X			}
X		}
X		else
X		/***********************************************\
X		* It has not timed out, adjust and leave	*
X		\***********************************************/
X		{
X			ecb->delta -= ONETICK;
X			ahb_furtherest -= ONETICK;
X			break;
X		}
X	}
X	splx(s);
X	timeout(ahb_timeout,arg,SLEEPTIME);
X}
X
Xahb_show_scsi_cmd(struct scsi_xfer *xs)
X{
X	u_char	*b = (u_char *)xs->cmd;
X	int i = 0;
X	if(!(xs->flags & SCSI_RESET))
X	{
X		printf("ahb%d:%d:%d-"
X			,xs->adapter
X			,xs->targ
X			,xs->lu);
X		while(i < xs->cmdlen )
X		{
X			if(i) printf(",");
X			printf("%x",b[i++]);
X		}
X		printf("-\n");
X	}
X	else
X	{
X		printf("ahb%d:%d:%d-RESET-\n" 
X			,xs->adapter 
X			,xs->targ
X			,xs->lu
X		);
X	}
X}
Xahb_print_ecb(ecb)
Xstruct	ecb *ecb;
X{
X	printf("ecb:%x op:%x cmdlen:%d senlen:%d\n"
X		,ecb
X		,ecb->opcode
X		,ecb->cdblen
X		,ecb->senselen);
X	printf("	datlen:%d hstat:%x tstat:%x delta:%d flags:%x\n"
X		,ecb->datalen
X		,ecb->ecb_status.ha_status
X		,ecb->ecb_status.targ_status
X		,ecb->delta
X		,ecb->flags);
X	ahb_show_scsi_cmd(ecb->xs);
X}
X
Xahb_print_active_ecb()
X{
X	struct	ecb *ecb;
X	ecb = ahb_soonest;
X
X	while(ecb)
X	{
X		ahb_print_ecb(ecb);
X		ecb = ecb->later;
X	}
X	printf("Furtherest = %d\n",ahb_furtherest);
X}
END-of-i386/isa/aha1742.c
exit

Newsgroups: comp.unix.bsd