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