URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [tpqic02.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/* $Id: tpqic02.c,v 1.1.1.1 2004-04-15 01:58:24 phoenix 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/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 <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
 
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 volatile int ctlbits;    /* control reg bits for tape interface */
 
static wait_queue_head_t qic02_tape_transfer;   /* sync rw with interrupts */
 
static volatile struct mtget ioctl_status;      /* current generic status */
 
static volatile struct tpstatus tperror;        /* last drive status */
 
static char rcs_revision[] = "$Revision: 1.1.1.1 $";
static char rcs_date[] = "$Date: 2004-04-15 01:58:24 $";
 
/* 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 volatile flag status_dead = YES; /* device is legally dead until proven alive */
static flag status_zombie = YES;        /* it's `zombie' until irq/dma allocated */
 
static volatile flag status_bytes_wr = NO;      /* write FM at close or not */
static volatile flag status_bytes_rd = NO;      /* (rd|wr) used for rewinding */
 
static volatile unsigned long status_cmd_pending;       /* cmd in progress */
static volatile flag status_expect_int = NO;    /* ready for interrupts */
static volatile flag status_timer_on = NO;      /* using time-out */
static volatile int status_error;       /* int handler may detect error */
static volatile flag status_eof_detected = NO;  /* end of file */
static volatile flag status_eom_detected = NO;  /* end of recorded media */
static volatile flag status_eot_detected = NO;  /* end of tape */
static volatile flag doing_read = NO;
static volatile flag doing_write = NO;
 
static volatile unsigned long dma_bytes_todo;
static volatile unsigned long dma_bytes_done;
static volatile unsigned dma_mode;      /* !=0 also means DMA in use */
static flag need_rewind = YES;
 
static kdev_t current_tape_dev;
static int extra_blocks_left = BLOCKS_BEYOND_EW;
 
static struct timer_list tp_timer;
 
/* 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. */
};
 
 
/* `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 */
 
 
/* Perform byte order swapping for a 16-bit word.
 *
 * [FIXME] This should probably be in include/asm/
 * ([FIXME] i486 can do this faster)
 */
static inline void byte_swap_w(volatile unsigned short *w)
{
        int t = *w;
        *w = (t >> 8) | ((t & 0xff) << 8);
}
 
 
 
/* 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))
                /*skip */ ;
        /* 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))
                /*skip */ ;
        /* 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;
        time_t 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))
                /*SKIP*/;
        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))
                schedule();     /* 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... */
                current->state = TASK_INTERRUPTIBLE;
                /* nap 0.30 sec between checks, */
                /* but could be woken up earlier by signals... */
                schedule_timeout(3 * HZ / 10);
        }
 
        /* 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 = 1000;               /* 500 is not enough on a 486/33 */
        while ((n > 0) && ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_MASK) == QIC02_STAT_MASK))
                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)
                        schedule();
                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_tape_dev))
                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_tape_dev))
                        printk("[%1d]=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);        /* 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)
                /*skip */ ;
        /* wait for ready */
 
        if (TP_DIAGS(current_tape_dev))
                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);
#if defined(__i386__) || defined (__x86_64__)
        byte_swap_w(&(stp->dec));
        byte_swap_w(&(stp->urc));
#else
#warning Undefined architecture
        /* should probably swap status bytes #definition */
#endif
        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;
        }
#if OBSOLETE
        /* wait for ready since it may not be active immediately after reading status */
        while ((inb_p(QIC02_STAT_PORT) & QIC02_STAT_READY) != 0);
