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