![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to up.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 up.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxuba |
1.1 root 1: /* up.c 6.1 83/07/29 */
2:
3: #include "up.h"
4: #if NSC > 0
5: /*
6: * UNIBUS disk driver with:
7: * overlapped seeks,
8: * ECC recovery, and
9: * bad sector forwarding.
10: *
11: * TODO:
12: * Check that offset recovery code works
13: */
14: #include "../machine/pte.h"
15:
16: #include "../h/param.h"
17: #include "../h/systm.h"
18: #include "../h/dk.h"
19: #include "../h/dkbad.h"
20: #include "../h/buf.h"
21: #include "../h/conf.h"
22: #include "../h/dir.h"
23: #include "../h/user.h"
24: #include "../h/map.h"
25: #include "../h/vm.h"
26: #include "../h/cmap.h"
27: #include "../h/uio.h"
28: #include "../h/kernel.h"
29:
30: #include "../vax/cpu.h"
31: #include "../vax/nexus.h"
32: #include "../vaxuba/ubavar.h"
33: #include "../vaxuba/ubareg.h"
34: #include "../vaxuba/upreg.h"
35:
36: struct up_softc {
37: int sc_softas;
38: int sc_ndrive;
39: int sc_wticks;
40: int sc_recal;
41: } up_softc[NSC];
42:
43: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
44: struct size {
45: daddr_t nblocks;
46: int cyloff;
47: } up9300_sizes[8] = {
48: 15884, 0, /* A=cyl 0 thru 26 */
49: 33440, 27, /* B=cyl 27 thru 81 */
50: 495520, 0, /* C=cyl 0 thru 814 */
51: 15884, 562, /* D=cyl 562 thru 588 */
52: 55936, 589, /* E=cyl 589 thru 680 */
53: 81376, 681, /* F=cyl 681 thru 814 */
54: 153728, 562, /* G=cyl 562 thru 814 */
55: 291346, 82, /* H=cyl 82 thru 561 */
56: }, up9766_sizes[8] = {
57: 15884, 0, /* A=cyl 0 thru 26 */
58: 33440, 27, /* B=cyl 27 thru 81 */
59: 500384, 0, /* C=cyl 0 thru 822 */
60: 15884, 562, /* D=cyl 562 thru 588 */
61: 55936, 589, /* E=cyl 589 thru 680 */
62: 86240, 681, /* F=cyl 681 thru 822 */
63: 158592, 562, /* G=cyl 562 thru 822 */
64: 291346, 82, /* H=cyl 82 thru 561 */
65: }, up160_sizes[8] = {
66: 15884, 0, /* A=cyl 0 thru 49 */
67: 33440, 50, /* B=cyl 50 thru 154 */
68: 263360, 0, /* C=cyl 0 thru 822 */
69: 15884, 155, /* D=cyl 155 thru 204 */
70: 55936, 205, /* E=cyl 205 thru 379 */
71: 141664, 380, /* F=cyl 380 thru 822 */
72: 213664, 155, /* G=cyl 155 thru 822 */
73: 0, 0,
74: }, upam_sizes[8] = {
75: 15884, 0, /* A=cyl 0 thru 31 */
76: 33440, 32, /* B=cyl 32 thru 97 */
77: 524288, 0, /* C=cyl 0 thru 1023 */
78: 15884, 668, /* D=cyl 668 thru 699 */
79: 55936, 700, /* E=cyl 700 thru 809 */
80: 109472, 810, /* F=cyl 810 thru 1023 */
81: 182176, 668, /* G=cyl 668 thru 1023 */
82: 291346, 98, /* H=cyl 98 thru 667 */
83: }, up980_sizes[8] = {
84: 15884, 0, /* A=cyl 0 thru 99 */
85: 33440, 100, /* B=cyl 100 thru 308 */
86: 131680, 0, /* C=cyl 0 thru 822 */
87: 15884, 309, /* D=cyl 309 thru 408 */
88: 55936, 409, /* E=cyl 409 thru 758 */
89: 10080, 759, /* F=cyl 759 thru 822 */
90: 82080, 309, /* G=cyl 309 thru 822 */
91: 0, 0,
92: };
93: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
94:
95: int upprobe(), upslave(), upattach(), updgo(), upintr();
96: struct uba_ctlr *upminfo[NSC];
97: struct uba_device *updinfo[NUP];
98: #define UPIPUNITS 8
99: struct uba_device *upip[NSC][UPIPUNITS]; /* fuji w/fixed head gives n,n+4 */
100:
101: u_short upstd[] = { 0776700, 0774400, 0776300, 0 };
102: struct uba_driver scdriver =
103: { upprobe, upslave, upattach, updgo, upstd, "up", updinfo, "sc", upminfo };
104: struct buf uputab[NUP];
105: char upinit[NUP];
106:
107: struct upst {
108: short nsect; /* # sectors/track */
109: short ntrak; /* # tracks/cylinder */
110: short nspc; /* # sectors/cylinder */
111: short ncyl; /* # cylinders */
112: struct size *sizes; /* partition tables */
113: short sdist; /* seek distance metric */
114: short rdist; /* rotational distance metric */
115: } upst[] = {
116: { 32, 19, 32*19, 815, up9300_sizes, 3, 4 }, /* 9300 */
117: { 32, 19, 32*19, 823, up9766_sizes, 3, 4 }, /* 9766 */
118: { 32, 10, 32*10, 823, up160_sizes, 3, 4 }, /* fuji 160m */
119: { 32, 16, 32*16, 1024, upam_sizes, 7, 8 }, /* Capricorn */
120: { 32, 5, 32*5, 823, up980_sizes, 3, 4 }, /* DM980 */
121: { 0, 0, 0, 0, 0, 0, 0 }
122: };
123:
124: u_char up_offset[16] = {
125: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400,
126: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800,
127: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200,
128: 0, 0, 0, 0
129: };
130:
131: struct buf rupbuf[NUP];
132: struct buf bupbuf[NUP];
133: struct dkbad upbad[NUP];
134:
135: #define b_cylin b_resid
136:
137: #ifdef INTRLVE
138: daddr_t dkblock();
139: #endif
140:
141: int upwstart, upwatch(); /* Have started guardian */
142: int upseek;
143: int upwaitdry;
144:
145: /*ARGSUSED*/
146: upprobe(reg)
147: caddr_t reg;
148: {
149: register int br, cvec;
150:
151: #ifdef lint
152: br = 0; cvec = br; br = cvec; upintr(0);
153: #endif
154: ((struct updevice *)reg)->upcs1 = UP_IE|UP_RDY;
155: DELAY(10);
156: ((struct updevice *)reg)->upcs1 = 0;
157: return (sizeof (struct updevice));
158: }
159:
160: upslave(ui, reg)
161: struct uba_device *ui;
162: caddr_t reg;
163: {
164: register struct updevice *upaddr = (struct updevice *)reg;
165:
166: upaddr->upcs1 = 0; /* conservative */
167: upaddr->upcs2 = ui->ui_slave;
168: upaddr->upcs1 = UP_NOP|UP_GO;
169: if (upaddr->upcs2&UPCS2_NED) {
170: upaddr->upcs1 = UP_DCLR|UP_GO;
171: return (0);
172: }
173: return (1);
174: }
175:
176: upattach(ui)
177: register struct uba_device *ui;
178: {
179:
180: if (upwstart == 0) {
181: timeout(upwatch, (caddr_t)0, hz);
182: upwstart++;
183: }
184: if (ui->ui_dk >= 0)
185: dk_mspw[ui->ui_dk] = .0000020345;
186: upip[ui->ui_ctlr][ui->ui_slave] = ui;
187: up_softc[ui->ui_ctlr].sc_ndrive++;
188: ui->ui_type = upmaptype(ui);
189: }
190:
191: upmaptype(ui)
192: register struct uba_device *ui;
193: {
194: register struct updevice *upaddr = (struct updevice *)ui->ui_addr;
195: int type = ui->ui_type;
196: register struct upst *st;
197:
198: upaddr->upcs1 = 0;
199: upaddr->upcs2 = ui->ui_slave;
200: upaddr->uphr = UPHR_MAXTRAK;
201: for (st = upst; st->nsect != 0; st++)
202: if (upaddr->uphr == st->ntrak - 1) {
203: type = st - upst;
204: break;
205: }
206: if (st->nsect == 0)
207: printf("up%d: uphr=%x\n", ui->ui_slave, upaddr->uphr);
208: if (type == 0) {
209: upaddr->uphr = UPHR_MAXCYL;
210: if (upaddr->uphr == 822)
211: type++;
212: }
213: upaddr->upcs2 = UPCS2_CLR;
214: return (type);
215: }
216:
217: upopen(dev)
218: dev_t dev;
219: {
220: register int unit = minor(dev) >> 3;
221: register struct uba_device *ui;
222:
223: if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0)
224: return (ENXIO);
225: return (0);
226: }
227:
228: upstrategy(bp)
229: register struct buf *bp;
230: {
231: register struct uba_device *ui;
232: register struct upst *st;
233: register int unit;
234: register struct buf *dp;
235: int xunit = minor(bp->b_dev) & 07;
236: long bn, sz;
237:
238: sz = (bp->b_bcount+511) >> 9;
239: unit = dkunit(bp);
240: if (unit >= NUP)
241: goto bad;
242: ui = updinfo[unit];
243: if (ui == 0 || ui->ui_alive == 0)
244: goto bad;
245: st = &upst[ui->ui_type];
246: if (bp->b_blkno < 0 ||
247: (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks)
248: goto bad;
249: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
250: (void) spl5();
251: dp = &uputab[ui->ui_unit];
252: disksort(dp, bp);
253: if (dp->b_active == 0) {
254: (void) upustart(ui);
255: bp = &ui->ui_mi->um_tab;
256: if (bp->b_actf && bp->b_active == 0)
257: (void) upstart(ui->ui_mi);
258: }
259: (void) spl0();
260: return;
261:
262: bad:
263: bp->b_flags |= B_ERROR;
264: iodone(bp);
265: return;
266: }
267:
268: /*
269: * Unit start routine.
270: * Seek the drive to be where the data is
271: * and then generate another interrupt
272: * to actually start the transfer.
273: * If there is only one drive on the controller,
274: * or we are very close to the data, don't
275: * bother with the search. If called after
276: * searching once, don't bother to look where
277: * we are, just queue for transfer (to avoid
278: * positioning forever without transferrring.)
279: */
280: upustart(ui)
281: register struct uba_device *ui;
282: {
283: register struct buf *bp, *dp;
284: register struct uba_ctlr *um;
285: register struct updevice *upaddr;
286: register struct upst *st;
287: daddr_t bn;
288: int sn, csn;
289: /*
290: * The SC21 cancels commands if you just say
291: * cs1 = UP_IE
292: * so we are cautious about handling of cs1.
293: * Also don't bother to clear as bits other than in upintr().
294: */
295: int didie = 0;
296:
297: if (ui == 0)
298: return (0);
299: um = ui->ui_mi;
300: dk_busy &= ~(1<<ui->ui_dk);
301: dp = &uputab[ui->ui_unit];
302: if ((bp = dp->b_actf) == NULL)
303: goto out;
304: /*
305: * If the controller is active, just remember
306: * that this device would like to be positioned...
307: * if we tried to position now we would confuse the SC21.
308: */
309: if (um->um_tab.b_active) {
310: up_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave;
311: return (0);
312: }
313: /*
314: * If we have already positioned this drive,
315: * then just put it on the ready queue.
316: */
317: if (dp->b_active)
318: goto done;
319: dp->b_active = 1;
320: upaddr = (struct updevice *)um->um_addr;
321: upaddr->upcs2 = ui->ui_slave;
322: /*
323: * If drive has just come up,
324: * setup the pack.
325: */
326: if ((upaddr->upds & UPDS_VV) == 0 || upinit[ui->ui_unit] == 0) {
327: struct buf *bbp = &bupbuf[ui->ui_unit];
328:
329: /* SHOULD WARN SYSTEM THAT THIS HAPPENED */
330: upinit[ui->ui_unit] = 1;
331: upaddr->upcs1 = UP_IE|UP_DCLR|UP_GO;
332: upaddr->upcs1 = UP_IE|UP_PRESET|UP_GO;
333: upaddr->upof = UPOF_FMT22;
334: didie = 1;
335: st = &upst[ui->ui_type];
336: bbp->b_flags = B_READ|B_BUSY;
337: bbp->b_dev = bp->b_dev;
338: bbp->b_bcount = 512;
339: bbp->b_un.b_addr = (caddr_t)&upbad[ui->ui_unit];
340: bbp->b_blkno = st->ncyl * st->nspc - st->nsect;
341: bbp->b_cylin = st->ncyl - 1;
342: dp->b_actf = bbp;
343: bbp->av_forw = bp;
344: bp = bbp;
345: }
346: /*
347: * If drive is offline, forget about positioning.
348: */
349: if ((upaddr->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL))
350: goto done;
351: /*
352: * If there is only one drive,
353: * dont bother searching.
354: */
355: if (up_softc[um->um_ctlr].sc_ndrive == 1)
356: goto done;
357: /*
358: * Figure out where this transfer is going to
359: * and see if we are close enough to justify not searching.
360: */
361: st = &upst[ui->ui_type];
362: bn = dkblock(bp);
363: sn = bn%st->nspc;
364: sn = (sn + st->nsect - st->sdist) % st->nsect;
365: if (bp->b_cylin - upaddr->updc)
366: goto search; /* Not on-cylinder */
367: else if (upseek)
368: goto done; /* Ok just to be on-cylinder */
369: csn = (upaddr->upla>>6) - sn - 1;
370: if (csn < 0)
371: csn += st->nsect;
372: if (csn > st->nsect - st->rdist)
373: goto done;
374: search:
375: upaddr->updc = bp->b_cylin;
376: /*
377: * Not on cylinder at correct position,
378: * seek/search.
379: */
380: if (upseek)
381: upaddr->upcs1 = UP_IE|UP_SEEK|UP_GO;
382: else {
383: upaddr->upda = sn;
384: upaddr->upcs1 = UP_IE|UP_SEARCH|UP_GO;
385: }
386: didie = 1;
387: /*
388: * Mark unit busy for iostat.
389: */
390: if (ui->ui_dk >= 0) {
391: dk_busy |= 1<<ui->ui_dk;
392: dk_seek[ui->ui_dk]++;
393: }
394: goto out;
395: done:
396: /*
397: * Device is ready to go.
398: * Put it on the ready queue for the controller
399: * (unless its already there.)
400: */
401: if (dp->b_active != 2) {
402: dp->b_forw = NULL;
403: if (um->um_tab.b_actf == NULL)
404: um->um_tab.b_actf = dp;
405: else
406: um->um_tab.b_actl->b_forw = dp;
407: um->um_tab.b_actl = dp;
408: dp->b_active = 2;
409: }
410: out:
411: return (didie);
412: }
413:
414: /*
415: * Start up a transfer on a drive.
416: */
417: upstart(um)
418: register struct uba_ctlr *um;
419: {
420: register struct buf *bp, *dp;
421: register struct uba_device *ui;
422: register struct updevice *upaddr;
423: struct upst *st;
424: daddr_t bn;
425: int dn, sn, tn, cmd, waitdry;
426:
427: loop:
428: /*
429: * Pull a request off the controller queue
430: */
431: if ((dp = um->um_tab.b_actf) == NULL)
432: return (0);
433: if ((bp = dp->b_actf) == NULL) {
434: um->um_tab.b_actf = dp->b_forw;
435: goto loop;
436: }
437: /*
438: * Mark controller busy, and
439: * determine destination of this request.
440: */
441: um->um_tab.b_active++;
442: ui = updinfo[dkunit(bp)];
443: bn = dkblock(bp);
444: dn = ui->ui_slave;
445: st = &upst[ui->ui_type];
446: sn = bn%st->nspc;
447: tn = sn/st->nsect;
448: sn %= st->nsect;
449: upaddr = (struct updevice *)ui->ui_addr;
450: /*
451: * Select drive if not selected already.
452: */
453: if ((upaddr->upcs2&07) != dn)
454: upaddr->upcs2 = dn;
455: /*
456: * Check that it is ready and online
457: */
458: waitdry = 0;
459: while ((upaddr->upds&UPDS_DRY) == 0) {
460: printf("up%d: ds wait ds=%o\n",dkunit(bp),upaddr->upds);
461: if (++waitdry > 512)
462: break;
463: upwaitdry++;
464: }
465: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
466: printf("up%d: not ready", dkunit(bp));
467: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
468: printf("\n");
469: um->um_tab.b_active = 0;
470: um->um_tab.b_errcnt = 0;
471: dp->b_actf = bp->av_forw;
472: dp->b_active = 0;
473: bp->b_flags |= B_ERROR;
474: iodone(bp);
475: goto loop;
476: }
477: /*
478: * Oh, well, sometimes this
479: * happens, for reasons unknown.
480: */
481: printf(" (flakey)\n");
482: }
483: /*
484: * Setup for the transfer, and get in the
485: * UNIBUS adaptor queue.
486: */
487: upaddr->updc = bp->b_cylin;
488: upaddr->upda = (tn << 8) + sn;
489: upaddr->upwc = -bp->b_bcount / sizeof (short);
490: if (bp->b_flags & B_READ)
491: cmd = UP_IE|UP_RCOM|UP_GO;
492: else
493: cmd = UP_IE|UP_WCOM|UP_GO;
494: um->um_cmd = cmd;
495: (void) ubago(ui);
496: return (1);
497: }
498:
499: /*
500: * Now all ready to go, stuff the registers.
501: */
502: updgo(um)
503: struct uba_ctlr *um;
504: {
505: register struct updevice *upaddr = (struct updevice *)um->um_addr;
506:
507: um->um_tab.b_active = 2; /* should now be 2 */
508: upaddr->upba = um->um_ubinfo;
509: upaddr->upcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300);
510: }
511:
512: /*
513: * Handle a disk interrupt.
514: */
515: upintr(sc21)
516: register sc21;
517: {
518: register struct buf *bp, *dp;
519: register struct uba_ctlr *um = upminfo[sc21];
520: register struct uba_device *ui;
521: register struct updevice *upaddr = (struct updevice *)um->um_addr;
522: register unit;
523: struct up_softc *sc = &up_softc[um->um_ctlr];
524: int as = (upaddr->upas & 0377) | sc->sc_softas;
525: int needie = 1, waitdry;
526:
527: sc->sc_wticks = 0;
528: sc->sc_softas = 0;
529: /*
530: * If controller wasn't transferring, then this is an
531: * interrupt for attention status on seeking drives.
532: * Just service them.
533: */
534: if (um->um_tab.b_active != 2 && !sc->sc_recal) {
535: if (upaddr->upcs1 & UP_TRE)
536: upaddr->upcs1 = UP_TRE;
537: goto doattn;
538: }
539: um->um_tab.b_active = 1;
540: /*
541: * Get device and block structures, and a pointer
542: * to the uba_device for the drive. Select the drive.
543: */
544: dp = um->um_tab.b_actf;
545: bp = dp->b_actf;
546: ui = updinfo[dkunit(bp)];
547: dk_busy &= ~(1 << ui->ui_dk);
548: if ((upaddr->upcs2&07) != ui->ui_slave)
549: upaddr->upcs2 = ui->ui_slave;
550: if (bp->b_flags&B_BAD) {
551: if (upecc(ui, CONT))
552: return;
553: }
554: /*
555: * Check for and process errors on
556: * either the drive or the controller.
557: */
558: if ((upaddr->upds&UPDS_ERR) || (upaddr->upcs1&UP_TRE)) {
559: waitdry = 0;
560: while ((upaddr->upds & UPDS_DRY) == 0) {
561: if (++waitdry > 512)
562: break;
563: upwaitdry++;
564: }
565: if (upaddr->uper1&UPER1_WLE) {
566: /*
567: * Give up on write locked devices
568: * immediately.
569: */
570: printf("up%d: write locked\n", dkunit(bp));
571: bp->b_flags |= B_ERROR;
572: } else if (++um->um_tab.b_errcnt > 27) {
573: /*
574: * After 28 retries (16 without offset, and
575: * 12 with offset positioning) give up.
576: * If the error was header CRC, the header is
577: * screwed up, and the sector may in fact exist
578: * in the bad sector table, better check...
579: */
580: if (upaddr->uper1&UPER1_HCRC) {
581: if (upecc(ui, BSE))
582: return;
583: }
584: hard:
585: harderr(bp, "up");
586: printf("cn=%d tn=%d sn=%d cs2=%b er1=%b er2=%b\n",
587: upaddr->updc, ((upaddr->upda)>>8)&077,
588: (upaddr->upda)&037,
589: upaddr->upcs2, UPCS2_BITS,
590: upaddr->uper1, UPER1_BITS,
591: upaddr->uper2, UPER2_BITS);
592: bp->b_flags |= B_ERROR;
593: } else if (upaddr->uper2 & UPER2_BSE) {
594: if (upecc(ui, BSE))
595: return;
596: else
597: goto hard;
598: } else {
599: /*
600: * Retriable error.
601: * If a soft ecc, correct it (continuing
602: * by returning if necessary.
603: * Otherwise fall through and retry the transfer
604: */
605: if ((upaddr->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK) {
606: if (upecc(ui, ECC))
607: return;
608: } else
609: um->um_tab.b_active = 0; /* force retry */
610: }
611: /*
612: * Clear drive error and, every eight attempts,
613: * (starting with the fourth)
614: * recalibrate to clear the slate.
615: */
616: upaddr->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
617: needie = 0;
618: if ((um->um_tab.b_errcnt&07) == 4 && um->um_tab.b_active == 0) {
619: upaddr->upcs1 = UP_RECAL|UP_IE|UP_GO;
620: sc->sc_recal = 0;
621: goto nextrecal;
622: }
623: }
624: /*
625: * Advance recalibration finite state machine
626: * if recalibrate in progress, through
627: * RECAL
628: * SEEK
629: * OFFSET (optional)
630: * RETRY
631: */
632: switch (sc->sc_recal) {
633:
634: case 1:
635: upaddr->updc = bp->b_cylin;
636: upaddr->upcs1 = UP_SEEK|UP_IE|UP_GO;
637: goto nextrecal;
638: case 2:
639: if (um->um_tab.b_errcnt < 16 || (bp->b_flags&B_READ) == 0)
640: goto donerecal;
641: upaddr->upof = up_offset[um->um_tab.b_errcnt & 017] | UPOF_FMT22;
642: upaddr->upcs1 = UP_IE|UP_OFFSET|UP_GO;
643: goto nextrecal;
644: nextrecal:
645: sc->sc_recal++;
646: um->um_tab.b_active = 1;
647: return;
648: donerecal:
649: case 3:
650: sc->sc_recal = 0;
651: um->um_tab.b_active = 0;
652: break;
653: }
654: /*
655: * If still ``active'', then don't need any more retries.
656: */
657: if (um->um_tab.b_active) {
658: /*
659: * If we were offset positioning,
660: * return to centerline.
661: */
662: if (um->um_tab.b_errcnt >= 16) {
663: upaddr->upof = UPOF_FMT22;
664: upaddr->upcs1 = UP_RTC|UP_GO|UP_IE;
665: while (upaddr->upds & UPDS_PIP)
666: DELAY(25);
667: needie = 0;
668: }
669: um->um_tab.b_active = 0;
670: um->um_tab.b_errcnt = 0;
671: um->um_tab.b_actf = dp->b_forw;
672: dp->b_active = 0;
673: dp->b_errcnt = 0;
674: dp->b_actf = bp->av_forw;
675: bp->b_resid = (-upaddr->upwc * sizeof(short));
676: iodone(bp);
677: /*
678: * If this unit has more work to do,
679: * then start it up right away.
680: */
681: if (dp->b_actf)
682: if (upustart(ui))
683: needie = 0;
684: }
685: as &= ~(1<<ui->ui_slave);
686: /*
687: * Release unibus resources and flush data paths.
688: */
689: ubadone(um);
690: doattn:
691: /*
692: * Process other units which need attention.
693: * For each unit which needs attention, call
694: * the unit start routine to place the slave
695: * on the controller device queue.
696: */
697: while (unit = ffs(as)) {
698: unit--; /* was 1 origin */
699: as &= ~(1<<unit);
700: upaddr->upas = 1<<unit;
701: if (unit < UPIPUNITS && upustart(upip[sc21][unit]))
702: needie = 0;
703: }
704: /*
705: * If the controller is not transferring, but
706: * there are devices ready to transfer, start
707: * the controller.
708: */
709: if (um->um_tab.b_actf && um->um_tab.b_active == 0)
710: if (upstart(um))
711: needie = 0;
712: if (needie)
713: upaddr->upcs1 = UP_IE;
714: }
715:
716: upread(dev, uio)
717: dev_t dev;
718: struct uio *uio;
719: {
720: register int unit = minor(dev) >> 3;
721:
722: if (unit >= NUP)
723: return (ENXIO);
724: return (physio(upstrategy, &rupbuf[unit], dev, B_READ, minphys, uio));
725: }
726:
727: upwrite(dev, uio)
728: dev_t dev;
729: struct uio *uio;
730: {
731: register int unit = minor(dev) >> 3;
732:
733: if (unit >= NUP)
734: return (ENXIO);
735: return (physio(upstrategy, &rupbuf[unit], dev, B_WRITE, minphys, uio));
736: }
737:
738: /*
739: * Correct an ECC error, and restart the i/o to complete
740: * the transfer if necessary. This is quite complicated because
741: * the transfer may be going to an odd memory address base and/or
742: * across a page boundary.
743: */
744: upecc(ui, flag)
745: register struct uba_device *ui;
746: int flag;
747: {
748: register struct updevice *up = (struct updevice *)ui->ui_addr;
749: register struct buf *bp = uputab[ui->ui_unit].b_actf;
750: register struct uba_ctlr *um = ui->ui_mi;
751: register struct upst *st;
752: struct uba_regs *ubp = ui->ui_hd->uh_uba;
753: register int i;
754: caddr_t addr;
755: int reg, bit, byte, npf, mask, o, cmd, ubaddr;
756: int bn, cn, tn, sn;
757:
758: /*
759: * Npf is the number of sectors transferred before the sector
760: * containing the ECC error, and reg is the UBA register
761: * mapping (the first part of) the transfer.
762: * O is offset within a memory page of the first byte transferred.
763: */
764: if (flag == CONT)
765: npf = bp->b_error;
766: else
767: npf = btop((up->upwc * sizeof(short)) + bp->b_bcount);
768: reg = btop(um->um_ubinfo&0x3ffff) + npf;
769: o = (int)bp->b_un.b_addr & PGOFSET;
770: mask = up->upec2;
771: #ifdef UPECCDEBUG
772: printf("npf %d reg %x o %d mask %o pos %d\n", npf, reg, o, mask,
773: up->upec1);
774: #endif
775: bn = dkblock(bp);
776: st = &upst[ui->ui_type];
777: cn = bp->b_cylin;
778: sn = bn%st->nspc + npf;
779: tn = sn/st->nsect;
780: sn %= st->nsect;
781: cn += tn/st->ntrak;
782: tn %= st->ntrak;
783: ubapurge(um);
784: um->um_tab.b_active=2;
785: /*
786: * action taken depends on the flag
787: */
788: switch(flag){
789: case ECC:
790: npf--;
791: reg--;
792: mask = up->upec2;
793: printf("up%d%c: soft ecc sn%d\n", dkunit(bp),
794: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
795: /*
796: * Flush the buffered data path, and compute the
797: * byte and bit position of the error. The variable i
798: * is the byte offset in the transfer, the variable byte
799: * is the offset from a page boundary in main memory.
800: */
801: i = up->upec1 - 1; /* -1 makes 0 origin */
802: bit = i&07;
803: i = (i&~07)>>3;
804: byte = i + o;
805: /*
806: * Correct while possible bits remain of mask. Since mask
807: * contains 11 bits, we continue while the bit offset is > -11.
808: * Also watch out for end of this block and the end of the whole
809: * transfer.
810: */
811: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
812: struct pte pte;
813:
814: pte = ubp->uba_map[reg + btop(byte)];
815: addr = ptob(pte.pg_pfnum) + (byte & PGOFSET);
816: #ifdef UPECCDEBUG
817: printf("addr %x map reg %x\n",
818: addr, *(int *)(&ubp->uba_map[reg+btop(byte)]));
819: printf("old: %x, ", getmemc(addr));
820: #endif
821: putmemc(addr, getmemc(addr)^(mask<<bit));
822: #ifdef UPECCDEBUG
823: printf("new: %x\n", getmemc(addr));
824: #endif
825: byte++;
826: i++;
827: bit -= 8;
828: }
829: if (up->upwc == 0)
830: return (0);
831: npf++;
832: reg++;
833: break;
834: case BSE:
835: /*
836: * if not in bad sector table, return 0
837: */
838: if ((bn = isbad(&upbad[ui->ui_unit], cn, tn, sn)) < 0)
839: return(0);
840: /*
841: * flag this one as bad
842: */
843: bp->b_flags |= B_BAD;
844: bp->b_error = npf + 1;
845: #ifdef UPECCDEBUG
846: printf("BSE: restart at %d\n",npf+1);
847: #endif
848: bn = st->ncyl * st->nspc -st->nsect - 1 - bn;
849: cn = bn / st->nspc;
850: sn = bn % st->nspc;
851: tn = sn / st->nsect;
852: sn %= st->nsect;
853: up->upwc = -(512 / sizeof (short));
854: #ifdef UPECCDEBUG
855: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
856: #endif
857: break;
858: case CONT:
859: #ifdef UPECCDEBUG
860: printf("upecc, CONT: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn);
861: #endif
862: bp->b_flags &= ~B_BAD;
863: up->upwc = -((bp->b_bcount - (int)ptob(npf)) / sizeof(short));
864: if (up->upwc == 0)
865: return(0);
866: break;
867: }
868: if (up->upwc == 0) {
869: um->um_tab.b_active = 0;
870: return (0);
871: }
872: /*
873: * Have to continue the transfer... clear the drive,
874: * and compute the position where the transfer is to continue.
875: * We have completed npf+1 sectors of the transfer already;
876: * restart at offset o of next sector (i.e. in UBA register reg+1).
877: */
878: #ifdef notdef
879: up->uper1 = 0;
880: up->upcs1 |= UP_GO;
881: #else
882: up->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
883: up->updc = cn;
884: up->upda = (tn << 8) | sn;
885: ubaddr = (int)ptob(reg) + o;
886: up->upba = ubaddr;
887: cmd = (ubaddr >> 8) & 0x300;
888: cmd |= ((bp->b_flags&B_READ)?UP_RCOM:UP_WCOM)|UP_IE|UP_GO;
889: um->um_tab.b_errcnt = 0;
890: up->upcs1 = cmd;
891: #endif
892: return (1);
893: }
894:
895: /*
896: * Reset driver after UBA init.
897: * Cancel software state of all pending transfers
898: * and restart all units and the controller.
899: */
900: upreset(uban)
901: int uban;
902: {
903: register struct uba_ctlr *um;
904: register struct uba_device *ui;
905: register sc21, unit;
906:
907: for (sc21 = 0; sc21 < NSC; sc21++) {
908: if ((um = upminfo[sc21]) == 0 || um->um_ubanum != uban ||
909: um->um_alive == 0)
910: continue;
911: printf(" sc%d", sc21);
912: um->um_tab.b_active = 0;
913: um->um_tab.b_actf = um->um_tab.b_actl = 0;
914: up_softc[sc21].sc_recal = 0;
915: up_softc[sc21].sc_wticks = 0;
916: if (um->um_ubinfo) {
917: printf("<%d>", (um->um_ubinfo>>28)&0xf);
918: um->um_ubinfo = 0;
919: }
920: ((struct updevice *)(um->um_addr))->upcs2 = UPCS2_CLR;
921: for (unit = 0; unit < NUP; unit++) {
922: if ((ui = updinfo[unit]) == 0)
923: continue;
924: if (ui->ui_alive == 0 || ui->ui_mi != um)
925: continue;
926: uputab[unit].b_active = 0;
927: (void) upustart(ui);
928: }
929: (void) upstart(um);
930: }
931: }
932:
933: /*
934: * Wake up every second and if an interrupt is pending
935: * but nothing has happened increment a counter.
936: * If nothing happens for 20 seconds, reset the UNIBUS
937: * and begin anew.
938: */
939: upwatch()
940: {
941: register struct uba_ctlr *um;
942: register sc21, unit;
943: register struct up_softc *sc;
944:
945: timeout(upwatch, (caddr_t)0, hz);
946: for (sc21 = 0; sc21 < NSC; sc21++) {
947: um = upminfo[sc21];
948: if (um == 0 || um->um_alive == 0)
949: continue;
950: sc = &up_softc[sc21];
951: if (um->um_tab.b_active == 0) {
952: for (unit = 0; unit < NUP; unit++)
953: if (uputab[unit].b_active &&
954: updinfo[unit]->ui_mi == um)
955: goto active;
956: sc->sc_wticks = 0;
957: continue;
958: }
959: active:
960: sc->sc_wticks++;
961: if (sc->sc_wticks >= 20) {
962: sc->sc_wticks = 0;
963: printf("sc%d: lost interrupt\n", sc21);
964: ubareset(um->um_ubanum);
965: }
966: }
967: }
968:
969: #define DBSIZE 20
970:
971: updump(dev)
972: dev_t dev;
973: {
974: struct updevice *upaddr;
975: char *start;
976: int num, blk, unit;
977: struct size *sizes;
978: register struct uba_regs *uba;
979: register struct uba_device *ui;
980: register short *rp;
981: struct upst *st;
982: register int retry;
983:
984: unit = minor(dev) >> 3;
985: if (unit >= NUP)
986: return (ENXIO);
987: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
988: ui = phys(struct uba_device *, updinfo[unit]);
989: if (ui->ui_alive == 0)
990: return (ENXIO);
991: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
992: ubainit(uba);
993: upaddr = (struct updevice *)ui->ui_physaddr;
994: DELAY(5000000);
995: num = maxfree;
996: upaddr->upcs2 = unit;
997: DELAY(100);
998: upaddr->upcs1 = UP_DCLR|UP_GO;
999: upaddr->upcs1 = UP_PRESET|UP_GO;
1000: upaddr->upof = UPOF_FMT22;
1001: retry = 0;
1002: do {
1003: DELAY(25);
1004: if (++retry > 527)
1005: break;
1006: } while ((upaddr->upds & UP_RDY) == 0);
1007: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY)
1008: return (EFAULT);
1009: start = 0;
1010: st = &upst[ui->ui_type];
1011: sizes = phys(struct size *, st->sizes);
1012: if (dumplo < 0 || dumplo + num >= sizes[minor(dev)&07].nblocks)
1013: return (EINVAL);
1014: while (num > 0) {
1015: register struct pte *io;
1016: register int i;
1017: int cn, sn, tn;
1018: daddr_t bn;
1019:
1020: blk = num > DBSIZE ? DBSIZE : num;
1021: io = uba->uba_map;
1022: for (i = 0; i < blk; i++)
1023: *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV;
1024: *(int *)io = 0;
1025: bn = dumplo + btop(start);
1026: cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
1027: sn = bn%st->nspc;
1028: tn = sn/st->nsect;
1029: sn = sn%st->nsect;
1030: upaddr->updc = cn;
1031: rp = (short *) &upaddr->upda;
1032: *rp = (tn << 8) + sn;
1033: *--rp = 0;
1034: *--rp = -blk*NBPG / sizeof (short);
1035: *--rp = UP_GO|UP_WCOM;
1036: retry = 0;
1037: do {
1038: DELAY(25);
1039: if (++retry > 527)
1040: break;
1041: } while ((upaddr->upcs1 & UP_RDY) == 0);
1042: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
1043: printf("up%d: not ready", unit);
1044: if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
1045: printf("\n");
1046: return (EIO);
1047: }
1048: printf(" (flakey)\n");
1049: }
1050: if (upaddr->upds&UPDS_ERR)
1051: return (EIO);
1052: start += blk*NBPG;
1053: num -= blk;
1054: }
1055: return (0);
1056: }
1057:
1058: upsize(dev)
1059: dev_t dev;
1060: {
1061: int unit = minor(dev) >> 3;
1062: struct uba_device *ui;
1063: struct upst *st;
1064:
1065: if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0)
1066: return (-1);
1067: st = &upst[ui->ui_type];
1068: return (st->sizes[minor(dev) & 07].nblocks);
1069: }
1070: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.