#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) {
                doing_read = NO;
                if (cmd != QCMD_RD_FM) {
                        /* 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) {
                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!)
 * When other devices use DMA they must ensure they use un-interruptible
 * double byte accesses to the DMA controller. Floppy.c is ok.
 * Must have interrupts disabled when this function is invoked,
 * otherwise, the double-byte transfers to the DMA controller will not
 * be atomic. That could lead to nasty problems when they are interrupted
 * by other DMA interrupt-routines.
 *
 * 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,
                     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;
        unsigned long flags;
 
        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;
 
#if 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 */
 
        save_flags(flags);
        cli();
        dma_transfer();
        restore_flags(flags);
 
        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 void 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_tape_dev))
                        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; /* "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;
                }
                /* 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;
 
                /* 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));
        }
}                               /* 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 *buf, size_t count,
                               loff_t * ppos)
{
        kdev_t dev = filp->f_dentry->d_inode->i_rdev;
        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_tape_dev))
                /* can't print a ``long long'' (for filp->f_pos), so chop it */
                printk(TPQIC02_NAME
                       ": request READ, minor=%x, buf=%p, count=%lx"
                       ", pos=%lx, flags=%x\n", MINOR(dev), buf,
                       (long) count, (unsigned long) 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 */
                                while (dma_mode != 0) {
                                        sleep_on(&qic02_tape_transfer);
                                }
                                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 *buf,
                                size_t count, loff_t * ppos)
{
        kdev_t dev = filp->f_dentry->d_inode->i_rdev;
        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_tape_dev)) {
                /* can't print a ``long long'' (for filp->f_pos), so chop it */
                printk(TPQIC02_NAME ": request WRITE, minor=%x, buf=%p"
                       ", count=%lx, pos=%lx, flags=%x\n",
                       MINOR(dev), buf,
                       (long) count, (unsigned long) 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. */
                        while ((status_error == 0) && (dma_mode != 0)) {
                                sleep_on(&qic02_tape_transfer);
                        }
 
                        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)
{
        kdev_t dev = inode->i_rdev;
        unsigned short flags = filp->f_flags;
        unsigned short dens = 0;
        int s;
 
 
        if (TP_DIAGS(dev)) {
                printk("qic02_tape_open: dev=%s, flags=%x     ",
                       kdevname(dev), flags);
        }
 
        if (MINOR(dev) == 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;
        }
 
        /* Only one at a time from here on... */
        if (file_count(filp) > 1) {     /* filp->f_count==1 for the first 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");
                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.");
                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(dev) != 0)
            && (TP_DENS(current_tape_dev) != TP_DENS(dev))) {
                /* 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_tape_dev = dev;
        }
 
        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_tape_dev) == TP_DENS(dev)) {
                return 0;
        }
 
        current_tape_dev = dev;
        need_rewind = NO;
        if (TP_HAVE_DENS) {
                dens = TP_DENS(dev);
        }
 
        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(dev)) {
        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_tape_dev = 0;    /* earlier 0xff80 */
                return -EIO;
        }
 
        return 0;
}                               /* qic02_tape_open */
 
 
static int qic02_tape_release(struct inode *inode, struct file *filp)
{
        kdev_t dev = inode->i_rdev;
 
        lock_kernel();
        if (TP_DIAGS(dev)) {
                printk("qic02_tape_release: dev=%s\n", kdevname(dev));
        }
 
        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(dev))
                    && (status_bytes_rd | status_bytes_wr)) {
                        tpqputs(TPQD_REWIND, "release: Doing rewind...");
                        (void) do_qic_cmd(QCMD_REWIND, TIM_R);
                }
        }
        unlock_kernel();
        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 dev_maj = MAJOR(inode->i_rdev);
        int c;
        struct mtop operation;
        unsigned char blk_addr[6];
        struct mtpos ioctl_tell;
 
 
        if (TP_DIAGS(current_tape_dev)) {
                printk(TPQIC02_NAME ": ioctl(%4x, %4x, %4lx)\n", dev_maj,
                       iocmd, ioarg);
        }
 
        if (!inode || !ioarg) {
                return -EINVAL;
        }
 
        /* check iocmd first */
 
        if (dev_maj != QIC02_TAPE_MAJOR) {
                printk(TPQIC02_NAME ": Oops! Wrong device?\n");
                /* A panic() would be appropriate here */
                return -ENODEV;
        }
 
        c = _IOC_NR(iocmd);
 
#ifdef CONFIG_QIC02_DYNCONF
        if (c == _IOC_NR(MTIOCGETCONFIG)) {
                CHECK_IOC_SIZE(mtconfiginfo);
 
                if (copy_to_user
                    ((char *) ioarg, (char *) &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_ADMIN)) {
                        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
                    ((char *) &qic02_tape_dynconf, (char *) ioarg,
                     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
                    ((char *) &operation, (char *) ioarg,
                     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_tape_dev)) {
                        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_tape_dev)) {
                        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
                    ((char *) ioarg, (char *) &ioctl_status,
                     sizeof(ioctl_status))) {
                        return -EFAULT;
                }
                return 0;
        } else if (TP_HAVE_TELL && (c == _IOC_NR(MTIOCPOS))) {
                if (TP_DIAGS(current_tape_dev)) {
                        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
                    ((char *) ioarg, (char *) &ioctl_tell,
                     sizeof(ioctl_tell))) {
                        return -EFAULT;
                }
                return 0;
 
        } else {
                return -ENOTTY; /* Other cmds not supported. */
        }
}                               /* qic02_tape_ioctl */
 
 
 
