Return to BSD News archive
Newsgroups: comp.unix.bsd
Path: sserve!manuel!munnari.oz.au!network.ucsd.edu!sdd.hp.com!uakari.primate.wisc.edu!ames!agate!tfs.com!tfs.com!julian
From: julian@tfs.com (Julian Elischer)
Subject: New scsi system beta3 (part 10 of 10)
Message-ID: <1992Oct3.040253.14147@tfs.com>
Organization: TRW Financial Systems
Date: Sat, 3 Oct 1992 04:02:53 GMT
Lines: 1607
# 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:
#
# i386/conf/BTTEST
# i386/isa/bt742a.c
#
echo x - i386/conf/BTTEST
sed 's/^X//' >i386/conf/BTTEST << 'END-of-i386/conf/BTTEST'
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
Xcontroller bt0 at isa? port "IO_BT0" bio irq 12 vector btintr
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/BTTEST
echo x - i386/isa/bt742a.c
sed 's/^X//' >i386/isa/bt742a.c << 'END-of-i386/isa/bt742a.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 */
X
X/*
X * HISTORY
X * $Log: bt742a.c,v $
X * Revision 1.7 1992/08/24 22:40:16 jason
X * BIG_DMA ifdef for 512 dma segments instead of 128 segments
X *
X * Revision 1.6 1992/08/24 21:01:58 jason
X * many changes and bugfixes for osf1
X *
X * Revision 1.5 1992/07/31 01:22:03 julian
X * support improved scsi.h layout
X *
X * Revision 1.4 1992/07/25 03:11:26 julian
X * check each request fro sane flags.
X *
X * Revision 1.3 1992/07/24 00:52:45 julian
X * improved timeout handling.
X * added support for two arguments to the sd_done (or equiv) call so that
X * they can pre-queue several arguments.
X * slightly clean up error handling
X *
X * Revision 1.2 1992/07/17 22:03:54 julian
X * upgraded the timeout code.
X * added support for UIO-based i/o (as used for pmem operations)
X *
X * Revision 1.1 1992/05/27 00:51:12 balsup
X * machkern/cor merge
X *
X */
X
X/*
X * bt742a BT-1542A SCSI driver
X */
X
X#include <sys/types.h>
X#include <bt.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/isa/isa_device.h>
X#include <scsi/scsi_all.h>
X#include <scsi/scsiconf.h>
X#endif __386BSD__
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
Xextern int delaycount; /* from clock setup code */
Xtypedef unsigned long int physaddr;
X
X/*
X * I/O Port Interface
X */
X
X#define BT_BASE bt_base[unit]
X#define BT_CTRL_STAT_PORT (BT_BASE + 0x0) /* control & status */
X#define BT_CMD_DATA_PORT (BT_BASE + 0x1) /* cmds and datas */
X#define BT_INTR_PORT (BT_BASE + 0x2) /* Intr. stat */
X
X/*
X * BT_CTRL_STAT bits (write)
X */
X
X#define BT_HRST 0x80 /* Hardware reset */
X#define BT_SRST 0x40 /* Software reset */
X#define BT_IRST 0x20 /* Interrupt reset */
X#define BT_SCRST 0x10 /* SCSI bus reset */
X
X/*
X * BT_CTRL_STAT bits (read)
X */
X
X#define BT_STST 0x80 /* Self test in Progress */
X#define BT_DIAGF 0x40 /* Diagnostic Failure */
X#define BT_INIT 0x20 /* Mbx Init required */
X#define BT_IDLE 0x10 /* Host Adapter Idle */
X#define BT_CDF 0x08 /* cmd/data out port full */
X#define BT_DF 0x04 /* Data in port full */
X#define BT_INVDCMD 0x01 /* Invalid command */
X
X/*
X * BT_CMD_DATA bits (write)
X */
X
X#define BT_NOP 0x00 /* No operation */
X#define BT_MBX_INIT 0x01 /* Mbx initialization */
X#define BT_START_SCSI 0x02 /* start scsi command */
X#define BT_START_BIOS 0x03 /* start bios command */
X#define BT_INQUIRE 0x04 /* Adapter Inquiry */
X#define BT_MBO_INTR_EN 0x05 /* Enable MBO available interrupt */
X#define BT_SEL_TIMEOUT_SET 0x06 /* set selection time-out */
X#define BT_BUS_ON_TIME_SET 0x07 /* set bus-on time */
X#define BT_BUS_OFF_TIME_SET 0x08 /* set bus-off time */
X#define BT_SPEED_SET 0x09 /* set transfer speed */
X#define BT_DEV_GET 0x0a /* return installed devices */
X#define BT_CONF_GET 0x0b /* return configuration data */
X#define BT_TARGET_EN 0x0c /* enable target mode */
X#define BT_SETUP_GET 0x0d /* return setup data */
X#define BT_WRITE_CH2 0x1a /* write channel 2 buffer */
X#define BT_READ_CH2 0x1b /* read channel 2 buffer */
X#define BT_WRITE_FIFO 0x1c /* write fifo buffer */
X#define BT_READ_FIFO 0x1d /* read fifo buffer */
X#define BT_ECHO 0x1e /* Echo command data */
X#define BT_MBX_INIT_EXTENDED 0x81 /* Mbx initialization */
X#define BT_INQUIRE_EXTENDED 0x8D /* Adapter Setup Inquiry */
X
Xstruct bt_cmd_buf {
X u_char byte[16];
X};
X
X/*
X * BT_INTR_PORT bits (read)
X */
X
X#define BT_ANY_INTR 0x80 /* Any interrupt */
X#define BT_SCRD 0x08 /* SCSI reset detected */
X#define BT_HACC 0x04 /* Command complete */
X#define BT_MBOA 0x02 /* MBX out empty */
X#define BT_MBIF 0x01 /* MBX in full */
X
X/*
X * Mail box defs
X */
X
X#define BT_MBX_SIZE 16 /* mail box size */
X
Xstruct bt_mbx
X{
X struct bt_mbx_out {
X physaddr ccb_addr;
X unsigned char dummy[3];
X unsigned char cmd;
X } mbo [BT_MBX_SIZE];
X struct bt_mbx_in{
X physaddr ccb_addr;
X unsigned char btstat;
X unsigned char sdstat;
X unsigned char dummy;
X unsigned char stat;
X } mbi[BT_MBX_SIZE];
X};
X
X/*
X * mbo.cmd values
X */
X
X#define BT_MBO_FREE 0x0 /* MBO entry is free */
X#define BT_MBO_START 0x1 /* MBO activate entry */
X#define BT_MBO_ABORT 0x2 /* MBO abort entry */
X
X#define BT_MBI_FREE 0x0 /* MBI entry is free */
X#define BT_MBI_OK 0x1 /* completed without error */
X#define BT_MBI_ABORT 0x2 /* aborted ccb */
X#define BT_MBI_UNKNOWN 0x3 /* Tried to abort invalid CCB */
X#define BT_MBI_ERROR 0x4 /* Completed with error */
X
Xextern struct bt_mbx bt_mbx[];
X
X#if defined(BIG_DMA)
X/* #define BT_NSEG 8192 /* Number of scatter gather segments - to much vm */
X#define BT_NSEG 512
X#else
X#define BT_NSEG 33
X#endif /* BIG_DMA */
Xstruct bt_scat_gath
X {
X unsigned long seg_len;
X physaddr seg_addr;
X };
X
Xstruct bt_ccb {
X unsigned char opcode;
X unsigned char :3,data_in:1,data_out:1,:3;
X unsigned char scsi_cmd_length;
X unsigned char req_sense_length;
X /*------------------------------------longword boundary */
X unsigned long data_length;
X /*------------------------------------longword boundary */
X physaddr data_addr;
X /*------------------------------------longword boundary */
X unsigned char dummy[2];
X unsigned char host_stat;
X unsigned char target_stat;
X /*------------------------------------longword boundary */
X unsigned char target;
X unsigned char lun;
X unsigned char scsi_cmd[12]; /* 12 bytes (bytes only)*/
X unsigned char dummy2[1];
X unsigned char link_id;
X /*------------------------------------4 longword boundary */
X physaddr link_addr;
X /*------------------------------------longword boundary */
X physaddr sense_ptr;
X /*------------------------------------longword boundary */
X struct scsi_sense_data scsi_sense;
X /*------------------------------------longword boundary */
X struct bt_scat_gath scat_gath[BT_NSEG];
X /*------------------------------------longword boundary */
X struct bt_ccb *next;
X /*------------------------------------longword boundary */
X struct scsi_xfer *xfer; /* the scsi_xfer for this cmd */
X /*------------------------------------longword boundary */
X struct bt_mbx_out *mbx; /* pointer to mail box */
X /*------------------------------------longword boundary */
X long int delta; /* difference from previous*/
X struct bt_ccb *later,*sooner;
X int flags;
X#define CCB_FREE 0
X#define CCB_ACTIVE 1
X#define CCB_ABORTED 2
X};
X
Xstruct bt_ccb *bt_soonest = (struct bt_ccb *)0;
Xstruct bt_ccb *bt_latest = (struct bt_ccb *)0;
Xlong int bt_furtherest = 0; /* longest time in the timeout queue */
X/*
X * opcode fields
X */
X
X#define BT_INITIATOR_CCB 0x00 /* SCSI Initiator CCB */
X#define BT_TARGET_CCB 0x01 /* SCSI Target CCB */
X#define BT_INIT_SCAT_GATH_CCB 0x02 /* SCSI Initiator with scattter gather*/
X#define BT_RESET_CCB 0x81 /* SCSI Bus reset */
X
X
X/*
X * bt_ccb.host_stat values
X */
X
X#define BT_OK 0x00 /* cmd ok */
X#define BT_LINK_OK 0x0a /* Link cmd ok */
X#define BT_LINK_IT 0x0b /* Link cmd ok + int */
X#define BT_SEL_TIMEOUT 0x11 /* Selection time out */
X#define BT_OVER_UNDER 0x12 /* Data over/under run */
X#define BT_BUS_FREE 0x13 /* Bus dropped at unexpected time */
X#define BT_INV_BUS 0x14 /* Invalid bus phase/sequence */
X#define BT_BAD_MBO 0x15 /* Incorrect MBO cmd */
X#define BT_BAD_CCB 0x16 /* Incorrect ccb opcode */
X#define BT_BAD_LINK 0x17 /* Not same values of LUN for links */
X#define BT_INV_TARGET 0x18 /* Invalid target direction */
X#define BT_CCB_DUP 0x19 /* Duplicate CCB received */
X#define BT_INV_CCB 0x1a /* Invalid CCB or segment list */
X#define BT_ABORTED 42 /* pseudo value from driver */
X
X
X
Xstruct bt_setup
X{
X u_char sync_neg:1;
X u_char parity:1;
X u_char :6;
X u_char speed;
X u_char bus_on;
X u_char bus_off;
X u_char num_mbx;
X u_char mbx[4];
X struct
X {
X u_char offset:4;
X u_char period:3;
X u_char valid:1;
X }sync[8];
X u_char disc_sts;
X};
X
Xstruct bt_config
X{
X u_char chan;
X u_char intr;
X u_char scsi_dev:3;
X u_char :5;
X};
X
X#define INT9 0x01
X#define INT10 0x02
X#define INT11 0x04
X#define INT12 0x08
X#define INT14 0x20
X#define INT15 0x40
X
X#define EISADMA 0x00
X#define CHAN0 0x01
X#define CHAN5 0x20
X#define CHAN6 0x40
X#define CHAN7 0x80
X
X
X
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
X
X
X#define PAGESIZ 4096
X#define INVALIDATE_CACHE {asm volatile( ".byte 0x0F ;.byte 0x08" ); }
X
X
Xu_char bt_scratch_buf[256];
X#ifdef MACH
Xcaddr_t bt_base[NBT]; /* base port for each board */
X#else MACH
Xshort bt_base[NBT]; /* base port for each board */
X#endif MACH
Xstruct bt_mbx bt_mbx[NBT];
Xstruct bt_ccb *bt_ccb_free[NBT];
Xstruct bt_ccb bt_ccb[NBT][BT_MBX_SIZE];
Xstruct scsi_xfer bt_scsi_xfer[NBT];
Xstruct isa_dev *btinfo[NBT];
Xstruct bt_ccb *bt_get_ccb();
Xint bt_int[NBT];
Xint bt_dma[NBT];
Xint bt_scsi_dev[NBT];
Xint bt_initialized[NBT];
X#if defined(OSF)
Xint bt_attached[NBT];
X#endif /* defined(OSF) */
X
X/***********debug values *************/
X#define BT_SHOWCCBS 0x01
X#define BT_SHOWINTS 0x02
X#define BT_SHOWCMDS 0x04
X#define BT_SHOWMISC 0x08
Xint bt_debug = 0;
X
X
Xint btprobe(), btattach();
Xint btintr();
X
X#ifdef MACH
Xstruct isa_driver btdriver = { btprobe, 0, btattach, "bt", 0, 0, 0};
Xint (*btintrs[])() = {btintr, 0};
X#endif MACH
X
X#ifdef __386BSD__
Xstruct isa_driver btdriver = { btprobe, btattach, "bt"};
X#endif __386BSD__
X
Xstatic int btunit = 0;
X
X#define bt_abortmbx(mbx) \
X (mbx)->cmd = BT_MBO_ABORT; \
X outb(BT_CMD_DATA_PORT, BT_START_SCSI);
X#define bt_startmbx(mbx) \
X (mbx)->cmd = BT_MBO_START; \
X outb(BT_CMD_DATA_PORT, BT_START_SCSI);
X
X
X
Xint bt_scsi_cmd();
Xint bt_timeout();
Xvoid btminphys();
Xlong int bt_adapter_info();
X
Xstruct scsi_switch bt_switch =
X{
X bt_scsi_cmd,
X btminphys,
X 0,
X 0,
X bt_adapter_info,
X 0,0,0
X};
X#define BT_CMD_TIMEOUT_FUDGE 200 /* multiplied to get Secs */
X#define BT_RESET_TIMEOUT 1000000
X#define BT_SCSI_TIMEOUT_FUDGE 20 /* divided by for mSecs */
X
X
X/***********************************************************************\
X* bt_cmd(unit,icnt, ocnt,wait, retval, opcode, args) *
X* Activate Adapter command *
X* icnt: number of args (outbound bytes written after opcode) *
X* ocnt: number of expected returned bytes *
X* wait: number of seconds to wait for response *
X* retval: buffer where to place returned bytes *
X* opcode: opcode BT_NOP, BT_MBX_INIT, BT_START_SCSI ... *
X* args: parameters *
X* *
X* Performs an adapter command through the ports. Not to be confused *
X* with a scsi command, which is read in via the dma *
X* One of the adapter commands tells it to read in a scsi command *
X\***********************************************************************/
Xbt_cmd(unit,icnt, ocnt, wait,retval, opcode, args)
X
Xu_char *retval;
Xunsigned opcode;
Xu_char args;
X{
X unsigned *ic = &opcode;
X u_char oc;
X register i;
X int sts;
X
X /*******************************************************\
X * multiply the wait argument by a big constant *
X * zero defaults to 1 *
X \*******************************************************/
X if(!wait)
X wait = BT_CMD_TIMEOUT_FUDGE * delaycount;
X else
X wait *= BT_CMD_TIMEOUT_FUDGE * delaycount;
X /*******************************************************\
X * Wait for the adapter to go idle, unless it's one of *
X * the commands which don't need this *
X \*******************************************************/
X if (opcode != BT_MBX_INIT && opcode != BT_START_SCSI)
X {
X i = BT_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec?*/
X while (--i)
X {
X sts = inb(BT_CTRL_STAT_PORT);
X if (sts & BT_IDLE)
X {
X break;
X }
X }
X if (!i)
X {
X printf("bt_cmd: bt742a host not idle(0x%x)\n",sts);
X return(ENXIO);
X }
X }
X /*******************************************************\
X * Now that it is idle, if we expect output, preflush the*
X * queue feeding to us. *
X \*******************************************************/
X if (ocnt)
X {
X while((inb(BT_CTRL_STAT_PORT)) & BT_DF)
X inb(BT_CMD_DATA_PORT);
X }
X
X /*******************************************************\
X * Output the command and the number of arguments given *
X * for each byte, first check the port is empty. *
X \*******************************************************/
X icnt++; /* include the command */
X while (icnt--)
X {
X sts = inb(BT_CTRL_STAT_PORT);
X for (i=0; i< wait; i++)
X {
X sts = inb(BT_CTRL_STAT_PORT);
X if (!(sts & BT_CDF))
X break;
X }
X if (i >= wait)
X {
X printf("bt_cmd: bt742a cmd/data port full\n");
X outb(BT_CTRL_STAT_PORT, BT_SRST);
X return(ENXIO);
X }
X outb(BT_CMD_DATA_PORT, (u_char)(*ic++));
X }
X /*******************************************************\
X * If we expect input, loop that many times, each time, *
X * looking for the data register to have valid data *
X \*******************************************************/
X while (ocnt--)
X {
X sts = inb(BT_CTRL_STAT_PORT);
X for (i=0; i< wait; i++)
X {
X sts = inb(BT_CTRL_STAT_PORT);
X if (sts & BT_DF)
X break;
X }
X if (i >= wait)
X {
X printf("bt_cmd: bt742a cmd/data port empty %d\n",ocnt);
X return(ENXIO);
X }
X oc = inb(BT_CMD_DATA_PORT);
X if (retval)
X *retval++ = oc;
X }
X /*******************************************************\
X * Wait for the board to report a finised instruction *
X \*******************************************************/
X i=BT_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec? */
X while (--i)
X {
X sts = inb(BT_INTR_PORT);
X if (sts & BT_HACC)
X {
X break;
X }
X }
X if (!i)
X {
X printf("bt_cmd: bt742a host not finished(0x%x)\n",sts);
X return(ENXIO);
X }
X outb(BT_CTRL_STAT_PORT, BT_IRST);
X return(0);
X}
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\*******************************************************/
X
Xbtprobe(dev)
Xstruct isa_dev *dev;
X{
X /***********************************************\
X * find unit and check we have that many defined *
X \***********************************************/
X int unit = btunit;
X#if defined(OSF)
X static ihandler_t bt_handler[NBT];
X static ihandler_id_t *bt_handler_id[NBT];
X register ihandler_t *chp = &bt_handler[unit];;
X#endif /* defined(OSF) */
X
X dev->dev_unit = unit;
X bt_base[unit] = dev->dev_addr;
X if(unit >= NBT)
X {
X printf("bt: 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 bt_int[unit]*
X \***********************************************/
X if (bt_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 ((bt_handler_id[unit] = handler_add(chp)) != NULL)
X handler_enable(bt_handler_id[unit]);
X else
X panic("Unable to add bt interrupt handler");
X#else /* CMU */
X dev->dev_pic = bt_int[unit];
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 << bt_int[unit]);
X dev->id_drq = bt_dma[unit];
X printf("\n **");
X#endif __386BSD__
X
X btunit++;
X return(1);
X}
X
X/***********************************************\
X* Attach all the sub-devices we can find *
X\***********************************************/
Xbtattach(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, bt_scsi_dev[unit], &bt_switch);
X#if defined(OSF)
X bt_attached[unit]=1;
X#endif /* defined(OSF) */
X if(!unit) /* only one for all boards */
X {
X bt_timeout(0);
X }
X#ifdef __386BSD__
X printf("bt%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 bt_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\***********************************************/
Xbtintr(unit)
X{
X struct bt_ccb *ccb;
X unsigned char stat;
X register i;
X
X if(scsi_debug & PRINTROUTINES)
X printf("btintr ");
X /***********************************************\
X * First acknowlege the interrupt, Then if it's *
X * not telling about a completed operation *
X * just return. *
X \***********************************************/
X stat = inb(BT_INTR_PORT);
X outb(BT_CTRL_STAT_PORT, BT_IRST);
X if(scsi_debug & TRACEINTERRUPTS)
X printf("int = 0x%x ",stat);
X if (! (stat & BT_MBIF))
X return 1;
X if(scsi_debug & TRACEINTERRUPTS)
X printf("mbxi ");
X#if defined(OSF)
X if (!bt_attached[unit])
X {
X return(1);
X }
X#endif /* defined(OSF) */
X /***********************************************\
X * If it IS then process the competed operation *
X \***********************************************/
X for (i = 0; i < BT_MBX_SIZE; i++)
X {
X if (bt_mbx[unit].mbi[i].stat != BT_MBI_FREE)
X {
X ccb = (struct bt_ccb *)PHYSTOKV(
X (bt_mbx[unit].mbi[i].ccb_addr));
X if((bt_debug & BT_SHOWCCBS) && ccb)
X printf("<int ccb(%x)>",ccb);
X if((stat = bt_mbx[unit].mbi[i].stat) != BT_MBI_OK)
X {
X switch(stat)
X {
X case BT_MBI_ABORT:
X if(bt_debug & BT_SHOWMISC)
X printf("abort ");
X ccb->host_stat = BT_ABORTED;
X break;
X
X case BT_MBI_UNKNOWN:
X ccb = (struct bt_ccb *)0;
X if(bt_debug & BT_SHOWMISC)
X printf("unknown ccb for abort");
X break;
X
X case BT_MBI_ERROR:
X break;
X
X default:
X panic("Impossible mbxi status");
X
X }
X if((bt_debug & BT_SHOWCMDS ) && ccb)
X {
X u_char *cp;
X cp = ccb->scsi_cmd;
X printf("op=%x %x %x %x %x %x\n",
X cp[0], cp[1], cp[2],
X cp[3], cp[4], cp[5]);
X printf("stat %x for mbi[%d]\n"
X , bt_mbx[unit].mbi[i].stat, i);
X printf("addr = 0x%x\n", ccb);
X }
X }
X if(ccb)
X {
X bt_remove_timeout(ccb);
X bt_done(unit,ccb);
X }
X bt_mbx[unit].mbi[i].stat = BT_MBI_FREE;
X }
X }
X return(1);
X}
X
X/***********************************************\
X* A ccb (and hence a mbx-out is put onto the *
X* free list. *
X\***********************************************/
Xbt_free_ccb(unit,ccb, flags)
Xstruct bt_ccb *ccb;
X{
X unsigned int opri;
X
X if(scsi_debug & PRINTROUTINES)
X printf("ccb%d(0x%x)> ",unit,flags);
X if (!(flags & SCSI_NOMASK))
X opri = splbio();
X
X ccb->next = bt_ccb_free[unit];
X bt_ccb_free[unit] = ccb;
X ccb->flags = CCB_FREE;
X /***********************************************\
X * If there were none, wake abybody waiting for *
X * one to come free, starting with queued entries*
X \***********************************************/
X if (!ccb->next) {
X wakeup(&bt_ccb_free[unit]);
X }
X if (!(flags & SCSI_NOMASK))
X splx(opri);
X}
X
X/***********************************************\
X* Get a free ccb (and hence mbox-out entry) *
X\***********************************************/
Xstruct bt_ccb *
Xbt_get_ccb(unit,flags)
X{
X unsigned opri;
X struct bt_ccb *rc;
X
X if(scsi_debug & PRINTROUTINES)
X printf("<ccb%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 = bt_ccb_free[unit])) && (!(flags & SCSI_NOSLEEP)))
X {
X sleep(&bt_ccb_free[unit], PRIBIO);
X }
X if (rc)
X {
X bt_ccb_free[unit] = rc->next;
X rc->flags = CCB_ACTIVE;
X }
X if (!(flags & SCSI_NOMASK))
X splx(opri);
X return(rc);
X}
X
X
X/***********************************************\
X* We have a ccb which has been processed by the *
X* adaptor, now we look to see how the operation *
X* went. Wake up the owner if waiting *
X\***********************************************/
Xbt_done(unit,ccb)
Xstruct bt_ccb *ccb;
X{
X struct scsi_sense_data *s1,*s2;
X struct scsi_xfer *xs = ccb->xfer;
X
X if(scsi_debug & (PRINTROUTINES | TRACEINTERRUPTS))
X printf("bt_done ");
X /***********************************************\
X * Otherwise, put the results of the operation *
X * into the xfer and call whoever started it *
X \***********************************************/
X if ( ( ccb->host_stat != BT_OK
X || ccb->target_stat != SCSI_OK)
X && (!(xs->flags & SCSI_ERR_OK)))
X {
X
X s1 = &(ccb->scsi_sense);
X s2 = &(xs->sense);
X
X if(ccb->host_stat)
X {
X switch(ccb->host_stat)
X {
X case BT_ABORTED: /* No response */
X case BT_SEL_TIMEOUT: /* No response */
X if (bt_debug & BT_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 (bt_debug & BT_SHOWMISC)
X {
X printf("unexpected host_stat: %x\n",
X ccb->host_stat);
X }
X }
X
X }
X else
X {
X switch(ccb->target_stat)
X {
X case 0x02:
X /* structure copy!!!!!*/
X *s2=*s1;
X xs->error = XS_SENSE;
X break;
X case 0x08:
X xs->error = XS_BUSY;
X break;
X default:
X if (bt_debug & BT_SHOWMISC)
X {
X printf("unexpected target_stat: %x\n",
X ccb->target_stat);
X }
X xs->error = XS_DRIVER_STUFFUP;
X }
X }
X }
X else /* All went correctly OR errors expected */
X {
X xs->resid = 0;
X }
X xs->flags |= ITSDONE;
X bt_free_ccb(unit,ccb, xs->flags);
X if(xs->when_done)
X (*(xs->when_done))(xs->done_arg,xs->done_arg2);
X}
X
X/***********************************************\
X* Start the board, ready for normal operation *
X\***********************************************/
Xbt_init(unit)
Xint unit;
X{
X unsigned char ad[4];
X volatile int i,sts;
X struct bt_config conf;
X
X /***********************************************\
X * reset board, If it doesn't respond, assume *
X * that it's not there.. good for the probe *
X \***********************************************/
X
X outb(BT_CTRL_STAT_PORT, BT_HRST|BT_SRST);
X
X for (i=0; i < BT_RESET_TIMEOUT; i++)
X {
X sts = inb(BT_CTRL_STAT_PORT) ;
X if ( sts == (BT_IDLE | BT_INIT))
X break;
X }
X if (i >= BT_RESET_TIMEOUT)
X {
X if (bt_debug & BT_SHOWMISC)
X printf("bt_init: No answer from bt742a board\n");
X return(ENXIO);
X }
X
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("bt%d reading board settings, ",unit);
X#define PRNT(x)
X#else __386BSD__
X printf("bt%d:",unit);
X#define PRNT(x) printf(x)
X#endif __386BSD__
X
X bt_cmd(unit,0, sizeof(conf), 0 ,&conf, BT_CONF_GET);
X switch(conf.chan)
X {
X case EISADMA:
X bt_dma[unit] = -1;
X PRNT("eisa dma ");
X break;
X case CHAN0:
X outb(0x0b, 0x0c);
X outb(0x0a, 0x00);
X bt_dma[unit] = 0;
X PRNT("dma=0 ");
X break;
X case CHAN5:
X outb(0xd6, 0xc1);
X outb(0xd4, 0x01);
X bt_dma[unit] = 5;
X PRNT("dma=5 ");
X break;
X case CHAN6:
X outb(0xd6, 0xc2);
X outb(0xd4, 0x02);
X bt_dma[unit] = 6;
X PRNT("dma=6 ");
X break;
X case CHAN7:
X outb(0xd6, 0xc3);
X outb(0xd4, 0x03);
X bt_dma[unit] = 7;
X PRNT("dma=7 ");
X break;
X default:
X printf("illegal dma setting %x\n",conf.chan);
X return(EIO);
X }
X switch(conf.intr)
X {
X case INT9:
X bt_int[unit] = 9;
X PRNT("int=9 ");
X break;
X case INT10:
X bt_int[unit] = 10;
X PRNT("int=10 ");
X break;
X case INT11:
X bt_int[unit] = 11;
X PRNT("int=11 ");
X break;
X case INT12:
X bt_int[unit] = 12;
X PRNT("int=12 ");
X break;
X case INT14:
X bt_int[unit] = 14;
X PRNT("int=14 ");
X break;
X case INT15:
X bt_int[unit] = 15;
X PRNT("int=15 ");
X break;
X default:
X printf("illegal int setting\n");
X return(EIO);
X }
X /* who are we on the scsi bus */
X bt_scsi_dev[unit] = conf.scsi_dev;
X /***********************************************\
X * Initialize mail box *
X \***********************************************/
X
X *((physaddr *)ad) = KVTOPHYS(&bt_mbx[unit]);
X bt_cmd(unit,5, 0, 0, 0, BT_MBX_INIT_EXTENDED
X , BT_MBX_SIZE
X , ad[0]
X , ad[1]
X , ad[2]
X , ad[3]);
X
X /***********************************************\
X * link the ccb's with the mbox-out entries and *
X * into a free-list *
X \***********************************************/
X for (i=0; i < BT_MBX_SIZE; i++) {
X bt_ccb[unit][i].next = bt_ccb_free[unit];
X bt_ccb_free[unit] = &bt_ccb[unit][i];
X bt_ccb_free[unit]->flags = CCB_FREE;
X bt_ccb_free[unit]->mbx = &bt_mbx[unit].mbo[i];
X bt_mbx[unit].mbo[i].ccb_addr = KVTOPHYS(bt_ccb_free[unit]) ;
X }
X
X /***********************************************\
X * Note that we are going and return (to probe) *
X \***********************************************/
X bt_initialized[unit]++;
X return( 0 );
X}
X
X
X#ifndef min
X#define min(x,y) (x < y ? x : y)
X#endif min
X
X
Xvoid btminphys(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 > ((BT_NSEG-1) * PAGESIZ))
X {
X bp->b_bcount = ((BT_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 bt_scsi_cmd(xs)
Xstruct scsi_xfer *xs;
X{
X struct scsi_sense_data *s1,*s2;
X struct bt_ccb *ccb;
X struct bt_scat_gath *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
X if(scsi_debug & PRINTROUTINES)
X printf("bt_scsi_cmd ");
X /***********************************************\
X * get a ccb (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 (!(ccb = bt_get_ccb(unit,flags)))
X {
X xs->error = XS_DRIVER_STUFFUP;
X return(TRY_AGAIN_LATER);
X }
X
X if(bt_debug & BT_SHOWCCBS)
X printf("<start ccb(%x)>",ccb);
X if (ccb->mbx->cmd != BT_MBO_FREE)
X printf("MBO not free\n");
X
X /***********************************************\
X * Put all the arguments for the xfer in the ccb *
X \***********************************************/
X ccb->xfer = xs;
X if(flags & SCSI_RESET)
X {
X ccb->opcode = BT_RESET_CCB;
X }
X else
X {
X /* can't use S/G if zero length */
X ccb->opcode = (xs->datalen?
X BT_INIT_SCAT_GATH_CCB
X :BT_INITIATOR_CCB);
X }
X ccb->target = xs->targ;;
X ccb->data_out = 0;
X ccb->data_in = 0;
X ccb->lun = xs->lu;
X ccb->scsi_cmd_length = xs->cmdlen;
X ccb->sense_ptr = KVTOPHYS(&(ccb->scsi_sense));
X ccb->req_sense_length = sizeof(ccb->scsi_sense);
X
X if((xs->datalen) && (!(flags & SCSI_RESET)))
X { /* can use S/G only if not zero length */
X ccb->data_addr = KVTOPHYS(ccb->scat_gath);
X sg = ccb->scat_gath ;
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 < BT_NSEG))
X {
X sg->seg_addr = (physaddr)iovp->iov_base;
X xs->datalen += sg->seg_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 < BT_NSEG))
X {
X bytes_this_seg = 0;
X
X /* put in the base address */
X sg->seg_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->seg_len = bytes_this_seg;
X sg++;
X seg++;
X }
X } /*end of iov/kv decision */
X ccb->data_length = seg * sizeof(struct bt_scat_gath);
X if(scsi_debug & SHOWSCATGATH)
X printf("\n");
X if (datalen)
X { /* there's still data, must have run out of segs! */
X printf("bt_scsi_cmd%d: more than %d DMA segs\n",
X unit,BT_NSEG);
X xs->error = XS_DRIVER_STUFFUP;
X bt_free_ccb(unit,ccb,flags);
X return(HAD_ERROR);
X }
X
X }
X else
X { /* No data xfer, use non S/G values */
X ccb->data_addr = (physaddr)0;
X ccb->data_length = 0;
X }
X ccb->link_id = 0;
X ccb->link_addr = (physaddr)0;
X /***********************************************\
X * Put the scsi command in the ccb and start it *
X \***********************************************/
X if(!(flags & SCSI_RESET))
X {
X bcopy(xs->cmd, ccb->scsi_cmd, ccb->scsi_cmd_length);
X }
X if(scsi_debug & SHOWCOMMANDS)
X {
X u_char *b = ccb->scsi_cmd;
X if(!(flags & SCSI_RESET))
X {
X int i = 0;
X printf("bt%d:%d:%d-"
X ,unit
X ,ccb->target
X ,ccb->lun);
X while(i < ccb->scsi_cmd_length )
X {
X if(i) printf(",");
X printf("%x",b[i++]);
X }
X printf("-\n");
X }
X else
X {
X printf("bt%d:%d:%d-RESET- "
X ,unit
X ,ccb->target
X ,ccb->lun
X );
X }
X }
X bt_startmbx(ccb->mbx);
X /***********************************************\
X * Usually return SUCCESSFULLY QUEUED *
X \***********************************************/
X if(scsi_debug & TRACEINTERRUPTS)
X printf("cmd_sent ");
X if (!(flags & SCSI_NOMASK))
X {
X bt_add_timeout(ccb,xs->timeout);
X return(SUCCESSFULLY_QUEUED);
X }
X /***********************************************\
X * If we can't use interrupts, poll on completion*
X \***********************************************/
X {
X int done = 0;
X int count = delaycount * xs->timeout / BT_SCSI_TIMEOUT_FUDGE;
X if(scsi_debug & TRACEINTERRUPTS)
X printf("wait ");
X while((!done) && count)
X {
X i=0;
X while ( (!done) && i<BT_MBX_SIZE)
X {
X if ((bt_mbx[unit].mbi[i].stat != BT_MBI_FREE )
X && (PHYSTOKV(bt_mbx[unit].mbi[i].ccb_addr)
X == (int)ccb))
X {
X bt_mbx[unit].mbi[i].stat = BT_MBI_FREE;
X bt_done(unit,ccb);
X done++;
X }
X i++;
X }
X count--;
X }
X if (!count)
X {
X if (!(xs->flags & SCSI_SILENT))
X printf("cmd fail\n");
X bt_abortmbx(ccb->mbx);
X count = delaycount * 2000 / BT_SCSI_TIMEOUT_FUDGE;
X while((!done) && count)
X {
X i=0;
X while ( (!done) && i<BT_MBX_SIZE)
X {
X if ((bt_mbx[unit].mbi[i].stat != BT_MBI_FREE )
X && (PHYSTOKV((bt_mbx[unit].mbi[i].ccb_addr)
X == (int)ccb)))
X {
X bt_mbx[unit].mbi[i].stat = BT_MBI_FREE;
X bt_done(unit,ccb);
X done++;
X }
X i++;
X }
X count--;
X }
X if(!count)
X {
X printf("abort failed in wait\n");
X ccb->mbx->cmd = BT_MBO_FREE;
X }
X bt_free_ccb(unit,ccb,flags);
X btintr(unit);
X xs->error = XS_DRIVER_STUFFUP;
X return(HAD_ERROR);
X }
X btintr(unit);
X if(xs->error) return(HAD_ERROR);
X return(COMPLETE);
X }
X}
X
X/*
X * +----------+ +----------+ +----------+
X * bt_soonest--->| later |---->| later|---->| later|--->0
X * | [Delta] | | [Delta] | | [Delta] |
X * 0<-----|sooner |<----|sooner |<----|sooner |<----bt_latest
X * +----------+ +----------+ +----------+
X *
X * bt_furtherest = sum(Delta[1..n])
X */
Xbt_add_timeout(ccb,time)
Xstruct bt_ccb *ccb;
Xint time;
X{
X int timeprev;
X struct bt_ccb *prev;
X int s = splbio();
X
X if(prev = bt_latest) /* yes, an assign */
X {
X timeprev = bt_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 ccb->delta = time - timeprev;
X if( ccb->later = prev->later) /* yes an assign */
X {
X ccb->later->sooner = ccb;
X ccb->later->delta -= ccb->delta;
X }
X else
X {
X bt_furtherest = time;
X bt_latest = ccb;
X }
X ccb->sooner = prev;
X prev->later = ccb;
X }
X else
X {
X if( ccb->later = bt_soonest) /* yes, an assign*/
X {
X ccb->later->sooner = ccb;
X ccb->later->delta -= time;
X }
X else
X {
X bt_furtherest = time;
X bt_latest = ccb;
X }
X ccb->delta = time;
X ccb->sooner = (struct bt_ccb *)0;
X bt_soonest = ccb;
X }
X splx(s);
X}
X
Xbt_remove_timeout(ccb)
Xstruct bt_ccb *ccb;
X{
X int s = splbio();
X
X if(ccb->sooner)
X {
X ccb->sooner->later = ccb->later;
X }
X else
X {
X bt_soonest = ccb->later;
X }
X if(ccb->later)
X {
X ccb->later->sooner = ccb->sooner;
X ccb->later->delta += ccb->delta;
X }
X else
X {
X bt_latest = ccb->sooner;
X bt_furtherest -= ccb->delta;
X }
X ccb->sooner = ccb->later = (struct bt_ccb *)0;
X splx(s);
X}
X
X
Xextern int hz;
X#define ONETICK 500 /* milliseconds */
X#define SLEEPTIME ((hz * 1000) / ONETICK)
Xbt_timeout(arg)
Xint arg;
X{
X struct bt_ccb *ccb;
X int unit;
X int s = splbio();
X
X while( ccb = bt_soonest )
X {
X if(ccb->delta <= ONETICK)
X /***********************************************\
X * It has timed out, we need to do some work *
X \***********************************************/
X {
X unit = ccb->xfer->adapter;
X printf("bt%d:%d device timed out\n",unit
X ,ccb->xfer->targ);
X if(bt_debug & BT_SHOWCCBS)
X tfs_print_active_ccbs();
X
X /***************************************\
X * Unlink it from the queue *
X \***************************************/
X bt_remove_timeout(ccb);
X
X /***************************************\
X * If The ccb's mbx is not free, then *
X * the board has gone south *
X \***************************************/
X if(ccb->mbx->cmd != BT_MBO_FREE)
X {
X printf("bt%d not taking commands!\n"
X ,unit);
X Debugger();
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(ccb->flags == CCB_ABORTED) /* abort timed out */
X {
X printf("AGAIN");
X ccb->xfer->retries = 0; /* I MEAN IT ! */
X ccb->host_stat = BT_ABORTED;
X bt_done(unit,ccb);
X }
X else /* abort the operation that has timed out */
X {
X printf("\n");
X bt_abortmbx(ccb->mbx);
X /* 2 secs for the abort */
X bt_add_timeout(ccb,2000 + ONETICK);
X ccb->flags = CCB_ABORTED;
X }
X }
X else
X /***********************************************\
X * It has not timed out, adjust and leave *
X \***********************************************/
X {
X ccb->delta -= ONETICK;
X bt_furtherest -= ONETICK;
X break;
X }
X }
X splx(s);
X timeout(bt_timeout,arg,SLEEPTIME);
X}
X
Xtfs_print_ccb(ccb)
Xstruct bt_ccb *ccb;
X{
X printf("ccb:%x op:%x cmdlen:%d senlen:%d\n"
X ,ccb
X ,ccb->opcode
X ,ccb->scsi_cmd_length
X ,ccb->req_sense_length);
X printf(" datlen:%d hstat:%x tstat:%x delta:%d flags:%x\n"
X ,ccb->data_length
X ,ccb->host_stat
X ,ccb->target_stat
X ,ccb->delta
X ,ccb->flags);
X}
X
Xtfs_print_active_ccbs()
X{
X struct bt_ccb *ccb;
X ccb = bt_soonest;
X
X while(ccb)
X {
X tfs_print_ccb(ccb);
X ccb = ccb->later;
X }
X printf("Furtherest = %d\n",bt_furtherest);
X}
END-of-i386/isa/bt742a.c
exit