home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.0 / LINUX-1.0 / LINUX-1 / linux / drivers / char / tpqic02.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-14  |  78.6 KB  |  2,623 lines
  1. /* $Id: tpqic02.c,v 0.2.1.21 1993/06/18 19:04:33 root Exp root $
  2.  *
  3.  * Driver for tape drive support for Linux-i386 0.99.12.
  4.  *
  5.  * Copyright (c) 1993 by H. H. Bergman. All rights reserved.
  6.  * Current e-mail address: csg279@wing.rug.nl
  7.  * [If you are unable to reach me directly, try the TAPE mailing list
  8.  * channel on linux-activists@niksula.hut.fi using "X-Mn-Key: TAPE" as
  9.  * the first line in your message.]
  10.  *
  11.  * Distribution of this program in executable form is only allowed if
  12.  * all of the corresponding source files are made available through the same
  13.  * medium at no extra cost.
  14.  *
  15.  * I will not accept any responsibility for damage caused directly or
  16.  * indirectly by this program, or code derived from this program.
  17.  *
  18.  * Use this code at your own risk. Don't blame me if it destroys your data!
  19.  * Make sure you have a backup before you try this code.
  20.  *
  21.  * This driver was partially inspired by the 'wt' driver in the 386BSD
  22.  * source distribution, which carries the following copyright notice:
  23.  *
  24.  *  Copyright (c) 1991 The Regents of the University of California.
  25.  *  All rights reserved.
  26.  *
  27.  * You are not allowed to change this line nor the text above.
  28.  *
  29.  * $Log: tpqic02.c,v $
  30.  * Revision 0.2.1.21  1993/06/18  19:04:33  root
  31.  * minor fixes for 0.99.10.
  32.  *
  33.  * Revision 0.2.1.20  1993/06/11  21:38:51  root
  34.  * Added exception code for status 0x8000 (Cypher weirdness).
  35.  *
  36.  * Revision 0.2.1.19  1993/04/19  23:13:59  root
  37.  * Cleanups. Changed to 0.99.8.
  38.  *
  39.  * Revision 0.2.1.18  1993/03/22  17:39:47  root
  40.  * Moved to 0.99.7. Added Archive MTSEEK and MTTELL support.
  41.  *
  42.  * Revision 0.2.1.17  1993/03/08  18:51:59  root
  43.  * Tried to `fix' write-once bug in previous release.
  44.  *
  45.  * Revision 0.2.1.16  1993/03/01  00:06:16  root
  46.  * Use register_chrdev() for 0.99.6.
  47.  *
  48.  * Revision 0.2.1.15  1993/02/25  00:14:25  root
  49.  * minor cleanups.
  50.  *
  51.  * Revision 0.2.1.14  1993/01/25  00:06:14  root
  52.  * Kernel udelay. Eof fixups.
  53.  * Removed report_ read/write dummies; have strace(1) now.
  54.  *
  55.  * Revision 0.2.1.13  1993/01/10  02:24:43  root
  56.  * Rewrote wait_for_ready() to use newer schedule() features.
  57.  * This improves performance for rewinds etc.
  58.  *
  59.  * Revision 0.2.1.12  1993/01/05  18:44:09  root
  60.  * Changes for 0.99.1. Fixed `restartable reads'.
  61.  *
  62.  * Revision 0.2.1.11  1992/11/28  01:19:10  root
  63.  * Changes to exception handling (significant).
  64.  * Changed returned error codes. Hopefully they're correct now.
  65.  * Changed declarations to please gcc-2.3.1.
  66.  * Patch to deal with bogus interrupts for Archive cards.
  67.  *
  68.  * Revision 0.2.1.10  1992/10/28  00:50:44  root
  69.  * underrun/error counter needed byte swapping.
  70.  *
  71.  * Revision 0.2.1.9  1992/10/15  17:06:01  root
  72.  * Removed online() stuff. Changed EOF handling.
  73.  *
  74.  * Revision 0.2.1.8  1992/10/02  22:25:48  root
  75.  * Removed `no_sleep' parameters (got usleep() now),
  76.  * cleaned up some comments.
  77.  *
  78.  * Revision 0.2.1.7  1992/09/27  01:41:55  root
  79.  * Changed write() to do entire user buffer in one go, rather than just
  80.  * a kernel-buffer sized portion each time.
  81.  *
  82.  * Revision 0.2.1.6  1992/09/21  02:15:30  root
  83.  * Introduced udelay() function for microsecond-delays.
  84.  * Trying to use get_dma_residue rather than TC flags.
  85.  * Patch to fill entire user buffer on reads before
  86.  * returning.
  87.  *
  88.  * Revision 0.2.1.5  1992/09/19  02:31:28  root
  89.  * Some changes based on patches by Eddy Olk to
  90.  * support Archive SC402/SC499R controller cards.
  91.  *
  92.  * Revision 0.2.1.4  1992/09/07  01:37:37  root
  93.  * Minor changes
  94.  *
  95.  * Revision 0.2.1.3  1992/08/13  00:11:02  root
  96.  * Added some support for Archive SC402 and SC499 cards.
  97.  * (Untested.)
  98.  *
  99.  * Revision 0.2.1.2  1992/08/10  02:02:36  root
  100.  * Changed from linux/system.h macros to asm/dma.h inline functions.
  101.  *
  102.  * Revision 0.2.1.1  1992/08/08  01:12:39  root
  103.  * cleaned up a bit. added stuff for selftesting.
  104.  * preparing for asm/dma.h instead of linux/system.h
  105.  *
  106.  * Revision 0.2  1992/08/03  20:11:30  root
  107.  * Changed to use new IRQ allocation. Padding now done at runtime, pads to
  108.  * 512 bytes. Because of this the page regs must be re-programmed every
  109.  * block! Added hooks for selftest commands.
  110.  * Moved to linux-0.97.
  111.  *
  112.  * Revision 0.1.0.5  1992/06/22  22:20:30  root
  113.  * moved to Linux 0.96b
  114.  *
  115.  * Revision 0.1.0.4  1992/06/18  02:00:04  root
  116.  * Use minor bit-7 to enable/disable printing of extra debugging info
  117.  * when do tape access.
  118.  * Added semop stuff for DMA/IRQ allocation checking. Don't think this
  119.  * is the right way to do it though.
  120.  *
  121.  * Revision 0.1.0.3  1992/06/01  01:57:34  root
  122.  * changed DRQ to DMA. added TDEBUG ifdefs to reduce output.
  123.  *
  124.  * Revision 0.1.0.2  1992/05/31  14:02:38  root
  125.  * changed SET_DMA_PAGE handling slightly.
  126.  *
  127.  * Revision 0.1.0.1  1992/05/27  12:12:03  root
  128.  * Can now use multiple files on tape (sort of).
  129.  * First release.
  130.  *
  131.  * Revision 0.1  1992/05/26  01:16:31  root
  132.  * Initial version. Copyright H. H. Bergman 1992
  133.  *
  134.  */
  135.  
  136. /* After the legalese, now the important bits:
  137.  * 
  138.  * This is a driver for the Wangtek 5150 tape drive with 
  139.  * a QIC-02 controller for ISA-PC type computers.
  140.  * Hopefully it will work with other QIC-02 tape drives as well.
  141.  *
  142.  * Make sure your setup matches the configuration parameters.
  143.  * Also, be careful to avoid IO conflicts with other devices!
  144.  */
  145.  
  146. #include <linux/config.h>
  147.  
  148. /* skip this driver if not required for this configuration */
  149. #if CONFIG_TAPE_QIC02
  150.  
  151. /*
  152. #define TDEBUG
  153. */
  154.  
  155. #define REALLY_SLOW_IO        /* it sure is ... */
  156.  
  157. #include <linux/sched.h>
  158. #include <linux/timer.h>
  159. #include <linux/fs.h>
  160. #include <linux/kernel.h>
  161. #include <linux/major.h>
  162. #include <linux/errno.h>
  163. #include <linux/mtio.h>
  164. #include <linux/fcntl.h>
  165. #include <linux/delay.h>
  166. #include <linux/tpqic02.h>
  167.  
  168. #include <asm/dma.h>
  169. #include <asm/system.h>
  170. #include <asm/io.h>
  171. #include <asm/segment.h>
  172.  
  173. /* check existence of required configuration parameters */
  174. #if !defined(TAPE_QIC02_PORT) || \
  175.     !defined(TAPE_QIC02_IRQ) || \
  176.     !defined(TAPE_QIC02_DMA)
  177. #error tape_qic02 configuration error
  178. #endif
  179.  
  180.  
  181. #define TPQIC_NAME    "tpqic02"
  182.  
  183. /* Linux outb() commands have (value,port) as parameters.
  184.  * One might expect (port,value) instead, so beware!
  185.  */
  186.  
  187. static volatile int ctlbits = 0;     /* control reg bits for tape interface */
  188.  
  189. static struct wait_queue *tape_qic02_transfer = NULL; /* sync rw with interrupts */
  190.  
  191. static volatile struct mtget ioctl_status;    /* current generic status */
  192.  
  193. static volatile struct tpstatus tperror;    /* last drive status */
  194.  
  195. static char rcs_revision[] = "$Revision: 0.2.1.21 $";
  196. static char rcs_date[] = "$Date: 1993/06/18 19:04:33 $";
  197.  
  198. /* Flag bits for status and outstanding requests.
  199.  * (Could all be put in one bit-field-struct.)
  200.  * Some variables need `volatile' because they may be modified
  201.  * by an interrupt.
  202.  */
  203. static volatile flag status_dead = YES;    /* device is legally dead until proven alive */
  204. static         flag status_open = NO;    /* in use or not */
  205.  
  206. static volatile flag status_bytes_wr = NO;    /* write FM at close or not */
  207. static volatile flag status_bytes_rd = NO;    /* (rd|wr) used for rewinding */
  208.  
  209. static volatile unsigned long status_cmd_pending = 0; /* cmd in progress */
  210. static volatile flag status_expect_int = NO;    /* ready for interrupts */
  211. static volatile flag status_timer_on = NO;     /* using time-out */
  212. static volatile int  status_error = 0;        /* int handler may detect error */
  213. static volatile flag status_eof_detected = NO;    /* end of file */
  214. static volatile flag status_eom_detected = NO;    /* end of recorded media */
  215. static volatile flag status_eot_detected = NO;    /* end of tape */
  216. static volatile flag doing_read = NO;
  217. static volatile flag doing_write = NO;
  218.  
  219. static volatile unsigned long dma_bytes_todo;
  220. static volatile unsigned long dma_bytes_done;
  221. static volatile unsigned dma_mode = 0;        /* !=0 also means DMA in use */
  222. static         flag need_rewind = YES;
  223.  
  224. static dev_t current_tape_dev = QIC02_TAPE_MAJOR << 8;
  225. static int extra_blocks_left = BLOCKS_BEYOND_EW;
  226.  
  227.  
  228. /* return_*_eof:
  229.  *    NO:    not at EOF,
  230.  *    YES:    tell app EOF was reached (return 0).
  231.  *
  232.  * return_*_eof==YES && reported_*_eof==NO  ==>
  233.  *    return current buffer, next time(s) return EOF.
  234.  *
  235.  * return_*_eof==YES && reported_*_eof==YES  ==>
  236.  *    at EOF and application knows it, so we can
  237.  *    move on to the next file.
  238.  *
  239.  */
  240. static flag return_read_eof = NO;    /* set to signal app EOF was reached */
  241. static flag return_write_eof = NO;
  242. static flag reported_read_eof = NO;    /* set when we've done that */
  243. static flag reported_write_eof = NO;
  244.  
  245.  
  246. #ifdef TP_HAVE_SEEK
  247. /* This is for doing `mt seek <blocknr>' */
  248. static char seek_addr_buf[SEEK_BUF_SIZE];
  249. #endif
  250.  
  251.  
  252. /* In write mode, we have to write a File Mark after the last block written, 
  253.  * when the tape device is closed. Tape repositioning and reading in write
  254.  * mode is allowed as long as no actual writing has been done. After writing
  255.  * the File Mark, repositioning and reading are allowed again.
  256.  */
  257. static int  mode_access;    /* access mode: READ or WRITE */
  258.  
  259.  
  260. /* This is the actual kernel buffer where the interrupt routines read
  261.  * from/write to. It is needed because the DMA channels 1 and 3 cannot
  262.  * access the user buffers. [The kernel buffer must reside in the lower
  263.  * 1MBytes of system memory because of the DMA controller.]
  264.  * The user must ensure that a large enough buffer is passed to the
  265.  * kernel, in order to reduce tape repositioning.
  266.  *
  267.  * The buffer is 512 bytes larger than expected, because I want to align it
  268.  * at 512 bytes, to prevent problems with 64k boundaries.
  269.  */
  270.  
  271. static volatile char tape_qic02_buf[TPQBUF_SIZE+TAPE_BLKSIZE];
  272. /* A really good compiler would be able to align this at 512 bytes... :-( */
  273.  
  274. static unsigned long buffaddr;    /* aligned physical address of buffer */
  275.  
  276.  
  277. /* This translates minor numbers to the corresponding recording format: */
  278. static char *format_names[] = {
  279.     "not set",    /* for dumb drives unable to handle format selection */
  280.     "11",        /* extinct */
  281.     "24",
  282.     "120",
  283.     "150",
  284.     "300",        /* untested. */
  285.     "600"        /* untested. */
  286. };
  287.  
  288.  
  289. /* `exception_list' is needed for exception status reporting.
  290.  * Exceptions 1..14 are defined by QIC-02 rev F.
  291.  * The drive status is matched sequentially to each entry,
  292.  * ignoring irrelevant bits, until a match is found. If no
  293.  * match is found, exception number 0 is used. (That should of
  294.  * course never happen...) The original table was based on the
  295.  * "Exception Status Summary" in QIC-02 rev F, but some changes
  296.  * were required to make it work with real-world drives.
  297.  *
  298.  * Exception 1 (CNI) is changed to also cover status 0x00e0 (mask USL),
  299.  * Exception 4 (EOM) is changed to also cover status 0x8288 (mask EOR),
  300.  * Exception 11 (FIL) is changed to also cover status 0x0089 (mask EOM).
  301.  * Exception 15 (EOR) is added for seek-to-end-of-data (catch EOR),
  302.  * Exception 16 (BOM) is added for beginning-of-media (catch BOM).
  303.  */
  304. static struct exception_list_type {
  305.     short mask, code;
  306.     char *msg;
  307. } exception_list[] = {
  308.     {0, 0,
  309.         "Unknown exception status code",        /* extra: 0 */},
  310.     {~(TP_WRP|TP_USL), TP_ST0|TP_CNI,
  311.         /* My Wangtek 5150EQ sometimes reports a status code
  312.          * of 0x00e0, which is not a valid exception code, but
  313.          * I think it should be recognized as "NO CARTRIDGE".
  314.          */
  315.         "Cartridge not in place"            /* 1 */},
  316.     {-1, TP_ST0|TP_CNI|TP_USL|TP_WRP,
  317.         "Drive not online"                /* 2 */},
  318.     {~(TP_ST1|TP_BOM), TP_ST0|TP_WRP,
  319.         "Write protected cartridge"            /* 3 */},
  320.     {~(TP_ST1|TP_EOR), TP_ST0|TP_EOM,
  321.         "End of media"                    /* 4 */},
  322.     {~TP_WRP, TP_ST0|TP_UDA| TP_ST1|TP_BOM,
  323.         "Read or Write abort. Rewind tape."        /* 5 */},
  324.     {~TP_WRP, TP_ST0|TP_UDA,
  325.         "Read error. Bad block transferred."        /* 6 */},
  326.     {~TP_WRP, TP_ST0|TP_UDA|TP_BNL,
  327.         "Read error. Filler block transferred."        /* 7 */},
  328.     {~TP_WRP, TP_ST0|TP_UDA|TP_BNL |TP_ST1|TP_NDT,
  329.         "Read error. No data detected."            /* 8 */},
  330.     {~TP_WRP, TP_ST0|TP_EOM|TP_UDA|TP_BNL |TP_ST1|TP_NDT,
  331.         "Read error. No data detected. EOM."        /* 9 */},
  332.     {~(TP_WRP|TP_MBD|TP_PAR|TP_EOR), TP_ST0|TP_UDA|TP_BNL |TP_ST1|TP_NDT|TP_BOM,
  333.         "Read error. No data detected. BOM."        /* 10 */},
  334.     {~(TP_WRP|TP_EOM), TP_ST0|TP_FIL,
  335.         /* Status 0x0089 (EOM & FM) is viewed as an FM,
  336.          * because it can only happen during a read.
  337.          * EOM is checked separately for an FM condition.
  338.          */
  339.         "File mark detected"                /* 11 */},
  340.     {~(TP_ST0|TP_CNI|TP_USL|TP_WRP|TP_BOM), TP_ST1|TP_ILL,
  341.         "Illegal command"                /* 12 */},
  342.     {~(TP_ST0|TP_CNI|TP_USL|TP_WRP|TP_BOM), TP_ST1|TP_POR,
  343.         "Reset occurred"                    /* 13 */},
  344.     {~TP_WRP, TP_ST0|TP_FIL|TP_MBD,        /* NOTE: ST1 not set! */
  345.         "Marginal block detected"            /* 14 */},
  346.     {~(TP_ST0|TP_WRP|TP_EOM|TP_UDA|TP_BNL|TP_FIL |TP_NDT), TP_ST1|TP_EOR,
  347.         /********** Is the extra TP_NDT really needed Eddy? **********/
  348.         "End of recorded media"                /* extra: 15 */},
  349.         /* 15 is returned when SEEKEOD completes successfully */
  350.     {~(TP_WRP|TP_ST0), TP_ST1|TP_BOM,
  351.         "Beginning of media"                /* extra: 16 */}
  352. #ifdef CYPHER_BUG
  353.     /* Perhaps the Cypher driver clears the TP_BOM bit after the
  354.      * status has been read? The QIC-02 specs explicitly state that
  355.      * the BOM bit should remain set as long as the tape is logically
  356.      * at the beginning of the tape.
  357.      */
  358.     ,{-1, TP_ST1,
  359.         "Hmm, this must be Cypher drive... Aaargh"    /* extra */}
  360. #endif
  361. };
  362. #define NR_OF_EXC    (sizeof(exception_list)/sizeof(struct exception_list_type))
  363.  
  364.  
  365.  
  366. static void tpqputs(char *s)
  367. {
  368.     printk(TPQIC_NAME ": %s\n", s);
  369. } /* tpqputs */
  370.  
  371.  
  372. /* Perform byte order swapping for a 16-bit word.
  373.  *
  374.  * [FIXME] This should probably be in include/asm/
  375.  * ([FIXME] i486 can do this faster)
  376.  */
  377. static inline void byte_swap_w(volatile unsigned short * w)
  378. {
  379.     int t = *w;
  380.  
  381.     *w = (t>>8) | ((t & 0xff)<<8);
  382. }
  383.  
  384.  
  385.  
  386. /* Init control register bits on interface card.
  387.  * For Archive, interrupts must be enabled explicitly.
  388.  * Wangtek interface card requires ONLINE to be set, Archive SC402/SC499R
  389.  * cards keep it active all the time.
  390.  */
  391. static void ifc_init(void)
  392. {
  393. #if TAPE_QIC02_IFC == WANGTEK
  394.     ctlbits = WT_CTL_ONLINE;    /* online */
  395.     outb_p(ctlbits, QIC_CTL_PORT);
  396.  
  397. #elif TAPE_QIC02_IFC == ARCHIVE
  398.     ctlbits = 0;            /* no interrupts yet */
  399.     outb_p(ctlbits, QIC_CTL_PORT);
  400.     outb_p(0, AR_RESET_DMA_PORT);    /* dummy write to reset DMA */
  401. #else
  402. # error No valid interface card specified
  403. #endif
  404. } /* ifc_init */
  405.  
  406.  
  407. static void report_exception(unsigned n)
  408. {
  409.     if (n >= NR_OF_EXC) { tpqputs("Oops -- report_exception"); n = 0; }
  410.     printk(TPQIC_NAME ": sense: %s\n", exception_list[n].msg);
  411. } /* report_exception */
  412.  
  413.  
  414. /* Try to map the drive-exception bits `s' to a predefined "exception number",
  415.  * by comparing the significant exception bits for each entry in the
  416.  * exception table (`exception_list[]').
  417.  * It is assumed that s!=0.
  418.  */
  419. static int decode_exception_nr(short s)    /* s must be short, because of sign-extension */
  420. {
  421.     int i;
  422.  
  423.     for (i=1; i<NR_OF_EXC; i++) {
  424.         if ((s & exception_list[i].mask)==exception_list[i].code)
  425.             return i;
  426.     }
  427.     tpqputs("decode_exception_nr: exception not recognized");
  428.     return 0;
  429. } /* decode_exception_nr */
  430.  
  431.  
  432. #ifdef OBSOLETE
  433. /* There are exactly 14 possible exceptions, as defined in QIC-02 rev F.
  434.  * Some are FATAL, some aren't. Currently all exceptions are treated as fatal.
  435.  * Especially 6 and 14 should not abort the transfer. RSN...
  436.  * Should probably let sense() figure out the exception number using the code
  437.  * below, and just report the error based on the number here, returning a code
  438.  * for FATAL/CONTINUABLE.
  439.  */
  440. static void report_error(int s)
  441. {
  442.     short n = -1;
  443.  
  444.     if (s & TP_ST1) {
  445.         if (s & TP_ILL)        /* 12: Illegal command. FATAL */
  446.             n = 12;
  447.         if (s & TP_POR)        /* 13: Reset occurred. FATAL */
  448.             n = 13;
  449.     } 
  450.     else if (s & TP_ST0) {
  451.         if (s & TP_EOR) {    /* extra: 15: End of Recorded Media. CONTINUABLE */
  452.             n = 15;
  453.             /********** should set flag here **********/
  454.         }
  455.         else if (s & TP_EOM)        /* 4: End Of Media. CONTINUABLE */
  456.             n = 4;
  457.         else if (s & TP_USL)        /* 2: Drive not online. FATAL */
  458.             n = 2;
  459.         else if (s & TP_CNI) {    /* 1: Cartridge not in place. FATAL */
  460.             n = 1;
  461.             need_rewind = YES;
  462.             status_eof_detected = NO;
  463.             status_eom_detected = NO;
  464.         }
  465.         else if (s & TP_UDA) {
  466.             if (s & TP_BNL) {
  467.                 if (s & TP_NDT) {
  468.                     if (s & TP_BOM)        /* 9: Read error. No data detected & EOM. CONTINUABLE */
  469.                         n = 9;
  470.                     else if (s & TP_EOM)    /* 10: Read error. No data detected & BOM. CONTINUABLE */
  471.                         n = 10;
  472.                     else            /* 8: Read error. No data detected. CONTINUABLE */
  473.                         n = 8;
  474.                 } else { /* 7: Read error. Cannot recover block, filler substituted. CONTINUABLE */
  475.                     tpqputs("[Bad block -- filler data transferred.]");
  476.                     n = 7;
  477.                 }
  478.             }
  479.             else {
  480.                 if (s & TP_EOM)    /* 5: Read or Write error. Rewind tape. FATAL */
  481.                     n = 5;
  482.                 else {        /* 6: Read error. Bad block transferred. CONTINUABLE */
  483.                     /* block is bad, but transfer may continue.
  484.                      * This is why some people prefer not to
  485.                      * use compression on backups...
  486.                      */
  487.                     tpqputs("[CRC failed!]");
  488.                     n = 6;
  489.                 }
  490.             }
  491.         }
  492.         else if (s & TP_FIL) {
  493.             if (s & TP_MBD) {    /* 14: Marginal block detected. CONTINUABLE */
  494.                 tpqputs("[Marginal block]");
  495.                 n = 14;
  496.             } else            /* 11: File mark detected. CONTINUABLE */
  497.                 n = 11;
  498.         }
  499.         else if (s & TP_WRP)        /* 3: Write protected cartridge. FATAL */
  500.             n = 3;
  501.     }
  502.     if (n >= 0)
  503.          sensemsg(n);
  504. } /* report_error */
  505. #endif
  506.  
  507.  
  508. /* perform appropriate action for certain exceptions */
  509. static void handle_exception(int exnr, int exbits)
  510. {
  511.     if (exnr==EXC_NCART) {
  512.         /* Cartridge was changed. Redo sense().
  513.          * EXC_NCART should be handled in open().
  514.          * It is not permitted to remove the tape while
  515.          * the tape driver has open files. 
  516.          */
  517.         need_rewind = YES;
  518.         status_eof_detected = NO;
  519.         status_eom_detected = NO;
  520.     }
  521.     else if (exnr==EXC_XFILLER)
  522.         tpqputs("[Bad block -- filler data transferred.]");
  523.     else if (exnr==EXC_XBAD)
  524.         tpqputs("[CRC failed!]");
  525.     else if (exnr==EXC_MARGINAL) {
  526.         /* A marginal block behaves much like a FM.
  527.          * User may continue reading, if desired.
  528.          */
  529.         tpqputs("[Marginal block]");
  530.         doing_read = NO;
  531.     } else if (exnr==EXC_FM)
  532.         doing_read = NO;
  533. } /* handle_exception */
  534.  
  535.  
  536. static inline int is_exception(void)
  537. {
  538.     return (inb(QIC_STAT_PORT) & QIC_STAT_EXCEPTION) == 0;
  539. } /* is_exception */
  540.  
  541.  
  542. /* Reset the tape drive and controller.
  543.  * When reset fails, it marks  the drive as dead and all
  544.  * requests (except reset) are to be ignored (ENXIO).
  545.  */
  546. static int tape_reset(int verbose)
  547. {
  548.     ifc_init();                /* reset interface card */
  549.  
  550.     outb_p(ctlbits | QIC_CTL_RESET, QIC_CTL_PORT);    /* assert reset */
  551.  
  552.     /* Next, we need to wait >=25 usec. */
  553.     udelay(30);
  554.  
  555.     /* after reset, we will be at BOT (modulo an automatic rewind) */
  556.     status_eof_detected = NO;
  557.     status_eom_detected = NO;
  558.     status_cmd_pending = 0;
  559.     need_rewind = YES;
  560.     doing_read = doing_write = NO;
  561.     ioctl_status.mt_fileno = ioctl_status.mt_blkno = 0;
  562.  
  563.     outb_p(ctlbits & ~QIC_CTL_RESET, QIC_CTL_PORT);    /* de-assert reset */
  564.     /* KLUDGE FOR G++ BUG */
  565.     { int stat = inb_p(QIC_STAT_PORT);
  566.       status_dead = ((stat & QIC_STAT_RESETMASK) != QIC_STAT_RESETVAL); }
  567.     /* if successful, inb(STAT) returned RESETVAL */
  568.     if (status_dead)
  569.         printk(TPQIC_NAME ": reset failed!\n");
  570.     else if (verbose)
  571.         printk(TPQIC_NAME ": reset successful\n");
  572.  
  573.     return (status_dead)? TE_DEAD : TE_OK;
  574. } /* tape_reset */
  575.  
  576.  
  577.  
  578. /* Notify tape drive of a new command. It only waits for the
  579.  * command to be accepted, not for the actual command to complete.
  580.  *
  581.  * Before calling this routine, QIC_CMD_PORT must have been loaded
  582.  * with the command to be executed.
  583.  * After this routine, the exception bit must be checked.
  584.  * This routine is also used by rdstatus(), so in that case, any exception
  585.  * must be ignored (`ignore_ex' flag).
  586.  */
  587. static int notify_cmd(char cmd, short ignore_ex)
  588. {
  589.     int i;
  590.  
  591.     outb_p(cmd, QIC_CMD_PORT);    /* output the command */
  592.  
  593.     /* wait 1 usec before asserting /REQUEST */
  594.     udelay(1);
  595.  
  596.     if ((!ignore_ex) && is_exception()) {
  597.         tpqputs("*** exception detected in notify_cmd");
  598.         /** force a reset here **/
  599.         if (tape_reset(1)==TE_DEAD)
  600.             return TE_DEAD;
  601.         if (is_exception()) {
  602.             tpqputs("exception persists after reset.");
  603.             tpqputs(" ^ exception ignored.");
  604.         }
  605.     }
  606.  
  607.     outb_p(ctlbits | QIC_CTL_REQUEST, QIC_CTL_PORT);  /* set request bit */
  608.     i = TAPE_NOTIFY_TIMEOUT;
  609.     /* The specs say this takes about 500 usec, but there is no upper limit!
  610.      * If the drive were busy retensioning or something like that,
  611.      * it could be *much* longer!
  612.      */
  613.     while ((inb_p(QIC_STAT_PORT) & QIC_STAT_READY) && (--i>0))
  614.         /*skip*/;              /* wait for ready */
  615.     if (i==0) {
  616.         tpqputs("timed out waiting for ready in notify_cmd");
  617.         status_dead = YES;
  618.         return TE_TIM;
  619.     }
  620.  
  621.     outb_p(ctlbits & ~QIC_CTL_REQUEST, QIC_CTL_PORT); /* reset request bit */
  622.     i = TAPE_NOTIFY_TIMEOUT;
  623.     /* according to the specs this one should never time-out */
  624.     while (((inb_p(QIC_STAT_PORT) & QIC_STAT_READY) == 0) && (--i>0))
  625.         /*skip*/;              /* wait for not ready */
  626.     if (i==0) {
  627.         tpqputs("timed out waiting for !ready in notify_cmd");
  628.         status_dead = YES;
  629.         return TE_TIM;
  630.     }
  631.     /* command accepted */
  632.     return TE_OK;
  633. } /* notify_cmd */
  634.  
  635.  
  636.  
  637. /* Wait for a command to complete, with timeout */
  638. static int wait_for_ready(time_t timeout)
  639. {
  640.     int stat;
  641.     time_t spin_t;
  642.  
  643.     /* Wait for ready or exception, without driving the loadavg up too much.
  644.      * In most cases, the tape drive already has READY asserted,
  645.      * so optimize for that case.
  646.      *
  647.      * First, busy wait a few usec:
  648.      */
  649.     spin_t = 50;
  650.     while (((stat = inb_p(QIC_STAT_PORT) & QIC_STAT_MASK) == QIC_STAT_MASK) && (--spin_t>0))
  651.         /*SKIP*/;
  652.     if ((stat & QIC_STAT_READY) == 0)
  653.         return TE_OK;            /* covers 99.99% of all calls */
  654.  
  655.     /* Then use schedule() a few times */
  656.     spin_t = 3;    /* max 0.03 sec busy waiting */
  657.     if (spin_t > timeout)
  658.         spin_t = timeout;
  659.     timeout -= spin_t;
  660.     spin_t += jiffies;
  661.  
  662.     while (((stat = inb_p(QIC_STAT_PORT) & QIC_STAT_MASK) == QIC_STAT_MASK) && (jiffies<spin_t))
  663.         schedule();        /* don't waste all the CPU time */
  664.     if ((stat & QIC_STAT_READY) == 0)
  665.         return TE_OK;
  666.  
  667.     /* If we reach this point, we probably need to wait much longer, or
  668.      * an exception occurred. Either case is not very time-critical.
  669.      * Check the status port only a few times every second.
  670.      * A interval of less than 0.10 sec will not be noticed by the user,
  671.      * more than 0.40 sec may give noticeable delays.
  672.      */
  673.     spin_t += timeout;
  674.     TPQDEB({printk("wait_for_ready: additional timeout: %d\n", spin_t);})
  675.  
  676.         /* not ready and no exception && timeout not expired yet */
  677.     while (((stat = inb_p(QIC_STAT_PORT) & QIC_STAT_MASK) == QIC_STAT_MASK) && (jiffies<spin_t)) {
  678.         /* be `nice` to other processes on long operations... */
  679.         current->timeout = jiffies + 30;    /* nap 0.30 sec between checks, */
  680.         current->state = TASK_INTERRUPTIBLE;
  681.         schedule();         /* but could be woken up earlier by signals... */
  682.     }
  683.  
  684.     /* don't use jiffies for this test because it may have changed by now */
  685.     if ((stat & QIC_STAT_MASK) == QIC_STAT_MASK) {
  686.         tpqputs("wait_for_ready() timed out");
  687.         return TE_TIM;
  688.     }
  689.  
  690.     if ((stat & QIC_STAT_EXCEPTION) == 0) {
  691.         tpqputs("exception detected after waiting_for_ready");
  692.         return TE_EX;
  693.     } else {
  694.         return TE_OK;
  695.     }
  696. } /* wait_for_ready */
  697.  
  698.  
  699. /* Send some data to the drive */
  700. static int send_qic02_data(char sb[], unsigned size, int ignore_ex)
  701. {
  702.     int i, stat;
  703.  
  704.     for (i=0; i<size; i++) {
  705.  
  706.         stat = wait_for_ready(TIM_S);
  707.         if (stat != TE_OK)
  708.             return stat;
  709.  
  710.         stat = notify_cmd(sb[i], ignore_ex);
  711.         if (stat != TE_OK)
  712.             return stat;
  713.     }
  714.     return TE_OK;
  715.     
  716. } /* send_qic02_data */
  717.  
  718.  
  719. /* Send a QIC-02 command (`cmd') to the tape drive, with
  720.  * a time-out (`timeout').
  721.  * This one is also used by tp_sense(), so we must have
  722.  * a flag to disable exception checking (`ignore_ex'). 
  723.  *
  724.  * On entry, the controller is supposed to be READY.
  725.  */
  726. static int send_qic02_cmd(int cmd, time_t timeout, int ignore_ex)
  727. {
  728.     int stat;
  729.  
  730.     stat = inb_p(QIC_STAT_PORT);
  731.     if ((stat & QIC_STAT_EXCEPTION) == 0) {    /* if exception */
  732.         tpqputs("send_qic02_cmd: Exception!");
  733.         return TE_EX;
  734.     }
  735.     if (stat & QIC_STAT_READY) {            /* if not ready */
  736.         tpqputs("send_qic02_cmd: not Ready!");
  737.         return TE_ERR;
  738.     }
  739.  
  740.     /* assert(ready & !exception) */
  741.  
  742.     /* Remember current command for later re-use with dma transfers.
  743.      * (For reading/writing multiple blocks.)
  744.      */
  745.     status_cmd_pending = cmd;
  746.  
  747.     stat = notify_cmd(cmd, ignore_ex); /* tell drive new command was loaded, */
  748.                        /* inherit exception check. */
  749.     if (cmd == QCMDV_SEEK_BLK) {
  750.         /* This one needs to send 3 more bytes, MSB first */
  751.         stat = send_qic02_data(seek_addr_buf, sizeof(seek_addr_buf), ignore_ex);
  752.     }
  753.     if (stat != TE_OK) {
  754.         tpqputs("send_qic02_cmd failed");
  755.     }
  756.     return stat;
  757. } /* send_qic02_cmd */
  758.  
  759.  
  760.  
  761. /* Get drive status. Assume drive is ready or has exception set.
  762.  * (or will be in <1000 usec.)
  763.  * Extra parameters added because of 'Read Extended Status 3' command.
  764.  */
  765. static int rdstatus(char *stp, unsigned size, char qcmd)
  766. {
  767.     int    s, n;
  768.     char    *q = stp;
  769.  
  770.     /* Try to busy-wait a few (700) usec, after that de-schedule.
  771.      *
  772.      * The problem is, if we don't de-schedule, performance will
  773.      * drop to zero when the drive is not responding and if we
  774.      * de-schedule immediately, we waste a lot of time because a
  775.      * task switch is much longer than we usually have to wait here.
  776.      */
  777.     n = 1000;    /* 500 is not enough on a 486/33 */
  778.     while ((n>0) && ((inb_p(QIC_STAT_PORT) & QIC_STAT_MASK) == QIC_STAT_MASK))
  779.         n--;  /* wait for ready or exception or timeout */
  780.     if (n==0) {
  781.         /* n (above) should be chosen such that on your machine
  782.          * you rarely ever see the message below, and it should
  783.          * be small enough to give reasonable response time.]
  784.          */
  785.         tpqputs("waiting looong in rdstatus() -- drive dead?");
  786.         while ((inb_p(QIC_STAT_PORT) & QIC_STAT_MASK) == QIC_STAT_MASK)
  787.             schedule();
  788.         tpqputs("finished waiting in rdstatus()");
  789.     }
  790.  
  791.     (void) notify_cmd(qcmd, 1);            /* send read status command */
  792.     /* ignore return code -- should always be ok, STAT may contain 
  793.      * exception flag from previous exception which we are trying to clear.
  794.      */
  795.  
  796.     if (TP_DIAGS(current_tape_dev))
  797.         printk(TPQIC_NAME ": reading status bytes: ");
  798.  
  799.     for (q=stp; q<stp+size; q++)
  800.     {
  801.         do s = inb_p(QIC_STAT_PORT);
  802.         while ((s & QIC_STAT_MASK) == QIC_STAT_MASK);    /* wait for ready or exception */
  803.  
  804.         if ((s & QIC_STAT_EXCEPTION) == 0) {        /* if exception */
  805.             tpqputs("rdstatus: exception error");
  806.             ioctl_status.mt_erreg = 0;        /* dunno... */
  807.             return TE_NS;                /* error, shouldn't happen... */
  808.         }
  809.  
  810.         *q = inb_p(QIC_DATA_PORT);            /* read status byte */
  811.  
  812.         if (TP_DIAGS(current_tape_dev))
  813.             printk("[%1d]=0x%x  ", q-stp, (unsigned) (*q) & 0xff);
  814.  
  815.         outb_p(ctlbits | QIC_CTL_REQUEST, QIC_CTL_PORT);    /* set request */
  816.  
  817.         while ((inb_p(QIC_STAT_PORT) & QIC_STAT_READY) == 0);    /* wait for not ready */
  818.  
  819.         udelay(22);    /* delay >20 usec */
  820.  
  821.         outb_p(ctlbits & ~QIC_CTL_REQUEST, QIC_CTL_PORT);    /* un-set request */
  822.  
  823.     }
  824.  
  825.     /* Specs say we should wait for READY here.
  826.      * My drive doesn't seem to need it here yet, but others do?
  827.      */
  828.     while (inb_p(QIC_STAT_PORT) & QIC_STAT_READY)
  829.         /*skip*/;              /* wait for ready */
  830.  
  831.     if (TP_DIAGS(current_tape_dev))
  832.         printk("\n");
  833.  
  834.     return TE_OK;
  835. } /* rdstatus */
  836.  
  837.  
  838.  
  839. /* Get standard status (6 bytes).
  840.  * The `.dec' and `.urc' fields are in MSB-first byte-order,
  841.  * so they have to be swapped first.
  842.  */
  843. static int get_status(char *stp)
  844. {
  845.     int stat = rdstatus(stp, TPSTATSIZE, QCMD_RD_STAT);
  846. #if defined(i386) || defined(i486)
  847.     byte_swap_w(&tperror.dec);
  848.     byte_swap_w(&tperror.urc);
  849. #else
  850.     /* should probably swap status bytes #definition */
  851. #endif
  852.     return stat;
  853. } /* get_status */
  854.  
  855.  
  856. #if 0
  857. /* This fails for my Wangtek drive */
  858. /* get "Extended Status Register 3" (64 bytes)
  859.  *
  860.  * If the meaning of the returned bytes were known, the MT_TYPE
  861.  * identifier could be used to decode them, since they are
  862.  * "vendor unique". :-(
  863.  */
  864. static int get_ext_status3(void)
  865. {
  866.     char vus[64];    /* vendor unique status */
  867.     int stat, i;
  868.  
  869.     tpqputs("Attempting to read Extended Status 3...");
  870.     stat = rdstatus(vus, sizeof(vus), QCMD_RD_STAT_X3);
  871.     if (stat != TE_OK)
  872.         return stat;
  873.  
  874.     tpqputs("Returned status bytes:");
  875.     for (i=0; i<sizeof(vus); i++) {
  876.         if ( i % 8 == 0 )
  877.             printk("\n" TPQIC_NAME ": %2d:");
  878.         printk(" %2x", vus[i] & 0xff);
  879.     }
  880.     printk("\n");
  881.  
  882.     return TE_OK;
  883. } /* get_ext_status3 */
  884. #endif
  885.  
  886.  
  887. /* Read drive status and set generic status too.
  888.  * NOTE: Once we do a tp_sense(), read/write transfers are killed.
  889.  */
  890. static int tp_sense(int ignore)
  891. {
  892.     unsigned err = 0, exnr = 0, gs = 0;
  893.     static void finish_rw(int cmd);
  894.  
  895.     printk(TPQIC_NAME ": tp_sense(ignore=0x%x) enter\n", ignore);
  896.  
  897.     /* sense() is not allowed during a read or write cycle */
  898.     if (doing_write == YES)
  899.         tpqputs("Warning: File Mark inserted because of sense() request");
  900.     /* The extra test is to avoid calling finish_rw during booting */
  901.     if ((doing_read!=NO) || (doing_write!=NO))
  902.         finish_rw(QCMD_RD_STAT);
  903.  
  904.     if (get_status((char *) &tperror) != TE_OK) {
  905.         tpqputs("tp_sense: could not read tape drive status");
  906.         return TE_ERR;
  907.     }
  908.  
  909.     err = tperror.exs;    /* get exception status bits */
  910.     if (err & (TP_ST0|TP_ST1))
  911.         printk(TPQIC_NAME ": tp_sense: status: %x, error count: %d, underruns: %d\n",
  912.             tperror.exs, tperror.dec, tperror.urc);
  913.     else
  914.         printk(TPQIC_NAME ": tp_sense: no errors at all, soft error count: %d, underruns: %d\n",
  915.             tperror.dec, tperror.urc);
  916.  
  917.     /* Set generic status. HP-UX defines these, but some extra would 
  918.      * be useful. Problem is to remain compatible. [Do we want to be
  919.      * compatible??]
  920.      */
  921.     if (err & TP_ST0) {
  922.         if (err & TP_CNI)        /* no cartridge */
  923.             gs |= GMT_DR_OPEN(-1);
  924.         if (status_dead == NO)
  925.             gs |= GMT_ONLINE(-1);    /* always online */
  926.         if (err & TP_USL)        /* not online */
  927.             gs &= ~GMT_ONLINE(-1);
  928.         if (err & TP_WRP)
  929.             gs |= GMT_WR_PROT(-1);
  930.         if (err & TP_EOM) {        /* end of media */
  931.             gs |= GMT_EOT(-1);    /* not sure this is correct for writes */
  932.             status_eom_detected = YES;
  933.             /* I don't know whether drive always reports EOF at or before EOM. */
  934.             status_eof_detected = YES;
  935.         }
  936.         /** if (err & TP_UDA) "Unrecoverable data error" **/
  937.         /** if (err & TP_BNL) "Bad block not located" **/
  938.         if (err & TP_FIL) {
  939.             gs |= GMT_EOF(-1);
  940.             status_eof_detected = YES;
  941.         }
  942.     }
  943.     if (err & TP_ST1) {
  944.         /** if (err & TP_ILL) "Illegal command" **/
  945.         /** if (err & TP_NDT) "No data detected" **/
  946.         /** if (err & TP_MBD) "Marginal block detected" **/
  947.         if (err & TP_BOM)
  948.             gs |= GMT_BOT(-1);    /* beginning of tape */
  949.     }
  950.     ioctl_status.mt_gstat = gs;
  951.     ioctl_status.mt_dsreg = tperror.exs;    /* "drive status" */
  952.     ioctl_status.mt_erreg = tperror.dec;    /* "sense key error" */
  953.  
  954.     if (err!=0) {
  955.         exnr = decode_exception_nr(err);
  956.         handle_exception(exnr, err);        /* update driver state wrt drive status */
  957.         report_exception(exnr);
  958.     }
  959.     err &= ~ignore;        /* mask unwanted errors -- not the correct way, use exception nrs?? */
  960.     if (((err & TP_ST0) && (err & REPORT_ERR0)) ||
  961.         ((err & TP_ST1) && (err & REPORT_ERR1)))
  962.         return TE_ERR;
  963.     return TE_OK;
  964. } /* tp_sense */
  965.  
  966.  
  967.  
  968. /* Wait for a wind or rewind operation to finish or
  969.  * to time-out. (May take very long).
  970.  */
  971. static int wait_for_rewind(time_t timeout)
  972. {
  973.     int stat;
  974.  
  975.     stat = inb(QIC_STAT_PORT) & QIC_STAT_MASK;
  976.     printk(TPQIC_NAME ": Waiting for (re-)wind to finish: stat=0x%x\n", stat);
  977.  
  978.     stat = wait_for_ready(timeout);
  979.  
  980.     if (stat != TE_OK) {
  981.             tpqputs("(re-) winding failed\n");
  982.     }
  983.     return stat;
  984. } /* wait_for_rewind */
  985.  
  986.  
  987.  
  988. /* Perform a full QIC02 command, and wait for completion,
  989.  * check status when done. Complain about exceptions.
  990.  *
  991.  * This function should return an OS error code when
  992.  * something goes wrong, 0 otherwise.
  993.  */
  994. static int ll_do_qic_cmd(int cmd, time_t timeout)
  995. {
  996.     int stat;
  997.  
  998.     if (status_dead) {
  999.         tpqputs("Drive is dead. Do a `mt reset`.");
  1000.         return -ENXIO;            /* User should do an MTRESET. */
  1001.     }
  1002.  
  1003.     stat = wait_for_ready(timeout);        /* wait for ready or exception */
  1004.     if (stat == TE_EX) {
  1005.         if (tp_sense(TP_WRP|TP_BOM|TP_EOM|TP_FIL)!=TE_OK)
  1006.             return -EIO;
  1007.         /* else nothing to worry about, I hope */
  1008.         stat = TE_OK;
  1009.     }
  1010.     if (stat != TE_OK) {
  1011.         printk(TPQIC_NAME ": ll_do_qic_cmd(%x, %d) failed\n", cmd, timeout);
  1012.         return -EIO;
  1013.     }
  1014.  
  1015.  
  1016. #if OBSOLETE
  1017.     /* wait for ready since it may not be active immediately after reading status */
  1018.     while ((inb_p(QIC_STAT_PORT) & QIC_STAT_READY) != 0);
  1019. #endif
  1020.  
  1021.     stat = send_qic02_cmd(cmd, timeout, 0);    /* (checks for exceptions) */
  1022.  
  1023.     if (cmd==QCMD_RD_FM) {
  1024.         status_eof_detected = NO;
  1025.         ioctl_status.mt_fileno++;
  1026.         /* Should update block count as well, but can't.
  1027.          * Can do a `read address' for some drives, when MTNOP is done.
  1028.          */
  1029.     } else if (cmd==QCMD_WRT_FM) {
  1030.         status_eof_detected = NO;
  1031.         ioctl_status.mt_fileno++;
  1032.     } else if ((cmd==QCMD_REWIND) || (cmd==QCMD_ERASE) || (cmd==QCMD_RETEN)) {
  1033.         status_eof_detected = NO;
  1034.         status_eom_detected = NO;
  1035.         status_eot_detected = NO;
  1036.         need_rewind = NO;
  1037.         ioctl_status.mt_fileno = ioctl_status.mt_blkno = 0;
  1038.         extra_blocks_left = BLOCKS_BEYOND_EW;
  1039.         return_write_eof = NO;
  1040.         return_read_eof = NO;
  1041.         reported_read_eof = NO;
  1042.         reported_write_eof = NO;
  1043.     }
  1044.     /* sense() will set eof/eom as required */
  1045.     if (stat==TE_EX) {
  1046.         if (tp_sense(TP_WRP|TP_BOM|TP_EOM|TP_FIL)!=TE_OK) {
  1047.             printk(TPQIC_NAME ": Exception persist in ll_do_qic_cmd[1](%x, %d)", cmd, timeout);
  1048.             status_dead = YES;
  1049.             return -ENXIO;
  1050.             /* if rdstatus fails too, we're in trouble */
  1051.         }
  1052.     }
  1053.     else if (stat!=TE_OK) {
  1054.         printk(TPQIC_NAME ": ll_do_qic_cmd: send_qic02_cmd failed, stat = 0x%x\n", stat);
  1055.         return -EIO;    /*** -EIO is probably not always appropriate */
  1056.     }
  1057.  
  1058.  
  1059.     if (timeout == TIM_R)
  1060.         stat = wait_for_rewind(timeout);
  1061.     else
  1062.         stat = wait_for_ready(timeout);
  1063.  
  1064.     if (stat==TE_EX) {
  1065.         if (tp_sense((cmd==QCMD_SEEK_EOD ?        /*****************************/
  1066.               TP_EOR|TP_NDT|TP_UDA|TP_BNL|TP_WRP|TP_BOM|TP_EOM|TP_FIL :
  1067.               TP_WRP|TP_BOM|TP_EOM|TP_FIL))!=TE_OK) {
  1068.             printk(TPQIC_NAME ": Exception persist in ll_do_qic_cmd[2](%x, %d)\n", cmd, timeout);
  1069.             if (cmd!=QCMD_RD_FM)
  1070.                 status_dead = YES;
  1071.             return -ENXIO;
  1072.             /* if rdstatus fails too, we're in trouble */
  1073.         }
  1074.     }
  1075.     else if (stat!=TE_OK) {
  1076.         printk(TPQIC_NAME ": ll_do_qic_cmd %x: wait failed, stat == 0x%x\n", cmd, stat);
  1077.         return -EIO;
  1078.     }
  1079.     return 0;
  1080. } /* ll_do_qic_cmd */
  1081.  
  1082.  
  1083. /* 
  1084.  * Problem: What to do when the user cancels a read/write operation
  1085.  * in-progress?
  1086.  *
  1087.  * "Deactivating ONLINE during a READ also causes the"
  1088.  * "tape to be rewound to BOT." Ditto for WRITEs, except
  1089.  * a FM is written first. "The host may alternatively terminate
  1090.  * the READ/WRITE command by issuing a RFM/WFM command."
  1091.  *
  1092.  * For READs:
  1093.  * Neither option will leave the tape positioned where it was.
  1094.  * Another (better?) solution is to terminate the READ by two
  1095.  * subsequent sense() operations, the first to stop the current
  1096.  * READ cycle, the second to clear the `Illegal command' exception,
  1097.  * because the QIC-02 specs didn't anticipate this. This is
  1098.  * delayed until actually needed, so a tar listing can be aborted
  1099.  * by the user and continued later.
  1100.  * If anybody has a better solution, let me know! [Also, let me
  1101.  * know if your drive (mine is a Wangtek5150EQ) does not accept
  1102.  * this sequence for canceling the read-cycle.]
  1103.  *
  1104.  * For WRITEs it's simple: Just do a WRITE_FM, leaving the tape
  1105.  * positioned after the FM.
  1106.  */
  1107.  
  1108. static void terminate_read(int cmd)
  1109. {
  1110.     if (doing_read == YES) {
  1111.         doing_read = NO;
  1112.         if (cmd != QCMD_RD_FM) {
  1113.             /* if the command is a RFM, there is no need to do this
  1114.              * because a RFM will legally terminate the read-cycle.
  1115.              */
  1116.             tpqputs("terminating pending read-cycle");
  1117.             if (tp_sense(TP_FIL|TP_EOM|TP_WRP) != TE_OK) {
  1118.                 tpqputs("finish_rw[read1]: ignore the 2 lines above");
  1119.                 if (is_exception()) {
  1120.                     if (tp_sense(TP_ILL|TP_FIL|TP_EOM|TP_WRP) != TE_OK)
  1121.                         tpqputs("finish_rw[read2]: read cycle error");
  1122.                 }
  1123.             }
  1124.         }
  1125.     }
  1126. } /* terminate_read */
  1127.  
  1128.  
  1129. static void terminate_write(int cmd)
  1130. {
  1131.     int stat;
  1132.  
  1133.     if (doing_write == YES) {
  1134.         doing_write = NO;
  1135.         /* Finish writing by appending a FileMark at the end. */
  1136.         if (cmd != QCMD_WRT_FM) {
  1137.             /* finish off write cycle */
  1138.             stat = ll_do_qic_cmd(QCMD_WRT_FM, TIM_M);
  1139.             if (stat != TE_OK)
  1140.                 tpqputs("Couldn't finish write cycle properly");
  1141.             (void) tp_sense(0);
  1142.         }
  1143.         /* If there is an EOF token waiting to be returned to
  1144.          * the (writing) application, discard it now.
  1145.          * We could be at EOT, so don't reset return_write_eof.
  1146.          */
  1147.         reported_write_eof=YES;
  1148.     }
  1149. } /* terminate_write */
  1150.  
  1151.  
  1152. /* terminate read or write cycle because of command `cmd' */
  1153. static void finish_rw(int cmd)
  1154. {
  1155.     if (wait_for_ready(TIM_S) != TE_OK) {
  1156.         tpqputs("error: drive not ready in finish_rw() !");
  1157.         return;
  1158.     }
  1159.     terminate_read(cmd);
  1160.     terminate_write(cmd);
  1161. } /* finish_rw */
  1162.  
  1163.  
  1164. /* Perform a QIC command through ll_do_qic_cmd().
  1165.  * If necessary, rewind the tape first.
  1166.  * Return an OS error code if something goes wrong, 0 if all is well.
  1167.  */
  1168. static int do_qic_cmd(int cmd, time_t timeout)
  1169. {
  1170.     int stat;
  1171.  
  1172.  
  1173.     finish_rw(cmd);
  1174.  
  1175.     if (need_rewind) {
  1176.         tpqputs("Rewinding tape...");
  1177.         stat = ll_do_qic_cmd(QCMD_REWIND, TIM_R);
  1178.         if (stat != 0) {
  1179.             printk(TPQIC_NAME ": rewind failed in do_qic_cmd(). stat=0x%2x", stat);
  1180.             return stat;
  1181.         }
  1182.         need_rewind = NO;
  1183.         if (cmd==QCMD_REWIND)    /* don't wind beyond BOT ;-) */
  1184.             return 0;
  1185.     }
  1186.  
  1187.     return ll_do_qic_cmd(cmd, timeout);
  1188. } /* do_qic_cmd */
  1189.  
  1190.  
  1191. /* Not all ioctls are supported for all drives. Some rely on
  1192.  * optional QIC-02 commands. Check tpqic02.h for configuration.
  1193.  * Some of these commands may require ONLINE to be active.
  1194.  */
  1195. static int do_ioctl_cmd(int cmd)
  1196. {
  1197.     int stat;
  1198.  
  1199.     /* It is not permitted to read or wind the tape after bytes have
  1200.      * been written. It is not permitted to write the tape while in
  1201.      * read mode.
  1202.      * We try to be kind and allow reading again after writing a FM...
  1203.      */
  1204.  
  1205.     switch (cmd) {
  1206.         case MTRESET:
  1207.             /* reset verbose */
  1208.             return (tape_reset(1)==TE_OK)? 0 : -EIO;
  1209.  
  1210.         case MTFSF:
  1211.             tpqputs("MTFSF forward searching filemark");
  1212.             if ((mode_access==WRITE) && status_bytes_wr)
  1213.                 return -EACCES;
  1214.             return do_qic_cmd(QCMD_RD_FM, TIM_F);
  1215.  
  1216.         case MTBSF:
  1217. #ifdef TP_HAVE_BSF
  1218.             tpqputs("MTBSF backward searching filemark -- optional command");
  1219.             if ((mode_access==WRITE) && status_bytes_wr)
  1220.                 return -EACCES;
  1221.             stat = do_qic_cmd(QCMD_RD_FM_BCK, TIM_F);
  1222. #else
  1223.             tpqputs("MTBSF not supported");
  1224.             stat = -ENXIO;
  1225. #endif
  1226.             status_eom_detected = status_eof_detected = NO;
  1227.             return stat;
  1228.  
  1229.         case MTFSR:
  1230. #ifdef TP_HAVE_FSR    /* This is an optional QIC-02 command */
  1231.             tpqputs("MTFSR forward space record");
  1232.             if ((mode_access==WRITE) && status_bytes_wr)
  1233.                 return -EACCES;
  1234.             stat = do_qic_cmd(QCMD_SPACE_FWD, TIM_F);
  1235. #else
  1236.             /**** fake it by doing a read data block command? ******/
  1237.             tpqputs("MTFSR not supported");
  1238.             stat = -ENXIO;
  1239. #endif
  1240.             return stat;
  1241.  
  1242.         case MTBSR:
  1243. #ifdef TP_HAVE_BSR    /* This is an optional QIC-02 command */
  1244.             /* we need this for appending files with GNU tar!! */
  1245.             tpqputs("MTFSR backward space record");
  1246.             if ((mode_access==WRITE) && status_bytes_wr)
  1247.                 return -EACCES;
  1248.             stat = do_qic_cmd(QCMD_SPACE_BCK, TIM_F);
  1249. #else
  1250.             tpqputs("MTBSR not supported");
  1251.             stat = -ENXIO;
  1252. #endif
  1253.             status_eom_detected = status_eof_detected = NO;
  1254.             return stat;
  1255.  
  1256.         case MTWEOF:
  1257.             tpqputs("MTWEOF write eof mark");
  1258.             /* Plain GNU mt(1) 2.2 uses read-only mode for writing FM. :-( */
  1259.             if (mode_access==READ)
  1260.                 return -EACCES;
  1261.  
  1262.             /* allow tape movement after writing FM */
  1263.             status_bytes_rd = status_bytes_wr;    /* Kludge-O-Matic */
  1264.             status_bytes_wr = NO;
  1265.             return do_qic_cmd(QCMD_WRT_FM, TIM_M);
  1266.             /* not sure what to do with status_bytes when WFM should fail */
  1267.  
  1268.         case MTREW:
  1269.             tpqputs("MTREW rewinding tape");
  1270.             if ((mode_access==WRITE) && status_bytes_wr)
  1271.                 return -EACCES;
  1272.             status_eom_detected = status_eof_detected = NO;
  1273.             return do_qic_cmd(QCMD_REWIND, TIM_R);
  1274.  
  1275.         case MTOFFL:
  1276.             tpqputs("MTOFFL rewinding & going offline"); /*---*/
  1277.             /******* What exactly are we supposed to do, to take it offline????
  1278.              *****/
  1279.             /* Doing a drive select will clear (unlock) the current drive.
  1280.              * But that requires support for multiple drives and locking.
  1281.              */
  1282.             if ((mode_access==WRITE) && status_bytes_wr)
  1283.                 return -EACCES;
  1284.             status_eom_detected = status_eof_detected = NO;
  1285.             /**** do rewind depending on minor bits??? ***/
  1286.             stat = do_qic_cmd(QCMD_REWIND, TIM_R);
  1287.             return stat;
  1288.  
  1289.         case MTNOP:
  1290.             tpqputs("MTNOP setting status only");
  1291.             /********** should do `read position' for drives that support it **********/
  1292.             return (tp_sense(-1)==TE_OK)? 0 : -EIO;    /**** check return codes ****/
  1293.  
  1294.         case MTRETEN:
  1295.             tpqputs("MTRETEN retension tape");
  1296.             if ((mode_access==WRITE) && status_bytes_wr)
  1297.                 return -EACCES;
  1298.             status_eom_detected = status_eof_detected = NO;
  1299.             return do_qic_cmd(QCMD_RETEN, TIM_R);
  1300.  
  1301.         case MTBSFM:
  1302.             /* Think think is like MTBSF, except that
  1303.              * we shouldn't skip the FM. Tricky.
  1304.              * Maybe use RD_FM_BCK, then do a SPACE_FWD?
  1305.              */
  1306.             tpqputs("MTBSFM not supported");
  1307.             if ((mode_access==WRITE) && status_bytes_wr)
  1308.                 return -EACCES;
  1309.             return -ENXIO;
  1310.  
  1311.         case MTFSFM:
  1312.             /* I think this is like MTFSF, except that
  1313.              * we shouldn't skip the FM. Tricky.
  1314.              * Maybe use QCMD_RD_DATA until we get a TP_FIL exception?
  1315.              * But then the FM will have been skipped...
  1316.              * Maybe use RD_FM, then RD_FM_BCK, but not all
  1317.              * drives will support that!
  1318.              */
  1319.             tpqputs("MTFSFM not supported");
  1320.             if ((mode_access==WRITE) && status_bytes_wr)
  1321.                 return -EACCES;
  1322.             return -ENXIO;
  1323.  
  1324.         case MTEOM:
  1325.             /* This should leave the tape ready for appending
  1326.              * another file to the end, such that it would append
  1327.              * after the last FM on tape.
  1328.              */
  1329.             tpqputs("MTEOM search for End Of recorded Media");
  1330.             if ((mode_access==WRITE) && status_bytes_wr)
  1331.                 return -EACCES;
  1332. #ifdef TP_HAVE_EOD
  1333.             /* Use faster seeking when possible.
  1334.              * This requires the absence of data beyond the EOM.
  1335.              */
  1336. # if TAPE_QIC02_DRIVE == MT_ISWT5150
  1337.             /* It seems that my drive does not always perform the
  1338.              * SEEK_EOD correctly, unless it is preceded by a
  1339.              * rewind command.
  1340.              */
  1341. # if 0
  1342.             status_eom_detected = status_eof_detected = NO;
  1343. # endif
  1344.             stat = do_qic_cmd(QCMD_REWIND, TIM_R);
  1345.             if (stat)
  1346.                 return stat;
  1347.             
  1348. # endif
  1349.             stat = do_qic_cmd(QCMD_SEEK_EOD, TIM_F);
  1350.             /* After a successful seek, TP_EOR should be returned */
  1351. #else
  1352.             /* else just seek until the drive returns exception "No Data" */
  1353.             stat = 0;
  1354.             while ((stat==0) && (!status_eom_detected)) {
  1355.                 stat = do_qic_cmd(QCMD_RD_FM, TIM_F); /***** should use MTFSFM here???? ******/
  1356.             }
  1357.             if (tperror.exs & TP_NDT)
  1358.                 return 0;
  1359. #endif
  1360.             return stat;
  1361.  
  1362.         case MTERASE:
  1363.             tpqputs("MTERASE -- ERASE TAPE !");
  1364.             if  ((tperror.exs & TP_ST0) && (tperror.exs & TP_WRP)) {
  1365.                 tpqputs("Cartridge is write-protected.");
  1366.                 return -EACCES;
  1367.             } else {
  1368.                 time_t t = jiffies;
  1369.                 /* give user a few seconds to pull out tape */
  1370.                 while (jiffies - t < 3*HZ)
  1371.                     schedule();
  1372.             }
  1373.  
  1374.             /* Plain GNU mt(1) 2.2 erases a tape in O_RDONLY. :-( */
  1375.             if (mode_access==READ) 
  1376.                 return -EACCES;
  1377.  
  1378.             /* don't bother writing filemark */
  1379.             status_eom_detected = status_eof_detected = NO;
  1380.             return do_qic_cmd(QCMD_ERASE, TIM_R);
  1381.  
  1382.  
  1383.         case MTRAS1:
  1384. #ifdef TP_HAVE_RAS1
  1385.             tpqputs("MTRAS1: non-destructive self test");
  1386.             stat = do_qic_cmd(QCMD_SELF_TST1, TIM_R);
  1387.             if (stat != 0) {
  1388.                 tpqputs("RAS1 failed");
  1389.                 return stat;
  1390.             }
  1391.             return (tp_sense(0)==TE_OK)? 0 : -EIO; /* get_ext_status3(); */
  1392. #else
  1393.             tpqputs("RAS1 not supported");
  1394.             return -ENXIO;
  1395. #endif
  1396.  
  1397.         case MTRAS2:
  1398. #ifdef TP_HAVE_RAS2
  1399.             tpqputs("MTRAS2: destructive self test");
  1400.             stat = do_qic_cmd(QCMD_SELF_TST2, TIM_R);
  1401.             if (stat != 0) {
  1402.                 tpqputs("RAS2 failed");
  1403.                 return stat;
  1404.             }
  1405.             return (tp_sense(0)==TE_OK)? 0 : -EIO; /* get_ext_status3(); */
  1406. #else
  1407.             tpqputs("RAS2 not supported");
  1408.             return -ENXIO;
  1409. #endif
  1410.  
  1411. #ifdef TP_HAVE_SEEK
  1412.         case MTSEEK:
  1413.             tpqputs("MTSEEK seeking block");
  1414.             if ((mode_access==WRITE) && status_bytes_wr)
  1415.                 return -EACCES;
  1416.             /* NOTE: address (24 bits) is in seek_addr_buf[] */
  1417.             return do_qic_cmd(QCMDV_SEEK_BLK, TIM_F);
  1418. #endif
  1419.  
  1420.         default:
  1421.             return -ENOTTY;
  1422.     }
  1423. } /* do_ioctl_cmd */
  1424.  
  1425.  
  1426. /* dma_transfer(): This routine is called for every 512 bytes to be read
  1427.  * from/written to the tape controller. Speed is important here!
  1428.  * (There must be enough time left for the hd controller!)
  1429.  * When other devices use DMA they must ensure they use un-interruptible
  1430.  * double byte accesses to the DMA controller. Floppy.c is ok.
  1431.  * Must have interrupts disabled when this function is invoked,
  1432.  * otherwise, the double-byte transfers to the DMA controller will not
  1433.  * be atomic. That could lead to nasty problems when they are interrupted
  1434.  * by other DMA interrupt-routines.
  1435.  *
  1436.  * This routine merely does the least possible to keep
  1437.  * the transfers going:
  1438.  *    - set the DMA count register for the next 512 bytes
  1439.  *    - adjust the DMA address and page registers
  1440.  *    - adjust the timeout
  1441.  *    - tell the tape controller to start transferring
  1442.  * We assume the dma address and mode are, and remain, valid.
  1443.  */ 
  1444. static inline void dma_transfer(void)
  1445. {
  1446.  
  1447. #if TAPE_QIC02_IFC == WANGTEK
  1448.     outb_p(WT_CTL_ONLINE, QIC_CTL_PORT);    /* back to normal */
  1449. #elif TAPE_QIC02_IFC == ARCHIVE
  1450.     outb_p(0, AR_RESET_DMA_PORT);
  1451. #endif
  1452.  
  1453.     clear_dma_ff(TAPE_QIC02_DMA);
  1454.     set_dma_mode(TAPE_QIC02_DMA, dma_mode);
  1455.     set_dma_addr(TAPE_QIC02_DMA, buffaddr+dma_bytes_done);    /* full address */
  1456.     set_dma_count(TAPE_QIC02_DMA, TAPE_BLKSIZE);
  1457.  
  1458.     /* start tape DMA controller */
  1459. #if TAPE_QIC02_IFC == WANGTEK
  1460.     outb_p(WT_CTL_DMA | WT_CTL_ONLINE, QIC_CTL_PORT); /* trigger DMA transfer */
  1461. #elif TAPE_QIC02_IFC == ARCHIVE
  1462.     outb_p(AR_CTL_IEN | AR_CTL_DNIEN, QIC_CTL_PORT);  /* enable interrupts again */
  1463.     outb_p(0, AR_START_DMA_PORT);              /* start DMA transfer */
  1464.     /* In dma_end() AR_RESET_DMA_PORT is written too. */
  1465. #endif
  1466.  
  1467.     /* start computer DMA controller */
  1468.     enable_dma(TAPE_QIC02_DMA);
  1469.     /* block transfer should start now, jumping to the 
  1470.      * interrupt routine when done or an exception was detected.
  1471.      */
  1472. } /* dma_transfer */
  1473.  
  1474.  
  1475. /* start_dma() sets a DMA transfer up between the tape controller and
  1476.  * the kernel tape_qic02_buf buffer.
  1477.  * Normally bytes_todo==dma_bytes_done at the end of a DMA transfer. If not,
  1478.  * a filemark was read, or an attempt to write beyond the End Of Tape 
  1479.  * was made. [Or some other bad thing happened.]
  1480.  * Must do a sense() before returning error.
  1481.  */
  1482. static int start_dma(short mode, unsigned long bytes_todo)
  1483. /* assume 'bytes_todo'>0 */
  1484. {
  1485.     int stat;
  1486.     
  1487.     TPQPUTS("start_dma() enter");
  1488.     TPQDEB({printk(TPQIC_NAME ": doing_read==%d, doing_write==%d\n", doing_read, doing_write);})
  1489.  
  1490.     dma_bytes_done = 0;
  1491.     dma_bytes_todo = bytes_todo;
  1492.     status_error = NO;
  1493.     /* dma_mode!=0 indicates that the dma controller is in use */
  1494.     dma_mode = (mode == WRITE)? DMA_MODE_WRITE : DMA_MODE_READ;    
  1495.  
  1496.     /* Only give READ/WRITE DATA command to tape drive if we haven't
  1497.      * done that already. Otherwise the drive will rewind to the beginning
  1498.      * of the current file on tape. Any QIC command given other than
  1499.      * R/W FM will break the read/write transfer cycle.
  1500.      * do_qic_cmd() will terminate doing_{read,write}
  1501.      */
  1502.     if ((doing_read == NO) && (doing_write == NO)) {
  1503.         /* First, we have to clear the status -- maybe remove TP_FIL???
  1504.          */
  1505.  
  1506. #if 0
  1507.         /* Next dummy get status is to make sure CNI is valid,
  1508.                    since we're only just starting a read/write it doesn't
  1509.                    matter some exceptions are cleared by reading the status;
  1510.                    we're only interested in CNI and WRP. -Eddy */
  1511.         get_status((char *) &tperror);
  1512. #else
  1513.         /* TP_CNI should now be handled in open(). -Hennus */
  1514. #endif
  1515.  
  1516.         stat = tp_sense(((mode == WRITE)? 0 : TP_WRP) | TP_BOM | TP_FIL);
  1517.         if (stat != TE_OK)
  1518.             return stat;
  1519.  
  1520. #if OBSOLETE
  1521.         /************* not needed iff rd_status() would wait for ready!!!!!! **********/
  1522.         if (wait_for_ready(TIM_S) != TE_OK) {    /*** not sure this is needed ***/
  1523.             tpqputs("wait_for_ready failed in start_dma");
  1524.             return -EIO;
  1525.         }
  1526. #endif
  1527.  
  1528.         /* Tell the controller the data direction */
  1529.  
  1530.         /* r/w, timeout medium, check exceptions, sets status_cmd_pending. */
  1531.         stat = send_qic02_cmd((mode == WRITE)? QCMD_WRT_DATA : QCMD_RD_DATA, TIM_M, 0);
  1532.         if (stat!=TE_OK) {
  1533.             printk(TPQIC_NAME ": start_dma: init %s failed\n",
  1534.                 (mode == WRITE)? "write" : "read");
  1535.             (void) tp_sense(0);
  1536.             return stat;
  1537.         }
  1538.  
  1539.         /* Do this last, because sense() will clear the doing_{read,write}
  1540.          * flags, causing trouble next time around.
  1541.          */
  1542.         if (wait_for_ready(TIM_M) != TE_OK)
  1543.             return -EIO;
  1544.         switch (mode) {
  1545.             case READ:
  1546.                 doing_read = YES;
  1547.                 break;
  1548.             case WRITE:
  1549.                 doing_write = YES;
  1550.                 break;
  1551.             default:
  1552.                 printk(TPQIC_NAME ": requested unknown mode %d\n", mode);
  1553.                 panic(TPQIC_NAME ": invalid mode in start_dma()");
  1554.         }
  1555.  
  1556.     } else if (is_exception()) {
  1557.         /* This is for Archive drives, to handle reads with 0 bytes
  1558.          * left for the last read request.
  1559.          *
  1560.          * ******** this also affects EOF/EOT handling! ************
  1561.          */
  1562.         tpqputs("detected exception in start_dma() while transfer in progress");
  1563.         status_error = YES;
  1564.         return TE_END;
  1565.     }
  1566.  
  1567.  
  1568.     status_expect_int = YES;
  1569.  
  1570.     /* This assumes tape is already positioned, but these
  1571.      * semi-'intelligent' drives are unpredictable...
  1572.      */
  1573.     TIMERON(TIM_M*2);
  1574.  
  1575.     /* initiate first data block read from/write to the tape controller */
  1576.  
  1577.     cli();
  1578.     dma_transfer();
  1579.     sti();
  1580.  
  1581.     TPQPUTS("start_dma() end");
  1582.     return TE_OK;
  1583. } /* start_dma */
  1584.  
  1585.  
  1586. /* This cleans up after the dma transfer has completed
  1587.  * (or failed). If an exception occurred, a sense()
  1588.  * must be done. If the exception was caused by a FM,
  1589.  * sense() will set `status_eof_detected' and
  1590.  * `status_eom_detected', as required.
  1591.  */
  1592. static void end_dma(unsigned long * bytes_done)
  1593. {
  1594.     int stat = TE_OK;
  1595.  
  1596.     TIMEROFF;
  1597.  
  1598.     TPQPUTS("end_dma() enter");
  1599.  
  1600.     disable_dma(TAPE_QIC02_DMA);
  1601.     clear_dma_ff(TAPE_QIC02_DMA);
  1602.  
  1603. #if TAPE_QIC02_IFC == WANGTEK
  1604.     outb_p(WT_CTL_ONLINE, QIC_CTL_PORT);    /* back to normal */
  1605. #elif TAPE_QIC02_IFC == ARCHIVE
  1606.     outb_p(0, AR_RESET_DMA_PORT);
  1607. #endif
  1608.  
  1609.     stat = wait_for_ready(TIM_M);
  1610.     if (status_error || (stat!=TE_OK)) {
  1611.         tpqputs("DMA transfer exception");
  1612.         stat = tp_sense((dma_mode==READ)? TP_WRP : 0);
  1613.         /* no return here -- got to clean up first! */
  1614.     }
  1615.     /* take the tape controller offline */
  1616.  
  1617.     /* finish off DMA stuff */
  1618.  
  1619.  
  1620.     dma_mode = 0;
  1621.     /* Note: The drive is left on-line, ready for the next
  1622.      * data transfer.
  1623.      * If the next command to the drive does not continue
  1624.      * the pending cycle, it must do 2 sense()s first.
  1625.      */
  1626.  
  1627.     *bytes_done = dma_bytes_done;
  1628.     status_expect_int = NO;
  1629.     ioctl_status.mt_blkno += (dma_bytes_done / TAPE_BLKSIZE);
  1630.  
  1631.     TPQPUTS("end_dma() exit");
  1632.     /*** could return stat here ***/
  1633. } /* end_dma */
  1634.  
  1635. /*********** Below are the (public) OS-interface procedures ***********/
  1636.  
  1637.  
  1638. /* tape_qic02_times_out() is called when a DMA transfer doesn't complete
  1639.  * quickly enough. Usually this means there is something seriously wrong
  1640.  * with the hardware/software, but it could just be that the controller
  1641.  * has decided to do a long rewind, just when I didn't expect it.
  1642.  * Just try again.
  1643.  */
  1644. static void tape_qic02_times_out(void)
  1645. {
  1646.     printk("time-out in %s driver\n", TPQIC_NAME);
  1647.     if ((status_cmd_pending>0) || dma_mode) {
  1648.         /* takes tooo long, shut it down */
  1649.         status_dead = YES;
  1650.         status_cmd_pending = 0;
  1651.         status_timer_on = NO;
  1652.         status_expect_int = NO;
  1653.         status_error = YES;
  1654.         if (dma_mode) {
  1655.             dma_mode = 0;    /* signal end to read/write routine */
  1656.             wake_up(&tape_qic02_transfer);
  1657.         }
  1658.     }
  1659. } /* tape_qic02_times_out */
  1660.  
  1661. /*
  1662.  * Interrupt handling:
  1663.  *
  1664.  * 1) Interrupt is generated iff at the end of 
  1665.  *    a 512-DMA-block transfer.
  1666.  * 2) EXCEPTION is not raised unless something 
  1667.  *    is wrong or EOT/FM is detected.
  1668.  * 3) FM EXCEPTION is set *after* the last byte has
  1669.  *    been transferred by DMA. By the time the interrupt
  1670.  *    is handled, the EXCEPTION may already be set.
  1671.  *
  1672.  * So,
  1673.  * 1) On EXCEPTION, assume data has been transferred, so
  1674.  *    continue as usual, but set a flag to indicate the
  1675.  *    exception was detected.
  1676.  *    Do a sense status when the flag is found set.
  1677.  * 2) Do not attempt to continue a transfer after an exception.
  1678.  *    [??? What about marginal blocks???????]
  1679.  */
  1680.  
  1681.  
  1682. /* tape_qic02_interrupt() is called when the tape controller completes 
  1683.  * a DMA transfer.
  1684.  * We are not allowed to sleep here! 
  1685.  *
  1686.  * Check if the transfer was successful, check if we need to transfer
  1687.  * more. If the buffer contains enough data/is empty enough, signal the
  1688.  * read/write() thread to copy to/from user space.
  1689.  * When we are finished, set flags to indicate end, disable timer.
  1690.  * NOTE: This *must* be fast! 
  1691.  */
  1692. static void tape_qic02_interrupt(int unused)
  1693. {
  1694.     int stat, r, i;
  1695.  
  1696.     TIMEROFF;
  1697.  
  1698.     if (status_expect_int) {
  1699.         if (TP_DIAGS(current_tape_dev))
  1700.             printk("@");
  1701.     
  1702.         stat = inb(QIC_STAT_PORT);    /* Knock, knock */
  1703. #if TAPE_QIC02_IFC == ARCHIVE            /* "Who's there?" */
  1704.         if (((stat & (AR_STAT_DMADONE)) == 0) &&
  1705.                       ((stat & (QIC_STAT_EXCEPTION)) != 0)) {
  1706.             TIMERCONT;
  1707.             return;            /* "Linux with IRQ sharing" */
  1708.         }
  1709. #endif
  1710.         if ((stat & QIC_STAT_EXCEPTION) == 0) {    /* exception occurred */
  1711.             /* Possible causes for an exception during a transfer:
  1712.              *     - during a write-cycle: end of tape (EW) hole detected.
  1713.              *    - during a read-cycle: filemark or EOD detected.
  1714.              *    - something went wrong
  1715.              * So don't continue with the next block.
  1716.              */
  1717.             tpqputs("isr: exception on tape controller");
  1718.             printk("      status %02x\n", stat);
  1719.             status_error = TE_EX;
  1720.  
  1721.             dma_bytes_done += TAPE_BLKSIZE;
  1722.  
  1723.             dma_mode = 0;    /* wake up rw() */
  1724.             status_expect_int = NO;
  1725.             wake_up(&tape_qic02_transfer);
  1726.             return;
  1727.         }
  1728.         /* return if tape controller not ready, or
  1729.          * if dma channel hasn't finished last byte yet.
  1730.          */
  1731.         r = 0;
  1732. /* Skip next ready check for Archive controller because
  1733.  * it may be busy reading ahead. Weird. --hhb
  1734.  */
  1735. #if TAPE_QIC02_IFC != ARCHIVE        /* I think this is a drive-dependency, not IFC -- hhb */
  1736.         if (stat & QIC_STAT_READY) {        /* not ready */
  1737.             tpqputs("isr: ? Tape controller not ready");
  1738.             r = 1;
  1739.         }
  1740. #endif
  1741.  
  1742.         if ( (i = get_dma_residue(TAPE_QIC02_DMA)) != 0 ) {
  1743.             printk(TPQIC_NAME ": dma_residue == %x !!!\n", i);
  1744.             r = 1;    /* big trouble, but can't do much about it... */
  1745.         }
  1746.  
  1747.         if (r) 
  1748.             return;
  1749.  
  1750.         /* finish DMA cycle */
  1751.  
  1752.         /* no errors detected, continue */
  1753.         dma_bytes_done += TAPE_BLKSIZE;
  1754.         if (dma_bytes_done >= dma_bytes_todo) {
  1755.             /* finished! Wakeup rw() */
  1756.             dma_mode = 0;
  1757.             status_expect_int = NO;
  1758.             TPQPUTS("isr: dma_bytes_done");
  1759.             wake_up(&tape_qic02_transfer);
  1760.         } else {
  1761.             /* start next transfer, account for track-switching time */
  1762.             timer_table[TAPE_QIC02_TIMER].expires = jiffies + 6*HZ;
  1763.             dma_transfer();
  1764.         }
  1765.     } else {
  1766.         printk(TPQIC_NAME ": Unexpected interrupt, stat == %x\n",
  1767.                inb(QIC_STAT_PORT));
  1768.     }
  1769. } /* tape_qic02_interrupt */
  1770.  
  1771.  
  1772. static int tape_qic02_lseek(struct inode * inode, struct file * file, off_t offset, int origin)
  1773. {
  1774.     return -EINVAL;    /* not supported */
  1775. } /* tape_qic02_lseek */
  1776.  
  1777.  
  1778. /* read/write routines:
  1779.  * This code copies between a kernel buffer and a user buffer. The 
  1780.  * actual data transfer is done using DMA and interrupts. Time-outs
  1781.  * are also used.
  1782.  *
  1783.  * When a filemark is read, we return '0 bytes read' and continue with the
  1784.  * next file after that.
  1785.  * When EOM is read, we return '0 bytes read' twice.
  1786.  * When the EOT marker is detected on writes, '0 bytes read' should be
  1787.  * returned twice. If user program does a MTNOP after that, 2 additional
  1788.  * blocks may be written.    ------- FIXME: Implement this correctly  *************************************************
  1789.  *
  1790.  * Only read/writes in multiples of 512 bytes are accepted.
  1791.  * When no bytes are available, we sleep() until they are. The controller will
  1792.  * generate an interrupt, and we (should) get a wake_up() call.
  1793.  *
  1794.  * Simple buffering is used. User program should ensure that a large enough
  1795.  * buffer is used. Usually the drive does some buffering as well (something
  1796.  * like 4k or so).
  1797.  *
  1798.  * Scott S. Bertilson suggested to continue filling the user buffer, rather
  1799.  * than waste time on a context switch, when the kernel buffer fills up.
  1800.  */
  1801.  
  1802. /*
  1803.  * Problem: tar(1) doesn't always read the entire file. Sometimes the entire file
  1804.  * has been read, but the EOF token is never returned to tar(1), simply because
  1805.  * tar(1) knows it has already read all of the data it needs. So we must use
  1806.  * open/release to reset the `reported_read_eof' flag. If we don't, the next read
  1807.  * request would return the EOF flag for the previous file.
  1808.  */
  1809.  
  1810. static int tape_qic02_read(struct inode * inode, struct file * filp, char * buf, int count)
  1811. {
  1812.     int error;
  1813.     dev_t dev = inode->i_rdev;
  1814.     unsigned short flags = filp->f_flags;
  1815.     unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
  1816.     int stat;
  1817.  
  1818.     if (TP_DIAGS(current_tape_dev))
  1819.         printk(TPQIC_NAME ": request READ, minor=%x, buf=%p, count=%x, pos=%x, flags=%x\n",
  1820.             MINOR(dev), buf, count, filp->f_pos, flags);
  1821.  
  1822.     if (count % TAPE_BLKSIZE) {    /* Only allow mod 512 bytes at a time. */
  1823.         tpqputs("Wrong block size");
  1824.         return -EINVAL;
  1825.     }
  1826.  
  1827.     /* Just assume everything is ok. Controller will scream if not. */
  1828.  
  1829.     if (status_bytes_wr)    /* Once written, no more reads, 'till after WFM. */
  1830.         return -EACCES;
  1831.  
  1832.  
  1833.     /* Make sure buffer is safe to write into. */
  1834.     error = verify_area(VERIFY_WRITE, buf, count);
  1835.     if (error) {
  1836.         printk(TPQIC_NAME ": read: verify_area(WRITE, %p, %x) failed\n", buf, count);
  1837.         return error;
  1838.     }
  1839.  
  1840.     /* This is rather ugly because it has to implement a finite state
  1841.      * machine in order to handle the EOF situations properly.
  1842.      */
  1843.     while (count>=0) {
  1844.         bytes_done = 0;
  1845.         /* see how much fits in the kernel buffer */
  1846.         bytes_todo = TPQBUF_SIZE;
  1847.         if (bytes_todo>count)
  1848.             bytes_todo = count;
  1849.  
  1850.         /* Must ensure that user program sees exactly one EOF token (==0) */
  1851.         if (return_read_eof==YES) {
  1852.             printk("read: return_read_eof==%d, reported_read_eof==%d, total_bytes_done==%d\n", return_read_eof, reported_read_eof, total_bytes_done);
  1853.  
  1854.             if (reported_read_eof==NO) {
  1855.                 /* have not yet returned EOF to user program */
  1856.                 if (total_bytes_done>0) {
  1857.                     return total_bytes_done; /* next time return EOF */
  1858.                 } else {
  1859.                     reported_read_eof = YES; /* move on next time */
  1860.                     return 0;         /* return EOF */
  1861.                 }                
  1862.             } else {
  1863.                 /* Application program has already received EOF
  1864.                  * (above), now continue with next file on tape,
  1865.                  * if possible.
  1866.                  * When the FM is reached, EXCEPTION is set,
  1867.                  * causing a sense(). Subsequent read/writes will
  1868.                  * continue after the FM.
  1869.                  */
  1870. /*********** ?????????? this should check for (EOD|NDT), not EOM, 'cause we can read past EW: ************/
  1871.                 if (status_eom_detected)
  1872.                     /* If EOM, nothing left to read, so keep returning EOFs.
  1873.                      *** should probably set some flag to avoid clearing
  1874.                      *** status_eom_detected through ioctls or something
  1875.                      */
  1876.                     return 0;
  1877.                 else {
  1878.                     /* just eof, there may be more files ahead... */
  1879.                     return_read_eof = NO;
  1880.                     reported_read_eof = NO;
  1881.                     status_eof_detected = NO; /* reset this too */
  1882.                     /*fall through*/
  1883.                 }
  1884.             }
  1885.         }
  1886.  
  1887. /*****************************/
  1888.         if (bytes_todo==0)
  1889.             return total_bytes_done;
  1890.  
  1891.         if (bytes_todo>0) {
  1892.             /* start reading data */
  1893.             if (is_exception())    /****************************************/
  1894.                 tpqputs("is_exception() before start_dma()!");
  1895. /******************************************************************
  1896.  ***** if start_dma() fails because the head is positioned 0 bytes
  1897.  ***** before the FM, (causing EXCEPTION to be set) return_read_eof should
  1898.  ***** be set to YES, and we should return total_bytes_done, rather than -ENXIO.
  1899.  ***** The app should recognize this as an EOF condition.
  1900.  ***************************************************************************/
  1901.             stat = start_dma(READ, bytes_todo);
  1902.             if (stat == TE_OK) {
  1903.                 /* Wait for transfer to complete, interrupt should wake us */
  1904.                 while (dma_mode != 0) {
  1905.                     sleep_on(&tape_qic02_transfer);
  1906.                 }
  1907.                 if (status_error)
  1908.                     return_read_eof = YES;
  1909.             } else if (stat != TE_END) {
  1910.                 /* should do sense() on error here */
  1911. #if 0
  1912.                 return -ENXIO;
  1913. #else
  1914.                 printk("Trouble: stat==%02x\n", stat);
  1915.                 return_read_eof = YES;
  1916.                 /*************** check EOF/EOT handling!!!!!! **/
  1917. #endif
  1918.             }
  1919.             end_dma(&bytes_done);
  1920.             if (bytes_done>bytes_todo) {
  1921.                 tpqputs("read: Oops, read more bytes than requested");
  1922.                 return -EIO;
  1923.             }
  1924.             /* copy buffer to user-space in one go */
  1925.             if (bytes_done>0)
  1926.                 memcpy_tofs( (void *) buf, (void *) buffaddr, bytes_done);
  1927. #if 1
  1928.             /* Checks Ton's patch below */
  1929.             if ((return_read_eof == NO) && (status_eof_detected == YES)) {
  1930.                 printk(TPQIC_NAME ": read(): return_read_eof=%d, status_eof_detected=YES. return_read_eof:=YES\n", return_read_eof);
  1931.             }
  1932. #endif
  1933.             if ((bytes_todo != bytes_done) || (status_eof_detected == YES))
  1934.                 /* EOF or EOM detected. return EOF next time. */
  1935.                 return_read_eof = YES;
  1936.         } /* else: ignore read request for 0 bytes */
  1937.  
  1938.         if (bytes_done>0) {
  1939.             status_bytes_rd = YES;
  1940.             buf += bytes_done;
  1941.             filp->f_pos += bytes_done;
  1942.             total_bytes_done += bytes_done;
  1943.             count -= bytes_done;
  1944.         }
  1945.     }
  1946.     tpqputs("read request for <0 bytes");
  1947.     return -EINVAL;
  1948. } /* tape_qic02_read */
  1949.  
  1950.  
  1951.  
  1952. /* The drive detects near-EOT by means of the holes in the tape.
  1953.  * When the holes are detected, there is some space left. The drive
  1954.  * reports this as a TP_EOM exception. After clearing the exception,
  1955.  * the drive should accept two extra blocks.
  1956.  *
  1957.  * It seems there are some archiver programs that would like to use the
  1958.  * extra space for writing a continuation marker. The driver should return
  1959.  * end-of-file to the user program on writes, when the holes are detected.
  1960.  * If the user-program wants to use the extra space, it should use the
  1961.  * MTNOP ioctl() to get the generic status register and may then continue
  1962.  * writing (max 1kB).    ----------- doesn't work yet...............
  1963.  *
  1964.  * EOF behaviour on writes:
  1965.  * If there is enough room, write all of the data.
  1966.  * If there is insufficient room, write as much as will fit and
  1967.  * return the amount written. If the requested amount differs from the
  1968.  * written amount, the application program should recognize that as the
  1969.  * end of file. Subsequent writes will return -ENOSPC.
  1970.  * Unless the minor bits specify a rewind-on-close, the tape will not
  1971.  * be rewound when it is full. The user-program should do that, if desired.
  1972.  * If the driver were to do that automatically, a user-program could be 
  1973.  * confused about the EOT/BOT condition after re-opening the tape device.
  1974.  *
  1975.  * Multiple volume support: Tar closes the tape device before prompting for
  1976.  * the next tape. The user may then insert a new tape and tar will open the
  1977.  * tape device again. The driver will detect an exception status in (No Cartridge)
  1978.  * and force a rewind. After that tar may continue writing.
  1979.  */
  1980. static int tape_qic02_write(struct inode * inode, struct file * filp, char * buf, int count)
  1981. {
  1982.     int error;
  1983.     dev_t dev = inode->i_rdev;
  1984.     unsigned short flags = filp->f_flags;
  1985.     unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
  1986.  
  1987.     if (TP_DIAGS(current_tape_dev))
  1988.         printk(TPQIC_NAME ": request WRITE, minor=%x, buf=%p, count=%x, pos=%x, flags=%x\n",
  1989.             MINOR(dev), buf, count, filp->f_pos, flags);
  1990.  
  1991.     if (count % TAPE_BLKSIZE) {    /* only allow mod 512 bytes at a time */
  1992.         tpqputs("Wrong block size");
  1993.         return -EINVAL;
  1994.     }
  1995.  
  1996.     if (mode_access==READ) {
  1997.         tpqputs("Not in write mode");
  1998.         return -EACCES;
  1999.     }
  2000.  
  2001.     /* open() does a sense() and we can assume the tape isn't changed
  2002.      * between open() and release(), so the tperror.exs bits will still
  2003.      * be valid.
  2004.      */
  2005.     if ((tperror.exs & TP_ST0) && (tperror.exs & TP_WRP)) {
  2006.         tpqputs("Cartridge is write-protected.");
  2007.         return -EACCES;    /* don't even try when write protected */
  2008.     }
  2009.  
  2010.     /* Make sure buffer is safe to read from. */
  2011.     error = verify_area(VERIFY_READ, buf, count);
  2012.     if (error) {
  2013.         printk(TPQIC_NAME ": write: verify_area(READ, %p, %x) failed\n", buf, count);
  2014.         return error;
  2015.     }
  2016.  
  2017.     if (doing_read == YES)
  2018.         terminate_read(0);
  2019.  
  2020.     while (count>=0) {
  2021.         /* see how much fits in the kernel buffer */
  2022.         bytes_done = 0;
  2023.         bytes_todo = TPQBUF_SIZE;
  2024.         if (bytes_todo>count)
  2025.             bytes_todo = count;
  2026.     
  2027.         if (return_write_eof == YES) {
  2028.             /* return_write_eof should be reset on reverse tape movements. */
  2029.  
  2030.             if (reported_write_eof==NO) {
  2031.                 if (bytes_todo>0) {
  2032.                     tpqputs("partial write");
  2033.                     /* partial write signals EOF to user program */
  2034.                 }
  2035.                 reported_write_eof = YES;
  2036.                 return total_bytes_done;
  2037.             } else {
  2038.                 return -ENOSPC;         /* return error */
  2039.             }    
  2040.         }
  2041.  
  2042.         /* Quit when done. */
  2043.         if (bytes_todo==0)
  2044.             return total_bytes_done;
  2045.  
  2046.  
  2047.         /* copy from user to DMA buffer and initiate transfer. */
  2048.         if (bytes_todo>0) {
  2049.             memcpy_fromfs( (void *) buffaddr, (void *) buf, bytes_todo);
  2050.  
  2051. /****************** similar problem with read() at FM could happen here at EOT.
  2052.  ******************/
  2053.  
  2054. /***** if at EOT, 0 bytes can be written. start_dma() will
  2055.  ***** fail and write() will return ENXIO error
  2056.  *****/
  2057.             if (start_dma(WRITE, bytes_todo) != TE_OK) {
  2058.                 tpqputs("write: start_dma() failed");
  2059.                 /* should do sense() on error here */
  2060.                 return -ENXIO;    /*********** FIXTHIS **************/
  2061.             }
  2062.  
  2063.             /* Wait for write to complete, interrupt should wake us. */
  2064.             while ((status_error == 0) && (dma_mode != 0)) {
  2065.                 sleep_on(&tape_qic02_transfer);
  2066.             }
  2067.  
  2068.             end_dma(&bytes_done);
  2069.             if (bytes_done>bytes_todo) {
  2070.                 tpqputs("write: Oops, wrote more bytes than requested");
  2071.                 return -EIO;
  2072.             }
  2073.             /* If the dma-transfer was aborted because of an exception,
  2074.              * status_error will have been set in the interrupt handler.
  2075.              * Then end_dma() will do a sense().
  2076.              * If the exception was EXC_EOM, the EW-hole was encountered
  2077.              * and two more blocks could be written. For the time being we'll
  2078.              * just consider this to be the EOT.
  2079.              * Otherwise, something Bad happened, such as the maximum number
  2080.              * of block-rewrites was exceeded. [e.g. A very bad spot on tape was
  2081.              * encountered. Normally short dropouts are compensated for by
  2082.              * rewriting the block in error, up to 16 times. I'm not sure
  2083.              * QIC-24 drives can do this.]
  2084.              */
  2085.             if (status_error) {
  2086.                 if (status_eom_detected == YES)    {
  2087.                     tpqputs("write: EW detected");
  2088.                     return_write_eof = YES;
  2089.                 } else {
  2090.                     /* probably EXC_RWA */
  2091.                     tpqputs("write: dma: error in writing");
  2092.                     return -EIO;
  2093.                 }
  2094.             }
  2095.             if (bytes_todo != bytes_done)
  2096.                 /* EOF or EOM detected. return EOT next time. */
  2097.                 return_write_eof = YES;
  2098.         }
  2099.         /* else: ignore write request for 0 bytes. */
  2100.  
  2101.         if (bytes_done>0) {
  2102.             status_bytes_wr = YES;
  2103.             buf += bytes_done;
  2104.             filp->f_pos += bytes_done;
  2105.             total_bytes_done += bytes_done;
  2106.             count -= bytes_done;
  2107.         }
  2108.     }
  2109.     tpqputs("write request for <0 bytes");
  2110.     printk(TPQIC_NAME ": status_bytes_wr %x, buf %p, total_bytes_done %x, count %x\n", status_bytes_wr, buf, total_bytes_done, count);
  2111.     return -EINVAL;
  2112. } /* tape_qic02_write */
  2113.  
  2114.  
  2115.  
  2116. /* tape_qic02_open()
  2117.  * We allow the device to be opened, even if it is marked 'dead' because
  2118.  * we want to be able to reset the tape device without rebooting.
  2119.  * Only one open tape file at a time, except when minor=255.
  2120.  * Minor 255 is only allowed for resetting and always returns <0.
  2121.  * 
  2122.  * The density command is only allowed when TP_BOM is set. Thus, remember
  2123.  * the most recently used minor bits. When they are different from the
  2124.  * remembered values, rewind the tape and set the required density.
  2125.  * Don't rewind if the minor bits specify density 0.
  2126.  */
  2127. static int tape_qic02_open(struct inode * inode, struct file * filp)
  2128. {
  2129.     dev_t dev = inode->i_rdev;
  2130.     unsigned short flags = filp->f_flags;
  2131.     unsigned short dens;
  2132.     int s;
  2133.  
  2134.     status_open = NO;
  2135.  
  2136.     if (TP_DIAGS(dev)) {
  2137.         printk("tape_qic02_open: dev=%x, flags=%x     ", dev, flags);
  2138.     }
  2139.  
  2140.     if (MINOR(dev)==255)    /* special case for resetting */
  2141.         if (suser())
  2142.             return (tape_reset(1)==TE_OK) ? -EAGAIN : -ENXIO;
  2143.         else
  2144.             return -EPERM;
  2145.  
  2146.     if (status_open==YES) {
  2147.         return -EBUSY;    /* only one at a time... */
  2148.     }
  2149.     status_open = YES;
  2150.  
  2151.     status_bytes_rd = NO;
  2152.     status_bytes_wr = NO;
  2153.  
  2154.     return_read_eof = NO;    /********????????????????*****/
  2155.     return_write_eof = (status_eot_detected)? YES : NO;
  2156.  
  2157.     /* Clear this in case user app close()d before reading EOF token */
  2158.     status_eof_detected = NO;
  2159.  
  2160.     reported_read_eof = NO;
  2161.     reported_write_eof = NO;
  2162.  
  2163.  
  2164.     switch (flags & O_ACCMODE) {
  2165.         case O_RDONLY:
  2166.             mode_access = READ;
  2167.             break;
  2168.         case O_WRONLY:    /* Fallthru... Strictly speaking this is not correct... */
  2169.         case O_RDWR:    /* reads are allowed as long as nothing is written */
  2170.             mode_access = WRITE;
  2171.             break;
  2172.     }
  2173.  
  2174.  
  2175.     /* This is to avoid tape-changed problems (TP_CNI exception). */
  2176.     if (is_exception()) {
  2177.         s = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
  2178.         if (s != TE_OK) {
  2179.             status_open = NO;
  2180.             tpqputs("open: sense() failed after exception was detected");
  2181.             return -EIO;
  2182.         }
  2183.     }
  2184.  
  2185.  
  2186.     /* not allowed to do QCMD_DENS_* unless tape is rewound */
  2187.     if ((TP_DENS(dev)!=0) && (TP_DENS(current_tape_dev) != TP_DENS(dev))) {
  2188.         /* force rewind if minor bits have changed,
  2189.          * i.e. user wants to use tape in different format.
  2190.          * [assuming single drive operation]
  2191.          */
  2192.         tpqputs("Density minor bits have changed. Forcing rewind.");
  2193.         need_rewind = YES;
  2194.     } else {
  2195.         /* density bits still the same, but TP_DIAGS bit 
  2196.          * may have changed.
  2197.          */
  2198.         current_tape_dev = dev;
  2199.     }
  2200.  
  2201.     if (need_rewind == YES) {
  2202.         s = do_qic_cmd(QCMD_REWIND, TIM_R);
  2203.         if (s != 0) {
  2204.             tpqputs("open: rewind failed");
  2205.             status_open = NO;
  2206.             return -EIO;
  2207.         }
  2208.     }
  2209.  
  2210.  
  2211. /* Note: After a reset command, the controller will rewind the tape
  2212.  *     just before performing any tape movement operation!
  2213.  */ 
  2214.     if (status_dead) {
  2215.         tpqputs("open: tape dead, attempting reset");
  2216.         if (tape_reset(1)!=TE_OK) {
  2217.             status_open = NO;
  2218.             return -ENXIO;
  2219.         } else {
  2220.             status_dead = NO;
  2221.             if (tp_sense(~(TP_ST1|TP_ILL)) != TE_OK) {
  2222.                 tpqputs("open: tp_sense() failed\n");
  2223.                 status_dead = YES;    /* try reset next time */
  2224.                 status_open = NO;
  2225.                 return -EIO;
  2226.             }
  2227.         }
  2228.     }
  2229.  
  2230.     /* things should be ok, once we get here */
  2231.  
  2232.  
  2233.     /* set density: only allowed when TP_BOM status bit is set,
  2234.      * so we must have done a rewind by now. If not, just skip over.
  2235.      * Only give set density command when minor bits have changed.
  2236.      */
  2237.     if (TP_DENS(current_tape_dev) == TP_DENS(dev) )
  2238.         return 0;
  2239.  
  2240.     current_tape_dev = dev;
  2241.     need_rewind = NO;
  2242.     dens = TP_DENS(dev);
  2243.     if (dens < sizeof(format_names)/sizeof(char *))
  2244.         printk(TPQIC_NAME ": format: %s%s\n", (dens!=0)? "QIC-" : "", format_names[dens]);
  2245.     else
  2246.         tpqputs("Wait for retensioning...");
  2247.  
  2248.     switch (TP_DENS(dev)) {
  2249.         case 0: /* This one's for Eddy ;-) */
  2250.             s = 0;
  2251.             break;
  2252.         case 1:
  2253.             s = do_qic_cmd(QCMD_DENS_11, TIM_S);
  2254.             break;
  2255.         case 2:
  2256.             s = do_qic_cmd(QCMD_DENS_24, TIM_S);
  2257.             break;
  2258.         case 3:
  2259.             s = do_qic_cmd(QCMD_DENS_120, TIM_S);
  2260.             break;
  2261.         case 4:
  2262.             s = do_qic_cmd(QCMD_DENS_150, TIM_S);
  2263.             break;
  2264.         case 5:
  2265.             s = do_qic_cmd(QCMD_DENS_300, TIM_S);
  2266.             break;
  2267.         case 6:
  2268.             s = do_qic_cmd(QCMD_DENS_600, TIM_S);
  2269.             break;
  2270.         default:  /* otherwise do a retension before anything else */
  2271.             s = do_qic_cmd(QCMD_RETEN, TIM_R);
  2272.     }
  2273.     if (s != 0) {
  2274.         status_open = NO;    /* fail if fault occurred */
  2275.         status_dead = YES;    /* force reset */
  2276.         current_tape_dev = 0xff80;
  2277.         return -EIO;
  2278.     }
  2279.  
  2280.     return 0;
  2281. } /* tape_qic02_open */
  2282.  
  2283.  
  2284. static int tape_qic02_readdir(struct inode * inode, struct file * filp, struct dirent * dp, int count)
  2285. {
  2286.     return -ENOTDIR;    /* not supported */
  2287. } /* tape_qic02_readdir */
  2288.  
  2289.  
  2290. static void tape_qic02_release(struct inode * inode, struct file * filp)
  2291. {
  2292.     dev_t dev = inode->i_rdev;
  2293.  
  2294.     if (TP_DIAGS(dev))
  2295.         printk("tape_qic02_release: dev=%x\n", dev);
  2296.  
  2297.     /* Terminate any pending write cycle. Terminating the read-cycle
  2298.      * is delayed until it is required to do so for a new command.
  2299.      */
  2300.     terminate_write(-1);
  2301.  
  2302.     if (status_dead==YES)
  2303.         tpqputs("release: device dead!?");
  2304.  
  2305.     if (status_open==NO) {
  2306.         tpqputs("release: device not open");
  2307.         return;
  2308.     }
  2309.      /* Rewind only if minor number requires it AND 
  2310.      * read/writes have been done.
  2311.      */
  2312.     if ((TP_REWCLOSE(dev)) && (status_bytes_rd | status_bytes_wr)) {
  2313.         tpqputs("release: Doing rewind...");
  2314.         (void) do_qic_cmd(QCMD_REWIND, TIM_R);
  2315.     }
  2316.  
  2317.     status_open = NO;
  2318.     return;
  2319. } /* tape_qic02_release */
  2320.  
  2321.  
  2322.  
  2323. /* ioctl allows user programs to rewind the tape and stuff like that */
  2324. static int tape_qic02_ioctl(struct inode * inode, struct file * filp, 
  2325.              unsigned int iocmd, unsigned long ioarg)
  2326. {
  2327.     int error;
  2328.     short i;
  2329.     int dev_maj = MAJOR(inode->i_rdev);
  2330.     int c;
  2331.     struct mtop operation;
  2332.     char *stp, *argp;
  2333.  
  2334. #ifdef TP_HAVE_TELL
  2335.     unsigned char blk_addr[6];
  2336.     struct mtpos ioctl_tell;
  2337. #endif
  2338.  
  2339.     if (TP_DIAGS(current_tape_dev))
  2340.         printk(TPQIC_NAME ": ioctl(%4x, %4x, %4x)\n", dev_maj, iocmd, ioarg);
  2341.  
  2342.     if (!inode || !ioarg)
  2343.         return -EINVAL;
  2344.  
  2345.     /* check iocmd first */
  2346.  
  2347.     if (dev_maj != QIC02_TAPE_MAJOR) {
  2348.         printk(TPQIC_NAME ": Oops! Wrong device?\n");
  2349.         /* A panic() would be appropriate here */
  2350.         return -ENODEV;
  2351.     }
  2352.  
  2353.     c = iocmd & IOCCMD_MASK;
  2354.     if (c == (MTIOCTOP & IOCCMD_MASK)) {
  2355.  
  2356.         /* Compare expected struct size and actual struct size. This
  2357.          * is useful to catch programs compiled with old #includes.
  2358.          */
  2359.         if (((iocmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtop)) {
  2360.             tpqputs("sizeof(struct mtop) does not match!");
  2361.             return -EFAULT;
  2362.         }
  2363.         error = verify_area(VERIFY_READ, (char *) ioarg, sizeof(operation));
  2364.         if (error)
  2365.             return error;
  2366.  
  2367.         /* copy mtop struct from user space to kernel space */
  2368.         stp = (char *) &operation;
  2369.         argp = (char *) ioarg;
  2370.         for (i=0; i<sizeof(operation); i++)
  2371.             *stp++ = get_fs_byte(argp++);
  2372.  
  2373.         /* ---note: mt_count is signed, negative seeks must be
  2374.          * ---        translated to seeks in opposite direction!
  2375.          * (only needed for Sun-programs, I think.)
  2376.          */
  2377.         /* ---note: MTFSF with count 0 should position the
  2378.          * ---        tape at the beginning of the current file.
  2379.          */
  2380.  
  2381.         if (TP_DIAGS(current_tape_dev))
  2382.             printk("OP op=%4x, count=%4x\n", operation.mt_op, operation.mt_count);
  2383.  
  2384.         if (operation.mt_count < 0)
  2385.             tpqputs("Warning: negative mt_count ignored");
  2386.  
  2387.         ioctl_status.mt_resid = operation.mt_count;
  2388.         if (operation.mt_op == MTSEEK) {
  2389.             seek_addr_buf[0] = (operation.mt_count>>16)&0xff;
  2390.             seek_addr_buf[1] = (operation.mt_count>>8)&0xff;
  2391.             seek_addr_buf[2] = (operation.mt_count)&0xff;
  2392.             if (operation.mt_count>>24)
  2393.                 return -EINVAL;
  2394.  
  2395.             if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
  2396.                 return error;
  2397.             ioctl_status.mt_resid = 0;
  2398.         } else {
  2399.             while (operation.mt_count > 0) {
  2400.                 operation.mt_count--;
  2401.                 if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
  2402.                     return error;
  2403.                 ioctl_status.mt_resid = operation.mt_count;
  2404.             }
  2405.         }
  2406.         return 0;
  2407.  
  2408.     } else if (c == (MTIOCGET & IOCCMD_MASK)) {
  2409.         if (TP_DIAGS(current_tape_dev))
  2410.             printk("GET ");
  2411.  
  2412.         /* compare expected struct size and actual struct size */
  2413.         if (((iocmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtget)) {
  2414.             tpqputs("sizeof(struct mtget) does not match!");
  2415.             return -EFAULT;
  2416.         }
  2417.  
  2418.         /* check for valid user address */
  2419.         error =    verify_area(VERIFY_WRITE, (void *) ioarg, sizeof(ioctl_status));
  2420.         if (error)
  2421.             return error;
  2422.  
  2423.         /* It appears (gmt(1)) that it is normal behaviour to
  2424.          * first set the status with MTNOP, and then to read
  2425.          * it out with MTIOCGET
  2426.          */
  2427.  
  2428.         /* copy results to user space */
  2429.         stp = (char *) &ioctl_status;
  2430.         argp = (char *) ioarg;
  2431.         for (i=0; i<sizeof(ioctl_status); i++) 
  2432.             put_fs_byte(*stp++, argp++);
  2433.         return 0;
  2434.  
  2435. #ifdef TP_HAVE_TELL
  2436.     } else if (c == (MTIOCPOS & IOCCMD_MASK)) {
  2437.         if (TP_DIAGS(current_tape_dev))
  2438.             printk("POS ");
  2439.  
  2440.         /* compare expected struct size and actual struct size */
  2441.         if (((iocmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT) != sizeof(struct mtpos)) {
  2442.             tpqputs("sizeof(struct mtpos) does not match!");
  2443.             return -EFAULT;
  2444.         }
  2445.  
  2446.         /* check for valid user address */
  2447.         error = verify_area(VERIFY_WRITE, (void *) ioarg, sizeof(ioctl_tell));
  2448.         if (error)
  2449.             return error;
  2450.  
  2451.         tpqputs("MTTELL reading block address");
  2452.         if ((doing_read==YES) || (doing_write==YES))
  2453.             finish_rw(QCMDV_TELL_BLK);
  2454.  
  2455.         c = rdstatus((char *) blk_addr, sizeof(blk_addr), QCMDV_TELL_BLK);
  2456.         if (c!=TE_OK)
  2457.             return -EIO;
  2458.  
  2459.         ioctl_tell.mt_blkno = (blk_addr[3] << 16) | (blk_addr[4] << 8) | blk_addr[5];
  2460.  
  2461.         /* copy results to user space */
  2462.         stp = (char *) &ioctl_tell;
  2463.         argp = (char *) ioarg;
  2464.         for (i=0; i<sizeof(ioctl_tell); i++) 
  2465.             put_fs_byte(*stp++, argp++);
  2466.         return 0;
  2467. #endif
  2468.     } else
  2469.         return -ENOTTY;    /* Other cmds not supported. */
  2470. } /* tape_qic02_ioctl */
  2471.  
  2472.  
  2473.  
  2474. /* These are (most) of the interface functions: */
  2475. static struct file_operations tape_qic02_fops = {
  2476.     tape_qic02_lseek,        /* not allowed */
  2477.     tape_qic02_read,        /* read */
  2478.     tape_qic02_write,        /* write */
  2479.     tape_qic02_readdir,        /* not allowed */
  2480.     NULL,                /* select ??? */
  2481.     tape_qic02_ioctl,        /* ioctl */
  2482.     NULL,                /* mmap not allowed */
  2483.     tape_qic02_open,        /* open */
  2484.     tape_qic02_release,        /* release */
  2485.     NULL                /* fsync */
  2486. };
  2487.  
  2488.  
  2489. /* Attribute `SA_INTERRUPT' makes the interrupt atomic with
  2490.  * interrupts disabled. We could do without the atomic stuff, but
  2491.  * then dma_transfer() would have to disable interrupts explicitly.
  2492.  * System load is high enough as it is :-(
  2493.  */
  2494. static struct sigaction tape_qic02_sigaction = {
  2495.     tape_qic02_interrupt,
  2496.     0,
  2497.     SA_INTERRUPT,
  2498.     NULL
  2499. };
  2500.  
  2501.  
  2502. /* align `a' at `size' bytes. `size' must be a power of 2 */
  2503. static inline unsigned long const align_buffer(unsigned long a, unsigned size)
  2504. {
  2505.     if (a & (size-1))            /* if not aligned */
  2506.         return (a | (size-1)) + 1;
  2507.     else                    /* else is aligned */
  2508.         return a;
  2509. }
  2510.  
  2511.  
  2512. /* init() is called from chr_dev_init() in kernel/chr_drv/mem.c */
  2513. long tape_qic02_init(long kmem_start)
  2514.     /* Shouldn't this be a caddr_t ? */
  2515. {
  2516.  
  2517.     printk(TPQIC_NAME ": IRQ %d, DMA %d, IO %xh, IFC %s, %s, %s\n",
  2518.          TAPE_QIC02_IRQ, TAPE_QIC02_DMA, TAPE_QIC02_PORT,
  2519. #if TAPE_QIC02_IFC == WANGTEK
  2520.          "Wangtek",
  2521. #elif TAPE_QIC02_IFC == ARCHIVE
  2522.          "Archive",
  2523. #else
  2524. # error
  2525. #endif
  2526.          rcs_revision, rcs_date);
  2527.  
  2528.     /* First perform some checks. If one of them fails,
  2529.      * the tape driver will not be registered to the system.
  2530.      */
  2531.  
  2532.     /* Should do IRQ/DMA allocation in open(). Use free_irq() in release()
  2533.      * return -EBUSY, if allocation fails in open().
  2534.      * Make IRQ settable/readable through ioctls. DMA is trickier because
  2535.      * some bits change for different DMA numbers. Also, this would add 
  2536.      * runtime overhead for having the dma channel number be a variable
  2537.      * rather than a constant. Probably need to make the DMA stuff #ifdef'd
  2538.      * to choose between hardcoded and changeable DMA channel.
  2539.      *
  2540.      * Also, Linux needs a more generic way to set DMA/IRQ and other stuff.
  2541.      * Right now, this is done differently for every device. (setserial,
  2542.      * ctrlaltdel, setdfprm, setfdthr, tunelp, ((setterm))...)
  2543.      *
  2544.      * #include <hint.h>
  2545.      */
  2546.  
  2547.     /* get IRQ */
  2548.     if (irqaction(TAPE_QIC02_IRQ, &tape_qic02_sigaction)) {
  2549.         printk(TPQIC_NAME ": can't allocate IRQ%d for QIC-02 tape\n",
  2550.             TAPE_QIC02_IRQ);
  2551.         return kmem_start;
  2552.     }
  2553.  
  2554.     /* After IRQ, allocate DMA channel */
  2555.     if (request_dma(TAPE_QIC02_DMA)) {
  2556.         printk(TPQIC_NAME ": can't allocate DMA%d for QIC-02 tape\n",
  2557.             TAPE_QIC02_DMA);
  2558.         free_irq(TAPE_QIC02_IRQ);
  2559.         return kmem_start;
  2560.     }
  2561.  
  2562.     if (TPSTATSIZE != 6) {
  2563.         printk(TPQIC_NAME ": internal error: tpstatus struct incorrect!\n");
  2564.         return kmem_start;
  2565.     }
  2566.     if ((TPQBUF_SIZE<512) || (TPQBUF_SIZE>=0x10000)) {
  2567.         printk(TPQIC_NAME ": internal error: DMA buffer size out of range\n");
  2568.         return kmem_start;
  2569.     }
  2570.  
  2571.     printk(TPQIC_NAME ": DMA buffers: %u blocks", NR_BLK_BUF);
  2572.  
  2573.     /* Setup the page-address for the dma transfer.
  2574.      * This assumes a one-to-one identity mapping between
  2575.      * kernel addresses and physical memory.
  2576.      */
  2577.     buffaddr = align_buffer((unsigned long) &tape_qic02_buf, TAPE_BLKSIZE);
  2578.     printk(", at address 0x%lx (0x%lx)\n", buffaddr, (unsigned long) &tape_qic02_buf);
  2579.  
  2580. #ifndef CONFIG_MAX_16M
  2581.     if (buffaddr+TPQBUF_SIZE>=0x1000000) {
  2582.         printk(TPQIC_NAME ": DMA buffer *must* be in lower 16MB\n");
  2583.         return kmem_start;
  2584.     }
  2585. #endif
  2586.  
  2587.     /* If we got this far, install driver functions */
  2588.     if (register_chrdev(QIC02_TAPE_MAJOR, TPQIC_NAME, &tape_qic02_fops)) {
  2589.         printk(TPQIC_NAME ": Unable to get chrdev major %d\n",
  2590.                QIC02_TAPE_MAJOR);
  2591.         return kmem_start;
  2592.     }
  2593.  
  2594.     /* prepare timer */
  2595.     TIMEROFF;
  2596.     timer_table[TAPE_QIC02_TIMER].expires = 0;
  2597.     timer_table[TAPE_QIC02_TIMER].fn = tape_qic02_times_out;
  2598.  
  2599.     if (tape_reset(0)!=TE_OK || tp_sense(TP_WRP|TP_POR|TP_CNI)!=TE_OK) {
  2600.         status_dead = YES;
  2601.     } else {
  2602.         if (is_exception()) {
  2603.             tpqputs("exception detected\n");
  2604.             (void) tp_sense(TP_WRP|TP_POR|TP_CNI);
  2605.         }
  2606.     }
  2607.  
  2608.     /* initialize generic status for ioctl requests */
  2609.  
  2610.     ioctl_status.mt_type    = TAPE_QIC02_DRIVE;    /* MT_IS* id nr */
  2611.  
  2612.     ioctl_status.mt_resid    = 0;    /* ---residual count */
  2613.     ioctl_status.mt_gstat    = 0;    /* ---generic status */
  2614.     ioctl_status.mt_erreg    = 0;    /* not used */
  2615.     ioctl_status.mt_fileno    = 0;    /* number of current file on tape */
  2616.     ioctl_status.mt_blkno    = 0;    /* number of current (logical) block */
  2617.  
  2618.     return kmem_start;
  2619. } /* tape_qic02_init */
  2620.  
  2621.  
  2622. #endif /* CONFIG_TAPE_QIC02 */
  2623.