![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to up.c.SC11 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / sys / dev|
Return to up.c.SC11 CVS log | Up to [CSRG BSD Unix] / 40BSD / sys / dev |
1.1 root 1: /* up.c 3.28 10/21/80 */
2:
3: #include "../conf/up.h"
4: /*
5: * UNIBUS disk driver with overlapped seeks and ECC recovery.
6: *
7: * This driver works marginally on an Emulex SC-11B controller with rev
8: * level J microcode, defining:
9: * int olducode = 1;
10: * to force CPU stalling delays.
11: *
12: * It has worked with no delays and no problems on a prototype
13: * SC-21 controller. Emulex intends to upgrade all SC-11s on VAXes to SC-21s.
14: * You should get a SC-21 to replace any SC-11 on a VAX.
15: *
16: * SC-11B Controller switch settings:
17: * SW1-1 5/19 surfaces (off, 19 surfaces on Ampex 9300)
18: * SW1-2 chksum enable (off, checksum disabled)
19: * SW1-3 volume select (off, 815 cylinders)
20: * SW1-4 sector select (on, 32 sectors)
21: * SW1-5 unused (off)
22: * SW1-6 port select (on, single port)
23: * SW1-7 npr delay (off, disable)
24: * SW1-8 ecc test mode (off, disable)
25: * and top mounted switches:
26: * SW2-1 extend opcodes (off=open, disable)
27: * SW2-2 extend diag (off=open, disable)
28: * SW2-3 4 wd dma burst (on=closed, enable)
29: * SW2-4 unused (off=open)
30: */
31:
32: #include "../h/param.h"
33: #include "../h/systm.h"
34: #include "../h/dk.h"
35: #include "../h/buf.h"
36: #include "../h/conf.h"
37: #include "../h/dir.h"
38: #include "../h/user.h"
39: #include "../h/map.h"
40: #include "../h/pte.h"
41: #include "../h/mba.h"
42: #include "../h/mtpr.h"
43: #include "../h/uba.h"
44: #include "../h/vm.h"
45:
46: #define ushort unsigned short
47:
48: struct device
49: {
50: ushort upcs1; /* control and status register 1 */
51: short upwc; /* word count register */
52: ushort upba; /* UNIBUS address register */
53: ushort upda; /* desired address register */
54: ushort upcs2; /* control and status register 2 */
55: ushort upds; /* drive Status */
56: ushort uper1; /* error register 1 */
57: ushort upas; /* attention summary */
58: ushort upla; /* look ahead */
59: ushort updb; /* data buffer */
60: ushort upmr; /* maintenance */
61: ushort updt; /* drive type */
62: ushort upsn; /* serial number */
63: ushort upof; /* offset register */
64: ushort updc; /* desired cylinder address register */
65: ushort upcc; /* current cylinder */
66: ushort uper2; /* error register 2 */
67: ushort uper3; /* error register 3 */
68: ushort upec1; /* burst error bit position */
69: ushort upec2; /* burst error bit pattern */
70: };
71:
72: /*
73: * Software extension to the upas register, so we can
74: * postpone starting SEARCH commands until the controller
75: * is not transferring.
76: */
77: int upsoftas;
78:
79: /*
80: * If upseek then we don't issue SEARCH commands but rather just
81: * settle for a SEEK to the correct cylinder.
82: */
83: int upseek;
84:
85: #define NSECT 32
86: #define NTRAC 19
87:
88: /*
89: * Constants controlling on-cylinder SEARCH usage.
90: *
91: * upSDIST/2 msec time needed to start transfer
92: * upRDIST/2 msec tolerable rotational latency when on-cylinder
93: *
94: * If we are no closer than upSDIST sectors and no further than upSDIST+upRDIST
95: * and in the driver then we take it as it is. Otherwise we do a SEARCH
96: * requesting an interrupt upSDIST sectors in advance.
97: */
98: #define _upSDIST 2 /* 1.0 msec */
99: #define _upRDIST 4 /* 2.0 msec */
100:
101: int upSDIST = _upSDIST;
102: int upRDIST = _upRDIST;
103:
104: /*
105: * To fill a 300M drive:
106: * A is designed to be used as a root.
107: * B is suitable for a swap area.
108: * H is the primary storage area.
109: * On systems with RP06'es, we normally use only 291346 blocks of the H
110: * area, and use DEF or G to cover the rest of the drive. The C system
111: * covers the whole drive and can be used for pack-pack copying.
112: */
113: struct size
114: {
115: daddr_t nblocks;
116: int cyloff;
117: } up_sizes[8] = {
118: 15884, 0, /* A=cyl 0 thru 26 */
119: 33440, 27, /* B=cyl 27 thru 81 */
120: 495520, 0, /* C=cyl 0 thru 814 */
121: 15884, 562, /* D=cyl 562 thru 588 */
122: 55936, 589, /* E=cyl 589 thru 680 */
123: 81472, 681, /* F=cyl 681 thru 814 */
124: 153824, 562, /* G=cyl 562 thru 814 */
125: 445664, 82, /* H=cyl 82 thru 814 */
126: /* Later, and more safely for H area...
127: 291346, 82, /* H=cyl 82 thru 561 */
128: };
129:
130: /*
131: * The following defines are used in offset positioning
132: * when trying to recover disk errors, with the constants being
133: * +/- microinches. Note that header compare inhibit (HCI) is not
134: * tried (this makes sense only during read, in any case.)
135: *
136: * NOT ALL OF THESE ARE IMPLEMENTED ON 9300!?!
137: */
138: #define P400 020
139: #define M400 0220
140: #define P800 040
141: #define M800 0240
142: #define P1200 060
143: #define M1200 0260
144: #define HCI 020000
145:
146: int up_offset[16] =
147: {
148: P400, M400, P400, M400,
149: P800, M800, P800, M800,
150: P1200, M1200, P1200, M1200,
151: 0, 0, 0, 0,
152: };
153:
154: /*
155: * Each drive has a table uputab[i]. On this table are sorted the
156: * pending requests implementing an elevator algorithm (see dsort.c.)
157: * In the upustart() routine, each drive is independently advanced
158: * until it is on the desired cylinder for the next transfer and near
159: * the desired sector. The drive is then chained onto the uptab
160: * table, and the transfer is initiated by the upstart() routine.
161: * When the transfer is completed the driver reinvokes the upustart()
162: * routine to set up the next transfer.
163: */
164: struct buf uptab;
165: struct buf uputab[NUP];
166:
167: struct buf rupbuf; /* Buffer for raw i/o */
168:
169: /* Drive commands, placed in upcs1 */
170: #define GO 01 /* Go bit, set in all commands */
171: #define PRESET 020 /* Preset drive at init or after errors */
172: #define OFFSET 014 /* Offset heads to try to recover error */
173: #define RTC 016 /* Return to center-line after OFFSET */
174: #define SEARCH 030 /* Search for cylinder+sector */
175: #define SEEK 04 /* Seek to cylinder */
176: #define RECAL 06 /* Recalibrate, needed after seek error */
177: #define DCLR 010 /* Drive clear, after error */
178: #define WCOM 060 /* Write */
179: #define RCOM 070 /* Read */
180:
181: /* Other bits of upcs1 */
182: #define IE 0100 /* Controller wide interrupt enable */
183: #define TRE 040000 /* Transfer error */
184: #define RDY 0200 /* Transfer terminated */
185:
186: /* Drive status bits of upds */
187: #define PIP 020000 /* Positioning in progress */
188: #define ERR 040000 /* Error has occurred, DCLR necessary */
189: #define VV 0100 /* Volume is valid, set by PRESET */
190: #define DPR 0400 /* Drive has been preset */
191: #define MOL 010000 /* Drive is online, heads loaded, etc */
192: #define DRY 0200 /* Drive ready */
193:
194: /* Bits of upcs2 */
195: #define CLR 040 /* Controller clear */
196: /* Bits of uper1 */
197: #define DCK 0100000 /* Ecc error occurred */
198: #define ECH 0100 /* Ecc error was unrecoverable */
199: #define WLE 04000 /* Attempt to write read-only drive */
200:
201: /* Bits of upof; the offset bits above are also in this register */
202: #define FMT22 010000 /* 16 bits/word, must be always set */
203:
204: #define b_cylin b_resid
205:
206: int up_ubinfo; /* Information about UBA usage saved here */
207: /*
208: * The EMULEX controller balks if accessed quickly after
209: * certain operations. With rev J delays seem to be needed only
210: * when selecting a new unit, and in drive initialization type
211: * like PRESET and DCLR. The following variables control the delay
212: * DELAY(n) is approximately n usec.
213: */
214: int olducode = 1;
215: int idelay = 500; /* Delay after PRESET or DCLR */
216: int osdelay = 150; /* Old delay after selecting drive in upcs2 */
217: int ordelay = 100; /* Old delay after SEARCH */
218: int oasdel = 100; /* Old delay after clearing bit in upas */
219: int nsdelay = 25;
220:
221: #define DELAY(N) { register int d; d = N; while (--d > 0); }
222:
223: int nwaitcs2; /* How many sdelay loops ? */
224: int neasycs2; /* How many sdelay loops not needed ? */
225:
226: int up_wticks; /* Ticks waiting for interrupt */
227: int upwstart; /* Have started guardian */
228: int upwatch();
229:
230: #ifdef INTRLVE
231: daddr_t dkblock();
232: #endif
233:
234: /*
235: * Queue an i/o request for a drive, checking first that it is in range.
236: *
237: * A unit start is issued if the drive is inactive, causing
238: * a SEARCH for the correct cylinder/sector. If the drive is
239: * already nearly on the money and the controller is not transferring
240: * we kick it to start the transfer.
241: */
242: upstrategy(bp)
243: register struct buf *bp;
244: {
245: register struct buf *dp;
246: register unit, xunit;
247: long sz, bn;
248:
249: if (upwstart == 0) {
250: timeout((caddr_t)upwatch, 0, HZ);
251: upwstart++;
252: }
253: xunit = minor(bp->b_dev) & 077;
254: sz = bp->b_bcount;
255: sz = (sz+511) >> 9; /* transfer size in 512 byte sectors */
256: unit = dkunit(bp);
257: if (unit >= NUP ||
258: bp->b_blkno < 0 ||
259: (bn = dkblock(bp))+sz > up_sizes[xunit&07].nblocks) {
260: bp->b_flags |= B_ERROR;
261: iodone(bp);
262: return;
263: }
264: if (DK_N+unit <= DK_NMAX)
265: dk_mspw[DK_N+unit] = .0000020345;
266: bp->b_cylin = bn/(NSECT*NTRAC) + up_sizes[xunit&07].cyloff;
267: dp = &uputab[unit];
268: (void) spl5();
269: disksort(dp, bp);
270: if (dp->b_active == 0) {
271: (void) upustart(unit);
272: if (uptab.b_actf && uptab.b_active == 0)
273: (void) upstart();
274: }
275: (void) spl0();
276: }
277:
278: /*
279: * Start activity on specified drive; called when drive is inactive
280: * and new transfer request arrives and also when upas indicates that
281: * a SEARCH command is complete.
282: */
283: upustart(unit)
284: register unit;
285: {
286: register struct buf *bp, *dp;
287: register struct device *upaddr = UPADDR;
288: daddr_t bn;
289: int sn, cn, csn;
290: int didie = 0;
291:
292: /*
293: * Other drivers tend to say something like
294: * upaddr->upcs1 = IE;
295: * upaddr->upas = 1<<unit;
296: * here, but the SC-11B will cancel a command which
297: * happens to be sitting in the cs1 if you clear the go
298: * bit by storing there (so the first is not safe),
299: * and it also does not like being bothered with operations
300: * such as clearing upas when a transfer is active (as
301: * it may well be.)
302: *
303: * Thus we keep careful track of when we re-enable IE
304: * after an interrupt and do it only if we didn't issue
305: * a command which re-enabled it as a matter of course.
306: * We clear bits in upas in the interrupt routine, when
307: * no transfers are active.
308: */
309: if (unit >= NUP)
310: goto out;
311: if (unit+DK_N <= DK_NMAX)
312: dk_busy &= ~(1<<(unit+DK_N));
313: dp = &uputab[unit];
314: if ((bp = dp->b_actf) == NULL)
315: goto out;
316: /*
317: * The SC-11B doesn't start SEARCH commands when transfers are
318: * in progress. In fact, it tends to get confused when given
319: * SEARCH'es during transfers, generating interrupts with neither
320: * RDY nor a bit in the upas register. Thus we defer
321: * until an interrupt when a transfer is pending.
322: */
323: if (uptab.b_active) {
324: upsoftas |= 1<<unit;
325: return (0);
326: }
327: if (dp->b_active)
328: goto done;
329: dp->b_active = 1;
330: if ((upaddr->upcs2 & 07) != unit) {
331: upaddr->upcs2 = unit;
332: DELAY(olducode ? osdelay : nsdelay);
333: nwaitcs2++;
334: } else
335: neasycs2++;
336: /*
337: * If we have changed packs or just initialized,
338: * then the volume will not be valid; if so, clear
339: * the drive, preset it and put in 16bit/word mode.
340: */
341: if ((upaddr->upds & VV) == 0) {
342: upaddr->upcs1 = IE|DCLR|GO;
343: DELAY(idelay);
344: upaddr->upcs1 = IE|PRESET|GO;
345: DELAY(idelay);
346: upaddr->upof = FMT22;
347: didie = 1;
348: }
349: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL))
350: goto done;
351: /*
352: * Do enough of the disk address decoding to determine
353: * which cylinder and sector the request is on.
354: * If we are on the correct cylinder and the desired sector
355: * lies between upSDIST and upSDIST+upRDIST sectors ahead of us, then
356: * we don't bother to SEARCH but just begin the transfer asap.
357: * Otherwise ask for a interrupt upSDIST sectors ahead.
358: */
359: bn = dkblock(bp);
360: cn = bp->b_cylin;
361: sn = bn%(NSECT*NTRAC);
362: sn = (sn+NSECT-upSDIST)%NSECT;
363:
364: if (cn - 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 += NSECT;
371: if (csn > NSECT-upRDIST)
372: goto done;
373:
374: search:
375: upaddr->updc = cn;
376: if (upseek)
377: upaddr->upcs1 = IE|SEEK|GO;
378: else {
379: upaddr->upda = sn;
380: upaddr->upcs1 = IE|SEARCH|GO;
381: }
382: didie = 1;
383: /*
384: * Mark this unit busy.
385: */
386: unit += DK_N;
387: if (unit <= DK_NMAX) {
388: dk_busy |= 1<<unit;
389: dk_seek[unit]++;
390: }
391: if (olducode)
392: DELAY(ordelay);
393: goto out;
394:
395: done:
396: /*
397: * This unit is ready to go so
398: * link it onto the chain of ready disks.
399: */
400: dp->b_forw = NULL;
401: if (uptab.b_actf == NULL)
402: uptab.b_actf = dp;
403: else
404: uptab.b_actl->b_forw = dp;
405: uptab.b_actl = dp;
406:
407: out:
408: return (didie);
409: }
410:
411: /*
412: * Start a transfer; call from top level at spl5() or on interrupt.
413: */
414: upstart()
415: {
416: register struct buf *bp, *dp;
417: register unit;
418: register struct device *upaddr;
419: daddr_t bn;
420: int dn, sn, tn, cn, cmd;
421:
422: loop:
423: /*
424: * Pick a drive off the queue of ready drives, and
425: * perform the first transfer on its queue.
426: *
427: * Looping here is completely for the sake of drives which
428: * are not present and on-line, for which we completely clear the
429: * request queue.
430: */
431: if ((dp = uptab.b_actf) == NULL)
432: return (0);
433: if ((bp = dp->b_actf) == NULL) {
434: uptab.b_actf = dp->b_forw;
435: goto loop;
436: }
437: /*
438: * Mark the controller busy, and multi-part disk address.
439: * Select the unit on which the i/o is to take place.
440: */
441: uptab.b_active++;
442: unit = minor(bp->b_dev) & 077;
443: dn = dkunit(bp);
444: bn = dkblock(bp);
445: cn = up_sizes[unit&07].cyloff;
446: cn += bn/(NSECT*NTRAC);
447: sn = bn%(NSECT*NTRAC);
448: tn = sn/NSECT;
449: sn %= NSECT;
450: upaddr = UPADDR;
451: if ((upaddr->upcs2 & 07) != dn) {
452: upaddr->upcs2 = dn;
453: /* DELAY(sdelay); Provided by ubasetup() */
454: nwaitcs2++;
455: } else
456: neasycs2++;
457: up_ubinfo = ubasetup(bp, 1); /* Providing delay */
458: /*
459: * If drive is not present and on-line, then
460: * get rid of this with an error and loop to get
461: * rid of the rest of its queued requests.
462: * (Then on to any other ready drives.)
463: */
464: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL)) {
465: printf("!DPR || !MOL, unit %d, ds %o", dn, upaddr->upds);
466: if ((upaddr->upds & (DPR|MOL)) != (DPR|MOL)) {
467: printf("-- hard\n");
468: uptab.b_active = 0;
469: uptab.b_errcnt = 0;
470: dp->b_actf = bp->av_forw;
471: dp->b_active = 0;
472: bp->b_flags |= B_ERROR;
473: iodone(bp);
474: /* A funny place to do this ... */
475: ubafree(up_ubinfo), up_ubinfo = 0;
476: goto loop;
477: }
478: printf("-- came back\n");
479: }
480: /*
481: * If this is a retry, then with the 16'th retry we
482: * begin to try offsetting the heads to recover the data.
483: */
484: if (uptab.b_errcnt >= 16 && (bp->b_flags&B_WRITE) == 0) {
485: upaddr->upof = up_offset[uptab.b_errcnt & 017] | FMT22;
486: upaddr->upcs1 = IE|OFFSET|GO;
487: DELAY(idelay);
488: while (upaddr->upds & PIP)
489: DELAY(25);
490: }
491: /*
492: * Now set up the transfer, retrieving the high
493: * 2 bits of the UNIBUS address from the information
494: * returned by ubasetup() for the cs1 register bits 8 and 9.
495: */
496: upaddr->updc = cn;
497: upaddr->upda = (tn << 8) + sn;
498: upaddr->upba = up_ubinfo;
499: upaddr->upwc = -bp->b_bcount / sizeof (short);
500: cmd = (up_ubinfo >> 8) & 0x300;
501: if (bp->b_flags & B_READ)
502: cmd |= IE|RCOM|GO;
503: else
504: cmd |= IE|WCOM|GO;
505: upaddr->upcs1 = cmd;
506: /*
507: * This is a controller busy situation.
508: * Record in dk slot NUP+DK_N (after last drive)
509: * unless there aren't that many slots reserved for
510: * us in which case we record this as a drive busy
511: * (if there is room for that).
512: */
513: unit = dn+DK_N;
514: if (unit <= DK_NMAX) {
515: dk_busy |= 1<<unit;
516: dk_xfer[unit]++;
517: dk_wds[unit] += bp->b_bcount>>6;
518: }
519: return (1);
520: }
521:
522: /*
523: * Handle a device interrupt.
524: *
525: * If the transferring drive needs attention, service it
526: * retrying on error or beginning next transfer.
527: * Service all other ready drives, calling ustart to transfer
528: * their blocks to the ready queue in uptab, and then restart
529: * the controller if there is anything to do.
530: */
531: upintr()
532: {
533: register struct buf *bp, *dp;
534: register unit;
535: register struct device *upaddr = UPADDR;
536: int as = upaddr->upas & 0377;
537: int oupsoftas;
538: int needie = 1;
539:
540: (void) spl6();
541: up_wticks = 0;
542: if (uptab.b_active) {
543: /*
544: * The drive is transferring, thus the hardware
545: * (say the designers) will only interrupt when the transfer
546: * completes; check for it anyways.
547: */
548: if ((upaddr->upcs1 & RDY) == 0) {
549: printf("!RDY: cs1 %o, ds %o, wc %d\n", upaddr->upcs1,
550: upaddr->upds, upaddr->upwc);
551: printf("as=%d act %d %d %d\n", as, uptab.b_active,
552: uputab[0].b_active, uputab[1].b_active);
553: }
554: /*
555: * Mark drive not busy, and check for an
556: * error condition which may have resulted from the transfer.
557: */
558: dp = uptab.b_actf;
559: bp = dp->b_actf;
560: unit = dkunit(bp);
561: if (DK_N+unit <= DK_NMAX)
562: dk_busy &= ~(1<<(DK_N+unit));
563: if ((upaddr->upcs2 & 07) != unit) {
564: upaddr->upcs2 = unit;
565: DELAY(olducode ? osdelay : nsdelay);
566: nwaitcs2++;
567: } else
568: neasycs2++;
569: if ((upaddr->upds&ERR) || (upaddr->upcs1&TRE)) {
570: /*
571: * An error occurred, indeed. Select this unit
572: * to get at the drive status (a SEARCH may have
573: * intervened to change the selected unit), and
574: * wait for the command which caused the interrupt
575: * to complete (DRY).
576: */
577: while ((upaddr->upds & DRY) == 0)
578: DELAY(25);
579: /*
580: * After 28 retries (16 w/o servo offsets, and then
581: * 12 with servo offsets), or if we encountered
582: * an error because the drive is write-protected,
583: * give up. Print an error message on the last 2
584: * retries before a hard failure.
585: */
586: if (++uptab.b_errcnt > 28 || upaddr->uper1&WLE)
587: bp->b_flags |= B_ERROR;
588: else
589: uptab.b_active = 0; /* To force retry */
590: if (uptab.b_errcnt > 27)
591: deverror(bp, upaddr->upcs2, upaddr->uper1);
592: /*
593: * If this was a correctible ECC error, let upecc
594: * do the dirty work to correct it. If upecc
595: * starts another READ for the rest of the data
596: * then it returns 1 (having set uptab.b_active).
597: * Otherwise we are done and fall through to
598: * finish up.
599: */
600: if ((upaddr->uper1&(DCK|ECH))==DCK && upecc(upaddr, bp))
601: return;
602: /*
603: * Clear the drive and, every 4 retries, recalibrate
604: * to hopefully help clear up seek positioning problems.
605: */
606: upaddr->upcs1 = TRE|IE|DCLR|GO;
607: DELAY(idelay);
608: needie = 0;
609: if ((uptab.b_errcnt&07) == 4) {
610: upaddr->upcs1 = RECAL|GO|IE;
611: DELAY(idelay);
612: while(upaddr->upds & PIP)
613: DELAY(25);
614: }
615: }
616: /*
617: * If we are still noted as active, then no
618: * (further) retries are necessary.
619: *
620: * Make sure the correct unit is selected,
621: * return it to centerline if necessary, and mark
622: * this i/o complete, starting the next transfer
623: * on this drive with the upustart routine (if any).
624: */
625: if (uptab.b_active) {
626: if (uptab.b_errcnt >= 16) {
627: upaddr->upcs1 = RTC|GO|IE;
628: DELAY(idelay);
629: while (upaddr->upds & PIP)
630: DELAY(25);
631: needie = 0;
632: }
633: uptab.b_active = 0;
634: uptab.b_errcnt = 0;
635: uptab.b_actf = dp->b_forw;
636: dp->b_active = 0;
637: dp->b_errcnt = 0;
638: dp->b_actf = bp->av_forw;
639: bp->b_resid = (-upaddr->upwc * sizeof(short));
640: if (bp->b_resid)
641: printf("resid %d ds %o er? %o %o %o\n",
642: bp->b_resid, upaddr->upds,
643: upaddr->uper1, upaddr->uper2, upaddr->uper3);
644: iodone(bp);
645: if(dp->b_actf)
646: if (upustart(unit))
647: needie = 0;
648: }
649: as &= ~(1<<unit);
650: upsoftas &= ~(1<<unit);
651: ubafree(up_ubinfo), up_ubinfo = 0;
652: } else {
653: if (upaddr->upcs1 & TRE) {
654: upaddr->upcs1 = TRE;
655: DELAY(idelay);
656: }
657: }
658: /*
659: * If we have a unit with an outstanding SEARCH,
660: * and the hardware indicates the unit requires attention,
661: * the bring the drive to the ready queue.
662: * Finally, if the controller is not transferring
663: * start it if any drives are now ready to transfer.
664: */
665: as |= upsoftas;
666: oupsoftas = upsoftas;
667: upsoftas = 0;
668: for (unit = 0; unit < NUP; unit++)
669: if ((as|oupsoftas) & (1<<unit)) {
670: if (as & (1<<unit)) {
671: upaddr->upas = 1<<unit;
672: if (olducode)
673: DELAY(oasdel);
674: }
675: if (upustart(unit))
676: needie = 0;
677: }
678: if (uptab.b_actf && uptab.b_active == 0)
679: if (upstart())
680: needie = 0;
681: out:
682: if (needie)
683: upaddr->upcs1 = IE;
684: }
685:
686: upread(dev)
687: {
688:
689: physio(upstrategy, &rupbuf, dev, B_READ, minphys);
690: }
691:
692: upwrite(dev)
693: {
694:
695: physio(upstrategy, &rupbuf, dev, B_WRITE, minphys);
696: }
697:
698: /*
699: * Correct an ECC error, and restart the i/o to complete
700: * the transfer if necessary. This is quite complicated because
701: * the transfer may be going to an odd memory address base and/or
702: * across a page boundary.
703: */
704: upecc(up, bp)
705: register struct device *up;
706: register struct buf *bp;
707: {
708: struct uba_regs *ubp = (struct uba_regs *)UBA0;
709: register int i;
710: caddr_t addr;
711: int reg, bit, byte, npf, mask, o, cmd, ubaddr;
712: int bn, cn, tn, sn;
713:
714: /*
715: * Npf is the number of sectors transferred before the sector
716: * containing the ECC error, and reg is the UBA register
717: * mapping (the first part of) the transfer.
718: * O is offset within a memory page of the first byte transferred.
719: */
720: npf = btop((up->upwc * sizeof(short)) + bp->b_bcount) - 1;
721: reg = btop(up_ubinfo&0x3ffff) + npf;
722: o = (int)bp->b_un.b_addr & PGOFSET;
723: printf("%D ", bp->b_blkno+npf);
724: prdev("ECC", bp->b_dev);
725: mask = up->upec2;
726: if (mask == 0) {
727: up->upof = FMT22; /* == RTC ???? */
728: DELAY(idelay);
729: return (0);
730: }
731: /*
732: * Flush the buffered data path, and compute the
733: * byte and bit position of the error. The variable i
734: * is the byte offset in the transfer, the variable byte
735: * is the offset from a page boundary in main memory.
736: */
737: ubp->uba_dpr[(up_ubinfo>>28)&0x0f] |= BNE;
738: i = up->upec1 - 1; /* -1 makes 0 origin */
739: bit = i&07;
740: i = (i&~07)>>3;
741: byte = i + o;
742: /*
743: * Correct while possible bits remain of mask. Since mask
744: * contains 11 bits, we continue while the bit offset is > -11.
745: * Also watch out for end of this block and the end of the whole
746: * transfer.
747: */
748: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
749: addr = ptob(ubp->uba_map[reg+btop(byte)].pg_pfnum)+
750: (byte & PGOFSET);
751: putmemc(addr, getmemc(addr)^(mask<<bit));
752: byte++;
753: i++;
754: bit -= 8;
755: }
756: uptab.b_active++; /* Either complete or continuing... */
757: if (up->upwc == 0)
758: return (0);
759: /*
760: * Have to continue the transfer... clear the drive,
761: * and compute the position where the transfer is to continue.
762: * We have completed npf+1 sectors of the transfer already;
763: * restart at offset o of next sector (i.e. in UBA register reg+1).
764: */
765: up->upcs1 = TRE|IE|DCLR|GO;
766: DELAY(idelay);
767: bn = dkblock(bp);
768: cn = bp->b_cylin;
769: sn = bn%(NSECT*NTRAC) + npf + 1;
770: tn = sn/NSECT;
771: sn %= NSECT;
772: cn += tn/NTRAC;
773: tn %= NTRAC;
774: up->updc = cn;
775: up->upda = (tn << 8) | sn;
776: ubaddr = (int)ptob(reg+1) + o;
777: up->upba = ubaddr;
778: cmd = (ubaddr >> 8) & 0x300;
779: cmd |= IE|GO|RCOM;
780: up->upcs1 = cmd;
781: return (1);
782: }
783:
784: /*
785: * Reset driver after UBA init.
786: * Cancel software state of all pending transfers
787: * and restart all units and the controller.
788: */
789: upreset()
790: {
791: int unit;
792:
793: printf(" up");
794: uptab.b_active = 0;
795: uptab.b_actf = uptab.b_actl = 0;
796: if (up_ubinfo) {
797: printf("<%d>", (up_ubinfo>>28)&0xf);
798: ubafree(up_ubinfo), up_ubinfo = 0;
799: }
800: UPADDR->upcs2 = CLR; /* clear controller */
801: DELAY(idelay);
802: for (unit = 0; unit < NUP; unit++) {
803: uputab[unit].b_active = 0;
804: (void) upustart(unit);
805: }
806: (void) upstart();
807: }
808:
809: /*
810: * Wake up every second and if an interrupt is pending
811: * but nothing has happened increment a counter.
812: * If nothing happens for 20 seconds, reset the controller
813: * and begin anew.
814: */
815: upwatch()
816: {
817: int i;
818:
819: timeout((caddr_t)upwatch, 0, HZ);
820: if (uptab.b_active == 0) {
821: for (i = 0; i < NUP; i++)
822: if (uputab[i].b_active)
823: goto active;
824: up_wticks = 0; /* idling */
825: return;
826: }
827: active:
828: up_wticks++;
829: if (up_wticks >= 20) {
830: up_wticks = 0;
831: printf("LOST INTERRUPT RESET");
832: upreset();
833: printf("\n");
834: }
835: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.