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