![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ct.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev|
Return to ct.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hpdev |
1.1 root 1: /*
2: * Copyright (c) 1982, 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)ct.c 7.1 (Berkeley) 5/8/90
21: */
22:
23: #include "ct.h"
24: #if NCT > 0
25: /*
26: * CS80 cartridge tape driver (9144, 88140, 9145)
27: *
28: * Reminder:
29: * C_CC bit (character count option) when used in the CS/80 command
30: * 'set options' will cause the tape not to stream.
31: *
32: * TODO:
33: * make filesystem compatible
34: * make block mode work according to mtio(4) spec. (if possible)
35: * merge with cs80 disk driver
36: * finish support of 9145
37: */
38:
39: #include "param.h"
40: #include "buf.h"
41: #include "ioctl.h"
42: #include "mtio.h"
43: #include "errno.h"
44: #include "ctreg.h"
45: #include "device.h"
46: #include "user.h"
47: #include "tty.h"
48: #include "proc.h"
49:
50: /* number of eof marks to remember */
51: #define EOFS 128
52:
53: int ctinit(), ctstart(), ctgo(), ctintr();
54: struct driver ctdriver = {
55: ctinit, "ct", ctstart, ctgo, ctintr,
56: };
57:
58: struct ct_softc {
59: struct hp_device *sc_hd;
60: struct ct_iocmd sc_ioc;
61: struct ct_rscmd sc_rsc;
62: struct ct_stat sc_stat;
63: struct ct_ssmcmd sc_ssmc;
64: struct ct_srcmd sc_src;
65: struct ct_soptcmd sc_soptc;
66: struct ct_ulcmd sc_ul;
67: struct ct_wfmcmd sc_wfm;
68: struct ct_clearcmd sc_clear;
69: struct buf *sc_bp;
70: int sc_blkno;
71: int sc_cmd;
72: int sc_resid;
73: char *sc_addr;
74: int sc_flags;
75: short sc_type;
76: short sc_punit;
77: caddr_t sc_ctty;
78: struct devqueue sc_dq;
79: int sc_eofp;
80: int sc_eofs[EOFS];
81: } ct_softc[NCT];
82:
83: /* flags */
84: #define CTF_OPEN 0x01
85: #define CTF_ALIVE 0x02
86: #define CTF_WRT 0x04
87: #define CTF_CMD 0x08
88: #define CTF_IO 0x10
89: #define CTF_BEOF 0x20
90: #define CTF_AEOF 0x40
91: #define CTF_EOT 0x80
92: #define CTF_STATWAIT 0x100
93: #define CTF_CANSTREAM 0x200
94: #define CTF_WRTTN 0x400
95:
96: struct ctinfo {
97: short hwid;
98: short punit;
99: char *desc;
100: } ctinfo[] = {
101: CT7946ID, 1, "7946A",
102: CT7912PID, 1, "7912P",
103: CT7914PID, 1, "7914P",
104: CT9144ID, 0, "9144",
105: CT9145ID, 0, "9145",
106: };
107: int nctinfo = sizeof(ctinfo) / sizeof(ctinfo[0]);
108:
109: struct buf cttab[NCT];
110: struct buf ctbuf[NCT];
111:
112: #define CT_NOREW 4
113: #define CT_STREAM 8
114: #define UNIT(x) (minor(x) & 3)
115: #define ctpunit(x) ((x) & 7)
116:
117: #ifdef DEBUG
118: int ctdebug = 0;
119: #define CDB_FILES 0x01
120: #define CT_BSF 0x02
121: #endif
122:
123: ctinit(hd)
124: register struct hp_device *hd;
125: {
126: register struct ct_softc *sc = &ct_softc[hd->hp_unit];
127:
128: sc->sc_hd = hd;
129: sc->sc_punit = ctpunit(hd->hp_flags);
130: if (ctident(sc, hd) < 0)
131: return(0);
132: ctreset(sc, hd);
133: sc->sc_dq.dq_ctlr = hd->hp_ctlr;
134: sc->sc_dq.dq_unit = hd->hp_unit;
135: sc->sc_dq.dq_slave = hd->hp_slave;
136: sc->sc_dq.dq_driver = &ctdriver;
137: sc->sc_flags |= CTF_ALIVE;
138: return(1);
139: }
140:
141: ctident(sc, hd)
142: register struct ct_softc *sc;
143: register struct hp_device *hd;
144: {
145: struct ct_describe desc;
146: u_char stat, cmd[3];
147: char name[7];
148: int id, i;
149:
150: /*
151: * Read device id and verify that:
152: * 1. It is a CS80 device
153: * 2. It is one of our recognized tape devices
154: * 3. It has the proper physical unit number
155: */
156: id = hpibid(hd->hp_ctlr, hd->hp_slave);
157: if ((id & 0x200) == 0)
158: return(-1);
159: for (i = 0; i < nctinfo; i++)
160: if (id == ctinfo[i].hwid)
161: break;
162: if (i == nctinfo || sc->sc_punit != ctinfo[i].punit)
163: return(-1);
164: id = i;
165:
166: /*
167: * Collect device description.
168: * Right now we only need this to differentiate 7945 from 7946.
169: * Note that we always issue the describe command to unit 0.
170: */
171: cmd[0] = C_SUNIT(0);
172: cmd[1] = C_SVOL(0);
173: cmd[2] = C_DESC;
174: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, cmd, sizeof(cmd));
175: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_EXEC, &desc, 37);
176: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat));
177: bzero(name, sizeof(name));
178: if (!stat) {
179: register int n = desc.d_name;
180: for (i = 5; i >= 0; i--) {
181: name[i] = (n & 0xf) + '0';
182: n >>= 4;
183: }
184: }
185: switch (ctinfo[id].hwid) {
186: case CT7946ID:
187: if (bcmp(name, "079450", 6) == 0)
188: return(-1); /* not really a 7946 */
189: /* fall into... */
190: case CT9144ID:
191: case CT9145ID:
192: sc->sc_type = CT9144;
193: sc->sc_flags |= CTF_CANSTREAM;
194: break;
195:
196: case CT7912PID:
197: case CT7914PID:
198: sc->sc_type = CT88140;
199: break;
200: }
201: printf("ct%d: %s %stape\n", hd->hp_unit, ctinfo[id].desc,
202: (sc->sc_flags & CTF_CANSTREAM) ? "streaming " : " ");
203: return(id);
204: }
205:
206: ctreset(sc, hd)
207: register struct ct_softc *sc;
208: register struct hp_device *hd;
209: {
210: u_char stat;
211:
212: sc->sc_clear.unit = C_SUNIT(sc->sc_punit);
213: sc->sc_clear.cmd = C_CLEAR;
214: hpibsend(hd->hp_ctlr, hd->hp_slave, C_TCMD, &sc->sc_clear,
215: sizeof(sc->sc_clear));
216: hpibswait(hd->hp_ctlr, hd->hp_slave);
217: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat));
218: sc->sc_src.unit = C_SUNIT(CTCTLR);
219: sc->sc_src.nop = C_NOP;
220: sc->sc_src.cmd = C_SREL;
221: sc->sc_src.param = C_REL;
222: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_src,
223: sizeof(sc->sc_src));
224: hpibswait(hd->hp_ctlr, hd->hp_slave);
225: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat));
226: sc->sc_ssmc.unit = C_SUNIT(sc->sc_punit);
227: sc->sc_ssmc.cmd = C_SSM;
228: sc->sc_ssmc.refm = REF_MASK;
229: sc->sc_ssmc.fefm = FEF_MASK;
230: sc->sc_ssmc.aefm = AEF_MASK;
231: sc->sc_ssmc.iefm = IEF_MASK;
232: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_ssmc,
233: sizeof(sc->sc_ssmc));
234: hpibswait(hd->hp_ctlr, hd->hp_slave);
235: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat));
236: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit);
237: sc->sc_soptc.nop = C_NOP;
238: sc->sc_soptc.cmd = C_SOPT;
239: sc->sc_soptc.opt = C_SPAR;
240: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_soptc,
241: sizeof(sc->sc_soptc));
242: hpibswait(hd->hp_ctlr, hd->hp_slave);
243: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat));
244: }
245:
246: /*ARGSUSED*/
247: ctopen(dev, flag)
248: dev_t dev;
249: {
250: register struct ct_softc *sc = &ct_softc[UNIT(dev)];
251: u_char stat;
252: int cc;
253:
254: if (UNIT(dev) >= NCT || (sc->sc_flags & CTF_ALIVE) == 0)
255: return(ENXIO);
256: if (sc->sc_flags & CTF_OPEN)
257: return(EBUSY);
258: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit);
259: sc->sc_soptc.nop = C_NOP;
260: sc->sc_soptc.cmd = C_SOPT;
261: if ((dev & CT_STREAM) && (sc->sc_flags & CTF_CANSTREAM))
262: sc->sc_soptc.opt = C_SPAR | C_IMRPT;
263: else
264: sc->sc_soptc.opt = C_SPAR;
265: /*
266: * Check the return of hpibsend() and hpibswait().
267: * Drive could be loading/unloading a tape. If not checked,
268: * driver hangs.
269: */
270: cc = hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave,
271: C_CMD, &sc->sc_soptc, sizeof(sc->sc_soptc));
272: if (cc != sizeof(sc->sc_soptc))
273: return(EBUSY);
274: hpibswait(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave);
275: cc = hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT,
276: &stat, sizeof(stat));
277: if (cc != sizeof(stat))
278: return(EBUSY);
279: sc->sc_ctty = (caddr_t)(u.u_procp->p_flag&SCTTY ?
280: u.u_procp->p_session->s_ttyvp : 0);
281: sc->sc_flags |= CTF_OPEN;
282: return(0);
283: }
284:
285: /*ARGSUSED*/
286: ctclose(dev, flag)
287: dev_t dev;
288: {
289: register struct ct_softc *sc = &ct_softc[UNIT(dev)];
290:
291: if ((sc->sc_flags & (CTF_WRT|CTF_WRTTN)) == (CTF_WRT|CTF_WRTTN) &&
292: (sc->sc_flags & CTF_EOT) == 0 ) { /* XXX return error if EOT ?? */
293: ctcommand(dev, MTWEOF, 2);
294: ctcommand(dev, MTBSR, 1);
295: if (sc->sc_eofp == EOFS - 1)
296: sc->sc_eofs[EOFS - 1]--;
297: else
298: sc->sc_eofp--;
299: #ifdef DEBUG
300: if(ctdebug & CT_BSF)
301: printf("ct%d: ctclose backup eofs prt %d blk %d\n",
302: UNIT(dev), sc->sc_eofp, sc->sc_eofs[sc->sc_eofp]);
303: #endif
304: }
305: if ((minor(dev) & CT_NOREW) == 0)
306: ctcommand(dev, MTREW, 1);
307: sc->sc_flags &= ~(CTF_OPEN | CTF_WRT | CTF_WRTTN);
308: sc->sc_ctty = NULL;
309: #ifdef DEBUG
310: if (ctdebug & CDB_FILES)
311: printf("ctclose: flags %x\n", sc->sc_flags);
312: #endif
313: return(0); /* XXX */
314: }
315:
316: ctcommand(dev, cmd, cnt)
317: dev_t dev;
318: register int cnt;
319: {
320: register struct ct_softc *sc = &ct_softc[UNIT(dev)];
321: register struct buf *bp = &ctbuf[UNIT(dev)];
322: register struct buf *nbp = 0;
323:
324: if (cmd == MTBSF && sc->sc_eofp == EOFS - 1) {
325: cnt = sc->sc_eofs[EOFS - 1] - cnt;
326: ctcommand(dev, MTREW, 1);
327: ctcommand(dev, MTFSF, cnt);
328: cnt = 2;
329: cmd = MTBSR;
330: }
331:
332: if (cmd == MTBSF && sc->sc_eofp - cnt < 0) {
333: cnt = 1;
334: cmd = MTREW;
335: }
336:
337: sc->sc_flags |= CTF_CMD;
338: sc->sc_bp = bp;
339: sc->sc_cmd = cmd;
340: bp->b_dev = dev;
341: if (cmd == MTFSF) {
342: nbp = (struct buf *)geteblk(MAXBSIZE);
343: bp->b_un.b_addr = nbp->b_un.b_addr;
344: bp->b_bcount = MAXBSIZE;
345: }
346: again:
347: bp->b_flags = B_BUSY;
348: if (cmd == MTBSF) {
349: sc->sc_blkno = sc->sc_eofs[sc->sc_eofp];
350: sc->sc_eofp--;
351: #ifdef DEBUG
352: if (ctdebug & CT_BSF)
353: printf("ct%d: backup eof pos %d blk %d\n",
354: UNIT(dev), sc->sc_eofp,
355: sc->sc_eofs[sc->sc_eofp]);
356: #endif
357: }
358: ctstrategy(bp);
359: iowait(bp);
360: if (--cnt > 0)
361: goto again;
362: bp->b_flags = 0;
363: sc->sc_flags &= ~CTF_CMD;
364: if (nbp)
365: brelse(nbp);
366: }
367:
368: ctstrategy(bp)
369: register struct buf *bp;
370: {
371: register struct buf *dp;
372: register int s, unit;
373:
374: unit = UNIT(bp->b_dev);
375: dp = &cttab[unit];
376: bp->av_forw = NULL;
377: s = splbio();
378: if (dp->b_actf == NULL)
379: dp->b_actf = bp;
380: else
381: dp->b_actl->av_forw = bp;
382: dp->b_actl = bp;
383: if (dp->b_active == 0) {
384: dp->b_active = 1;
385: ctustart(unit);
386: }
387: splx(s);
388: }
389:
390: ctustart(unit)
391: register int unit;
392: {
393: register struct ct_softc *sc = &ct_softc[unit];
394: register struct buf *bp;
395:
396: bp = cttab[unit].b_actf;
397: sc->sc_addr = bp->b_un.b_addr;
398: sc->sc_resid = bp->b_bcount;
399: if (hpibreq(&sc->sc_dq))
400: ctstart(unit);
401: }
402:
403: ctstart(unit)
404: register int unit;
405: {
406: register struct ct_softc *sc = &ct_softc[unit];
407: register struct buf *bp;
408: register int i;
409:
410: bp = cttab[unit].b_actf;
411: again:
412: if ((sc->sc_flags & CTF_CMD) && sc->sc_bp == bp) {
413: switch(sc->sc_cmd) {
414:
415: case MTFSF:
416: bp->b_flags |= B_READ;
417: goto mustio;
418:
419: case MTBSF:
420: goto gotaddr;
421:
422: case MTOFFL:
423: sc->sc_blkno = 0;
424: sc->sc_ul.unit = C_SUNIT(sc->sc_punit);
425: sc->sc_ul.cmd = C_UNLOAD;
426: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave,
427: C_CMD, &sc->sc_ul, sizeof(sc->sc_ul));
428: break;
429:
430: case MTWEOF:
431: sc->sc_blkno++;
432: sc->sc_flags |= CTF_WRT;
433: sc->sc_wfm.unit = C_SUNIT(sc->sc_punit);
434: sc->sc_wfm.cmd = C_WFM;
435: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave,
436: C_CMD, &sc->sc_wfm, sizeof(sc->sc_wfm));
437: ctaddeof(unit);
438: break;
439:
440: case MTBSR:
441: sc->sc_blkno--;
442: goto gotaddr;
443:
444: case MTFSR:
445: sc->sc_blkno++;
446: goto gotaddr;
447:
448: case MTREW:
449: sc->sc_blkno = 0;
450: #ifdef DEBUG
451: if(ctdebug & CT_BSF)
452: printf("ct%d: clearing eofs\n", unit);
453: #endif
454: for (i=0; i<EOFS; i++)
455: sc->sc_eofs[i] = 0;
456: sc->sc_eofp = 0;
457:
458: gotaddr:
459: sc->sc_ioc.saddr = C_SADDR;
460: sc->sc_ioc.addr0 = 0;
461: sc->sc_ioc.addr = sc->sc_blkno;
462: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit);
463: sc->sc_ioc.nop2 = C_NOP;
464: sc->sc_ioc.slen = C_SLEN;
465: sc->sc_ioc.len = 0;
466: sc->sc_ioc.nop3 = C_NOP;
467: sc->sc_ioc.cmd = C_READ;
468: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave,
469: C_CMD, &sc->sc_ioc, sizeof(sc->sc_ioc));
470: break;
471: }
472: }
473: else {
474: mustio:
475: if ((bp->b_flags & B_READ) &&
476: sc->sc_flags & (CTF_BEOF|CTF_EOT)) {
477: #ifdef DEBUG
478: if (ctdebug & CDB_FILES)
479: printf("ctstart: before flags %x\n", sc->sc_flags);
480: #endif
481: if (sc->sc_flags & CTF_BEOF) {
482: sc->sc_flags &= ~CTF_BEOF;
483: sc->sc_flags |= CTF_AEOF;
484: #ifdef DEBUG
485: if (ctdebug & CDB_FILES)
486: printf("ctstart: after flags %x\n", sc->sc_flags);
487: #endif
488: }
489: bp->b_resid = bp->b_bcount;
490: iodone(bp);
491: hpibfree(&sc->sc_dq);
492: cttab[unit].b_actf = bp = bp->av_forw;
493: if (bp == NULL) {
494: cttab[unit].b_active = 0;
495: return;
496: }
497: sc->sc_addr = bp->b_un.b_addr;
498: sc->sc_resid = bp->b_bcount;
499: if (hpibreq(&sc->sc_dq))
500: goto again;
501: return;
502: }
503: sc->sc_flags |= CTF_IO;
504: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit);
505: sc->sc_ioc.saddr = C_SADDR;
506: sc->sc_ioc.addr0 = 0;
507: sc->sc_ioc.addr = sc->sc_blkno;
508: sc->sc_ioc.nop2 = C_NOP;
509: sc->sc_ioc.slen = C_SLEN;
510: sc->sc_ioc.len = sc->sc_resid;
511: sc->sc_ioc.nop3 = C_NOP;
512: if (bp->b_flags & B_READ)
513: sc->sc_ioc.cmd = C_READ;
514: else {
515: sc->sc_ioc.cmd = C_WRITE;
516: sc->sc_flags |= (CTF_WRT | CTF_WRTTN);
517: }
518: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_CMD,
519: &sc->sc_ioc, sizeof(sc->sc_ioc));
520: }
521: hpibawait(sc->sc_hd->hp_ctlr);
522: }
523:
524: ctgo(unit)
525: register int unit;
526: {
527: register struct ct_softc *sc = &ct_softc[unit];
528: register struct buf *bp;
529:
530: bp = cttab[unit].b_actf;
531: hpibgo(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_EXEC,
532: sc->sc_addr, sc->sc_resid, bp->b_flags & B_READ);
533: }
534:
535: /*
536: * Hideous grue to handle EOF/EOT (mostly for reads)
537: */
538: cteof(sc, bp)
539: register struct ct_softc *sc;
540: register struct buf *bp;
541: {
542: long blks;
543:
544: /*
545: * EOT on a write is an error.
546: */
547: if ((bp->b_flags & B_READ) == 0) {
548: bp->b_resid = bp->b_bcount;
549: bp->b_flags |= B_ERROR;
550: bp->b_error = ENOSPC;
551: sc->sc_flags |= CTF_EOT;
552: return;
553: }
554: /*
555: * Use returned block position to determine how many blocks
556: * we really read and update b_resid.
557: */
558: blks = sc->sc_stat.c_blk - sc->sc_blkno - 1;
559: #ifdef DEBUG
560: if (ctdebug & CDB_FILES)
561: printf("cteof: bc %d oblk %d nblk %d read %d, resid %d\n",
562: bp->b_bcount, sc->sc_blkno, sc->sc_stat.c_blk,
563: blks, bp->b_bcount - CTKTOB(blks));
564: #endif
565: if (blks == -1) { /* 9145 on EOF does not change sc_stat.c_blk */
566: blks = 0;
567: sc->sc_blkno++;
568: }
569: else {
570: sc->sc_blkno = sc->sc_stat.c_blk;
571: }
572: bp->b_resid = bp->b_bcount - CTKTOB(blks);
573: /*
574: * If we are at physical EOV or were after an EOF,
575: * we are now at logical EOT.
576: */
577: if ((sc->sc_stat.c_aef & AEF_EOV) ||
578: (sc->sc_flags & CTF_AEOF)) {
579: sc->sc_flags |= CTF_EOT;
580: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF);
581: }
582: /*
583: * If we were before an EOF or we have just completed a FSF,
584: * we are now after EOF.
585: */
586: else if ((sc->sc_flags & CTF_BEOF) ||
587: (sc->sc_flags & CTF_CMD) && sc->sc_cmd == MTFSF) {
588: sc->sc_flags |= CTF_AEOF;
589: sc->sc_flags &= ~CTF_BEOF;
590: }
591: /*
592: * Otherwise if we read something we are now before EOF
593: * (and no longer after EOF).
594: */
595: else if (blks) {
596: sc->sc_flags |= CTF_BEOF;
597: sc->sc_flags &= ~CTF_AEOF;
598: }
599: /*
600: * Finally, if we didn't read anything we just passed an EOF
601: */
602: else
603: sc->sc_flags |= CTF_AEOF;
604: #ifdef DEBUG
605: if (ctdebug & CDB_FILES)
606: printf("cteof: leaving flags %x\n", sc->sc_flags);
607: #endif
608: }
609:
610: ctintr(unit)
611: register int unit;
612: {
613: register struct ct_softc *sc = &ct_softc[unit];
614: register struct buf *bp;
615: u_char stat;
616:
617: bp = cttab[unit].b_actf;
618: if (bp == NULL) {
619: printf("ct%d: bp == NULL\n", unit);
620: return;
621: }
622: if (sc->sc_flags & CTF_IO) {
623: sc->sc_flags &= ~CTF_IO;
624: if (hpibustart(sc->sc_hd->hp_ctlr))
625: ctgo(unit);
626: return;
627: }
628: if ((sc->sc_flags & CTF_STATWAIT) == 0) {
629: if (hpibpptest(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave) == 0) {
630: sc->sc_flags |= CTF_STATWAIT;
631: hpibawait(sc->sc_hd->hp_ctlr);
632: return;
633: }
634: } else
635: sc->sc_flags &= ~CTF_STATWAIT;
636: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT, &stat, 1);
637: #ifdef DEBUG
638: if (ctdebug & CDB_FILES)
639: printf("ctintr: before flags %x\n", sc->sc_flags);
640: #endif
641: if (stat) {
642: sc->sc_rsc.unit = C_SUNIT(sc->sc_punit);
643: sc->sc_rsc.cmd = C_STATUS;
644: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_CMD,
645: &sc->sc_rsc, sizeof(sc->sc_rsc));
646: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_EXEC,
647: &sc->sc_stat, sizeof(sc->sc_stat));
648: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT,
649: &stat, 1);
650: #ifdef DEBUG
651: if (ctdebug & CDB_FILES)
652: printf("ctintr: return stat 0x%x, A%x F%x blk %d\n",
653: stat, sc->sc_stat.c_aef,
654: sc->sc_stat.c_fef, sc->sc_stat.c_blk);
655: #endif
656: if (stat == 0) {
657: if (sc->sc_stat.c_aef & (AEF_EOF | AEF_EOV)) {
658: cteof(sc, bp);
659: ctaddeof(unit);
660: goto done;
661: }
662: if (sc->sc_stat.c_fef & FEF_PF) {
663: ctreset(sc, sc->sc_hd);
664: ctstart(unit);
665: return;
666: }
667: if (sc->sc_stat.c_fef & FEF_REXMT) {
668: ctstart(unit);
669: return;
670: }
671: if (sc->sc_stat.c_aef & 0x5800) {
672: if (sc->sc_stat.c_aef & 0x4000)
673: tprintf(sc->sc_ctty,
674: "ct%d: uninitialized media\n",
675: unit);
676: if (sc->sc_stat.c_aef & 0x1000)
677: tprintf(sc->sc_ctty,
678: "ct%d: not ready\n", unit);
679: if (sc->sc_stat.c_aef & 0x0800)
680: tprintf(sc->sc_ctty,
681: "ct%d: write protect\n", unit);
682: } else {
683: printf("ct%d err: v%d u%d ru%d bn%d, ",
684: unit,
685: (sc->sc_stat.c_vu>>4)&0xF,
686: sc->sc_stat.c_vu&0xF,
687: sc->sc_stat.c_pend,
688: sc->sc_stat.c_blk);
689: printf("R0x%x F0x%x A0x%x I0x%x\n",
690: sc->sc_stat.c_ref,
691: sc->sc_stat.c_fef,
692: sc->sc_stat.c_aef,
693: sc->sc_stat.c_ief);
694: }
695: } else
696: printf("ct%d: request status failed\n", unit);
697: bp->b_flags |= B_ERROR;
698: bp->b_error = EIO;
699: goto done;
700: } else
701: bp->b_resid = 0;
702: if (sc->sc_flags & CTF_CMD) {
703: switch (sc->sc_cmd) {
704: case MTFSF:
705: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF);
706: sc->sc_blkno += CTBTOK(sc->sc_resid);
707: ctstart(unit);
708: return;
709: case MTBSF:
710: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF|CTF_EOT);
711: break;
712: case MTBSR:
713: sc->sc_flags &= ~CTF_BEOF;
714: if (sc->sc_flags & CTF_EOT) {
715: sc->sc_flags |= CTF_AEOF;
716: sc->sc_flags &= ~CTF_EOT;
717: } else if (sc->sc_flags & CTF_AEOF) {
718: sc->sc_flags |= CTF_BEOF;
719: sc->sc_flags &= ~CTF_AEOF;
720: }
721: break;
722: case MTWEOF:
723: sc->sc_flags &= ~CTF_BEOF;
724: if (sc->sc_flags & (CTF_AEOF|CTF_EOT)) {
725: sc->sc_flags |= CTF_EOT;
726: sc->sc_flags &= ~CTF_AEOF;
727: } else
728: sc->sc_flags |= CTF_AEOF;
729: break;
730: case MTREW:
731: case MTOFFL:
732: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF|CTF_EOT);
733: break;
734: }
735: } else {
736: sc->sc_flags &= ~CTF_AEOF;
737: sc->sc_blkno += CTBTOK(sc->sc_resid);
738: }
739: done:
740: #ifdef DEBUG
741: if (ctdebug & CDB_FILES)
742: printf("ctintr: after flags %x\n", sc->sc_flags);
743: #endif
744: cttab[unit].b_actf = bp->av_forw;
745: iodone(bp);
746: hpibfree(&sc->sc_dq);
747: if (cttab[unit].b_actf == NULL) {
748: cttab[unit].b_active = 0;
749: return;
750: }
751: ctustart(unit);
752: }
753:
754: ctread(dev, uio)
755: dev_t dev;
756: struct uio *uio;
757: {
758: register int unit = UNIT(dev);
759:
760: return(physio(ctstrategy, &ctbuf[unit], dev, B_READ, minphys, uio));
761: }
762:
763: ctwrite(dev, uio)
764: dev_t dev;
765: struct uio *uio;
766: {
767: register int unit = UNIT(dev);
768:
769: return(physio(ctstrategy, &ctbuf[unit], dev, B_WRITE, minphys, uio));
770: }
771:
772: /*ARGSUSED*/
773: ctioctl(dev, cmd, data, flag)
774: dev_t dev;
775: caddr_t data;
776: {
777: register struct mtop *op;
778: register int cnt;
779:
780: switch (cmd) {
781:
782: case MTIOCTOP:
783: op = (struct mtop *)data;
784: switch(op->mt_op) {
785:
786: case MTWEOF:
787: case MTFSF:
788: case MTBSR:
789: case MTBSF:
790: case MTFSR:
791: cnt = op->mt_count;
792: break;
793:
794: case MTREW:
795: case MTOFFL:
796: cnt = 1;
797: break;
798:
799: default:
800: return(EINVAL);
801: }
802: ctcommand(dev, op->mt_op, cnt);
803: break;
804:
805: case MTIOCGET:
806: break;
807:
808: default:
809: return(EINVAL);
810: }
811: return(0);
812: }
813:
814: /*ARGSUSED*/
815: ctdump(dev)
816: dev_t dev;
817: {
818: return(ENXIO);
819: }
820:
821: ctaddeof(unit)
822: int unit;
823: {
824: register struct ct_softc *sc = &ct_softc[unit];
825:
826: if (sc->sc_eofp == EOFS - 1)
827: sc->sc_eofs[EOFS - 1]++;
828: else {
829: sc->sc_eofp++;
830: if (sc->sc_eofp == EOFS - 1)
831: sc->sc_eofs[EOFS - 1] = EOFS;
832: else
833: /* save blkno */
834: sc->sc_eofs[sc->sc_eofp] = sc->sc_blkno - 1;
835: }
836: #ifdef DEBUG
837: if (ctdebug & CT_BSF)
838: printf("ct%d: add eof pos %d blk %d\n",
839: unit, sc->sc_eofp,
840: sc->sc_eofs[sc->sc_eofp]);
841: #endif
842: }
843: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.