/* $Id: tpqic02.c,v 1.10 1997/01/26 07:13:20 davem Exp $ * * Driver for tape drive support for Linux-i386 * * Copyright (c) 1992--1996 by H. H. Bergman. All rights reserved. * Current e-mail address: hennus@cybercomm.nl * * Distribution of this program in executable form is only allowed if * all of the corresponding source files are made available through the same * medium at no extra cost. * * I will not accept any responsibility for damage caused directly or * indirectly by this program, or code derived from this program. * * Use this code at your own risk. Don't blame me if it destroys your data! * Make sure you have a backup before you try this code. * * If you make changes to my code and redistribute it in source or binary * form you must make it clear to even casual users of your code that you * have modified my code, clearly point out what the changes exactly are * (preferably in the form of a context diff file), how to undo your changes, * where the original can be obtained, and that complaints/requests about the * modified code should be directed to you instead of me. * * This driver was partially inspired by the 'wt' driver in the 386BSD * source distribution, which carries the following copyright notice: * * Copyright (c) 1991 The Regents of the University of California. * All rights reserved. * * You are not allowed to change this line nor the text above. * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* 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 = { 0, }; /* 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 = 0; /* 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.10 $"; static char rcs_date[] = "$Date: 1997/01/26 07:13:20 $"; /* Flag bits for status and outstanding requests. * (Could all be put in one bit-field-struct.) * Some variables need `volatile' because they may be modified * by an interrupt. */ static 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 = 0; /* 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 = 0; /* 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; /* !=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 ' */ 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 unsigned long buffaddr = 0; /* physical 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=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; 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; i0) && ((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.] */ 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; q20 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(i486) byte_swap_w(&(stp->dec)); byte_swap_w(&(stp->urc)); #else /* 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; i0 */ { 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 */ static long long qic02_tape_lseek(struct file * file, long long offset, int origin) { return -EINVAL; /* not supported */ } /* qic02_tape_lseek */ /* 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) { int err; 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) { err = copy_to_user( (void *) buf, (void *) bus_to_virt(buffaddr), bytes_done); if (err) { 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) { int err; 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) { err = copy_from_user( (void *) bus_to_virt(buffaddr), (const void *) buf, bytes_todo); if (err) { 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 (suser()) { 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; 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); } } 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 (!suser()) { 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: qic02_tape_lseek, /* not allowed */ 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(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. */ if (check_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE)) { 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); 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); return -EBUSY; } /* Grab the IO region. We already made sure it's available. */ request_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE, TPQIC02_NAME); /* Setup the page-address for the dma transfer. */ /*** TODO: does _get_dma_pages() really return the physical address?? ****/ buffaddr = __get_dma_pages(GFP_KERNEL,get_order(TPQBUF_SIZE)); if (!buffaddr) { qic02_release_resources(); return -EBUSY; /* Not ideal, EAGAIN perhaps? */ } memset( (void*) 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