v2.4.2.1 -> v2.4.2.2
[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 static long long qic02_tape_lseek(struct file * file, long long offset, int origin)
1738 {
1739         return -EINVAL; /* not supported */
1740 } /* qic02_tape_lseek */
1741
1742
1743 /* read/write routines:
1744  * This code copies between a kernel buffer and a user buffer. The 
1745  * actual data transfer is done using DMA and interrupts. Time-outs
1746  * are also used.
1747  *
1748  * When a filemark is read, we return '0 bytes read' and continue with the
1749  * next file after that.
1750  * When EOM is read, we return '0 bytes read' twice.
1751  * When the EOT marker is detected on writes, '0 bytes read' should be
1752  * returned twice. If user program does a MTNOP after that, 2 additional
1753  * blocks may be written.       ------- FIXME: Implement this correctly  *************************************************
1754  *
1755  * Only read/writes in multiples of 512 bytes are accepted.
1756  * When no bytes are available, we sleep() until they are. The controller will
1757  * generate an interrupt, and we (should) get a wake_up() call.
1758  *
1759  * Simple buffering is used. User program should ensure that a large enough
1760  * buffer is used. Usually the drive does some buffering as well (something
1761  * like 4k or so).
1762  *
1763  * Scott S. Bertilson suggested to continue filling the user buffer, rather
1764  * than waste time on a context switch, when the kernel buffer fills up.
1765  */
1766
1767 /*
1768  * Problem: tar(1) doesn't always read the entire file. Sometimes the entire file
1769  * has been read, but the EOF token is never returned to tar(1), simply because
1770  * tar(1) knows it has already read all of the data it needs. So we must use
1771  * open/release to reset the `reported_read_eof' flag. If we don't, the next read
1772  * request would return the EOF flag for the previous file.
1773  */
1774
1775 static ssize_t qic02_tape_read(struct file * filp, char * buf, size_t count, loff_t *ppos)
1776 {
1777     int err;
1778     kdev_t dev = filp->f_dentry->d_inode->i_rdev;
1779     unsigned short flags = filp->f_flags;
1780     unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
1781     int stat;
1782
1783     if (status_zombie==YES)
1784     {
1785         tpqputs(TPQD_ALWAYS, "configs not set");                
1786         return -ENXIO;
1787     }
1788
1789     if (TP_DIAGS(current_tape_dev))
1790       /* can't print a ``long long'' (for filp->f_pos), so chop it */
1791       printk(TPQIC02_NAME ": request READ, minor=%x, buf=%p, count=%lx"
1792                           ", pos=%lx, flags=%x\n",
1793              MINOR(dev), buf, (long) count,
1794              (unsigned long) filp->f_pos, flags);
1795     
1796     if (count % TAPE_BLKSIZE)   /* Only allow mod 512 bytes at a time. */
1797     {
1798         tpqputs(TPQD_BLKSZ, "Wrong block size");
1799         return -EINVAL;
1800     }
1801
1802     /* Just assume everything is ok. Controller will scream if not. */
1803
1804     if (status_bytes_wr)        /* Once written, no more reads, 'till after WFM. */
1805     {
1806         return -EACCES;
1807     }
1808     
1809     /* This is rather ugly because it has to implement a finite state
1810      * machine in order to handle the EOF situations properly.
1811      */
1812     while ((signed)count>=0)
1813     {
1814         bytes_done = 0;
1815         /* see how much fits in the kernel buffer */
1816         bytes_todo = TPQBUF_SIZE;
1817         if (bytes_todo>count)
1818         {
1819             bytes_todo = count;
1820         }
1821         
1822         /* Must ensure that user program sees exactly one EOF token (==0) */
1823         if (return_read_eof==YES)
1824         {
1825             if (TPQDBG(DEBUG))
1826             {
1827                 printk("read: return_read_eof==%d, reported_read_eof==%d, total_bytes_done==%lu\n", return_read_eof, reported_read_eof, total_bytes_done);
1828             }
1829             
1830             if (reported_read_eof==NO)
1831             {
1832                 /* have not yet returned EOF to user program */
1833                 if (total_bytes_done>0)
1834                 {
1835                     return total_bytes_done; /* next time return EOF */
1836                 }
1837                 else
1838                 {
1839                     reported_read_eof = YES; /* move on next time */
1840                     return 0;            /* return EOF */
1841                 }                               
1842             }
1843             else
1844             {
1845                 /* Application program has already received EOF
1846                  * (above), now continue with next file on tape,
1847                  * if possible.
1848                  * When the FM is reached, EXCEPTION is set,
1849                  * causing a sense(). Subsequent read/writes will
1850                  * continue after the FM.
1851                  */
1852                 /*********** ?????????? this should check for (EOD|NDT), not EOM, 'cause we can read past EW: ************/
1853                 if (status_eom_detected)
1854                 {
1855                     /* If EOM, nothing left to read, so keep returning EOFs.
1856                      *** should probably set some flag to avoid clearing
1857                      *** status_eom_detected through ioctls or something
1858                      */
1859                     return 0;
1860                 }
1861                 else
1862                 {
1863                     /* just eof, there may be more files ahead... */
1864                     return_read_eof = NO;
1865                     reported_read_eof = NO;
1866                     status_eof_detected = NO; /* reset this too */
1867                     /*fall through*/
1868                 }
1869             }
1870         }
1871         
1872         /*****************************/
1873         if (bytes_todo==0)
1874         {
1875             return total_bytes_done;
1876         }
1877         
1878         if (bytes_todo>0)
1879         {
1880             /* start reading data */
1881             if (is_exception()) /****************************************/
1882             {
1883                 tpqputs(TPQD_DMAX, "is_exception() before start_dma()!");
1884             }
1885             
1886 /******************************************************************
1887  ***** if start_dma() fails because the head is positioned 0 bytes
1888  ***** before the FM, (causing EXCEPTION to be set) return_read_eof should
1889  ***** be set to YES, and we should return total_bytes_done, rather than -ENXIO.
1890  ***** The app should recognize this as an EOF condition.
1891  ***************************************************************************/
1892             stat = start_dma(READ, bytes_todo);
1893             if (stat == TE_OK)
1894             {
1895                 /* Wait for transfer to complete, interrupt should wake us */
1896                 while (dma_mode != 0)
1897                 {
1898                     sleep_on(&qic02_tape_transfer);
1899                 }
1900                 if (status_error)
1901                 {
1902                     return_read_eof = YES;
1903                 }
1904                 
1905             }
1906             else if (stat != TE_END)
1907             {
1908                 /* should do sense() on error here */
1909 #if 0
1910                 return -ENXIO;
1911 #else
1912                 printk("Trouble: stat==%02x\n", stat);
1913                 return_read_eof = YES;
1914                 /*************** check EOF/EOT handling!!!!!! **/
1915 #endif
1916             }
1917             end_dma(&bytes_done);
1918             if (bytes_done>bytes_todo)
1919             {
1920                 tpqputs(TPQD_ALWAYS, "read: Oops, read more bytes than requested");
1921                 return -EIO;
1922             }
1923             /* copy buffer to user-space in one go */
1924             if (bytes_done>0)
1925             {
1926                 err = copy_to_user(buf, buffaddr, bytes_done);
1927                 if (err)
1928                 {
1929                     return -EFAULT;
1930                 }
1931             }
1932 #if 1
1933             /* Checks Ton's patch below */
1934             if ((return_read_eof == NO) && (status_eof_detected == YES))
1935             {
1936                 printk(TPQIC02_NAME ": read(): return_read_eof=%d, status_eof_detected=YES. return_read_eof:=YES\n", return_read_eof);
1937             }
1938 #endif
1939             if ((bytes_todo != bytes_done) || (status_eof_detected == YES))
1940             {
1941                 /* EOF or EOM detected. return EOF next time. */
1942                 return_read_eof = YES;
1943             }
1944             
1945         } /* else: ignore read request for 0 bytes */
1946
1947         if (bytes_done>0)
1948         {
1949             status_bytes_rd = YES;
1950             buf += bytes_done;
1951             *ppos += bytes_done;
1952             total_bytes_done += bytes_done;
1953             count -= bytes_done;
1954         }
1955     }
1956     tpqputs(TPQD_ALWAYS, "read request for <0 bytes");
1957     return -EINVAL;
1958 } /* qic02_tape_read */
1959
1960
1961
1962 /* The drive detects near-EOT by means of the holes in the tape.
1963  * When the holes are detected, there is some space left. The drive
1964  * reports this as a TP_EOM exception. After clearing the exception,
1965  * the drive should accept two extra blocks.
1966  *
1967  * It seems there are some archiver programs that would like to use the
1968  * extra space for writing a continuation marker. The driver should return
1969  * end-of-file to the user program on writes, when the holes are detected.
1970  * If the user-program wants to use the extra space, it should use the
1971  * MTNOP ioctl() to get the generic status register and may then continue
1972  * writing (max 1kB).   ----------- doesn't work yet...............
1973  *
1974  * EOF behaviour on writes:
1975  * If there is enough room, write all of the data.
1976  * If there is insufficient room, write as much as will fit and
1977  * return the amount written. If the requested amount differs from the
1978  * written amount, the application program should recognize that as the
1979  * end of file. Subsequent writes will return -ENOSPC.
1980  * Unless the minor bits specify a rewind-on-close, the tape will not
1981  * be rewound when it is full. The user-program should do that, if desired.
1982  * If the driver were to do that automatically, a user-program could be 
1983  * confused about the EOT/BOT condition after re-opening the tape device.
1984  *
1985  * Multiple volume support: Tar closes the tape device before prompting for
1986  * the next tape. The user may then insert a new tape and tar will open the
1987  * tape device again. The driver will detect an exception status in (No Cartridge)
1988  * and force a rewind. After that tar may continue writing.
1989  */
1990 static ssize_t qic02_tape_write( struct file * filp,  const char * buf, 
1991                 size_t count, loff_t *ppos)
1992 {
1993     int err;
1994     kdev_t dev = filp->f_dentry->d_inode->i_rdev;
1995     unsigned short flags = filp->f_flags;
1996     unsigned long bytes_todo, bytes_done, total_bytes_done = 0;
1997     
1998     if (status_zombie==YES)
1999     {
2000         tpqputs(TPQD_ALWAYS, "configs not set");                
2001         return -ENXIO;
2002     }
2003
2004     if (TP_DIAGS(current_tape_dev))
2005     {
2006         /* can't print a ``long long'' (for filp->f_pos), so chop it */
2007         printk(TPQIC02_NAME ": request WRITE, minor=%x, buf=%p"
2008                             ", count=%lx, pos=%lx, flags=%x\n",
2009                MINOR(dev), buf,
2010                (long) count, (unsigned long) filp->f_pos, flags);
2011     }
2012     
2013     if (count % TAPE_BLKSIZE)   /* only allow mod 512 bytes at a time */
2014     {
2015         tpqputs(TPQD_BLKSZ, "Wrong block size");
2016         return -EINVAL;
2017     }
2018
2019     if (mode_access==READ)
2020     {
2021         tpqputs(TPQD_ALWAYS, "Not in write mode");
2022         return -EACCES;
2023     }
2024
2025     /* open() does a sense() and we can assume the tape isn't changed
2026      * between open() and release(), so the tperror.exs bits will still
2027      * be valid.
2028      */
2029     if ((tperror.exs & TP_ST0) && (tperror.exs & TP_WRP))
2030     {
2031         tpqputs(TPQD_ALWAYS, "Cartridge is write-protected.");
2032         return -EACCES; /* don't even try when write protected */
2033     }
2034       
2035     if (doing_read == YES)
2036     {
2037         terminate_read(0);
2038     }
2039     
2040     while ((signed)count>=0)
2041     {
2042         /* see how much fits in the kernel buffer */
2043         bytes_done = 0;
2044         bytes_todo = TPQBUF_SIZE;
2045         if (bytes_todo>count)
2046         {
2047             bytes_todo = count;
2048         }
2049         
2050         if (return_write_eof == YES)
2051         {
2052             /* return_write_eof should be reset on reverse tape movements. */
2053             
2054             if (reported_write_eof==NO)
2055             {
2056                 if (bytes_todo>0)
2057                 {
2058                     tpqputs(TPQD_ALWAYS, "partial write");
2059                     /* partial write signals EOF to user program */
2060                 }
2061                 reported_write_eof = YES;
2062                 return total_bytes_done;
2063             }
2064             else
2065             {
2066                 return -ENOSPC;          /* return error */
2067             }   
2068         }
2069         
2070         /* Quit when done. */
2071         if (bytes_todo==0)
2072         {
2073             return total_bytes_done;
2074         }
2075         
2076         /* copy from user to DMA buffer and initiate transfer. */
2077         if (bytes_todo>0)
2078         {
2079             err = copy_from_user(buffaddr, buf, bytes_todo);
2080             if (err)
2081             {
2082                 return -EFAULT;
2083             }
2084
2085 /****************** similar problem with read() at FM could happen here at EOT.
2086  ******************/
2087
2088 /***** if at EOT, 0 bytes can be written. start_dma() will
2089  ***** fail and write() will return ENXIO error
2090  *****/
2091             if (start_dma(WRITE, bytes_todo) != TE_OK)
2092             {
2093                 tpqputs(TPQD_ALWAYS, "write: start_dma() failed");
2094                 /* should do sense() on error here */
2095                 return -ENXIO;  /*********** FIXTHIS **************/
2096             }
2097
2098             /* Wait for write to complete, interrupt should wake us. */
2099             while ((status_error == 0) && (dma_mode != 0))
2100             {
2101                 sleep_on(&qic02_tape_transfer);
2102             }
2103
2104             end_dma(&bytes_done);
2105             if (bytes_done>bytes_todo)
2106             {
2107                 tpqputs(TPQD_ALWAYS, "write: Oops, wrote more bytes than requested");
2108                 return -EIO;
2109             }
2110             /* If the dma-transfer was aborted because of an exception,
2111              * status_error will have been set in the interrupt handler.
2112              * Then end_dma() will do a sense().
2113              * If the exception was EXC_EOM, the EW-hole was encountered
2114              * and two more blocks could be written. For the time being we'll
2115              * just consider this to be the EOT.
2116              * Otherwise, something Bad happened, such as the maximum number
2117              * of block-rewrites was exceeded. [e.g. A very bad spot on tape was
2118              * encountered. Normally short dropouts are compensated for by
2119              * rewriting the block in error, up to 16 times. I'm not sure
2120              * QIC-24 drives can do this.]
2121              */
2122             if (status_error)
2123             {
2124                 if (status_eom_detected == YES)
2125                 {
2126                     tpqputs(TPQD_ALWAYS, "write: EW detected");
2127                     return_write_eof = YES;
2128                 }
2129                 else
2130                 {
2131                     /* probably EXC_RWA */
2132                     tpqputs(TPQD_ALWAYS, "write: dma: error in writing");
2133                     return -EIO;
2134                 }
2135             }
2136             if (bytes_todo != bytes_done)
2137             {
2138                 /* EOF or EOM detected. return EOT next time. */
2139                 return_write_eof = YES;
2140             }
2141         }
2142         /* else: ignore write request for 0 bytes. */
2143         
2144         if (bytes_done>0)
2145         {
2146             status_bytes_wr = YES;
2147             buf += bytes_done;
2148             *ppos += bytes_done;
2149             total_bytes_done += bytes_done;
2150             count -= bytes_done;
2151         }
2152     }
2153     
2154     tpqputs(TPQD_ALWAYS, "write request for <0 bytes");
2155     if (TPQDBG(DEBUG))
2156     {
2157         printk(TPQIC02_NAME ": status_bytes_wr %x, buf %p"
2158                             ", total_bytes_done %lx, count %lx\n",
2159                status_bytes_wr, buf, total_bytes_done, (long) count);
2160     }
2161     return -EINVAL;
2162 } /* qic02_tape_write */
2163
2164
2165
2166 /* qic02_tape_open()
2167  * We allow the device to be opened, even if it is marked 'dead' because
2168  * we want to be able to reset the tape device without rebooting.
2169  * Only one open tape file at a time, except when minor=255.
2170  * Minor 255 is only allowed for resetting and always returns <0.
2171  * 
2172  * The density command is only allowed when TP_BOM is set. Thus, remember
2173  * the most recently used minor bits. When they are different from the
2174  * remembered values, rewind the tape and set the required density.
2175  * Don't rewind if the minor bits specify density 0.
2176  */
2177
2178 static int qic02_tape_open(struct inode * inode, struct file * filp)
2179 {
2180     static int qic02_tape_open_no_use_count(struct inode *, struct file *);
2181     int open_error;
2182
2183     open_error = qic02_tape_open_no_use_count(inode, filp);
2184     return open_error;
2185 }
2186
2187 static int qic02_tape_open_no_use_count(struct inode * inode, struct file * filp)
2188 {
2189     kdev_t dev = inode->i_rdev;
2190     unsigned short flags = filp->f_flags;
2191     unsigned short dens = 0;
2192     int s;
2193
2194
2195     if (TP_DIAGS(dev))
2196     {
2197         printk("qic02_tape_open: dev=%s, flags=%x     ",
2198                kdevname(dev), flags);
2199     }
2200
2201     if (MINOR(dev)==255)        /* special case for resetting */
2202     {
2203         if (capable(CAP_SYS_ADMIN))
2204         {
2205             return (tape_reset(1)==TE_OK) ? -EAGAIN : -ENXIO;
2206         }
2207         else
2208         {
2209             return -EPERM;
2210         }
2211     }
2212     
2213     if (status_dead==YES)
2214     {
2215         /* Allow `mt reset' ioctl() even when already open()ed. */
2216         return 0;
2217     }
2218     
2219         /* Only one at a time from here on... */
2220     if (file_count(filp)>1)     /* filp->f_count==1 for the first open() */
2221     {
2222         return -EBUSY;
2223     }
2224
2225     if (status_zombie==YES)
2226     {
2227         /* no irq/dma/port stuff allocated yet, no reset done
2228          * yet, so return until MTSETCONFIG has been done.
2229          */
2230         return 0;
2231     }
2232     
2233     status_bytes_rd = NO;
2234     status_bytes_wr = NO;
2235     
2236     return_read_eof = NO;       /********????????????????*****/
2237     return_write_eof = (status_eot_detected)? YES : NO;
2238
2239     /* Clear this in case user app close()d before reading EOF token */
2240     status_eof_detected = NO;
2241
2242     reported_read_eof = NO;
2243     reported_write_eof = NO;
2244
2245
2246     switch (flags & O_ACCMODE)
2247     {
2248      case O_RDONLY:
2249         mode_access = READ;
2250         break;
2251      case O_WRONLY:     /* Fallthru... Strictly speaking this is not correct... */
2252      case O_RDWR:       /* Reads are allowed as long as nothing is written */
2253         mode_access = WRITE;
2254         break;
2255     }
2256     
2257     /* This is to avoid tape-changed problems (TP_CNI exception).
2258      *
2259      * Since removing the cartridge will not raise an exception,
2260      * we always do a tp_sense() to make sure we have the proper
2261      * CNI status, the 2150L may need an additional sense.... - Eddy
2262      */
2263     s = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
2264     
2265     if (s == TE_OK)
2266     {
2267         /* Try to clear cartridge-changed status for Archive-2150L */
2268         if ((tperror.exs & TP_ST0) && (tperror.exs & TP_CNI))
2269         {
2270             s = tp_sense(TP_WRP|TP_EOM|TP_BOM|TP_CNI|TP_EOR);
2271         }
2272     }
2273     
2274     if (s != TE_OK)
2275     {
2276         tpqputs(TPQD_ALWAYS, "open: sense() failed");
2277         return -EIO;
2278     }
2279
2280     /* exception bits should be up-to-date now, so check for
2281      * tape presence and exit if absent.
2282      * Even `mt stat' will fail without a tape.
2283      */
2284     if ((tperror.exs & TP_ST0) && (tperror.exs & TP_CNI))
2285     {
2286         tpqputs(TPQD_ALWAYS, "No tape present.");
2287         return -EIO;
2288     }
2289
2290     /* At this point we can assume that a tape is present and
2291      * that it will remain present until release() is called.
2292      */
2293
2294     /* not allowed to do QCMD_DENS_* unless tape is rewound */
2295     if ((TP_DENS(dev)!=0) && (TP_DENS(current_tape_dev) != TP_DENS(dev)))
2296     {
2297         /* force rewind if minor bits have changed,
2298          * i.e. user wants to use tape in different format.
2299          * [assuming single drive operation]
2300          */
2301         if (TP_HAVE_DENS)
2302         {
2303             tpqputs(TPQD_REWIND, "Density minor bits have changed. Forcing rewind.");
2304             need_rewind = YES;
2305         }
2306     }
2307     else
2308     {
2309         /* density bits still the same, but TP_DIAGS bit 
2310          * may have changed.
2311          */
2312         current_tape_dev = dev;
2313     }
2314     
2315     if (need_rewind == YES)  /***************** CHECK THIS!!!!!!!! **********/
2316     {
2317         s = do_qic_cmd(QCMD_REWIND, TIM_R);
2318         if (s != 0)
2319         {
2320             tpqputs(TPQD_ALWAYS, "open: rewind failed");
2321             return -EIO;
2322         }
2323     }
2324
2325
2326 /* Note: After a reset command, the controller will rewind the tape
2327  *       just before performing any tape movement operation! ************ SO SET need_rewind flag!!!!!
2328  */ 
2329     if (status_dead==YES)
2330     {
2331         tpqputs(TPQD_ALWAYS, "open: tape dead, attempting reset");
2332         if (tape_reset(1)!=TE_OK)
2333         {
2334             return -ENXIO;
2335         }
2336         else
2337         {
2338             status_dead = NO;
2339             if (tp_sense(~(TP_ST1|TP_ILL)) != TE_OK)
2340             {
2341                 tpqputs(TPQD_ALWAYS, "open: tp_sense() failed\n");
2342                 status_dead = YES;      /* try reset next time */
2343                 return -EIO;
2344             }
2345         }
2346     }
2347     
2348     /* things should be ok, once we get here */
2349     
2350
2351     /* set density: only allowed when TP_BOM status bit is set,
2352      * so we must have done a rewind by now. If not, just skip over.
2353      * Only give set density command when minor bits have changed.
2354      */
2355     if (TP_DENS(current_tape_dev) == TP_DENS(dev) )
2356     {
2357         return 0;
2358     }
2359     
2360     current_tape_dev = dev;
2361     need_rewind = NO;
2362     if (TP_HAVE_DENS)
2363     {
2364         dens = TP_DENS(dev);
2365     }
2366     
2367     if (dens < sizeof(format_names)/sizeof(char *))
2368     {
2369         printk(TPQIC02_NAME ": format: %s%s\n", (dens!=0)? "QIC-" : "", format_names[dens]);
2370     }
2371     else
2372     {
2373         tpqputs(TPQD_REWIND, "Wait for retensioning...");
2374     }
2375     
2376     switch (TP_DENS(dev))
2377     {
2378      case 0: /* Minor 0 is for drives without set-density support */
2379         s = 0;
2380         break;
2381      case 1:
2382         s = do_qic_cmd(QCMD_DENS_11, TIM_S);
2383         break;
2384      case 2:
2385         s = do_qic_cmd(QCMD_DENS_24, TIM_S);
2386         break;
2387      case 3:
2388         s = do_qic_cmd(QCMD_DENS_120, TIM_S);
2389         break;
2390      case 4:
2391         s = do_qic_cmd(QCMD_DENS_150, TIM_S);
2392         break;
2393      case 5:
2394         s = do_qic_cmd(QCMD_DENS_300, TIM_S);
2395         break;
2396      case 6:
2397         s = do_qic_cmd(QCMD_DENS_600, TIM_S);
2398         break;
2399      default:  /* otherwise do a retension before anything else */
2400         s = do_qic_cmd(QCMD_RETEN, TIM_R);
2401     }
2402     if (s != 0)
2403     {
2404         status_dead = YES;      /* force reset */
2405         current_tape_dev = 0; /* earlier 0xff80 */
2406         return -EIO;
2407     }
2408     
2409     return 0;
2410 } /* qic02_tape_open */
2411
2412
2413 static int qic02_tape_release(struct inode * inode, struct file * filp)
2414 {
2415     kdev_t dev = inode->i_rdev;
2416
2417     lock_kernel();
2418     if (TP_DIAGS(dev))
2419     {
2420         printk("qic02_tape_release: dev=%s\n",  kdevname(dev));
2421     }
2422     
2423     if (status_zombie==NO)              /* don't rewind in zombie mode */
2424     {
2425         /* Terminate any pending write cycle. Terminating the read-cycle
2426          * is delayed until it is required to do so for a new command.
2427          */
2428         terminate_write(-1);
2429         
2430         if (status_dead==YES)
2431         {
2432             tpqputs(TPQD_ALWAYS, "release: device dead!?");
2433         }
2434         
2435         /* Rewind only if minor number requires it AND 
2436          * read/writes have been done. ************* IS THIS CORRECT??????????
2437          */
2438         if ((TP_REWCLOSE(dev)) && (status_bytes_rd | status_bytes_wr))
2439         {
2440             tpqputs(TPQD_REWIND, "release: Doing rewind...");
2441             (void) do_qic_cmd(QCMD_REWIND, TIM_R);
2442         }
2443     }
2444     unlock_kernel();
2445     return 0;
2446 } /* qic02_tape_release */
2447
2448
2449 #ifdef CONFIG_QIC02_DYNCONF
2450 /* Set masks etc. based on the interface card type. */
2451 static int update_ifc_masks(int ifc)
2452 {
2453     QIC02_TAPE_IFC = ifc;
2454
2455     if ((QIC02_TAPE_IFC == WANGTEK) || (QIC02_TAPE_IFC == EVEREX))
2456     {
2457         QIC02_STAT_PORT = QIC02_TAPE_PORT;
2458         QIC02_CTL_PORT = QIC02_TAPE_PORT;
2459         QIC02_CMD_PORT = QIC02_TAPE_PORT+1;
2460         QIC02_DATA_PORT = QIC02_TAPE_PORT+1;
2461         QIC02_STAT_READY = WT_QIC02_STAT_READY;
2462         QIC02_STAT_EXCEPTION = WT_QIC02_STAT_EXCEPTION;
2463         QIC02_STAT_MASK = WT_QIC02_STAT_MASK;
2464         
2465         QIC02_STAT_RESETMASK = WT_QIC02_STAT_RESETMASK;
2466         QIC02_STAT_RESETVAL = WT_QIC02_STAT_RESETVAL;
2467         
2468         QIC02_CTL_RESET = WT_QIC02_CTL_RESET;
2469         QIC02_CTL_REQUEST = WT_QIC02_CTL_REQUEST;
2470  
2471         if (QIC02_TAPE_DMA == 3)
2472         {
2473             WT_CTL_DMA = WT_CTL_DMA3;
2474         }
2475         else if (QIC02_TAPE_DMA == 1)
2476         {
2477             WT_CTL_DMA = WT_CTL_DMA1;
2478         }
2479         else
2480         {
2481             tpqputs(TPQD_ALWAYS, "Unsupported or incorrect DMA channel");
2482             return -EIO;
2483         } 
2484
2485         if (QIC02_TAPE_IFC == EVEREX)
2486         {
2487             /* Everex is a special case for Wangtek (actually
2488              * it's the other way 'round, but I saw Wangtek first)
2489              */
2490             if (QIC02_TAPE_DMA==3)
2491             {
2492                 WT_CTL_DMA = WT_CTL_DMA1;
2493             }
2494             
2495             /* Fixup the kernel copy of the IFC type to that
2496              * we don't have to distinguish between Wangtek and
2497              * and Everex at runtime.
2498              */
2499             QIC02_TAPE_IFC = WANGTEK;
2500         }
2501     }
2502     else if (QIC02_TAPE_IFC == ARCHIVE)
2503     {
2504         QIC02_STAT_PORT = QIC02_TAPE_PORT+1;
2505         QIC02_CTL_PORT = QIC02_TAPE_PORT+1;
2506         QIC02_CMD_PORT = QIC02_TAPE_PORT;
2507         QIC02_DATA_PORT = QIC02_TAPE_PORT;
2508         QIC02_STAT_READY = AR_QIC02_STAT_READY;
2509         QIC02_STAT_EXCEPTION  = AR_QIC02_STAT_EXCEPTION;
2510         QIC02_STAT_MASK = AR_QIC02_STAT_MASK;
2511         
2512         QIC02_STAT_RESETMASK = AR_QIC02_STAT_RESETMASK;
2513         QIC02_STAT_RESETVAL = AR_QIC02_STAT_RESETVAL;
2514         
2515         QIC02_CTL_RESET = AR_QIC02_CTL_RESET;
2516         QIC02_CTL_REQUEST = AR_QIC02_CTL_REQUEST;
2517         
2518         if (QIC02_TAPE_DMA > 3)
2519         {
2520             tpqputs(TPQD_ALWAYS, "Unsupported or incorrect DMA channel");
2521             return -EIO;
2522         } 
2523     }
2524     else if (QIC02_TAPE_IFC == MOUNTAIN)
2525     {
2526         QIC02_STAT_PORT = QIC02_TAPE_PORT+1;
2527         QIC02_CTL_PORT = QIC02_TAPE_PORT+1;
2528         QIC02_CMD_PORT = QIC02_TAPE_PORT;
2529         QIC02_DATA_PORT = QIC02_TAPE_PORT;
2530         
2531         QIC02_STAT_READY = MTN_QIC02_STAT_READY;
2532         QIC02_STAT_EXCEPTION  = MTN_QIC02_STAT_EXCEPTION;
2533         QIC02_STAT_MASK = MTN_QIC02_STAT_MASK;
2534         
2535         QIC02_STAT_RESETMASK = MTN_QIC02_STAT_RESETMASK;
2536         QIC02_STAT_RESETVAL = MTN_QIC02_STAT_RESETVAL;
2537         
2538         QIC02_CTL_RESET = MTN_QIC02_CTL_RESET;
2539         QIC02_CTL_REQUEST = MTN_QIC02_CTL_REQUEST;
2540         
2541         if (QIC02_TAPE_DMA > 3)
2542         {
2543             tpqputs(TPQD_ALWAYS, "Unsupported or incorrect DMA channel");
2544             return -EIO;
2545         } 
2546     }
2547     else
2548     {
2549         tpqputs(TPQD_ALWAYS, "Invalid interface type");
2550         return -ENXIO;
2551     }
2552     return qic02_get_resources();
2553 } /* update_ifc_masks */
2554 #endif
2555
2556
2557 /* ioctl allows user programs to rewind the tape and stuff like that */
2558 static int qic02_tape_ioctl(struct inode * inode, struct file * filp, 
2559                      unsigned int iocmd, unsigned long ioarg)
2560 {
2561     int error;
2562     int dev_maj = MAJOR(inode->i_rdev);
2563     int c;
2564     struct mtop operation;
2565     unsigned char blk_addr[6];
2566     struct mtpos ioctl_tell;
2567     
2568
2569     if (TP_DIAGS(current_tape_dev))
2570     {
2571         printk(TPQIC02_NAME ": ioctl(%4x, %4x, %4lx)\n", dev_maj, iocmd, ioarg);
2572     }
2573     
2574     if (!inode || !ioarg)
2575     {
2576         return -EINVAL;
2577     }
2578     
2579     /* check iocmd first */
2580
2581     if (dev_maj != QIC02_TAPE_MAJOR)
2582     {
2583         printk(TPQIC02_NAME ": Oops! Wrong device?\n");
2584         /* A panic() would be appropriate here */
2585         return -ENODEV;
2586     }
2587
2588     c = _IOC_NR(iocmd);
2589
2590 #ifdef CONFIG_QIC02_DYNCONF
2591     if (c == _IOC_NR(MTIOCGETCONFIG))
2592     {
2593         CHECK_IOC_SIZE(mtconfiginfo);
2594
2595         if (copy_to_user((char *) ioarg, (char *) &qic02_tape_dynconf, sizeof(qic02_tape_dynconf)))
2596         {
2597             return -EFAULT;
2598         }
2599         return 0;
2600
2601     }
2602     else if (c == _IOC_NR(MTIOCSETCONFIG))
2603     {
2604         /* One should always do a MTIOCGETCONFIG first, then update
2605          * user-settings, then write back with MTIOCSETCONFIG.
2606          * The qic02conf program should re-open() the device before actual
2607          * use, to make sure everything is initialized.
2608          */
2609         
2610         CHECK_IOC_SIZE(mtconfiginfo);
2611         
2612         if (!capable(CAP_SYS_ADMIN))
2613         {
2614             return -EPERM;
2615         }
2616         
2617         if ((doing_read!=NO) || (doing_write!=NO))
2618         {
2619             return -EBUSY;
2620         }
2621         
2622         if (status_zombie==NO)
2623         {
2624             qic02_release_resources();  /* and go zombie */
2625         }
2626         
2627         /* copy struct from user space to kernel space */
2628         if (copy_from_user((char *) &qic02_tape_dynconf, (char *) ioarg, sizeof(qic02_tape_dynconf)))
2629         {
2630             return -EFAULT;
2631         }
2632         return update_ifc_masks(qic02_tape_dynconf.ifc_type);
2633     }
2634     if (status_zombie==YES)
2635     {
2636         tpqputs(TPQD_ALWAYS, "Configs not set");
2637         return -ENXIO;
2638     }
2639 #endif
2640     if (c == _IOC_NR(MTIOCTOP))
2641     {
2642         CHECK_IOC_SIZE(mtop);
2643
2644         /* copy mtop struct from user space to kernel space */
2645         if (copy_from_user((char *) &operation, (char *) ioarg, sizeof(operation)))
2646         {
2647             return -EFAULT;
2648         }
2649
2650         /* ---note: mt_count is signed, negative seeks must be
2651          * ---      translated to seeks in opposite direction!
2652          * (only needed for Sun-programs, I think.)
2653          */
2654         /* ---note: MTFSF with count 0 should position the
2655          * ---      tape at the beginning of the current file.
2656          */
2657
2658         if (TP_DIAGS(current_tape_dev))
2659         {
2660             printk("OP op=%4x, count=%4x\n", operation.mt_op, operation.mt_count);
2661         }
2662         
2663         if (operation.mt_count < 0)
2664         {
2665             tpqputs(TPQD_ALWAYS, "Warning: negative mt_count ignored");
2666         }
2667         
2668         ioctl_status.mt_resid = operation.mt_count;
2669         if (operation.mt_op == MTSEEK)
2670         {
2671             if (!TP_HAVE_SEEK)
2672             {
2673                 return -ENOTTY;
2674             }
2675             
2676             seek_addr_buf[0] = (operation.mt_count>>16)&0xff;
2677             seek_addr_buf[1] = (operation.mt_count>>8)&0xff;
2678             seek_addr_buf[2] = (operation.mt_count)&0xff;
2679             if (operation.mt_count>>24)
2680             {
2681                 return -EINVAL;
2682             }
2683             if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
2684             {
2685                 return error;
2686             }
2687             
2688             ioctl_status.mt_resid = 0;
2689         }
2690         else
2691         {
2692             while (operation.mt_count > 0)
2693             {
2694                 operation.mt_count--;
2695                 if ((error = do_ioctl_cmd(operation.mt_op)) != 0)
2696                 {
2697                     return error;
2698                 }
2699                 
2700                 ioctl_status.mt_resid = operation.mt_count;
2701             }
2702         }
2703         return 0;
2704         
2705     }
2706     else if (c == _IOC_NR(MTIOCGET))
2707     {
2708         if (TP_DIAGS(current_tape_dev))
2709         {
2710             printk("GET ");
2711         }
2712         
2713         CHECK_IOC_SIZE(mtget);
2714
2715         /* It appears (gmt(1)) that it is normal behaviour to
2716          * first set the status with MTNOP, and then to read
2717          * it out with MTIOCGET
2718          */
2719
2720         /* copy results to user space */
2721         if (copy_to_user((char *) ioarg, (char *) &ioctl_status, sizeof(ioctl_status)))
2722         {
2723             return -EFAULT;
2724         }       
2725         return 0;
2726     }
2727     else if (TP_HAVE_TELL && (c == _IOC_NR(MTIOCPOS)))
2728     {
2729         if (TP_DIAGS(current_tape_dev))
2730         {
2731             printk("POS ");
2732         }
2733         
2734         CHECK_IOC_SIZE(mtpos);
2735         
2736         tpqputs(TPQD_IOCTLS, "MTTELL reading block address");
2737         if ((doing_read==YES) || (doing_write==YES))
2738         {
2739             finish_rw(AR_QCMDV_TELL_BLK);
2740         }
2741         
2742         c = rdstatus((char *) blk_addr, sizeof(blk_addr), AR_QCMDV_TELL_BLK);
2743         if (c!=TE_OK)
2744         {
2745             return -EIO;
2746         }
2747         
2748         ioctl_tell.mt_blkno = (blk_addr[3] << 16) | (blk_addr[4] << 8) | blk_addr[5];
2749
2750         /* copy results to user space */
2751         if (copy_to_user((char *) ioarg, (char *) &ioctl_tell, sizeof(ioctl_tell)))
2752         {
2753             return -EFAULT;
2754         }
2755         return 0;
2756
2757     }
2758     else
2759     {
2760         return -ENOTTY; /* Other cmds not supported. */
2761     }
2762 } /* qic02_tape_ioctl */
2763
2764
2765
2766 /* These are (most) of the interface functions: */
2767 static struct file_operations qic02_tape_fops = {
2768         owner:          THIS_MODULE,
2769         llseek:         qic02_tape_lseek,       /* not allowed */
2770         read:           qic02_tape_read,
2771         write:          qic02_tape_write,
2772         ioctl:          qic02_tape_ioctl,
2773         open:           qic02_tape_open,
2774         release:        qic02_tape_release,
2775 };
2776
2777
2778 static void qic02_release_resources(void)
2779 {
2780     free_irq(QIC02_TAPE_IRQ, NULL);
2781     free_dma(QIC02_TAPE_DMA);
2782     release_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
2783     if (buffaddr)
2784     {
2785         free_pages((unsigned long)buffaddr, get_order(TPQBUF_SIZE));
2786     }
2787     buffaddr = 0; /* Better to cause a panic than overwite someone else */
2788     status_zombie = YES;
2789 } /* qic02_release_resources */
2790
2791
2792 static int qic02_get_resources(void)
2793 {
2794     /* First perform some checks. If one of them fails,
2795      * the tape driver will not be registered to the system.
2796      */
2797     if (QIC02_TAPE_IRQ>16)
2798     {
2799         tpqputs(TPQD_ALWAYS, "Bogus interrupt number.");
2800         return -ENXIO;
2801     }
2802
2803     /* for DYNCONF, allocating IO, DMA and IRQ should not be done until 
2804      * the config parameters have been set using MTSETCONFIG.
2805      */
2806
2807     if (check_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE))
2808     {
2809         printk(TPQIC02_NAME ": IO space at 0x%x [%d ports] already reserved\n",
2810                QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE);
2811         return -ENXIO;
2812     }
2813
2814     /* get IRQ */
2815     if (request_irq(QIC02_TAPE_IRQ, qic02_tape_interrupt, SA_INTERRUPT, "QIC-02", NULL))
2816     {
2817         printk(TPQIC02_NAME ": can't allocate IRQ%d for QIC-02 tape\n",
2818                QIC02_TAPE_IRQ);
2819         return -EBUSY;
2820     }
2821
2822     /* After IRQ, allocate DMA channel */
2823     if (request_dma(QIC02_TAPE_DMA,"QIC-02"))
2824     {
2825         printk(TPQIC02_NAME ": can't allocate DMA%d for QIC-02 tape\n",
2826                QIC02_TAPE_DMA);
2827         free_irq(QIC02_TAPE_IRQ, NULL);
2828         return -EBUSY;
2829     }
2830
2831     /* Grab the IO region. We already made sure it's available. */
2832     request_region(QIC02_TAPE_PORT, QIC02_TAPE_PORT_RANGE, TPQIC02_NAME);
2833     
2834     /* Setup the page-address for the dma transfer. */
2835     buffaddr = (void *)__get_dma_pages(GFP_KERNEL, get_order(TPQBUF_SIZE));
2836     
2837     if (!buffaddr)
2838     {
2839         qic02_release_resources();
2840         return -EBUSY; /* Not ideal, EAGAIN perhaps? */
2841     }
2842     
2843     memset(buffaddr, 0, TPQBUF_SIZE);
2844     
2845     printk(TPQIC02_NAME ": Settings: IRQ %d, DMA %d, IO 0x%x, IFC %s\n",
2846            QIC02_TAPE_IRQ, QIC02_TAPE_DMA,
2847            ((QIC02_TAPE_IFC==ARCHIVE) || (QIC02_TAPE_IFC==MOUNTAIN))?
2848            QIC02_CMD_PORT : QIC02_STAT_PORT,
2849            (QIC02_TAPE_IFC==MOUNTAIN)? "Mountain" :
2850            ((QIC02_TAPE_IFC==ARCHIVE)? "Archive" : "Wangtek"));
2851     
2852     if (tape_reset(0)!=TE_OK || tp_sense(TP_WRP|TP_POR|TP_CNI)!=TE_OK)
2853     {
2854         /* No drive detected, so vanish */
2855         tpqputs(TPQD_ALWAYS, "No drive detected -- releasing IO/IRQ/DMA.");
2856         status_dead = YES;
2857         qic02_release_resources();
2858         return -EIO;
2859     }
2860
2861     /* All should be ok now */
2862     status_zombie = NO;
2863     return 0;
2864 } /* qic02_get_resources */
2865
2866 int __init qic02_tape_init(void)
2867 {
2868     if (TPSTATSIZE != 6)
2869     {
2870         printk(TPQIC02_NAME ": internal error: tpstatus struct incorrect!\n");
2871         return -ENODEV;
2872     }
2873     if ((TPQBUF_SIZE<512) || (TPQBUF_SIZE>=0x10000))
2874     {
2875         printk(TPQIC02_NAME ": internal error: DMA buffer size out of range\n");
2876         return -ENODEV;
2877     }
2878
2879     current_tape_dev = MKDEV(QIC02_TAPE_MAJOR, 0);
2880
2881 #ifndef CONFIG_QIC02_DYNCONF
2882     printk(TPQIC02_NAME ": IRQ %d, DMA %d, IO 0x%x, IFC %s, %s, %s\n",
2883            QIC02_TAPE_IRQ, QIC02_TAPE_DMA,
2884 # if QIC02_TAPE_IFC == WANGTEK
2885            QIC02_STAT_PORT, "Wangtek",
2886 # elif QIC02_TAPE_IFC == ARCHIVE
2887            QIC02_CMD_PORT, "Archive",
2888 # elif QIC02_TAPE_IFC == MOUNTAIN
2889            QIC02_CMD_PORT, "Mountain",
2890 # else
2891 #  error
2892 # endif
2893            rcs_revision, rcs_date);
2894     if (qic02_get_resources())
2895     {
2896         return -ENODEV;
2897     }
2898 #else
2899     printk(TPQIC02_NAME ": Runtime config, %s, %s\n", 
2900            rcs_revision, rcs_date);
2901 #endif
2902     printk(TPQIC02_NAME ": DMA buffers: %u blocks\n", NR_BLK_BUF);
2903     /* If we got this far, install driver functions */
2904     if (devfs_register_chrdev(QIC02_TAPE_MAJOR, TPQIC02_NAME, &qic02_tape_fops))
2905     {
2906         printk(TPQIC02_NAME ": Unable to get chrdev major %d\n", QIC02_TAPE_MAJOR);
2907 #ifndef CONFIG_QIC02_DYNCONF
2908         qic02_release_resources();
2909 #endif
2910         return -ENODEV;
2911     }
2912     devfs_register (NULL, "ntpqic11", DEVFS_FL_DEFAULT,
2913                     QIC02_TAPE_MAJOR, 2,
2914                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2915                     &qic02_tape_fops, NULL);
2916     devfs_register (NULL, "tpqic11", DEVFS_FL_DEFAULT,
2917                     QIC02_TAPE_MAJOR, 3,
2918                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2919                     &qic02_tape_fops, NULL);
2920     devfs_register (NULL, "ntpqic24", DEVFS_FL_DEFAULT,
2921                     QIC02_TAPE_MAJOR, 4,
2922                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2923                     &qic02_tape_fops, NULL);
2924     devfs_register (NULL, "tpqic24", DEVFS_FL_DEFAULT,
2925                     QIC02_TAPE_MAJOR, 5,
2926                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2927                     &qic02_tape_fops, NULL);
2928     devfs_register (NULL, "ntpqic120", DEVFS_FL_DEFAULT,
2929                     QIC02_TAPE_MAJOR, 6,
2930                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2931                     &qic02_tape_fops, NULL);
2932     devfs_register (NULL, "tpqic120", DEVFS_FL_DEFAULT,
2933                     QIC02_TAPE_MAJOR, 7,
2934                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2935                     &qic02_tape_fops, NULL);
2936     devfs_register (NULL, "ntpqic150", DEVFS_FL_DEFAULT,
2937                     QIC02_TAPE_MAJOR, 8,
2938                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2939                     &qic02_tape_fops, NULL);
2940     devfs_register (NULL, "tpqic150", DEVFS_FL_DEFAULT,
2941                     QIC02_TAPE_MAJOR, 9,
2942                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
2943                     &qic02_tape_fops, NULL);
2944     init_waitqueue_head(&qic02_tape_transfer);
2945     /* prepare timer */
2946     TIMEROFF;
2947     init_timer(&tp_timer);
2948     tp_timer.function = qic02_tape_times_out;
2949     
2950 #ifndef CONFIG_QIC02_DYNCONF
2951     if (tape_reset(0)!=TE_OK || tp_sense(TP_WRP|TP_POR|TP_CNI)!=TE_OK)
2952     {
2953         /* No drive detected, so vanish */
2954         tpqputs(TPQD_ALWAYS, "No drive detected -- driver going on vacation...");
2955         qic02_release_resources();
2956         status_dead = YES;
2957         return -ENODEV;
2958     }
2959     else
2960     {
2961         if (is_exception())
2962         {
2963             tpqputs(TPQD_ALWAYS, "exception detected\n");
2964             (void) tp_sense(TP_WRP|TP_POR|TP_CNI);
2965         }
2966     }
2967 #endif
2968
2969     /* initialize generic status for ioctl requests */
2970     
2971     ioctl_status.mt_type        = QIC02_TAPE_DRIVE;     /* MT_IS* id nr */
2972     
2973     ioctl_status.mt_resid       = 0;    /* ---residual count */
2974     ioctl_status.mt_gstat       = 0;    /* ---generic status */
2975     ioctl_status.mt_erreg       = 0;    /* not used */
2976     ioctl_status.mt_fileno      = 0;    /* number of current file on tape */
2977     ioctl_status.mt_blkno       = 0;    /* number of current (logical) block */
2978
2979     return 0;
2980 } /* qic02_tape_init */
2981
2982 #ifdef MODULE
2983
2984 void cleanup_module(void)
2985 {
2986     if (status_zombie == NO)
2987     {
2988         qic02_release_resources();
2989     }
2990     devfs_unregister_chrdev(QIC02_TAPE_MAJOR, TPQIC02_NAME);
2991     devfs_unregister(devfs_find_handle(NULL, "ntpqic11", QIC02_TAPE_MAJOR, 2, DEVFS_SPECIAL_CHR, 0));
2992     devfs_unregister(devfs_find_handle(NULL, "tpqic11", QIC02_TAPE_MAJOR, 3, DEVFS_SPECIAL_CHR, 0));
2993     devfs_unregister(devfs_find_handle(NULL, "ntpqic24", QIC02_TAPE_MAJOR, 4, DEVFS_SPECIAL_CHR, 0));
2994     devfs_unregister(devfs_find_handle(NULL, "tpqic24", QIC02_TAPE_MAJOR, 5, DEVFS_SPECIAL_CHR, 0));
2995     devfs_unregister(devfs_find_handle(NULL, "ntpqic120", QIC02_TAPE_MAJOR, 6, DEVFS_SPECIAL_CHR, 0));
2996     devfs_unregister(devfs_find_handle(NULL, "tpqic120", QIC02_TAPE_MAJOR, 7, DEVFS_SPECIAL_CHR, 0));
2997     devfs_unregister(devfs_find_handle(NULL, "ntpqic150", QIC02_TAPE_MAJOR, 8, DEVFS_SPECIAL_CHR, 0));
2998     devfs_unregister(devfs_find_handle(NULL, "tpqic150", QIC02_TAPE_MAJOR, 9, DEVFS_SPECIAL_CHR, 0));
2999 }
3000
3001 int init_module(void)
3002 {
3003     int retval;
3004     retval=qic02_tape_init();
3005 # ifdef CONFIG_QIC02_DYNCONF
3006     /* This allows the dynamic config program to setup the card
3007      * by presetting qic02_tape_dynconf via insmod
3008      */
3009     if (!retval && qic02_tape_dynconf.ifc_type)
3010     {
3011         retval=update_ifc_masks(qic02_tape_dynconf.ifc_type);
3012         if (retval)
3013         {
3014           cleanup_module();
3015         }
3016     }
3017 # endif
3018     return retval;
3019 }
3020 #endif