![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba|
Return to cy.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Computer Consoles Inc.
7: *
8: * Redistribution is only permitted until one year after the first shipment
9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
10: * binary forms are permitted provided that: (1) source distributions retain
11: * this entire copyright notice and comment, and (2) distributions including
12: * binaries display the following acknowledgement: This product includes
13: * software developed by the University of California, Berkeley and its
14: * contributors'' in the documentation or other materials provided with the
15: * distribution and in all advertising materials mentioning features or use
16: * of this software. Neither the name of the University nor the names of
17: * its contributors may be used to endorse or promote products derived from
18: * this software without specific prior written permission.
19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22: *
23: * @(#)cy.c 7.4 (Berkeley) 5/5/89
24: */
25:
26: #include "yc.h"
27: #if NCY > 0
28: /*
29: * Cipher Tapemaster driver.
30: */
31: #define CYDEBUG
32: #ifdef CYDEBUG
33: int cydebug = 0;
34: #define dlog(params) if (cydebug) log params
35: #else
36: #define dlog(params) /* */
37: #endif
38:
39: #include "param.h"
40: #include "systm.h"
41: #include "vm.h"
42: #include "buf.h"
43: #include "file.h"
44: #include "signal.h"
45: #include "ioctl.h"
46: #include "mtio.h"
47: #include "errno.h"
48: #include "cmap.h"
49: #include "time.h"
50: #include "kernel.h"
51: #include "syslog.h"
52: #include "tprintf.h"
53:
54: #include "../tahoe/cpu.h"
55: #include "../tahoe/mtpr.h"
56: #include "../tahoe/pte.h"
57:
58: #include "../tahoevba/vbavar.h"
59: #define CYERROR
60: #include "../tahoevba/cyreg.h"
61:
62: /*
63: * There is a ccybuf per tape controller.
64: * It is used as the token to pass to the internal routines
65: * to execute tape ioctls, and also acts as a lock on the slaves
66: * on the controller, since there is only one per controller.
67: * In particular, when the tape is rewinding on close we release
68: * the user process but any further attempts to use the tape drive
69: * before the rewind completes will hang waiting for ccybuf.
70: */
71: struct buf ccybuf[NCY];
72:
73: int cyprobe(), cyslave(), cyattach();
74: struct buf ycutab[NYC];
75: short yctocy[NYC];
76: struct vba_ctlr *cyminfo[NCY];
77: struct vba_device *ycdinfo[NYC];
78: long cystd[] = { 0 };
79: struct vba_driver cydriver =
80: { cyprobe, cyslave, cyattach, 0, cystd, "yc", ycdinfo, "cy", cyminfo };
81:
82: /* bits in minor device */
83: #define YCUNIT(dev) (minor(dev)&03)
84: #define CYUNIT(dev) (yctocy[YCUNIT(dev)])
85: #define T_NOREWIND 0x04
86: #define T_1600BPI 0x00 /* pseudo */
87: #define T_3200BPI 0x08 /* unused */
88:
89: #define INF 1000000L /* close to infinity */
90:
91: /*
92: * Software state and shared command areas per controller.
93: *
94: * The i/o intermediate buffer must be allocated in startup()
95: * so its address will fit in 20-bits (YECH!!!!!!!!!!!!!!).
96: */
97: struct cy_softc {
98: int cy_bs; /* controller's buffer size */
99: struct cyscp *cy_scp; /* system configuration block address */
100: struct cyccb cy_ccb; /* channel control block */
101: struct cyscb cy_scb; /* system configuration block */
102: struct cytpb cy_tpb; /* tape parameter block */
103: struct cytpb cy_nop; /* nop parameter block for cyintr */
104: struct vb_buf cy_rbuf; /* vba resources */
105: } cy_softc[NCY];
106:
107: /*
108: * Software state per tape transport.
109: */
110: struct yc_softc {
111: char yc_openf; /* lock against multiple opens */
112: char yc_lastiow; /* last operation was a write */
113: short yc_tact; /* timeout is active */
114: long yc_timo; /* time until timeout expires */
115: u_short yc_control; /* copy of last tpcb.tpcontrol */
116: u_short yc_status; /* copy of last tpcb.tpstatus */
117: u_short yc_resid; /* copy of last bc */
118: u_short yc_dens; /* prototype control word with density info */
119: tpr_t yc_tpr; /* handle for tprintf */
120: daddr_t yc_blkno; /* block number, for block device tape */
121: daddr_t yc_nxrec; /* position of end of tape, if known */
122: int yc_blksize; /* current tape blocksize estimate */
123: int yc_blks; /* number of I/O operations since open */
124: int yc_softerrs; /* number of soft I/O errors since open */
125: } yc_softc[NYC];
126:
127: /*
128: * States for vm->um_tab.b_active, the per controller state flag.
129: * This is used to sequence control in the driver.
130: */
131: #define SSEEK 1 /* seeking */
132: #define SIO 2 /* doing seq i/o */
133: #define SCOM 3 /* sending control command */
134: #define SREW 4 /* sending a rewind */
135: #define SERASE 5 /* erase inter-record gap */
136: #define SERASED 6 /* erased inter-record gap */
137:
138: /* there's no way to figure these out dynamically? -- yech */
139: struct cyscp *cyscp[] =
140: { (struct cyscp *)0xc0000c06, (struct cyscp *)0xc0000c16 };
141: #define NCYSCP (sizeof (cyscp) / sizeof (cyscp[0]))
142:
143: cyprobe(reg, vm)
144: caddr_t reg;
145: struct vba_ctlr *vm;
146: {
147: register br, cvec; /* must be r12, r11 */
148: register struct cy_softc *cy;
149: int ctlr = vm->um_ctlr;
150:
151: #ifdef lint
152: br = 0; cvec = br; br = cvec;
153: cyintr(0);
154: #endif
155: if (badcyaddr(reg+1))
156: return (0);
157: if (ctlr > NCYSCP || cyscp[ctlr] == 0) /* XXX */
158: return (0);
159: cy = &cy_softc[ctlr];
160: cy->cy_scp = cyscp[ctlr]; /* XXX */
161: /*
162: * Tapemaster controller must have interrupt handler
163: * disable interrupt, so we'll just kludge things
164: * (stupid multibus non-vectored interrupt crud).
165: */
166: if (cyinit(ctlr, reg)) {
167: uncache(&cy->cy_tpb.tpcount);
168: cy->cy_bs = htoms(cy->cy_tpb.tpcount);
169: /*
170: * Setup nop parameter block for clearing interrupts.
171: */
172: cy->cy_nop.tpcmd = CY_NOP;
173: cy->cy_nop.tpcontrol = 0;
174: /*
175: * Allocate page tables.
176: */
177: if (cybuf == 0) {
178: printf("no cy buffer!!!\n");
179: return (0);
180: }
181: cy->cy_rbuf.vb_rawbuf = cybuf + ctlr * CYMAXIO;
182: if (vbainit(&cy->cy_rbuf, CYMAXIO, VB_20BIT) == 0) {
183: printf("cy%d: vbainit failed\n", ctlr);
184: return (0);
185: }
186:
187: br = 0x13, cvec = 0x80; /* XXX */
188: return (sizeof (struct cyccb));
189: } else
190: return (0);
191: }
192:
193: /*
194: * Check to see if a drive is attached to a controller.
195: * Since we can only tell that a drive is there if a tape is loaded and
196: * the drive is placed online, we always indicate the slave is present.
197: */
198: cyslave(vi, addr)
199: struct vba_device *vi;
200: caddr_t addr;
201: {
202:
203: #ifdef lint
204: vi = vi; addr = addr;
205: #endif
206: return (1);
207: }
208:
209: cyattach(vi)
210: struct vba_device *vi;
211: {
212: register struct cy_softc *cy;
213: int ctlr = vi->ui_mi->um_ctlr;
214:
215: yctocy[vi->ui_unit] = ctlr;
216: cy = &cy_softc[ctlr];
217: if (vi->ui_slave == 0 && cy->cy_bs)
218: printf("; %dkb buffer", cy->cy_bs/1024);
219: }
220:
221: /*
222: * Initialize the controller after a controller reset or
223: * during autoconfigure. All of the system control blocks
224: * are initialized and the controller is asked to configure
225: * itself for later use.
226: */
227: cyinit(ctlr, addr)
228: int ctlr;
229: register caddr_t addr;
230: {
231: register struct cy_softc *cy = &cy_softc[ctlr];
232: register int *pte;
233:
234: /*
235: * Initialize the system configuration pointer.
236: */
237: /* make kernel writable */
238: pte = (int *)&Sysmap[btop((int)cy->cy_scp &~ KERNBASE)];
239: *pte &= ~PG_PROT; *pte |= PG_KW;
240: mtpr(TBIS, cy->cy_scp);
241: /* load the correct values in the scp */
242: cy->cy_scp->csp_buswidth = CSP_16BITS;
243: cyldmba(cy->cy_scp->csp_scb, (caddr_t)&cy->cy_scb);
244: /* put it back to read-only */
245: *pte &= ~PG_PROT; *pte |= PG_KR;
246: mtpr(TBIS, cy->cy_scp);
247:
248: /*
249: * Init system configuration block.
250: */
251: cy->cy_scb.csb_fixed = CSB_FIXED;
252: /* set pointer to the channel control block */
253: cyldmba(cy->cy_scb.csb_ccb, (caddr_t)&cy->cy_ccb);
254:
255: /*
256: * Initialize the chanel control block.
257: */
258: cy->cy_ccb.cbcw = CBCW_CLRINT;
259: cy->cy_ccb.cbgate = GATE_OPEN;
260: /* set pointer to the tape parameter block */
261: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
262:
263: /*
264: * Issue a nop cmd and get the internal buffer size for buffered i/o.
265: */
266: cy->cy_tpb.tpcmd = CY_NOP;
267: cy->cy_tpb.tpcontrol = CYCW_16BITS;
268: cy->cy_ccb.cbgate = GATE_CLOSED;
269: CY_GO(addr);
270: if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) {
271: uncache(&cy->cy_tpb.tpstatus);
272: printf("cy%d: timeout or err during init, status=%b\n", ctlr,
273: cy->cy_tpb.tpstatus, CYS_BITS);
274: return (0);
275: }
276: cy->cy_tpb.tpcmd = CY_CONFIG;
277: cy->cy_tpb.tpcontrol = CYCW_16BITS;
278: cy->cy_ccb.cbgate = GATE_CLOSED;
279: CY_GO(addr);
280: if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) {
281: uncache(&cy->cy_tpb.tpstatus);
282: printf("cy%d: configuration failure, status=%b\n", ctlr,
283: cy->cy_tpb.tpstatus, CYS_BITS);
284: return (0);
285: }
286: return (1);
287: }
288:
289: int cytimer();
290: /*
291: * Open the device. Tapes are unique open
292: * devices, so we refuse if it is already open.
293: * We also check that a tape is available, and
294: * don't block waiting here; if you want to wait
295: * for a tape you should timeout in user code.
296: */
297: cyopen(dev, flag)
298: dev_t dev;
299: register int flag;
300: {
301: register int ycunit;
302: register struct vba_device *vi;
303: register struct yc_softc *yc;
304:
305: ycunit = YCUNIT(dev);
306: if (ycunit >= NYC || (vi = ycdinfo[ycunit]) == 0 || vi->ui_alive == 0)
307: return (ENXIO);
308: if ((yc = &yc_softc[ycunit])->yc_openf)
309: return (EBUSY);
310: yc->yc_openf = 1;
311: #define PACKUNIT(vi) \
312: (((vi->ui_slave&1)<<11)|((vi->ui_slave&2)<<9)|((vi->ui_slave&4)>>2))
313: /* no way to select density */
314: yc->yc_dens = PACKUNIT(vi)|CYCW_IE|CYCW_16BITS;
315: if (yc->yc_tact == 0) {
316: yc->yc_timo = INF;
317: yc->yc_tact = 1;
318: timeout(cytimer, (caddr_t)dev, 5*hz);
319: }
320: cycommand(dev, CY_SENSE, 1);
321: if ((yc->yc_status&CYS_OL) == 0) { /* not on-line */
322: uprintf("cy%d: not online\n", ycunit);
323: yc->yc_openf = 0;
324: return (EIO);
325: }
326: if ((flag&FWRITE) && (yc->yc_status&CYS_WP)) {
327: uprintf("cy%d: no write ring\n", ycunit);
328: yc->yc_openf = 0;
329: return (EIO);
330: }
331: yc->yc_blkno = (daddr_t)0;
332: yc->yc_nxrec = INF;
333: yc->yc_lastiow = 0;
334: yc->yc_blksize = CYMAXIO; /* guess > 0 */
335: yc->yc_blks = 0;
336: yc->yc_softerrs = 0;
337: yc->yc_tpr = tprintf_open();
338: return (0);
339: }
340:
341: /*
342: * Close tape device.
343: *
344: * If tape was open for writing or last operation was a write,
345: * then write two EOF's and backspace over the last one.
346: * Unless this is a non-rewinding special file, rewind the tape.
347: * Make the tape available to others.
348: */
349: cyclose(dev, flag)
350: dev_t dev;
351: int flag;
352: {
353: struct yc_softc *yc = &yc_softc[YCUNIT(dev)];
354:
355: if (flag == FWRITE || (flag&FWRITE) && yc->yc_lastiow) {
356: cycommand(dev, CY_WEOF, 1); /* can't use count with WEOF */
357: cycommand(dev, CY_WEOF, 1);
358: cycommand(dev, CY_SREV, 1);
359: }
360: if ((minor(dev)&T_NOREWIND) == 0)
361: /*
362: * 0 count means don't hang waiting for rewind complete
363: * rather ccybuf stays busy until the operation completes
364: * preventing further opens from completing by preventing
365: * a CY_SENSE from completing.
366: */
367: cycommand(dev, CY_REW, 0);
368: if (yc->yc_blks > 10 && yc->yc_softerrs > yc->yc_blks / 10)
369: log(LOG_INFO, "yc%d: %d soft errors in %d blocks\n",
370: YCUNIT(dev), yc->yc_softerrs, yc->yc_blks);
371: dlog((LOG_INFO, "%d soft errors in %d blocks\n",
372: yc->yc_softerrs, yc->yc_blks));
373: tprintf_close(yc->yc_tpr);
374: yc->yc_openf = 0;
375: return (0);
376: }
377:
378: /*
379: * Execute a command on the tape drive a specified number of times.
380: */
381: cycommand(dev, com, count)
382: dev_t dev;
383: int com, count;
384: {
385: register struct buf *bp;
386: int s;
387:
388: bp = &ccybuf[CYUNIT(dev)];
389: s = spl3();
390: dlog((LOG_INFO, "cycommand(%o, %x, %d), b_flags %x\n",
391: dev, com, count, bp->b_flags));
392: while (bp->b_flags&B_BUSY) {
393: /*
394: * This special check is because B_BUSY never
395: * gets cleared in the non-waiting rewind case.
396: */
397: if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
398: break;
399: bp->b_flags |= B_WANTED;
400: sleep((caddr_t)bp, PRIBIO);
401: }
402: bp->b_flags = B_BUSY|B_READ;
403: splx(s);
404: bp->b_dev = dev;
405: bp->b_repcnt = count;
406: bp->b_command = com;
407: bp->b_blkno = 0;
408: cystrategy(bp);
409: /*
410: * In case of rewind from close; don't wait.
411: * This is the only case where count can be 0.
412: */
413: if (count == 0)
414: return;
415: biowait(bp);
416: if (bp->b_flags&B_WANTED)
417: wakeup((caddr_t)bp);
418: bp->b_flags &= B_ERROR;
419: }
420:
421: cystrategy(bp)
422: register struct buf *bp;
423: {
424: int ycunit = YCUNIT(bp->b_dev);
425: register struct vba_ctlr *vm;
426: register struct buf *dp;
427: int s;
428:
429: /*
430: * Put transfer at end of unit queue.
431: */
432: dlog((LOG_INFO, "cystrategy(%o, %x)\n", bp->b_dev, bp->b_command));
433: dp = &ycutab[ycunit];
434: bp->av_forw = NULL;
435: vm = ycdinfo[ycunit]->ui_mi;
436: /* BEGIN GROT */
437: if (bp->b_flags & B_RAW) {
438: if (bp->b_bcount >= CYMAXIO) {
439: uprintf("cy%d: i/o size too large\n", vm->um_ctlr);
440: bp->b_error = EINVAL;
441: bp->b_resid = bp->b_bcount;
442: bp->b_flags |= B_ERROR;
443: biodone(bp);
444: return;
445: }
446: }
447: /* END GROT */
448: s = spl3();
449: if (dp->b_actf == NULL) {
450: dp->b_actf = bp;
451: /*
452: * Transport not already active...
453: * put at end of controller queue.
454: */
455: dp->b_forw = NULL;
456: if (vm->um_tab.b_actf == NULL)
457: vm->um_tab.b_actf = dp;
458: else
459: vm->um_tab.b_actl->b_forw = dp;
460: } else
461: dp->b_actl->av_forw = bp;
462: dp->b_actl = bp;
463: /*
464: * If the controller is not busy, get it going.
465: */
466: if (vm->um_tab.b_active == 0)
467: cystart(vm);
468: splx(s);
469: }
470:
471: /*
472: * Start activity on a cy controller.
473: */
474: cystart(vm)
475: register struct vba_ctlr *vm;
476: {
477: register struct buf *bp, *dp;
478: register struct yc_softc *yc;
479: register struct cy_softc *cy;
480: int ycunit;
481: daddr_t blkno;
482:
483: dlog((LOG_INFO, "cystart()\n"));
484: /*
485: * Look for an idle transport on the controller.
486: */
487: loop:
488: if ((dp = vm->um_tab.b_actf) == NULL)
489: return;
490: if ((bp = dp->b_actf) == NULL) {
491: vm->um_tab.b_actf = dp->b_forw;
492: goto loop;
493: }
494: ycunit = YCUNIT(bp->b_dev);
495: yc = &yc_softc[ycunit];
496: cy = &cy_softc[CYUNIT(bp->b_dev)];
497: /*
498: * Default is that last command was NOT a write command;
499: * if we do a write command we will notice this in cyintr().
500: */
501: yc->yc_lastiow = 0;
502: if (yc->yc_openf < 0 ||
503: (bp->b_command != CY_SENSE && (cy->cy_tpb.tpstatus&CYS_OL) == 0)) {
504: /*
505: * Have had a hard error on a non-raw tape
506: * or the tape unit is now unavailable (e.g.
507: * taken off line).
508: */
509: dlog((LOG_INFO, "openf %d command %x status %b\n",
510: yc->yc_openf, bp->b_command, cy->cy_tpb.tpstatus, CYS_BITS));
511: bp->b_flags |= B_ERROR;
512: goto next;
513: }
514: if (bp == &ccybuf[CYUNIT(bp->b_dev)]) {
515: /*
516: * Execute control operation with the specified count.
517: *
518: * Set next state; give 5 minutes to complete
519: * rewind or file mark search, or 10 seconds per
520: * iteration (minimum 60 seconds and max 5 minutes)
521: * to complete other ops.
522: */
523: if (bp->b_command == CY_REW) {
524: vm->um_tab.b_active = SREW;
525: yc->yc_timo = 5*60;
526: } else if (bp->b_command == CY_FSF ||
527: bp->b_command == CY_BSF) {
528: vm->um_tab.b_active = SCOM;
529: yc->yc_timo = 5*60;
530: } else {
531: vm->um_tab.b_active = SCOM;
532: yc->yc_timo = imin(imax(10*(int)bp->b_repcnt,60),5*60);
533: }
534: cy->cy_tpb.tprec = htoms(bp->b_repcnt);
535: dlog((LOG_INFO, "bpcmd "));
536: goto dobpcmd;
537: }
538: /*
539: * For raw I/O, save the current block
540: * number in case we have to retry.
541: */
542: if (bp->b_flags & B_RAW) {
543: if (vm->um_tab.b_errcnt == 0) {
544: yc->yc_blkno = bp->b_blkno;
545: yc->yc_nxrec = yc->yc_blkno + 1;
546: }
547: } else {
548: /*
549: * Handle boundary cases for operation
550: * on non-raw tapes.
551: */
552: if (bp->b_blkno > yc->yc_nxrec) {
553: /*
554: * Can't read past known end-of-file.
555: */
556: bp->b_flags |= B_ERROR;
557: bp->b_error = ENXIO;
558: goto next;
559: }
560: if (bp->b_blkno == yc->yc_nxrec && bp->b_flags&B_READ) {
561: /*
562: * Reading at end of file returns 0 bytes.
563: */
564: bp->b_resid = bp->b_bcount;
565: clrbuf(bp);
566: goto next;
567: }
568: if ((bp->b_flags&B_READ) == 0)
569: /*
570: * Writing sets EOF.
571: */
572: yc->yc_nxrec = bp->b_blkno + 1;
573: }
574: if ((blkno = yc->yc_blkno) == bp->b_blkno) {
575: caddr_t addr;
576: int cmd;
577:
578: /*
579: * Choose the appropriate i/o command based on the
580: * transfer size, the estimated block size,
581: * and the controller's internal buffer size.
582: * If the request length is longer than the tape
583: * block length, a buffered read will fail,
584: * thus, we request at most the size that we expect.
585: * We then check for larger records when the read completes.
586: * If we're retrying a read on a raw device because
587: * the original try was a buffer request which failed
588: * due to a record length error, then we force the use
589: * of the raw controller read (YECH!!!!).
590: */
591: if (bp->b_flags&B_READ) {
592: if (yc->yc_blksize <= cy->cy_bs &&
593: vm->um_tab.b_errcnt == 0)
594: cmd = CY_BRCOM;
595: else
596: cmd = CY_RCOM;
597: } else {
598: /*
599: * On write error retries erase the
600: * inter-record gap before rewriting.
601: */
602: if (vm->um_tab.b_errcnt &&
603: vm->um_tab.b_active != SERASED) {
604: vm->um_tab.b_active = SERASE;
605: bp->b_command = CY_ERASE;
606: yc->yc_timo = 60;
607: goto dobpcmd;
608: }
609: cmd = (bp->b_bcount > cy->cy_bs) ? CY_WCOM : CY_BWCOM;
610: }
611: vm->um_tab.b_active = SIO;
612: addr = (caddr_t)vbasetup(bp, &cy->cy_rbuf, 1);
613: cy->cy_tpb.tpcmd = cmd;
614: cy->cy_tpb.tpcontrol = yc->yc_dens;
615: if (cmd == CY_RCOM || cmd == CY_WCOM)
616: cy->cy_tpb.tpcontrol |= CYCW_LOCK;
617: cy->cy_tpb.tpstatus = 0;
618: cy->cy_tpb.tpcount = 0;
619: cyldmba(cy->cy_tpb.tpdata, (caddr_t)addr);
620: cy->cy_tpb.tprec = 0;
621: if (cmd == CY_BRCOM)
622: cy->cy_tpb.tpsize = htoms(imin(yc->yc_blksize,
623: (int)bp->b_bcount));
624: else
625: cy->cy_tpb.tpsize = htoms(bp->b_bcount);
626: cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
627: do
628: uncache(&cy->cy_ccb.cbgate);
629: while (cy->cy_ccb.cbgate == GATE_CLOSED);
630: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
631: cy->cy_ccb.cbcw = CBCW_IE;
632: cy->cy_ccb.cbgate = GATE_CLOSED;
633: dlog((LOG_INFO, "CY_GO(%x) cmd %x control %x size %d\n",
634: vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol,
635: htoms(cy->cy_tpb.tpsize)));
636: CY_GO(vm->um_addr);
637: return;
638: }
639: /*
640: * Tape positioned incorrectly; set to seek forwards
641: * or backwards to the correct spot. This happens
642: * for raw tapes only on error retries.
643: */
644: vm->um_tab.b_active = SSEEK;
645: if (blkno < bp->b_blkno) {
646: bp->b_command = CY_SFORW;
647: cy->cy_tpb.tprec = htoms(bp->b_blkno - blkno);
648: } else {
649: bp->b_command = CY_SREV;
650: cy->cy_tpb.tprec = htoms(blkno - bp->b_blkno);
651: }
652: yc->yc_timo = imin(imax((int)(10 * htoms(cy->cy_tpb.tprec)), 60), 5*60);
653: dobpcmd:
654: /*
655: * Do the command in bp. Reverse direction commands
656: * are indicated by having CYCW_REV or'd into their
657: * value. For these we must set the appropriate bit
658: * in the control field.
659: */
660: if (bp->b_command&CYCW_REV) {
661: cy->cy_tpb.tpcmd = bp->b_command &~ CYCW_REV;
662: cy->cy_tpb.tpcontrol = yc->yc_dens | CYCW_REV;
663: dlog((LOG_INFO, "cmd %x control %x\n", cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol));
664: } else {
665: cy->cy_tpb.tpcmd = bp->b_command;
666: cy->cy_tpb.tpcontrol = yc->yc_dens;
667: dlog((LOG_INFO, "cmd %x control %x\n", cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol));
668: }
669: cy->cy_tpb.tpstatus = 0;
670: cy->cy_tpb.tpcount = 0;
671: cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
672: do
673: uncache(&cy->cy_ccb.cbgate);
674: while (cy->cy_ccb.cbgate == GATE_CLOSED);
675: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
676: cy->cy_ccb.cbcw = CBCW_IE;
677: cy->cy_ccb.cbgate = GATE_CLOSED;
678: dlog((LOG_INFO, "CY_GO(%x) cmd %x control %x rec %d\n",
679: vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol,
680: htoms(cy->cy_tpb.tprec)));
681: CY_GO(vm->um_addr);
682: return;
683: next:
684: /*
685: * Done with this operation due to error or the
686: * fact that it doesn't do anything.
687: * Dequeue the transfer and continue
688: * processing this slave.
689: */
690: vm->um_tab.b_errcnt = 0;
691: dp->b_actf = bp->av_forw;
692: biodone(bp);
693: goto loop;
694: }
695:
696: /*
697: * Cy interrupt routine.
698: */
699: cyintr(cyunit)
700: int cyunit;
701: {
702: struct buf *dp;
703: register struct buf *bp;
704: register struct vba_ctlr *vm = cyminfo[cyunit];
705: register struct cy_softc *cy;
706: register struct yc_softc *yc;
707: int err;
708: register state;
709:
710: dlog((LOG_INFO, "cyintr(%d)\n", cyunit));
711: /*
712: * First, turn off the interrupt from the controller
713: * (device uses Multibus non-vectored interrupts...yech).
714: */
715: cy = &cy_softc[vm->um_ctlr];
716: cy->cy_ccb.cbcw = CBCW_CLRINT;
717: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_nop);
718: cy->cy_ccb.cbgate = GATE_CLOSED;
719: CY_GO(vm->um_addr);
720: if ((dp = vm->um_tab.b_actf) == NULL) {
721: dlog((LOG_ERR, "cy%d: stray interrupt", vm->um_ctlr));
722: return;
723: }
724: bp = dp->b_actf;
725: cy = &cy_softc[cyunit];
726: cyuncachetpb(cy);
727: yc = &yc_softc[YCUNIT(bp->b_dev)];
728: /*
729: * If last command was a rewind and tape is
730: * still moving, wait for the operation to complete.
731: */
732: if (vm->um_tab.b_active == SREW) {
733: vm->um_tab.b_active = SCOM;
734: if ((cy->cy_tpb.tpstatus&CYS_RDY) == 0) {
735: yc->yc_timo = 5*60; /* 5 minutes */
736: return;
737: }
738: }
739: /*
740: * An operation completed...record status.
741: */
742: yc->yc_timo = INF;
743: yc->yc_control = cy->cy_tpb.tpcontrol;
744: yc->yc_status = cy->cy_tpb.tpstatus;
745: yc->yc_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount);
746: dlog((LOG_INFO, "cmd %x control %b status %b resid %d\n",
747: cy->cy_tpb.tpcmd, yc->yc_control, CYCW_BITS,
748: yc->yc_status, CYS_BITS, yc->yc_resid));
749: if ((bp->b_flags&B_READ) == 0)
750: yc->yc_lastiow = 1;
751: state = vm->um_tab.b_active;
752: vm->um_tab.b_active = 0;
753: /*
754: * Check for errors.
755: */
756: if (cy->cy_tpb.tpstatus&CYS_ERR) {
757: err = cy->cy_tpb.tpstatus&CYS_ERR;
758: dlog((LOG_INFO, "error %d\n", err));
759: /*
760: * If we hit the end of tape file, update our position.
761: */
762: if (err == CYER_FM) {
763: yc->yc_status |= CYS_FM;
764: state = SCOM; /* force completion */
765: cyseteof(bp); /* set blkno and nxrec */
766: goto opdone;
767: }
768: /*
769: * Fix up errors which occur due to backspacing over
770: * the beginning of the tape.
771: */
772: if (err == CYER_BOT && cy->cy_tpb.tpcontrol&CYCW_REV) {
773: yc->yc_status |= CYS_BOT;
774: goto ignoreerr;
775: }
776: /*
777: * If we were reading raw tape and the only error was that the
778: * record was too long, then we don't consider this an error.
779: */
780: if ((bp->b_flags & (B_READ|B_RAW)) == (B_READ|B_RAW) &&
781: err == CYER_STROBE) {
782: /*
783: * Retry reads with the command changed to
784: * a raw read if necessary. Setting b_errcnt
785: * here causes cystart (above) to force a CY_RCOM.
786: */
787: if (cy->cy_tpb.tpcmd == CY_BRCOM &&
788: vm->um_tab.b_errcnt++ == 0) {
789: yc->yc_blkno++;
790: goto opcont;
791: } else
792: goto ignoreerr;
793: }
794: /*
795: * If error is not hard, and this was an i/o operation
796: * retry up to 8 times.
797: */
798: if (state == SIO && (CYMASK(err) &
799: ((bp->b_flags&B_READ) ? CYER_RSOFT : CYER_WSOFT))) {
800: if (++vm->um_tab.b_errcnt < 7) {
801: yc->yc_blkno++;
802: goto opcont;
803: }
804: } else
805: /*
806: * Hard or non-i/o errors on non-raw tape
807: * cause it to close.
808: */
809: if ((bp->b_flags&B_RAW) == 0 &&
810: yc->yc_openf > 0)
811: yc->yc_openf = -1;
812: /*
813: * Couldn't recover from error.
814: */
815: tprintf(yc->yc_tpr,
816: "yc%d: hard error bn%d status=%b, %s\n", YCUNIT(bp->b_dev),
817: bp->b_blkno, yc->yc_status, CYS_BITS,
818: (err < NCYERROR) ? cyerror[err] : "");
819: bp->b_flags |= B_ERROR;
820: goto opdone;
821: } else if (cy->cy_tpb.tpcmd == CY_BRCOM) {
822: int reclen = htoms(cy->cy_tpb.tprec);
823:
824: /*
825: * If we did a buffered read, check whether the read
826: * was long enough. If we asked the controller for less
827: * than the user asked for because the previous record
828: * was shorter, update our notion of record size
829: * and retry. If the record is longer than the buffer,
830: * bump the errcnt so the retry will use direct read.
831: */
832: if (reclen > yc->yc_blksize && bp->b_bcount > yc->yc_blksize) {
833: yc->yc_blksize = reclen;
834: if (reclen > cy->cy_bs)
835: vm->um_tab.b_errcnt++;
836: yc->yc_blkno++;
837: goto opcont;
838: }
839: }
840: /*
841: * Advance tape control FSM.
842: */
843: ignoreerr:
844: /*
845: * If we hit a tape mark update our position.
846: */
847: if (yc->yc_status&CYS_FM && bp->b_flags&B_READ) {
848: cyseteof(bp);
849: goto opdone;
850: }
851: switch (state) {
852:
853: case SIO:
854: /*
855: * Read/write increments tape block number.
856: */
857: yc->yc_blkno++;
858: yc->yc_blks++;
859: if (vm->um_tab.b_errcnt || yc->yc_status & CYS_CR)
860: yc->yc_softerrs++;
861: yc->yc_blksize = htoms(cy->cy_tpb.tpcount);
862: dlog((LOG_ERR, "blocksize %d", yc->yc_blksize));
863: goto opdone;
864:
865: case SCOM:
866: /*
867: * For forward/backward space record update current position.
868: */
869: if (bp == &ccybuf[CYUNIT(bp->b_dev)])
870: switch ((int)bp->b_command) {
871:
872: case CY_SFORW:
873: yc->yc_blkno -= bp->b_repcnt;
874: break;
875:
876: case CY_SREV:
877: yc->yc_blkno += bp->b_repcnt;
878: break;
879: }
880: goto opdone;
881:
882: case SSEEK:
883: yc->yc_blkno = bp->b_blkno;
884: goto opcont;
885:
886: case SERASE:
887: /*
888: * Completed erase of the inter-record gap due to a
889: * write error; now retry the write operation.
890: */
891: vm->um_tab.b_active = SERASED;
892: goto opcont;
893: }
894:
895: opdone:
896: /*
897: * Reset error count and remove from device queue.
898: */
899: vm->um_tab.b_errcnt = 0;
900: dp->b_actf = bp->av_forw;
901: /*
902: * Save resid and release resources.
903: */
904: bp->b_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount);
905: if (bp != &ccybuf[cyunit])
906: vbadone(bp, &cy->cy_rbuf);
907: biodone(bp);
908: /*
909: * Circulate slave to end of controller
910: * queue to give other slaves a chance.
911: */
912: vm->um_tab.b_actf = dp->b_forw;
913: if (dp->b_actf) {
914: dp->b_forw = NULL;
915: if (vm->um_tab.b_actf == NULL)
916: vm->um_tab.b_actf = dp;
917: else
918: vm->um_tab.b_actl->b_forw = dp;
919: }
920: if (vm->um_tab.b_actf == 0)
921: return;
922: opcont:
923: cystart(vm);
924: }
925:
926: cytimer(dev)
927: int dev;
928: {
929: register struct yc_softc *yc = &yc_softc[YCUNIT(dev)];
930: int s;
931:
932: if (yc->yc_openf == 0 && yc->yc_timo == INF) {
933: yc->yc_tact = 0;
934: return;
935: }
936: if (yc->yc_timo != INF && (yc->yc_timo -= 5) < 0) {
937: printf("yc%d: lost interrupt\n", YCUNIT(dev));
938: yc->yc_timo = INF;
939: s = spl3();
940: cyintr(CYUNIT(dev));
941: splx(s);
942: }
943: timeout(cytimer, (caddr_t)dev, 5*hz);
944: }
945:
946: cyseteof(bp)
947: register struct buf *bp;
948: {
949: register int cyunit = CYUNIT(bp->b_dev);
950: register struct cy_softc *cy = &cy_softc[cyunit];
951: register struct yc_softc *yc = &yc_softc[YCUNIT(bp->b_dev)];
952:
953: if (bp == &ccybuf[cyunit]) {
954: if (yc->yc_blkno > bp->b_blkno) {
955: /* reversing */
956: yc->yc_nxrec = bp->b_blkno - htoms(cy->cy_tpb.tpcount);
957: yc->yc_blkno = yc->yc_nxrec;
958: } else {
959: yc->yc_blkno = bp->b_blkno + htoms(cy->cy_tpb.tpcount);
960: yc->yc_nxrec = yc->yc_blkno - 1;
961: }
962: return;
963: }
964: /* eof on read */
965: yc->yc_nxrec = bp->b_blkno;
966: }
967:
968: /*ARGSUSED*/
969: cyioctl(dev, cmd, data, flag)
970: caddr_t data;
971: dev_t dev;
972: {
973: int ycunit = YCUNIT(dev);
974: register struct yc_softc *yc = &yc_softc[ycunit];
975: register struct buf *bp = &ccybuf[CYUNIT(dev)];
976: register callcount;
977: int fcount, op;
978: struct mtop *mtop;
979: struct mtget *mtget;
980: /* we depend of the values and order of the MT codes here */
981: static cyops[] =
982: {CY_WEOF,CY_FSF,CY_BSF,CY_SFORW,CY_SREV,CY_REW,CY_OFFL,CY_SENSE};
983:
984: switch (cmd) {
985:
986: case MTIOCTOP: /* tape operation */
987: mtop = (struct mtop *)data;
988: switch (op = mtop->mt_op) {
989:
990: case MTWEOF:
991: callcount = mtop->mt_count;
992: fcount = 1;
993: break;
994:
995: case MTFSR: case MTBSR:
996: callcount = 1;
997: fcount = mtop->mt_count;
998: break;
999:
1000: case MTFSF: case MTBSF:
1001: callcount = mtop->mt_count;
1002: fcount = 1;
1003: break;
1004:
1005: case MTREW: case MTOFFL: case MTNOP:
1006: callcount = 1;
1007: fcount = 1;
1008: break;
1009:
1010: default:
1011: return (ENXIO);
1012: }
1013: if (callcount <= 0 || fcount <= 0)
1014: return (EINVAL);
1015: while (--callcount >= 0) {
1016: #ifdef notdef
1017: /*
1018: * Gagh, this controller is the pits...
1019: */
1020: if (op == MTFSF || op == MTBSF) {
1021: do
1022: cycommand(dev, cyops[op], 1);
1023: while ((bp->b_flags&B_ERROR) == 0 &&
1024: (yc->yc_status&(CYS_EOT|CYS_BOT|CYS_FM)) == 0);
1025: } else
1026: #endif
1027: cycommand(dev, cyops[op], fcount);
1028: dlog((LOG_INFO,
1029: "cyioctl: status %x, b_flags %x, resid %d\n",
1030: yc->yc_status, bp->b_flags, bp->b_resid));
1031: if ((bp->b_flags&B_ERROR) ||
1032: (yc->yc_status&(CYS_BOT|CYS_EOT)))
1033: break;
1034: }
1035: bp->b_resid = callcount + 1;
1036: /*
1037: * Pick up the device's error number and pass it
1038: * to the user; if there is an error but the number
1039: * is 0 set a generalized code.
1040: */
1041: if ((bp->b_flags & B_ERROR) == 0)
1042: return (0);
1043: if (bp->b_error)
1044: return (bp->b_error);
1045: return (EIO);
1046:
1047: case MTIOCGET:
1048: cycommand(dev, CY_SENSE, 1);
1049: mtget = (struct mtget *)data;
1050: mtget->mt_dsreg = yc->yc_status;
1051: mtget->mt_erreg = yc->yc_control;
1052: mtget->mt_resid = yc->yc_resid;
1053: mtget->mt_type = MT_ISCY;
1054: break;
1055:
1056: default:
1057: return (ENXIO);
1058: }
1059: return (0);
1060: }
1061:
1062: /*
1063: * Poll until the controller is ready.
1064: */
1065: cywait(cp)
1066: register struct cyccb *cp;
1067: {
1068: register int i = 5000;
1069:
1070: uncache(&cp->cbgate);
1071: while (i-- > 0 && cp->cbgate == GATE_CLOSED) {
1072: DELAY(1000);
1073: uncache(&cp->cbgate);
1074: }
1075: return (i <= 0);
1076: }
1077:
1078: /*
1079: * Load a 20 bit pointer into a Tapemaster pointer.
1080: */
1081: cyldmba(reg, value)
1082: register u_char *reg;
1083: caddr_t value;
1084: {
1085: register int v = (int)value;
1086:
1087: *reg++ = v;
1088: *reg++ = v >> 8;
1089: *reg++ = 0;
1090: *reg = (v&0xf0000) >> 12;
1091: }
1092:
1093: /*
1094: * Unconditionally reset all controllers to their initial state.
1095: */
1096: cyreset(vba)
1097: int vba;
1098: {
1099: register caddr_t addr;
1100: register int ctlr;
1101:
1102: for (ctlr = 0; ctlr < NCY; ctlr++)
1103: if (cyminfo[ctlr] && cyminfo[ctlr]->um_vbanum == vba) {
1104: addr = cyminfo[ctlr]->um_addr;
1105: CY_RESET(addr);
1106: if (!cyinit(ctlr, addr)) {
1107: printf("cy%d: reset failed\n", ctlr);
1108: cyminfo[ctlr] = NULL;
1109: }
1110: }
1111: }
1112:
1113: cyuncachetpb(cy)
1114: struct cy_softc *cy;
1115: {
1116: register long *lp = (long *)&cy->cy_tpb;
1117: register int i;
1118:
1119: for (i = 0; i < howmany(sizeof (struct cytpb), sizeof (long)); i++)
1120: uncache(lp++);
1121: }
1122:
1123: /*
1124: * Dump routine.
1125: */
1126: #define DUMPREC (32*1024)
1127: cydump(dev)
1128: dev_t dev;
1129: {
1130: register struct cy_softc *cy;
1131: register int bs, num, start;
1132: register caddr_t addr;
1133: int unit = CYUNIT(dev), error;
1134:
1135: if (unit >= NCY || cyminfo[unit] == 0 ||
1136: (cy = &cy_softc[unit])->cy_bs == 0 || YCUNIT(dev) >= NYC)
1137: return (ENXIO);
1138: if (cywait(&cy->cy_ccb))
1139: return (EFAULT);
1140: #define phys(a) ((caddr_t)((int)(a)&~0xc0000000))
1141: addr = phys(cyminfo[unit]->um_addr);
1142: num = maxfree, start = NBPG*2;
1143: while (num > 0) {
1144: bs = num > btoc(DUMPREC) ? btoc(DUMPREC) : num;
1145: error = cydwrite(cy, start, bs, addr);
1146: if (error)
1147: return (error);
1148: start += bs, num -= bs;
1149: }
1150: cyweof(cy, addr);
1151: cyweof(cy, addr);
1152: uncache(&cy->cy_tpb);
1153: if (cy->cy_tpb.tpstatus&CYS_ERR)
1154: return (EIO);
1155: cyrewind(cy, addr);
1156: return (0);
1157: }
1158:
1159: cydwrite(cy, pf, npf, addr)
1160: register struct cy_softc *cy;
1161: int pf, npf;
1162: caddr_t addr;
1163: {
1164:
1165: cy->cy_tpb.tpcmd = CY_WCOM;
1166: cy->cy_tpb.tpcontrol = CYCW_LOCK|CYCW_25IPS|CYCW_16BITS;
1167: cy->cy_tpb.tpstatus = 0;
1168: cy->cy_tpb.tpsize = htoms(npf*NBPG);
1169: cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
1170: cyldmba(cy->cy_tpb.tpdata, (caddr_t)(pf*NBPG));
1171: cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
1172: cy->cy_ccb.cbgate = GATE_CLOSED;
1173: CY_GO(addr);
1174: if (cywait(&cy->cy_ccb))
1175: return (EFAULT);
1176: uncache(&cy->cy_tpb);
1177: if (cy->cy_tpb.tpstatus&CYS_ERR)
1178: return (EIO);
1179: return (0);
1180: }
1181:
1182: cyweof(cy, addr)
1183: register struct cy_softc *cy;
1184: caddr_t addr;
1185: {
1186:
1187: cy->cy_tpb.tpcmd = CY_WEOF;
1188: cy->cy_tpb.tpcount = htoms(1);
1189: cy->cy_ccb.cbgate = GATE_CLOSED;
1190: CY_GO(addr);
1191: (void) cywait(&cy->cy_ccb);
1192: }
1193:
1194: cyrewind(cy, addr)
1195: register struct cy_softc *cy;
1196: caddr_t addr;
1197: {
1198:
1199: cy->cy_tpb.tpcmd = CY_REW;
1200: cy->cy_tpb.tpcount = htoms(1);
1201: cy->cy_ccb.cbgate = GATE_CLOSED;
1202: CY_GO(addr);
1203: (void) cywait(&cy->cy_ccb);
1204: }
1205: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.