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