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