Return to BSD News archive
Newsgroups: comp.unix.bsd
Path: sserve!manuel!munnari.oz.au!uunet!sun-barr!ames!agate!tfs.com!tfs.com!julian
From: julian@tfs.com (Julian Elischer)
Subject: REPLACEMENT SCSI SYSTEM (beta) (4 of 4)
Message-ID: <1992Sep18.024043.27861@tfs.com>
Organization: TRW Financial Systems
Date: Fri, 18 Sep 1992 02:40:43 GMT
Lines: 1834
# 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/isa/aha1542.c
# /dev/MAKEDEV
#
echo x - i386/isa/aha1542.c
sed 's/^X//' >i386/isa/aha1542.c << 'END-of-i386/isa/aha1542.c'
X/*
X * (Mostly) 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 * Ported to run under 386BSD by Julian Elischer (julian@tfs.com) Sept 1992
X */
X
X/*
X * HISTORY
X * $Log: adaptec.c,v $
X *
X * a FEW lines in this driver come from a MACH adaptec-disk driver
X * so the copyright below is included:
X *
X * Copyright 1990 by Open Software Foundation,
X * Grenoble, FRANCE
X *
X * All Rights Reserved
X *
X * Permission to use, copy, modify, and distribute this software and
X * its documentation for any purpose and without fee is hereby granted,
X * provided that the above copyright notice appears in all copies and
X * that both the copyright notice and this permission notice appear in
X * supporting documentation, and that the name of OSF or Open Software
X * Foundation not be used in advertising or publicity pertaining to
X * distribution of the software without specific, written prior
X * permission.
X *
X * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
X * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
X * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
X * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
X * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
X * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
X */
X
X
X#include <sys/types.h>
X#include <aha.h>
X
X#include <sys/param.h>
X#include <sys/systm.h>
X#include <sys/ioctl.h>
X#include <sys/buf.h>
X#include <sys/proc.h>
X#include <sys/user.h>
X#if defined(OSF)
X#include <i386/AT386/atbus.h>
X#else /* defined(OSF) */
X#ifndef MACH
X/*#include <i386/include/pio.h>*/
X#include <i386/isa/isa_device.h>
X#define isa_dev isa_device
X#define dev_unit id_unit
X#define dev_addr id_iobase
X#else /*not mach */
X#include <i386at/atbus.h>
X#include <i386/pio.h>
X#endif MACH
X#endif /* defined(OSF) */
X
X#if defined(OSF) || defined(MACH)
X#include <i386/ipl.h>
X#include <i386at/scsi.h>
X#include <i386at/scsiconf.h>
X#else defined(OSF) || defined(MACH)
X#include <scsi/scsi.h>
X#include <scsi/scsiconf.h>
X#endif defined(OSF) || defined(MACH)
X
X#if defined(OSF)
X#include <sys/table.h>
X#include <i386/handler.h>
X#include <i386/dispatcher.h>
X#endif /* defined(OSF) */
X
X#ifdef __386BSD__
X#define Debugger() panic("should call debugger here (adaptec.c)")
X#endif __386BSD__
Xextern int delaycount; /* from clock setup code */
X
X/************************** board definitions *******************************/
X/*
X * I/O Port Interface
X */
X
X#define AHA_BASE aha_base[unit]
X#define AHA_CTRL_STAT_PORT (AHA_BASE + 0x0) /* control & status */
X#define AHA_CMD_DATA_PORT (AHA_BASE + 0x1) /* cmds and datas */
X#define AHA_INTR_PORT (AHA_BASE + 0x2) /* Intr. stat */
X
X/*
X * AHA_CTRL_STAT bits (write)
X */
X
X#define AHA_HRST 0x80 /* Hardware reset */
X#define AHA_SRST 0x40 /* Software reset */
X#define AHA_IRST 0x20 /* Interrupt reset */
X#define AHA_SCRST 0x10 /* SCSI bus reset */
X
X/*
X * AHA_CTRL_STAT bits (read)
X */
X
X#define AHA_STST 0x80 /* Self test in Progress */
X#define AHA_DIAGF 0x40 /* Diagnostic Failure */
X#define AHA_INIT 0x20 /* Mbx Init required */
X#define AHA_IDLE 0x10 /* Host Adapter Idle */
X#define AHA_CDF 0x08 /* cmd/data out port full */
X#define AHA_DF 0x04 /* Data in port full */
X#define AHA_INVDCMD 0x01 /* Invalid command */
X
X/*
X * AHA_CMD_DATA bits (write)
X */
X
X#define AHA_NOP 0x00 /* No operation */
X#define AHA_MBX_INIT 0x01 /* Mbx initialization */
X#define AHA_START_SCSI 0x02 /* start scsi command */
X#define AHA_START_BIOS 0x03 /* start bios command */
X#define AHA_INQUIRE 0x04 /* Adapter Inquiry */
X#define AHA_MBO_INTR_EN 0x05 /* Enable MBO available interrupt */
X#define AHA_SEL_TIMEOUT_SET 0x06 /* set selection time-out */
X#define AHA_BUS_ON_TIME_SET 0x07 /* set bus-on time */
X#define AHA_BUS_OFF_TIME_SET 0x08 /* set bus-off time */
X#define AHA_SPEED_SET 0x09 /* set transfer speed */
X#define AHA_DEV_GET 0x0a /* return installed devices */
X#define AHA_CONF_GET 0x0b /* return configuration data */
X#define AHA_TARGET_EN 0x0c /* enable target mode */
X#define AHA_SETUP_GET 0x0d /* return setup data */
X#define AHA_WRITE_CH2 0x1a /* write channel 2 buffer */
X#define AHA_READ_CH2 0x1b /* read channel 2 buffer */
X#define AHA_WRITE_FIFO 0x1c /* write fifo buffer */
X#define AHA_READ_FIFO 0x1d /* read fifo buffer */
X#define AHA_ECHO 0x1e /* Echo command data */
X
Xstruct aha_cmd_buf {
X u_char byte[16];
X};
X
X/*
X * AHA_INTR_PORT bits (read)
X */
X
X#define AHA_ANY_INTR 0x80 /* Any interrupt */
X#define AHA_SCRD 0x08 /* SCSI reset detected */
X#define AHA_HACC 0x04 /* Command complete */
X#define AHA_MBOA 0x02 /* MBX out empty */
X#define AHA_MBIF 0x01 /* MBX in full */
X
X/*
X * Mail box defs
X */
X
X#define AHA_MBX_SIZE 16 /* mail box size */
X
Xstruct aha_mbx {
X struct aha_mbx_out {
X unsigned char cmd;
X unsigned char ccb_addr[3];
X } mbo [AHA_MBX_SIZE];
X struct aha_mbx_in{
X unsigned char stat;
X unsigned char ccb_addr[3];
X } mbi[AHA_MBX_SIZE];
X};
X
X/*
X * mbo.cmd values
X */
X
X#define AHA_MBO_FREE 0x0 /* MBO entry is free */
X#define AHA_MBO_START 0x1 /* MBO activate entry */
X#define AHA_MBO_ABORT 0x2 /* MBO abort entry */
X
X#define AHA_MBI_FREE 0x0 /* MBI entry is free */
X#define AHA_MBI_OK 0x1 /* completed without error */
X#define AHA_MBI_ABORT 0x2 /* aborted ccb */
X#define AHA_MBI_UNKNOWN 0x3 /* Tried to abort invalid CCB */
X#define AHA_MBI_ERROR 0x4 /* Completed with error */
X
Xextern struct aha_mbx aha_mbx[];
X
X#define AHA_NSEG 17 /* Number of scatter gather segments <= 16 */
X /* allow 64 K i/o (min) */
X
Xstruct aha_ccb {
X unsigned char opcode;
X unsigned char lun:3;
X unsigned char data_in:1; /* must be 0 */
X unsigned char data_out:1; /* must be 0 */
X unsigned char target:3;
X unsigned char scsi_cmd_length;
X unsigned char req_sense_length;
X unsigned char data_length[3];
X unsigned char data_addr[3];
X unsigned char link_addr[3];
X unsigned char link_id;
X unsigned char host_stat;
X unsigned char target_stat;
X unsigned char reserved[2];
X union scsi_cmd scsi_cmd;
X struct scsi_sense_data scsi_sense;
X struct aha_scat_gath {
X unsigned char seg_len[3];
X unsigned char seg_addr[3];
X } scat_gath[AHA_NSEG];
X struct aha_ccb *next;
X struct scsi_xfer *xfer; /* the scsi_xfer for this cmd */
X struct aha_mbx_out *mbx; /* pointer to mail box */
X long int delta; /* difference from previous*/
X struct aha_ccb *later,*sooner;
X int flags;
X#define CCB_FREE 0
X#define CCB_ACTIVE 1
X#define CCB_ABORTED 2
X
X};
X
Xstruct aha_ccb *soonest = (struct aha_ccb *)0;
Xstruct aha_ccb *latest = (struct aha_ccb *)0;
Xlong int furtherest = 0; /* longest time in the timeout queue */
X
X/*
X * opcode fields
X */
X
X#define AHA_INITIATOR_CCB 0x00 /* SCSI Initiator CCB */
X#define AHA_TARGET_CCB 0x01 /* SCSI Target CCB */
X#define AHA_INIT_SCAT_GATH_CCB 0x02 /* SCSI Initiator with scattter gather*/
X#define AHA_RESET_CCB 0x81 /* SCSI Bus reset */
X
X
X/*
X * aha_ccb.host_stat values
X */
X
X#define AHA_OK 0x00 /* cmd ok */
X#define AHA_LINK_OK 0x0a /* Link cmd ok */
X#define AHA_LINK_IT 0x0b /* Link cmd ok + int */
X#define AHA_SEL_TIMEOUT 0x11 /* Selection time out */
X#define AHA_OVER_UNDER 0x12 /* Data over/under run */
X#define AHA_BUS_FREE 0x13 /* Bus dropped at unexpected time */
X#define AHA_INV_BUS 0x14 /* Invalid bus phase/sequence */
X#define AHA_BAD_MBO 0x15 /* Incorrect MBO cmd */
X#define AHA_BAD_CCB 0x16 /* Incorrect ccb opcode */
X#define AHA_BAD_LINK 0x17 /* Not same values of LUN for links */
X#define AHA_INV_TARGET 0x18 /* Invalid target direction */
X#define AHA_CCB_DUP 0x19 /* Duplicate CCB received */
X#define AHA_INV_CCB 0x1a /* Invalid CCB or segment list */
X#define AHA_ABORTED 42
X
X
X#if defined(__STDC__) || (defined(__GNUC__) && defined(OSF))
X#define A_CMD _IOWR('a',0,struct aha_cmd_buf) /* Execute cmd command */
X#define A_SCSI _IOWR('a',1,union scsi_cmd) /* Execute scsi command */
X#else /* defined(__STC__)||defined(__GNUC__) */
X#define A_CMD _IOWR(a,0,struct aha_cmd_buf) /* Execute cmd command */
X#define A_SCSI _IOWR(a,1,union scsi_cmd) /* Execute scsi command */
X#endif /* defined(__STC__)||defined(__GNUC__) */
X
X
Xstruct aha_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[3];
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 aha_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 CHAN0 0x01
X#define CHAN5 0x20
X#define CHAN6 0x40
X#define CHAN7 0x80
X
X
X/*********************************** end of board definitions***************/
X
X
X#ifdef MACH
X#define PHYSTOKV(x) phystokv(x)
X#define KVTOPHYS(x) kvtophys(x)
X#else MACH
X#ifdef __386BSD__
X#define PHYSTOKV(x) (x | 0xFE000000)
X#define KVTOPHYS(x) vtophys(x)
X#else __386BSD__
X#endif __386BSD__
X#endif MACH
X#define AHA_DMA_PAGES AHA_NSEG
X
X#define PAGESIZ 4096
X#define INVALIDATE_CACHE {asm volatile( ".byte 0x0F ;.byte 0x08" ); }
X
X
Xu_char aha_scratch_buf[256];
X#ifdef MACH
Xcaddr_t aha_base[NAHA]; /* base port for each board */
X#else
Xshort aha_base[NAHA]; /* base port for each board */
X#endif
Xstruct aha_mbx aha_mbx[NAHA];
Xstruct aha_ccb *aha_ccb_free[NAHA];
Xstruct aha_ccb aha_ccb[NAHA][AHA_MBX_SIZE];
Xstruct scsi_xfer aha_scsi_xfer[NAHA];
Xstruct isa_dev *ahainfo[NAHA];
Xstruct aha_ccb *aha_get_ccb();
Xint aha_int[NAHA];
Xint aha_dma[NAHA];
Xint aha_scsi_dev[NAHA];
Xint aha_initialized[NAHA];
X#ifdef OSF
Xint aha_attached[NAHA];
X#endif OSF
Xint aha_debug = 0;
X
Xint ahaprobe(), ahaattach(), ahaintr();
X#ifdef MACH
Xstruct isa_driver ahadriver = { ahaprobe, 0, ahaattach, "aha", 0, 0, 0};
X#endif
X#ifdef __386BSD__
Xstruct isa_driver ahadriver = { ahaprobe, ahaattach, "aha",};
X#endif __386BSD__
Xint (*ahaintrs[])() = {ahaintr, 0};
Xstatic int ahaunit = 0;
X
X
X#define aha_abortmbx(mbx) \
X (mbx)->cmd = AHA_MBO_ABORT; \
X outb(AHA_CMD_DATA_PORT, AHA_START_SCSI);
X#define aha_startmbx(mbx) \
X (mbx)->cmd = AHA_MBO_START; \
X outb(AHA_CMD_DATA_PORT, AHA_START_SCSI);
X
X
X
Xint aha_scsi_cmd();
Xint aha_timeout();
Xvoid ahaminphys();
X
Xstruct scsi_switch aha_switch =
X{
X aha_scsi_cmd,
X ahaminphys
X};
X#define AHA_CMD_TIMEOUT_FUDGE 200 /* multiplied to get Secs */
X#define AHA_RESET_TIMEOUT 1000000 /* time to wait for reset */
X#define AHA_SCSI_TIMEOUT_FUDGE 20 /* divided by for mSecs */
X
X
X/***********************************************************************\
X* aha_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 AHA_NOP, AHA_MBX_INIT, AHA_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\***********************************************************************/
X
X
Xaha_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 = AHA_CMD_TIMEOUT_FUDGE * delaycount;
X else
X wait *= AHA_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 != AHA_MBX_INIT && opcode != AHA_START_SCSI)
X {
X i = AHA_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec?*/
X while (--i)
X {
X sts = inb(AHA_CTRL_STAT_PORT);
X if (sts & AHA_IDLE)
X {
X break;
X }
X }
X if (!i)
X {
X printf("aha_cmd: aha1542 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(AHA_CTRL_STAT_PORT)) & AHA_DF)
X inb(AHA_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(AHA_CTRL_STAT_PORT);
X for (i=0; i< wait; i++)
X {
X sts = inb(AHA_CTRL_STAT_PORT);
X if (!(sts & AHA_CDF))
X break;
X }
X if (i >= wait)
X {
X printf("aha_cmd: aha1542 cmd/data port full\n");
X outb(AHA_CTRL_STAT_PORT, AHA_SRST);
X return(ENXIO);
X }
X outb(AHA_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(AHA_CTRL_STAT_PORT);
X for (i=0; i< wait; i++)
X {
X sts = inb(AHA_CTRL_STAT_PORT);
X if (sts & AHA_DF)
X break;
X }
X if (i >= wait)
X {
X printf("aha_cmd: aha1542 cmd/data port empty %d\n",ocnt);
X return(ENXIO);
X }
X oc = inb(AHA_CMD_DATA_PORT);
X if (retval)
X *retval++ = oc;
X }
X /*******************************************************\
X * Wait for the board to report a finised instruction *
X \*******************************************************/
X i=AHA_CMD_TIMEOUT_FUDGE * delaycount; /* 1 sec? */
X while (--i)
X {
X sts = inb(AHA_INTR_PORT);
X if (sts & AHA_HACC)
X {
X break;
X }
X }
X if (!i)
X {
X printf("aha_cmd: aha1542 host not finished(0x%x)\n",sts);
X return(ENXIO);
X }
X outb(AHA_CTRL_STAT_PORT, AHA_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\*******************************************************/
Xahaprobe(dev)
Xstruct isa_dev *dev;
X{
X int unit = ahaunit;
X#if defined(OSF)
X static ihandler_t aha_handler[NAHA];
X static ihandler_id_t *aha_handler_id[NAHA];
X register ihandler_t *chp = &aha_handler[unit];;
X#endif /* defined(OSF) */
X
X /***********************************************\
X /***********************************************\
X * find unit and check we have that many defined *
X \***********************************************/
X dev->dev_unit = unit;
X aha_base[unit] = dev->dev_addr;
X if(unit > NAHA)
X {
X printf("aha: 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 aha_int[unit]*
X \***********************************************/
X if (aha_init(unit) != 0)
X {
X return(0);
X }
X
X /***********************************************\
X * If it's there, put in it's interrupt vectors *
X \***********************************************/
X#if !defined(OSF)
X#if defined MACH
X iunit[aha_int[unit]] =unit;
X ivect[aha_int[unit]] = ahaintr;
X intpri[aha_int[unit]] = dev->dev_spl;
X form_pic_mask();
X /*take_dev_irq(dev);*/
X#else
X#ifdef __386BSD__
X dev->id_irq = (1 << aha_int[unit]);
X dev->id_drq = aha_dma[unit];
X#endif __386BSD__
X#endif
X#else /* !defined(OSF) */
X
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 ((aha_handler_id[unit] = handler_add(chp)) != NULL)
X handler_enable(aha_handler_id[unit]);
X else
X panic("Unable to add aha interrupt handler");
X#endif /* !defined(OSF) */
X#ifdef __386BSD__
X printf("\n **");
X#else __386BSD__
X printf("port=%x spl=%d\n",
X dev->dev_addr, dev->dev_spl);
X#endif __386BSD__
X ahaunit ++;
X return(1);
X}
X
X/***********************************************\
X* Attach all the sub-devices we can find *
X\***********************************************/
Xahaattach(dev)
Xstruct isa_dev *dev;
X{
X int unit = dev->dev_unit;
X
X#ifdef __386BSD__
X printf(" probing for scsi devices**\n");
X#endif __386BSD__
X /***********************************************\
X * ask the adapter what subunits are present *
X \***********************************************/
X scsi_attachdevs( unit, aha_scsi_dev[unit], &aha_switch);
X#if defined(OSF)
X aha_attached[unit]=1;
X#endif /* defined(OSF) */
X if(!unit) /* only one for all boards */
X {
X aha_timeout(0);
X }
X#ifdef __386BSD__
X printf("aha%d",unit);
X#endif __386BSD__
X return;
X
X}
X
X/***********************************************\
X* Catch an interrupt from the adaptor *
X\***********************************************/
Xahaintr(unit)
X{
X struct aha_ccb *ccb;
X unsigned char stat;
X register i;
X
X if(scsi_debug & PRINTROUTINES)
X printf("ahaintr ");
X /***********************************************\
X * First acknowlege the interrupt, Then if it's *
X * not telling about a completed operation *
X * just return. *
X \***********************************************/
X stat = inb(AHA_INTR_PORT);
X outb(AHA_CTRL_STAT_PORT, AHA_IRST);
X if(scsi_debug & TRACEINTERRUPTS)
X printf("int ");
X if (! (stat & AHA_MBIF))
X return(1);
X if(scsi_debug & TRACEINTERRUPTS)
X printf("b ");
X#if defined(OSF)
X if (!aha_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 < AHA_MBX_SIZE; i++)
X {
X if (aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE)
X {
X ccb = (struct aha_ccb *)PHYSTOKV(
X (_3btol(aha_mbx[unit].mbi[i].ccb_addr)));
X
X if((stat = aha_mbx[unit].mbi[i].stat) != AHA_MBI_OK)
X {
X switch(stat)
X {
X case AHA_MBI_ABORT:
X if(aha_debug)
X printf("abort");
X ccb->host_stat = AHA_ABORTED;
X break;
X
X case AHA_MBI_UNKNOWN:
X ccb = (struct aha_ccb *)0;
X if(aha_debug)
X printf("unknown ccb for abort ");
X /* may have missed it */
X /* no such ccb known for abort */
X
X case AHA_MBI_ERROR:
X break;
X
X default:
X panic("Impossible mbxi status");
X
X }
X if( aha_debug && ccb )
X {
X u_char *cp;
X cp = (u_char *)(&(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 , aha_mbx[unit].mbi[i].stat, i);
X printf("addr = 0x%x\n", ccb);
X }
X }
X if(ccb)
X {
X remove_timeout(ccb);
X aha_done(unit,ccb);
X }
X aha_mbx[unit].mbi[i].stat = AHA_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\***********************************************/
Xaha_free_ccb(unit,ccb, flags)
Xstruct aha_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 = aha_ccb_free[unit];
X aha_ccb_free[unit] = ccb;
X ccb->flags = CCB_FREE;
X if(ccb->sooner || ccb->later)
X {
X printf("yikes, still in timeout queue\n");
X remove_timeout(ccb);
X }
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(&aha_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 aha_ccb *
Xaha_get_ccb(unit,flags)
X{
X unsigned opri;
X struct aha_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 = aha_ccb_free[unit])) && (!(flags & SCSI_NOSLEEP)))
X {
X sleep(&aha_ccb_free[unit], PRIBIO);
X }
X if (rc)
X {
X aha_ccb_free[unit] = aha_ccb_free[unit]->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\***********************************************/
Xaha_done(unit,ccb)
Xstruct aha_ccb *ccb;
X{
X struct scsi_sense_data *s1,*s2;
X struct scsi_xfer *xs = ccb->xfer;
X
X if(scsi_debug & PRINTROUTINES )
X printf("aha_done ");
X /***********************************************\
X * Otherwise, put the results of the operation *
X * into the xfer and call whoever started it *
X \***********************************************/
X if(!(xs->flags & INUSE))
X {
X printf("exiting but not in use! ");
X Debugger();
X }
X if ( ( ccb->host_stat != AHA_OK
X || ccb->target_stat != SCSI_OK)
X && (!(xs->flags & SCSI_ERR_OK)))
X {
X s1 = (struct scsi_sense_data *)(((char *)(&ccb->scsi_cmd))
X + ccb->scsi_cmd_length);
X s2 = &(xs->sense);
X
X if(ccb->host_stat)
X {
X switch(ccb->host_stat)
X {
X case AHA_ABORTED:
X case AHA_SEL_TIMEOUT: /* No response */
X xs->error = XS_TIMEOUT;
X break;
X default: /* Other scsi protocol messes */
X xs->error = XS_DRIVER_STUFFUP;
X if (aha_debug > 1)
X {
X printf("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 (aha_debug > 1)
X {
X printf("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 aha_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/***********************************************\
X* Start the board, ready for normal operation *
X\***********************************************/
Xaha_init(unit)
Xint unit;
X{
X unsigned char ad[3];
X volatile int i,sts;
X struct aha_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(AHA_CTRL_STAT_PORT, AHA_HRST|AHA_SRST);
X
X for (i=0; i < AHA_RESET_TIMEOUT; i++)
X {
X sts = inb(AHA_CTRL_STAT_PORT) ;
X if ( sts == (AHA_IDLE | AHA_INIT))
X break;
X }
X if (i >= AHA_RESET_TIMEOUT)
X {
X if (aha_debug)
X printf("aha_init: No answer from adaptec 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("aha%d reading board settings, ",unit);
X#define PRNT(x)
X#else __386BSD__
X printf("aha%d:",unit);
X#define PRNT(x) printf(x)
X#endif __386BSD__
X aha_cmd(unit,0, sizeof(conf), 0 ,&conf, AHA_CONF_GET);
X switch(conf.chan)
X {
X case CHAN0:
X outb(0x0b, 0x0c);
X outb(0x0a, 0x00);
X aha_dma[unit] = 0;
X PRNT("dma=0 ");
X break;
X case CHAN5:
X outb(0xd6, 0xc1);
X outb(0xd4, 0x01);
X aha_dma[unit] = 5;
X PRNT("dma=5 ");
X break;
X case CHAN6:
X outb(0xd6, 0xc2);
X outb(0xd4, 0x02);
X aha_dma[unit] = 6;
X PRNT("dma=6 ");
X break;
X case CHAN7:
X outb(0xd6, 0xc3);
X outb(0xd4, 0x03);
X aha_dma[unit] = 7;
X PRNT("dma=7 ");
X break;
X default:
X printf("illegal dma jumper setting\n");
X return(EIO);
X }
X switch(conf.intr)
X {
X case INT9:
X aha_int[unit] = 9;
X PRNT("int=9 ");
X break;
X case INT10:
X aha_int[unit] = 10;
X PRNT("int=10 ");
X break;
X case INT11:
X aha_int[unit] = 11;
X PRNT("int=11 ");
X break;
X case INT12:
X aha_int[unit] = 12;
X PRNT("int=12 ");
X break;
X case INT14:
X aha_int[unit] = 14;
X PRNT("int=14 ");
X break;
X case INT15:
X aha_int[unit] = 15;
X PRNT("int=15 ");
X break;
X default:
X printf("illegal int jumper setting\n");
X return(EIO);
X }
X /* who are we on the scsi bus */
X aha_scsi_dev[unit] = conf.scsi_dev;
X
X
X /***********************************************\
X * Initialize memory transfer speed *
X \***********************************************/
X if(!(aha_set_bus_speed(unit)))
X {
X return(EIO);
X }
X
X
X /***********************************************\
X * Initialize mail box *
X \***********************************************/
X
X lto3b(KVTOPHYS(&aha_mbx[unit]), ad);
X
X aha_cmd(unit,4, 0, 0, 0, AHA_MBX_INIT,
X AHA_MBX_SIZE,
X ad[0],
X ad[1],
X ad[2]);
X
X
X /***********************************************\
X * link the ccb's with the mbox-out entries and *
X * into a free-list *
X \***********************************************/
X for (i=0; i < AHA_MBX_SIZE; i++) {
X aha_ccb[unit][i].next = aha_ccb_free[unit];
X aha_ccb_free[unit] = &aha_ccb[unit][i];
X aha_ccb_free[unit]->flags = CCB_FREE;
X aha_ccb_free[unit]->mbx = &aha_mbx[unit].mbo[i];
X lto3b(KVTOPHYS(aha_ccb_free[unit]), aha_mbx[unit].mbo[i].ccb_addr);
X }
X
X /***********************************************\
X * Note that we are going and return (to probe) *
X \***********************************************/
X aha_initialized[unit]++;
X return(0);
X}
X
X
X
X
X/***********************************************\
X* get a passed down ioctl from the subdriver *
X\***********************************************/
Xahaioctl(unit,dev, cmd, arg, mode)
Xdev_t dev;
Xint cmd;
Xcaddr_t arg;
X{
X struct aha_cmd_buf *args;
X union scsi_cmd *scsi_cmd;
X register i,j;
X unsigned int opri;
X int errcode = 0;
X struct absio *absio_kernel;
X unsigned snum;
X int xcount;
X union vfy_io *vfy_io_kernel;
X struct buf *aha_bp1, *aha_bp2;
X
X
X switch(cmd) {
X case A_CMD:
X args = (struct aha_cmd_buf *) arg;
X aha_cmd(unit,args->byte[0], args->byte[1],0, args->byte,
X args->byte[3], args->byte[4], args->byte[5],
X args->byte[6], args->byte[7]);
X ahaintr(unit);
X break;
X }
X return(errcode);
X}
X
X
Xvoid ahaminphys(bp)
Xstruct buf *bp;
X{
X#if !defined(OSF)
X#ifdef MACH
X bp->b_flags |= B_NPAGES; /* can support scat/gather */
X#endif MACH
X/* if(bp->b_bcount > (16 * PAGESIZ)) bp->b_bcount = (16 * PAGESIZ);*/
X/* aha seems to explode with 17 segs (64k may require 17 segs) */
X/* so use a max of 16 segs */
X if(bp->b_bcount > (15 * PAGESIZ)) bp->b_bcount = (15 * PAGESIZ);
X#else /* !defined(OSF) */
X if(bp->b_bcount > 4096) bp->b_bcount = 4096;
X#endif /* !defined(OSF) */
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 aha_scsi_cmd(xs)
Xstruct scsi_xfer *xs;
X{
X struct scsi_sense_data *s1,*s2;
X struct aha_ccb *ccb;
X struct aha_scat_gath *sg;
X int seg; /* scatter gather seg being worked on */
X int i = 0;
X int rc = 0;
X int thiskv;
X int 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
X if(scsi_debug & PRINTROUTINES)
X printf("aha_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(!(flags & INUSE))
X {
X printf("not in use!");
X Debugger();
X xs->flags |= INUSE;
X }
X if(flags & ITSDONE)
X {
X printf("Already done! check device retry code ");
X Debugger();
X xs->flags &= ~ITSDONE;
X }
X if(xs->bp) flags |= (SCSI_NOSLEEP); /* just to be sure */
X if (!(ccb = aha_get_ccb(unit,flags)))
X {
X xs->error = XS_DRIVER_STUFFUP;
X return(TRY_AGAIN_LATER);
X }
X
X if (ccb->mbx->cmd != AHA_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 = AHA_RESET_CCB;
X }
X else
X {
X /* can't use S/G if zero length */
X ccb->opcode = (xs->datalen?
X AHA_INIT_SCAT_GATH_CCB
X :AHA_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->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 lto3b(KVTOPHYS(ccb->scat_gath), ccb->data_addr );
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 while ((datalen) && (seg < AHA_NSEG))
X {
X lto3b(iovp->iov_base,&(sg->seg_addr));
X lto3b(iovp->iov_len,&(sg->seg_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 < AHA_NSEG))
X {
X bytes_this_seg = 0;
X
X /* put in the base address */
X lto3b(thisphys,&(sg->seg_addr));
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) *
X * with the the last, just extend the *
X * 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 lto3b(bytes_this_seg,&(sg->seg_len));
X sg++;
X seg++;
X }
X }
X lto3b(seg * sizeof(struct aha_scat_gath),ccb->data_length);
X if(scsi_debug & SHOWSCATGATH)
X printf("\n");
X if (datalen)
X { /* there's still data, must have run out of segs! */
X printf("aha_scsi_cmd%d: more than %d DMA segs\n",
X unit,AHA_NSEG);
X xs->error = XS_DRIVER_STUFFUP;
X aha_free_ccb(unit,ccb,flags);
X return(HAD_ERROR);
X }
X
X }
X else
X { /* No data xfer, use non S/G values */
X lto3b(0, ccb->data_addr );
X lto3b(0,ccb->data_length);
X }
X lto3b(0, ccb->link_addr );
X /***********************************************\
X * Put the scsi command in the ccb and start it *
X \***********************************************/
X if(!(flags & SCSI_RESET))
X bcopy(xs->cmd, &ccb->scsi_cmd, ccb->scsi_cmd_length);
X if(scsi_debug & SHOWCOMMANDS)
X {
X u_char *b = (u_char *)&ccb->scsi_cmd;
X if(!(flags & SCSI_RESET))
X {
X printf("aha%d:%d:%d-%x,%x,%x,%x,%x,%x-"
X ,unit
X ,ccb->target
X ,ccb->lun
X ,b[0],b[1],b[2]
X ,b[3],b[4],b[5]
X );
X }
X else
X {
X printf("aha%d:%d:%d-RESET- "
X ,unit
X ,ccb->target
X ,ccb->lun
X );
X }
X }
X if (!(flags & SCSI_NOMASK))
X {
X s= splbio(); /* stop instant timeouts */
X add_timeout(ccb,xs->timeout);
X aha_startmbx(ccb->mbx);
X /***********************************************\
X * Usually return SUCCESSFULLY QUEUED *
X \***********************************************/
X splx(s);
X if(scsi_debug & TRACEINTERRUPTS)
X printf("sent ");
X return(SUCCESSFULLY_QUEUED);
X }
X aha_startmbx(ccb->mbx);
X if(scsi_debug & TRACEINTERRUPTS)
X printf("cmd_sent, waiting ");
X /***********************************************\
X * If we can't use interrupts, poll on completion*
X \***********************************************/
X {
X int done = 0;
X int count = delaycount * xs->timeout / AHA_SCSI_TIMEOUT_FUDGE;
X while((!done) && count)
X {
X i=0;
X while ( (!done) && i<AHA_MBX_SIZE)
X {
X if ((aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE )
X && (PHYSTOKV(_3btol(aha_mbx[unit].mbi[i].ccb_addr)
X == (int)ccb)))
X {
X aha_mbx[unit].mbi[i].stat = AHA_MBI_FREE;
X aha_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 aha_abortmbx(ccb->mbx);
X count = delaycount * 2000 / AHA_SCSI_TIMEOUT_FUDGE;
X while((!done) && count)
X {
X i=0;
X while ( (!done) && i<AHA_MBX_SIZE)
X {
X if ((aha_mbx[unit].mbi[i].stat != AHA_MBI_FREE )
X && (PHYSTOKV(_3btol(aha_mbx[unit].mbi[i].ccb_addr)
X == (int)ccb)))
X {
X aha_mbx[unit].mbi[i].stat = AHA_MBI_FREE;
X aha_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 = AHA_MBO_FREE;
X }
X aha_free_ccb(unit,ccb,flags);
X ahaintr(unit);
X xs->error = XS_DRIVER_STUFFUP;
X return(HAD_ERROR);
X }
X ahaintr(unit);
X if(xs->error) return(HAD_ERROR);
X return(COMPLETE);
X
X }
X}
X/***************************************************************\
X* try each speed in turn, when we find one that works, use *
X* the NEXT one for a safety margin, unless that doesn't exist *
X* or doesn't work. returns the nSEC value of the time used *
X* or 0 if it could get a working speed ( or the NEXT speed *
X* failed) *
X\***************************************************************/
X
Xint aha_set_bus_speed(unit)
Xint unit;
X{
X int speed;
X int retval,retval2;
X
X#ifdef EISA
X speed = 0; /* start at the fastest */
X#else EISA
X speed = 1; /* 100 ns can crash some ISA busses (!?!) */
X#endif EISA
X while (1)
X {
X retval = aha_bus_speed_check(unit,speed);
X if(retval == HAD_ERROR)
X {
X printf("no working bus speed!!!\n");
X return(0);
X }
X if(retval == 0)
X {
X speed++;
X }
X else /* Go one slower to be safe */
X { /* unless eisa at 100 ns.. trust it */
X if(speed != 0)
X {
X speed++;
X }
X printf("%d nSEC ok, use ",retval);
X retval2 = aha_bus_speed_check(unit,speed);
X if(retval2 == HAD_ERROR) /* retval is slowest already */
X {
X printf("marginal ");
X retval2 = retval;
X }
X if(retval2)
X {
X printf("%d nSEC ",retval2);
X return(retval2);
X }
X else
X {
X printf(".. slower failed, abort.\n",retval);
X return(0);
X }
X
X }
X }
X}
X
X/***************************************************************\
X* Set the DMA speed to the Nth speed and try an xfer. If it *
X* fails return 0, if it succeeds return the nSec value selected *
X* If there is no such speed return HAD_ERROR. *
X\***************************************************************/
Xstatic struct bus_speed
X{
X char arg;
X int nsecs;
X}bus_speeds[] =
X{
X {0x88,100},
X {0x99,150},
X {0xaa,200},
X {0xbb,250},
X {0xcc,300},
X {0xdd,350},
X {0xee,400},
X {0xff,450}
X};
Xstatic char test_string[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijklmnopqrstuvwxyz!@";
X
Xint aha_bus_speed_check(unit,speed)
Xint unit,speed;
X{
X int numspeeds = sizeof(bus_speeds)/sizeof(struct bus_speed);
X u_char ad[3];
X
X /*******************************************************\
X * Check we have such an entry *
X \*******************************************************/
X if(speed >= numspeeds) return(HAD_ERROR); /* illegal speed */
X
X /*******************************************************\
X * Set the dma-speed *
X \*******************************************************/
X aha_cmd(unit,1, 0, 0, 0, AHA_SPEED_SET,bus_speeds[speed].arg);
X
X /*******************************************************\
X * put the test data into the buffer and calculate *
X * it's address. Read it onto the board *
X \*******************************************************/
X strcpy(aha_scratch_buf,test_string);
X lto3b(KVTOPHYS(aha_scratch_buf),ad);
X
X aha_cmd(unit,3, 0, 0, 0, AHA_WRITE_FIFO, ad[0], ad[1], ad[2]);
X
X /*******************************************************\
X * clear the buffer then copy the contents back from the *
X * board. *
X \*******************************************************/
X bzero(aha_scratch_buf,54); /* 54 bytes transfered by test */
X
X aha_cmd(unit,3, 0, 0, 0, AHA_READ_FIFO, ad[0], ad[1], ad[2]);
X
X /*******************************************************\
X * Compare the original data and the final data and *
X * return the correct value depending upon the result *
X \*******************************************************/
X if(strcmp(test_string,aha_scratch_buf))
X { /* copy failed.. assume too fast */
X return(0);
X }
X else
X { /* copy succeded assume speed ok */
X return(bus_speeds[speed].nsecs);
X }
X}
X
X
X/*
X * +----------+ +----------+ +----------+
X * soonest----->| later |---->| later|---->| later|--->0
X * | [Delta] | | [Delta] | | [Delta] |
X * 0<-----|sooner |<----|sooner |<----|sooner |<----latest
X * +----------+ +----------+ +----------+
X *
X * furtherest = sum(Delta[1..n])
X */
Xadd_timeout(ccb,time)
Xstruct aha_ccb *ccb;
Xint time;
X{
X int timeprev;
X struct aha_ccb *prev;
X int s = splbio();
X
X if(prev = latest) /* yes, an assign */
X {
X timeprev = 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 furtherest = time;
X latest = ccb;
X }
X ccb->sooner = prev;
X prev->later = ccb;
X }
X else
X {
X if( ccb->later = soonest) /* yes, an assign*/
X {
X ccb->later->sooner = ccb;
X ccb->later->delta -= time;
X }
X else
X {
X furtherest = time;
X latest = ccb;
X }
X ccb->delta = time;
X ccb->sooner = (struct aha_ccb *)0;
X soonest = ccb;
X }
X splx(s);
X}
X
Xremove_timeout(ccb)
Xstruct aha_ccb *ccb;
X{
X int s = splbio();
X
X if(ccb->sooner)
X {
X ccb->sooner->later = ccb->later;
X }
X else
X {
X 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 latest = ccb->sooner;
X furtherest -= ccb->delta;
X }
X ccb->sooner = ccb->later = (struct aha_ccb *)0;
X splx(s);
X}
X
X
Xextern int sd_debug;
Xextern int hz;
X#define ONETICK 500 /* milliseconds */
X#define SLEEPTIME ((hz * 1000) / ONETICK)
Xaha_timeout(arg)
Xint arg;
X{
X struct aha_ccb *ccb;
X int unit;
X int s = splbio();
X
X while( ccb = 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("aha%d: device %d timed out ",unit
X ,ccb->xfer->targ);
X
X /***************************************\
X * Unlink it from the queue *
X \***************************************/
X 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 != AHA_MBO_FREE)
X {
X printf("aha%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\n");
X ccb->xfer->retries = 0; /* I MEAN IT ! */
X ccb->host_stat = AHA_ABORTED;
X aha_done(unit,ccb);
X }
X else /* abort the operation that has timed out */
X {
X printf("\n");
X aha_abortmbx(ccb->mbx);
X /* 2 secs for the abort */
X 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 furtherest -= ONETICK;
X break;
X }
X }
X splx(s);
X timeout(aha_timeout,arg,SLEEPTIME);
X}
END-of-i386/isa/aha1542.c
echo x - /dev/MAKEDEV
sed 's/^X//' >/dev/MAKEDEV << 'END-of-/dev/MAKEDEV'
X#!/bin/sh -
X#
X# Copyright (c) 1990 The Regents of the University of California.
X# All rights reserved.
X#
X# Written and contributed by W. Jolitz 12/90
X#
X# Redistribution and use in source and binary forms are permitted provided
X# that: (1) source distributions retain this entire copyright notice and
X# comment, and (2) distributions including binaries display the following
X# acknowledgement: ``This product includes software developed by the
X# University of California, Berkeley and its contributors'' in the
X# documentation or other materials provided with the distribution and in
X# all advertising materials mentioning features or use of this software.
X# Neither the name of the University nor the names of its contributors may
X# be used to endorse or promote products derived from this software without
X# specific prior written permission.
X# THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
X# WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
X# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
X#
X# @(#)MAKEDEV 5.2 (Berkeley) 6/22/90
X#
X# Device "make" file. Valid arguments:
X# std standard devices
X# local configuration specific devices
X#
X# Tapes:
X# wt* QIC-interfaced (e.g. not SCSI) 3M cartridge tape
X# st* "NEW type scsi tapes"
X#
X# Disks:
X# wd* "winchester" disk drives (ST506,IDE,ESDI,RLL,...)
X# fd* "floppy" disk drives (3 1/2", 5 1/4")
X# as* "SCSI" disk/tape/CDROM drives
X# sd* "NEW type scsi disks"
X#
X# Terminal ports:
X# com* standard PC COM ports
X#
X# Pseudo terminals:
X# pty* set of 16 master and slave pseudo terminals
X#
X# Printers:
X#
X# Call units:
X#
X# Special purpose devices:
X# flog* kernel logging device
X#
X
XPATH=/sbin:/bin/:/usr/bin:/usr/sbin:
Xumask 77
Xfor i
Xdo
Xcase $i in
X
Xstd)
X rm -f console drum mem kmdem null tty klog stdin stdout stderr
X mknod console c 0 0
X mknod drum c 4 0 ; chmod 640 drum ; chgrp kmem drum
X mknod kmem c 2 1 ; chmod 640 kmem ; chgrp kmem kmem
X mknod mem c 2 0 ; chmod 640 mem ; chgrp kmem mem
X mknod null c 2 2 ; chmod 666 null
X mknod tty c 1 0 ; chmod 666 tty
X mknod klog c 7 0 ; chmod 600 klog
X mknod stdin c 53 0 ; chmod 666 stdin
X mknod stdout c 53 1 ; chmod 666 stdout
X mknod stderr c 53 2 ; chmod 666 stderr
X rm -f fd/*
X mkdir fd > /dev/null 2>&1
X (cd fd && eval `echo "" | awk ' BEGIN { \
X for (i = 0; i < 64; i++) \
X printf("mknod %d c 53 %d;", i, i)}'`)
X chown -R bin.bin fd
X chmod 555 fd
X chmod 666 fd/*
X ;;
X
Xwt*)
X umask 2
X mknod wt0 b 3 0
X mknod rwt0 c 10 0
X umask 77
X ;;
X
Xst*)
X umask 2 ; unit=`expr $i : '..\(.*\)'`
X case $i in
X st*) name=st; chr=14;;
X esac
X rm -f r$name$unit nr$name$unit er$name$unit enr$name$unit
X case $unit in
X 0|1|2|3|4|5|6)
X mknod r${name}${unit} c $chr `expr $unit '*' 16 + 0`
X mknod nr${name}${unit} c $chr `expr $unit '*' 16 + 1`
X mknod er${name}${unit} c $chr `expr $unit '*' 16 + 2`
X mknod enr${name}${unit} c $chr `expr $unit '*' 16 + 3`
X chgrp operator r${name}${unit} nr${name}${unit} \
X er${name}${unit} enr${name}${unit}
X chmod 640 r${name}${unit} nr${name}${unit} \
X er${name}${unit} enr${name}${unit}
X ;;
X *)
X echo bad unit for tape in: $i
X ;;
X esac
X umask 77
X ;;
X
Xfd*|wd*|as*|sd*)
X umask 2 ; unit=`expr $i : '..\(.*\)'`
X case $i in
X fd*) name=fd; blk=2; chr=9;;
X wd*) name=wd; blk=0; chr=3;;
X as*) name=as; blk=4; chr=13;;
X sd*) name=sd; blk=4; chr=13;;
X esac
X rm -f $name$unit? r$name$unit?
X case $unit in
X 0|1|2|3|4|5|6)
X mknod ${name}${unit}a b $blk `expr $unit '*' 8 + 0`
X mknod ${name}${unit}b b $blk `expr $unit '*' 8 + 1`
X mknod ${name}${unit}c b $blk `expr $unit '*' 8 + 2`
X mknod ${name}${unit}d b $blk `expr $unit '*' 8 + 3`
X mknod ${name}${unit}e b $blk `expr $unit '*' 8 + 4`
X mknod ${name}${unit}f b $blk `expr $unit '*' 8 + 5`
X mknod ${name}${unit}g b $blk `expr $unit '*' 8 + 6`
X mknod ${name}${unit}h b $blk `expr $unit '*' 8 + 7`
X mknod r${name}${unit}a c $chr `expr $unit '*' 8 + 0`
X mknod r${name}${unit}b c $chr `expr $unit '*' 8 + 1`
X mknod r${name}${unit}c c $chr `expr $unit '*' 8 + 2`
X mknod r${name}${unit}d c $chr `expr $unit '*' 8 + 3`
X mknod r${name}${unit}e c $chr `expr $unit '*' 8 + 4`
X mknod r${name}${unit}f c $chr `expr $unit '*' 8 + 5`
X mknod r${name}${unit}g c $chr `expr $unit '*' 8 + 6`
X mknod r${name}${unit}h c $chr `expr $unit '*' 8 + 7`
X chgrp operator ${name}${unit}[a-h] r${name}${unit}[a-h]
X chmod 640 ${name}${unit}[a-h] r${name}${unit}[a-h]
X ;;
X *)
X echo bad unit for disk in: $i
X ;;
X esac
X umask 77
X ;;
X
Xcom*)
X unit=`expr $i : 'com\(.*\)'`
X rm -f com0$unit
X mknod com0$unit c 8 $unit
X ;;
X
Xpty*)
X class=`expr $i : 'pty\(.*\)'`
X case $class in
X 0) offset=0 name=p;;
X 1) offset=16 name=q;;
X 2) offset=32 name=r;;
X 3) offset=48 name=s;;
X# Note that telnetd, rlogind, and xterm (at least) only look at p-s.
X 4) offset=64 name=t;;
X *) echo bad unit for pty in: $i;;
X esac
X case $class in
X 0|1|2|3|4)
X umask 0
X eval `echo $offset $name | awk ' { b=$1; n=$2 } END {
X for (i = 0; i < 16; i++)
X printf("mknod tty%s%x c 5 %d; \
X mknod pty%s%x c 6 %d; ", \
X n, i, b+i, n, i, b+i); }'`
X umask 77
X if [ $class = 1 ]; then
X mv ttyqf ttyv0; mv ptyqf ptyv0
X fi
X ;;
X esac
X ;;
X
Xlocal)
X umask 0
X sh MAKEDEV.local
X ;;
X
Xesac
Xdone
END-of-/dev/MAKEDEV
exit