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