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