![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to rl.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
1.1 root 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: * @(#)rl.c 7.1 (Berkeley) 6/5/86
7: */
8:
9: #include "rl.h"
10: #if NRL > 0
11: /*
12: * UNIBUS RL02 disk driver
13: */
14: #include "../machine/pte.h"
15:
16: #include "param.h"
17: #include "systm.h"
18: #include "dk.h"
19: #include "dkbad.h"
20: #include "buf.h"
21: #include "conf.h"
22: #include "dir.h"
23: #include "user.h"
24: #include "map.h"
25: #include "vm.h"
26: #include "cmap.h"
27: #include "uio.h"
28: #include "kernel.h"
29:
30: #include "../vax/cpu.h"
31: #include "../vax/nexus.h"
32: #include "ubavar.h"
33: #include "ubareg.h"
34: #include "rlreg.h"
35:
36: /* Pending Controller items and statistics */
37: struct rl_softc {
38: int rl_softas; /* Attention sumary, (seeks pending) */
39: int rl_ndrive; /* Number of drives on controller */
40: int rl_wticks; /* Monitor time for function */
41: } rl_softc[NHL];
42:
43: /*
44: * State of controller from last transfer.
45: * Since only one transfer can be done at a time per
46: * controller, only allocate one for each controller.
47: */
48: struct rl_stat {
49: short rl_cyl[4]; /* Current cylinder for each drive */
50: short rl_dn; /* drive number currently transferring */
51: short rl_cylnhd; /* current cylinder and head of transfer */
52: u_short rl_bleft; /* bytes left to transfer */
53: u_short rl_bpart; /* bytes transferred */
54: } rl_stat[NHL];
55:
56: #define rlunit(dev) (minor(dev) >> 3)
57:
58: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
59: /* Last cylinder not used. Saved for Bad Sector File */
60: struct size {
61: daddr_t nblocks;
62: int cyloff;
63: } rl02_sizes[8] = {
64: 15884, 0, /* A=cyl 0 thru 397 */
65: 4520, 398, /* B=cyl 398 thru 510 */
66: -1, 0, /* C=cyl 0 thru 511 */
67: 4520, 398, /* D=cyl 398 thru 510 */
68: 0, 0, /* E= Not Defined */
69: 0, 0, /* F= Not Defined */
70: 20440, 0, /* G=cyl 0 thru 510 */
71: 0, 0, /* H= Not Defined */
72: };
73: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
74:
75: int rlprobe(), rlslave(), rlattach(), rldgo(), rlintr();
76: struct uba_ctlr *rlminfo[NHL];
77: struct uba_device *rldinfo[NRL];
78: struct uba_device *rlip[NHL][4];
79:
80: /* RL02 driver structure */
81: u_short rlstd[] = { 0174400, 0 };
82: struct uba_driver hldriver =
83: { rlprobe, rlslave, rlattach, rldgo, rlstd, "rl", rldinfo, "hl", rlminfo };
84:
85: /* User table per controller */
86: struct buf rlutab[NRL];
87:
88: /* RL02 drive structure */
89: struct RL02 {
90: short nbpt; /* Number of 512 byte blocks/track */
91: short ntrak;
92: short nbpc; /* Number of 512 byte blocks/cylinder */
93: short ncyl;
94: short btrak; /* Number of bytes/track */
95: struct size *sizes;
96: } rl02 = {
97: 20, 2, 40, 512, 20*512, rl02_sizes /* rl02/DEC*/
98: };
99:
100: struct buf rrlbuf[NRL];
101:
102: #define b_cylin b_resid /* Last seek as CYL<<1 | HD */
103:
104: int rlwstart, rlwatch(); /* Have started guardian */
105:
106: /* Check that controller exists */
107: /*ARGSUSED*/
108: rlprobe(reg)
109: caddr_t reg;
110: {
111: register int br, cvec;
112:
113: #ifdef lint
114: br = 0; cvec = br; br = cvec;
115: rlintr(0);
116: #endif
117: ((struct rldevice *)reg)->rlcs = RL_IE | RL_NOOP;
118: DELAY(10);
119: ((struct rldevice *)reg)->rlcs &= ~RL_IE;
120: return (sizeof (struct rldevice));
121: }
122:
123: rlslave(ui, reg)
124: struct uba_device *ui;
125: caddr_t reg;
126: {
127: register struct rldevice *rladdr = (struct rldevice *)reg;
128: short ctr = 0;
129:
130: /*
131: * DEC reports that:
132: * For some unknown reason the RL02 (seems to be only drive 1)
133: * does not return a valid drive status the first time that a
134: * GET STATUS request is issued for the drive, in fact it can
135: * take up to three or more GET STATUS requests to obtain the
136: * correct status.
137: * In order to overcome this, the driver has been modified to
138: * issue a GET STATUS request and validate the drive status
139: * returned. If a valid status is not returned after eight
140: * attempts, then an error message is printed.
141: */
142: do {
143: rladdr->rlda.getstat = RL_RESET;
144: rladdr->rlcs = (ui->ui_slave <<8) | RL_GETSTAT; /* Get status*/
145: rlwait(rladdr);
146: } while ((rladdr->rlcs & (RL_CRDY|RL_ERR)) != RL_CRDY && ++ctr < 8);
147:
148: if ((rladdr->rlcs & RL_DE) || (ctr >= 8))
149: return (0);
150: if ((rladdr->rlmp.getstat & RLMP_DT) == 0 ) {
151: printf("rl%d: rl01's not supported\n", ui->ui_slave);
152: return(0);
153: }
154: return (1);
155: }
156:
157: rlattach(ui)
158: register struct uba_device *ui;
159: {
160: register struct rldevice *rladdr;
161:
162: if (rlwstart == 0) {
163: timeout(rlwatch, (caddr_t)0, hz);
164: rlwstart++;
165: }
166: /* Initialize iostat values */
167: if (ui->ui_dk >= 0)
168: dk_mspw[ui->ui_dk] = .000003906; /* 16bit transfer time? */
169: rlip[ui->ui_ctlr][ui->ui_slave] = ui;
170: rl_softc[ui->ui_ctlr].rl_ndrive++;
171: rladdr = (struct rldevice *)ui->ui_addr;
172: /* reset controller */
173: rladdr->rlda.getstat = RL_RESET; /* SHOULD BE REPEATED? */
174: rladdr->rlcs = (ui->ui_slave << 8) | RL_GETSTAT; /* Reset DE bit */
175: rlwait(rladdr);
176: /* determine disk posistion */
177: rladdr->rlcs = (ui->ui_slave << 8) | RL_RHDR;
178: rlwait(rladdr);
179: /* save disk drive posistion */
180: rl_stat[ui->ui_ctlr].rl_cyl[ui->ui_slave] =
181: (rladdr->rlmp.readhdr & 0177700) >> 6;
182: rl_stat[ui->ui_ctlr].rl_dn = -1;
183: }
184:
185: rlopen(dev)
186: dev_t dev;
187: {
188: register int unit = rlunit(dev);
189: register struct uba_device *ui;
190:
191: if (unit >= NRL || (ui = rldinfo[unit]) == 0 || ui->ui_alive == 0)
192: return (ENXIO);
193: return (0);
194: }
195:
196: rlstrategy(bp)
197: register struct buf *bp;
198: {
199: register struct uba_device *ui;
200: register int drive;
201: register struct buf *dp;
202: int partition = minor(bp->b_dev) & 07, s;
203: long bn, sz;
204:
205: sz = (bp->b_bcount+511) >> 9;
206: drive = rlunit(bp->b_dev);
207: if (drive >= NRL) {
208: bp->b_error = ENXIO;
209: goto bad;
210: }
211: ui = rldinfo[drive];
212: if (ui == 0 || ui->ui_alive == 0) {
213: bp->b_error = ENXIO;
214: goto bad;
215: }
216: if (bp->b_blkno < 0 ||
217: (bn = bp->b_blkno)+sz > rl02.sizes[partition].nblocks) {
218: if (bp->b_blkno == rl02.sizes[partition].nblocks) {
219: bp->b_resid = bp->b_bcount;
220: goto done;
221: }
222: bp->b_error = EINVAL;
223: goto bad;
224: }
225: /* bn is in 512 byte block size */
226: bp->b_cylin = bn/rl02.nbpc + rl02.sizes[partition].cyloff;
227: s = spl5();
228: dp = &rlutab[ui->ui_unit];
229: disksort(dp, bp);
230: if (dp->b_active == 0) {
231: rlustart(ui);
232: bp = &ui->ui_mi->um_tab;
233: if (bp->b_actf && bp->b_active == 0)
234: rlstart(ui->ui_mi);
235: }
236: splx(s);
237: return;
238:
239: bad:
240: bp->b_flags |= B_ERROR;
241: done:
242: iodone(bp);
243: return;
244: }
245:
246: /*
247: * Unit start routine.
248: * Seek the drive to be where the data is
249: * and then generate another interrupt
250: * to actually start the transfer.
251: */
252: rlustart(ui)
253: register struct uba_device *ui;
254: {
255: register struct buf *bp, *dp;
256: register struct uba_ctlr *um;
257: register struct rldevice *rladdr;
258: daddr_t bn;
259: short hd, diff;
260:
261: if (ui == 0)
262: return;
263: um = ui->ui_mi;
264: dk_busy &= ~(1 << ui->ui_dk);
265: dp = &rlutab[ui->ui_unit];
266: if ((bp = dp->b_actf) == NULL)
267: return;
268: /*
269: * If the controller is active, just remember
270: * that this device has to be positioned...
271: */
272: if (um->um_tab.b_active) {
273: rl_softc[um->um_ctlr].rl_softas |= 1<<ui->ui_slave;
274: return;
275: }
276: /*
277: * If we have already positioned this drive,
278: * then just put it on the ready queue.
279: */
280: if (dp->b_active)
281: goto done;
282: dp->b_active = 1; /* positioning drive */
283: rladdr = (struct rldevice *)um->um_addr;
284:
285: /*
286: * Figure out where this transfer is going to
287: * and see if we are seeked correctly.
288: */
289: bn = bp->b_blkno; /* Block # desired */
290: /*
291: * Map 512 byte logical disk blocks
292: * to 256 byte sectors (rl02's are stupid).
293: */
294: hd = (bn / rl02.nbpt) & 1; /* Get head required */
295: diff = (rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] >> 1) - bp->b_cylin;
296: if ( diff == 0 && (rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] & 1) == hd)
297: goto done; /* on cylinder and head */
298: /*
299: * Not at correct position.
300: */
301: rl_stat[um->um_ctlr].rl_cyl[ui->ui_slave] = (bp->b_cylin << 1) | hd;
302: if (diff < 0)
303: rladdr->rlda.seek = -diff << 7 | RLDA_HGH | hd << 4;
304: else
305: rladdr->rlda.seek = diff << 7 | RLDA_LOW | hd << 4;
306: rladdr->rlcs = (ui->ui_slave << 8) | RL_SEEK;
307:
308: /*
309: * Mark unit busy for iostat.
310: */
311: if (ui->ui_dk >= 0) {
312: dk_busy |= 1<<ui->ui_dk;
313: dk_seek[ui->ui_dk]++;
314: }
315: rlwait(rladdr);
316: done:
317: /*
318: * Device is ready to go.
319: * Put it on the ready queue for the controller
320: * (unless its already there.)
321: */
322: if (dp->b_active != 2) {
323: dp->b_forw = NULL;
324: if (um->um_tab.b_actf == NULL)
325: um->um_tab.b_actf = dp;
326: else
327: um->um_tab.b_actl->b_forw = dp;
328: um->um_tab.b_actl = dp;
329: dp->b_active = 2; /* Request on ready queue */
330: }
331: }
332:
333: /*
334: * Start up a transfer on a drive.
335: */
336: rlstart(um)
337: register struct uba_ctlr *um;
338: {
339: register struct buf *bp, *dp;
340: register struct uba_device *ui;
341: register struct rldevice *rladdr;
342: register struct rl_stat *st = &rl_stat[um->um_ctlr];
343: daddr_t bn;
344: short sn, cyl, cmd;
345:
346: loop:
347: if ((dp = um->um_tab.b_actf) == NULL) {
348: st->rl_dn = -1;
349: st->rl_cylnhd = 0;
350: st->rl_bleft = 0;
351: st->rl_bpart = 0;
352: return;
353: }
354: if ((bp = dp->b_actf) == NULL) {
355: um->um_tab.b_actf = dp->b_forw;
356: goto loop;
357: }
358: /*
359: * Mark controller busy, and
360: * determine destination.
361: */
362: um->um_tab.b_active++;
363: ui = rldinfo[rlunit(bp->b_dev)]; /* Controller */
364: bn = bp->b_blkno; /* 512 byte Block number */
365: cyl = bp->b_cylin << 1; /* Cylinder */
366: cyl |= (bn / rl02.nbpt) & 1; /* Get head required */
367: sn = (bn % rl02.nbpt) << 1; /* Sector number */
368: rladdr = (struct rldevice *)ui->ui_addr;
369: rlwait(rladdr);
370: rladdr->rlda.rw = cyl<<6 | sn;
371: /* save away current transfers drive status */
372: st->rl_dn = ui->ui_slave;
373: st->rl_cylnhd = cyl;
374: st->rl_bleft = bp->b_bcount;
375: st->rl_bpart = rl02.btrak - (sn * NRLBPSC);
376: /*
377: * RL02 must seek between cylinders and between tracks,
378: * determine maximum data transfer at this time.
379: */
380: if (st->rl_bleft < st->rl_bpart)
381: st->rl_bpart = st->rl_bleft;
382: rladdr->rlmp.rw = -(st->rl_bpart >> 1);
383: if (bp->b_flags & B_READ)
384: cmd = RL_IE | RL_READ | (ui->ui_slave << 8);
385: else
386: cmd = RL_IE | RL_WRITE | (ui->ui_slave << 8);
387: um->um_cmd = cmd;
388: (void) ubago(ui);
389: }
390:
391: rldgo(um)
392: register struct uba_ctlr *um;
393: {
394: register struct rldevice *rladdr = (struct rldevice *)um->um_addr;
395:
396: rladdr->rlba = um->um_ubinfo;
397: rladdr->rlcs = um->um_cmd|((um->um_ubinfo>>12)&RL_BAE);
398: }
399:
400: /*
401: * Handle a disk interrupt.
402: */
403: rlintr(rl21)
404: register rl21;
405: {
406: register struct buf *bp, *dp;
407: register struct uba_ctlr *um = rlminfo[rl21];
408: register struct uba_device *ui;
409: register struct rldevice *rladdr = (struct rldevice *)um->um_addr;
410: register unit;
411: struct rl_softc *rl = &rl_softc[um->um_ctlr];
412: struct rl_stat *st = &rl_stat[um->um_ctlr];
413: int as = rl->rl_softas, status;
414:
415: rl->rl_wticks = 0;
416: rl->rl_softas = 0;
417: dp = um->um_tab.b_actf;
418: bp = dp->b_actf;
419: ui = rldinfo[rlunit(bp->b_dev)];
420: dk_busy &= ~(1 << ui->ui_dk);
421:
422: /*
423: * Check for and process errors on
424: * either the drive or the controller.
425: */
426: if (rladdr->rlcs & RL_ERR) {
427: u_short err;
428: rlwait(rladdr);
429: err = rladdr->rlcs;
430: /* get staus and reset controller */
431: rladdr->rlda.getstat = RL_GSTAT;
432: rladdr->rlcs = (ui->ui_slave << 8) | RL_GETSTAT;
433: rlwait(rladdr);
434: status = rladdr->rlmp.getstat;
435: /* reset drive */
436: rladdr->rlda.getstat = RL_RESET;
437: rladdr->rlcs = (ui->ui_slave <<8) | RL_GETSTAT; /* Get status*/
438: rlwait(rladdr);
439: if ((status & RLMP_WL) == RLMP_WL) {
440: /*
441: * Give up on write protected devices
442: * immediately.
443: */
444: printf("rl%d: write protected\n", rlunit(bp->b_dev));
445: bp->b_flags |= B_ERROR;
446: } else if (++um->um_tab.b_errcnt > 10) {
447: /*
448: * After 10 retries give up.
449: */
450: harderr(bp, "rl");
451: printf("cs=%b mp=%b\n", err, RLCS_BITS,
452: status, RLER_BITS);
453: bp->b_flags |= B_ERROR;
454: } else
455: um->um_tab.b_active = 0; /* force retry */
456: /* determine disk position */
457: rladdr->rlcs = (ui->ui_slave << 8) | RL_RHDR;
458: rlwait(rladdr);
459: /* save disk drive position */
460: st->rl_cyl[ui->ui_slave] =
461: (rladdr->rlmp.readhdr & 0177700) >> 6;
462: }
463: /*
464: * If still ``active'', then don't need any more retries.
465: */
466: if (um->um_tab.b_active) {
467: /* RL02 check if more data from previous request */
468: if ((bp->b_flags & B_ERROR) == 0 &&
469: (int)(st->rl_bleft -= st->rl_bpart) > 0) {
470: /*
471: * The following code was modeled from the rk07
472: * driver when an ECC error occured. It has to
473: * fix the bits then restart the transfer which is
474: * what we have to do (restart transfer).
475: */
476: int reg, npf, o, cmd, ubaddr, diff, head;
477:
478: /* seek to next head/track */
479: /* increment head and/or cylinder */
480: st->rl_cylnhd++;
481: diff = (st->rl_cyl[ui->ui_slave] >> 1) -
482: (st->rl_cylnhd >> 1);
483: st->rl_cyl[ui->ui_slave] = st->rl_cylnhd;
484: head = st->rl_cylnhd & 1;
485: rlwait(rladdr);
486: if (diff < 0)
487: rladdr->rlda.seek =
488: -diff << 7 | RLDA_HGH | head << 4;
489: else
490: rladdr->rlda.seek =
491: diff << 7 | RLDA_LOW | head << 4;
492: rladdr->rlcs = (ui->ui_slave << 8) | RL_SEEK;
493: npf = btop( bp->b_bcount - st->rl_bleft );
494: reg = btop(um->um_ubinfo&0x3ffff) + npf;
495: o = (int)bp->b_un.b_addr & PGOFSET;
496: ubapurge(um);
497: um->um_tab.b_active++;
498: rlwait(rladdr);
499: rladdr->rlda.rw = st->rl_cylnhd << 6;
500: if (st->rl_bleft < (st->rl_bpart = rl02.btrak))
501: st->rl_bpart = st->rl_bleft;
502: rladdr->rlmp.rw = -(st->rl_bpart >> 1);
503: cmd = (bp->b_flags&B_READ ? RL_READ : RL_WRITE) |
504: RL_IE | (ui->ui_slave << 8);
505: ubaddr = (int)ptob(reg) + o;
506: cmd |= ((ubaddr >> 12) & RL_BAE);
507: rladdr->rlba = ubaddr;
508: rladdr->rlcs = cmd;
509: return;
510: }
511: um->um_tab.b_active = 0;
512: um->um_tab.b_errcnt = 0;
513: dp->b_active = 0;
514: dp->b_errcnt = 0;
515: /* "b_resid" words remaining after error */
516: bp->b_resid = st->rl_bleft;
517: um->um_tab.b_actf = dp->b_forw;
518: dp->b_actf = bp->av_forw;
519: st->rl_dn = -1;
520: st->rl_bpart = st->rl_bleft = 0;
521: iodone(bp);
522: /*
523: * If this unit has more work to do,
524: * then start it up right away.
525: */
526: if (dp->b_actf)
527: rlustart(ui);
528: as &= ~(1<<ui->ui_slave);
529: } else
530: as |= (1<<ui->ui_slave);
531: ubadone(um);
532: /* reset state info */
533: st->rl_dn = -1;
534: st->rl_cylnhd = st->rl_bpart = st->rl_bleft = 0;
535: /*
536: * Process other units which need attention.
537: * For each unit which needs attention, call
538: * the unit start routine to place the slave
539: * on the controller device queue.
540: */
541: while (unit = ffs((long)as)) {
542: unit--; /* was 1 origin */
543: as &= ~(1<<unit);
544: rlustart(rlip[rl21][unit]);
545: }
546: /*
547: * If the controller is not transferring, but
548: * there are devices ready to transfer, start
549: * the controller.
550: */
551: if (um->um_tab.b_actf && um->um_tab.b_active == 0)
552: rlstart(um);
553: }
554:
555: rlwait(rladdr)
556: register struct rldevice *rladdr;
557: {
558:
559: while ((rladdr->rlcs & RL_CRDY) == 0)
560: ;
561: }
562:
563: rlread(dev, uio)
564: dev_t dev;
565: struct uio *uio;
566: {
567: register int unit = rlunit(dev);
568:
569: if (unit >= NRL)
570: return (ENXIO);
571: return (physio(rlstrategy, &rrlbuf[unit], dev, B_READ, minphys, uio));
572: }
573:
574: rlwrite(dev, uio)
575: dev_t dev;
576: struct uio *uio;
577: {
578: register int unit = rlunit(dev);
579:
580: if (unit >= NRL)
581: return (ENXIO);
582: return (physio(rlstrategy, &rrlbuf[unit], dev, B_WRITE, minphys, uio));
583: }
584:
585: /*
586: * Reset driver after UBA init.
587: * Cancel software state of all pending transfers
588: * and restart all units and the controller.
589: */
590: rlreset(uban)
591: int uban;
592: {
593: register struct uba_ctlr *um;
594: register struct uba_device *ui;
595: register struct rldevice *rladdr;
596: register struct rl_stat *st;
597: register int rl21, unit;
598:
599: for (rl21 = 0; rl21 < NHL; rl21++) {
600: if ((um = rlminfo[rl21]) == 0 || um->um_ubanum != uban ||
601: um->um_alive == 0)
602: continue;
603: printf(" hl%d", rl21);
604: rladdr = (struct rldevice *)um->um_addr;
605: st = &rl_stat[rl21];
606: um->um_tab.b_active = 0;
607: um->um_tab.b_actf = um->um_tab.b_actl = 0;
608: if (um->um_ubinfo) {
609: printf("<%d>", (um->um_ubinfo>>28)&0xf);
610: um->um_ubinfo = 0;
611: }
612: /* reset controller */
613: st->rl_dn = -1;
614: st->rl_cylnhd = 0;
615: st->rl_bleft = 0;
616: st->rl_bpart = 0;
617: rlwait(rladdr);
618: for (unit = 0; unit < NRL; unit++) {
619: rladdr->rlcs = (unit << 8) | RL_GETSTAT;
620: rlwait(rladdr);
621: /* Determine disk posistion */
622: rladdr->rlcs = (unit << 8) | RL_RHDR;
623: rlwait(rladdr);
624: /* save disk drive posistion */
625: st->rl_cyl[unit] =
626: (rladdr->rlmp.readhdr & 0177700) >> 6;
627: if ((ui = rldinfo[unit]) == 0)
628: continue;
629: if (ui->ui_alive == 0 || ui->ui_mi != um)
630: continue;
631: rlutab[unit].b_active = 0;
632: rlustart(ui);
633: }
634: rlstart(um);
635: }
636: }
637:
638: /*
639: * Wake up every second and if an interrupt is pending
640: * but nothing has happened increment a counter.
641: * If nothing happens for 20 seconds, reset the UNIBUS
642: * and begin anew.
643: */
644: rlwatch()
645: {
646: register struct uba_ctlr *um;
647: register rl21, unit;
648: register struct rl_softc *rl;
649:
650: timeout(rlwatch, (caddr_t)0, hz);
651: for (rl21 = 0; rl21 < NHL; rl21++) {
652: um = rlminfo[rl21];
653: if (um == 0 || um->um_alive == 0)
654: continue;
655: rl = &rl_softc[rl21];
656: if (um->um_tab.b_active == 0) {
657: for (unit = 0; unit < NRL; unit++)
658: if (rlutab[unit].b_active &&
659: rldinfo[unit]->ui_mi == um)
660: goto active;
661: rl->rl_wticks = 0;
662: continue;
663: }
664: active:
665: rl->rl_wticks++;
666: if (rl->rl_wticks >= 20) {
667: rl->rl_wticks = 0;
668: printf("hl%d: lost interrupt\n", rl21);
669: ubareset(um->um_ubanum);
670: }
671: }
672: }
673:
674: /*ARGSUSED*/
675: rldump(dev)
676: dev_t dev;
677: {
678:
679: /* don't think there is room on swap for it anyway. */
680: }
681:
682: rlsize(dev)
683: dev_t dev;
684: {
685: register int unit = rlunit(dev);
686: register struct uba_device *ui;
687:
688: if (unit >= NRL || (ui = rldinfo[unit]) == 0 || ui->ui_alive == 0)
689: return (-1);
690: return (rl02.sizes[minor(dev) & 07].nblocks);
691: }
692: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.