![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rk.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba|
Return to rk.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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: * @(#)rk.c 7.4 (Berkeley) 5/27/88
7: */
8:
9: #include "rk.h"
10: #if NHK > 0
11: int rkpip; /* DEBUG */
12: int rknosval; /* DEBUG */
13: #ifdef RKDEBUG
14: int rkdebug;
15: #endif
16: #ifdef RKBDEBUG
17: int rkbdebug;
18: #endif
19: /*
20: * RK611/RK0[67] disk driver
21: *
22: * This driver mimics up.c; see it for an explanation of common code.
23: *
24: * TODO:
25: * Learn why we lose an interrupt sometime when spinning drives down
26: */
27: #include "../machine/pte.h"
28:
29: #include "param.h"
30: #include "systm.h"
31: #include "buf.h"
32: #include "conf.h"
33: #include "dir.h"
34: #include "user.h"
35: #include "map.h"
36: #include "vm.h"
37: #include "dkstat.h"
38: #include "cmap.h"
39: #include "dkbad.h"
40: #include "ioctl.h"
41: #include "disklabel.h"
42: #include "uio.h"
43: #include "kernel.h"
44: #include "syslog.h"
45:
46: #include "../vax/cpu.h"
47: #include "ubareg.h"
48: #include "ubavar.h"
49: #include "rkreg.h"
50:
51: struct rk_softc {
52: int sc_softas;
53: int sc_ndrive;
54: int sc_wticks;
55: int sc_recal;
56: } rk_softc[NHK];
57:
58: #define rkunit(dev) (minor(dev) >> 3)
59:
60: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
61: struct size {
62: daddr_t nblocks;
63: int cyloff;
64: } rk7_sizes[8] = {
65: 15884, 0, /* A=cyl 0 thru 240 */
66: 10032, 241, /* B=cyl 241 thru 392 */
67: 53790, 0, /* C=cyl 0 thru 814 */
68: 15884, 393, /* D=cyl 393 thru 633 */
69: 0, 0,
70: 11792, 634, /* F=cyl 634 thru 814 */
71: 27786, 393, /* G=cyl 393 thru 814, should be 27698 */
72: 0, 0,
73: }, rk6_sizes[8] ={
74: 15884, 0, /* A=cyl 0 thru 240 */
75: 11154, 241, /* B=cyl 241 thru 409 */
76: 27126, 0, /* C=cyl 0 thru 410 */
77: 0, 0,
78: 0, 0,
79: 0, 0,
80: 0, 0,
81: 0, 0,
82: };
83: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
84:
85: short rktypes[] = { RK_CDT, 0 };
86:
87: int rkprobe(), rkslave(), rkattach(), rkdgo(), rkintr();
88: struct uba_ctlr *rkminfo[NHK];
89: struct uba_device *rkdinfo[NRK];
90: struct uba_device *rkip[NHK][4];
91:
92: u_short rkstd[] = { 0777440, 0 };
93: struct uba_driver hkdriver =
94: { rkprobe, rkslave, rkattach, rkdgo, rkstd, "rk", rkdinfo, "hk", rkminfo, 1 };
95: struct buf rkutab[NRK];
96: short rkcyl[NRK];
97: struct dkbad rkbad[NRK];
98: struct buf brkbuf[NRK];
99:
100: struct rkst {
101: short nsect;
102: short ntrak;
103: short nspc;
104: short ncyl;
105: struct size *sizes;
106: } rkst[] = {
107: NRKSECT, NRKTRK, NRKSECT*NRKTRK, NRK7CYL, rk7_sizes,
108: NRKSECT, NRKTRK, NRKSECT*NRKTRK, NRK6CYL, rk6_sizes,
109: };
110:
111: u_char rk_offset[16] =
112: { RKAS_P400,RKAS_M400,RKAS_P400,RKAS_M400,RKAS_P800,RKAS_M800,RKAS_P800,
113: RKAS_M800,RKAS_P1200,RKAS_M1200,RKAS_P1200,RKAS_M1200,0,0,0,0
114: };
115:
116: #define b_cylin b_resid
117:
118: int rkwstart, rkwatch();
119:
120: rkprobe(reg)
121: caddr_t reg;
122: {
123: register int br, cvec;
124:
125: #ifdef lint
126: br = 0; cvec = br; br = cvec;
127: rkintr(0);
128: #endif
129: ((struct rkdevice *)reg)->rkcs1 = RK_CDT|RK_IE|RK_CRDY;
130: DELAY(10);
131: ((struct rkdevice *)reg)->rkcs1 = RK_CDT;
132: return (sizeof (struct rkdevice));
133: }
134:
135: rkslave(ui, reg)
136: struct uba_device *ui;
137: caddr_t reg;
138: {
139: register struct rkdevice *rkaddr = (struct rkdevice *)reg;
140:
141: ui->ui_type = 0;
142: rkaddr->rkcs1 = RK_CCLR;
143: rkaddr->rkcs2 = ui->ui_slave;
144: rkaddr->rkcs1 = RK_CDT|RK_DCLR|RK_GO;
145: rkwait(rkaddr);
146: DELAY(50);
147: if (rkaddr->rkcs2&RKCS2_NED || (rkaddr->rkds&RKDS_SVAL) == 0) {
148: rkaddr->rkcs1 = RK_CCLR;
149: return (0);
150: }
151: if (rkaddr->rkcs1&RK_CERR && rkaddr->rker&RKER_DTYE) {
152: ui->ui_type = 1;
153: rkaddr->rkcs1 = RK_CCLR;
154: }
155: return (1);
156: }
157:
158: rkattach(ui)
159: register struct uba_device *ui;
160: {
161:
162: if (rkwstart == 0) {
163: timeout(rkwatch, (caddr_t)0, hz);
164: rkwstart++;
165: }
166: if (ui->ui_dk >= 0)
167: dk_mspw[ui->ui_dk] = 1.0 / (60 * NRKSECT * 256);
168: rkip[ui->ui_ctlr][ui->ui_slave] = ui;
169: rk_softc[ui->ui_ctlr].sc_ndrive++;
170: rkcyl[ui->ui_unit] = -1;
171: ui->ui_flags = 0;
172: }
173:
174: rkopen(dev)
175: dev_t dev;
176: {
177: register int unit = rkunit(dev);
178: register struct uba_device *ui;
179:
180: if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0)
181: return (ENXIO);
182: return (0);
183: }
184:
185: rkstrategy(bp)
186: register struct buf *bp;
187: {
188: register struct uba_device *ui;
189: register struct rkst *st;
190: register int unit;
191: register struct buf *dp;
192: int xunit = minor(bp->b_dev) & 07;
193: long bn, sz;
194: int s;
195:
196: sz = (bp->b_bcount+511) >> 9;
197: unit = rkunit(bp->b_dev);
198: if (unit >= NRK) {
199: bp->b_error = ENXIO;
200: goto bad;
201: }
202: ui = rkdinfo[unit];
203: if (ui == 0 || ui->ui_alive == 0) {
204: bp->b_error = ENXIO;
205: goto bad;
206: }
207: st = &rkst[ui->ui_type];
208: if (bp->b_blkno < 0 ||
209: (bn = bp->b_blkno)+sz > st->sizes[xunit].nblocks) {
210: if (bp->b_blkno == st->sizes[xunit].nblocks) {
211: bp->b_resid = bp->b_bcount;
212: goto done;
213: }
214: bp->b_error = EINVAL;
215: goto bad;
216: }
217: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
218: s = spl5();
219: dp = &rkutab[ui->ui_unit];
220: disksort(dp, bp);
221: if (dp->b_active == 0) {
222: (void) rkustart(ui);
223: bp = &ui->ui_mi->um_tab;
224: if (bp->b_actf && bp->b_active == 0)
225: (void) rkstart(ui->ui_mi);
226: }
227: splx(s);
228: return;
229:
230: bad:
231: bp->b_flags |= B_ERROR;
232: done:
233: iodone(bp);
234: return;
235: }
236:
237: rkustart(ui)
238: register struct uba_device *ui;
239: {
240: register struct buf *bp, *dp;
241: register struct uba_ctlr *um;
242: register struct rkdevice *rkaddr;
243:
244: if (ui == 0)
245: return;
246: dk_busy &= ~(1<<ui->ui_dk);
247: dp = &rkutab[ui->ui_unit];
248: um = ui->ui_mi;
249: rkaddr = (struct rkdevice *)um->um_addr;
250: if (um->um_tab.b_active) {
251: rk_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave;
252: return;
253: }
254: if ((bp = dp->b_actf) == NULL)
255: return;
256: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_CERR;
257: rkaddr->rkcs2 = ui->ui_slave;
258: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
259: rkwait(rkaddr);
260: if ((rkaddr->rkds & RKDS_VV) == 0 || ui->ui_flags == 0) {
261: /* SHOULD WARN SYSTEM THAT THIS HAPPENED */
262: struct rkst *st = &rkst[ui->ui_type];
263: struct buf *bbp = &brkbuf[ui->ui_unit];
264:
265: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_PACK|RK_GO;
266: ui->ui_flags = 1;
267: bbp->b_flags = B_READ|B_BUSY;
268: bbp->b_dev = bp->b_dev;
269: bbp->b_bcount = 512;
270: bbp->b_un.b_addr = (caddr_t)&rkbad[ui->ui_unit];
271: bbp->b_blkno = st->ncyl*st->nspc - st->nsect;
272: bbp->b_cylin = st->ncyl - 1;
273: dp->b_actf = bbp;
274: bbp->av_forw = bp;
275: bp = bbp;
276: rkwait(rkaddr);
277: }
278: if (dp->b_active)
279: goto done;
280: dp->b_active = 1;
281: if ((rkaddr->rkds & RKDS_DREADY) != RKDS_DREADY)
282: goto done;
283: if (rk_softc[um->um_ctlr].sc_ndrive == 1)
284: goto done;
285: if (bp->b_cylin == rkcyl[ui->ui_unit])
286: goto done;
287: rkaddr->rkcyl = bp->b_cylin;
288: rkcyl[ui->ui_unit] = bp->b_cylin;
289: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_SEEK|RK_GO;
290: if (ui->ui_dk >= 0) {
291: dk_busy |= 1<<ui->ui_dk;
292: dk_seek[ui->ui_dk]++;
293: }
294: goto out;
295: done:
296: if (dp->b_active != 2) {
297: dp->b_forw = NULL;
298: if (um->um_tab.b_actf == NULL)
299: um->um_tab.b_actf = dp;
300: else
301: um->um_tab.b_actl->b_forw = dp;
302: um->um_tab.b_actl = dp;
303: dp->b_active = 2;
304: }
305: out:
306: return;
307: }
308:
309: rkstart(um)
310: register struct uba_ctlr *um;
311: {
312: register struct buf *bp, *dp;
313: register struct uba_device *ui;
314: register struct rkdevice *rkaddr;
315: struct rkst *st;
316: daddr_t bn;
317: int sn, tn, cmd;
318:
319: loop:
320: if ((dp = um->um_tab.b_actf) == NULL)
321: return;
322: if ((bp = dp->b_actf) == NULL) {
323: um->um_tab.b_actf = dp->b_forw;
324: goto loop;
325: }
326: um->um_tab.b_active++;
327: ui = rkdinfo[rkunit(bp->b_dev)];
328: bn = bp->b_blkno;
329: st = &rkst[ui->ui_type];
330: sn = bn%st->nspc;
331: tn = sn/st->nsect;
332: sn %= st->nsect;
333: rkaddr = (struct rkdevice *)ui->ui_addr;
334: retry:
335: rkaddr->rkcs1 = RK_CCLR;
336: rkaddr->rkcs2 = ui->ui_slave;
337: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
338: rkwait(rkaddr);
339: if ((rkaddr->rkds&RKDS_SVAL) == 0) {
340: rknosval++;
341: goto nosval;
342: }
343: if (rkaddr->rkds&RKDS_PIP) {
344: rkpip++;
345: goto retry;
346: }
347: if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
348: printf("rk%d: not ready", rkunit(bp->b_dev));
349: if ((rkaddr->rkds&RKDS_DREADY) != RKDS_DREADY) {
350: printf("\n");
351: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
352: rkwait(rkaddr);
353: rkaddr->rkcs1 = RK_CCLR;
354: rkwait(rkaddr);
355: um->um_tab.b_active = 0;
356: um->um_tab.b_errcnt = 0;
357: dp->b_actf = bp->av_forw;
358: dp->b_active = 0;
359: bp->b_flags |= B_ERROR;
360: iodone(bp);
361: goto loop;
362: }
363: printf(" (came back!)\n");
364: }
365: nosval:
366: rkaddr->rkcyl = bp->b_cylin;
367: rkcyl[ui->ui_unit] = bp->b_cylin;
368: rkaddr->rkda = (tn << 8) + sn;
369: rkaddr->rkwc = -bp->b_bcount / sizeof (short);
370: if (bp->b_flags & B_READ)
371: cmd = rktypes[ui->ui_type]|RK_IE|RK_READ|RK_GO;
372: else
373: cmd = rktypes[ui->ui_type]|RK_IE|RK_WRITE|RK_GO;
374: um->um_cmd = cmd;
375: (void) ubago(ui);
376: }
377:
378: rkdgo(um)
379: register struct uba_ctlr *um;
380: {
381: register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
382:
383: um->um_tab.b_active = 2; /* should now be 2 */
384: rkaddr->rkba = um->um_ubinfo;
385: rkaddr->rkcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300);
386: }
387:
388: rkintr(rk11)
389: int rk11;
390: {
391: register struct uba_ctlr *um = rkminfo[rk11];
392: register struct uba_device *ui;
393: register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
394: register struct buf *bp, *dp;
395: int unit;
396: struct rk_softc *sc = &rk_softc[um->um_ctlr];
397: int as = (rkaddr->rkatt >> 8) | sc->sc_softas;
398:
399: sc->sc_wticks = 0;
400: sc->sc_softas = 0;
401: if (um->um_tab.b_active == 2 || sc->sc_recal) {
402: um->um_tab.b_active = 1;
403: dp = um->um_tab.b_actf;
404: bp = dp->b_actf;
405: ui = rkdinfo[rkunit(bp->b_dev)];
406: dk_busy &= ~(1 << ui->ui_dk);
407: if (bp->b_flags&B_BAD)
408: if (rkecc(ui, CONT))
409: return;
410: if (rkaddr->rkcs1 & RK_CERR) {
411: int recal;
412: u_short ds = rkaddr->rkds;
413: u_short cs2 = rkaddr->rkcs2;
414: u_short er = rkaddr->rker;
415: #ifdef RKDEBUG
416: if (rkdebug) {
417: printf("cs2=%b ds=%b er=%b\n",
418: cs2, RKCS2_BITS, ds,
419: RKDS_BITS, er, RKER_BITS);
420: }
421: #endif
422: if (er & RKER_WLE) {
423: printf("rk%d: write locked\n",
424: rkunit(bp->b_dev));
425: bp->b_flags |= B_ERROR;
426: } else if (++um->um_tab.b_errcnt > 28 ||
427: ds&RKDS_HARD || er&RKER_HARD || cs2&RKCS2_HARD) {
428: hard:
429: diskerr(bp, "rk", "hard error", LOG_PRINTF, -1,
430: (struct disklabel *)0);
431: printf(" cs2=%b ds=%b er=%b\n",
432: cs2, RKCS2_BITS, ds,
433: RKDS_BITS, er, RKER_BITS);
434: bp->b_flags |= B_ERROR;
435: sc->sc_recal = 0;
436: } else if (er & RKER_BSE) {
437: if (rkecc(ui, BSE))
438: return;
439: else
440: goto hard;
441: } else {
442: if ((er & (RKER_DCK|RKER_ECH)) == RKER_DCK) {
443: if (rkecc(ui, ECC))
444: return;
445: } else
446: um->um_tab.b_active = 0;
447: }
448: if (cs2&RKCS2_MDS) {
449: rkaddr->rkcs2 = RKCS2_SCLR;
450: goto retry;
451: }
452: recal = 0;
453: if (ds&RKDS_DROT || er&(RKER_OPI|RKER_SKI|RKER_UNS) ||
454: (um->um_tab.b_errcnt&07) == 4)
455: recal = 1;
456: rkaddr->rkcs1 = RK_CCLR;
457: rkaddr->rkcs2 = ui->ui_slave;
458: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
459: rkwait(rkaddr);
460: if (recal && um->um_tab.b_active == 0) {
461: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_RECAL|RK_GO;
462: rkcyl[ui->ui_unit] = -1;
463: sc->sc_recal = 0;
464: goto nextrecal;
465: }
466: }
467: retry:
468: switch (sc->sc_recal) {
469:
470: case 1:
471: rkaddr->rkcyl = bp->b_cylin;
472: rkcyl[ui->ui_unit] = bp->b_cylin;
473: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_SEEK|RK_GO;
474: goto nextrecal;
475: case 2:
476: if (um->um_tab.b_errcnt < 16 ||
477: (bp->b_flags&B_READ) == 0)
478: goto donerecal;
479: rkaddr->rkatt = rk_offset[um->um_tab.b_errcnt & 017];
480: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_OFFSET|RK_GO;
481: /* fall into ... */
482: nextrecal:
483: sc->sc_recal++;
484: rkwait(rkaddr);
485: um->um_tab.b_active = 1;
486: return;
487: donerecal:
488: case 3:
489: sc->sc_recal = 0;
490: um->um_tab.b_active = 0;
491: break;
492: }
493: ubadone(um);
494: if (um->um_tab.b_active) {
495: um->um_tab.b_active = 0;
496: um->um_tab.b_errcnt = 0;
497: um->um_tab.b_actf = dp->b_forw;
498: dp->b_active = 0;
499: dp->b_errcnt = 0;
500: dp->b_actf = bp->av_forw;
501: bp->b_resid = -rkaddr->rkwc * sizeof(short);
502: iodone(bp);
503: if (dp->b_actf)
504: rkustart(ui);
505: }
506: as &= ~(1<<ui->ui_slave);
507: }
508: for (unit = 0; as; as >>= 1, unit++)
509: if (as & 1) {
510: ui = rkip[rk11][unit];
511: if (ui) {
512: rkustart(rkip[rk11][unit]);
513: } else {
514: rkaddr->rkcs1 = RK_CCLR;
515: rkaddr->rkcs2 = unit;
516: rkaddr->rkcs1 = RK_DCLR|RK_GO;
517: rkwait(rkaddr);
518: rkaddr->rkcs1 = RK_CCLR;
519: }
520: }
521: if (um->um_tab.b_actf && um->um_tab.b_active == 0)
522: rkstart(um);
523: if (((rkaddr->rkcs1) & RK_IE) == 0)
524: rkaddr->rkcs1 = RK_IE;
525: }
526:
527: rkwait(addr)
528: register struct rkdevice *addr;
529: {
530:
531: while ((addr->rkcs1 & RK_CRDY) == 0)
532: ;
533: }
534:
535: rkecc(ui, flag)
536: register struct uba_device *ui;
537: {
538: register struct rkdevice *rk = (struct rkdevice *)ui->ui_addr;
539: register struct buf *bp = rkutab[ui->ui_unit].b_actf;
540: register struct uba_ctlr *um = ui->ui_mi;
541: register struct rkst *st;
542: struct uba_regs *ubp = ui->ui_hd->uh_uba;
543: caddr_t addr;
544: int reg, npf, o, cmd, ubaddr;
545: int bn, cn, tn, sn;
546:
547: if (flag == CONT)
548: npf = bp->b_error;
549: else
550: npf = btodb(bp->b_bcount + (rk->rkwc * sizeof(short)) + 511);
551: reg = btop(um->um_ubinfo&0x3ffff) + npf;
552: o = (int)bp->b_un.b_addr & PGOFSET;
553: bn = bp->b_blkno;
554: st = &rkst[ui->ui_type];
555: cn = bp->b_cylin;
556: sn = bn%st->nspc + npf;
557: tn = sn/st->nsect;
558: sn %= st->nsect;
559: cn += tn/st->ntrak;
560: tn %= st->ntrak;
561: ubapurge(um);
562: switch (flag) {
563: case ECC:
564: {
565: register int i;
566: int bit, byte, mask;
567:
568: npf--;
569: reg--;
570: diskerr(bp, "rk", "soft ecc", LOG_WARNING, npf,
571: (struct disklabel *)0);
572: addlog("\n");
573: mask = rk->rkec2;
574: i = rk->rkec1 - 1; /* -1 makes 0 origin */
575: bit = i&07;
576: i = (i&~07)>>3;
577: byte = i + o;
578: while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) {
579: addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+
580: (byte & PGOFSET);
581: putmemc(addr, getmemc(addr)^(mask<<bit));
582: byte++;
583: i++;
584: bit -= 8;
585: }
586: if (rk->rkwc == 0) {
587: um->um_tab.b_active = 0;
588: return (0);
589: }
590: npf++;
591: reg++;
592: break;
593: }
594:
595: case BSE:
596: #ifdef RKBDEBUG
597: if (rkbdebug)
598: printf("rkecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn);
599: #endif
600: if ((bn = isbad(&rkbad[ui->ui_unit], cn, tn, sn)) < 0)
601: return(0);
602: bp->b_flags |= B_BAD;
603: bp->b_error = npf + 1;
604: bn = st->ncyl*st->nspc - st->nsect - 1 - bn;
605: cn = bn/st->nspc;
606: sn = bn%st->nspc;
607: tn = sn/st->nsect;
608: sn %= st->nsect;
609: #ifdef RKBDEBUG
610: if (rkbdebug)
611: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
612: #endif
613: rk->rkwc = -(512 / sizeof (short));
614: break;
615:
616: case CONT:
617: #ifdef RKBDEBUG
618: if (rkbdebug)
619: printf("rkecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn);
620: #endif
621: bp->b_flags &= ~B_BAD;
622: if ((int)dbtob(npf) >= bp->b_bcount)
623: return (0);
624: rk->rkwc = -((bp->b_bcount - (int)dbtob(npf)) / sizeof (short));
625: break;
626: }
627: rk->rkcs1 = RK_CCLR;
628: rk->rkcs2 = ui->ui_slave;
629: rk->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
630: rkwait(rk);
631: rk->rkcyl = cn;
632: rk->rkda = (tn << 8) | sn;
633: ubaddr = (int)ptob(reg) + o;
634: rk->rkba = ubaddr;
635: cmd = (bp->b_flags&B_READ ? RK_READ : RK_WRITE)|RK_IE|RK_GO;
636: cmd |= (ubaddr >> 8) & 0x300;
637: cmd |= rktypes[ui->ui_type];
638: rk->rkcs1 = cmd;
639: um->um_tab.b_active = 2; /* continuing */
640: um->um_tab.b_errcnt = 0; /* error has been corrected */
641: return (1);
642: }
643:
644: rkreset(uban)
645: int uban;
646: {
647: register struct uba_ctlr *um;
648: register struct uba_device *ui;
649: register rk11, unit;
650:
651: for (rk11 = 0; rk11 < NHK; rk11++) {
652: if ((um = rkminfo[rk11]) == 0 || um->um_ubanum != uban ||
653: um->um_alive == 0)
654: continue;
655: printf(" hk%d", rk11);
656: um->um_tab.b_active = 0;
657: um->um_tab.b_actf = um->um_tab.b_actl = 0;
658: rk_softc[um->um_ctlr].sc_recal = 0;
659: rk_softc[um->um_ctlr].sc_wticks = 0;
660: if (um->um_ubinfo) {
661: printf("<%d>", (um->um_ubinfo>>28)&0xf);
662: um->um_ubinfo = 0;
663: }
664: for (unit = 0; unit < NRK; unit++) {
665: if ((ui = rkdinfo[unit]) == 0)
666: continue;
667: if (ui->ui_alive == 0 || ui->ui_mi != um)
668: continue;
669: rkutab[unit].b_active = 0;
670: (void) rkustart(ui);
671: }
672: (void) rkstart(um);
673: }
674: }
675:
676: rkwatch()
677: {
678: register struct uba_ctlr *um;
679: register rk11, unit;
680: register struct rk_softc *sc;
681:
682: timeout(rkwatch, (caddr_t)0, hz);
683: for (rk11 = 0; rk11 < NHK; rk11++) {
684: um = rkminfo[rk11];
685: if (um == 0 || um->um_alive == 0)
686: continue;
687: sc = &rk_softc[rk11];
688: if (um->um_tab.b_active == 0) {
689: for (unit = 0; unit < NRK; unit++)
690: if (rkutab[unit].b_active &&
691: rkdinfo[unit]->ui_mi == um)
692: goto active;
693: sc->sc_wticks = 0;
694: continue;
695: }
696: active:
697: sc->sc_wticks++;
698: if (sc->sc_wticks >= 20) {
699: sc->sc_wticks = 0;
700: printf("hk%d: lost interrupt\n", rk11);
701: ubareset(um->um_ubanum);
702: }
703: }
704: }
705:
706: #define DBSIZE 20
707:
708: rkdump(dev)
709: dev_t dev;
710: {
711: struct rkdevice *rkaddr;
712: char *start;
713: int num, blk, unit;
714: struct size *sizes;
715: register struct uba_regs *uba;
716: register struct uba_device *ui;
717: register short *rp;
718: struct rkst *st;
719:
720: unit = rkunit(dev);
721: if (unit >= NRK)
722: return (ENXIO);
723: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
724: ui = phys(struct uba_device *, rkdinfo[unit]);
725: if (ui->ui_alive == 0)
726: return (ENXIO);
727: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
728: ubainit(uba);
729: rkaddr = (struct rkdevice *)ui->ui_physaddr;
730: num = maxfree;
731: start = 0;
732: rkaddr->rkcs1 = RK_CCLR;
733: rkaddr->rkcs2 = unit;
734: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_DCLR|RK_GO;
735: rkwait(rkaddr);
736: if ((rkaddr->rkds & RKDS_VV) == 0) {
737: rkaddr->rkcs1 = rktypes[ui->ui_type]|RK_IE|RK_PACK|RK_GO;
738: rkwait(rkaddr);
739: }
740: st = &rkst[ui->ui_type];
741: sizes = phys(struct size *, st->sizes);
742: if (dumplo < 0)
743: return (EINVAL);
744: if (dumplo + num >= sizes[minor(dev)&07].nblocks)
745: num = sizes[minor(dev)&07].nblocks - dumplo;
746: while (num > 0) {
747: register struct pte *io;
748: register int i;
749: int cn, sn, tn;
750: daddr_t bn;
751:
752: blk = num > DBSIZE ? DBSIZE : num;
753: io = uba->uba_map;
754: for (i = 0; i < blk; i++)
755: *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV;
756: *(int *)io = 0;
757: bn = dumplo + btop(start);
758: cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
759: sn = bn%st->nspc;
760: tn = sn/st->nsect;
761: sn = sn%st->nsect;
762: rkaddr->rkcyl = cn;
763: rp = (short *) &rkaddr->rkda;
764: *rp = (tn << 8) + sn;
765: *--rp = 0;
766: *--rp = -blk*NBPG / sizeof (short);
767: *--rp = rktypes[ui->ui_type]|RK_GO|RK_WRITE;
768: rkwait(rkaddr);
769: if (rkaddr->rkcs1 & RK_CERR)
770: return (EIO);
771: start += blk*NBPG;
772: num -= blk;
773: }
774: return (0);
775: }
776:
777: rksize(dev)
778: dev_t dev;
779: {
780: int unit = rkunit(dev);
781: struct uba_device *ui;
782: struct rkst *st;
783:
784: if (unit >= NRK || (ui = rkdinfo[unit]) == 0 || ui->ui_alive == 0)
785: return (-1);
786: st = &rkst[ui->ui_type];
787: return (st->sizes[minor(dev) & 07].nblocks);
788: }
789: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.