Path: utzoo!censor!geac!torsqnt!news-server.csri.toronto.edu!cs.utexas.edu!sdd.hp.com!mips!news.cs.indiana.edu!msi.umn.edu!cs.umn.edu!kksys!com50!rosevax!atc!cimcor!mike
From: mike@cimcor.mn.org (Michael Grenier)
Newsgroups: comp.unix.sysv386
Subject: BETA St-01 (p2 of 3)
Message-ID: <1991Jan2.010638.17353@cimcor.mn.org>
Date: 2 Jan 91 01:06:38 GMT
Organization: Scandia Microsystems
Lines: 1176
Submitted-By: mike@cimcor
Archive-Name: st01/part02

#!/bin/sh
# this is st01.02 (part 2 of st01)
# do not concatenate these parts, unpack them in order with /bin/sh
# file scsi.c continued
#
if touch 2>&1 | fgrep 'amc' > /dev/null
 then TOUCH=touch
 else TOUCH=true
fi
if test ! -r shar3_seq_.tmp; then
	echo "Please unpack part 1 first!"
	exit 1
fi
(read Scheck
 if test "$Scheck" != 2; then
	echo "Please unpack part $Scheck next!"
	exit 1
 else
	exit 0
 fi
) < shar3_seq_.tmp || exit 1
echo "x - Continuing file scsi.c"
sed 's/^X//' << 'SHAR_EOF' >> scsi.c &&
X      if (d[unit].xferphys)
X        { /* directly to user space */
X	  if (le > sizeof(rawiobuf))
X	    le=sizeof(rawiobuf);
X          getfromscsi(rawiobuf,le);
X          strlog(0, unit, 0, SL_TRACE, "Read into raw buffer\n");
X          if (copyout(rawiobuf,d[unit].xferbuf,le) == -1) {
X            strlog(0, unit, 1, SL_TRACE, "Copyout failed to transfer into raw buffer \n");
X            return 0;
X	  }
X	} else
X        getfromscsi(d[unit].xferbuf,le);
X    }
X  while ((*cmdport & (STMSG|STCD|STIO|STREQ)) == (0|0|STIO|STREQ))
X    {
X      le=(*scsidataport);
X      for (l=0;l<1000l;l++)
X        if (*cmdport & STREQ)
X          break;
X    }
X  return 1;
X}
X
X/* This is called when we are connected to the target on the scsi bus.
X   This will do any exchange of data with the target.  The dialog is
X   controlled by the target.  This will remain connected until the
X   target sends a disconnect message, the command is complete, or a timeout
X   if encountered. There should be no interrupts while this is executing,
X   as the unit should be connected all the time.  This returns a C* completion
X   status. Normally, this should return quite fast.  This will never sleep
X   and will also be called at interrupt time.  With dumb drives not supporting
X   disconnect (are there any?) this would block the system for the duration
X   of this call.  This will only mark the drive not busy if the command
X   completed successfully.  If an error is returned, the drive has not
X   been marked not busy. */
X
Xstatic int doxfernosleep(unit)
Xint unit;
X{
X  int a;
X  long l;
X
X  for (l=0;l<1000000l || d[unit].xfertimeout == 0;l++)
X    {
X      if (!(*cmdport & STBSY))
X        {
X#ifdef DEBUG
X          strlog(0, unit, 0, SL_ERROR, "scsi: doxfernosleep: !STBSY unit %d\n",unit);
X#endif
X          d[unit].connected=0;
X          return CERROR; /* we are no longer connected??? */
X        }
X      if (!(*cmdport & STREQ))
X        continue; /* loop until target requesting something */
X#ifdef DEBUG1
X      strlog(0, unit, 0, SL_ERROR, "scsi: doxfernosleep: new state=%x\n",*cmdport);
X#endif
X      switch ((*cmdport & (STMSG|STCD|STIO)) & 0xff)
X        {
X          case 0|0|0: /* data out */
X            if (!dataout(unit))
X              {
X                strlog(0, unit, 0, SL_ERROR, "scsi: dataout returned error; unit=%d\n",unit);
X                return CERROR;
X              }
X            break;
X          case 0|0|STIO: /* data in */
X            if (!datain(unit))
X              {
X#ifdef DEBUG
X                strlog(0, unit, 0, SL_ERROR, "scsi: datain returned error; unit=%d\n",unit);
X#endif
X                return CERROR;
X              }
X            break;
X          case 0|STCD|0: /* command out */
X            *scsidataport=(*d[unit].xfercmd++);
X            break;
X          case 0|STCD|STIO: /* status in */
X            d[unit].xferstatus=(*scsidataport);
X            break;
X          case STMSG|STCD|0: /* msg out */
X            /* we should never get here.  We don't want to send a message.
X               Lets just drop attention and hope the drive understands. */
X#ifdef DEBUG0
X            strlog(0, unit, 0, SL_ERROR, "scsi: unexpected msg out state; status=%x\n",*cmdport);
X#endif
X            *scsidataport=MSGNOP; /* send a no-operation message */
X            *cmdport=CMDBASE|CMDENABLE;
X            break;
X          case STMSG|STCD|STIO: /* msg in */
X            a=(*scsidataport) & 0xff;
X            switch (a)
X              {
X                case MSGCOMPLETE:
X                  d[unit].connected=0;
X                  *cmdport=CMDBASE;
X#ifdef DEBUG0
X                  strlog(0, unit, 0, SL_ERROR, "scsi: command complete message received\n");
X#endif
X                  if (d[unit].xferstatus == 0) /* completed succesfully */
X                    {
X                      marknotbusy(unit,COK);
X                      return COK;
X                    }
X                  print_status(unit, d[unit].xferstatus);
X                  return CERROR;
X                case MSGSAVEDATAPTR:
X                  d[unit].savedbuf=d[unit].xferbuf;
X                  d[unit].savedlen=d[unit].xferlen;
X                  break;
X                case MSGRESTOREPTR:
X                  d[unit].xferbuf=d[unit].savedbuf;
X                  d[unit].xferlen=d[unit].savedlen;
X                  d[unit].xfercmd=d[unit].savedcmd;
X                  break;
X                case MSGDISCONNECT:
X                  d[unit].connected=0;
X                  d[unit].xfertime=1;
X                  *cmdport=CMDBASE;
X#ifdef DEBUG0
X                  strlog(0, unit, 0, SL_ERROR, "scsi: disconnected\n");
X#endif
X                  return CDISCONNECT;
X                case MSGMSGREJECT:
X                  break; /* the target rejected some message... Who cares. */
X                case MSGNOP:
X                  break; /* this should not be sent by the target, but... */
X                case MSGIDENTIFY:
X                  break; /* we don't care about targets identify messages */
X                default:
X                  if (a & 0x80)
X                    break; /* assume it is an identify message */
X                  strlog(0, unit, 0, SL_ERROR, "scsi: unknown message received from drive %d: %x\n",
X                         unit,a);
X                  break;
X              }
X            break;
X          default:
X            /* unexpected stack state.  Now I don't know what to do.  Lets
X               hope the drive changes to another state. */
X
X            strlog(0, unit, 0, SL_ERROR, "scsi: unexpected bus state: status=%x\n",*cmdport);
X            break;
X        }
X    }
X  return CTIMEOUT;
X}
X
X/* This implements polled wait for reconnect.  This is mainly used at
X   system initialization time when the interrupt system may not be fully
X   initialized.  This returns true if reconnect was encountered.
X   If there is no successful reconnect, this will time out after a few
X   seconds and return false. */
X
Xstatic int polledwaitreconnect(unit)
Xint unit;
X{
X  long l;
X  unsigned char ch;
X
X  *cmdport=CMDBASE&~CMDENINTR;
X  for (l=0;l<2000000l;l++)
X    {
X      if ((*cmdport & (STSEL|STIO|STBSY)) != (STSEL|STIO|0))
X        continue;
X      ch=(*scsidataport);
X      if (!(ch & MYADDR))
X        {
X#ifdef DEBUG
X          strlog(0, unit, 0, SL_ERROR, "scsi: polled releselection was not for me: %x\n",ch);
X#endif
X          continue;
X        }
X      ch&=~MYADDR;
X      if (!(ch & (1 << unit)))
X        {
X#ifdef DEBUG
X          strlog(0, unit, 0, SL_ERROR, "scsi: reselecting (polled) unit other than expected: %x\n",
X                 ch);
X#endif
X          continue;
X        }
X      *cmdport=(CMDBASE&~CMDENINTR)|CMDBSY|CMDENABLE;
X      for (l=0;l<100000l;l++)
X        if (!(*cmdport & STSEL))
X          break;
X      for (l=0;l<100000l;l++)
X	if (!(*cmdport & STBSY))
X	  break;
X      *cmdport=CMDBASE|CMDENABLE;
X      d[unit].connected=1;
X      return 1;
X    }
X  *cmdport=CMDBASE;
X#ifdef DEBUG
X  strlog(0, unit, 0, SL_ERROR, "scsi: timeout polled wait for reselection from %d\n",unit);
X#endif
X  return 0;
X}
X
X/* This starts the scsi command.  Interrupts may be enabled when this is
X   called.  When this retuns, either the drive must have been marked not
X   busy (error or completion), or the target has disconnected and the drive
X   will be marked not busy when an interrupt or timeout comes.  A failure
X   to mark the drive not busy will block the drive from all future
X   requests.  If retries are made for a command, this will be called to
X   start the retry. */
X
Xstatic int startscsi(unit)
Xint unit;
X{
X  int a;
X
X  d[unit].xferbuf=d[unit].savedbuf=d[unit].origbuf;
X  d[unit].xferlen=d[unit].savedlen=d[unit].origlen;
X  d[unit].xfercmd=d[unit].savedcmd=d[unit].origcmd;
X
X startagain:
X
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: arbitrating for %d\n",unit);
X#endif
X  a=arbitrate(unit);
X  if (a != COK) /* arbitrate does the necessary retries */
X    return a;
X
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: arbitration complete\n");
X#endif
X  while (1)
X    {
X      a=doxfernosleep(unit);
X#ifdef DEBUG0
X      strlog(0, unit, 0, SL_ERROR, "scsi: doxfernosleep returned %d\n",a);
X#endif
X      if (a == CDISCONNECT)
X        { /* The target disconnected */
X          if (d[unit].xferpolled)
X            {
X#ifdef DEBUG0
X              strlog(0, unit, 0, SL_ERROR, "scsi: polled wait\n");
X#endif
X              if (!polledwaitreconnect(unit))
X                goto retry;
X#ifdef DEBUG0
X              strlog(0, unit, 0, SL_ERROR, "scsi: polled wait complete - reconnected\n");
X#endif
X              continue;
X            }
X          if (d[unit].currentbuf)
X            { /* We are doing io for a buffer */
X              /* All we have to do is to return; intr will call iodone. */
X              d[unit].xfertime=1; /* enable timeouts */
X              return CDISCONNECT;
X            }
X
X          /* disconnect; we do not have a buffer but may use intrs */
X          /* This is not too efficient, as the delay from wakeup to
X             continuing execution might be substantial, but this is not
X             a typical case, as transfers do not normally go to
X             internal buffers. */
X          d[unit].xfertime=1; /* enable timeouts */
X          if (sleep(&d[unit].connected,MYSLEEPPRI|PCATCH) == 1)
X            { /* cought a signal */
X              d[unit].busy=0; /* I guess this is an atomic operation */
X              return CERROR;
X            }
X          if (!d[unit].connected)
X            goto retry; /* it must have been a timeout */
X          continue;
X        }
X      if (a == COK || a == CNOCONNECT || a == CBUSBUSY)
X        {
X          if (a != COK)
X            marknotbusy(unit,a);
X          return a;
X        }
X      goto retry;
X    }
X retry:
X  /* a possibly recoverable error was encountered */
X#ifdef DEBUG
X  strlog(0, unit, 0, SL_ERROR, "scsi: startscsi: retrying or failing\n");
X#endif
X  if (d[unit].xferretries > 1)
X    {
X      d[unit].xferretries--;
X      goto startagain;
X    }
X  if (a == CTIMEOUT || a == CBUSBUSY)
X    resetscsibus(); /* in case the drive was hanging on the bus */
X  d[unit].connected=0;
X  *cmdport=CMDBASE;
X  marknotbusy(unit,a);
X  return a; /* too many retries - return error */
X}
X
X/* This executes the given command on the unit.  This returns command status
X   (C* constants).  There is no need to retry the operation after calling
X   this. */
X
Xstatic int doscsicmd(unit,cmd,buf,len,timeout,retries,slow,phys,polled,bp)
Xint unit,    /* drive number */
X    len,     /* buffer size */
X    timeout, /* timeout in 1/10 secs if != 0 */
X    retries, /* number of tries before returning failure; 1=try only once */
X    slow,    /* set to true if slow transfer (only true for read & write) */
X    phys,    /* set to true if xfer directly to/from user space (raw io) */
X    polled;  /* set to true if polled transfer */
Xchar *cmd,   /* command to execute */
X     *buf;   /* transfer buffer address */
Xstruct buf *bp; /* io buffer being executed, or NULL */
X{
X  int x;
X
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: cmd unit=%d buf=%x len=%d timeout=%d retries=%d slow=%d phys=%d polled=%d bp=%x\n",
X         unit,buf,len,timeout,retries,slow,phys,polled,bp);
X#endif
X
X  x=splnointrs();
X  if (d[unit].busy)
X    {
X      if (bp)
X        {
X          splx(x);
X          return CBUSY;
X        }
X      strlog(0, unit, 0, SL_ERROR, "scsi : Sleeping, waiting for idle target\n");
X      while (d[unit].busy)
X        {
X          splx(x);
X          if (sleep(&d[unit].connected,MYSLEEPPRI) == 1)
X            { /* cought a signal */
X              return CERROR;
X            }
X          x=splnointrs();
X        }
X    }
X  d[unit].origbuf=buf;
X  d[unit].origlen=len;
X  d[unit].origcmd=cmd;
X  d[unit].xferslow=slow;
X  d[unit].xferstatus=0x01; /* indicates error */
X  d[unit].xfertimeout=timeout?timeout+1:0;
X  d[unit].xfertime=0;
X  d[unit].xferretries=retries;
X  d[unit].xferphys=phys;
X  d[unit].xferpolled=polled;
X  d[unit].currentbuf=bp;
X  d[unit].busy=1;
X  splx(x);
X
X  return startscsi(unit);
X}
X
Xstatic int dorw(unit,sec,buf,len,flags,polled,bp)
Xint unit;
Xlong sec;
Xchar *buf;
Xint len,flags,polled;
Xstruct buf *bp;
X{
X  char cmd[10];
X  int nblocks,a;
X
X  a=d[unit].blocksize;
X  if (a == 0)
X    a=512;
X  nblocks=(len+a-1)/a;
X
X  strlog(0, unit, 0, SL_TRACE, "scsi: dorw: unit=%d sec=%d buf=%x len=%d flags=%x polled=%d bp=%x\n",
X         unit,sec,buf,len,flags,polled,bp);
X
X  d[unit].scsicmd = cmd[0]=(flags & B_READ)?SCSIREAD:SCSIWRITE;
X  cmd[1]=0x00; /* LU & RADDR */
X  cmd[2]=sec >> 24;
X  cmd[3]=sec >> 16;
X  cmd[4]=sec >> 8;
X  cmd[5]=sec;
X  cmd[6]=0;
X  d[unit].logical_block = sec;
X  cmd[7]=nblocks >> 8;
X  cmd[8]=nblocks;
X  d[unit].num_blocks = nblocks;
X  cmd[9]=0;
X
X  return doscsicmd(unit,cmd,buf,len,RWTIMEOUT,3,0,flags & B_PHYS,polled,bp);
X}
X
X/* This starts an io operation on the given buffer.  This is called when
X   a new buffer is added to the io queue, and when a previous operation has
X   completed, to start io on the next buffer.  If the unit is busy, this will
X   do nothing.  If it is not busy, this will start the request.  This should
X   be called with splnointrs.  Any routines called by this will not change
X   the interrupt level to a lower value. */
X
Xstatic int startbufferio(unit,bp)
Xint unit;
Xstruct buf *bp;
X{
X  return dorw(unit,BLPTOSEC(unit,PARTNO(minor(bp->b_dev)),bp->b_blkno),
X       bp->b_un.b_addr,bp->b_bcount,bp->b_flags,0,bp);
X}
X
X/* This will start a pending io request in the system.  If bp (the previous
X   request) is non-NULL, this will first remove bp from the list of
X   pending requests.  This will then start a new request if there are any.
X   This can only be called with splnointrs, and when the unit is not busy. */
X
Xstatic startpendingreq(unit,bp)
Xint unit;
Xstruct buf *bp;
X{
X  struct buf *ap;
X  int x;
X
X  x=splnointrs();
X  if (bp)
X    {
X      ap=bp->av_forw;
X      if (!ap)
X        if (d[unit].reqlist != bp)
X          ap=d[unit].reqlist;
X    }
X   else
X    ap=d[unit].reqlist;
X  /* ap is the next request to process, or NULL if there are none pending. */
X  if (bp)
X    {
X      if (bp == d[unit].reqlist)
X        d[unit].reqlist=bp->av_forw;
X      if (bp->av_back)
X        bp->av_back->av_forw=bp->av_forw;
X      if (bp->av_forw)
X        bp->av_forw->av_back=bp->av_back;
X      bp->av_forw=NULL;
X      bp->av_back=NULL;
X      /* bp has now been removed from the list of requests. */
X    }
X
X  if (ap) /* start the next pending request if there are any */
X    startbufferio(unit,ap);
X
X  splx(x);
X}
X
X/* This marks the unit not busy.  This is used to mark the completion
X   of a command.  This must absolutely be called exactly once for each and
X   every i/o request made.  If the request was for an io buffer, this will
X   set b_flags&B_ERROR according to the completion; COK marks good completion.
X   If there are any processes sleeping for the drive to become not busy,
X   this will wake them up.  If there is any pending block io, this will
X   start i/o for the next buffer.  After a call to this, all data in the
X   d[unit] structure for the previous request will have been lost and the
X   next operation may be in progress. The scsi driver and controller should
X   be set to bus free phase before calling this. */
X
Xstatic marknotbusy(unit,completion)
Xint unit,completion;
X{
X  int x;
X  struct buf *ap;
X
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: marknotbusy unit=%d completion=%d\n",
X         unit,completion);
X#endif
X  x=splnointrs();
X  d[unit].busy=0;
X  d[unit].connected=0; /* just in case */
X  d[unit].xfertime=0; /* we don't want any timeouts any more */
X  ap=d[unit].currentbuf;
X  if (ap)
X    {
X      if (completion != COK)
X        ap->b_flags|=B_ERROR;
X    }
X   else
X    if (!d[unit].xferpolled)
X      wakeup(&d[unit].connected);
X  startpendingreq(unit,ap); /* This will start any pending io */
X  if (ap)
X    iodone(ap);
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: marknotbusy returning\n");
X#endif
X  splx(x);
X}
X
X/* This is the scsi interrupt service routine.  This is called with a priority
X   lower than that of the timer tick, which is used to detect timeouts.
X   This is called (this ignores other calls) when a target is reselecting this
X   initiator.  This will continue processing the reconnected request, and
X   if the request completes, this will (in lower-level routines) start the
X   next request automatically. */
X
Xscsiintr()
X{
X  int a,x,unit;
X  long l;
X  /* beg M000 */
X  static long error_count = 0L;
X  static int error_delta = 1;
X  /* end M000 */
X
X  if (!(*cmdport & STSEL))
X    {
X#ifdef DEBUG0
X      strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (no SEL)\n");
X#endif
X      return; /* The controller should only generate interrupts when select
X                 rises. */
X    }
X  for (l=0;l<10000l;l++)
X    if (*cmdport & STIO)
X      goto gotio;
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (IO timeout)\n");
X#endif
X  return;
X gotio:
X  a=(*scsidataport) & 0xff;
X  if (!(a & MYADDR))
X    {
X#ifdef DEBUG
X      strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (not my addr); addr=%x\n",a);
X#endif
X      return;
X    }
X  a&=(~MYADDR);
X  for (unit=0;unit < 8;unit++)
X    if (a & (unsigned char)(1<<unit))
X      break;
X  if (unit >= 8 || (a & ~(unsigned char)(1<<unit)))
X    {
X#ifdef DEBUG
X      strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (invalid id); unit=%d a=%x\n",unit,a);
X#endif
X      return;
X    }
X  if (unit >= SCSIMAXDRIVES)
X    {
X#ifdef DEBUG
X      strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (unit %d >= SCSIMAXDRIVES %d)\n",
X             unit,SCSIMAXDRIVES);
X#endif
X      return;
X    }
X  x=splnointrs();
X  if (d[unit].connected || !d[unit].busy)
X    {
X#ifdef DEBUG
X      /* beg M000 */
X      if (!(++error_count%error_delta)) {
X		error_delta *= 2;
X      		strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (internal state): unit=%d connected=%d busy=%d (%ld/%d)\n",
X             	unit,d[unit].connected,d[unit].busy,error_count,error_delta);
X      }
X      /* end M000 */
X#endif
X      splx(x);
X      return;
X    }
X  if (d[unit].xferpolled)
X    { /* ooops... This is not the way it was supposed to happen... */
X#ifdef DEBUG
X      /* beg M000 */
X      if (!(++error_count%error_delta)) {
X		error_delta *= 2;
X      		strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (xfer is polled); unit=%d (%ld/%d)\n",
X		unit,error_count,error_delta);
X      }
X      /* end M000 */
X#endif
X      splx(x);
X      return;
X    }
X  *cmdport=CMDBASE|CMDBSY|CMDENABLE; /* acknowledge reselection */
X  for (l=0;l<10000l;l++)
X    if (!(*cmdport & STSEL))
X      goto selreleased;
X  /* timeout waiting for sel to be released */
X  *cmdport=CMDBASE;
X#ifdef DEBUG
X  strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (timeout waiting for sel to be released); unit=%d\n",
X         unit);
X#endif
X  splx(x);
X  return;
X selreleased:
X  for (l=0;l<10000l;l++)
X    if (*cmdport & STBSY)
X      goto selectedandhavebsy;
X  /* timeout waiting for sel to be released */
X  *cmdport=CMDBASE;
X#ifdef DEBUG
X  strlog(0, unit, 0, SL_ERROR, "scsi: intr ignored (timeout waiting for bsy after sel to be released); unit=%d\n",
X         unit);
X#endif
X  splx(x);
X  return;
X selectedandhavebsy:
X  *cmdport=CMDBASE|CMDENABLE;
X  d[unit].connected=1;
X  d[unit].xfertime=0;
X  intrserviced=1;
X  splx(x); /* allow timer ticks */
X  if (d[unit].currentbuf)
X    {
X      a=doxfernosleep(unit);
X      d[unit].connected=0; /* just in case */
X      if (a != COK && a != CDISCONNECT)
X            {
X              strlog(0, unit, 0, SL_ERROR, "scsi: intr: cmd failed (%d); returning error\n",a);
X              *cmdport=CMDBASE;
X              marknotbusy(unit,a); /* This may start a new operation */
X            }
X    }
X   else
X    { /* it must be an interrupt-driven operation to an internal buffer */
X      wakeup(&d[unit].connected);
X      /* leave the connected indicator on, and do no further processing
X         here.  This will signal the sleeping operation that we are once
X         again connected. */
X    }
X  intrserviced=0;
X  return;
X}
X
X/* This is called using timeout() every 1/10th of a second.  This is used
X   to solve timeout conditions related to lost interrupts and the like.
X   Note that this is usually entered with a priority higher than that of
X   the scsi driver.  splnointrs should be defined so that this interrupt
X   is also masked out.  There may also be a drawback in using splnointrs:
X   if the system clock is incremented with these timer interrupts, it might
X   lose some ticks when the scsi disk is being used.  I hope Microport has
X   implemented the system clock in some more clever way.  */
X
Xscsitick()
X{
X  int a,unit,x;
X
X  x=splnointrs();
X  if (!intrserviced) /* if in the middle of a scsi interrupt, do nothing */
X    {
X      for (unit=0;unit<SCSIMAXDRIVES;unit++)
X        {
X          if (!d[unit].blocksize || !d[unit].busy || d[unit].connected || d[unit].xfertime == 0 ||
X              d[unit].xfertimeout == 0 || d[unit].xferpolled)
X            continue;
X          d[unit].xfertime++;
X          if (d[unit].xfertime < d[unit].xfertimeout)
X            continue;
X          /* the timeout has elapsed.  We can only assume that we have lost an
X             interrupt or there are problems on the target which prevent it from
X             reconnecting and completing the command. */
X          d[unit].xfertime=0; /* will be reset in retry if appropriate */
X          if (!d[unit].currentbuf)
X            { /* interrupt-driven transter to local buffer */
X              strlog(0, unit, 0, SL_ERROR, "scsi: local intr driven xfer woken up by timer tick; unit=%d\n",
X                     unit);
X              wakeup(&d[unit].connected); /* !connected tells it to retry */
X              continue;
X            }
X          a=COK;  /* was CTIMEOUT - this will now disable retries */
X         retrytickforbuf:
X          if (a == COK || a == CDISCONNECT)
X            continue;
X          if (d[unit].xferretries == 0 || a == CBUSBUSY || a == CNOCONNECT)
X            {
X              strlog(0, unit, 0, SL_ERROR, "scsi: block xfer fails in timer tick; unit=%d, err=%d\n",
X                     unit,a);
X              marknotbusy(unit,a); /* This may start a new operation */
X              continue;
X            }
X          d[unit].xferretries--;
X          strlog(0, unit, 0, SL_ERROR, "scsi: TIMEOUT : xfer retried in timer tick; unit=%d, err=%d\n",
X                 unit,a);
X          a=startscsi(unit);  /* NO!!!!! */
X          goto retrytickforbuf;
X        }
X    }
X  timeout(scsitick,0,HZ);
X  splx(x);
X}
X
X/* This is the normal strcpy */
X
Xstatic strcpy(d,s)
Xchar *d,*s;
X{
X  while (*s)
X    *d++=(*s++);
X  *d=0;
X}
X
X/* This implements the request sense command.  This returns a C* status. */
X
Xstatic int requestsense(unit,buf,len,polled)
Xint unit,len,polled;
Xchar *buf;
X{
X  char cmd[6];
X
X  if (len > 18)
X    len=18;
X  cmd[0]=SCSIREQSENSE;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X  cmd[4]=len; /* Length of 0 forces non-extended sense information */
X  cmd[5]=0;
X
X  return doscsicmd(unit,cmd,buf,len,2,3,1,0,polled,NULL);
X}
X
X
X/* This implements the request sense command.  This returns a C* status. */
X
Xstatic int reassign(unit,bad_block)
Xint unit, bad_block;
X{
X  char cmd[6];
X  static rbuf[8];
X
X  cmd[0]=SCSIREASSIGN;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X  cmd[4]=0; /* Length of 0 forces non-extended sense information */
X  cmd[5]=0;
X
X  rbuf[0] = 0;
X  rbuf[1] = 0;
X  rbuf[2] = 0;
X  rbuf[3] = 4;  /* 4 bytes in defect list */
X  
X  /* Defect list follows containing only one defect */
X
X  rbuf[4] = bad_block >> 24;
X  rbuf[5] = (bad_block >> 16) & 0xff;
X  rbuf[6] = (bad_block >> 8) & 0xff;
X  rbuf[7] = bad_block & 0xff;
X
X  return doscsicmd(unit,cmd,rbuf,8,200,1,1,0, 1 /* Polled */,NULL);
X}
X
X/* This tests for drive readyness (with the scsi test unit ready command).
X   This returns a C* status. */
X
Xstatic int testready(unit)
Xint unit;
X{
X  char cmd[6];
X
X  cmd[0]=SCSITESTREADY;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X  cmd[4]=0;
X  cmd[5]=0;
X
X  return doscsicmd(unit,cmd,NULL,0,1,1,1,0,1,NULL);
X}
X
X/* This issues the inquiry command to the scsi drive to get its drive type
X   and other characteristics.  This returns a C* status. */
X
Xstatic int doinquiry(unit,buf,len,polled)
Xint unit,len,polled;
Xchar *buf;
X{
X  char cmd[6];
X
X  if (len > 36)
X    len=36;
X  cmd[0]=SCSIINQUIRY;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X  cmd[4]=len;
X  cmd[5]=0;
X  return doscsicmd(unit,cmd,buf,len,150,3,1,0,polled,NULL);
X    /* the timeout is quite long to allow time for startup */
X}
X
X/* This reads the storage capacity and block size of the scsi drive */
X
Xstatic int readcapacity(unit,buf,len,polled)
Xint unit,len,polled;
Xchar *buf;
X{
X  char cmd[10];
X
X  if (len > 8)
X    len=8;
X
X  cmd[0]=SCSIREADCAPACITY;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X  cmd[4]=0;
X  cmd[5]=0;
X  cmd[6]=0;
X  cmd[7]=0;
X  cmd[8]=0;
X  cmd[9]=0;
X
X  if (doscsicmd(unit,cmd,buf,len,150,2,1,0,polled,NULL) != COK)
X    return 0; /* the timeout period is quite long to allow time for startup */
X  return 1;
X}
X
X/* This is used to initialize the drive at system startup time */
X
Xstatic initdrive(unit)
Xint unit;
X{
X  int a,bs;
X  char buf[100];
X  long s,l;
X  unsigned char *cp;
X
X  d[unit].blocksize=0;
X  d[unit].busy=0;
X  d[unit].connected=0;
X  d[unit].nparts=0;
X  d[unit].nomsgs=0;
X
X  a=testready(unit);
X  if (a != COK)
X    {
X      if (a != CERROR && a != CBUSY)
X        return 0;  /* no point in waiting */
X      printf("Waiting for unit %d powerup...\n",unit);
X      for (l=0;l<10000000l;l++)
X        if (l % 100000l == 0)
X          {
X            a=testready(unit);
X            if (a == COK)
X              break;
X          }
X      if (a != COK)
X        {
X          printf("Powerup timeout on drive %d\n",unit);
X          return 0;
X        }
X    }
X  a=requestsense(unit,buf,sizeof(buf),1);
X  if (a == CNOCONNECT || a == CBUSBUSY)
X    return 0;
X  if (a != COK)
X    {
X      printf("scsi drive %d is not responding properly.\n",unit);
X      return 0;
X    }
X#ifdef DEBUG0
X  printf("scsi: initdrive: requestsense ok\n");
X#endif
X  a=doinquiry(unit,buf,sizeof(buf),1);
X  if (a != COK)
X    {
X      printf("scsi drive %d: inquiry failed.\n",unit);
X      return 0;
X    }
X#ifdef DEBUG0
X  printf("scsi: initdrive: doinquiry ok\n");
X#endif
X  if (buf[0] != 0)
X    {
X      printf("scsi drive %d is on a direct access device\n",unit);
X      return 0;
X    }
X  buf[buf[4]+6]=0;
X  strcpy(d[unit].drivename,buf+8);
X  if (!readcapacity(unit,buf,sizeof(buf),1))
X    {
X      d[unit].capacity=0;
X      bs=d[unit].blocksize=512;
X      printf("scsi drive %d: cannot read capacity\n",unit);
X    }
X   else
X    {
X      bs=d[unit].blocksize=((unsigned char)buf[6]<<8)+(unsigned char)buf[7];
X      if (bs > BSIZE)
X        printf("scsi drive %d: blocksize=%d BSIZE=%d not supported\n",
X               unit,bs,BSIZE);
X      d[unit].capacity=(long)((unsigned char)buf[0]<<24)+
X                       (long)((unsigned char)buf[1]<<16)+
X                       (long)((unsigned char)buf[2]<<8)+
X                       (long)((unsigned char)buf[3]);
X    }
X  printf("scsi drive %d: %ldM (%d byte sectors): %s\n",
X         unit,(d[unit].capacity*d[unit].blocksize+524288l)/1048576l,
X         d[unit].blocksize,d[unit].drivename);
X  a=dorw(unit,0l,buf,sizeof(buf),B_READ,1,NULL);
X  if (a != COK)
X    {
X      printf("scsi drive %d: could not read partition table\n",unit);
X      return 0;
X    }
X  for (cp=(unsigned char *)buf,a=0;
X       a<SCSIMAXPARTS-1 &&
X        (cp[0] || cp[1] || cp[2] || cp[3] || cp[4] || cp[5]);
X       a++,cp+=6)
X    {
X      s=(long)(cp[0]<<16)+(cp[1]<<8)+cp[2];
X      l=(long)(cp[3]<<16)+(cp[4]<<8)+cp[5];
X      if (s == 0)
X        {
X          s++;
X          l--;
X        }
X      d[unit].parts[a].start=s;
X      d[unit].parts[a].len=l;
X      if (a == 0)
X        printf("partitions:");
X      printf(" %ldM",(l*bs+524288l)/1048576l);
X    }
X  if (a != 0)
X    printf("\n");
X  d[unit].nparts=a;
X  d[unit].parts[SCSIMAXPARTS-1].start=0;
X  d[unit].parts[SCSIMAXPARTS-1].len=d[unit].capacity;
X  return 1;
X}
X
Xscsiinit()
X{
X  int a;
X  extern char *sptalloc();
X
X  printf("\n%s\n",COPYRIGHT);
X  if (!baseaddr)
X    baseaddr=sptalloc(SCSISIZE/PAGESIZE,PG_P,(int)(SCSIBASE/PAGESIZE),
X                      NOSLEEP);
X  if (!baseaddr)
X    {
X      printf("scsi driver error: could not sptalloc controller memory\n");
X      return;
X    }
X  cmdport=baseaddr+SCSICONTROLOFS;
X  scsidataport=baseaddr+SCSIDATAOFS;
X
X  timeouting=0;
X  for (a=0;a<SCSIMAXDRIVES;a++)
X    {
X      d[a].currentbuf=NULL;
X      d[a].reqlist=NULL;
X    }
X  resetscsibus();
X  for (a=0;a<SCSIMAXDRIVES;a++)
X    {
X      initdrive(a);
X    }
X  printf("\n");
X}
X
Xscsiopen(dev,flags)
Xdev_t dev;
Xint flags;
X{
X  int unit=UNITNO(minor(dev)),
X      part=PARTNO(minor(dev)),
X      x;
X
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsiopen: unit=%d part=%d\n",unit,part);
X#endif
X  if (!timeouting)
X    {
X      x=splnointrs(); /* in case scsitick makes any assumptions about spl */
X      scsitick();
X      splx(x);
X      timeouting=1;
X    }
X  if (unit >= SCSIMAXDRIVES ||
X      (part != SCSIMAXPARTS-1 &&
X       (d[unit].blocksize == 0 || part >= d[unit].nparts)))
X    u.u_error=ENXIO;
X}
X
Xscsiclose()
X{
X#ifdef DEBUG0
X  strlog(0, unit, 0, SL_ERROR, "scsiclose called\n");
X#endif
X  /* do nothing */
X}
X
X
Xscsiprint()
X{
X#ifdef DEBUG
X  strlog(0, unit, 0, SL_ERROR, "scsiprint called\n");
X#endif
X  /* do nothing */
X}
X
Xscsistrategy(bp)
Xstruct buf *bp;
X{
X  int unit=UNITNO(minor(bp->b_dev)),
X      part=PARTNO(minor(bp->b_dev)),
X      nsecs,x;
X  long sec;
X  struct buf *ap,**app;
X
X  strlog(0, unit, 0, SL_TRACE, "scsistrategy: unit=%d part=%d b_dev=%x b_bcount=%d b_blkno=%d b_flags=%x\n",
X         unit,part,bp->b_dev,bp->b_bcount,bp->b_blkno,bp->b_flags);
X
X  if (unit >= SCSIMAXDRIVES || d[unit].blocksize == 0 ||
X      bp->b_bcount % d[unit].blocksize != 0)
X    {
X      bp->b_flags|=B_ERROR;
X      bp->b_resid=bp->b_bcount;
X      iodone(bp);
X      return;
X    }
X  if (part == SCSIMAXPARTS-1)
X    sec=BLTOSEC(unit,bp->b_blkno);
X   else
X    {
X      sec=BLTOSEC(unit,bp->b_blkno);
X      if (part >= d[unit].nparts || sec > d[unit].parts[part].len)
X        {
X          bp->b_flags|=B_ERROR;
X          bp->b_resid=bp->b_bcount;
X          iodone(bp);
X          return;
X        }
X      if (sec == d[unit].parts[part].len)
X        {
X          bp->b_resid=bp->b_bcount;
X          iodone(bp);
X          return;
X        }
X      nsecs=(bp->b_bcount+d[unit].blocksize-1)/d[unit].blocksize;
X      if (sec+nsecs > d[unit].parts[part].len)
X        {
X          nsecs=d[unit].parts[part].len-sec;
X          bp->b_resid=bp->b_bcount-nsecs*d[unit].blocksize;
X        }
X       else
X        bp->b_resid=0;
X      sec+=d[unit].parts[part].start;
X    }
X
X  if (bp->b_flags & B_PHYS) {   /* raw read/write request */
X    /* We do the command immediately, this will actually sleep          */
X    /* down the call tree in doscsicmd()                                */
X
X    if (dorw(unit,BLPTOSEC(unit,PARTNO(minor(bp->b_dev)),bp->b_blkno),
X       bp->b_un.b_addr,bp->b_bcount,bp->b_flags,
X       0 /* Not polled */, 
X       0 /* No current buffer! transfer done in user context */) != COK) {
X      bp->b_flags|=B_ERROR;
X      bp->b_resid=bp->b_bcount;
X    }      
X    iodone(bp);
X    return;
X  }
X
X
X  x=splnointrs();
X
X  /* Place on queue for this unit */
X
X  for (app=(&d[unit].reqlist),ap=NULL;
X       *app;
X       ap=(*app),app=(&(*app)->av_forw))
X    {
X      if (sec < BLPTOSEC(unit,part,(*app)->b_blkno))
X        {
X          bp->av_back=ap;
X          (*app)->av_back=bp;
X          bp->av_forw=(*app);
X          *app=bp;
X          goto haveinserted;
X        }
X    }
X  *app=bp;
X  bp->av_forw=NULL;
X  bp->av_back=ap;
X haveinserted:
X  if (!d[unit].busy)
X    startbufferio(unit,bp);
X  splx(x);
X}
X
X/* raw io read on the device */
X
Xscsiread(dev)
Xint dev;
X{
X  strlog(0, minor(dev), 0, SL_TRACE, "scsiread on unit %d\b", UNITNO(minor(dev)));
X  physio(scsistrategy,NULL,dev,B_READ); 
X}
X
X/* raw io write on the device */
X
Xscsiwrite(dev)
Xint dev;
X{
X  strlog(0, minor(dev), 0, SL_TRACE, "scsiwrite on unit %d\b", UNITNO(minor(dev)));
X  physio(scsistrategy,NULL,dev,B_WRITE);
X}
X
X/* This formats the entire scsi drive. */
X
Xstatic int formatscsidrive(unit,blocksize,interleave)
Xint unit,blocksize,interleave;
X{
X  char cmd[10],buf[30];
X
X  if (blocksize == 0)
X    blocksize=512;
X  printf("scsi: formatting unit %d with blocksize=%d, interleave=%d\n",
X         unit,blocksize,interleave);
X
X  cmd[0]=SCSIMODESELECT;
X  cmd[1]=0;
X  cmd[2]=0;
X  cmd[3]=0;
X/*   cmd[4]=12; /* Parameter length */
X  cmd[4]=12+16; /* Parameter length with read ahead enabled */
X  cmd[5]=0;
X
X  buf[0]=0;
X  buf[1]=0;
X  buf[2]=0;
X  buf[3]=8;
X  buf[4]=0;
X  buf[5]=0;
X  buf[6]=0;
X  buf[7]=0;
X  buf[8]=0;
X  buf[9]=blocksize>>16;
X  buf[10]=blocksize>>8;
X  buf[11]=blocksize;
X
X  /* Enable read ahead */
X
X  buf[12] = 0x38; /* Page code */
X  buf[13] = 14; /* Size of Page 38 structure which follows */
X  buf[14] = 0x11; /* Turn on cache */
SHAR_EOF
echo "End of st01 part 2"
echo "File scsi.c is continued in part 3"
echo "3" > shar3_seq_.tmp
exit 0