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