mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-20 11:11:24 +00:00
Code Issues Releases Activity
67f5dcad6b
freebsd/sys/i386/isa/ft.c
Paul Richards d091793974 Ran ft.c through ident. 
Added a missing #ifdef INET wrapper in lpt.c

Main change:
	Removed the timeout_func_t casts from timeout calls and
	correctly defined the timeout routines to conform to
	the new format.
lpt.c doesn't have this change.

Reviewed by:
Submitted by:
1994-08-23 07:52:29 +00:00

2185 lines
56 KiB
C
Raw Blame History

/*
* Copyright (c) 1993 Steve Gerakines
*
* This is freely redistributable software. You may do anything you wish with
* it, so long as the above notice stays intact.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
* NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ft.c - QIC-40/80 floppy tape driver $Id: ft.c,v 1.9 1994/08/21 20:16:14 paul
* Exp $
*
*
* 01/26/94 v0.3b - Jim Babb Got rid of the hard coded device selection. Moved
* (some of) the static variables into a structure for support of multiple
* devices. ( still has a way to go for 2 controllers - but closer ) Changed
* the interface with fd.c so we no longer 'steal' it's driver routine
* vectors.
*
* 10/30/93 v0.3 Fixed a couple more bugs. Reading was sometimes looping when
* an an error such as address-mark-missing was encountered. Both reading
* and writing was having more backup-and-retries than was necessary. Added
* support to get hardware info. Updated for use with FreeBSD.
*
* 09/15/93 v0.2 pl01 Fixed a bunch of bugs: extra isa_dmadone() in
* async_write() (shouldn't matter), fixed double buffering in async_req(),
* changed tape_end() in set_fdcmode() to reduce unexpected interrupts,
* changed end of track processing in async_req(), protected more of
* ftreq_rw() with an splbio(). Changed some of the ftreq_*() functions so
* that they wait for inactivity and then go, instead of aborting
* immediately.
*
* 08/07/93 v0.2 release Shifted from ftstrat to ioctl support for I/O.
* Streaming is now much more reliable. Added internal support for error
* correction, QIC-40, and variable length tapes. Random access of segments
* greatly improved. Formatting and verification support is close but still
* incomplete.
*
* 06/03/93 v0.1 Alpha release Hopefully the last re-write. Many bugs fixed,
* many remain.
*
* $Id: ft.c,v 1.9 1994/08/21 20:16:14 paul Exp $
*/
#include "ft.h"
#if NFT > 0
#include "fd.h"
#include <sys/param.h>
#include <sys/dkbad.h>
#include <sys/systm.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/ftape.h>
#include <machine/pio.h>
#include <i386/isa/isa_device.h>
#include <i386/isa/fdreg.h>
#include <i386/isa/fdc.h>
#include <i386/isa/icu.h>
#include <i386/isa/rtc.h>
#include <i386/isa/ftreg.h>
/* Enable or disable debugging messages. */
#define FTDBGALL 0 /* everything */
/* #define DPRT(a) printf a */
#define DPRT(a)
/* Constants private to the driver */
#define FTPRI (PRIBIO)/* sleep priority */
/* The following items are needed from the fd driver. */
extern int in_fdc(int); /* read fdc registers */
extern int out_fdc(int, int); /* write fdc registers */
extern int hz; /* system clock rate */
/* Type of tape attached */
/* use numbers that don't interfere with the possible floppy types */
#define NO_TYPE 0 /* (same as NO_TYPE in fd.c) */
/* F_TAPE_TYPE must match value in fd.c */
#define F_TAPE_TYPE 0x020 /* bit for ft->types to indicate tape */
#define FT_MOUNTAIN (F_TAPE_TYPE | 1)
#define FT_COLORADO (F_TAPE_TYPE | 2)
/* Mode FDC is currently in: tape or disk */
enum {
FDC_TAPE_MODE, FDC_DISK_MODE
};
/* Command we are awaiting completion of */
enum {
FTCMD_NONE, FTCMD_RESET, FTCMD_RECAL, FTCMD_SEEK, FTCMD_READID
};
/* Tape interrupt status of current request */
enum {
FTSTS_NONE, FTSTS_SNOOZE, FTSTS_INTERRUPT, FTSTS_TIMEOUT
};
/* Tape I/O status */
enum {
FTIO_READY, /* No I/O activity */
FTIO_READING, /* Currently reading blocks */
FTIO_RDAHEAD, /* Currently reading ahead */
FTIO_WRITING /* Buffers are being written */
};
/* Current tape mode */
enum {
FTM_PRIMARY, /* Primary mode */
FTM_VERIFY, /* Verify mode */
FTM_FORMAT, /* Format mode */
FTM_DIAG1, /* Diagnostic mode 1 */
FTM_DIAG2 /* Diagnostic mode 2 */
};
/* Tape geometries table */
QIC_Geom ftgtbl[] = {
{0, 0, "Unformatted", "Unknown", 0, 0, 0, 0, 0}, /* XXX */
{1, 1, "QIC-40", "205/550", 20, 68, 2176, 128, 21760},
{1, 2, "QIC-40", "307.5/550", 20, 102, 3264, 128, 32640},
{1, 3, "QIC-40", "295/900", 0, 0, 0, 0, 0}, /* ??? */
{1, 4, "QIC-40", "1100/550", 20, 365, 11680, 128, 32512},
{1, 5, "QIC-40", "1100/900", 0, 0, 0, 0, 0}, /* ??? */
{2, 1, "QIC-80", "205/550", 28, 100, 3200, 128, 19200},
{2, 2, "QIC-80", "307.5/550", 28, 150, 4800, 128, 19200},
{2, 3, "QIC-80", "295/900", 0, 0, 0, 0, 0}, /* ??? */
{2, 4, "QIC-80", "1100/550", 28, 537, 17184, 128, 32512},
{2, 5, "QIC-80", "1100/900", 0, 0, 0, 0, 0}, /* ??? */
{3, 1, "QIC-500", "205/550", 0, 0, 0, 0, 0}, /* ??? */
{3, 2, "QIC-500", "307.5/550", 0, 0, 0, 0, 0}, /* ??? */
{3, 3, "QIC-500", "295/900", 0, 0, 0, 0, 0}, /* ??? */
{3, 4, "QIC-500", "1100/550", 0, 0, 0, 0, 0}, /* ??? */
{3, 5, "QIC-500", "1100/900", 0, 0, 0, 0, 0} /* ??? */
};
#define NGEOM (sizeof(ftgtbl) / sizeof(QIC_Geom))
QIC_Geom *ftg = NULL; /* Current tape's geometry */
/*
* things relating to asynchronous commands
*/
static int astk_depth; /* async_cmd stack depth */
static int awr_state; /* state of async write */
static int ard_state; /* state of async read */
static int arq_state; /* state of async request */
static int async_retries; /* retries, one per invocation */
static int async_func; /* function to perform */
static int async_state; /* state current function is at */
static int async_arg[5]; /* up to 5 arguments for async cmds */
static int async_ret; /* return value */
/* List of valid async (interrupt driven) tape support functions. */
enum {
ACMD_NONE, /* no command */
ACMD_SEEK, /* command seek */
ACMD_STATUS, /* report status */
ACMD_STATE, /* wait for state bits to be true */
ACMD_SEEKSTS, /* perform command and wait for status */
ACMD_READID, /* read id */
ACMD_RUNBLK /* ready tape for I/O on the given block */
};
/* Call another asyncronous command from within async_cmd(). */
#define CALL_ACMD(r,f,a,b,c,d,e) \
astk[astk_depth].over_retries = async_retries; \
astk[astk_depth].over_func = async_func; \
astk[astk_depth].over_state = (r); \
for (i = 0; i < 5; i++) \
astk[astk_depth].over_arg[i] = async_arg[i]; \
async_func = (f); async_state = 0; async_retries = 0; \
async_arg[0]=(a); async_arg[1]=(b); async_arg[2]=(c); \
async_arg[3]=(d); async_arg[4]=(e); \
astk_depth++; \
goto restate
/* Perform an asyncronous command from outside async_cmd(). */
#define ACMD_FUNC(r,f,a,b,c,d,e) over_async = (r); astk_depth = 0; \
async_func = (f); async_state = 0; async_retries = 0; \
async_arg[0]=(a); async_arg[1]=(b); async_arg[2]=(c); \
async_arg[3]=(d); async_arg[4]=(e); \
async_cmd(ftu); \
return
/* Various wait channels */
static struct {
int buff_avail;
int iosts_change;
int long_delay;
int intr_wait;
} ftsem;
/***********************************************************************\
* Per controller structure. *
\***********************************************************************/
extern struct fdc_data fdc_data[NFDC];
/***********************************************************************\
* Per tape drive structure. *
\***********************************************************************/
struct ft_data {
struct fdc_data *fdc; /* pointer to controller structure */
int ftsu; /* this units number on this controller */
int type; /* Drive type (Mountain, Colorado) */
/* QIC_Geom *ftg; *//* pointer to Current tape's geometry */
int flags;
int cmd_wait; /* Command we are awaiting completion
* of */
int sts_wait; /* Tape interrupt status of current
* request */
int io_sts; /* Tape I/O status */
int mode;
int pcn; /* present cylinder number */
int attaching; /* true when ft is attaching */
unsigned char *xptr; /* pointer to buffer blk to xfer */
int xcnt; /* transfer count */
int xblk; /* block number to transfer */
SegReq *curseg; /* Current segment to do I/O on */
SegReq *bufseg; /* Buffered segment to r/w ahead */
/* the next 3 should be defines in 'flags' */
int active; /* TRUE if transfer is active */
int rdonly; /* TRUE if tape is read-only */
int newcart;/* TRUE if new cartridge detected */
int laststs;/* last reported status code */
int lastcfg;/* last reported QIC config */
int lasterr;/* last QIC error code */
int lastpos;/* last known segment number */
int moving; /* TRUE if tape is moving */
int rid[7]; /* read_id return values */
} ft_data[NFT];
/***********************************************************************\
* Throughout this file the following conventions will be used: *
* ft is a pointer to the ft_data struct for the drive in question *
* fdc is a pointer to the fdc_data struct for the controller *
* ftu is the tape drive unit number *
* fdcu is the floppy controller unit number *
* ftsu is the tape drive unit number on that controller. (sub-unit) *
\***********************************************************************/
typedef int ftu_t;
typedef int ftsu_t;
typedef struct ft_data *ft_p;
#define id_physid id_scsiid /* this biotab field doubles as a field */
/* for the physical unit number on the controller */
int ftopen(dev_t, int);
int ftclose(dev_t, int);
void ftstrategy(struct buf *);
int ftioctl(dev_t, int, caddr_t, int, struct proc *);
int ftdump(dev_t);
int ftsize(dev_t);
static timeout_t ft_timeout;
void async_cmd(ftu_t);
void async_req(ftu_t, int);
void async_read(ftu_t, int);
void async_write(ftu_t, int);
void tape_start(ftu_t);
void tape_end(ftu_t);
void tape_inactive(ftu_t);
/*
* Probe/attach floppy tapes.
*/
int
ftattach(isadev, fdup)
struct isa_device *isadev, *fdup;
{
fdcu_t fdcu = isadev->id_unit; /* fdc active unit */
fdc_p fdc = fdc_data + fdcu; /* pointer to controller
* structure */
ftu_t ftu = fdup->id_unit;
ft_p ft;
ftsu_t ftsu = fdup->id_physid;
if (ftu >= NFT)
return 0;
ft = &ft_data[ftu];
/* Probe for tape */
ft->attaching = 1;
ft->type = NO_TYPE;
ft->fdc = fdc;
ft->ftsu = ftsu;
tape_start(ftu); /* ready controller for tape */
tape_cmd(ftu, QC_COL_ENABLE1);
tape_cmd(ftu, QC_COL_ENABLE2);
if (tape_status(ftu) >= 0) {
ft->type = FT_COLORADO;
fdc->flags |= FDC_HASFTAPE;
printf(" [%d: ft%d: Colorado tape]",
fdup->id_physid, fdup->id_unit);
tape_cmd(ftu, QC_COL_DISABLE);
goto out;
}
tape_start(ftu); /* ready controller for tape */
tape_cmd(ftu, QC_MTN_ENABLE1);
tape_cmd(ftu, QC_MTN_ENABLE2);
if (tape_status(ftu) >= 0) {
ft->type = FT_MOUNTAIN;
fdc->flags |= FDC_HASFTAPE;
printf(" [%d: ft%d: Mountain tape]",
fdup->id_physid, fdup->id_unit);
tape_cmd(ftu, QC_MTN_DISABLE);
goto out;
}
out:
tape_end(ftu);
ft->attaching = 0;
return (ft->type);
}
/*
* Perform common commands asynchronously.
*/
void
async_cmd(ftu_t ftu)
{
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu;
int cmd, i, st0, st3, pcn;
static int bitn, retval, retpos, nbits, newcn;
static struct {
int over_func;
int over_state;
int over_retries;
int over_arg[5];
} astk[15];
static int wanttrk, wantblk, wantdir;
static int curpos, curtrk, curblk, curdir, curdiff;
static int errcnt = 0;
restate:
#if FTDBGALL
DPRT(("async_cmd state: func: %d state: %d\n", async_func, async_state));
#endif
switch (async_func) {
case ACMD_SEEK:
/*
* Arguments: 0 - command to perform
*/
switch (async_state) {
case 0:
cmd = async_arg[0];
#if FTDBGALL
DPRT(("===>async_seek cmd = %d\n", cmd));
#endif
newcn = (cmd <= ft->pcn) ? ft->pcn - cmd : ft->pcn + cmd;
async_state = 1;
i = 0;
if (out_fdc(fdcu, NE7CMD_SEEK) < 0)
i = 1;
if (!i && out_fdc(fdcu, 0x00) < 0)
i = 1;
if (!i && out_fdc(fdcu, newcn) < 0)
i = 1;
if (i) {
if (++async_retries >= 10) {
DPRT(("ft%d: async_cmd command seek failed!!\n", ftu));
goto complete;
}
DPRT(("ft%d: async_cmd command seek retry...\n", ftu));
async_state = 0;
goto restate;
}
break;
case 1:
out_fdc(fdcu, NE7CMD_SENSEI);
st0 = in_fdc(fdcu);
pcn = in_fdc(fdcu);
if (st0 < 0 || pcn < 0 || newcn != pcn) {
if (++async_retries >= 10) {
DPRT(("ft%d: async_cmd seek retries exceeded\n", ftu));
goto complete;
}
DPRT(("ft%d: async_cmd command bad st0=$%02x pcn=$%02x\n",
ftu, st0, pcn));
async_state = 0;
timeout(ft_timeout, (caddr_t) ftu, hz / 10);
break;
}
if (st0 & 0x20) { /* seek done */
ft->pcn = pcn;
}
#if FTDBGALL
else
DPRT(("ft%d: async_seek error st0 = $%02x pcn = %d\n",
ftu, st0, pcn));
#endif
if (async_arg[1])
goto complete;
async_state = 2;
timeout(ft_timeout, (caddr_t) ftu, hz / 50);
break;
case 2:
goto complete;
/* NOTREACHED */
}
break;
case ACMD_STATUS:
/*
* Arguments: 0 - command to issue report from 1 - number of
* bits modifies: bitn, retval, st3
*/
switch (async_state) {
case 0:
bitn = 0;
retval = 0;
cmd = async_arg[0];
nbits = async_arg[1];
DPRT(("async_status got cmd = %d nbits = %d\n", cmd, nbits));
CALL_ACMD(5, ACMD_SEEK, QC_NEXTBIT, 0, 0, 0, 0);
/* NOTREACHED */
case 1:
out_fdc(fdcu, NE7CMD_SENSED);
out_fdc(fdcu, 0x00);
st3 = in_fdc(fdcu);
if (st3 < 0) {
DPRT(("ft%d: async_status timed out on bit %d r=$%02x\n",
ftu, bitn, retval));
async_ret = -1;
goto complete;
}
if ((st3 & 0x10) != 0)
retval |= (1 << bitn);
bitn++;
if (bitn >= (nbits + 2)) {
if ((retval & 1) && (retval & (1 << (nbits + 1)))) {
async_ret = (retval & ~(1 << (nbits + 1))) >> 1;
if (async_arg[0] == QC_STATUS && async_arg[2] == 0 &&
(async_ret & (QS_ERROR | QS_NEWCART))) {
async_state = 2;
goto restate;
}
DPRT(("async status got $%04x ($%04x)\n", async_ret, retval));
} else {
DPRT(("ft%d: async_status failed: retval=$%04x nbits=%d\n",
ftu, retval, nbits));
async_ret = -2;
}
goto complete;
}
CALL_ACMD(1, ACMD_SEEK, QC_NEXTBIT, 0, 0, 0, 0);
/* NOTREACHED */
case 2:
if (async_ret & QS_NEWCART)
ft->newcart = 1;
CALL_ACMD(3, ACMD_STATUS, QC_ERRCODE, 16, 1, 0, 0);
case 3:
ft->lasterr = async_ret;
if ((ft->lasterr & QS_NEWCART) == 0 && ft->lasterr) {
DPRT(("ft%d: QIC error %d occurred on cmd %d\n",
ftu, ft->lasterr & 0xff, ft->lasterr >> 8));
}
cmd = async_arg[0];
nbits = async_arg[1];
CALL_ACMD(4, ACMD_STATUS, QC_STATUS, 8, 1, 0, 0);
case 4:
goto complete;
case 5:
CALL_ACMD(6, ACMD_SEEK, QC_NEXTBIT, 0, 0, 0, 0);
case 6:
CALL_ACMD(7, ACMD_SEEK, QC_NEXTBIT, 0, 0, 0, 0);
case 7:
CALL_ACMD(8, ACMD_SEEK, QC_NEXTBIT, 0, 0, 0, 0);
case 8:
cmd = async_arg[0];
CALL_ACMD(1, ACMD_SEEK, cmd, 0, 0, 0, 0);
}
break;
case ACMD_STATE:
/*
* Arguments: 0 - status bits to check
*/
switch (async_state) {
case 0:
CALL_ACMD(1, ACMD_STATUS, QC_STATUS, 8, 0, 0, 0);
case 1:
if ((async_ret & async_arg[0]) != 0)
goto complete;
async_state = 0;
if (++async_retries == 360) { /* 90 secs. */
DPRT(("ft%d: acmd_state exceeded retry count\n", ftu));
goto complete;
}
timeout(ft_timeout, (caddr_t) ftu, hz / 4);
break;
}
break;
case ACMD_SEEKSTS:
/*
* Arguments: 0 - command to perform 1 - status bits to check
* 2 - (optional) seconds to wait until completion
*/
switch (async_state) {
case 0:
cmd = async_arg[0];
async_retries = (async_arg[2]) ? (async_arg[2] * 4) : 10;
CALL_ACMD(1, ACMD_SEEK, cmd, 0, 0, 0, 0);
case 1:
CALL_ACMD(2, ACMD_STATUS, QC_STATUS, 8, 0, 0, 0);
case 2:
if ((async_ret & async_arg[1]) != 0)
goto complete;
if (--async_retries == 0) {
DPRT(("ft%d: acmd_seeksts retries exceeded\n", ftu));
goto complete;
}
async_state = 1;
timeout(ft_timeout, (caddr_t) ftu, hz / 4);
break;
}
break;
case ACMD_READID:
/*
* Arguments: (none)
*/
switch (async_state) {
case 0:
if (!ft->moving) {
CALL_ACMD(4, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
/* NOTREACHED */
}
async_state = 1;
out_fdc(fdcu, 0x4a); /* READ_ID */
out_fdc(fdcu, 0);
break;
case 1:
for (i = 0; i < 7; i++)
ft->rid[i] = in_fdc(fdcu);
async_ret = (ft->rid[3] * ftg->g_fdtrk) +
(ft->rid[4] * ftg->g_fdside) + ft->rid[5] - 1;
DPRT(("readid st0:%02x st1:%02x st2:%02x c:%d h:%d s:%d pos:%d\n",
ft->rid[0], ft->rid[1], ft->rid[2], ft->rid[3],
ft->rid[4], ft->rid[5], async_ret));
if ((ft->rid[0] & 0xc0) == 0x40) {
if (++errcnt >= 10) {
DPRT(("ft%d: acmd_readid errcnt exceeded\n", fdcu));
async_ret = ft->lastpos;
errcnt = 0;
goto complete;
}
if (errcnt > 2) {
ft->moving = 0;
CALL_ACMD(4, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
}
DPRT(("readid retry...\n"));
async_state = 0;
goto restate;
}
if ((async_ret % ftg->g_blktrk) == (ftg->g_blktrk - 1)) {
DPRT(("acmd_readid detected last block on track\n"));
retpos = async_ret;
CALL_ACMD(2, ACMD_STATE, QS_BOT | QS_EOT, 0, 0, 0, 0);
/* NOTREACHED */
}
ft->lastpos = async_ret;
errcnt = 0;
goto complete;
/* NOTREACHED */
case 2:
CALL_ACMD(3, ACMD_STATE, QS_READY, 0, 0, 0, 0);
case 3:
ft->moving = 0;
async_ret = retpos + 1;
goto complete;
case 4:
CALL_ACMD(5, ACMD_SEEK, QC_FORWARD, 0, 0, 0, 0);
case 5:
ft->moving = 1;
async_state = 0;
timeout(ft_timeout, (caddr_t) ftu, hz / 10); /* XXX */
break;
}
break;
case ACMD_RUNBLK:
/*
* Arguments: 0 - block number I/O will be performed on
*
* modifies: curpos
*/
switch (async_state) {
case 0:
wanttrk = async_arg[0] / ftg->g_blktrk;
wantblk = async_arg[0] % ftg->g_blktrk;
wantdir = wanttrk & 1;
ft->moving = 0;
CALL_ACMD(1, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
case 1:
curtrk = wanttrk;
curdir = curtrk & 1;
DPRT(("Changing to track %d\n", wanttrk));
CALL_ACMD(2, ACMD_SEEK, QC_SEEKTRACK, 0, 0, 0, 0);
case 2:
cmd = wanttrk + 2;
CALL_ACMD(3, ACMD_SEEKSTS, cmd, QS_READY, 0, 0, 0);
case 3:
CALL_ACMD(4, ACMD_STATUS, QC_STATUS, 8, 0, 0, 0);
case 4:
ft->laststs = async_ret;
if (wantblk == 0) {
curblk = 0;
cmd = (wantdir) ? QC_SEEKEND : QC_SEEKSTART;
CALL_ACMD(6, ACMD_SEEKSTS, cmd, QS_READY, 90, 0, 0);
}
if (ft->laststs & QS_BOT) {
DPRT(("Tape is at BOT\n"));
curblk = (wantdir) ? 4800 : 0;
async_state = 6;
goto restate;
}
if (ft->laststs & QS_EOT) {
DPRT(("Tape is at EOT\n"));
curblk = (wantdir) ? 0 : 4800;
async_state = 6;
goto restate;
}
CALL_ACMD(5, ACMD_READID, 0, 0, 0, 0, 0);
case 5:
curtrk = (async_ret + 1) / ftg->g_blktrk;
curblk = (async_ret + 1) % ftg->g_blktrk;
DPRT(("gotid: curtrk=%d wanttrk=%d curblk=%d wantblk=%d\n",
curtrk, wanttrk, curblk, wantblk));
if (curtrk != wanttrk) { /* oops! */
DPRT(("oops!! wrong track!\n"));
CALL_ACMD(1, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
}
async_state = 6;
goto restate;
case 6:
DPRT(("curtrk = %d nextblk = %d\n", curtrk, curblk));
if (curblk == wantblk) {
ft->lastpos = curblk - 1;
async_ret = ft->lastpos;
if (ft->moving)
goto complete;
CALL_ACMD(7, ACMD_STATE, QS_READY, 0, 0, 0, 0);
}
if (curblk > wantblk) { /* passed it */
ft->moving = 0;
CALL_ACMD(10, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
}
if ((wantblk - curblk) <= 96) { /* approaching it */
CALL_ACMD(5, ACMD_READID, 0, 0, 0, 0, 0);
}
/* way up ahead */
ft->moving = 0;
CALL_ACMD(14, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
break;
case 7:
ft->moving = 1;
CALL_ACMD(8, ACMD_SEEK, QC_FORWARD, 0, 0, 0, 0);
break;
case 8:
async_state = 9;
timeout(ft_timeout, (caddr_t) ftu, hz / 10); /* XXX */
break;
case 9:
goto complete;
case 10:
curdiff = ((curblk - wantblk) / QCV_BLKSEG) + 2;
if (curdiff >= ftg->g_segtrk)
curdiff = ftg->g_segtrk - 1;
DPRT(("pos %d past %d, reverse %d\n", curblk, wantblk, curdiff));
CALL_ACMD(11, ACMD_SEEK, QC_SEEKREV, 0, 0, 0, 0);
case 11:
DPRT(("reverse 1 done\n"));
CALL_ACMD(12, ACMD_SEEK, (curdiff & 0xf) + 2, 0, 0, 0, 0);
case 12:
DPRT(("reverse 2 done\n"));
CALL_ACMD(13, ACMD_SEEKSTS, ((curdiff >> 4) & 0xf) + 2, QS_READY, 90, 0, 0);
case 13:
CALL_ACMD(5, ACMD_READID, 0, 0, 0, 0, 0);
case 14:
curdiff = ((wantblk - curblk) / QCV_BLKSEG) - 2;
if (curdiff < 0)
curdiff = 0;
DPRT(("pos %d before %d, forward %d\n", curblk, wantblk, curdiff));
CALL_ACMD(15, ACMD_SEEK, QC_SEEKFWD, 0, 0, 0, 0);
case 15:
DPRT(("forward 1 done\n"));
CALL_ACMD(16, ACMD_SEEK, (curdiff & 0xf) + 2, 0, 0, 0, 0);
case 16:
DPRT(("forward 2 done\n"));
CALL_ACMD(13, ACMD_SEEKSTS, ((curdiff >> 4) & 0xf) + 2, QS_READY, 90, 0, 0);
}
break;
}
return;
complete:
if (astk_depth) {
astk_depth--;
async_retries = astk[astk_depth].over_retries;
async_func = astk[astk_depth].over_func;
async_state = astk[astk_depth].over_state;
for (i = 0; i < 5; i++)
async_arg[i] = astk[astk_depth].over_arg[i];
goto restate;
}
async_func = ACMD_NONE;
async_state = 0;
switch (ft->io_sts) {
case FTIO_READY:
async_req(ftu, 2);
break;
case FTIO_READING:
async_read(ftu, 2);
break;
case FTIO_WRITING:
async_write(ftu, 2);
break;
default:
DPRT(("ft%d: bad async_cmd ending I/O state!\n", ftu));
break;
}
}
/*
* Entry point for the async request processor.
*/
void
async_req(ftu_t ftu, int from)
{
ft_p ft = &ft_data[ftu];
SegReq *sp;
static int over_async, lastreq, domore;
int cmd;
if (from == 2)
arq_state = over_async;
restate:
switch (arq_state) {
case 0: /* Process segment */
ft->io_sts = ft->curseg->reqtype;
if (ft->io_sts == FTIO_WRITING)
async_write(ftu, from);
else
async_read(ftu, from);
if (ft->io_sts != FTIO_READY)
return;
/* Swap buffered and current segment */
lastreq = ft->curseg->reqtype;
ft->curseg->reqtype = FTIO_READY;
sp = ft->curseg;
ft->curseg = ft->bufseg;
ft->bufseg = sp;
wakeup((caddr_t) & ftsem.buff_avail);
/* Detect end of track */
if (((ft->xblk / QCV_BLKSEG) % ftg->g_segtrk) == 0) {
domore = (ft->curseg->reqtype != FTIO_READY);
ACMD_FUNC(2, ACMD_STATE, QS_BOT | QS_EOT, 0, 0, 0, 0);
}
arq_state = 1;
goto restate;
case 1: /* Next request */
if (ft->curseg->reqtype != FTIO_READY) {
ft->curseg->reqcrc = 0;
arq_state = ard_state = awr_state = 0;
ft->xblk = ft->curseg->reqblk;
ft->xcnt = 0;
ft->xptr = ft->curseg->buff;
DPRT(("I/O reqblk = %d\n", ft->curseg->reqblk));
goto restate;
}
if (lastreq == FTIO_READING) {
ft->curseg->reqtype = FTIO_RDAHEAD;
ft->curseg->reqblk = ft->xblk;
ft->curseg->reqcrc = 0;
ft->curseg->reqcan = 0;
bzero(ft->curseg->buff, QCV_SEGSIZE);
arq_state = ard_state = awr_state = 0;
ft->xblk = ft->curseg->reqblk;
ft->xcnt = 0;
ft->xptr = ft->curseg->buff;
DPRT(("Processing readahead reqblk = %d\n", ft->curseg->reqblk));
goto restate;
}
if (ft->moving) {
DPRT(("No more I/O.. Stopping.\n"));
ACMD_FUNC(7, ACMD_SEEKSTS, QC_STOP, QS_READY, 0, 0, 0);
break;
}
arq_state = 7;
goto restate;
case 2: /* End of track */
ft->moving = 0;
ACMD_FUNC(3, ACMD_STATE, QS_READY, 0, 0, 0, 0);
break;
case 3:
DPRT(("async_req seek head to track %d\n", ft->xblk / ftg->g_blktrk));
ACMD_FUNC(4, ACMD_SEEK, QC_SEEKTRACK, 0, 0, 0, 0);
break;
case 4:
cmd = (ft->xblk / ftg->g_blktrk) + 2;
if (domore) {
ACMD_FUNC(5, ACMD_SEEKSTS, cmd, QS_READY, 0, 0, 0);
} else {
ACMD_FUNC(7, ACMD_SEEKSTS, cmd, QS_READY, 0, 0, 0);
}
break;
case 5:
ft->moving = 1;
ACMD_FUNC(6, ACMD_SEEK, QC_FORWARD, 0, 0, 0, 0);
break;
case 6:
arq_state = 1;
timeout(ft_timeout, (caddr_t) ftu, hz / 10); /* XXX */
break;
case 7:
ft->moving = 0;
/* Check one last time to see if a request came in. */
if (ft->curseg->reqtype != FTIO_READY) {
DPRT(("async_req: Never say no!\n"));
arq_state = 1;
goto restate;
}
/* Time to rest. */
ft->active = 0;
wakeup((caddr_t) & ftsem.iosts_change); /* wakeup those who want
* an i/o chg */
break;
}
}
/*
* Entry for async read.
*/
void
async_read(ftu_t ftu, int from)
{
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
unsigned long paddr;
int i, cmd, newcn, rddta[7];
int st0, pcn, where;
static int over_async;
if (from == 2)
ard_state = over_async;
restate:
#if FTDBGALL
DPRT(("async_read: state: %d from = %d\n", ard_state, from));
#endif
switch (ard_state) {
case 0: /* Start off */
/* If tape is not at desired position, stop and locate */
if (ft->lastpos != (ft->xblk - 1)) {
DPRT(("ft%d: position unknown: lastpos:%d ft->xblk:%d\n",
ftu, ft->lastpos, ft->xblk));
ACMD_FUNC(1, ACMD_RUNBLK, ft->xblk, 0, 0, 0, 0);
}
/* Tape is in position but stopped. */
if (!ft->moving) {
DPRT(("async_read ******STARTING TAPE\n"));
ACMD_FUNC(3, ACMD_STATE, QS_READY, 0, 0, 0, 0);
}
ard_state = 1;
goto restate;
case 1: /* Start DMA */
/* Tape is now moving and in position-- start DMA now! */
isa_dmastart(B_READ, ft->xptr, QCV_BLKSIZE, 2);
out_fdc(fdcu, 0x66); /* read */
out_fdc(fdcu, 0x00); /* unit */
out_fdc(fdcu, (ft->xblk % ftg->g_fdside) / ftg->g_fdtrk); /* cylinder */
out_fdc(fdcu, ft->xblk / ftg->g_fdside); /* head */
out_fdc(fdcu, (ft->xblk % ftg->g_fdtrk) + 1); /* sector */
out_fdc(fdcu, 0x03); /* 1K sectors */
out_fdc(fdcu, (ft->xblk % ftg->g_fdtrk) + 1); /* count */
out_fdc(fdcu, 0x74); /* gap length */
out_fdc(fdcu, 0xff); /* transfer size */
ard_state = 2;
break;
case 2: /* DMA completed */
/* Transfer complete, get status */
for (i = 0; i < 7; i++)
rddta[i] = in_fdc(fdcu);
isa_dmadone(B_READ, ft->xptr, QCV_BLKSIZE, 2);
#if FTDBGALL
/* Compute where the controller thinks we are */
where = (rddta[3] * ftg->g_fdtrk) + (rddta[4] * ftg->g_fdside) + rddta[5] - 1;
DPRT(("xfer done: st0:%02x st1:%02x st2:%02x c:%d h:%d s:%d pos:%d want:%d\n",
rddta[0], rddta[1], rddta[2], rddta[3], rddta[4], rddta[5],
where, ft->xblk));
#endif
/* Check for errors */
if ((rddta[0] & 0xc0) != 0x00) {
if (rddta[1] & 0x04) {
/* Probably wrong position */
ft->lastpos = ft->xblk;
ard_state = 0;
goto restate;
} else {
/* CRC/Address-mark/Data-mark, et. al. */
DPRT(("ft%d: CRC error on block %d\n", fdcu, ft->xblk));
ft->curseg->reqcrc |= (1 << ft->xcnt);
}
}
/* Otherwise, transfer completed okay. */
ft->lastpos = ft->xblk;
ft->xblk++;
ft->xcnt++;
ft->xptr += QCV_BLKSIZE;
if (ft->xcnt < QCV_BLKSEG && ft->curseg->reqcan == 0) {
ard_state = 0;
goto restate;
}
DPRT(("Read done.. Cancel = %d\n", ft->curseg->reqcan));
ft->io_sts = FTIO_READY;
break;
case 3:
ft->moving = 1;
ACMD_FUNC(4, ACMD_SEEK, QC_FORWARD, 0, 0, 0, 0);
break;
case 4:
ard_state = 1;
timeout(ft_timeout, (caddr_t) ftu, hz / 10); /* XXX */
break;
default:
DPRT(("ft%d: bad async_read state %d!!\n", ftu, ard_state));
break;
}
}
/*
* Entry for async write. If from is 0, this came from the interrupt
* routine, if it's 1 then it was a timeout, if it's 2, then an async_cmd
* completed.
*/
void
async_write(ftu_t ftu, int from)
{
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
unsigned long paddr;
int i, cmd, newcn, rddta[7];
int st0, pcn, where;
static int over_async;
static int retries = 0;
if (from == 2)
awr_state = over_async;
restate:
#if FTDBGALL
DPRT(("async_write: state: %d from = %d\n", awr_state, from));
#endif
switch (awr_state) {
case 0: /* Start off */
/* If tape is not at desired position, stop and locate */
if (ft->lastpos != (ft->xblk - 1)) {
DPRT(("ft%d: position unknown: lastpos:%d ft->xblk:%d\n",
ftu, ft->lastpos, ft->xblk));
ACMD_FUNC(1, ACMD_RUNBLK, ft->xblk, 0, 0, 0, 0);
}
/* Tape is in position but stopped. */
if (!ft->moving) {
DPRT(("async_write ******STARTING TAPE\n"));
ACMD_FUNC(3, ACMD_STATE, QS_READY, 0, 0, 0, 0);
}
awr_state = 1;
goto restate;
case 1: /* Start DMA */
/* Tape is now moving and in position-- start DMA now! */
isa_dmastart(B_WRITE, ft->xptr, QCV_BLKSIZE, 2);
out_fdc(fdcu, 0x45); /* write */
out_fdc(fdcu, 0x00); /* unit */
out_fdc(fdcu, (ft->xblk % ftg->g_fdside) / ftg->g_fdtrk); /* cylinder */
out_fdc(fdcu, ft->xblk / ftg->g_fdside); /* head */
out_fdc(fdcu, (ft->xblk % ftg->g_fdtrk) + 1); /* sector */
out_fdc(fdcu, 0x03); /* 1K sectors */
out_fdc(fdcu, (ft->xblk % ftg->g_fdtrk) + 1); /* count */
out_fdc(fdcu, 0x74); /* gap length */
out_fdc(fdcu, 0xff); /* transfer size */
awr_state = 2;
break;
case 2: /* DMA completed */
/* Transfer complete, get status */
for (i = 0; i < 7; i++)
rddta[i] = in_fdc(fdcu);
isa_dmadone(B_WRITE, ft->xptr, QCV_BLKSIZE, 2);
#if FTDBGALL
/* Compute where the controller thinks we are */
where = (rddta[3] * ftg->g_fdtrk) + (rddta[4] * ftg->g_fdside) + rddta[5] - 1;
DPRT(("xfer done: st0:%02x st1:%02x st2:%02x c:%d h:%d s:%d pos:%d want:%d\n",
rddta[0], rddta[1], rddta[2], rddta[3], rddta[4], rddta[5],
where, ft->xblk));
#endif
/* Check for errors */
if ((rddta[0] & 0xc0) != 0x00) {
if (rddta[1] & 0x04) {
/* Probably wrong position */
ft->lastpos = ft->xblk;
awr_state = 0;
goto restate;
} else if (retries < 5) {
/* Something happened -- try again */
ft->lastpos = ft->xblk;
awr_state = 0;
retries++;
goto restate;
} else {
/*
* Retries failed. Note the unrecoverable
* error. Marking the block as bad is fairly
* useless.
*/
printf("ft%d: unrecoverable write error on block %d\n",
ftu, ft->xblk);
ft->curseg->reqcrc |= (1 << ft->xcnt);
}
}
/* Otherwise, transfer completed okay. */
retries = 0;
ft->lastpos = ft->xblk;
ft->xblk++;
ft->xcnt++;
ft->xptr += QCV_BLKSIZE;
if (ft->xcnt < QCV_BLKSEG) {
awr_state = 0; /* next block */
goto restate;
}
#if FTDBGALL
DPRT(("Write done.\n"));
#endif
ft->io_sts = FTIO_READY;
break;
case 3:
ft->moving = 1;
ACMD_FUNC(4, ACMD_SEEK, QC_FORWARD, 0, 0, 0, 0);
break;
case 4:
awr_state = 1;
timeout(ft_timeout, (caddr_t) ftu, hz / 10); /* XXX */
break;
default:
DPRT(("ft%d: bad async_write state %d!!\n", ftu, awr_state));
break;
}
}
/*
* Interrupt handler for active tape. Bounced off of fdintr().
*/
int
ftintr(ftu_t ftu)
{
int st0, pcn, i;
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
st0 = 0;
pcn = 0;
/* I/O segment transfer completed */
if (ft->active) {
if (async_func != ACMD_NONE) {
async_cmd(ftu);
return (1);
}
#if FTDBGALL
DPRT(("Got request interrupt\n"));
#endif
async_req(ftu, 0);
return (1);
}
/* Get interrupt status */
if (ft->cmd_wait != FTCMD_READID) {
out_fdc(fdcu, NE7CMD_SENSEI);
st0 = in_fdc(fdcu);
pcn = in_fdc(fdcu);
}
if (ft->cmd_wait == FTCMD_NONE || ft->sts_wait != FTSTS_SNOOZE) {
huh_what:
printf("ft%d: unexpected interrupt; st0 = $%02x pcn = %d\n",
ftu, st0, pcn);
return (1);
}
switch (ft->cmd_wait) {
case FTCMD_RESET:
ft->sts_wait = FTSTS_INTERRUPT;
wakeup((caddr_t) & ftsem.intr_wait);
break;
case FTCMD_RECAL:
case FTCMD_SEEK:
if (st0 & 0x20) { /* seek done */
ft->sts_wait = FTSTS_INTERRUPT;
ft->pcn = pcn;
wakeup((caddr_t) & ftsem.intr_wait);
}
#if FTDBGALL
else
DPRT(("ft%d: seek error st0 = $%02x pcn = %d\n",
ftu, st0, pcn));
#endif
break;
case FTCMD_READID:
for (i = 0; i < 7; i++)
ft->rid[i] = in_fdc(fdcu);
ft->sts_wait = FTSTS_INTERRUPT;
wakeup((caddr_t) & ftsem.intr_wait);
break;
default:
goto huh_what;
}
return (1);
}
/*
* Interrupt timeout routine.
*/
static void
ft_timeout(void *arg1)
{
int s;
ftu_t ftu = (ftu_t) arg1;
ft_p ft = &ft_data[ftu];
s = splbio();
if (ft->active) {
if (async_func != ACMD_NONE) {
async_cmd(ftu);
splx(s);
return;
}
async_req(ftu, 1);
} else {
ft->sts_wait = FTSTS_TIMEOUT;
wakeup((caddr_t) & ftsem.intr_wait);
}
splx(s);
}
/*
* Wait for a particular interrupt to occur. ftintr() will wake us up if it
* sees what we want. Otherwise, time out and return error. Should always
* disable ints before trigger is sent and calling here.
*/
int
ftintr_wait(ftu_t ftu, int cmd, int ticks)
{
int retries, st0, pcn;
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
ft->cmd_wait = cmd;
ft->sts_wait = FTSTS_SNOOZE;
/* At attach time, we can't rely on having interrupts serviced */
if (ft->attaching) {
switch (cmd) {
case FTCMD_RESET:
DELAY(100);
ft->sts_wait = FTSTS_INTERRUPT;
goto intrdone;
case FTCMD_RECAL:
case FTCMD_SEEK:
for (retries = 0; retries < 10000; retries++) {
out_fdc(fdcu, NE7CMD_SENSEI);
st0 = in_fdc(fdcu);
pcn = in_fdc(fdcu);
if (st0 & 0x20) {
ft->sts_wait = FTSTS_INTERRUPT;
ft->pcn = pcn;
goto intrdone;
}
DELAY(100);
}
break;
}
ft->sts_wait = FTSTS_TIMEOUT;
goto intrdone;
}
if (ticks)
timeout(ft_timeout, (caddr_t) ftu, ticks);
tsleep((caddr_t) & ftsem.intr_wait, FTPRI, "ftwait", 0);
intrdone:
if (ft->sts_wait == FTSTS_TIMEOUT) { /* timeout */
if (ft->cmd_wait != FTCMD_RESET)
DPRT(("ft%d: timeout on command %d\n", ftu, ft->cmd_wait));
ft->cmd_wait = FTCMD_NONE;
ft->sts_wait = FTSTS_NONE;
return (1);
}
/* got interrupt */
if (ft->attaching == 0 && ticks)
untimeout(ft_timeout, (caddr_t) ftu);
ft->cmd_wait = FTCMD_NONE;
ft->sts_wait = FTSTS_NONE;
return (0);
}
/*
* Recalibrate tape drive. Parameter totape is true, if we should
* recalibrate to tape drive settings.
*/
int
tape_recal(ftu_t ftu, int totape)
{
int s;
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
DPRT(("tape_recal start\n"));
out_fdc(fdcu, NE7CMD_SPECIFY);
out_fdc(fdcu, (totape) ? 0xAD : 0xDF);
out_fdc(fdcu, 0x02);
s = splbio();
out_fdc(fdcu, NE7CMD_RECAL);
out_fdc(fdcu, 0x00);
if (ftintr_wait(ftu, FTCMD_RECAL, hz)) {
splx(s);
DPRT(("ft%d: recalibrate timeout\n", ftu));
return (1);
}
splx(s);
out_fdc(fdcu, NE7CMD_SPECIFY);
out_fdc(fdcu, (totape) ? 0xFD : 0xDF);
out_fdc(fdcu, 0x02);
DPRT(("tape_recal end\n"));
return (0);
}
static void
state_timeout(void *arg1)
{
ftu_t ftu = (ftu_t) arg1;
wakeup((caddr_t) & ftsem.long_delay);
}
/*
* Wait for a particular tape status to be met. If all is TRUE, then all
* states must be met, otherwise any state can be met.
*/
int
tape_state(ftu_t ftu, int all, int mask, int seconds)
{
int r, tries, maxtries;
maxtries = (seconds) ? (4 * seconds) : 1;
for (tries = 0; tries < maxtries; tries++) {
r = tape_status(ftu);
if (r >= 0) {
if (all && (r & mask) == mask)
return (r);
if ((r & mask) != 0)
return (r);
}
if (seconds) {
timeout(state_timeout, (caddr_t) ftu, hz / 4);
tsleep((caddr_t) & ftsem.long_delay, FTPRI, "ftstate", 0);
}
}
DPRT(("ft%d: tape_state failed on mask=$%02x maxtries=%d\n",
ftu, mask, maxtries));
return (-1);
}
/*
* Send a QIC command to tape drive, wait for completion.
*/
int
tape_cmd(ftu_t ftu, int cmd)
{
int newcn;
int retries = 0;
int s;
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
DPRT(("===> tape_cmd: %d\n", cmd));
newcn = (cmd <= ft->pcn) ? ft->pcn - cmd : ft->pcn + cmd;
retry:
/* Perform seek */
s = splbio();
out_fdc(fdcu, NE7CMD_SEEK);
out_fdc(fdcu, 0x00);
out_fdc(fdcu, newcn);
if (ftintr_wait(ftu, FTCMD_SEEK, hz)) {
DPRT(("ft%d: tape_cmd seek timeout\n", ftu));
redo:
splx(s);
if (++retries < 5)
goto retry;
DPRT(("ft%d: tape_cmd seek failed!\n", ftu));
return (1);
}
splx(s);
if (ft->pcn != newcn) {
DPRT(("ft%d: bad seek in tape_cmd; pcn = %d newcn = %d\n",
ftu, ft->pcn, newcn));
goto redo;
}
DELAY(2500);
return (0);
}
/*
* Return status of tape drive
*/
int
tape_status(ftu_t ftu)
{
int r, err, tries;
ft_p ft = &ft_data[ftu];
for (r = -1, tries = 0; r < 0 && tries < 3; tries++)
r = qic_status(ftu, QC_STATUS, 8);
if (tries == 3)
return (-1);
DPRT(("tape_status got $%04x\n", r));
ft->laststs = r;
if (r & (QS_ERROR | QS_NEWCART)) {
if (r & QS_NEWCART)
ft->newcart = 1;
err = qic_status(ftu, QC_ERRCODE, 16);
ft->lasterr = err;
if ((r & QS_NEWCART) == 0 && err && ft->attaching == 0) {
DPRT(("ft%d: QIC error %d occurred on cmd %d\n",
ftu, err & 0xff, err >> 8));
}
r = qic_status(ftu, QC_STATUS, 8);
ft->laststs = r;
DPRT(("tape_status got error code $%04x new sts = $%02x\n", err, r));
}
ft->rdonly = (r & QS_RDONLY);
return (r);
}
/*
* Transfer control to tape drive.
*/
void
tape_start(ftu_t ftu)
{
ft_p ft = &ft_data[ftu];
fdc_p fdc = ft->fdc;
int s;
DPRT(("tape_start start\n"));
s = splbio();
/* reset, dma disable */
outb(fdc->baseport + fdout, 0x00);
(void) ftintr_wait(ftu, FTCMD_RESET, hz / 10);
/* raise reset, enable DMA */
outb(fdc->baseport + fdout, FDO_FRST | FDO_FDMAEN);
(void) ftintr_wait(ftu, FTCMD_RESET, hz / 10);
splx(s);
tape_recal(ftu, 1);
/* set transfer speed */
outb(fdc->baseport + fdctl, FDC_500KBPS);
DELAY(10);
DPRT(("tape_start end\n"));
}
/*
* Transfer control back to floppy disks.
*/
void
tape_end(ftu_t ftu)
{
ft_p ft = &ft_data[ftu];
fdc_p fdc = ft->fdc;
int s;
DPRT(("tape_end start\n"));
tape_recal(ftu, 0);
s = splbio();
/* reset, dma disable */
outb(fdc->baseport + fdout, 0x00);
(void) ftintr_wait(ftu, FTCMD_RESET, hz / 10);
/* raise reset, enable DMA */
outb(fdc->baseport + fdout, FDO_FRST | FDO_FDMAEN);
(void) ftintr_wait(ftu, FTCMD_RESET, hz / 10);
splx(s);
/* set transfer speed */
outb(fdc->baseport + fdctl, FDC_500KBPS);
DELAY(10);
fdc->flags &= ~FDC_TAPE_BUSY;
DPRT(("tape_end end\n"));
}
/*
* Wait for the driver to go inactive, cancel readahead if necessary.
*/
void
tape_inactive(ftu_t ftu)
{
ft_p ft = &ft_data[ftu];
if (ft->curseg->reqtype == FTIO_RDAHEAD) {
ft->curseg->reqcan = 1; /* XXX cancel rdahead */
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftinact", 0);
}
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftinact", 0);
}
/*
* Get the geometry of the tape currently in the drive.
*/
int
ftgetgeom(ftu_t ftu)
{
int r, i, tries;
int cfg, qic80, ext;
int sts, fmt, len;
ft_p ft = &ft_data[ftu];
r = tape_status(ftu);
/* XXX fix me when format mode is finished */
if ((r & QS_CART) == 0 || (r & QS_FMTOK) == 0) {
DPRT(("ftgetgeom: no cart or not formatted 0x%04x\n", r));
ftg = NULL;
ft->newcart = 1;
return (0);
}
/* Report drive configuration */
for (cfg = -1, tries = 0; cfg < 0 && tries < 3; tries++)
cfg = qic_status(ftu, QC_CONFIG, 8);
if (tries == 3) {
DPRT(("ftgetgeom report config failed\n"));
ftg = NULL;
return (-1);
}
DPRT(("ftgetgeom report config got $%04x\n", cfg));
ft->lastcfg = cfg;
qic80 = cfg & QCF_QIC80;
ext = cfg & QCF_EXTRA;
/*
* XXX - This doesn't seem to work on my Colorado Jumbo 250... if it
* works on your drive, I'd sure like to hear about it.
*/
#if 0
/* Report drive status */
for (sts = -1, tries = 0; sts < 0 && tries < 3; tries++)
sts = qic_status(ftu, QC_TSTATUS, 8);
if (tries == 3) {
DPRT(("ftgetgeom report tape status failed\n"));
ftg = NULL;
return (-1);
}
DPRT(("ftgetgeom report tape status got $%04x\n", sts));
#else
/*
* XXX - Forge a fake tape status based upon the returned
* configuration, since the above command or code is broken for my
* drive and probably other older drives.
*/
sts = 0;
sts = (qic80) ? QTS_QIC80 : QTS_QIC40;
sts |= (ext) ? QTS_LEN2 : QTS_LEN1;
#endif
fmt = sts & QTS_FMMASK;
len = (sts & QTS_LNMASK) >> 4;
if (fmt > QCV_NFMT) {
ftg = NULL;
printf("ft%d: unsupported tape format\n", ftu);
return (-1);
}
if (len > QCV_NLEN) {
ftg = NULL;
printf("ft%d: unsupported tape length\n", ftu);
return (-1);
}
/* Look up geometry in the table */
for (i = 1; i < NGEOM; i++)
if (ftgtbl[i].g_fmtno == fmt && ftgtbl[i].g_lenno == len)
break;
if (i == NGEOM) {
printf("ft%d: unknown tape geometry\n", ftu);
ftg = NULL;
return (-1);
}
ftg = &ftgtbl[i];
if (!ftg->g_trktape) {
printf("ft%d: unsupported format %s w/len %s\n",
ftu, ftg->g_fmtdesc, ftg->g_lendesc);
ftg = NULL;
return (-1);
}
DPRT(("Tape format is %s, length is %s\n", ftg->g_fmtdesc, ftg->g_lendesc));
ft->newcart = 0;
return (0);
}
/*
* Switch between tape/floppy. This will send the tape enable/disable codes
* for this drive's manufacturer.
*/
int
set_fdcmode(dev_t dev, int newmode)
{
ftu_t ftu = FDUNIT(minor(dev));
ft_p ft = &ft_data[ftu];
fdc_p fdc = ft->fdc;
static int havebufs = 0;
void *buf;
int r, s, i;
SegReq *sp;
if (newmode == FDC_TAPE_MODE) {
/* Wake up the tape drive */
switch (ft->type) {
case NO_TYPE:
fdc->flags &= ~FDC_TAPE_BUSY;
return (ENXIO);
case FT_COLORADO:
tape_start(ftu);
if (tape_cmd(ftu, QC_COL_ENABLE1)) {
tape_end(ftu);
return (EIO);
}
if (tape_cmd(ftu, QC_COL_ENABLE2)) {
tape_end(ftu);
return (EIO);
}
break;
case FT_MOUNTAIN:
tape_start(ftu);
if (tape_cmd(ftu, QC_MTN_ENABLE1)) {
tape_end(ftu);
return (EIO);
}
if (tape_cmd(ftu, QC_MTN_ENABLE2)) {
tape_end(ftu);
return (EIO);
}
break;
default:
DPRT(("ft%d: bad tape type\n", ftu));
return (ENXIO);
}
if (tape_status(ftu) < 0) {
tape_cmd(ftu, (ft->type == FT_COLORADO) ? QC_COL_DISABLE : QC_MTN_DISABLE);
tape_end(ftu);
return (EIO);
}
/* Grab buffers from memory. */
if (!havebufs) {
ft->curseg = malloc(sizeof(SegReq), M_DEVBUF, M_NOWAIT);
if (ft->curseg == NULL) {
printf("ft%d: not enough memory for buffers\n", ftu);
return (ENOMEM);
}
ft->bufseg = malloc(sizeof(SegReq), M_DEVBUF, M_NOWAIT);
if (ft->bufseg == NULL) {
free(ft->curseg, M_DEVBUF);
printf("ft%d: not enough memory for buffers\n", ftu);
return (ENOMEM);
}
havebufs = 1;
}
ft->curseg->reqtype = FTIO_READY;
ft->bufseg->reqtype = FTIO_READY;
ft->io_sts = FTIO_READY; /* tape drive is ready */
ft->active = 0; /* interrupt driver not active */
ft->moving = 0; /* tape not moving */
ft->rdonly = 0; /* tape read only */
ft->newcart = 0;/* a new cart was inserted */
ft->lastpos = -1; /* tape is rewound */
tape_state(ftu, 0, QS_READY, 60);
tape_cmd(ftu, QC_RATE);
tape_cmd(ftu, QCF_RT500 + 2); /* 500K bps */
tape_state(ftu, 0, QS_READY, 60);
ft->mode = FTM_PRIMARY;
tape_cmd(ftu, QC_PRIMARY); /* Make sure we're in primary
* mode */
tape_state(ftu, 0, QS_READY, 60);
ftg = NULL; /* No geometry yet */
ftgetgeom(ftu); /* Get tape geometry */
ftreq_rewind(ftu); /* Make sure tape is rewound */
} else {
tape_cmd(ftu, (ft->type == FT_COLORADO) ? QC_COL_DISABLE : QC_MTN_DISABLE);
tape_end(ftu);
ft->newcart = 0;/* clear new cartridge */
havebufs = 0;
free(ft->curseg, M_DEVBUF);
free(ft->bufseg, M_DEVBUF);
}
return (0);
}
/*
* Perform a QIC status function.
*/
int
qic_status(ftu_t ftu, int cmd, int nbits)
{
int st3, val, r, i;
ft_p ft = &ft_data[ftu];
fdcu_t fdcu = ft->fdc->fdcu; /* fdc active unit */
if (tape_cmd(ftu, cmd)) {
DPRT(("ft%d: QIC status timeout\n", ftu));
return (-1);
}
/* Sense drive status */
out_fdc(fdcu, NE7CMD_SENSED);
out_fdc(fdcu, 0x00);
st3 = in_fdc(fdcu);
if ((st3 & 0x10) == 0) {/* track 0 */
DPRT(("qic_status has dead drive... st3 = $%02x\n", st3));
return (-1);
}
for (i = r = 0; i <= nbits; i++) {
if (tape_cmd(ftu, QC_NEXTBIT)) {
DPRT(("ft%d: QIC status bit timed out on %d\n", ftu, i));
return (-1);
}
out_fdc(fdcu, NE7CMD_SENSED);
out_fdc(fdcu, 0x00);
st3 = in_fdc(fdcu);
if (st3 < 0) {
DPRT(("ft%d: controller timed out on bit %d r=$%02x\n",
ftu, i, r));
return (-1);
}
r >>= 1;
if (i < nbits)
r |= ((st3 & 0x10) ? 1 : 0) << nbits;
else if ((st3 & 0x10) == 0) {
DPRT(("ft%d: qic status stop bit missing at %d, st3=$%02x r=$%04x\n",
ftu, i, st3, r));
return (-1);
}
}
DPRT(("qic_status returned $%02x\n", r));
return (r);
}
/*
* Open tape drive for use. Bounced off of Fdopen if tape minor is detected.
*/
int
ftopen(dev_t dev, int arg2)
{
ftu_t ftu = FDUNIT(minor(dev));
int type = FDTYPE(minor(dev));
fdc_p fdc;
/* check bounds */
if (ftu >= NFT)
return (ENXIO);
fdc = ft_data[ftu].fdc;
/* check for controller already busy with tape */
if (fdc->flags & FDC_TAPE_BUSY)
return (EBUSY);
/* make sure we found a tape when probed */
if (!(fdc->flags & FDC_HASFTAPE))
return (ENODEV);
fdc->fdu = ftu;
fdc->flags |= FDC_TAPE_BUSY;
return (set_fdcmode(dev, FDC_TAPE_MODE)); /* try to switch to tape */
}
/*
* Close tape and return floppy controller to disk mode.
*/
int
ftclose(dev_t dev, int flags)
{
int s;
SegReq *sp;
ftu_t ftu = FDUNIT(minor(dev));
ft_p ft = &ft_data[ftu];
/* Wait for any remaining I/O activity to complete. */
if (ft->curseg->reqtype == FTIO_RDAHEAD)
ft->curseg->reqcan = 1;
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftclose", 0);
ft->mode = FTM_PRIMARY;
tape_cmd(ftu, QC_PRIMARY);
tape_state(ftu, 0, QS_READY, 60);
ftreq_rewind(ftu);
return (set_fdcmode(dev, FDC_DISK_MODE)); /* Otherwise, close tape */
}
/*
* Perform strategy on a given buffer (not!). The driver was not performing
* very efficiently using the buffering routines. After support for error
* correction was added, this routine became obsolete in favor of doing
* ioctl's. Ugly, yes.
*/
void
ftstrategy(struct buf * bp)
{
return;
}
/* Read or write a segment. */
int
ftreq_rw(ftu_t ftu, int cmd, QIC_Segment * sr, struct proc * p)
{
int r, i, j;
SegReq *sp;
int s;
long blk, bad;
unsigned char *cp, *cp2;
ft_p ft = &ft_data[ftu];
if (!ft->active) {
r = tape_status(ftu);
if ((r & QS_CART) == 0) {
return (ENXIO); /* No cartridge */
}
if ((r & QS_FMTOK) == 0) {
return (ENXIO); /* Not formatted */
}
tape_state(ftu, 0, QS_READY, 90);
}
if (ftg == NULL || ft->newcart) {
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftrw", 0);
tape_state(ftu, 0, QS_READY, 90);
if (ftgetgeom(ftu) < 0) {
return (ENXIO);
}
}
/* Write not allowed on a read-only tape. */
if (cmd == QIOWRITE && ft->rdonly) {
return (EROFS);
}
/* Quick check of request and buffer. */
if (sr == NULL || sr->sg_data == NULL) {
return (EINVAL);
}
if (sr->sg_trk >= ftg->g_trktape ||
sr->sg_seg >= ftg->g_segtrk) {
return (EINVAL);
}
blk = sr->sg_trk * ftg->g_blktrk + sr->sg_seg * QCV_BLKSEG;
s = splbio();
if (cmd == QIOREAD) {
if (ft->curseg->reqtype == FTIO_RDAHEAD) {
if (blk == ft->curseg->reqblk) {
sp = ft->curseg;
sp->reqtype = FTIO_READING;
sp->reqbad = sr->sg_badmap;
goto rdwait;
} else
ft->curseg->reqcan = 1; /* XXX cancel rdahead */
}
/* Wait until we're ready. */
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftrw", 0);
/* Set up a new read request. */
sp = ft->curseg;
sp->reqcrc = 0;
sp->reqbad = sr->sg_badmap;
sp->reqblk = blk;
sp->reqcan = 0;
sp->reqtype = FTIO_READING;
/* Start the read request off. */
DPRT(("Starting read I/O chain\n"));
arq_state = ard_state = awr_state = 0;
ft->xblk = sp->reqblk;
ft->xcnt = 0;
ft->xptr = sp->buff;
ft->active = 1;
timeout(ft_timeout, (caddr_t) ftu, 1);
rdwait:
tsleep((caddr_t) & ftsem.buff_avail, FTPRI, "ftrw", 0);
bad = sp->reqbad;
sr->sg_crcmap = sp->reqcrc & ~bad;
/* Copy out segment and discard bad mapped blocks. */
cp = sp->buff;
cp2 = sr->sg_data;
for (i = 0; i < QCV_BLKSEG; cp += QCV_BLKSIZE, i++) {
if (bad & (1 << i))
continue;
copyout(cp, cp2, QCV_BLKSIZE);
cp2 += QCV_BLKSIZE;
}
} else {
if (ft->curseg->reqtype == FTIO_RDAHEAD) {
ft->curseg->reqcan = 1; /* XXX cancel rdahead */
while (ft->active)
tsleep((caddr_t) & ftsem.iosts_change, FTPRI, "ftrw", 0);
}
/* Sleep until a buffer becomes available. */
while (ft->bufseg->reqtype != FTIO_READY)
tsleep((caddr_t) & ftsem.buff_avail, FTPRI, "ftrwbuf", 0);
sp = (ft->curseg->reqtype == FTIO_READY) ? ft->curseg : ft->bufseg;
/* Copy in segment and expand bad blocks. */
bad = sr->sg_badmap;
cp = sr->sg_data;
cp2 = sp->buff;
for (i = 0; i < QCV_BLKSEG; cp2 += QCV_BLKSIZE, i++) {
if (bad & (1 << i))
continue;
copyin(cp, cp2, QCV_BLKSIZE);
cp += QCV_BLKSIZE;
}
sp->reqblk = blk;
sp->reqcan = 0;
sp->reqtype = FTIO_WRITING;
if (!ft->active) {
DPRT(("Starting write I/O chain\n"));
arq_state = ard_state = awr_state = 0;
ft->xblk = sp->reqblk;
ft->xcnt = 0;
ft->xptr = sp->buff;
ft->active = 1;
timeout(ft_timeout, (caddr_t) ftu, 1);
}
}
splx(s);
return (0);
}
/* Rewind to beginning of tape */
int
ftreq_rewind(ftu_t ftu)
{
ft_p ft = &ft_data[ftu];
tape_inactive(ftu);
tape_cmd(ftu, QC_STOP);
tape_state(ftu, 0, QS_READY, 90);
tape_cmd(ftu, QC_SEEKSTART);
tape_state(ftu, 0, QS_READY, 90);
tape_cmd(ftu, QC_SEEKTRACK);
tape_cmd(ftu, 2);
tape_state(ftu, 0, QS_READY, 90);
ft->lastpos = -1;
ft->moving = 0;
return (0);
}
/* Move to logical beginning or end of track */
int
ftreq_trkpos(ftu_t ftu, int req)
{
int curtrk, r, cmd;
ft_p ft = &ft_data[ftu];
tape_inactive(ftu);
tape_cmd(ftu, QC_STOP);
tape_state(ftu, 0, QS_READY, 90);
r = tape_status(ftu);
if ((r & QS_CART) == 0)
return (ENXIO); /* No cartridge */
if ((r & QS_FMTOK) == 0)
return (ENXIO); /* Not formatted */
if (ftg == NULL || ft->newcart) {
if (ftgetgeom(ftu) < 0)
return (ENXIO);
}
curtrk = (ft->lastpos < 0) ? 0 : ft->lastpos / ftg->g_blktrk;
if (req == QIOBOT)
cmd = (curtrk & 1) ? QC_SEEKEND : QC_SEEKSTART;
else
cmd = (curtrk & 1) ? QC_SEEKSTART : QC_SEEKEND;
tape_cmd(ftu, cmd);
tape_state(ftu, 0, QS_READY, 90);
return (0);
}
/* Seek tape head to a particular track. */
int
ftreq_trkset(ftu_t ftu, int *trk)
{
int curtrk, r, cmd;
ft_p ft = &ft_data[ftu];
tape_inactive(ftu);
tape_cmd(ftu, QC_STOP);
tape_state(ftu, 0, QS_READY, 90);
r = tape_status(ftu);
if ((r & QS_CART) == 0)
return (ENXIO); /* No cartridge */
if ((r & QS_FMTOK) == 0)
return (ENXIO); /* Not formatted */
if (ftg == NULL || ft->newcart) {
if (ftgetgeom(ftu) < 0)
return (ENXIO);
}
tape_cmd(ftu, QC_SEEKTRACK);
tape_cmd(ftu, *trk + 2);
tape_state(ftu, 0, QS_READY, 90);
return (0);
}
/* Start tape moving forward. */
int
ftreq_lfwd(ftu_t ftu)
{
tape_inactive(ftu);
tape_cmd(ftu, QC_STOP);
tape_state(ftu, 0, QS_READY, 90);
tape_cmd(ftu, QC_FORWARD);
return (0);
}
/* Stop the tape */
int
ftreq_stop(ftu_t ftu)
{
tape_inactive(ftu);
tape_cmd(ftu, QC_STOP);
tape_state(ftu, 0, QS_READY, 90);
return (0);
}
/* Set the particular mode the drive should be in. */
int
ftreq_setmode(ftu_t ftu, int cmd)
{
int r;
ft_p ft = &ft_data[ftu];
tape_inactive(ftu);
r = tape_status(ftu);
switch (cmd) {
case QIOPRIMARY:
ft->mode = FTM_PRIMARY;
tape_cmd(ftu, QC_PRIMARY);
break;
case QIOFORMAT:
if (r & QS_RDONLY)
return (ENXIO);
if ((r & QS_BOT) == 0)
return (ENXIO);
tape_cmd(ftu, QC_FORMAT);
break;
case QIOVERIFY:
if ((r & QS_FMTOK) == 0)
return (ENXIO); /* Not formatted */
tape_cmd(ftu, QC_VERIFY);
break;
}
tape_state(ftu, 0, QS_READY, 60);
return (0);
}
/* Return drive status bits */
int
ftreq_status(ftu_t ftu, int cmd, int *sts, struct proc * p)
{
ft_p ft = &ft_data[ftu];
if (ft->active)
*sts = ft->laststs & ~QS_READY;
else
*sts = tape_status(ftu);
return (0);
}
/* Return drive configuration bits */
int
ftreq_config(ftu_t ftu, int cmd, int *cfg, struct proc * p)
{
int r, tries;
ft_p ft = &ft_data[ftu];
if (ft->active)
r = ft->lastcfg;
else {
for (r = -1, tries = 0; r < 0 && tries < 3; tries++)
r = qic_status(ftu, QC_CONFIG, 8);
if (tries == 3)
return (ENXIO);
}
*cfg = r;
return (0);
}
/* Return current tape's geometry. */
int
ftreq_geom(ftu_t ftu, QIC_Geom * g)
{
tape_inactive(ftu);
if (ftg == NULL && ftgetgeom(ftu) < 0)
return (ENXIO);
bcopy(ftg, g, sizeof(QIC_Geom));
return (0);
}
/* Return drive hardware information */
int
ftreq_hwinfo(ftu_t ftu, QIC_HWInfo * hwp)
{
int r, tries;
int rom, vend;
tape_inactive(ftu);
bzero(hwp, sizeof(QIC_HWInfo));
for (rom = -1, tries = 0; rom < 0 && tries < 3; tries++)
rom = qic_status(ftu, QC_VERSION, 8);
if (rom > 0) {
hwp->hw_rombeta = (rom >> 7) & 0x01;
hwp->hw_romid = rom & 0x7f;
}
for (vend = -1, tries = 0; vend < 0 && tries < 3; tries++)
vend = qic_status(ftu, QC_VENDORID, 16);
if (vend > 0) {
hwp->hw_make = (vend >> 6) & 0x3ff;
hwp->hw_model = vend & 0x3f;
}
return (0);
}
/*
* I/O functions.
*/
int
ftioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc * p)
{
ftu_t ftu = FDUNIT(minor(dev));
ft_p ft = &ft_data[ftu];
switch (cmd) {
case QIOREAD: /* Request reading a segment from tape. */
case QIOWRITE: /* Request writing a segment to tape. */
return (ftreq_rw(ftu, cmd, (QIC_Segment *) data, p));
case QIOREWIND: /* Rewind tape. */
return (ftreq_rewind(ftu));
case QIOBOT: /* Seek to logical beginning of track. */
case QIOEOT: /* Seek to logical end of track. */
return (ftreq_trkpos(ftu, cmd));
case QIOTRACK: /* Seek tape head to specified track. */
return (ftreq_trkset(ftu, (int *) data));
case QIOSEEKLP: /* Seek load point. */
goto badreq;
case QIOFORWARD: /* Move tape in logical forward direction. */
return (ftreq_lfwd(ftu));
case QIOSTOP: /* Causes tape to stop. */
return (ftreq_stop(ftu));
case QIOPRIMARY: /* Enter primary mode. */
case QIOFORMAT: /* Enter format mode. */
case QIOVERIFY: /* Enter verify mode. */
return (ftreq_setmode(ftu, cmd));
case QIOWRREF: /* Write reference burst. */
goto badreq;
case QIOSTATUS: /* Get drive status. */
return (ftreq_status(ftu, cmd, (int *) data, p));
case QIOCONFIG: /* Get tape configuration. */
return (ftreq_config(ftu, cmd, (int *) data, p));
case QIOGEOM:
return (ftreq_geom(ftu, (QIC_Geom *) data));
case QIOHWINFO:
return (ftreq_hwinfo(ftu, (QIC_HWInfo *) data));
}
badreq:
DPRT(("ft%d: unknown ioctl(%d) request\n", ftu, cmd));
return (ENXIO);
}
/* Not implemented */
int
ftdump(dev_t dev)
{
return (EINVAL);
}
/* Not implemented */
int
ftsize(dev_t dev)
{
return (EINVAL);
}
#endif
Reference in New Issue View Git Blame Copy Permalink