/* These are (most) of the interface functions: */
static struct file_operations qic02_tape_fops = {
        owner:THIS_MODULE,
        llseek:no_llseek,
        read:qic02_tape_read,
        write:qic02_tape_write,
        ioctl:qic02_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 = 0;            /* 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.
         */
        if (QIC02_TAPE_IRQ > 16) {
                tpqputs(TPQD_ALWAYS, "Bogus interrupt number.");
                return -ENXIO;
        }
 
        /* 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_tape_dev = MKDEV(QIC02_TAPE_MAJOR, 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 (devfs_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;
        }
        devfs_register(NULL, "ntpqic11", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 2,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "tpqic11", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 3,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "ntpqic24", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 4,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "tpqic24", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 5,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "ntpqic120", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 6,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "tpqic120", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 7,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "ntpqic150", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 8,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        devfs_register(NULL, "tpqic150", DEVFS_FL_DEFAULT,
                       QIC02_TAPE_MAJOR, 9,
                       S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
                       &qic02_tape_fops, NULL);
        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 */
 
#ifdef MODULE
 
void cleanup_module(void)
{
        if (status_zombie == NO) {
                qic02_release_resources();
        }
        devfs_unregister_chrdev(QIC02_TAPE_MAJOR, TPQIC02_NAME);
        devfs_unregister(devfs_find_handle
                         (NULL, "ntpqic11", QIC02_TAPE_MAJOR, 2,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "tpqic11", QIC02_TAPE_MAJOR, 3,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "ntpqic24", QIC02_TAPE_MAJOR, 4,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "tpqic24", QIC02_TAPE_MAJOR, 5,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "ntpqic120", QIC02_TAPE_MAJOR, 6,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "tpqic120", QIC02_TAPE_MAJOR, 7,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "ntpqic150", QIC02_TAPE_MAJOR, 8,
                          DEVFS_SPECIAL_CHR, 0));
        devfs_unregister(devfs_find_handle
                         (NULL, "tpqic150", QIC02_TAPE_MAJOR, 9,
                          DEVFS_SPECIAL_CHR, 0));
}
 
int init_module(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) {
                        cleanup_module();
                }
        }
# endif
        return retval;
}
#endif
 
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [tpqic02.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/* $Id: tpqic02.c,v 1.1.1.1 2004-04-15 01:58:24 phoenix Exp $`
2			`*`
3			`* Driver for tape drive support for Linux-i386`
4			`*`
5			`* Copyright (c) 1992--1996 by H. H. Bergman. All rights reserved.`
6			`* Current e-mail address: hennus@cybercomm.nl`
7			`*`
8			`* Distribution of this program in executable form is only allowed if`
9			`* all of the corresponding source files are made available through the same`
10			`* medium at no extra cost.`
11			`*`
12			`* I will not accept any responsibility for damage caused directly or`
13			`* indirectly by this program, or code derived from this program.`
14			`*`
15			`* Use this code at your own risk. Don't blame me if it destroys your data!`
16			`* Make sure you have a backup before you try this code.`
17			`*`
18			`* If you make changes to my code and redistribute it in source or binary`
19			`* form you must make it clear to even casual users of your code that you`
20			`* have modified my code, clearly point out what the changes exactly are`
21			`* (preferably in the form of a context diff file), how to undo your changes,`
22			`* where the original can be obtained, and that complaints/requests about the`
23			`* modified code should be directed to you instead of me.`
24			`*`
25			`* This driver was partially inspired by the 'wt' driver in the 386BSD`
26			`* source distribution, which carries the following copyright notice:`
27			`*`
28			`* Copyright (c) 1991 The Regents of the University of California.`
29			`* All rights reserved.`
30			`*`
31			`* You are not allowed to change this line nor the text above.`
32			`*`
33			`* 2001/02/26 Minor s/suser/capable/`
34			`*`
35			`* 1996/10/10 Emerald changes`
36			`*`
37			`* 1996/05/21 Misc changes+merges+cleanups + I/O reservations`
38			`*`
39			`* 1996/05/20 Module support patches submitted by Brian McCauley.`
40			`*`