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