1 /*
2 * Copyright (c) 1982, 1986 Regents of the University of California.
3 * All rights reserved. The Berkeley software License Agreement
4 * specifies the terms and conditions for redistribution.
5 *
6 * @(#)ut.c 7.12 (Berkeley) 12/16/90
7 */
8
9 #include "tj.h"
10 #if NUT > 0
11 /*
12 * System Industries Model 9700 Tape Drive
13 * emulates a TU45 on the UNIBUS
14 *
15 * TODO:
16 * check out attention processing
17 * try reset code and dump code
18 */
19 #include "sys/param.h"
20 #include "sys/systm.h"
21 #include "sys/buf.h"
22 #include "sys/conf.h"
23 #include "sys/errno.h"
24 #include "sys/file.h"
25 #include "sys/map.h"
26 #include "sys/ioctl.h"
27 #include "sys/mtio.h"
28 #include "sys/cmap.h"
29 #include "sys/time.h"
30 #include "sys/uio.h"
31 #include "sys/kernel.h"
32 #include "sys/syslog.h"
33 #include "sys/tprintf.h"
34
35 #include "../include/pte.h"
36 #include "../include/cpu.h"
37 #include "ubareg.h"
38 #include "ubavar.h"
39 #include "utreg.h"
40
41 struct buf cutbuf[NUT]; /* bufs for control operations */
42 struct buf tjutab[NTJ]; /* bufs for slave queue headers */
43
44 struct uba_ctlr *utminfo[NUT];
45 struct uba_device *tjdinfo[NTJ];
46 int utprobe(), utslave(), utattach(), utdgo(), utintr(), uttimer();
47 u_short utstd[] = { 0772440, 0 };
48 struct uba_driver utdriver =
49 { utprobe, utslave, utattach, utdgo, utstd, "tj", tjdinfo, "ut", utminfo, 0 };
50
51 #define MASKREG(reg) ((reg)&0xffff)
52
53 /* bits in minor device */
54 #define TJUNIT(dev) (minor(dev)&03)
55 #define T_NOREWIND 04
56 #define T_1600BPI 010
57 #define T_6250BPI 020
58 short utdens[] = { UT_NRZI, UT_PE, UT_GCR, UT_NRZI };
59
60 /* slave to controller mapping table */
61 short tjtout[NTJ];
62 #define UTUNIT(dev) (tjtout[TJUNIT(dev)])
63
64 #define INF (daddr_t)1000000L /* a block number that wont exist */
65
66 struct tj_softc {
67 char sc_openf; /* exclusive open */
68 char sc_lastiow; /* last I/O operation was a write */
69 daddr_t sc_blkno; /* next block to transfer */
70 daddr_t sc_nxrec; /* next record on tape */
71 u_short sc_erreg; /* image of uter */
72 u_short sc_dsreg; /* image of utds */
73 u_short sc_resid; /* residual from transfer */
74 u_short sc_dens; /* sticky selected density */
75 daddr_t sc_timo; /* time until timeout expires */
76 short sc_tact; /* timeout is active flag */
77 tpr_t sc_tpr; /* tprintf handle */
78 int sc_blks; /* number of I/O operations since open */
79 int sc_softerrs; /* number of soft I/O errors since open */
80 } tj_softc[NTJ];
81
82 /*
83 * Internal per/slave states found in sc_state
84 */
85 #define SSEEK 1 /* seeking */
86 #define SIO 2 /* doing sequential I/O */
87 #define SCOM 3 /* sending a control command */
88 #define SREW 4 /* doing a rewind op */
89 #define SERASE 5 /* erase inter-record gap */
90 #define SERASED 6 /* erased inter-record gap */
91
92 /*ARGSUSED*/
utprobe(reg)93 utprobe(reg)
94 caddr_t reg;
95 {
96 register int br, cvec;
97 #ifdef lint
98 br=0; cvec=br; br=cvec;
99 utintr(0);
100 #endif
101 /*
102 * The SI documentation says you must set the RDY bit
103 * (even though it's read-only) to force an interrupt.
104 */
105 ((struct utdevice *) reg)->utcs1 = UT_IE|UT_NOP|UT_RDY;
106 DELAY(10000);
107 return (sizeof (struct utdevice));
108 }
109
110 /*ARGSUSED*/
111 utslave(ui, reg)
112 struct uba_device *ui;
113 caddr_t reg;
114 {
115 /*
116 * A real TU45 would support the slave present bit
117 * int the drive type register, but this thing doesn't,
118 * so there's no way to determine if a slave is present or not.
119 */
120 return(1);
121 }
122
123 utattach(ui)
124 struct uba_device *ui;
125 {
126 tjtout[ui->ui_unit] = ui->ui_mi->um_ctlr;
127 }
128
129 /*
130 * Open the device with exclusive access.
131 */
utopen(dev,flag)132 utopen(dev, flag)
133 dev_t dev;
134 int flag;
135 {
136 register int tjunit = TJUNIT(dev);
137 register struct uba_device *ui;
138 register struct tj_softc *sc;
139 int olddens, dens, error;
140 register int s;
141
142 if (tjunit >= NTJ || (ui = tjdinfo[tjunit]) == 0 || ui->ui_alive == 0)
143 return (ENXIO);
144 if ((sc = &tj_softc[tjunit])->sc_openf)
145 return (EBUSY);
146 sc->sc_openf = 1;
147 olddens = sc->sc_dens;
148 dens = sc->sc_dens =
149 utdens[(minor(dev)&(T_1600BPI|T_6250BPI))>>3]|
150 PDP11FMT|(ui->ui_slave&07);
151 get:
152 utcommand(dev, UT_SENSE, 1);
153 if (sc->sc_dsreg&UTDS_PIP) {
154 if (error = tsleep((caddr_t)&lbolt, (PZERO+1) | PCATCH,
155 devopn, 0))
156 return (error);
157 goto get;
158 }
159 sc->sc_dens = olddens;
160 if ((sc->sc_dsreg&UTDS_MOL) == 0) {
161 sc->sc_openf = 0;
162 uprintf("tj%d: not online\n", tjunit);
163 return (EIO);
164 }
165 if ((flag&FWRITE) && (sc->sc_dsreg&UTDS_WRL)) {
166 sc->sc_openf = 0;
167 uprintf("tj%d: no write ring\n", tjunit);
168 return (EIO);
169 }
170 if ((sc->sc_dsreg&UTDS_BOT) == 0 && (flag&FWRITE) &&
171 dens != sc->sc_dens) {
172 sc->sc_openf = 0;
173 uprintf("tj%d: can't change density in mid-tape\n", tjunit);
174 return (EIO);
175 }
176 sc->sc_blkno = (daddr_t)0;
177 sc->sc_nxrec = INF;
178 sc->sc_lastiow = 0;
179 sc->sc_blks = 0;
180 sc->sc_softerrs = 0;
181 sc->sc_dens = dens;
182 sc->sc_tpr = tprintf_open();
183 /*
184 * For 6250 bpi take exclusive use of the UNIBUS.
185 */
186 ui->ui_driver->ud_xclu = (dens&(T_1600BPI|T_6250BPI)) == T_6250BPI;
187 s = splclock();
188 if (sc->sc_tact == 0) {
189 sc->sc_timo = INF;
190 sc->sc_tact = 1;
191 timeout(uttimer, (caddr_t)dev, 5*hz);
192 }
193 splx(s);
194 return (0);
195 }
196
utclose(dev,flag)197 utclose(dev, flag)
198 register dev_t dev;
199 register flag;
200 {
201 register struct tj_softc *sc = &tj_softc[TJUNIT(dev)];
202
203 if (flag == FWRITE || ((flag&FWRITE) && sc->sc_lastiow)) {
204 utcommand(dev, UT_WEOF, 1);
205 utcommand(dev, UT_WEOF, 1);
206 utcommand(dev, UT_SREV, 1);
207 }
208 if ((minor(dev)&T_NOREWIND) == 0)
209 utcommand(dev, UT_REW, 0);
210 if (sc->sc_blks > 100 && sc->sc_softerrs > sc->sc_blks / 100)
211 log(LOG_INFO, "tj%d: %d soft errors in %d blocks\n",
212 TJUNIT(dev), sc->sc_softerrs, sc->sc_blks);
213 tprintf_close(sc->sc_tpr);
214 sc->sc_openf = 0;
215 return (0);
216 }
217
utcommand(dev,com,count)218 utcommand(dev, com, count)
219 dev_t dev;
220 int com, count;
221 {
222 register struct buf *bp;
223 register int s;
224
225 bp = &cutbuf[UTUNIT(dev)];
226 s = spl5();
227 while (bp->b_flags&B_BUSY) {
228 if(bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
229 break;
230 bp->b_flags |= B_WANTED;
231 sleep((caddr_t)bp, PRIBIO);
232 }
233 bp->b_flags = B_BUSY|B_READ;
234 splx(s);
235 bp->b_dev = dev;
236 bp->b_command = com;
237 bp->b_repcnt = count;
238 bp->b_blkno = 0;
239 utstrategy(bp);
240 if (count == 0)
241 return;
242 iowait(bp);
243 if (bp->b_flags&B_WANTED)
244 wakeup((caddr_t)bp);
245 bp->b_flags &= B_ERROR;
246 }
247
248 /*
249 * Queue a tape operation.
250 */
utstrategy(bp)251 utstrategy(bp)
252 register struct buf *bp;
253 {
254 int tjunit = TJUNIT(bp->b_dev);
255 register struct uba_ctlr *um;
256 register struct buf *dp;
257 int s;
258
259 /*
260 * Put transfer at end of unit queue
261 */
262 dp = &tjutab[tjunit];
263 bp->av_forw = NULL;
264 um = tjdinfo[tjunit]->ui_mi;
265 s = spl5();
266 if (dp->b_actf == NULL) {
267 dp->b_actf = bp;
268 /*
269 * Transport not active, so...
270 * put at end of controller queue
271 */
272 dp->b_forw = NULL;
273 if (um->um_tab.b_actf == NULL)
274 um->um_tab.b_actf = dp;
275 else
276 um->um_tab.b_actl->b_forw = dp;
277 um->um_tab.b_actl = dp;
278 } else
279 dp->b_actl->av_forw = bp;
280 dp->b_actl = bp;
281 /*
282 * If the controller is not busy, set it going.
283 */
284 if (um->um_tab.b_state == 0)
285 utstart(um);
286 splx(s);
287 }
288
utstart(um)289 utstart(um)
290 register struct uba_ctlr *um;
291 {
292 register struct utdevice *addr;
293 register struct buf *bp, *dp;
294 register struct tj_softc *sc;
295 struct uba_device *ui;
296 int tjunit;
297 daddr_t blkno;
298
299 loop:
300 /*
301 * Scan controller queue looking for units with
302 * transaction queues to dispatch
303 */
304 if ((dp = um->um_tab.b_actf) == NULL)
305 return;
306 if ((bp = dp->b_actf) == NULL) {
307 um->um_tab.b_actf = dp->b_forw;
308 goto loop;
309 }
310 addr = (struct utdevice *)um->um_addr;
311 tjunit = TJUNIT(bp->b_dev);
312 ui = tjdinfo[tjunit];
313 sc = &tj_softc[tjunit];
314 /* note slave select, density, and format were merged on open */
315 addr->uttc = sc->sc_dens;
316 sc->sc_dsreg = addr->utds;
317 sc->sc_erreg = addr->uter;
318 sc->sc_resid = MASKREG(addr->utfc);
319 /*
320 * Default is that last command was NOT a write command;
321 * if we do a write command we will notice this in utintr().
322 */
323 sc->sc_lastiow = 0;
324 if (sc->sc_openf < 0 || (addr->utds&UTDS_MOL) == 0) {
325 /*
326 * Have had a hard error on a non-raw tape
327 * or the tape unit is now unavailable
328 * (e.g. taken off line).
329 */
330 bp->b_flags |= B_ERROR;
331 goto next;
332 }
333 if (bp == &cutbuf[UTUNIT(bp->b_dev)]) {
334 /*
335 * Execute a control operation with the specified
336 * count.
337 */
338 if (bp->b_command == UT_SENSE)
339 goto next;
340 if (bp->b_command == UT_SFORW && (addr->utds & UTDS_EOT)) {
341 bp->b_resid = bp->b_bcount;
342 goto next;
343 }
344 /*
345 * Set next state; handle timeouts
346 */
347 if (bp->b_command == UT_REW) {
348 um->um_tab.b_state = SREW;
349 sc->sc_timo = 5*60;
350 } else {
351 um->um_tab.b_state = SCOM;
352 sc->sc_timo = imin(imax(10*(int)-bp->b_repcnt,60),5*60);
353 }
354 /* NOTE: this depends on the ut command values */
355 if (bp->b_command >= UT_SFORW && bp->b_command <= UT_SREVF)
356 addr->utfc = -bp->b_repcnt;
357 goto dobpcmd;
358 }
359 /*
360 * For raw I/O, save the current block
361 * number in case we have to retry.
362 */
363 if (bp->b_flags & B_RAW) {
364 if (um->um_tab.b_errcnt == 0) {
365 sc->sc_blkno = bdbtofsb(bp->b_blkno);
366 sc->sc_nxrec = sc->sc_blkno + 1;
367 }
368 }
369 else {
370 /*
371 * Handle boundary cases for operation
372 * on non-raw tapes.
373 */
374 if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
375 /* can't read past end of file */
376 bp->b_flags |= B_ERROR;
377 bp->b_error = ENXIO;
378 goto next;
379 }
380 if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
381 (bp->b_flags&B_READ)) {
382 /*
383 * Reading at end of file returns 0 bytes.
384 */
385 bp->b_resid = bp->b_bcount;
386 clrbuf(bp);
387 goto next;
388 }
389 if ((bp->b_flags&B_READ) == 0)
390 sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
391 }
392 /*
393 * If the tape is correctly positioned, set up all the
394 * registers but the csr, and give control over to the
395 * UNIBUS adaptor routines, to wait for resources to
396 * start I/O.
397 */
398 if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
399 addr->utwc = -(((bp->b_bcount)+1)>>1);
400 addr->utfc = -bp->b_bcount;
401 if ((bp->b_flags&B_READ) == 0) {
402 /*
403 * On write error retries erase the
404 * inter-record gap before rewriting.
405 */
406 if (um->um_tab.b_errcnt) {
407 if (um->um_tab.b_state != SERASED) {
408 um->um_tab.b_state = SERASE;
409 sc->sc_timo = 60;
410 addr->utcs1 = UT_ERASE|UT_IE|UT_GO;
411 return;
412 }
413 }
414 if (addr->utds & UTDS_EOT) {
415 bp->b_resid = bp->b_bcount;
416 um->um_tab.b_state = 0;
417 goto next;
418 }
419 um->um_cmd = UT_WCOM;
420 } else
421 um->um_cmd = UT_RCOM;
422 sc->sc_timo = 60;
423 um->um_tab.b_state = SIO;
424 (void) ubago(ui);
425 return;
426 }
427 /*
428 * Tape positioned incorrectly; seek forwards or
429 * backwards to the correct spot. This happens for
430 * raw tapes only on error retries.
431 */
432 um->um_tab.b_state = SSEEK;
433 if (blkno < bdbtofsb(bp->b_blkno)) {
434 addr->utfc = blkno - bdbtofsb(bp->b_blkno);
435 bp->b_command = UT_SFORW;
436 } else {
437 addr->utfc = bdbtofsb(bp->b_blkno) - blkno;
438 bp->b_command = UT_SREV;
439 }
440 sc->sc_timo = imin(imax(10 * -addr->utfc, 60), 5*60);
441
442 dobpcmd:
443 /*
444 * Perform the command setup in bp.
445 */
446 addr->utcs1 = bp->b_command|UT_IE|UT_GO;
447 return;
448 next:
449 /*
450 * Advance to the next command in the slave queue,
451 * posting notice and releasing resources as needed.
452 */
453 if (um->um_ubinfo)
454 ubadone(um);
455 um->um_tab.b_errcnt = 0;
456 dp->b_actf = bp->av_forw;
457 iodone(bp);
458 goto loop;
459 }
460
461 /*
462 * Start operation on controller --
463 * UNIBUS resources have been allocated.
464 */
utdgo(um)465 utdgo(um)
466 register struct uba_ctlr *um;
467 {
468 register struct utdevice *addr = (struct utdevice *)um->um_addr;
469
470 addr->utba = (u_short) um->um_ubinfo;
471 addr->utcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300)|UT_IE|UT_GO;
472 }
473
474 /*
475 * Ut interrupt handler
476 */
477 /*ARGSUSED*/
utintr(ut11)478 utintr(ut11)
479 int ut11;
480 {
481 struct buf *dp;
482 register struct buf *bp;
483 register struct uba_ctlr *um = utminfo[ut11];
484 register struct utdevice *addr;
485 register struct tj_softc *sc;
486 u_short tjunit, cs2, cs1;
487 register state;
488
489 if ((dp = um->um_tab.b_actf) == NULL)
490 return;
491 bp = dp->b_actf;
492 tjunit = TJUNIT(bp->b_dev);
493 addr = (struct utdevice *)tjdinfo[tjunit]->ui_addr;
494 sc = &tj_softc[tjunit];
495 /*
496 * Record status...
497 */
498 sc->sc_timo = INF;
499 sc->sc_dsreg = addr->utds;
500 sc->sc_erreg = addr->uter;
501 sc->sc_resid = MASKREG(addr->utfc);
502 if ((bp->b_flags&B_READ) == 0)
503 sc->sc_lastiow = 1;
504 state = um->um_tab.b_state;
505 um->um_tab.b_state = 0;
506 /*
507 * Check for errors...
508 */
509 if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE)) {
510 /*
511 * To clear the ERR bit, we must issue a drive clear
512 * command, and to clear the TRE bit we must set the
513 * controller clear bit.
514 */
515 cs2 = addr->utcs2;
516 if ((cs1 = addr->utcs1)&UT_TRE)
517 addr->utcs2 |= UTCS2_CLR;
518 /* is this dangerous ?? */
519 while ((addr->utcs1&UT_RDY) == 0)
520 ;
521 addr->utcs1 = UT_CLEAR|UT_GO;
522 /*
523 * If we were reading at 1600 or 6250 bpi and the error
524 * was corrected, then don't consider this an error.
525 */
526 if (sc->sc_erreg & UTER_COR && (bp->b_flags & B_READ) &&
527 (addr->uttc & UTTC_DEN) != UT_NRZI) {
528 tprintf(sc->sc_tpr,
529 "ut%d: soft error bn%d cs1=%b er=%b cs2=%b ds=%b\n",
530 tjunit, bp->b_blkno, cs1, UT_BITS, sc->sc_erreg,
531 UTER_BITS, cs2, UTCS2_BITS, sc->sc_dsreg, UTDS_BITS);
532 sc->sc_erreg &= ~UTER_COR;
533 }
534 /*
535 * If we were reading from a raw tape and the only error
536 * was that the record was too long, then we don't consider
537 * this an error.
538 */
539 if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) &&
540 (sc->sc_erreg&UTER_FCE))
541 sc->sc_erreg &= ~UTER_FCE;
542 if (sc->sc_erreg == 0)
543 goto ignoreerr;
544 /*
545 * Fix up errors which occur due to backspacing
546 * "over" the front of the tape.
547 */
548 if ((sc->sc_dsreg & UTDS_BOT) && bp->b_command == UT_SREV &&
549 ((sc->sc_erreg &= ~(UTER_NEF|UTER_FCE)) == 0))
550 goto opdone;
551 /*
552 * Retry soft errors up to 8 times
553 */
554 if ((sc->sc_erreg&UTER_HARD) == 0 && state == SIO) {
555 if (++um->um_tab.b_errcnt < 7) {
556 sc->sc_blkno++;
557 ubadone(um);
558 goto opcont;
559 }
560 }
561 /*
562 * Hard or non-I/O errors on non-raw tape
563 * cause it to close.
564 */
565 if ((bp->b_flags&B_RAW) == 0 && sc->sc_openf > 0)
566 sc->sc_openf = -1;
567 /*
568 * Couldn't recover error.
569 */
570 tprintf(sc->sc_tpr,
571 "ut%d: hard error bn%d cs1=%b er=%b cs2=%b ds=%b\n",
572 tjunit, bp->b_blkno, cs1, UT_BITS, sc->sc_erreg,
573 UTER_BITS, cs2, UTCS2_BITS, sc->sc_dsreg, UTDS_BITS);
574 bp->b_flags |= B_ERROR;
575 goto opdone;
576 }
577
578 ignoreerr:
579 /*
580 * If we hit a tape mark update our position.
581 */
582 if (sc->sc_dsreg & UTDS_TM && bp->b_flags & B_READ) {
583 /*
584 * Set blkno and nxrec
585 */
586 if (bp == &cutbuf[UTUNIT(bp->b_dev)]) {
587 if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
588 sc->sc_nxrec =
589 bdbtofsb(bp->b_blkno) - addr->utfc;
590 sc->sc_blkno = sc->sc_nxrec;
591 } else {
592 sc->sc_blkno =
593 bdbtofsb(bp->b_blkno) + addr->utfc;
594 sc->sc_nxrec = sc->sc_blkno-1;
595 }
596 } else
597 sc->sc_nxrec = bdbtofsb(bp->b_blkno);
598 /*
599 * Note: if we get a tape mark on a read, the
600 * frame count register will be zero, so b_resid
601 * will be calculated correctly below.
602 */
603 goto opdone;
604 }
605 /*
606 * Advance tape control FSM.
607 */
608 switch (state) {
609
610 case SIO: /* read/write increments tape block # */
611 sc->sc_blkno++;
612 sc->sc_blks++;
613 if (um->um_tab.b_errcnt)
614 sc->sc_softerrs++;
615 break;
616
617 case SCOM: /* motion commands update current position */
618 if (bp == &cutbuf[UTUNIT(bp->b_dev)])
619 switch ((int)bp->b_command) {
620
621 case UT_SFORW:
622 sc->sc_blkno -= bp->b_repcnt;
623 break;
624
625 case UT_SREV:
626 sc->sc_blkno += bp->b_repcnt;
627 break;
628
629 case UT_REWOFFL:
630 addr->utcs1 = UT_CLEAR|UT_GO;
631 break;
632 }
633 break;
634
635 case SSEEK:
636 sc->sc_blkno = bdbtofsb(bp->b_blkno);
637 goto opcont;
638
639 case SERASE:
640 /*
641 * Completed erase of the inter-record gap due to a
642 * write error; now retry the write operation.
643 */
644 um->um_tab.b_state = SERASED;
645 goto opcont;
646
647 case SREW: /* clear attention bit */
648 addr->utcs1 = UT_CLEAR|UT_GO;
649 break;
650
651 default:
652 printf("bad state %d\n", state);
653 panic("utintr");
654 }
655
656 opdone:
657 /*
658 * Reset error count and remove
659 * from device queue
660 */
661 um->um_tab.b_errcnt = 0;
662 dp->b_actf = bp->av_forw;
663 /*
664 * For read command, frame count register contains
665 * actual length of tape record. Otherwise, it
666 * holds negative residual count.
667 */
668 if (state == SIO && um->um_cmd == UT_RCOM) {
669 bp->b_resid = 0;
670 if (bp->b_bcount > MASKREG(addr->utfc))
671 bp->b_resid = bp->b_bcount - MASKREG(addr->utfc);
672 } else
673 bp->b_resid = MASKREG(-addr->utfc);
674 ubadone(um);
675 iodone(bp);
676 /*
677 * Circulate slave to end of controller queue
678 * to give other slaves a chance
679 */
680 um->um_tab.b_actf = dp->b_forw;
681 if (dp->b_actf) {
682 dp->b_forw = NULL;
683 if (um->um_tab.b_actf == NULL)
684 um->um_tab.b_actf = dp;
685 else
686 um->um_tab.b_actl->b_forw = dp;
687 um->um_tab.b_actl = dp;
688 }
689 if (um->um_tab.b_actf == 0)
690 return;
691 opcont:
692 utstart(um);
693 }
694
695 /*
696 * Watchdog timer routine.
697 */
uttimer(dev)698 uttimer(dev)
699 int dev;
700 {
701 register struct tj_softc *sc = &tj_softc[TJUNIT(dev)];
702 register short x;
703
704 if (sc->sc_timo != INF && (sc->sc_timo -= 5) < 0) {
705 printf("tj%d: lost interrupt\n", TJUNIT(dev));
706 sc->sc_timo = INF;
707 x = spl5();
708 utintr(UTUNIT(dev));
709 (void) splx(x);
710 }
711 timeout(uttimer, (caddr_t)dev, 5*hz);
712 }
713
714 /*ARGSUSED*/
utioctl(dev,cmd,data,flag)715 utioctl(dev, cmd, data, flag)
716 dev_t dev;
717 caddr_t data;
718 {
719 register struct tj_softc *sc = &tj_softc[TJUNIT(dev)];
720 register struct buf *bp = &cutbuf[UTUNIT(dev)];
721 register callcount;
722 int fcount, error = 0;
723 struct mtop *mtop;
724 struct mtget *mtget;
725 /* we depend of the values and order of the MT codes here */
726 static utops[] =
727 {UT_WEOF,UT_SFORWF,UT_SREVF,UT_SFORW,UT_SREV,UT_REW,UT_REWOFFL,UT_SENSE};
728
729 switch (cmd) {
730
731 case MTIOCTOP:
732 mtop = (struct mtop *)data;
733 switch(mtop->mt_op) {
734
735 case MTWEOF:
736 case MTFSF: case MTBSF:
737 case MTFSR: case MTBSR:
738 callcount = mtop->mt_count;
739 fcount = 1;
740 break;
741
742 case MTREW: case MTOFFL: case MTNOP:
743 callcount = 1;
744 fcount = 1;
745 break;
746
747 default:
748 return (ENXIO);
749 }
750 if (callcount <= 0 || fcount <= 0)
751 return (EINVAL);
752 while (--callcount >= 0) {
753 utcommand(dev, utops[mtop->mt_op], fcount);
754 if ((bp->b_flags&B_ERROR) || (sc->sc_dsreg&UTDS_BOT))
755 break;
756 }
757 if (bp->b_flags&B_ERROR)
758 if ((error = bp->b_error)==0)
759 return (EIO);
760 return (error);
761
762 case MTIOCGET:
763 mtget = (struct mtget *)data;
764 mtget->mt_dsreg = sc->sc_dsreg;
765 mtget->mt_erreg = sc->sc_erreg;
766 mtget->mt_resid = sc->sc_resid;
767 mtget->mt_type = MT_ISUT;
768 break;
769
770 default:
771 return (ENXIO);
772 }
773 return (0);
774 }
775
utreset(uban)776 utreset(uban)
777 int uban;
778 {
779 register struct uba_ctlr *um;
780 register ut11, tjunit;
781 register struct uba_device *ui;
782 register struct buf *dp;
783
784 for (ut11 = 0; ut11 < NUT; ut11++) {
785 if ((um = utminfo[ut11]) == 0 || um->um_alive == 0 ||
786 um->um_ubanum != uban)
787 continue;
788 printf(" ut%d", ut11);
789 um->um_tab.b_state = 0;
790 um->um_tab.b_actf = um->um_tab.b_actl = 0;
791 if (um->um_ubinfo) {
792 printf("<%d>", (um->um_ubinfo>>28)&0xf);
793 um->um_ubinfo = 0;
794 }
795 ((struct utdevice *)(um->um_addr))->utcs1 = UT_CLEAR|UT_GO;
796 ((struct utdevice *)(um->um_addr))->utcs2 |= UTCS2_CLR;
797 for (tjunit = 0; tjunit < NTJ; tjunit++) {
798 if ((ui = tjdinfo[tjunit]) == 0 || ui->ui_mi != um ||
799 ui->ui_alive == 0)
800 continue;
801 dp = &tjutab[tjunit];
802 dp->b_state = 0;
803 dp->b_forw = 0;
804 if (um->um_tab.b_actf == NULL)
805 um->um_tab.b_actf = dp;
806 else
807 um->um_tab.b_actl->b_forw = dp;
808 um->um_tab.b_actl = dp;
809 if (tj_softc[tjunit].sc_openf > 0)
810 tj_softc[tjunit].sc_openf = -1;
811 }
812 utstart(um);
813 }
814 }
815
816 /*
817 * Do a stand-alone core dump to tape --
818 * from here down, routines are used only in dump context
819 */
820 #define DBSIZE 20
821
utdump()822 utdump()
823 {
824 register struct uba_device *ui;
825 register struct uba_regs *up;
826 register struct utdevice *addr;
827 int blk, num = maxfree;
828 int start = 0;
829
830 #define phys(a,b) ((b)((int)(a)&0x7fffffff))
831 if (tjdinfo[0] == 0)
832 return (ENXIO);
833 ui = phys(tjdinfo[0], struct uba_device *);
834 up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba;
835 ubainit(up);
836 DELAY(1000000);
837 addr = (struct utdevice *)ui->ui_physaddr;
838 utwait(addr);
839 /*
840 * Be sure to set the appropriate density here. We use
841 * 6250, but maybe it should be done at 1600 to insure the
842 * tape can be read by most any other tape drive available.
843 */
844 addr->uttc = UT_GCR|PDP11FMT; /* implicit slave 0 or-ed in */
845 addr->utcs1 = UT_CLEAR|UT_GO;
846 while (num > 0) {
847 blk = num > DBSIZE ? DBSIZE : num;
848 utdwrite(start, blk, addr, up);
849 if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE))
850 return(EIO);
851 start += blk;
852 num -= blk;
853 }
854 uteof(addr);
855 uteof(addr);
856 utwait(addr);
857 if ((addr->utds&UTDS_ERR) || (addr->utcs1&UT_TRE))
858 return(EIO);
859 addr->utcs1 = UT_REW|UT_GO;
860 return (0);
861 }
862
utdwrite(dbuf,num,addr,up)863 utdwrite(dbuf, num, addr, up)
864 register dbuf, num;
865 register struct utdevice *addr;
866 struct uba_regs *up;
867 {
868 register struct pte *io;
869 register int npf;
870
871 utwait(addr);
872 io = up->uba_map;
873 npf = num + 1;
874 while (--npf != 0)
875 *(int *)io++ = (dbuf++ | (1<<UBAMR_DPSHIFT) | UBAMR_MRV);
876 *(int *)io = 0;
877 addr->utwc = -((num*NBPG)>>1);
878 addr->utfc = -(num*NBPG);
879 addr->utba = 0;
880 addr->utcs1 = UT_WCOM|UT_GO;
881 }
882
883 utwait(addr)
884 struct utdevice *addr;
885 {
886 register s;
887
888 do
889 s = addr->utds;
890 while ((s&UTDS_DRY) == 0);
891 }
892
893 uteof(addr)
894 struct utdevice *addr;
895 {
896
897 utwait(addr);
898 addr->utcs1 = UT_WEOF|UT_GO;
899 }
900 #endif
901