Skip to content

L
linux
Commit ee05e0b0 authored by Adrian Bunk's avatar Adrian Bunk Committed by Linus Torvalds
Browse files
Options

[PATCH] remove drivers/char/tpqic02.c 

Since at about half a year, this driver was no longer selectable via
Kconfig.

Since it seems noone missed this driver, therefore this patch removes
it.
Signed-off-by: default avatarAdrian Bunk <bunk@stusta.de>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 08b2d088
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 3643 deletions
drivers/char/Makefile
View file @ ee05e0b0
......@@ -73,7 +73,6 @@ obj-$(CONFIG_TOSHIBA) += toshiba.o
obj-$(CONFIG_I8K) += i8k.o
obj-$(CONFIG_DS1620) += ds1620.o
obj-$(CONFIG_HW_RANDOM) += hw_random.o
obj-$(CONFIG_QIC02_TAPE) += tpqic02.o
obj-$(CONFIG_FTAPE) += ftape/
obj-$(CONFIG_COBALT_LCD) += lcd.o
obj-$(CONFIG_PPDEV) += ppdev.o
......
drivers/char/tpqic02.c deleted 100644 → 0
View file @ 08b2d088
/* $Id: tpqic02.c,v 1.10 1997/01/26 07:13:20 davem Exp $
*
* Driver for tape drive support for Linux-i386
*
* Copyright (c) 1992--1996 by H. H. Bergman. All rights reserved.
* Current e-mail address: hennus@cybercomm.nl
*
* Distribution of this program in executable form is only allowed if
* all of the corresponding source files are made available through the same
* medium at no extra cost.
*
* I will not accept any responsibility for damage caused directly or
* indirectly by this program, or code derived from this program.
*
* Use this code at your own risk. Don't blame me if it destroys your data!
* Make sure you have a backup before you try this code.
*
* If you make changes to my code and redistribute it in source or binary
* form you must make it clear to even casual users of your code that you
* have modified my code, clearly point out what the changes exactly are
* (preferably in the form of a context diff file), how to undo your changes,
* where the original can be obtained, and that complaints/requests about the
* modified code should be directed to you instead of me.
*
* This driver was partially inspired by the 'wt' driver in the 386BSD
* source distribution, which carries the following copyright notice:
*
* Copyright (c) 1991 The Regents of the University of California.
* All rights reserved.
*
* You are not allowed to change this line nor the text above.
*
* 2001/02/26 Minor s/suser/capable/
*
* 1996/10/10 Emerald changes
*
* 1996/05/21 Misc changes+merges+cleanups + I/O reservations
*
* 1996/05/20 Module support patches submitted by Brian McCauley.
*
* 1994/05/03 Initial attempt at Mountain support for the Mountain 7150.
* Based on patches provided by Erik Jacobson. Still incomplete, I suppose.
*
* 1994/02/07 Archive changes & some cleanups by Eddy Olk.
*
* 1994/01/19 Speed measuring stuff moved from aperf.h to delay.h.
* BogoMips (tm) introduced by Linus.
*
* 1993/01/25 Kernel udelay. Eof fixups.
*
* 1992/09/19 Some changes based on patches by Eddy Olk to support
* Archive SC402/SC499R controller cards.
*
* 1992/05/27 First release.
*
* 1992/05/26 Initial version. Copyright H. H. Bergman 1992
*/
/* After the legalese, now the important bits:
*
* This is a driver for the Wangtek 5150 tape drive with
* a QIC-02 controller for ISA-PC type computers.
* Hopefully it will work with other QIC-02 tape drives as well.
*
* Make sure your setup matches the configuration parameters.
* Also, be careful to avoid IO conflicts with other devices!
*/
/*
#define TDEBUG
*/
#define REALLY_SLOW_IO /* it sure is ... */
#include <linux/module.h>
#include <linux/config.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/errno.h>
#include <linux/mtio.h>
#include <linux/fcntl.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/tpqic02.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/smp_lock.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/device.h>
#include <asm/dma.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/uaccess.h>
/* check existence of required configuration parameters */
#if !defined(QIC02_CMD_PORT) || !defined(QIC02_TAPE_IRQ) || !defined(QIC02_TAPE_DMA)
# error qic02_tape configuration error
#endif
#define TPQIC02_NAME "tpqic02"
/* Linux outb() commands have (value,port) as parameters.
* One might expect (port,value) instead, so beware!
*/
#ifdef CONFIG_QIC02_DYNCONF
/* This holds the dynamic configuration info for the interface
* card+drive info if runtime configuration has been selected.
*/
static struct mtconfiginfo qic02_tape_dynconf = {
/* user settable */
0, 0, BOGUS_IRQ, 0, 0, TPQD_DEFAULT_FLAGS,
};
static struct qic02_ccb qic02_tape_ccb; /* private stuff */
#else
static unsigned long qic02_tape_debug = TPQD_DEFAULT_FLAGS;
# if ((QIC02_TAPE_IFC!=WANGTEK) && (QIC02_TAPE_IFC!=ARCHIVE) && (QIC02_TAPE_IFC!=MOUNTAIN))
# error No valid interface card specified
# endif
#endif /* CONFIG_QIC02_DYNCONF */
static int ctlbits; /* control reg bits for tape interface */
static wait_queue_head_t qic02_tape_transfer; /* sync rw with interrupts */
static struct mtget ioctl_status; /* current generic status */
static struct tpstatus tperror; /* last drive status */
static char rcs_revision[] = "$Revision: 1.10 $";
static char rcs_date[] = "$Date: 1997/01/26 07:13:20 $";
/* Flag bits for status and outstanding requests.
* (Could all be put in one bit-field-struct.)
* Some variables need `volatile' because they may be modified
* by an interrupt.
*/
static flag status_dead = YES; /* device is legally dead until proven alive */
static flag status_zombie = YES; /* it's `zombie' until irq/dma allocated */
static flag status_bytes_wr = NO; /* write FM at close or not */
static flag status_bytes_rd = NO; /* (rd|wr) used for rewinding */
static volatile unsigned long status_cmd_pending; /* cmd in progress */
static flag status_expect_int = NO; /* ready for interrupts */
static flag status_timer_on = NO; /* using time-out */
static int status_error; /* int handler may detect error */
static flag status_eof_detected = NO; /* end of file */
static flag status_eom_detected = NO; /* end of recorded media */
static flag status_eot_detected = NO; /* end of tape */
static flag doing_read = NO;
static flag doing_write = NO;
static unsigned long dma_bytes_todo;
static unsigned long dma_bytes_done;
static volatile unsigned dma_mode; /* !=0 also means DMA in use */
static flag need_rewind = YES;
static int current_type;
static int extra_blocks_left = BLOCKS_BEYOND_EW;
static struct timer_list tp_timer;
static unsigned long tape_open; /* Guard open one only */
static DECLARE_MUTEX(tape_op); /* Serialize tape operations */
/* return_*_eof:
* NO: not at EOF,
* YES: tell app EOF was reached (return 0).
*
* return_*_eof==YES && reported_*_eof==NO ==>
* return current buffer, next time(s) return EOF.
*
* return_*_eof==YES && reported_*_eof==YES ==>
* at EOF and application knows it, so we can
* move on to the next file.
*
*/
static flag return_read_eof = NO; /* set to signal app EOF was reached */
static flag return_write_eof = NO;
static flag reported_read_eof = NO; /* set when we've done that */
static flag reported_write_eof = NO;
/* This is for doing `mt seek <blocknr>' */
static char seek_addr_buf[AR_SEEK_BUF_SIZE];
/* In write mode, we have to write a File Mark after the last block written,
* when the tape device is closed. Tape repositioning and reading in write
* mode is allowed as long as no actual writing has been done. After writing
* the File Mark, repositioning and reading are allowed again.
*/
static int mode_access; /* access mode: READ or WRITE */
static int qic02_get_resources(void);
static void qic02_release_resources(void);
/* This is a pointer to the actual kernel buffer where the interrupt routines
* read from/write to. It is needed because the DMA channels 1 and 3 cannot
* always access the user buffers. [The kernel buffer must reside in the
* lower 16MBytes of system memory because of the DMA controller.] The user
* must ensure that a large enough buffer is passed to the kernel, in order
* to reduce tape repositioning wear and tear.
*/
static void *buffaddr; /* virtual address of buffer */
/* This translates minor numbers to the corresponding recording format: */
static const char *format_names[] = {
"not set", /* for dumb drives unable to handle format selection */
"11", /* extinct */
"24",
"120",
"150",
"300", /* untested. */
"600" /* untested. */
};
static struct class_simple *tpqic02_class;
/* `exception_list' is needed for exception status reporting.
* Exceptions 1..14 are defined by QIC-02 rev F.
* The drive status is matched sequentially to each entry,
* ignoring irrelevant bits, until a match is found. If no
* match is found, exception number 0 is used. (That should of
* course never happen...) The original table was based on the
* "Exception Status Summary" in QIC-02 rev F, but some changes
* were required to make it work with real-world drives.
*
* Exception 2 (CNI) is changed to also cover status 0x00e0 (mask USL),
* Exception 4 (EOM) is changed to also cover status 0x8288 (mask EOR),
* Exception 11 (FIL) is changed to also cover status 0x0089 (mask EOM).
* Exception 15 (EOR) is added for seek-to-end-of-data (catch EOR),
* Exception 16 (BOM) is added for beginning-of-media (catch BOM).
*
* Had to swap EXC_NDRV and EXC_NCART to ensure that extended EXC_NCART
* (because of the incorrect Wangtek status code) doesn't catch the
* EXC_NDRV first.
*/
static struct exception_list_type {
unsigned short mask, code;
const char *msg;
/* EXC_nr attribute should match with tpqic02.h */
} exception_list[] = {
{ 0, 0, "Unknown exception status code", /* extra: 0 */ },
{ ~(0), TP_ST0 | TP_CNI | TP_USL | TP_WRP, "Drive not online" /* 1 */ }, /* Drive presence goes before cartridge presence. */
{ ~(TP_WRP | TP_USL), TP_ST0 | TP_CNI,
/* My Wangtek 5150EQ sometimes reports a status code
* of 0x00e0, which is not a valid exception code, but
* I think it should be recognized as "NO CARTRIDGE".
*/
"Cartridge not in place" /* 2 */ },
{ (unsigned short) ~(TP_ST1 | TP_BOM), (TP_ST0 | TP_WRP), "Write protected cartridge" /* 3 */ },
{ (unsigned short) ~(TP_ST1 | TP_EOR), (TP_ST0 | TP_EOM), "End of media" /* 4 */ },
{ ~TP_WRP, TP_ST0 | TP_UDA | TP_ST1 | TP_BOM, "Read or Write abort. Rewind tape." /* 5 */ },
{ ~TP_WRP, TP_ST0 | TP_UDA, "Read error. Bad block transferred." /* 6 */ },
{ ~TP_WRP, TP_ST0 | TP_UDA | TP_BNL, "Read error. Filler block transferred." /* 7 */ },
{ ~TP_WRP, TP_ST0 | TP_UDA | TP_BNL | TP_ST1 | TP_NDT, "Read error. No data detected." /* 8 */ },
{ ~TP_WRP, TP_ST0 | TP_EOM | TP_UDA | TP_BNL | TP_ST1 | TP_NDT, "Read error. No data detected. EOM." /* 9 */ },
{ ~(TP_WRP | TP_MBD | TP_PAR | TP_EOR), TP_ST0 | TP_UDA | TP_BNL | TP_ST1 | TP_NDT | TP_BOM, "Read error. No data detected. BOM." /* 10 */ },
{ ~(TP_WRP | TP_EOM), TP_ST0 | TP_FIL,
/* Status 0x0089 (EOM & FM) is viewed as an FM,
* because it can only happen during a read.
* EOM is checked separately for an FM condition.
*/
"File mark detected" /* 11 */ },
{ ~(TP_ST0 | TP_CNI | TP_USL | TP_WRP | TP_BOM), TP_ST1 | TP_ILL, "Illegal command" /* 12 */ },
{ ~(TP_ST0 | TP_CNI | TP_USL | TP_WRP | TP_BOM), TP_ST1 | TP_POR, "Reset occurred" /* 13 */ },
{ ~TP_WRP, TP_ST0 | TP_FIL | TP_MBD, /* NOTE: ST1 not set! */ "Marginal block detected" /* 14 */ },
{ ~(TP_ST0 | TP_WRP | TP_EOM | TP_UDA | TP_BNL | TP_FIL | TP_NDT), TP_ST1 | TP_EOR, /********** Is the extra TP_NDT really needed Eddy? **********/ "End of recorded media" /* extra: 15 */ },
/* 15 is returned when SEEKEOD completes successfully */
{ ~(TP_WRP | TP_ST0), TP_ST1 | TP_BOM, "Beginning of media" /* extra: 16 */ }
};
#define NR_OF_EXC (sizeof(exception_list)/sizeof(struct exception_list_type))
/* Compare expected struct size and actual struct size. This
* is useful to catch programs compiled with old #includes.
*/
#define CHECK_IOC_SIZE(structure) \
if (_IOC_SIZE(iocmd) != sizeof(struct structure)) { \
tpqputs(TPQD_ALWAYS, "sizeof(struct " #structure \
") does not match!"); \
return -EFAULT; \
} \
static void tpqputs(unsigned long flags, const char *s)
{
if ((flags & TPQD_ALWAYS) || (flags & QIC02_TAPE_DEBUG))
printk(TPQIC02_NAME ": %s\n", s);
} /* tpqputs */
/* Init control register bits on interface card.
* For Archive, interrupts must be enabled explicitly.
* Wangtek interface card requires ONLINE to be set, Archive SC402/SC499R
* cards keep it active all the time.
*/
static void ifc_init(void)
{
if (QIC02_TAPE_IFC == WANGTEK) { /* || (QIC02_TAPE_IFC == EVEREX) */
ctlbits = WT_CTL_ONLINE; /* online */
outb_p(ctlbits, QIC02_CTL_PORT);
} else if (QIC02_TAPE_IFC == ARCHIVE) {
ctlbits = 0; /* no interrupts yet */
outb_p(ctlbits, QIC02_CTL_PORT);
outb_p(0, AR_RESET_DMA_PORT); /* dummy write to reset DMA */
} else { /* MOUNTAIN */
ctlbits = MTN_CTL_ONLINE; /* online, and logic enabled */
outb_p(ctlbits, QIC02_CTL_PORT);
}
} /* ifc_init */
static void report_qic_exception(unsigned n)
{
if (n >= NR_OF_EXC) {
tpqputs(TPQD_ALWAYS, "Oops -- report_qic_exception");
n = 0;
}
if (TPQDBG(SENSE_TEXT) || n == 0)
printk(TPQIC02_NAME ": sense: %s\n", exception_list[n].msg);
} /* report_qic_exception */
/* Try to map the drive-exception bits `s' to a predefined "exception number",
* by comparing the significant exception bits for each entry in the
* exception table (`exception_list[]').
* It is assumed that s!=0.
*/
static int decode_qic_exception_nr(unsigned s)
{
int i;
for (i = 1; i < NR_OF_EXC; i++) {
if ((s & exception_list[i].mask) == exception_list[i].code) {
return i;
}
}
printk(TPQIC02_NAME ": decode_qic_exception_nr: exception(%x) not recognized\n", s);
return 0;
} /* decode_qic_exception_nr */
/* Perform appropriate action for certain exceptions.
* should return a value to indicate stop/continue (in case of bad blocks)
*/
static void handle_qic_exception(int exnr, int exbits)
{
if (exnr == EXC_NCART) {
/* Cartridge was changed. Redo sense().
* EXC_NCART should be handled in open().
* It is not permitted to remove the tape while
* the tape driver has open files.
*/
need_rewind = YES;
status_eof_detected = NO;
status_eom_detected = NO;
} else if (exnr == EXC_XFILLER) {
tpqputs(TPQD_ALWAYS,
"[Bad block -- filler data transferred.]");
} else if (exnr == EXC_XBAD) {
tpqputs(TPQD_ALWAYS, "[CRC failed!]");
} else if (exnr == EXC_MARGINAL) {
/* A marginal block behaves much like a FM.
* User may continue reading, if desired.
*/
tpqputs(TPQD_ALWAYS, "[Marginal block]");
doing_read = NO;
} else if (exnr == EXC_FM) {
doing_read = NO;
}
} /* handle_qic_exception */
static inline int is_exception(void)
{
return (inb(QIC02_STAT_PORT) & QIC02_STAT_EXCEPTION) == 0;
} /* is_exception */
/* Reset the tape drive and controller.
* When reset fails, it marks the drive as dead and all
* requests (except reset) are to be ignored (ENXIO).
*/
static int tape_reset(int verbose)
{
ifc_init(); /* reset interface card */
/* assert reset */
if (QIC02_TAPE_IFC == MOUNTAIN) {
outb_p(ctlbits & ~MTN_QIC02_CTL_RESET_NOT, QIC02_CTL_PORT);
} else { /* WANGTEK, ARCHIVE */
outb_p(ctlbits | QIC02_CTL_RESET, QIC02_CTL_PORT);
}
/* Next, we need to wait >=25 usec. */
udelay(30);
/* after reset, we will be at BOT (modulo an automatic rewind) */
status_eof_detected = NO;
status_eom_detected = NO;
status_cmd_pending = 0;
need_rewind = YES;
doing_read = doing_write = NO;
ioctl_status.mt_fileno = ioctl_status.mt_blkno = 0;
/* de-assert reset */
if (QIC02_TAPE_IFC == MOUNTAIN) {
outb_p(ctlbits | MTN_QIC02_CTL_RESET_NOT, QIC02_CTL_PORT);
} else {
outb_p(ctlbits & ~QIC02_CTL_RESET, QIC02_CTL_PORT);
}
/* KLUDGE FOR G++ BUG */
{
int stat = inb_p(QIC02_STAT_PORT);
status_dead = ((stat & QIC02_STAT_RESETMASK) != QIC02_STAT_RESETVAL);
}
/* if successful, inb(STAT) returned RESETVAL */
if (status_dead == YES)
printk(TPQIC02_NAME ": reset failed!\n");
else if (verbose)
printk(TPQIC02_NAME ": reset successful\n");
return (status_dead == YES) ? TE_DEAD : TE_OK;
} /* tape_reset */
/* Notify tape drive of a new command. It only waits for the
* command to be accepted, not for the actual command to complete.
*
* Before calling this routine, QIC02_CMD_PORT must have been loaded
* with the command to be executed.
* After this routine, the exception bit must be checked.
* This routine is also used by rdstatus(), so in that case, any exception
* must be ignored (`ignore_ex' flag).
*/
static int notify_cmd(char cmd, short ignore_ex)
{
int i;
outb_p(cmd, QIC02_CMD_PORT); /* output the command */
/* wait 1 usec before asserting /REQUEST */
udelay(1);
if ((!ignore_ex) && is_exception()) {
tpqputs(TPQD_ALWAYS, "*** exception detected in notify_cmd");
/** force a reset here **/
if (tape_reset(1) == TE_DEAD)
return TE_DEAD;
if (is_exception()) {
tpqputs(TPQD_ALWAYS, "exception persists after reset.");
tpqputs(TPQD_ALWAYS, " ^ exception ignored.");
}
}
outb_p(ctlbits | QIC02_CTL_REQUEST, QIC02_CTL_PORT); /* set request bit */
i = TAPE_NOTIFY_TIMEOUT;
/* The specs say this takes about 500 usec, but there is no upper limit!
* If the drive were busy retensioning or something like that,
* it could be *much* longer!
*/
while ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY) && (--i > 0))
udelay(1);
/* wait for ready */
if (i == 0) {
tpqputs(TPQD_ALWAYS, "timed out waiting for ready in notify_cmd");
status_dead = YES;
return TE_TIM;
}
outb_p(ctlbits & ~QIC02_CTL_REQUEST, QIC02_CTL_PORT); /* reset request bit */
i = TAPE_NOTIFY_TIMEOUT;
/* according to the specs this one should never time-out */
while (((inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY) == 0) && (--i > 0))
udelay(1);
/* wait for not ready */
if (i == 0) {
tpqputs(TPQD_ALWAYS, "timed out waiting for !ready in notify_cmd");
status_dead = YES;
return TE_TIM;
}
/* command accepted */
return TE_OK;
} /* notify_cmd */
/* Wait for a command to complete, with timeout */
static int wait_for_ready(time_t timeout)
{
int stat;
unsigned long spin_t;
/* Wait for ready or exception, without driving the loadavg up too much.
* In most cases, the tape drive already has READY asserted,
* so optimize for that case.
*
* First, busy wait a few usec:
*/
spin_t = 50;
while (((stat = inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK) && (--spin_t > 0))
udelay(1);
if ((stat & QIC02_STAT_READY) == 0)
return TE_OK; /* covers 99.99% of all calls */
/* Then use schedule() a few times */
spin_t = 3; /* max 0.03 sec busy waiting */
if (spin_t > timeout)
spin_t = timeout;
timeout -= spin_t;
spin_t += jiffies;
/* FIXME...*/
while (((stat = inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK) && time_before(jiffies, spin_t))
{
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(1); /* don't waste all the CPU time */
}
if ((stat & QIC02_STAT_READY) == 0)
return TE_OK;
/* If we reach this point, we probably need to wait much longer, or
* an exception occurred. Either case is not very time-critical.
* Check the status port only a few times every second.
* A interval of less than 0.10 sec will not be noticed by the user,
* more than 0.40 sec may give noticeable delays.
*/
spin_t += timeout;
TPQDEB({printk("wait_for_ready: additional timeout: %d\n", spin_t);})
/* not ready and no exception && timeout not expired yet */
while (((stat = inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK) && time_before(jiffies, spin_t)) {
/* be `nice` to other processes on long operations... */
/* nap 0.30 sec between checks, */
/* but could be woken up earlier by signals... */
msleep_interruptible(300);
}
/* don't use jiffies for this test because it may have changed by now */
if ((stat & QIC02_STAT_MASK) == QIC02_STAT_MASK) {
tpqputs(TPQD_ALWAYS, "wait_for_ready() timed out");
return TE_TIM;
}
if ((stat & QIC02_STAT_EXCEPTION) == 0) {
tpqputs(TPQD_ALWAYS, "exception detected after waiting_for_ready");
return TE_EX;
} else {
return TE_OK;
}
} /* wait_for_ready */
/* Send some data to the drive */
static int send_qic02_data(char sb[], unsigned size, int ignore_ex)
{
int i, stat;
for (i = 0; i < size; i++) {
stat = wait_for_ready(TIM_S);
if (stat != TE_OK)
return stat;
stat = notify_cmd(sb[i], ignore_ex);
if (stat != TE_OK)
return stat;
}
return TE_OK;
} /* send_qic02_data */
/* Send a QIC-02 command (`cmd') to the tape drive, with
* a time-out (`timeout').
* This one is also used by tp_sense(), so we must have
* a flag to disable exception checking (`ignore_ex').
*
* On entry, the controller is supposed to be READY.
*/
static int send_qic02_cmd(int cmd, time_t timeout, int ignore_ex)
{
int stat;
stat = inb_p(QIC02_STAT_PORT);
if ((stat & QIC02_STAT_EXCEPTION) == 0) { /* if exception */
tpqputs(TPQD_ALWAYS, "send_qic02_cmd: Exception!");
return TE_EX;
}
if (stat & QIC02_STAT_READY) { /* if not ready */
tpqputs(TPQD_ALWAYS, "send_qic02_cmd: not Ready!");
return TE_ERR;
}
/* assert(ready & !exception) */
/* Remember current command for later re-use with dma transfers.
* (For reading/writing multiple blocks.)
*/
status_cmd_pending = cmd;
stat = notify_cmd(cmd, ignore_ex); /* tell drive new command was loaded, */
/* inherit exception check. */
if (TP_HAVE_SEEK && (cmd == AR_QCMDV_SEEK_BLK)) {
/* This one needs to send 3 more bytes, MSB first */
stat = send_qic02_data(seek_addr_buf, sizeof(seek_addr_buf), ignore_ex);
}
if (stat != TE_OK) {
tpqputs(TPQD_ALWAYS, "send_qic02_cmd failed");
}
return stat;
} /* send_qic02_cmd */
/* Get drive status. Assume drive is ready or has exception set.
* (or will be in <1000 usec.)
* Extra parameters added because of 'Read Extended Status 3' command.
*/
static int rdstatus(char *stp, unsigned size, char qcmd)
{
int s, n;
char *q = stp;
/* Try to busy-wait a few (700) usec, after that de-schedule.
*
* The problem is, if we don't de-schedule, performance will
* drop to zero when the drive is not responding and if we
* de-schedule immediately, we waste a lot of time because a
* task switch is much longer than we usually have to wait here.
*/
n = 700;
while ((n > 0) && ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK))
{
udelay(1);
n--; /* wait for ready or exception or timeout */
}
if (n == 0) {
/* n (above) should be chosen such that on your machine
* you rarely ever see the message below, and it should
* be small enough to give reasonable response time.]
*/
/* FIXME */
tpqputs(TPQD_ALWAYS, "waiting looong in rdstatus() -- drive dead?");
while ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK)
{
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout(1);
}
tpqputs(TPQD_ALWAYS, "finished waiting in rdstatus()");
}
(void) notify_cmd(qcmd, 1); /* send read status command */
/* ignore return code -- should always be ok, STAT may contain
* exception flag from previous exception which we are trying to clear.
*/
if (TP_DIAGS(current_type))
printk(TPQIC02_NAME ": reading status bytes: ");
for (q = stp; q < stp + size; q++) {
do
s = inb_p(QIC02_STAT_PORT);
while ((s & QIC02_STAT_MASK) == QIC02_STAT_MASK); /* wait for ready or exception */
if ((s & QIC02_STAT_EXCEPTION) == 0) { /* if exception */
tpqputs(TPQD_ALWAYS, "rdstatus: exception error");
ioctl_status.mt_erreg = 0; /* dunno... */
return TE_NS; /* error, shouldn't happen... */
}
*q = inb_p(QIC02_DATA_PORT); /* read status byte */
if (TP_DIAGS(current_type))
printk("[%1zd]=0x%x ", q - stp, (unsigned) (*q) & 0xff);
outb_p(ctlbits | QIC02_CTL_REQUEST, QIC02_CTL_PORT); /* set request */
while ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY) == 0)
cpu_relax(); /* wait for not ready */
udelay(22); /* delay >20 usec */
outb_p(ctlbits & ~QIC02_CTL_REQUEST, QIC02_CTL_PORT); /* un-set request */
}
/* Specs say we should wait for READY here.
* My drive doesn't seem to need it here yet, but others do?
*/
while (inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY)
cpu_relax();
/* wait for ready */
if (TP_DIAGS(current_type))
printk("\n");
return TE_OK;
} /* rdstatus */
/* Get standard status (6 bytes).
* The `.dec' and `.urc' fields are in MSB-first byte-order,
* so they have to be swapped first.
*/
static int get_status(volatile struct tpstatus *stp)
{
int stat = rdstatus((char *) stp, TPSTATSIZE, QCMD_RD_STAT);
stp->dec = be16_to_cpu(stp->dec);
stp->urc = be16_to_cpu(stp->urc);
return stat;
} /* get_status */
#if 0
/* This fails for my Wangtek drive */
/* get "Extended Status Register 3" (64 bytes)
*
* If the meaning of the returned bytes were known, the MT_TYPE
* identifier could be used to decode them, since they are
* "vendor unique". :-(
*/
static int get_ext_status3(void)
{
char vus[64]; /* vendor unique status */
int stat, i;
tpqputs(TPQD_ALWAYS, "Attempting to read Extended Status 3...");
stat = rdstatus(vus, sizeof(vus), QCMD_RD_STAT_X3);
if (stat != TE_OK)
return stat;
tpqputs(TPQD_ALWAYS, "Returned status bytes:");
for (i = 0; i < sizeof(vus); i++) {
if (i % 8 == 0)
printk("\n" TPQIC02_NAME ": %2d:");
printk(" %2x", vus[i] & 0xff);
}
printk("\n");
return TE_OK;
} /* get_ext_status3 */
#endif
/* Read drive status and set generic status too.
* NOTE: Once we do a tp_sense(), read/write transfers are killed.
*/
static int tp_sense(int ignore)
{
unsigned err = 0, exnr = 0, gs = 0;
static void finish_rw(int cmd);
if (TPQDBG(SENSE_TEXT))
printk(TPQIC02_NAME ": tp_sense(ignore=0x%x) enter\n", ignore);
/* sense() is not allowed during a read or write cycle */
if (doing_write == YES)
tpqputs(TPQD_ALWAYS, "Warning: File Mark inserted because of sense() request");
/* The extra test is to avoid calling finish_rw during booting */
if ((doing_read != NO) || (doing_write != NO))
finish_rw(QCMD_RD_STAT);
if (get_status(&tperror) != TE_OK) {
tpqputs(TPQD_ALWAYS, "tp_sense: could not read tape drive status");
return TE_ERR;
}
err = tperror.exs; /* get exception status bits */
if (err & (TP_ST0 | TP_ST1))
printk(TPQIC02_NAME ": tp_sense: status: %x, error count: %d, underruns: %d\n",
tperror.exs, tperror.dec, tperror.urc);
else if ((tperror.dec != 0) || (tperror.urc != 0) || TPQDBG(SENSE_CNTS))
printk(TPQIC02_NAME ": tp_sense: no hard errors, soft error count: %d, underruns: %d\n", tperror.dec, tperror.urc);
/* Set generic status. HP-UX defines these, but some extra would
* be useful. Problem is to remain compatible. [Do we want to be
* compatible??]
*/
if (err & TP_ST0) {
if (err & TP_CNI) /* no cartridge */
gs |= GMT_DR_OPEN(-1);
if (status_dead == NO)
gs |= GMT_ONLINE(-1); /* always online */
if (err & TP_USL) /* not online */
gs &= ~GMT_ONLINE(-1);
if (err & TP_WRP)
gs |= GMT_WR_PROT(-1);
if (err & TP_EOM) { /* end of media */
gs |= GMT_EOT(-1); /* not sure this is correct for writes */
status_eom_detected = YES;
/* I don't know whether drive always reports EOF at or before EOM. */
status_eof_detected = YES;
}
/** if (err & TP_UDA) "Unrecoverable data error" **/
/** if (err & TP_BNL) "Bad block not located" **/
if (err & TP_FIL) {
gs |= GMT_EOF(-1);
status_eof_detected = YES;
}
}
if (err & TP_ST1) {
/** if (err & TP_ILL) "Illegal command" **/
/** if (err & TP_NDT) "No data detected" **/
/** if (err & TP_MBD) "Marginal block detected" **/
if (err & TP_BOM)
gs |= GMT_BOT(-1); /* beginning of tape */
}
ioctl_status.mt_gstat = gs;
ioctl_status.mt_dsreg = tperror.exs; /* "drive status" */
ioctl_status.mt_erreg = tperror.dec; /* "sense key error" */
if (err & (TP_ST0 | TP_ST1)) {
/* My Wangtek occasionally reports `status' 1212 which should be ignored. */
exnr = decode_qic_exception_nr(err);
handle_qic_exception(exnr, err); /* update driver state wrt drive status */
report_qic_exception(exnr);
}
err &= ~ignore; /* mask unwanted errors -- not the correct way, use exception nrs?? */
if (((err & TP_ST0) && (err & REPORT_ERR0)) ||
((err & TP_ST1) && (err & REPORT_ERR1)))
return TE_ERR;
return TE_OK;
} /* tp_sense */
/* Wait for a wind or rewind operation to finish or
* to time-out. (May take very long).
*/
static int wait_for_rewind(time_t timeout)
{
int stat;
stat = inb(QIC02_STAT_PORT) & QIC02_STAT_MASK;
if (TPQDBG(REWIND))
printk(TPQIC02_NAME ": Waiting for (re-)wind to finish: stat=0x%x\n", stat);
stat = wait_for_ready(timeout);
if (stat != TE_OK) {
tpqputs(TPQD_ALWAYS, "(re-) winding failed\n");
}
return stat;
} /* wait_for_rewind */
/* Perform a full QIC02 command, and wait for completion,
* check status when done. Complain about exceptions.
*
* This function should return an OS error code when
* something goes wrong, 0 otherwise.
*/
static int ll_do_qic_cmd(int cmd, time_t timeout)
{
int stat;
if (status_dead == YES) {
tpqputs(TPQD_ALWAYS, "Drive is dead. Do a `mt reset`.");
return -ENXIO; /* User should do an MTRESET. */
}
stat = wait_for_ready(timeout); /* wait for ready or exception */
if (stat == TE_EX) {
if (tp_sense(TP_WRP | TP_BOM | TP_EOM | TP_FIL) != TE_OK)
return -EIO;
/* else nothing to worry about, I hope */
stat = TE_OK;
}
if (stat != TE_OK) {
printk(TPQIC02_NAME ": ll_do_qic_cmd(%x, %ld) failed\n", cmd, (long) timeout);
return -EIO;
}
#ifdef OBSOLETE
/* wait for ready since it may not be active immediately after reading status */
while ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY) != 0)
cpu_relax();
#endif
stat = send_qic02_cmd(cmd, timeout, 0); /* (checks for exceptions) */
if (cmd == QCMD_RD_FM) {
status_eof_detected = NO;
ioctl_status.mt_fileno++;
/* Should update block count as well, but can't.
* Can do a `read address' for some drives, when MTNOP is done.
*/
} else if (cmd == QCMD_WRT_FM) {
status_eof_detected = NO;
ioctl_status.mt_fileno++;
} else if ((cmd == QCMD_REWIND) || (cmd == QCMD_ERASE)
|| (cmd == QCMD_RETEN)) {
status_eof_detected = NO;
status_eom_detected = NO;
status_eot_detected = NO;
need_rewind = NO;
ioctl_status.mt_fileno = ioctl_status.mt_blkno = 0;
extra_blocks_left = BLOCKS_BEYOND_EW;
return_write_eof = NO;
return_read_eof = NO;
reported_read_eof = NO;
reported_write_eof = NO;
}
/* sense() will set eof/eom as required */
if (stat == TE_EX) {
if (tp_sense(TP_WRP | TP_BOM | TP_EOM | TP_FIL) != TE_OK) {
printk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[1](%x, %ld)", cmd, (long) timeout);
status_dead = YES;
return -ENXIO;
/* if rdstatus fails too, we're in trouble */
}
} else if (stat != TE_OK) {
printk(TPQIC02_NAME ": ll_do_qic_cmd: send_qic02_cmd failed, stat = 0x%x\n", stat);
return -EIO; /*** -EIO is probably not always appropriate */
}
if (timeout == TIM_R)
stat = wait_for_rewind(timeout);
else
stat = wait_for_ready(timeout);
if (stat == TE_EX) {
if (tp_sense((cmd == QCMD_SEEK_EOD ? /*****************************/
TP_EOR | TP_NDT | TP_UDA | TP_BNL | TP_WRP |
TP_BOM | TP_EOM | TP_FIL : TP_WRP | TP_BOM |
TP_EOM | TP_FIL)) != TE_OK) {
printk(TPQIC02_NAME ": Exception persist in ll_do_qic_cmd[2](%x, %ld)\n", cmd, (long) timeout);
if (cmd != QCMD_RD_FM)
status_dead = YES;
return -ENXIO;
/* if rdstatus fails too, we're in trouble */
}
} else if (stat != TE_OK) {
printk(TPQIC02_NAME ": ll_do_qic_cmd %x: wait failed, stat == 0x%x\n", cmd, stat);
return -EIO;
}
return 0;
} /* ll_do_qic_cmd */
/*
* Problem: What to do when the user cancels a read/write operation
* in-progress?
*
* "Deactivating ONLINE during a READ also causes the"
* "tape to be rewound to BOT." Ditto for WRITEs, except
* a FM is written first. "The host may alternatively terminate
* the READ/WRITE command by issuing a RFM/WFM command."
*
* For READs:
* Neither option will leave the tape positioned where it was.
* Another (better?) solution is to terminate the READ by two
* subsequent sense() operations, the first to stop the current
* READ cycle, the second to clear the `Illegal command' exception,
* because the QIC-02 specs didn't anticipate this. This is
* delayed until actually needed, so a tar listing can be aborted
* by the user and continued later.
* If anybody has a better solution, let me know! [Also, let me
* know if your drive (mine is a Wangtek5150EQ) does not accept
* this sequence for canceling the read-cycle.]
*
* For WRITEs it's simple: Just do a WRITE_FM, leaving the tape
* positioned after the FM.
*/
static void terminate_read(int cmd)
{
if (doing_read != YES)
return;
doing_read = NO;
if (cmd == QCMD_RD_FM)
return;
/* if the command is a RFM, there is no need to do this
* because a RFM will legally terminate the read-cycle.
*/
tpqputs(TPQD_ALWAYS, "terminating pending read-cycle");
/* I'm not too sure about this part -- hhb */
if (QIC02_TAPE_IFC == MOUNTAIN) {
/* Mountain reference says can terminate by de-asserting online */
ctlbits &= ~MTN_QIC02_CTL_ONLINE;
}
if (tp_sense(TP_FIL | TP_EOM | TP_WRP) != TE_OK) {
tpqputs(TPQD_ALWAYS, "finish_rw[read1]: ignore the 2 lines above");
if (is_exception()) {
if (tp_sense(TP_ILL | TP_FIL | TP_EOM | TP_WRP) != TE_OK)
tpqputs(TPQD_ALWAYS,"finish_rw[read2]: read cycle error");
}
}
} /* terminate_read */
static void terminate_write(int cmd)
{
int stat;
if (doing_write != YES)
return;
doing_write = NO;
/* Finish writing by appending a FileMark at the end. */
if (cmd != QCMD_WRT_FM) {
/* finish off write cycle */
stat = ll_do_qic_cmd(QCMD_WRT_FM, TIM_M);
if (stat != TE_OK)
tpqputs(TPQD_ALWAYS, "Couldn't finish write cycle properly");
(void) tp_sense(0);
}
/* If there is an EOF token waiting to be returned to
* the (writing) application, discard it now.
* We could be at EOT, so don't reset return_write_eof.
*/
reported_write_eof = YES;
} /* terminate_write */
/* terminate read or write cycle because of command `cmd' */
static void finish_rw(int cmd)
{
if (wait_for_ready(TIM_S) != TE_OK) {
tpqputs(TPQD_ALWAYS, "error: drive not ready in finish_rw() !");
return;
}
terminate_read(cmd);
terminate_write(cmd);
} /* finish_rw */
/* Perform a QIC command through ll_do_qic_cmd().
* If necessary, rewind the tape first.
* Return an OS error code if something goes wrong, 0 if all is well.
*/
static int do_qic_cmd(int cmd, time_t timeout)
{
int stat;
finish_rw(cmd);
if (need_rewind) {
tpqputs(TPQD_REWIND, "Rewinding tape...");
stat = ll_do_qic_cmd(QCMD_REWIND, TIM_R);
if (stat != 0) {
printk(TPQIC02_NAME ": rewind failed in do_qic_cmd(). stat=0x%2x", stat);
return stat;
}
need_rewind = NO;
if (cmd == QCMD_REWIND) /* don't wind beyond BOT ;-) */
return 0;
}
return ll_do_qic_cmd(cmd, timeout);
} /* do_qic_cmd */
/* Not all ioctls are supported for all drives. Some rely on
* optional QIC-02 commands. Check tpqic02.h for configuration.
* Some of these commands may require ONLINE to be active.
*/
static int do_ioctl_cmd(int cmd)
{
int stat;
/* It is not permitted to read or wind the tape after bytes have
* been written. It is not permitted to write the tape while in
* read mode.
* We try to be kind and allow reading again after writing a FM...
*/
switch (cmd) {
case MTRESET:
/* reset verbose */
return (tape_reset(1) == TE_OK) ? 0 : -EIO;
case MTFSF:
tpqputs(TPQD_IOCTLS, "MTFSF forward searching filemark");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
return do_qic_cmd(QCMD_RD_FM, TIM_F);
case MTBSF:
if (TP_HAVE_BSF) {
tpqputs(TPQD_IOCTLS, "MTBSF backward searching filemark -- optional command");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
stat = do_qic_cmd(QCMD_RD_FM_BCK, TIM_F);
} else {
stat = -ENXIO;
}
status_eom_detected = status_eof_detected = NO;
return stat;
case MTFSR:
if (TP_HAVE_FSR) { /* This is an optional QIC-02 command */
tpqputs(TPQD_IOCTLS, "MTFSR forward space record");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
stat = do_qic_cmd(QCMD_SPACE_FWD, TIM_F);
} else {
/**** fake it by doing a read data block command? ******/
tpqputs(TPQD_IOCTLS, "MTFSR not supported");
stat = -ENXIO;
}
return stat;
case MTBSR:
if (TP_HAVE_BSR) { /* This is an optional QIC-02 command */
/* we need this for appending files with GNU tar!! */
tpqputs(TPQD_IOCTLS, "MTFSR backward space record");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
stat = do_qic_cmd(QCMD_SPACE_BCK, TIM_F);
} else {
tpqputs(TPQD_IOCTLS, "MTBSR not supported");
stat = -ENXIO;
}
status_eom_detected = status_eof_detected = NO;
return stat;
case MTWEOF:
tpqputs(TPQD_IOCTLS, "MTWEOF write eof mark");
/* Plain GNU mt(1) 2.2 uses read-only mode for writing FM. :-( */
if (mode_access == READ)
return -EACCES;
/* allow tape movement after writing FM */
status_bytes_rd = status_bytes_wr; /* Kludge-O-Matic */
status_bytes_wr = NO;
return do_qic_cmd(QCMD_WRT_FM, TIM_M);
/* not sure what to do with status_bytes when WFM should fail */
case MTREW:
tpqputs(TPQD_IOCTLS, "MTREW rewinding tape");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
status_eom_detected = status_eof_detected = NO;
return do_qic_cmd(QCMD_REWIND, TIM_R);
case MTOFFL:
tpqputs(TPQD_IOCTLS, "MTOFFL rewinding & going offline");
/* Doing a drive select will clear (unlock) the current drive.
* But that requires support for multiple drives and locking.
*/
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
status_eom_detected = status_eof_detected = NO;
/**** do rewind depending on minor bits??? ***/
stat = do_qic_cmd(QCMD_REWIND, TIM_R);
return stat;
case MTNOP:
tpqputs(TPQD_IOCTLS, "MTNOP setting status only");
/********** should do `read position' for drives that support it **********/
return (tp_sense(-1) == TE_OK) ? 0 : -EIO; /**** check return codes ****/
case MTRETEN:
tpqputs(TPQD_IOCTLS, "MTRETEN retension tape");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
status_eom_detected = status_eof_detected = NO;
return do_qic_cmd(QCMD_RETEN, TIM_R);
case MTBSFM:
/* Think think is like MTBSF, except that
* we shouldn't skip the FM. Tricky.
* Maybe use RD_FM_BCK, then do a SPACE_FWD?
*/
tpqputs(TPQD_IOCTLS, "MTBSFM not supported");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
return -ENXIO;
case MTFSFM:
/* I think this is like MTFSF, except that
* we shouldn't skip the FM. Tricky.
* Maybe use QCMD_RD_DATA until we get a TP_FIL exception?
* But then the FM will have been skipped...
* Maybe use RD_FM, then RD_FM_BCK, but not all
* drives will support that!
*/
tpqputs(TPQD_IOCTLS, "MTFSFM not supported");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
return -ENXIO;
case MTEOM:
/* This should leave the tape ready for appending
* another file to the end, such that it would append
* after the last FM on tape.
*/
tpqputs(TPQD_IOCTLS, "MTEOM search for End Of recorded Media");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
if (TP_HAVE_EOD) {
/* Use faster seeking when possible.
* This requires the absence of data beyond the EOM.
* It seems that my drive does not always perform the
* SEEK_EOD correctly, unless it is preceded by a
* rewind command.
*/
# if 0
status_eom_detected = status_eof_detected = NO;
# endif
stat = do_qic_cmd(QCMD_REWIND, TIM_R);
if (stat)
return stat;
stat = do_qic_cmd(QCMD_SEEK_EOD, TIM_F);
/* After a successful seek, TP_EOR should be returned */
} else {
/* else just seek until the drive returns exception "No Data" */
stat = 0;
while ((stat == 0) && (!status_eom_detected)) {
stat = do_qic_cmd(QCMD_RD_FM, TIM_F); /***** should use MTFSFM here???? ******/
}
if (tperror.exs & TP_NDT)
return 0;
}
return stat;
case MTERASE:
tpqputs(TPQD_IOCTLS, "MTERASE -- ERASE TAPE !");
if ((tperror.exs & TP_ST0) && (tperror.exs & TP_WRP)) {
tpqputs(TPQD_ALWAYS, "Cartridge is write-protected.");
return -EACCES;
} else {
time_t t = jiffies;
/* Plain GNU mt(1) 2.2 erases a tape in O_RDONLY. :-( */
if (mode_access == READ)
return -EACCES;
/* FIXME */
/* give user a few seconds to pull out tape */
while (jiffies - t < 4 * HZ)
schedule();
}
/* don't bother writing filemark first */
status_eom_detected = status_eof_detected = NO;
return do_qic_cmd(QCMD_ERASE, TIM_R);
case MTRAS1:
if (TP_HAVE_RAS1) {
tpqputs(TPQD_IOCTLS, "MTRAS1: non-destructive self test");
stat = do_qic_cmd(QCMD_SELF_TST1, TIM_R);
if (stat != 0) {
tpqputs(TPQD_ALWAYS, "RAS1 failed");
return stat;
}
return (tp_sense(0) == TE_OK) ? 0 : -EIO; /* get_ext_status3(); */
}
tpqputs(TPQD_IOCTLS, "RAS1 not supported");
return -ENXIO;
case MTRAS2:
if (TP_HAVE_RAS2) {
tpqputs(TPQD_IOCTLS, "MTRAS2: destructive self test");
stat = do_qic_cmd(QCMD_SELF_TST2, TIM_R);
if (stat != 0) {
tpqputs(TPQD_ALWAYS, "RAS2 failed");
return stat;
}
return (tp_sense(0) == TE_OK) ? 0 : -EIO; /* get_ext_status3(); */
}
tpqputs(TPQD_IOCTLS, "RAS2 not supported");
return -ENXIO;
case MTSEEK:
if (TP_HAVE_SEEK && (QIC02_TAPE_IFC == ARCHIVE)) {
tpqputs(TPQD_IOCTLS, "MTSEEK seeking block");
if ((mode_access == WRITE) && status_bytes_wr)
return -EACCES;
/* NOTE: address (24 bits) is in seek_addr_buf[] */
return do_qic_cmd(AR_QCMDV_SEEK_BLK, TIM_F);
} else
return -ENOTTY;
default:
return -ENOTTY;
}
} /* do_ioctl_cmd */
/* dma_transfer(): This routine is called for every 512 bytes to be read
* from/written to the tape controller. Speed is important here!
* (There must be enough time left for the hd controller!)
* The dma lock protects the DMA controller
*
* This routine merely does the least possible to keep
* the transfers going:
* - set the DMA count register for the next 512 bytes
* - adjust the DMA address and page registers
* - adjust the timeout
* - tell the tape controller to start transferring
* We assume the dma address and mode are, and remain, valid.
*/
static inline void dma_transfer(void)
{
unsigned long flags;
if (QIC02_TAPE_IFC == WANGTEK) /* or EVEREX */
outb_p(WT_CTL_ONLINE, QIC02_CTL_PORT); /* back to normal */
else if (QIC02_TAPE_IFC == ARCHIVE)
outb_p(0, AR_RESET_DMA_PORT);
else /* QIC02_TAPE_IFC == MOUNTAIN */
outb_p(ctlbits, QIC02_CTL_PORT);
flags = claim_dma_lock();
clear_dma_ff(QIC02_TAPE_DMA);
set_dma_mode(QIC02_TAPE_DMA, dma_mode);
set_dma_addr(QIC02_TAPE_DMA, isa_virt_to_bus(buffaddr) + dma_bytes_done);
set_dma_count(QIC02_TAPE_DMA, TAPE_BLKSIZE);
/* start tape DMA controller */
if (QIC02_TAPE_IFC == WANGTEK) /* or EVEREX */
outb_p(WT_CTL_DMA | WT_CTL_ONLINE, QIC02_CTL_PORT); /* trigger DMA transfer */
else if (QIC02_TAPE_IFC == ARCHIVE) {
outb_p(AR_CTL_IEN | AR_CTL_DNIEN, QIC02_CTL_PORT); /* enable interrupts again */
outb_p(0, AR_START_DMA_PORT); /* start DMA transfer */
/* In dma_end() AR_RESET_DMA_PORT is written too. */
} else { /* QIC02_TAPE_IFC == MOUNTAIN */
inb(MTN_R_DESELECT_DMA_PORT);
outb_p(ctlbits | (MTN_CTL_EXC_IEN | MTN_CTL_DNIEN),
QIC02_CTL_PORT);
outb_p(0, MTN_W_SELECT_DMA_PORT); /* start DMA transfer */
if (dma_mode == DMA_MODE_WRITE)
outb_p(0, MTN_W_DMA_WRITE_PORT); /* start DMA transfer */
}
/* start computer DMA controller */
enable_dma(QIC02_TAPE_DMA);
release_dma_lock(flags);
/* block transfer should start now, jumping to the
* interrupt routine when done or an exception was detected.
*/
} /* dma_transfer */
/* start_dma() sets a DMA transfer up between the tape controller and
* the kernel qic02_tape_buf buffer.
* Normally bytes_todo==dma_bytes_done at the end of a DMA transfer. If not,
* a filemark was read, or an attempt to write beyond the End Of Tape
* was made. [Or some other bad thing happened.]
* Must do a sense() before returning error.
*/
static int start_dma(short mode, unsigned long bytes_todo)
/* assume 'bytes_todo'>0 */
{
int stat;
tpqputs(TPQD_DEBUG, "start_dma() enter");
TPQDEB( {printk(TPQIC02_NAME ": doing_read==%d, doing_write==%d\n",
doing_read, doing_write);})
dma_bytes_done = 0;
dma_bytes_todo = bytes_todo;
status_error = NO;
/* dma_mode!=0 indicates that the dma controller is in use */
dma_mode = (mode == WRITE) ? DMA_MODE_WRITE : DMA_MODE_READ;
/* Only give READ/WRITE DATA command to tape drive if we haven't
* done that already. Otherwise the drive will rewind to the beginning
* of the current file on tape. Any QIC command given other than
* R/W FM will break the read/write transfer cycle.
* do_qic_cmd() will terminate doing_{read,write}
*/
if ((doing_read == NO) && (doing_write == NO)) {
/* First, we have to clear the status -- maybe remove TP_FIL???
*/
#if 0
/* Next dummy get status is to make sure CNI is valid,
since we're only just starting a read/write it doesn't
matter some exceptions are cleared by reading the status;
we're only interested in CNI and WRP. -Eddy */
get_status(&tperror);
#else
/* TP_CNI should now be handled in open(). -Hennus */
#endif
stat = tp_sense(((mode == WRITE) ? 0 : TP_WRP) | TP_BOM | TP_FIL);
if (stat != TE_OK)
return stat;
#ifdef OBSOLETE
/************* not needed iff rd_status() would wait for ready!!!!!! **********/
if (wait_for_ready(TIM_S) != TE_OK) { /*** not sure this is needed ***/
tpqputs(TPQD_ALWAYS, "wait_for_ready failed in start_dma");
return -EIO;
}
#endif
if (QIC02_TAPE_IFC == MOUNTAIN) {
/* Set control bits to select ONLINE during command */
ctlbits |= MTN_QIC02_CTL_ONLINE;
}
/* Tell the controller the data direction */
/* r/w, timeout medium, check exceptions, sets status_cmd_pending. */
stat = send_qic02_cmd((mode == WRITE) ? QCMD_WRT_DATA : QCMD_RD_DATA, TIM_M, 0);
if (stat != TE_OK) {
printk(TPQIC02_NAME ": start_dma: init %s failed\n", (mode == WRITE) ? "write" : "read");
(void) tp_sense(0);
return stat;
}
/* Do this last, because sense() will clear the doing_{read,write}
* flags, causing trouble next time around.
*/
if (wait_for_ready(TIM_M) != TE_OK)
return -EIO;
switch (mode) {
case READ:
doing_read = YES;
break;
case WRITE:
doing_write = YES;
break;
default:
printk(TPQIC02_NAME ": requested unknown mode %d\n", mode);
panic(TPQIC02_NAME ": invalid mode in start_dma()");
}
} else if (is_exception()) {
/* This is for Archive drives, to handle reads with 0 bytes
* left for the last read request.
*
* ******** this also affects EOF/EOT handling! ************
*/
tpqputs(TPQD_ALWAYS, "detected exception in start_dma() while transfer in progress");
status_error = YES;
return TE_END;
}
status_expect_int = YES;
/* This assumes tape is already positioned, but these
* semi-'intelligent' drives are unpredictable...
*/
TIMERON(TIM_M * 2);
/* initiate first data block read from/write to the tape controller */
dma_transfer();
TPQPUTS("start_dma() end");
return TE_OK;
} /* start_dma */
/* This cleans up after the dma transfer has completed
* (or failed). If an exception occurred, a sense()
* must be done. If the exception was caused by a FM,
* sense() will set `status_eof_detected' and
* `status_eom_detected', as required.
*/
static void end_dma(unsigned long *bytes_done)
{
int stat = TE_OK;
unsigned long flags;
TIMEROFF;
TPQPUTS("end_dma() enter");
flags = claim_dma_lock();
disable_dma(QIC02_TAPE_DMA);
clear_dma_ff(QIC02_TAPE_DMA);
release_dma_lock(flags);
if (QIC02_TAPE_IFC == WANGTEK) /* or EVEREX */
outb_p(WT_CTL_ONLINE, QIC02_CTL_PORT); /* back to normal */
else if (QIC02_TAPE_IFC == ARCHIVE)
outb_p(0, AR_RESET_DMA_PORT);
else { /* QIC02_TAPE_IFC == MOUNTAIN */
/* Clear control bits, de-select ONLINE during tp_sense */
ctlbits &= ~MTN_QIC02_CTL_ONLINE;
}
stat = wait_for_ready(TIM_M);
if (status_error || (stat != TE_OK)) {
tpqputs(TPQD_DMAX, "DMA transfer exception");
stat = tp_sense((dma_mode == READ) ? TP_WRP : 0);
/* no return here -- got to clean up first! */
} else { /* if (QIC02_TAPE_IFC == MOUNTAIN) */
outb_p(ctlbits, QIC02_CTL_PORT);
}
if (QIC02_TAPE_IFC == MOUNTAIN)
inb(MTN_R_DESELECT_DMA_PORT);
/* take the tape controller offline */
/* finish off DMA stuff */
dma_mode = 0;
/* Note: The drive is left on-line, ready for the next
* data transfer.
* If the next command to the drive does not continue
* the pending cycle, it must do 2 sense()s first.
*/
*bytes_done = dma_bytes_done;
status_expect_int = NO;
ioctl_status.mt_blkno += (dma_bytes_done / TAPE_BLKSIZE);
TPQPUTS("end_dma() exit");
/*** could return stat here ***/
} /* end_dma */
/*********** Below are the (public) OS-interface procedures ***********/
/* qic02_tape_times_out() is called when a DMA transfer doesn't complete
* quickly enough. Usually this means there is something seriously wrong
* with the hardware/software, but it could just be that the controller
* has decided to do a long rewind, just when I didn't expect it.
* Just try again.
*/
static void qic02_tape_times_out(unsigned long dummy)
{
printk("time-out in %s driver\n", TPQIC02_NAME);
if ((status_cmd_pending > 0) || dma_mode) {
/* takes tooo long, shut it down */
status_dead = YES;
status_cmd_pending = 0;
status_timer_on = NO;
status_expect_int = NO;
status_error = YES;
if (dma_mode) {
dma_mode = 0; /* signal end to read/write routine */
wake_up(&qic02_tape_transfer);
}
}
} /* qic02_tape_times_out */
/*
* Interrupt handling:
*
* 1) Interrupt is generated iff at the end of
* a 512-DMA-block transfer.
* 2) EXCEPTION is not raised unless something
* is wrong or EOT/FM is detected.
* 3) FM EXCEPTION is set *after* the last byte has
* been transferred by DMA. By the time the interrupt
* is handled, the EXCEPTION may already be set.
*
* So,
* 1) On EXCEPTION, assume data has been transferred, so
* continue as usual, but set a flag to indicate the
* exception was detected.
* Do a sense status when the flag is found set.
* 2) Do not attempt to continue a transfer after an exception.
* [??? What about marginal blocks???????]
*/
/* qic02_tape_interrupt() is called when the tape controller completes
* a DMA transfer.
* We are not allowed to sleep here!
*
* Check if the transfer was successful, check if we need to transfer
* more. If the buffer contains enough data/is empty enough, signal the
* read/write() thread to copy to/from user space.
* When we are finished, set flags to indicate end, disable timer.
* NOTE: This *must* be fast!
*/
static irqreturn_t qic02_tape_interrupt(int irq, void *dev_id,
struct pt_regs *regs)
{
int stat, r, i;
unsigned long flags;
TIMEROFF;
if (status_expect_int) {
#ifdef WANT_EXTRA_FULL_DEBUGGING
if (TP_DIAGS(current_type))
printk("@");
#endif
stat = inb(QIC02_STAT_PORT); /* Knock, knock */
if (QIC02_TAPE_IFC == ARCHIVE) { /* "Who's there?" */
if (((stat & (AR_STAT_DMADONE)) == 0) &&
((stat & (QIC02_STAT_EXCEPTION)) != 0)) {
TIMERCONT;
return IRQ_NONE;/* "Linux with IRQ sharing" */
}
}
if ((stat & QIC02_STAT_EXCEPTION) == 0) { /* exception occurred */
/* Possible causes for an exception during a transfer:
* - during a write-cycle: end of tape (EW) hole detected.
* - during a read-cycle: filemark or EOD detected.
* - something went wrong
* So don't continue with the next block.
*/
tpqputs(TPQD_ALWAYS, "isr: exception on tape controller");
printk(" status %02x\n", stat);
status_error = TE_EX;
dma_bytes_done += TAPE_BLKSIZE;
dma_mode = 0; /* wake up rw() */
status_expect_int = NO;
wake_up(&qic02_tape_transfer);
return IRQ_HANDLED;
}
/* return if tape controller not ready, or
* if dma channel hasn't finished last byte yet.
*/
r = 0;
/* Skip next ready check for Archive controller because
* it may be busy reading ahead. Weird. --hhb
*/
if (QIC02_TAPE_IFC == WANGTEK) /* I think this is a drive-dependency, not IFC -- hhb */
if (stat & QIC02_STAT_READY) { /* not ready */
tpqputs(TPQD_ALWAYS, "isr: ? Tape controller not ready");
r = 1;
}
flags = claim_dma_lock();
if ((i = get_dma_residue(QIC02_TAPE_DMA)) != 0) {
printk(TPQIC02_NAME ": dma_residue == %x !!!\n", i);
r = 1; /* big trouble, but can't do much about it... */
}
release_dma_lock(flags);
if (r)
return IRQ_HANDLED;
/* finish DMA cycle */
/* no errors detected, continue */
dma_bytes_done += TAPE_BLKSIZE;
if (dma_bytes_done >= dma_bytes_todo) {
/* finished! Wakeup rw() */
dma_mode = 0;
status_expect_int = NO;
TPQPUTS("isr: dma_bytes_done");
wake_up(&qic02_tape_transfer);
} else {
/* start next transfer, account for track-switching time */
mod_timer(&tp_timer, jiffies + 6 * HZ);
dma_transfer();
}
} else {
printk(TPQIC02_NAME ": Unexpected interrupt, stat == %x\n", inb(QIC02_STAT_PORT));
}
return IRQ_HANDLED;
} /* qic02_tape_interrupt */
/* read/write routines:
* This code copies between a kernel buffer and a user buffer. The
* actual data transfer is done using DMA and interrupts. Time-outs
* are also used.
*
* When a filemark is read, we return '0 bytes read' and continue with the
* next file after that.
* When EOM is read, we return '0 bytes read' twice.
* When the EOT marker is detected on writes, '0 bytes read' should be
* returned twice. If user program does a MTNOP after that, 2 additional
* blocks may be written. ------- FIXME: Implement this correctly *************************************************
*
* Only read/writes in multiples of 512 bytes are accepted.
* When no bytes are available, we sleep() until they are. The controller will
* generate an interrupt, and we (should) get a wake_up() call.
*
* Simple buffering is used. User program should ensure that a large enough
* buffer is used. Usually the drive does some buffering as well (something
* like 4k or so).
*
* Scott S. Bertilson suggested to continue filling the user buffer, rather
* than waste time on a context switch, when the kernel buffer fills up.
*/
/*
* Problem: tar(1) doesn't always read the entire file. Sometimes the entire file
* has been read, but the EOF token is never returned to tar(1), simply because
* tar(1) knows it has already read all of the data it needs. So we must use
* open/release to reset the `reported_read_eof' flag. If we don't, the next read
* request would return the EOF flag for the previous file.
*/
static ssize_t qic02_tape_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
{
int type = iminor(filp->f_dentry->d_inode);
unsigned short flags = filp->f_flags;
unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
int stat;
if (status_zombie == YES) {
tpqputs(TPQD_ALWAYS, "configs not set");
return -ENXIO;
}
if (TP_DIAGS(current_type))
printk(TPQIC02_NAME ": request READ, minor=%x, buf=%p, count=%lx, pos=%Lx, flags=%x\n", type, buf,
(long) count, filp->f_pos, flags);
if (count % TAPE_BLKSIZE) { /* Only allow mod 512 bytes at a time. */
tpqputs(TPQD_BLKSZ, "Wrong block size");
return -EINVAL;
}
/* Just assume everything is ok. Controller will scream if not. */
if (status_bytes_wr) { /* Once written, no more reads, 'till after WFM. */
return -EACCES;
}
/* This is rather ugly because it has to implement a finite state
* machine in order to handle the EOF situations properly.
*/
while ((signed) count >= 0) {
bytes_done = 0;
/* see how much fits in the kernel buffer */
bytes_todo = TPQBUF_SIZE;
if (bytes_todo > count) {
bytes_todo = count;
}
/* Must ensure that user program sees exactly one EOF token (==0) */
if (return_read_eof == YES) {
if (TPQDBG(DEBUG)) {
printk("read: return_read_eof==%d, reported_read_eof==%d, total_bytes_done==%lu\n", return_read_eof, reported_read_eof, total_bytes_done);
}
if (reported_read_eof == NO) {
/* have not yet returned EOF to user program */
if (total_bytes_done > 0) {
return total_bytes_done; /* next time return EOF */
} else {
reported_read_eof = YES; /* move on next time */
return 0; /* return EOF */
}
} else {
/* Application program has already received EOF
* (above), now continue with next file on tape,
* if possible.
* When the FM is reached, EXCEPTION is set,
* causing a sense(). Subsequent read/writes will
* continue after the FM.
*/
/*********** ?????????? this should check for (EOD|NDT), not EOM, 'cause we can read past EW: ************/
if (status_eom_detected) {
/* If EOM, nothing left to read, so keep returning EOFs.
*** should probably set some flag to avoid clearing
*** status_eom_detected through ioctls or something
*/
return 0;
} else {
/* just eof, there may be more files ahead... */
return_read_eof = NO;
reported_read_eof = NO;
status_eof_detected = NO; /* reset this too */
/*fall through */
}
}
}
if (bytes_todo == 0) {
return total_bytes_done;
}
if (bytes_todo > 0) {
/* start reading data */
if (is_exception()) {
tpqputs(TPQD_DMAX, "is_exception() before start_dma()!");
}
/******************************************************************
***** if start_dma() fails because the head is positioned 0 bytes
***** before the FM, (causing EXCEPTION to be set) return_read_eof should
***** be set to YES, and we should return total_bytes_done, rather than -ENXIO.
***** The app should recognize this as an EOF condition.
***************************************************************************/
stat = start_dma(READ, bytes_todo);
if (stat == TE_OK) {
/* Wait for transfer to complete, interrupt should wake us */
wait_event(qic02_tape_transfer, dma_mode != 0);
if (status_error)
return_read_eof = YES;
} else if (stat != TE_END) {
/* should do sense() on error here */
#if 0
return -ENXIO;
#else
printk("Trouble: stat==%02x\n", stat);
return_read_eof = YES;
/*************** check EOF/EOT handling!!!!!! **/
#endif
}
end_dma(&bytes_done);
if (bytes_done > bytes_todo) {
tpqputs(TPQD_ALWAYS, "read: Oops, read more bytes than requested");
return -EIO;
}
/* copy buffer to user-space in one go */
if (bytes_done > 0) {
if (copy_to_user(buf, buffaddr, bytes_done))
return -EFAULT;
}
#if 1
/* Checks Ton's patch below */
if ((return_read_eof == NO) && (status_eof_detected == YES)) {
printk(TPQIC02_NAME ": read(): return_read_eof=%d, status_eof_detected=YES. return_read_eof:=YES\n",
return_read_eof);
}
#endif
if ((bytes_todo != bytes_done) || (status_eof_detected == YES)) {
/* EOF or EOM detected. return EOF next time. */
return_read_eof = YES;
}
}
/* else: ignore read request for 0 bytes */
if (bytes_done > 0) {
status_bytes_rd = YES;
buf += bytes_done;
*ppos += bytes_done;
total_bytes_done += bytes_done;
count -= bytes_done;
}
}
tpqputs(TPQD_ALWAYS, "read request for <0 bytes");
return -EINVAL;
} /* qic02_tape_read */
/* The drive detects near-EOT by means of the holes in the tape.
* When the holes are detected, there is some space left. The drive
* reports this as a TP_EOM exception. After clearing the exception,
* the drive should accept two extra blocks.
*
* It seems there are some archiver programs that would like to use the
* extra space for writing a continuation marker. The driver should return
* end-of-file to the user program on writes, when the holes are detected.
* If the user-program wants to use the extra space, it should use the
* MTNOP ioctl() to get the generic status register and may then continue
* writing (max 1kB). ----------- doesn't work yet...............
*
* EOF behaviour on writes:
* If there is enough room, write all of the data.
* If there is insufficient room, write as much as will fit and
* return the amount written. If the requested amount differs from the
* written amount, the application program should recognize that as the
* end of file. Subsequent writes will return -ENOSPC.
* Unless the minor bits specify a rewind-on-close, the tape will not
* be rewound when it is full. The user-program should do that, if desired.
* If the driver were to do that automatically, a user-program could be
* confused about the EOT/BOT condition after re-opening the tape device.
*
* Multiple volume support: Tar closes the tape device before prompting for
* the next tape. The user may then insert a new tape and tar will open the
* tape device again. The driver will detect an exception status in (No Cartridge)
* and force a rewind. After that tar may continue writing.
*/
static ssize_t qic02_tape_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
int type = iminor(filp->f_dentry->d_inode);
unsigned short flags = filp->f_flags;
unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
if (status_zombie == YES) {
tpqputs(TPQD_ALWAYS, "configs not set");
return -ENXIO;
}
if (TP_DIAGS(current_type)) {
printk(TPQIC02_NAME ": request WRITE, minor=%x, buf=%p, count=%lx, pos=%Lx, flags=%x\n",
type, buf, (long) count, filp->f_pos, flags);
}
if (count % TAPE_BLKSIZE) { /* only allow mod 512 bytes at a time */
tpqputs(TPQD_BLKSZ, "Wrong block size");
return -EINVAL;
}
if (mode_access == READ) {
tpqputs(TPQD_ALWAYS, "Not in write mode");
return -EACCES;
}
/* open() does a sense() and we can assume the tape isn't changed
* between open() and release(), so the tperror.exs bits will still
* be valid.
*/
if ((tperror.exs & TP_ST0) && (tperror.exs & TP_WRP)) {
tpqputs(TPQD_ALWAYS, "Cartridge is write-protected.");
return -EACCES; /* don't even try when write protected */
}
if (doing_read == YES) {
terminate_read(0);
}
while ((signed) count >= 0) {
/* see how much fits in the kernel buffer */
bytes_done = 0;
bytes_todo = TPQBUF_SIZE;
if (bytes_todo > count) {
bytes_todo = count;
}
if (return_write_eof == YES) {
/* return_write_eof should be reset on reverse tape movements. */
if (reported_write_eof == NO) {
if (bytes_todo > 0) {
tpqputs(TPQD_ALWAYS, "partial write");
/* partial write signals EOF to user program */
}
reported_write_eof = YES;
return total_bytes_done;
} else {
return -ENOSPC; /* return error */
}
}
/* Quit when done. */
if (bytes_todo == 0) {
return total_bytes_done;
}
/* copy from user to DMA buffer and initiate transfer. */
if (bytes_todo > 0) {
if (copy_from_user(buffaddr, buf, bytes_todo))
return -EFAULT;
/****************** similar problem with read() at FM could happen here at EOT.
******************/
/***** if at EOT, 0 bytes can be written. start_dma() will
***** fail and write() will return ENXIO error
*****/
if (start_dma(WRITE, bytes_todo) != TE_OK) {
tpqputs(TPQD_ALWAYS, "write: start_dma() failed");
/* should do sense() on error here */
return -ENXIO;
/*********** FIXTHIS **************/
}
/* Wait for write to complete, interrupt should wake us. */
wait_event(qic02_tape_transfer, (status_error == 0 && dma_mode != 0));
end_dma(&bytes_done);
if (bytes_done > bytes_todo) {
tpqputs(TPQD_ALWAYS, "write: Oops, wrote more bytes than requested");
return -EIO;
}
/* If the dma-transfer was aborted because of an exception,
* status_error will have been set in the interrupt handler.
* Then end_dma() will do a sense().
* If the exception was EXC_EOM, the EW-hole was encountered
* and two more blocks could be written. For the time being we'll
* just consider this to be the EOT.
* Otherwise, something Bad happened, such as the maximum number
* of block-rewrites was exceeded. [e.g. A very bad spot on tape was
* encountered. Normally short dropouts are compensated for by
* rewriting the block in error, up to 16 times. I'm not sure
* QIC-24 drives can do this.]
*/
if (status_error) {
if (status_eom_detected == YES) {
tpqputs(TPQD_ALWAYS, "write: EW detected");
return_write_eof = YES;
} else {
/* probably EXC_RWA */
tpqputs(TPQD_ALWAYS, "write: dma: error in writing");
return -EIO;
}
}
if (bytes_todo != bytes_done) {
/* EOF or EOM detected. return EOT next time. */
return_write_eof = YES;
}
}
/* else: ignore write request for 0 bytes. */
if (bytes_done > 0) {
status_bytes_wr = YES;
buf += bytes_done;
*ppos += bytes_done;
total_bytes_done += bytes_done;
count -= bytes_done;
}
}
tpqputs(TPQD_ALWAYS, "write request for <0 bytes");
if (TPQDBG(DEBUG)) {
printk(TPQIC02_NAME ": status_bytes_wr %x, buf %p"
", total_bytes_done %lx, count %lx\n",
status_bytes_wr, buf, total_bytes_done,
(long) count);
}
return -EINVAL;
} /* qic02_tape_write */
/* qic02_tape_open()
* We allow the device to be opened, even if it is marked 'dead' because
* we want to be able to reset the tape device without rebooting.
* Only one open tape file at a time, except when minor=255.
* Minor 255 is only allowed for resetting and always returns <0.
*
* The density command is only allowed when TP_BOM is set. Thus, remember
* the most recently used minor bits. When they are different from the
* remembered values, rewind the tape and set the required density.
* Don't rewind if the minor bits specify density 0.
*/
static int qic02_tape_open(struct inode *inode, struct file *filp)
{
static int qic02_tape_open_no_use_count(struct inode *,
struct file *);
int open_error;
open_error = qic02_tape_open_no_use_count(inode, filp);
return open_error;
}
static int qic02_tape_open_no_use_count(struct inode *inode,
struct file *filp)
{
int type = iminor(inode);
unsigned short flags = filp->f_flags;
unsigned short dens = 0;
int s;
if (TP_DIAGS(type)) {
printk("qic02_tape_open: dev=tpqic2(%d), flags=%x ",
type, flags);
}
if (type == 255) { /* special case for resetting */
if (capable(CAP_SYS_ADMIN)) {
return (tape_reset(1) == TE_OK) ? -EAGAIN : -ENXIO;
} else {
return -EPERM;
}
}
if (status_dead == YES) {
/* Allow `mt reset' ioctl() even when already open()ed. */
return 0;
}
if(test_and_set_bit(0, &tape_open))
return -EBUSY;
if (status_zombie == YES) {
/* no irq/dma/port stuff allocated yet, no reset done
* yet, so return until MTSETCONFIG has been done.
*/
return 0;
}
status_bytes_rd = NO;
status_bytes_wr = NO;
return_read_eof = NO; /********????????????????*****/
return_write_eof = (status_eot_detected) ? YES : NO;
/* Clear this in case user app close()d before reading EOF token */
status_eof_detected = NO;
reported_read_eof = NO;
reported_write_eof = NO;
switch (flags & O_ACCMODE) {
case O_RDONLY:
mode_access = READ;
break;
case O_WRONLY: /* Fallthru... Strictly speaking this is not correct... */
case O_RDWR: /* Reads are allowed as long as nothing is written */
mode_access = WRITE;
break;
}
/* This is to avoid tape-changed problems (TP_CNI exception).
*
* Since removing the cartridge will not raise an exception,
* we always do a tp_sense() to make sure we have the proper
* CNI status, the 2150L may need an additional sense.... - Eddy
*/
s = tp_sense(TP_WRP | TP_EOM | TP_BOM | TP_CNI | TP_EOR);
if (s == TE_OK) {
/* Try to clear cartridge-changed status for Archive-2150L */
if ((tperror.exs & TP_ST0) && (tperror.exs & TP_CNI)) {
s = tp_sense(TP_WRP | TP_EOM | TP_BOM | TP_CNI | TP_EOR);
}
}
if (s != TE_OK) {
tpqputs(TPQD_ALWAYS, "open: sense() failed");
clear_bit(0, &tape_open);
return -EIO;
}
/* exception bits should be up-to-date now, so check for
* tape presence and exit if absent.
* Even `mt stat' will fail without a tape.
*/
if ((tperror.exs & TP_ST0) && (tperror.exs & TP_CNI)) {
tpqputs(TPQD_ALWAYS, "No tape present.");
clear_bit(0, &tape_open);
return -EIO;
}
/* At this point we can assume that a tape is present and
* that it will remain present until release() is called.
*/
/* not allowed to do QCMD_DENS_* unless tape is rewound */
if ((TP_DENS(type) != 0) && (TP_DENS(current_type) != TP_DENS(type))) {
/* force rewind if minor bits have changed,
* i.e. user wants to use tape in different format.
* [assuming single drive operation]
*/
if (TP_HAVE_DENS) {
tpqputs(TPQD_REWIND, "Density minor bits have changed. Forcing rewind.");
need_rewind = YES;
}
} else {
/* density bits still the same, but TP_DIAGS bit
* may have changed.
*/
current_type = type;
}
if (need_rewind == YES) {
/***************** CHECK THIS!!!!!!!! **********/
s = do_qic_cmd(QCMD_REWIND, TIM_R);
if (s != 0) {
tpqputs(TPQD_ALWAYS, "open: rewind failed");
return -EIO;
}
}
/* Note: After a reset command, the controller will rewind the tape
* just before performing any tape movement operation! ************ SO SET need_rewind flag!!!!!
*/
if (status_dead == YES) {
tpqputs(TPQD_ALWAYS, "open: tape dead, attempting reset");
if (tape_reset(1) != TE_OK) {
return -ENXIO;
} else {
status_dead = NO;
if (tp_sense(~(TP_ST1 | TP_ILL)) != TE_OK) {
tpqputs(TPQD_ALWAYS, "open: tp_sense() failed\n");
status_dead = YES; /* try reset next time */
return -EIO;
}
}
}
/* things should be ok, once we get here */
/* set density: only allowed when TP_BOM status bit is set,
* so we must have done a rewind by now. If not, just skip over.
* Only give set density command when minor bits have changed.
*/
if (TP_DENS(current_type) == TP_DENS(type)) {
return 0;
}
current_type = type;
need_rewind = NO;
if (TP_HAVE_DENS) {
dens = TP_DENS(type);
}
if (dens < sizeof(format_names) / sizeof(char *))
printk(TPQIC02_NAME ": format: %s%s\n", (dens != 0) ? "QIC-" : "", format_names[dens]);
else
tpqputs(TPQD_REWIND, "Wait for retensioning...");
switch (TP_DENS(type)) {
case 0: /* Minor 0 is for drives without set-density support */
s = 0;
break;
case 1:
s = do_qic_cmd(QCMD_DENS_11, TIM_S);
break;
case 2:
s = do_qic_cmd(QCMD_DENS_24, TIM_S);
break;
case 3:
s = do_qic_cmd(QCMD_DENS_120, TIM_S);
break;
case 4:
s = do_qic_cmd(QCMD_DENS_150, TIM_S);
break;
case 5:
s = do_qic_cmd(QCMD_DENS_300, TIM_S);
break;
case 6:
s = do_qic_cmd(QCMD_DENS_600, TIM_S);
break;
default: /* otherwise do a retension before anything else */
s = do_qic_cmd(QCMD_RETEN, TIM_R);
}
if (s != 0) {
status_dead = YES; /* force reset */
current_type = 0;/* earlier 0xff80 */
return -EIO;
}
return 0;
} /* qic02_tape_open */
static int qic02_tape_release(struct inode *inode, struct file *filp)
{
int type = iminor(inode);
if (TP_DIAGS(type)) {
printk("qic02_tape_release: dev=tpqic2(%d)\n", type);
}
if (status_zombie == NO) { /* don't rewind in zombie mode */
/* Terminate any pending write cycle. Terminating the read-cycle
* is delayed until it is required to do so for a new command.
*/
terminate_write(-1);
if (status_dead == YES) {
tpqputs(TPQD_ALWAYS, "release: device dead!?");
}
/* Rewind only if minor number requires it AND
* read/writes have been done. ************* IS THIS CORRECT??????????
*/
if (TP_REWCLOSE(type) && (status_bytes_rd | status_bytes_wr)) {
tpqputs(TPQD_REWIND, "release: Doing rewind...");
(void) do_qic_cmd(QCMD_REWIND, TIM_R);
}
}
clear_bit(0, &tape_open);
return 0;
} /* qic02_tape_release */
#ifdef CONFIG_QIC02_DYNCONF
/* Set masks etc. based on the interface card type. */
static int update_ifc_masks(int ifc)
{
QIC02_TAPE_IFC = ifc;
if ((QIC02_TAPE_IFC == WANGTEK) || (QIC02_TAPE_IFC == EVEREX)) {
QIC02_STAT_PORT = QIC02_TAPE_PORT;
QIC02_CTL_PORT = QIC02_TAPE_PORT;
QIC02_CMD_PORT = QIC02_TAPE_PORT + 1;
QIC02_DATA_PORT = QIC02_TAPE_PORT + 1;
QIC02_STAT_READY = WT_QIC02_STAT_READY;
QIC02_STAT_EXCEPTION = WT_QIC02_STAT_EXCEPTION;
QIC02_STAT_MASK = WT_QIC02_STAT_MASK;
QIC02_STAT_RESETMASK = WT_QIC02_STAT_RESETMASK;
QIC02_STAT_RESETVAL = WT_QIC02_STAT_RESETVAL;
QIC02_CTL_RESET = WT_QIC02_CTL_RESET;
QIC02_CTL_REQUEST = WT_QIC02_CTL_REQUEST;
if (QIC02_TAPE_DMA == 3) {
WT_CTL_DMA = WT_CTL_DMA3;
} else if (QIC02_TAPE_DMA == 1) {
WT_CTL_DMA = WT_CTL_DMA1;
} else {
tpqputs(TPQD_ALWAYS,
"Unsupported or incorrect DMA channel");
return -EIO;
}
if (QIC02_TAPE_IFC == EVEREX) {
/* Everex is a special case for Wangtek (actually
* it's the other way 'round, but I saw Wangtek first)
*/
if (QIC02_TAPE_DMA == 3) {
WT_CTL_DMA = WT_CTL_DMA1;
}
/* Fixup the kernel copy of the IFC type to that
* we don't have to distinguish between Wangtek and
* and Everex at runtime.
*/
QIC02_TAPE_IFC = WANGTEK;
}
} else if (QIC02_TAPE_IFC == ARCHIVE) {
QIC02_STAT_PORT = QIC02_TAPE_PORT + 1;
QIC02_CTL_PORT = QIC02_TAPE_PORT + 1;
QIC02_CMD_PORT = QIC02_TAPE_PORT;
QIC02_DATA_PORT = QIC02_TAPE_PORT;
QIC02_STAT_READY = AR_QIC02_STAT_READY;
QIC02_STAT_EXCEPTION = AR_QIC02_STAT_EXCEPTION;
QIC02_STAT_MASK = AR_QIC02_STAT_MASK;
QIC02_STAT_RESETMASK = AR_QIC02_STAT_RESETMASK;
QIC02_STAT_RESETVAL = AR_QIC02_STAT_RESETVAL;
QIC02_CTL_RESET = AR_QIC02_CTL_RESET;
QIC02_CTL_REQUEST = AR_QIC02_CTL_REQUEST;
if (QIC02_TAPE_DMA > 3) {
tpqputs(TPQD_ALWAYS,
"Unsupported or incorrect DMA channel");
return -EIO;
}
} else if (QIC02_TAPE_IFC == MOUNTAIN) {
QIC02_STAT_PORT = QIC02_TAPE_PORT + 1;
QIC02_CTL_PORT = QIC02_TAPE_PORT + 1;
QIC02_CMD_PORT = QIC02_TAPE_PORT;
QIC02_DATA_PORT = QIC02_TAPE_PORT;
QIC02_STAT_READY = MTN_QIC02_STAT_READY;
QIC02_STAT_EXCEPTION = MTN_QIC02_STAT_EXCEPTION;
QIC02_STAT_MASK = MTN_QIC02_STAT_MASK;
QIC02_STAT_RESETMASK = MTN_QIC02_STAT_RESETMASK;
QIC02_STAT_RESETVAL = MTN_QIC02_STAT_RESETVAL;
QIC02_CTL_RESET = MTN_QIC02_CTL_RESET;
QIC02_CTL_REQUEST = MTN_QIC02_CTL_REQUEST;
if (QIC02_TAPE_DMA > 3) {
tpqputs(TPQD_ALWAYS,
"Unsupported or incorrect DMA channel");
return -EIO;
}
} else {
tpqputs(TPQD_ALWAYS, "Invalid interface type");
return -ENXIO;
}
return qic02_get_resources();
} /* update_ifc_masks */
#endif
/* ioctl allows user programs to rewind the tape and stuff like that */
static int qic02_tape_ioctl(struct inode *inode, struct file *filp, unsigned int iocmd, unsigned long ioarg)
{
int error;
int c;
struct mtop operation;
unsigned char blk_addr[6];
struct mtpos ioctl_tell;
void __user *argp = (void __user *)ioarg;
if (TP_DIAGS(current_type))
printk(TPQIC02_NAME ": ioctl(%4x, %4lx)\n", iocmd, ioarg);
if (!inode)
return -EINVAL;
/* check iocmd first */
c = _IOC_NR(iocmd);
#ifdef CONFIG_QIC02_DYNCONF
if (c == _IOC_NR(MTIOCGETCONFIG)) {
CHECK_IOC_SIZE(mtconfiginfo);
if (copy_to_user(argp, &qic02_tape_dynconf, sizeof(qic02_tape_dynconf)))
return -EFAULT;
return 0;
} else if (c == _IOC_NR(MTIOCSETCONFIG)) {
/* One should always do a MTIOCGETCONFIG first, then update
* user-settings, then write back with MTIOCSETCONFIG.
* The qic02conf program should re-open() the device before actual
* use, to make sure everything is initialized.
*/
CHECK_IOC_SIZE(mtconfiginfo);
if (!capable(CAP_SYS_RAWIO))
return -EPERM;
if (doing_read != NO || doing_write != NO)
return -EBUSY;
if (status_zombie == NO)
qic02_release_resources(); /* and go zombie */
/* copy struct from user space to kernel space */
if (copy_from_user(&qic02_tape_dynconf, argp, sizeof(qic02_tape_dynconf)))
return -EFAULT;
return update_ifc_masks(qic02_tape_dynconf.ifc_type);
}
if (status_zombie == YES) {
tpqputs(TPQD_ALWAYS, "Configs not set");
return -ENXIO;
}
#endif
if (c == _IOC_NR(MTIOCTOP)) {
CHECK_IOC_SIZE(mtop);
/* copy mtop struct from user space to kernel space */
if (copy_from_user(&operation, argp, sizeof(operation)))
return -EFAULT;
/* ---note: mt_count is signed, negative seeks must be
* --- translated to seeks in opposite direction!
* (only needed for Sun-programs, I think.)
*/
/* ---note: MTFSF with count 0 should position the
* --- tape at the beginning of the current file.
*/
if (TP_DIAGS(current_type))
printk("OP op=%4x, count=%4x\n", operation.mt_op, operation.mt_count);
if (operation.mt_count < 0)
tpqputs(TPQD_ALWAYS, "Warning: negative mt_count ignored");
ioctl_status.mt_resid = operation.mt_count;
if (operation.mt_op == MTSEEK) {
if (!TP_HAVE_SEEK)
return -ENOTTY;
seek_addr_buf[0] = (operation.mt_count >> 16) & 0xff;
seek_addr_buf[1] = (operation.mt_count >> 8) & 0xff;
seek_addr_buf[2] = (operation.mt_count) & 0xff;
if (operation.mt_count >> 24)
return -EINVAL;
if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
return error;
ioctl_status.mt_resid = 0;
} else {
while (operation.mt_count > 0) {
operation.mt_count--;
if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
return error;
ioctl_status.mt_resid = operation.mt_count;
}
}
return 0;
} else if (c == _IOC_NR(MTIOCGET)) {
if (TP_DIAGS(current_type))
printk("GET ");
CHECK_IOC_SIZE(mtget);
/* It appears (gmt(1)) that it is normal behaviour to
* first set the status with MTNOP, and then to read
* it out with MTIOCGET
*/
/* copy results to user space */
if (copy_to_user(argp, &ioctl_status, sizeof(ioctl_status)))
return -EFAULT;
return 0;
} else if (TP_HAVE_TELL && (c == _IOC_NR(MTIOCPOS))) {
if (TP_DIAGS(current_type))
printk("POS ");
CHECK_IOC_SIZE(mtpos);
tpqputs(TPQD_IOCTLS, "MTTELL reading block address");
if (doing_read == YES || doing_write == YES)
finish_rw(AR_QCMDV_TELL_BLK);
c = rdstatus((char *) blk_addr, sizeof(blk_addr), AR_QCMDV_TELL_BLK);
if (c != TE_OK)
return -EIO;
ioctl_tell.mt_blkno = (blk_addr[3] << 16) | (blk_addr[4] << 8) | blk_addr[5];
/* copy results to user space */
if (copy_to_user(argp, &ioctl_tell, sizeof(ioctl_tell)))
return -EFAULT;
return 0;
} else
return -ENOTTY; /* Other cmds not supported. */
} /* qic02_tape_ioctl */
static ssize_t qic02_do_tape_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
{
int err;
down(&tape_op);
err = qic02_tape_read(filp, buf, count, ppos);
up(&tape_op);
return err;
}
static ssize_t qic02_do_tape_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
{
int err;
down(&tape_op);
err = qic02_tape_write(filp, buf, count, ppos);
up(&tape_op);
return err;
}
static int qic02_do_tape_ioctl(struct inode *inode, struct file *filp, unsigned int iocmd, unsigned long ioarg)
{
int err;
down(&tape_op);
err = qic02_tape_ioctl(inode, filp, iocmd, ioarg);
up(&tape_op);
return err;
}
/* These are (most) of the interface functions: */
static struct file_operations qic02_tape_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = qic02_do_tape_read,
.write = qic02_do_tape_write,
.ioctl = qic02_do_tape_ioctl,
.open = qic02_tape_open,
.release = qic02_tape_release,
};
static void qic02_release_resources(void)
{
free_irq(QIC02_TAPE_IRQ, NULL);
free_dma(QIC02_TAPE_DMA);
release_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
if (buffaddr)
free_pages((unsigned long) buffaddr, get_order(TPQBUF_SIZE));
buffaddr = NULL; /* Better to cause a panic than overwite someone else */
status_zombie = YES;
} /* qic02_release_resources */
static int qic02_get_resources(void)
{
/* First perform some checks. If one of them fails,
* the tape driver will not be registered to the system.
*/
/* for DYNCONF, allocating IO, DMA and IRQ should not be done until
* the config parameters have been set using MTSETCONFIG.
*/
/* Grab the IO region. */
if (!request_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE, TPQIC02_NAME)) {
printk(TPQIC02_NAME ": IO space at 0x%x [%d ports] already reserved\n",
QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
return -ENXIO;
}
/* get IRQ */
if (request_irq(QIC02_TAPE_IRQ, qic02_tape_interrupt, SA_INTERRUPT, "QIC-02", NULL)) {
printk(TPQIC02_NAME ": can't allocate IRQ%d for QIC-02 tape\n", QIC02_TAPE_IRQ);
release_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
return -EBUSY;
}
/* After IRQ, allocate DMA channel */
if (request_dma(QIC02_TAPE_DMA, "QIC-02")) {
printk(TPQIC02_NAME ": can't allocate DMA%d for QIC-02 tape\n", QIC02_TAPE_DMA);
free_irq(QIC02_TAPE_IRQ, NULL);
release_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
return -EBUSY;
}
/* Setup the page-address for the dma transfer. */
buffaddr = (void *) __get_dma_pages(GFP_KERNEL, get_order(TPQBUF_SIZE));
if (!buffaddr) {
qic02_release_resources();
return -EBUSY; /* Not ideal, EAGAIN perhaps? */
}
memset(buffaddr, 0, TPQBUF_SIZE);
printk(TPQIC02_NAME ": Settings: IRQ %d, DMA %d, IO 0x%x, IFC %s\n",
QIC02_TAPE_IRQ, QIC02_TAPE_DMA, ((QIC02_TAPE_IFC == ARCHIVE)
|| (QIC02_TAPE_IFC ==
MOUNTAIN)) ?
QIC02_CMD_PORT : QIC02_STAT_PORT,
(QIC02_TAPE_IFC ==
MOUNTAIN) ? "Mountain" : ((QIC02_TAPE_IFC ==
ARCHIVE) ? "Archive" :
"Wangtek"));
if (tape_reset(0) != TE_OK || tp_sense(TP_WRP | TP_POR | TP_CNI) != TE_OK) {
/* No drive detected, so vanish */
tpqputs(TPQD_ALWAYS, "No drive detected -- releasing IO/IRQ/DMA.");
status_dead = YES;
qic02_release_resources();
return -EIO;
}
/* All should be ok now */
status_zombie = NO;
return 0;
} /* qic02_get_resources */
int __init qic02_tape_init(void)
{
if (TPSTATSIZE != 6) {
printk(TPQIC02_NAME ": internal error: tpstatus struct incorrect!\n");
return -ENODEV;
}
if ((TPQBUF_SIZE < 512) || (TPQBUF_SIZE >= 0x10000)) {
printk(TPQIC02_NAME ": internal error: DMA buffer size out of range\n");
return -ENODEV;
}
current_type = 0;
#ifndef CONFIG_QIC02_DYNCONF
printk(TPQIC02_NAME ": IRQ %d, DMA %d, IO 0x%x, IFC %s, %s, %s\n",
QIC02_TAPE_IRQ, QIC02_TAPE_DMA,
# if QIC02_TAPE_IFC == WANGTEK
QIC02_STAT_PORT, "Wangtek",
# elif QIC02_TAPE_IFC == ARCHIVE
QIC02_CMD_PORT, "Archive",
# elif QIC02_TAPE_IFC == MOUNTAIN
QIC02_CMD_PORT, "Mountain",
# else
# error
# endif
rcs_revision, rcs_date);
if (qic02_get_resources())
return -ENODEV;
#else
printk(TPQIC02_NAME ": Runtime config, %s, %s\n", rcs_revision, rcs_date);
#endif
printk(TPQIC02_NAME ": DMA buffers: %u blocks\n", NR_BLK_BUF);
/* If we got this far, install driver functions */
if (register_chrdev(QIC02_TAPE_MAJOR, TPQIC02_NAME, &qic02_tape_fops))
{
printk(TPQIC02_NAME ": Unable to get chrdev major %d\n", QIC02_TAPE_MAJOR);
#ifndef CONFIG_QIC02_DYNCONF
qic02_release_resources();
#endif
return -ENODEV;
}
tpqic02_class = class_simple_create(THIS_MODULE, TPQIC02_NAME);
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 2), NULL, "ntpqic11");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 2),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "ntpqic11");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 3), NULL, "tpqic11");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 3),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "tpqic11");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 4), NULL, "ntpqic24");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 4),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "ntpqic24");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 5), NULL, "tpqic24");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 5),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "tpqic24");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 6), NULL, "ntpqic20");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 6),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "ntpqic120");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 7), NULL, "tpqic20");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 7),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "tpqic120");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 8), NULL, "ntpqic50");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 8),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "ntpqic150");
class_simple_device_add(tpqic02_class, MKDEV(QIC02_TAPE_MAJOR, 9), NULL, "tpqic50");
devfs_mk_cdev(MKDEV(QIC02_TAPE_MAJOR, 9),
S_IFCHR|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "tpqic150");
init_waitqueue_head(&qic02_tape_transfer);
/* prepare timer */
TIMEROFF;
init_timer(&tp_timer);
tp_timer.function = qic02_tape_times_out;
#ifndef CONFIG_QIC02_DYNCONF
if (tape_reset(0) != TE_OK || tp_sense(TP_WRP | TP_POR | TP_CNI) != TE_OK) {
/* No drive detected, so vanish */
tpqputs(TPQD_ALWAYS, "No drive detected -- driver going on vacation...");
qic02_release_resources();
status_dead = YES;
return -ENODEV;
} else {
if (is_exception()) {
tpqputs(TPQD_ALWAYS, "exception detected\n");
(void) tp_sense(TP_WRP | TP_POR | TP_CNI);
}
}
#endif
/* initialize generic status for ioctl requests */
ioctl_status.mt_type = QIC02_TAPE_DRIVE; /* MT_IS* id nr */
ioctl_status.mt_resid = 0; /* ---residual count */
ioctl_status.mt_gstat = 0; /* ---generic status */
ioctl_status.mt_erreg = 0; /* not used */
ioctl_status.mt_fileno = 0; /* number of current file on tape */
ioctl_status.mt_blkno = 0; /* number of current (logical) block */
return 0;
} /* qic02_tape_init */
static void qic02_module_exit(void)
{
unregister_chrdev(QIC02_TAPE_MAJOR, TPQIC02_NAME);
if (status_zombie == NO)
qic02_release_resources();
devfs_remove("ntpqic11");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 2));
devfs_remove("tpqic11");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 3));
devfs_remove("ntpqic24");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 4));
devfs_remove("tpqic24");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 5));
devfs_remove("ntpqic120");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 6));
devfs_remove("tpqic120");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 7));
devfs_remove("ntpqic150");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 8));
devfs_remove("tpqic150");
class_simple_device_remove(MKDEV(QIC02_TAPE_MAJOR, 9));
class_simple_destroy(tpqic02_class);
}
static int qic02_module_init(void)
{
int retval;
retval = qic02_tape_init();
# ifdef CONFIG_QIC02_DYNCONF
/* This allows the dynamic config program to setup the card
* by presetting qic02_tape_dynconf via insmod
*/
if (!retval && qic02_tape_dynconf.ifc_type) {
retval = update_ifc_masks(qic02_tape_dynconf.ifc_type);
if (retval) {
qic02_module_exit();
}
}
# endif
return retval;
}
MODULE_LICENSE("GPL");
module_init(qic02_module_init);
module_exit(qic02_module_exit);
fs/compat_ioctl.c
View file @ ee05e0b0
......@@ -1281,35 +1281,9 @@ struct mtpos32 {
};
#define MTIOCPOS32 _IOR('m', 3, struct mtpos32)
struct mtconfiginfo32 {
compat_long_t mt_type;
compat_long_t ifc_type;
unsigned short irqnr;
unsigned short dmanr;
unsigned short port;
compat_ulong_t debug;
compat_uint_t have_dens:1;
compat_uint_t have_bsf:1;
compat_uint_t have_fsr:1;
compat_uint_t have_bsr:1;
compat_uint_t have_eod:1;
compat_uint_t have_seek:1;
compat_uint_t have_tell:1;
compat_uint_t have_ras1:1;
compat_uint_t have_ras2:1;
compat_uint_t have_ras3:1;
compat_uint_t have_qfa:1;
compat_uint_t pad1:5;
char reserved[10];
};
#define MTIOCGETCONFIG32 _IOR('m', 4, struct mtconfiginfo32)
#define MTIOCSETCONFIG32 _IOW('m', 5, struct mtconfiginfo32)
static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
{
mm_segment_t old_fs = get_fs();
struct mtconfiginfo info;
struct mtconfiginfo32 __user *uinfo32;
struct mtget get;
struct mtget32 __user *umget32;
struct mtpos pos;
......@@ -1327,27 +1301,6 @@ static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
kcmd = MTIOCGET;
karg = &get;
break;
case MTIOCGETCONFIG32:
kcmd = MTIOCGETCONFIG;
karg = &info;
break;
case MTIOCSETCONFIG32:
kcmd = MTIOCSETCONFIG;
karg = &info;
uinfo32 = compat_ptr(arg);
err = __get_user(info.mt_type, &uinfo32->mt_type);
err |= __get_user(info.ifc_type, &uinfo32->ifc_type);
err |= __get_user(info.irqnr, &uinfo32->irqnr);
err |= __get_user(info.dmanr, &uinfo32->dmanr);
err |= __get_user(info.port, &uinfo32->port);
err |= __get_user(info.debug, &uinfo32->debug);
err |= __copy_from_user((char *)&info.debug
+ sizeof(info.debug),
(char __user *)&uinfo32->debug
+ sizeof(uinfo32->debug), sizeof(__u32));
if (err)
return -EFAULT;
break;
default:
do {
static int count;
......@@ -1378,20 +1331,6 @@ static int mt_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
err |= __put_user(get.mt_fileno, &umget32->mt_fileno);
err |= __put_user(get.mt_blkno, &umget32->mt_blkno);
break;
case MTIOCGETCONFIG32:
uinfo32 = compat_ptr(arg);
err = __put_user(info.mt_type, &uinfo32->mt_type);
err |= __put_user(info.ifc_type, &uinfo32->ifc_type);
err |= __put_user(info.irqnr, &uinfo32->irqnr);
err |= __put_user(info.dmanr, &uinfo32->dmanr);
err |= __put_user(info.port, &uinfo32->port);
err |= __put_user(info.debug, &uinfo32->debug);
err |= __copy_to_user((char __user *)&uinfo32->debug
+ sizeof(uinfo32->debug),
(char *)&info.debug + sizeof(info.debug), sizeof(__u32));
break;
case MTIOCSETCONFIG32:
break;
}
return err ? -EFAULT: 0;
}
......@@ -3259,8 +3198,6 @@ HANDLE_IOCTL(PPPIOCSPASS32, ppp_sock_fprog_ioctl_trans)
HANDLE_IOCTL(PPPIOCSACTIVE32, ppp_sock_fprog_ioctl_trans)
HANDLE_IOCTL(MTIOCGET32, mt_ioctl_trans)
HANDLE_IOCTL(MTIOCPOS32, mt_ioctl_trans)
HANDLE_IOCTL(MTIOCGETCONFIG32, mt_ioctl_trans)
HANDLE_IOCTL(MTIOCSETCONFIG32, mt_ioctl_trans)
HANDLE_IOCTL(CDROMREADAUDIO, cdrom_ioctl_trans)
HANDLE_IOCTL(CDROM_SEND_PACKET, cdrom_ioctl_trans)
HANDLE_IOCTL(LOOP_SET_STATUS, loop_status)
......
include/linux/major.h
View file @ ee05e0b0
......@@ -25,7 +25,6 @@
#define MISC_MAJOR 10
#define SCSI_CDROM_MAJOR 11
#define MUX_MAJOR 11 /* PA-RISC only */
#define QIC02_TAPE_MAJOR 12
#define XT_DISK_MAJOR 13
#define INPUT_MAJOR 13
#define SOUND_MAJOR 14
......
include/linux/mtio.h
View file @ ee05e0b0
......@@ -150,34 +150,6 @@ struct mtpos {
};
/* structure for MTIOCGETCONFIG/MTIOCSETCONFIG primarily intended
* as an interim solution for QIC-02 until DDI is fully implemented.
*/
struct mtconfiginfo {
long mt_type; /* drive type */
long ifc_type; /* interface card type */
unsigned short irqnr; /* IRQ number to use */
unsigned short dmanr; /* DMA channel to use */
unsigned short port; /* IO port base address */
unsigned long debug; /* debugging flags */
unsigned have_dens:1;
unsigned have_bsf:1;
unsigned have_fsr:1;
unsigned have_bsr:1;
unsigned have_eod:1;
unsigned have_seek:1;
unsigned have_tell:1;
unsigned have_ras1:1;
unsigned have_ras2:1;
unsigned have_ras3:1;
unsigned have_qfa:1;
unsigned pad1:5;
char reserved[10];
};
/* structure for MTIOCVOLINFO, query information about the volume
* currently positioned at (zftape)
*/
......
include/linux/tpqic02.h deleted 100644 → 0
View file @ 08b2d088
/* $Id: tpqic02.h,v 1.5 1996/12/14 23:01:38 root Exp root $
*
* Include file for QIC-02 driver for Linux.
*
* Copyright (c) 1992--1995 by H. H. Bergman. All rights reserved.
*
* ******* USER CONFIG SECTION BELOW (Near line 70) *******
*/
#ifndef _LINUX_TPQIC02_H
#define _LINUX_TPQIC02_H
#include <linux/config.h>
#if defined(CONFIG_QIC02_TAPE) || defined(CONFIG_QIC02_TAPE_MODULE)
/* need to have QIC02_TAPE_DRIVE and QIC02_TAPE_IFC expand to something */
#include <linux/mtio.h>
/* Make QIC02_TAPE_IFC expand to something.
*
* The only difference between WANGTEK and EVEREX is in the
* handling of the DMA channel 3.
* Note that the driver maps EVEREX to WANGTEK internally for speed
* reasons. Externally WANGTEK==1, EVEREX==2, ARCHIVE==3.
* These must correspond to the values used in qic02config(1).
*
* Support for Mountain controllers was added by Erik Jacobson
* and severely hacked by me. -- hhb
*
* Support for Emerald controllers by Alan Bain <afrb2@chiark.chu.cam.ac.uk>
* with more hacks by me. -- hhb
*/
#define WANGTEK 1 /* don't know about Wangtek QIC-36 */
#define EVEREX (WANGTEK+1) /* I heard *some* of these are identical */
#define EVEREX_811V EVEREX /* With TEAC MT 2ST 45D */
#define EVEREX_831V EVEREX
#define ARCHIVE 3
#define ARCHIVE_SC400 ARCHIVE /* rumoured to be from the pre-SMD-age */
#define ARCHIVE_SC402 ARCHIVE /* don't know much about SC400 */
#define ARCHIVE_SC499 ARCHIVE /* SC402 and SC499R should be identical */
#define MOUNTAIN 5 /* Mountain Computer Interface */
#define EMERALD 6 /* Emerald Interface card */
#define QIC02_TAPE_PORT_RANGE 8 /* number of IO locations to reserve */
/*********** START OF USER CONFIGURABLE SECTION ************/
/* Tape configuration: Select DRIVE, IFC, PORT, IRQ and DMA below.
* Runtime (re)configuration is not supported yet.
*
* Tape drive configuration: (MT_IS* constants are defined in mtio.h)
*
* QIC02_TAPE_DRIVE = MT_ISWT5150
* - Wangtek 5150, format: up to QIC-150.
* QIC02_TAPE_DRIVE = MT_ISQIC02_ALL_FEATURES
* - Enables some optional QIC02 commands that some drives may lack.
* It is provided so you can check which are supported by your drive.
* Refer to tpqic02.h for others.
*
* Supported interface cards: QIC02_TAPE_IFC =
* WANGTEK,
* ARCHIVE_SC402, ARCHIVE_SC499. (both same programming interface)
*
* Make sure you have the I/O ports/DMA channels
* and IRQ stuff configured properly!
* NOTE: There may be other device drivers using the same major
* number. This must be avoided. Check for timer.h conflicts too.
*
* If you have an EVEREX EV-831 card and you are using DMA channel 3,
* you will probably have to ``#define QIC02_TAPE_DMA3_FIX'' below.
*/
/* CONFIG_QIC02_DYNCONF can be defined in autoconf.h, by `make config' */
/*** #undef CONFIG_QIC02_DYNCONF ***/
#ifndef CONFIG_QIC02_DYNCONF
#define QIC02_TAPE_DRIVE MT_ISQIC02_ALL_FEATURES /* drive type */
/* #define QIC02_TAPE_DRIVE MT_ISWT5150 */
/* #define QIC02_TAPE_DRIVE MT_ISARCHIVE_5945L2 */
/* #define QIC02_TAPE_DRIVE MT_ISTEAC_MT2ST */
/* #define QIC02_TAPE_DRIVE MT_ISARCHIVE_2150L */
/* #define QIC02_TAPE_DRIVE MT_ISARCHIVESC499 */
/* Either WANGTEK, ARCHIVE or MOUNTAIN. Not EVEREX.
* If you have an EVEREX, use WANGTEK and try the DMA3_FIX below.
*/
#define QIC02_TAPE_IFC WANGTEK /* interface card type */
/* #define QIC02_TAPE_IFC ARCHIVE */
/* #define QIC02_TAPE_IFC MOUNTAIN */
#define QIC02_TAPE_PORT 0x300 /* controller port address */
#define QIC02_TAPE_IRQ 5 /* For IRQ2, use 9 here, others normal. */
#define QIC02_TAPE_DMA 1 /* either 1 or 3, because 2 is used by the floppy */
/* If DMA3 doesn't work, but DMA1 does, and you have a
* Wangtek/Everex card, you can try #define-ing the flag
* below. Note that you should also change the DACK jumper
* for Wangtek/Everex cards when changing the DMA channel.
*/
#undef QIC02_TAPE_DMA3_FIX
/************ END OF USER CONFIGURABLE SECTION *************/
/* I put the stuff above in config.in, but a few recompiles, to
* verify different configurations, and several days later I decided
* to change it back again.
*/
/* NOTE: TP_HAVE_DENS should distinguish between available densities (?)
* NOTE: Drive select is not implemented -- I have only one tape streamer,
* so I'm unable and unmotivated to test and implement that. ;-) ;-)
*/
#if QIC02_TAPE_DRIVE == MT_ISWT5150
#define TP_HAVE_DENS 1
#define TP_HAVE_BSF 0 /* nope */
#define TP_HAVE_FSR 0 /* nope */
#define TP_HAVE_BSR 0 /* nope */
#define TP_HAVE_EOD 0 /* most of the time */
#define TP_HAVE_SEEK 0
#define TP_HAVE_TELL 0
#define TP_HAVE_RAS1 1
#define TP_HAVE_RAS2 1
#elif QIC02_TAPE_DRIVE == MT_ISARCHIVESC499 /* Archive SC-499 QIC-36 controller */
#define TP_HAVE_DENS 1 /* can do set density (QIC-11 / QIC-24) */
#define TP_HAVE_BSF 0
#define TP_HAVE_FSR 1 /* can skip one block forwards */
#define TP_HAVE_BSR 1 /* can skip one block backwards */
#define TP_HAVE_EOD 1 /* can seek to end of recorded data */
#define TP_HAVE_SEEK 0
#define TP_HAVE_TELL 0
#define TP_HAVE_RAS1 1 /* can run selftest 1 */
#define TP_HAVE_RAS2 1 /* can run selftest 2 */
/* These last two selftests shouldn't be used yet! */
#elif (QIC02_TAPE_DRIVE == MT_ISARCHIVE_2060L) || (QIC02_TAPE_DRIVE == MT_ISARCHIVE_2150L)
#define TP_HAVE_DENS 1 /* can do set density (QIC-24 / QIC-120 / QIC-150) */
#define TP_HAVE_BSF 0
#define TP_HAVE_FSR 1 /* can skip one block forwards */
#define TP_HAVE_BSR 1 /* can skip one block backwards */
#define TP_HAVE_EOD 1 /* can seek to end of recorded data */
#define TP_HAVE_TELL 1 /* can read current block address */
#define TP_HAVE_SEEK 1 /* can seek to block */
#define TP_HAVE_RAS1 1 /* can run selftest 1 */
#define TP_HAVE_RAS2 1 /* can run selftest 2 */
/* These last two selftests shouldn't be used yet! */
#elif QIC02_TAPE_DRIVE == MT_ISARCHIVE_5945L2
/* can anyone verify this entry?? */
#define TP_HAVE_DENS 1 /* can do set density?? (QIC-24??) */
#define TP_HAVE_BSF 0
#define TP_HAVE_FSR 1 /* can skip one block forwards */
#define TP_HAVE_BSR 1 /* can skip one block backwards */
#define TP_HAVE_EOD 1 /* can seek to end of recorded data */
#define TP_HAVE_TELL 1 /* can read current block address */
#define TP_HAVE_SEEK 1 /* can seek to block */
#define TP_HAVE_RAS1 1 /* can run selftest 1 */
#define TP_HAVE_RAS2 1 /* can run selftest 2 */
/* These last two selftests shouldn't be used yet! */
#elif QIC02_TAPE_DRIVE == MT_ISTEAC_MT2ST
/* can anyone verify this entry?? */
#define TP_HAVE_DENS 0 /* cannot do set density?? (QIC-150?) */
#define TP_HAVE_BSF 0
#define TP_HAVE_FSR 1 /* can skip one block forwards */
#define TP_HAVE_BSR 1 /* can skip one block backwards */
#define TP_HAVE_EOD 1 /* can seek to end of recorded data */
#define TP_HAVE_SEEK 1 /* can seek to block */
#define TP_HAVE_TELL 1 /* can read current block address */
#define TP_HAVE_RAS1 1 /* can run selftest 1 */
#define TP_HAVE_RAS2 1 /* can run selftest 2 */
/* These last two selftests shouldn't be used yet! */
#elif QIC02_TAPE_DRIVE == MT_ISQIC02_ALL_FEATURES
#define TP_HAVE_DENS 1 /* can do set density */
#define TP_HAVE_BSF 1 /* can search filemark backwards */
#define TP_HAVE_FSR 1 /* can skip one block forwards */
#define TP_HAVE_BSR 1 /* can skip one block backwards */
#define TP_HAVE_EOD 1 /* can seek to end of recorded data */
#define TP_HAVE_SEEK 1 /* seek to block address */
#define TP_HAVE_TELL 1 /* tell current block address */
#define TP_HAVE_RAS1 1 /* can run selftest 1 */
#define TP_HAVE_RAS2 1 /* can run selftest 2 */
/* These last two selftests shouldn't be used yet! */
#else
#error No QIC-02 tape drive type defined!
/* If your drive is not listed above, first try the 'ALL_FEATURES',
* to see what commands are supported, then create your own entry in
* the list above. You may want to mail it to me, so that I can include
* it in the next release.
*/
#endif
#endif /* !CONFIG_QIC02_DYNCONF */
/* WANGTEK interface card specifics */
#define WT_QIC02_STAT_PORT (QIC02_TAPE_PORT)
#define WT_QIC02_CTL_PORT (QIC02_TAPE_PORT)
#define WT_QIC02_CMD_PORT (QIC02_TAPE_PORT+1)
#define WT_QIC02_DATA_PORT (QIC02_TAPE_PORT+1)
/* status register bits (Active LOW!) */
#define WT_QIC02_STAT_POLARITY 0
#define WT_QIC02_STAT_READY 0x01
#define WT_QIC02_STAT_EXCEPTION 0x02
#define WT_QIC02_STAT_MASK (WT_QIC02_STAT_READY|WT_QIC02_STAT_EXCEPTION)
#define WT_QIC02_STAT_RESETMASK 0x07
#define WT_QIC02_STAT_RESETVAL (WT_QIC02_STAT_RESETMASK & ~WT_QIC02_STAT_EXCEPTION)
/* controller register (QIC02_CTL_PORT) bits */
#define WT_QIC02_CTL_RESET 0x02
#define WT_QIC02_CTL_REQUEST 0x04
#define WT_CTL_ONLINE 0x01
#define WT_CTL_CMDOFF 0xC0
#define WT_CTL_DMA3 0x10 /* enable dma chan3 */
#define WT_CTL_DMA1 0x08 /* enable dma chan1 or chan2 */
/* EMERALD interface card specifics
* Much like Wangtek, only different polarity and bit locations
*/
#define EMR_QIC02_STAT_PORT (QIC02_TAPE_PORT)
#define EMR_QIC02_CTL_PORT (QIC02_TAPE_PORT)
#define EMR_QIC02_CMD_PORT (QIC02_TAPE_PORT+1)
#define EMR_QIC02_DATA_PORT (QIC02_TAPE_PORT+1)
/* status register bits (Active High!) */
#define EMR_QIC02_STAT_POLARITY 1
#define EMR_QIC02_STAT_READY 0x01
#define EMR_QIC02_STAT_EXCEPTION 0x02
#define EMR_QIC02_STAT_MASK (EMR_QIC02_STAT_READY|EMR_QIC02_STAT_EXCEPTION)
#define EMR_QIC02_STAT_RESETMASK 0x07
#define EMR_QIC02_STAT_RESETVAL (EMR_QIC02_STAT_RESETMASK & ~EMR_QIC02_STAT_EXCEPTION)
/* controller register (QIC02_CTL_PORT) bits */
#define EMR_QIC02_CTL_RESET 0x02
#define EMR_QIC02_CTL_REQUEST 0x04
#define EMR_CTL_ONLINE 0x01
#define EMR_CTL_CMDOFF 0xC0
#define EMR_CTL_DMA3 0x10 /* enable dma chan3 */
#define EMR_CTL_DMA1 0x08 /* enable dma chan1 or chan2 */
/* ARCHIVE interface card specifics */
#define AR_QIC02_STAT_PORT (QIC02_TAPE_PORT+1)
#define AR_QIC02_CTL_PORT (QIC02_TAPE_PORT+1)
#define AR_QIC02_CMD_PORT (QIC02_TAPE_PORT)
#define AR_QIC02_DATA_PORT (QIC02_TAPE_PORT)
#define AR_START_DMA_PORT (QIC02_TAPE_PORT+2)
#define AR_RESET_DMA_PORT (QIC02_TAPE_PORT+3)
/* STAT port bits */
#define AR_QIC02_STAT_POLARITY 0
#define AR_STAT_IRQF 0x80 /* active high, interrupt request flag */
#define AR_QIC02_STAT_READY 0x40 /* active low */
#define AR_QIC02_STAT_EXCEPTION 0x20 /* active low */
#define AR_QIC02_STAT_MASK (AR_QIC02_STAT_READY|AR_QIC02_STAT_EXCEPTION)
#define AR_STAT_DMADONE 0x10 /* active high, DMA done */
#define AR_STAT_DIRC 0x08 /* active high, direction */
#define AR_QIC02_STAT_RESETMASK 0x70 /* check RDY,EXC,DMADONE */
#define AR_QIC02_STAT_RESETVAL ((AR_QIC02_STAT_RESETMASK & ~AR_STAT_IRQF & ~AR_QIC02_STAT_EXCEPTION) | AR_STAT_DMADONE)
/* CTL port bits */
#define AR_QIC02_CTL_RESET 0x80 /* drive reset */
#define AR_QIC02_CTL_REQUEST 0x40 /* notify of new command */
#define AR_CTL_IEN 0x20 /* interrupt enable */
#define AR_CTL_DNIEN 0x10 /* done-interrupt enable */
/* Note: All of these bits are cleared automatically when writing to
* AR_RESET_DMA_PORT. So AR_CTL_IEN and AR_CTL_DNIEN must be
* reprogrammed before the write to AR_START_DMA_PORT.
*/
/* MOUNTAIN interface specifics */
#define MTN_QIC02_STAT_PORT (QIC02_TAPE_PORT+1)
#define MTN_QIC02_CTL_PORT (QIC02_TAPE_PORT+1)
#define MTN_QIC02_CMD_PORT (QIC02_TAPE_PORT)
#define MTN_QIC02_DATA_PORT (QIC02_TAPE_PORT)
#define MTN_W_SELECT_DMA_PORT (QIC02_TAPE_PORT+2)
#define MTN_R_DESELECT_DMA_PORT (QIC02_TAPE_PORT+2)
#define MTN_W_DMA_WRITE_PORT (QIC02_TAPE_PORT+3)
/* STAT port bits */
#define MTN_QIC02_STAT_POLARITY 0
#define MTN_QIC02_STAT_READY 0x02 /* active low */
#define MTN_QIC02_STAT_EXCEPTION 0x04 /* active low */
#define MTN_QIC02_STAT_MASK (MTN_QIC02_STAT_READY|MTN_QIC02_STAT_EXCEPTION)
#define MTN_STAT_DMADONE 0x01 /* active high, DMA done */
#define MTN_QIC02_STAT_RESETMASK 0x07 /* check RDY,EXC,DMADONE */
#define MTN_QIC02_STAT_RESETVAL ((MTN_QIC02_STAT_RESETMASK & ~MTN_QIC02_STAT_EXCEPTION) | MTN_STAT_DMADONE)
/* CTL port bits */
#define MTN_QIC02_CTL_RESET_NOT 0x80 /* drive reset, active low */
#define MTN_QIC02_CTL_RESET 0x80 /* Fodder #definition to keep gcc happy */
#define MTN_QIC02_CTL_ONLINE 0x40 /* Put drive on line */
#define MTN_QIC02_CTL_REQUEST 0x20 /* notify of new command */
#define MTN_QIC02_CTL_IRQ_DRIVER 0x10 /* Enable IRQ tristate driver */
#define MTN_QIC02_CTL_DMA_DRIVER 0x08 /* Enable DMA tristate driver */
#define MTN_CTL_EXC_IEN 0x04 /* Exception interrupt enable */
#define MTN_CTL_RDY_IEN 0x02 /* Ready interrupt enable */
#define MTN_CTL_DNIEN 0x01 /* done-interrupt enable */
#define MTN_CTL_ONLINE (MTN_QIC02_CTL_RESET_NOT | MTN_QIC02_CTL_IRQ_DRIVER | MTN_QIC02_CTL_DMA_DRIVER)
#ifndef CONFIG_QIC02_DYNCONF
# define QIC02_TAPE_DEBUG (qic02_tape_debug)
# if QIC02_TAPE_IFC == WANGTEK
# define QIC02_STAT_POLARITY WT_QIC02_STAT_POLARITY
# define QIC02_STAT_PORT WT_QIC02_STAT_PORT
# define QIC02_CTL_PORT WT_QIC02_CTL_PORT
# define QIC02_CMD_PORT WT_QIC02_CMD_PORT
# define QIC02_DATA_PORT WT_QIC02_DATA_PORT
# define QIC02_STAT_READY WT_QIC02_STAT_READY
# define QIC02_STAT_EXCEPTION WT_QIC02_STAT_EXCEPTION
# define QIC02_STAT_MASK WT_QIC02_STAT_MASK
# define QIC02_STAT_RESETMASK WT_QIC02_STAT_RESETMASK
# define QIC02_STAT_RESETVAL WT_QIC02_STAT_RESETVAL
# define QIC02_CTL_RESET WT_QIC02_CTL_RESET
# define QIC02_CTL_REQUEST WT_QIC02_CTL_REQUEST
# if QIC02_TAPE_DMA == 3
# ifdef QIC02_TAPE_DMA3_FIX
# define WT_CTL_DMA WT_CTL_DMA1
# else
# define WT_CTL_DMA WT_CTL_DMA3
# endif
# elif QIC02_TAPE_DMA == 1
# define WT_CTL_DMA WT_CTL_DMA1
# else
# error Unsupported or incorrect DMA configuration.
# endif
# elif QIC02_TAPE_IFC == EMERALD
# define QIC02_STAT_POLARITY EMR_QIC02_STAT_POLARITY
# define QIC02_STAT_PORT EMR_QIC02_STAT_PORT
# define QIC02_CTL_PORT EMR_QIC02_CTL_PORT
# define QIC02_CMD_PORT EMR_QIC02_CMD_PORT
# define QIC02_DATA_PORT EMR_QIC02_DATA_PORT
# define QIC02_STAT_READY EMR_QIC02_STAT_READY
# define QIC02_STAT_EXCEPTION EMR_QIC02_STAT_EXCEPTION
# define QIC02_STAT_MASK EMR_QIC02_STAT_MASK
# define QIC02_STAT_RESETMASK EMR_QIC02_STAT_RESETMASK
# define QIC02_STAT_RESETVAL EMR_QIC02_STAT_RESETVAL
# define QIC02_CTL_RESET EMR_QIC02_CTL_RESET
# define QIC02_CTL_REQUEST EMR_QIC02_CTL_REQUEST
# if QIC02_TAPE_DMA == 3
# ifdef QIC02_TAPE_DMA3_FIX
# define EMR_CTL_DMA EMR_CTL_DMA1
# else
# define EMR_CTL_DMA EMR_CTL_DMA3
# endif
# elif QIC02_TAPE_DMA == 1
# define EMR_CTL_DMA EMR_CTL_DMA1
# else
# error Unsupported or incorrect DMA configuration.
# endif
# elif QIC02_TAPE_IFC == ARCHIVE
# define QIC02_STAT_POLARITY AR_QIC02_STAT_POLARITY
# define QIC02_STAT_PORT AR_QIC02_STAT_PORT
# define QIC02_CTL_PORT AR_QIC02_CTL_PORT
# define QIC02_CMD_PORT AR_QIC02_CMD_PORT
# define QIC02_DATA_PORT AR_QIC02_DATA_PORT
# define QIC02_STAT_READY AR_QIC02_STAT_READY
# define QIC02_STAT_EXCEPTION AR_QIC02_STAT_EXCEPTION
# define QIC02_STAT_MASK AR_QIC02_STAT_MASK
# define QIC02_STAT_RESETMASK AR_QIC02_STAT_RESETMASK
# define QIC02_STAT_RESETVAL AR_QIC02_STAT_RESETVAL
# define QIC02_CTL_RESET AR_QIC02_CTL_RESET
# define QIC02_CTL_REQUEST AR_QIC02_CTL_REQUEST
# if QIC02_TAPE_DMA > 3 /* channel 2 is used by the floppy driver */
# error DMA channels other than 1 and 3 are not supported.
# endif
# elif QIC02_TAPE_IFC == MOUNTAIN
# define QIC02_STAT_POLARITY MTN_QIC02_STAT_POLARITY
# define QIC02_STAT_PORT MTN_QIC02_STAT_PORT
# define QIC02_CTL_PORT MTN_QIC02_CTL_PORT
# define QIC02_CMD_PORT MTN_QIC02_CMD_PORT
# define QIC02_DATA_PORT MTN_QIC02_DATA_PORT
# define QIC02_STAT_READY MTN_QIC02_STAT_READY
# define QIC02_STAT_EXCEPTION MTN_QIC02_STAT_EXCEPTION
# define QIC02_STAT_MASK MTN_QIC02_STAT_MASK
# define QIC02_STAT_RESETMASK MTN_QIC02_STAT_RESETMASK
# define QIC02_STAT_RESETVAL MTN_QIC02_STAT_RESETVAL
# define QIC02_CTL_RESET MTN_QIC02_CTL_RESET
# define QIC02_CTL_REQUEST MTN_QIC02_CTL_REQUEST
# if QIC02_TAPE_DMA > 3 /* channel 2 is used by the floppy driver */
# error DMA channels other than 1 and 3 are not supported.
# endif
# else
# error No valid interface card specified!
# endif /* QIC02_TAPE_IFC */
/* An ugly hack to make sure WT_CTL_DMA is defined even for the
* static, non-Wangtek case. The alternative was even worse.
*/
# ifndef WT_CTL_DMA
# define WT_CTL_DMA WT_CTL_DMA1
# endif
/*******************/
#else /* !CONFIG_QIC02_DYNCONF */
/* Now the runtime config version, using variables instead of constants.
*
* qic02_tape_dynconf is R/O for the kernel, set from userspace.
* qic02_tape_ccb is private to the driver, R/W.
*/
# define QIC02_TAPE_DRIVE (qic02_tape_dynconf.mt_type)
# define QIC02_TAPE_IFC (qic02_tape_ccb.ifc_type)
# define QIC02_TAPE_IRQ (qic02_tape_dynconf.irqnr)
# define QIC02_TAPE_DMA (qic02_tape_dynconf.dmanr)
# define QIC02_TAPE_PORT (qic02_tape_dynconf.port)
# define WT_CTL_DMA (qic02_tape_ccb.dma_enable_value)
# define QIC02_TAPE_DEBUG (qic02_tape_dynconf.debug)
# define QIC02_STAT_PORT (qic02_tape_ccb.port_stat)
# define QIC02_CTL_PORT (qic02_tape_ccb.port_ctl)
# define QIC02_CMD_PORT (qic02_tape_ccb.port_cmd)
# define QIC02_DATA_PORT (qic02_tape_ccb.port_data)
# define QIC02_STAT_POLARITY (qic02_tape_ccb.stat_polarity)
# define QIC02_STAT_READY (qic02_tape_ccb.stat_ready)
# define QIC02_STAT_EXCEPTION (qic02_tape_ccb.stat_exception)
# define QIC02_STAT_MASK (qic02_tape_ccb.stat_mask)
# define QIC02_STAT_RESETMASK (qic02_tape_ccb.stat_resetmask)
# define QIC02_STAT_RESETVAL (qic02_tape_ccb.stat_resetval)
# define QIC02_CTL_RESET (qic02_tape_ccb.ctl_reset)
# define QIC02_CTL_REQUEST (qic02_tape_ccb.ctl_request)
# define TP_HAVE_DENS (qic02_tape_dynconf.have_dens)
# define TP_HAVE_BSF (qic02_tape_dynconf.have_bsf)
# define TP_HAVE_FSR (qic02_tape_dynconf.have_fsr)
# define TP_HAVE_BSR (qic02_tape_dynconf.have_bsr)
# define TP_HAVE_EOD (qic02_tape_dynconf.have_eod)
# define TP_HAVE_SEEK (qic02_tape_dynconf.have_seek)
# define TP_HAVE_TELL (qic02_tape_dynconf.have_tell)
# define TP_HAVE_RAS1 (qic02_tape_dynconf.have_ras1)
# define TP_HAVE_RAS2 (qic02_tape_dynconf.have_ras2)
#endif /* CONFIG_QIC02_DYNCONF */
/* "Vendor Unique" codes */
/* Archive seek & tell stuff */
#define AR_QCMDV_TELL_BLK 0xAE /* read current block address */
#define AR_QCMDV_SEEK_BLK 0xAD /* seek to specific block */
#define AR_SEEK_BUF_SIZE 3 /* address is 3 bytes */
/*
* Misc common stuff
*/
/* Standard QIC-02 commands -- rev F. All QIC-02 drives must support these */
#define QCMD_SEL_1 0x01 /* select drive 1 */
#define QCMD_SEL_2 0x02 /* select drive 2 */
#define QCMD_SEL_3 0x04 /* select drive 3 */
#define QCMD_SEL_4 0x08 /* select drive 4 */
#define QCMD_REWIND 0x21 /* rewind tape */
#define QCMD_ERASE 0x22 /* erase tape */
#define QCMD_RETEN 0x24 /* retension tape */
#define QCMD_WRT_DATA 0x40 /* write data */
#define QCMD_WRT_FM 0x60 /* write file mark */
#define QCMD_RD_DATA 0x80 /* read data */
#define QCMD_RD_FM 0xA0 /* read file mark (forward direction) */
#define QCMD_RD_STAT 0xC0 /* read status */
/* Other (optional/vendor unique) commands */
/* Density commands are only valid when TP_BOM is set! */
#define QCMD_DENS_11 0x26 /* QIC-11 */
#define QCMD_DENS_24 0x27 /* QIC-24: 9 track 60MB */
#define QCMD_DENS_120 0x28 /* QIC-120: 15 track 120MB */
#define QCMD_DENS_150 0x29 /* QIC-150: 18 track 150MB */
#define QCMD_DENS_300 0x2A /* QIC-300/QIC-2100 */
#define QCMD_DENS_600 0x2B /* QIC-600/QIC-2200 */
/* don't know about QIC-1000 and QIC-1350 */
#define QCMD_WRTNU_DATA 0x40 /* write data, no underruns, insert filler. */
#define QCMD_SPACE_FWD 0x81 /* skip next block */
#define QCMD_SPACE_BCK 0x89 /* move tape head one block back -- very useful! */
#define QCMD_RD_FM_BCK 0xA8 /* read filemark (backwards) */
#define QCMD_SEEK_EOD 0xA3 /* skip to EOD */
#define QCMD_RD_STAT_X1 0xC1 /* read extended status 1 */
#define QCMD_RD_STAT_X2 0xC4 /* read extended status 2 */
#define QCMD_RD_STAT_X3 0xE0 /* read extended status 3 */
#define QCMD_SELF_TST1 0xC2 /* run self test 1 (nondestructive) */
#define QCMD_SELF_TST2 0xCA /* run self test 2 (destructive) */
/* Optional, QFA (Quick File Access) commands.
* Not all drives support this, but those that do could use these commands
* to implement semi-non-sequential access. `mt fsf` would benefit from this.
* QFA divides the tape into 2 partitions, a data and a directory partition,
* causing some incompatibility problems wrt std QIC-02 data exchange.
* It would be useful to cache the directory info, but that might be tricky
* to do in kernel-space. [Size constraints.]
* Refer to the QIC-02 specs, appendix A for more information.
* I have no idea how other *nix variants implement QFA.
* I have no idea which drives support QFA and which don't.
*/
#define QFA_ENABLE 0x2D /* enter QFA mode, give @ BOT only */
#define QFA_DATA 0x20 /* select data partition */
#define QFA_DIR 0x23 /* select directory partition */
#define QFA_RD_POS 0xCF /* read position+status bytes */
#define QFA_SEEK_EOD 0xA1 /* seek EOD within current partition */
#define QFA_SEEK_BLK 0xAF /* seek to a block within current partition */
/*
* Debugging flags
*/
#define TPQD_SENSE_TEXT 0x0001
#define TPQD_SENSE_CNTS 0x0002
#define TPQD_REWIND 0x0004
#define TPQD_TERM_CYCLE 0x0008
#define TPQD_IOCTLS 0x0010
#define TPQD_DMAX 0x0020
#define TPQD_BLKSZ 0x0040
#define TPQD_MISC 0x0080
#define TPQD_DEBUG 0x0100
#define TPQD_DIAGS 0x1000
#define TPQD_ALWAYS 0x8000
#define TPQD_DEFAULT_FLAGS 0x00fc
#define TPQDBG(f) ((QIC02_TAPE_DEBUG) & (TPQD_##f))
/* Minor device codes for tapes:
* |7|6|5|4|3|2|1|0|
* | \ | / \ | / |_____ 1=rewind on close, 0=no rewind on close
* | \|/ |_________ Density: 000=none, 001=QIC-11, 010=24, 011=120,
* | | 100=QIC-150, 101..111 reserved.
* | |_______________ Reserved for unit numbers.
* |___________________ Reserved for diagnostics during debugging.
*/
#define TP_REWCLOSE(d) ((d)&1) /* rewind bit */
/* rewind is only done if data has been transferred */
#define TP_DENS(d) (((d) >> 1) & 0x07) /* tape density */
#define TP_UNIT(d) (((d) >> 4) & 0x07) /* unit number */
/* print excessive diagnostics */
#define TP_DIAGS(dev) (QIC02_TAPE_DEBUG & TPQD_DIAGS)
/* status codes returned by a WTS_RDSTAT call */
struct tpstatus { /* sizeof(short)==2), LSB first */
unsigned short exs; /* Drive exception flags */
unsigned short dec; /* data error count: nr of blocks rewritten/soft read errors */
unsigned short urc; /* underrun count: nr of times streaming was interrupted */
};
#define TPSTATSIZE sizeof(struct tpstatus)
/* defines for tpstatus.exs -- taken from 386BSD wt driver */
#define TP_POR 0x100 /* Power on or reset occurred */
#define TP_EOR 0x200 /* REServed for end of RECORDED media */
#define TP_PAR 0x400 /* REServed for bus parity */
#define TP_BOM 0x800 /* Beginning of media */
#define TP_MBD 0x1000 /* Marginal block detected */
#define TP_NDT 0x2000 /* No data detected */
#define TP_ILL 0x4000 /* Illegal command */
#define TP_ST1 0x8000 /* Status byte 1 flag */
#define TP_FIL 0x01 /* File mark detected */
#define TP_BNL 0x02 /* Bad block not located */
#define TP_UDA 0x04 /* Unrecoverable data error */
#define TP_EOM 0x08 /* End of media */
#define TP_WRP 0x10 /* Write protected cartridge */
#define TP_USL 0x20 /* Unselected drive */
#define TP_CNI 0x40 /* Cartridge not in place */
#define TP_ST0 0x80 /* Status byte 0 flag */
#define REPORT_ERR0 (TP_CNI|TP_USL|TP_WRP|TP_EOM|TP_UDA|TP_BNL|TP_FIL)
#define REPORT_ERR1 (TP_ILL|TP_NDT|TP_MBD|TP_PAR)
/* exception numbers */
#define EXC_UNKNOWN 0 /* (extra) Unknown exception code */
#define EXC_NDRV 1 /* No drive */
#define EXC_NCART 2 /* No cartridge */
#define EXC_WP 3 /* Write protected */
#define EXC_EOM 4 /* EOM */
#define EXC_RWA 5 /* read/write abort */
#define EXC_XBAD 6 /* read error, bad block transferred */
#define EXC_XFILLER 7 /* read error, filler block transferred */
#define EXC_NDT 8 /* read error, no data */
#define EXC_NDTEOM 9 /* read error, no data & EOM */
#define EXC_NDTBOM 10 /* read error, no data & BOM */
#define EXC_FM 11 /* Read a filemark */
#define EXC_ILL 12 /* Illegal command */
#define EXC_POR 13 /* Power on/reset */
#define EXC_MARGINAL 14 /* Marginal block detected */
#define EXC_EOR 15 /* (extra, for SEEKEOD) End Of Recorded data reached */
#define EXC_BOM 16 /* (extra) BOM reached */
#define TAPE_NOTIFY_TIMEOUT 1000000
/* internal function return codes */
#define TE_OK 0 /* everything is fine */
#define TE_EX 1 /* exception detected */
#define TE_ERR 2 /* some error */
#define TE_NS 3 /* can't read status */
#define TE_TIM 4 /* timed out */
#define TE_DEAD 5 /* tape drive doesn't respond */
#define TE_END 6 /******** Archive hack *****/
/* timeout timer values -- check these! */
#define TIM_S (4*HZ) /* 4 seconds (normal cmds) */
#define TIM_M (30*HZ) /* 30 seconds (write FM) */
#define TIM_R (8*60*HZ) /* 8 minutes (retensioning) */
#define TIM_F (2*3600*HZ) /* est. 1.2hr for full tape read/write+2 retens */
#define TIMERON(t) mod_timer(&tp_timer, jiffies + (t))
#define TIMEROFF del_timer_sync(&tp_timer);
#define TIMERCONT add_timer(&tp_timer);
typedef char flag;
#define NO 0 /* NO must be 0 */
#define YES 1 /* YES must be != 0 */
#ifdef TDEBUG
# define TPQDEB(s) s
# define TPQPUTS(s) tpqputs(s)
#else
# define TPQDEB(s)
# define TPQPUTS(s)
#endif
/* NR_BLK_BUF is a `tuneable parameter'. If you're really low on
* kernel space, you could decrease it to 1, or if you got a very
* slow machine, you could increase it up to 127 blocks. Less kernel
* buffer blocks result in more context-switching.
*/
#define NR_BLK_BUF 20 /* max 127 blocks */
#define TAPE_BLKSIZE 512 /* streamer tape block size (fixed) */
#define TPQBUF_SIZE (TAPE_BLKSIZE*NR_BLK_BUF) /* buffer size */
#define BLOCKS_BEYOND_EW 2 /* nr of blocks after Early Warning hole */
#define BOGUS_IRQ 32009
/* This is internal data, filled in based on the ifc_type field given
* by the user. Everex is mapped to Wangtek with a different
* `dma_enable_value', if dmanr==3.
*/
struct qic02_ccb {
long ifc_type;
unsigned short port_stat; /* Status port address */
unsigned short port_ctl; /* Control port address */
unsigned short port_cmd; /* Command port address */
unsigned short port_data; /* Data port address */
/* status register bits */
unsigned short stat_polarity; /* invert status bits or not */
unsigned short stat_ready; /* drive ready */
unsigned short stat_exception; /* drive signals exception */
unsigned short stat_mask;
unsigned short stat_resetmask;
unsigned short stat_resetval;
/* control register bits */
unsigned short ctl_reset; /* reset drive */
unsigned short ctl_request; /* latch command */
/* This is used to change the DMA3 behaviour */
unsigned short dma_enable_value;
};
#if MODULE
static int qic02_tape_init(void);
#else
extern int qic02_tape_init(void); /* for mem.c */
#endif
#endif /* CONFIG_QIC02_TAPE */
#endif /* _LINUX_TPQIC02_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7