![[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] / 43BSDReno / sys / vaxstand|
Return to up.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxstand |
1.1 root 1: /*
2: * Copyright (c) 1982, 1988 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.9 (Berkeley) 4/4/90
7: */
8:
9: /*
10: * UNIBUS peripheral standalone driver with ECC correction and bad
11: * block forwarding. Also supports header operation and write check
12: * for data and/or header.
13: */
14: #include "param.h"
15: #include "dkbad.h"
16: #include "disklabel.h"
17:
18: #include "../vax/pte.h"
19:
20: #include "../vaxuba/upreg.h"
21: #include "../vaxuba/ubareg.h"
22:
23: #include "saio.h"
24: #include "savax.h"
25:
26: #define RETRIES 27
27:
28: #define MAXBADDESC 126 /* max number of bad sectors recorded */
29: #define SECTSIZ 512 /* sector size in bytes */
30: #define HDRSIZ 4 /* number of bytes in sector header */
31:
32: #define MAXUNIT 8
33: #define MAXCTLR 1 /* all addresses must be specified */
34: static u_short upstd[MAXCTLR] = { 0776700 };
35: static struct disklabel uplabel[MAXNUBA][MAXCTLR][MAXUNIT];
36: static char lbuf[SECTSIZ];
37:
38: extern struct st upst[];
39:
40: #ifndef SMALL
41: struct dkbad upbad[MAXNUBA][MAXCTLR][MAXUNIT]; /* bad sector table */
42: #endif
43: int sectsiz; /* real sector size */
44:
45: struct up_softc {
46: char gottype;
47: char type;
48: char debug;
49: # define UPF_BSEDEBUG 01 /* debugging bad sector forwarding */
50: # define UPF_ECCDEBUG 02 /* debugging ecc correction */
51: int retries;
52: int ecclim;
53: } up_softc[MAXNUBA][MAXCTLR][MAXUNIT];
54:
55: u_char up_offset[16] = {
56: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400,
57: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800,
58: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200,
59: 0, 0, 0, 0
60: };
61:
62: upopen(io)
63: register struct iob *io;
64: {
65: register struct updevice *upaddr;
66: register struct up_softc *sc;
67: register struct st *st;
68: register struct disklabel *lp;
69: struct disklabel *dlp;
70: register int unit;
71: int error = 0, uba, ctlr;
72:
73: if ((u_int)(uba = io->i_adapt) >= nuba)
74: return (EADAPT);
75: if ((u_int)(ctlr = io->i_ctlr) >= MAXCTLR)
76: return (ECTLR);
77: unit = io->i_unit;
78: if ((u_int)unit >= MAXUNIT)
79: return (EUNIT);
80: upaddr = (struct updevice *)ubamem(uba, upstd[ctlr]);
81: upaddr->upcs2 = unit;
82: while ((upaddr->upcs1 & UP_DVA) == 0);
83: sc = &up_softc[uba][ctlr][unit];
84: lp = &uplabel[uba][ctlr][unit];
85: if (sc->gottype == 0) {
86: register int i;
87: struct iob tio;
88:
89: #ifndef SMALL
90: sc->retries = RETRIES;
91: sc->ecclim = 11;
92: sc->debug = 0;
93: #endif
94: /* Read in the pack label. */
95: lp->d_nsectors = 32;
96: lp->d_secpercyl = 19*32;
97: tio = *io;
98: tio.i_bn = LABELSECTOR;
99: tio.i_ma = lbuf;
100: tio.i_cc = SECTSIZ;
101: tio.i_flgs |= F_RDDATA;
102: if (upstrategy(&tio, READ) != SECTSIZ)
103: error = ERDLAB;
104: dlp = (struct disklabel *)(lbuf + LABELOFFSET);
105: if (error == 0 && (dlp->d_magic != DISKMAGIC ||
106: dlp->d_magic2 != DISKMAGIC))
107: error = EUNLAB;
108: if (error == 0)
109: *lp = *dlp;
110: else
111: #ifdef COMPAT_42
112: if (upmaptype(unit, upaddr, lp) == 0)
113: #endif
114: return (error);
115:
116: #ifndef SMALL
117: /* Read in the bad sector table. */
118: tio.i_bn = lp->d_secpercyl * lp->d_ncylinders - lp->d_nsectors;
119: tio.i_ma = (char *)&upbad[uba][ctlr][unit];
120: tio.i_cc = sizeof(struct dkbad);
121: tio.i_flgs |= F_RDDATA;
122: for (i = 0; i < 5; i++) {
123: if (upstrategy(&tio, READ) == sizeof(struct dkbad))
124: break;
125: tio.i_bn += 2;
126: }
127: if (i == 5) {
128: printf("up: can't read bad sector table\n");
129: for (i = 0; i < MAXBADDESC; i++) {
130: upbad[uba][ctlr][unit].bt_bad[i].bt_cyl = -1;
131: upbad[uba][ctlr][unit].bt_bad[i].bt_trksec = -1;
132: }
133: }
134: #endif
135: sc->gottype = 1;
136: }
137: if (io->i_part >= lp->d_npartitions ||
138: lp->d_partitions[io->i_part].p_size == 0)
139: return (EPART);
140: io->i_boff = lp->d_partitions[io->i_part].p_offset;
141: io->i_flgs &= ~F_TYPEMASK;
142: return (0);
143: }
144:
145: upstrategy(io, func)
146: register struct iob *io;
147: int func;
148: {
149: int cn, tn, sn, o;
150: register unit = io->i_unit;
151: register daddr_t bn;
152: int recal, info, waitdry;
153: register struct updevice *upaddr;
154: register struct disklabel *lp;
155: struct up_softc *sc;
156: int error, rv = io->i_cc;
157: #ifndef SMALL
158: int doprintf = 0;
159: #endif
160:
161: upaddr = (struct updevice *)ubamem(io->i_adapt, upstd[io->i_ctlr]);
162: sc = &up_softc[io->i_adapt][io->i_ctlr][unit];
163: lp = &uplabel[io->i_adapt][io->i_ctlr][unit];
164: sectsiz = SECTSIZ;
165: #ifndef SMALL
166: if (io->i_flgs & (F_HDR|F_HCHECK))
167: sectsiz += HDRSIZ;
168: #endif
169: upaddr->upcs2 = unit;
170: if ((upaddr->upds & UPDS_VV) == 0) {
171: upaddr->upcs1 = UP_DCLR|UP_GO;
172: upaddr->upcs1 = UP_PRESET|UP_GO;
173: upaddr->upof = UPOF_FMT22;
174: }
175: if ((upaddr->upds & UPDS_DREADY) == 0) {
176: printf("up%d not ready\n", unit);
177: return (-1);
178: }
179: info = ubasetup(io, 1);
180: upaddr->upwc = -io->i_cc / sizeof (short);
181: recal = 0;
182: io->i_errcnt = 0;
183:
184: restart:
185: o = io->i_cc + (upaddr->upwc * sizeof (short));
186: upaddr->upba = info + o;
187: bn = io->i_bn + o / sectsiz;
188: #ifndef SMALL
189: error = 0;
190: if (doprintf && sc->debug & (UPF_ECCDEBUG|UPF_BSEDEBUG))
191: printf("wc=%d o=%d i_bn=%d bn=%d\n",
192: upaddr->upwc, o, io->i_bn, bn);
193: #endif
194: upwaitdry(upaddr);
195: if (upstart(io, bn, lp) != 0) {
196: rv = -1;
197: goto done;
198: }
199: upwaitrdy(upaddr);
200: /*
201: * If transfer has completed, free UNIBUS
202: * resources and return transfer size.
203: */
204: if ((upaddr->upds&UPDS_ERR) == 0 && (upaddr->upcs1&UP_TRE) == 0)
205: goto done;
206: bn = io->i_bn +
207: (io->i_cc + upaddr->upwc * sizeof (short)) / sectsiz;
208: if (upaddr->uper1 & (UPER1_DCK|UPER1_ECH))
209: bn--;
210: cn = bn / lp->d_secpercyl;
211: sn = bn % lp->d_secpercyl;
212: tn = sn / lp->d_nsectors;
213: sn = sn % lp->d_nsectors;
214: #ifndef SMALL
215: if (sc->debug & (UPF_ECCDEBUG|UPF_BSEDEBUG)) {
216: printf("up error: sn%d (cyl,trk,sec)=(%d,%d,%d) ",
217: bn, cn, tn, sn);
218: printf("cs2=%b er1=%b er2=%b wc=%d\n",
219: upaddr->upcs2, UPCS2_BITS, upaddr->uper1,
220: UPER1_BITS, upaddr->uper2, UPER2_BITS, upaddr->upwc);
221: }
222: #endif
223: waitdry = 0;
224: while ((upaddr->upds&UPDS_DRY) == 0 && ++waitdry < sectsiz)
225: DELAY(5);
226: #ifndef SMALL
227: if (upaddr->uper1&UPER1_WLE) {
228: /*
229: * Give up on write locked devices immediately.
230: */
231: printf("up%d: write locked\n", unit);
232: rv = -1;
233: goto done;
234: }
235: if (upaddr->uper2 & UPER2_BSE) {
236: if ((io->i_flgs&F_NBSF) == 0 && upecc(io, BSE) == 0)
237: goto success;
238: error = EBSE;
239: goto hard;
240: }
241: /*
242: * ECC error. If a soft error, correct it;
243: * if correction is too large, no more retries.
244: */
245: if ((upaddr->uper1 & (UPER1_DCK|UPER1_ECH|UPER1_HCRC)) == UPER1_DCK) {
246: if (upecc(io, ECC) == 0)
247: goto success;
248: error = EECC;
249: goto hard;
250: }
251: /*
252: * If the error is a header CRC, check if a replacement sector
253: * exists in the bad sector table.
254: */
255: if ((upaddr->uper1&UPER1_HCRC) && (io->i_flgs&F_NBSF) == 0 &&
256: upecc(io, BSE) == 0)
257: goto success;
258: #endif
259: if (++io->i_errcnt > sc->retries) {
260: /*
261: * After 28 retries (16 without offset, and
262: * 12 with offset positioning) give up.
263: */
264: hard:
265: #ifndef SMALL
266: if (error == 0) {
267: error = EHER;
268: if (upaddr->upcs2 & UPCS2_WCE)
269: error = EWCK;
270: }
271: io->i_error = error;
272: #endif
273: printf("up error: sn%d (cyl,trk,sec)=(%d,%d,%d) ",
274: bn, cn, tn, sn);
275: printf("cs2=%b er1=%b er2=%b\n",
276: upaddr->upcs2, UPCS2_BITS, upaddr->uper1,
277: UPER1_BITS, upaddr->uper2, UPER2_BITS);
278: upaddr->upcs1 = UP_TRE|UP_DCLR|UP_GO;
279: io->i_errblk = bn;
280: if (io->i_errcnt >= 16) {
281: upaddr->upof = UPOF_FMT22;
282: upaddr->upcs1 = UP_RTC|UP_GO;
283: upwaitdry(upaddr);
284: }
285: rv = -1;
286: goto done;
287: }
288: /*
289: * Clear drive error and, every eight attempts, (starting with the
290: * fourth) recalibrate to clear the slate.
291: */
292: upaddr->upcs1 = UP_TRE|UP_DCLR|UP_GO;
293: if ((io->i_errcnt&07) == 4 ) {
294: upaddr->upcs1 = UP_RECAL|UP_GO;
295: upwaitdry(upaddr);
296: upaddr->updc = cn;
297: upaddr->upcs1 = UP_SEEK|UP_GO;
298: upwaitdry(upaddr);
299: }
300: if (io->i_errcnt >= 16 && (func & READ)) {
301: upaddr->upof = up_offset[io->i_errcnt & 017] | UPOF_FMT22;
302: upaddr->upcs1 = UP_OFFSET|UP_GO;
303: upwaitdry(upaddr);
304: }
305: goto restart;
306:
307: success:
308: #define rounddown(x, y) (((x) / (y)) * (y))
309: upaddr->upwc = rounddown(upaddr->upwc, sectsiz / sizeof (short));
310: if (upaddr->upwc) {
311: #ifndef SMALL
312: doprintf++;
313: #endif
314: goto restart;
315: }
316: done:
317: ubafree(io, info);
318: /*
319: * If we were offset positioning,
320: * return to centerline.
321: */
322: if (io->i_errcnt >= 16) {
323: upaddr->upof = UPOF_FMT22;
324: upaddr->upcs1 = UP_RTC|UP_GO;
325: upwaitdry(upaddr);
326: }
327: return (rv);
328: }
329:
330: upwaitrdy(upaddr)
331: register struct updevice *upaddr;
332: {
333: do {
334: DELAY(25);
335: } while ((upaddr->upcs1 & UP_RDY) == 0);
336: }
337:
338: upwaitdry(upaddr)
339: register struct updevice *upaddr;
340: {
341: while ((upaddr->upds&UPDS_DRY) == 0)
342: DELAY(25);
343: }
344:
345: #ifndef SMALL
346: /*
347: * Correct an ECC error, and restart the i/o to complete the transfer (if
348: * necessary). This is quite complicated because the transfer may be going
349: * to an odd memory address base and/or across a page boundary.
350: */
351: upecc(io, flag)
352: register struct iob *io;
353: int flag;
354: {
355: register i, unit;
356: register struct up_softc *sc;
357: register struct updevice *up;
358: register struct disklabel *lp;
359: caddr_t addr;
360: int bn, twc, npf, mask, cn, tn, sn;
361: daddr_t bbn;
362:
363: /*
364: * Npf is the number of sectors transferred
365: * before the sector containing the ECC error;
366: * bn is the current block number.
367: */
368: unit = io->i_unit;
369: sc = &up_softc[io->i_adapt][io->i_ctlr][unit];
370: lp = &uplabel[io->i_adapt][io->i_ctlr][unit];
371: up = (struct updevice *)ubamem(io->i_adapt, upstd[io->i_ctlr]);
372: twc = up->upwc;
373: npf = ((twc * sizeof(short)) + io->i_cc) / sectsiz;
374: if (flag == ECC)
375: npf--;
376: if (sc->debug & UPF_ECCDEBUG)
377: printf("npf=%d mask=0x%x ec1=%d wc=%d\n",
378: npf, up->upec2, up->upec1, twc);
379: bn = io->i_bn + npf;
380: cn = bn / lp->d_secpercyl;
381: sn = bn % lp->d_secpercyl;
382: tn = sn / lp->d_nsectors;
383: sn = sn % lp->d_nsectors;
384:
385: /*
386: * ECC correction.
387: */
388: if (flag == ECC) {
389: int bit, o;
390:
391: mask = up->upec2;
392: printf("up%d: soft ecc sn%d\n", unit, bn);
393: for (i = mask, bit = 0; i; i >>= 1)
394: if (i & 1)
395: bit++;
396: if (bit > sc->ecclim) {
397: printf("%d-bit error\n", bit);
398: return (1);
399: }
400: /*
401: * Compute the byte and bit position of
402: * the error. o is the byte offset in
403: * the transfer at which the correction
404: * applied.
405: */
406: i = up->upec1 - 1; /* -1 makes 0 origin */
407: bit = i & 07;
408: o = (i & ~07) >> 3;
409: up->upcs1 = UP_TRE|UP_DCLR|UP_GO;
410: /*
411: * Correct while possible bits remain of mask.
412: * Since mask contains 11 bits, we continue while
413: * the bit offset is > -11. Also watch out for
414: * end of this block and the end of the transfer.
415: */
416: while (o < sectsiz && (npf*sectsiz)+o < io->i_cc && bit > -11) {
417: /*
418: * addr =
419: * (base address of transfer) +
420: * (# sectors transferred before the error) *
421: * (sector size) +
422: * (byte offset to incorrect data)
423: */
424: addr = io->i_ma + (npf * sectsiz) + o;
425: /*
426: * No data transfer occurs with a write check,
427: * so don't correct the resident copy of data.
428: */
429: if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) {
430: if (sc->debug & UPF_ECCDEBUG)
431: printf("addr=0x%x old=0x%x ", addr,
432: (*addr&0xff));
433: *addr ^= (mask << bit);
434: if (sc->debug & UPF_ECCDEBUG)
435: printf("new=0x%x\n", (*addr&0xff));
436: }
437: o++, bit -= 8;
438: }
439: return (0);
440: }
441:
442: /*
443: * Bad sector forwarding.
444: */
445: if (flag == BSE) {
446: /*
447: * If not in bad sector table,
448: * indicate a hard error to caller.
449: */
450: up->upcs1 = UP_TRE|UP_DCLR|UP_GO;
451: if ((bbn = isbad(&upbad[io->i_adapt][io->i_ctlr][unit], cn, tn, sn)) < 0)
452: return (1);
453: bbn = (lp->d_ncylinders * lp->d_secpercyl) -
454: lp->d_nsectors - 1 - bbn;
455: twc = up->upwc + sectsiz;
456: up->upwc = - (sectsiz / sizeof (short));
457: if (sc->debug & UPF_BSEDEBUG)
458: printf("revector sn %d to %d\n", sn, bbn);
459: /*
460: * Clear the drive & read the replacement
461: * sector. If this is in the middle of a
462: * transfer, then set up the controller
463: * registers in a normal fashion.
464: * The UNIBUS address need not be changed.
465: */
466: upwaitrdy(up);
467: if (upstart(io, bbn, lp))
468: return (1); /* error */
469: io->i_errcnt = 0; /* success */
470: upwaitrdy(up);
471: if ((up->upds & UPDS_ERR) || (up->upcs1 & UP_TRE)) {
472: up->upwc = twc - sectsiz;
473: return (1);
474: }
475: }
476: if (twc)
477: up->upwc = twc;
478: return (0);
479: }
480: #endif /* !SMALL */
481:
482: upstart(io, bn, lp)
483: register struct iob *io;
484: daddr_t bn;
485: register struct disklabel *lp;
486: {
487: register struct updevice *upaddr;
488: register struct up_softc *sc;
489: int sn, tn;
490:
491: upaddr = (struct updevice *)ubamem(io->i_adapt, upstd[io->i_ctlr]);
492: sc = &up_softc[io->i_adapt][io->i_ctlr][io->i_unit];
493: sn = bn % lp->d_secpercyl;
494: tn = sn / lp->d_nsectors;
495: sn = sn % lp->d_nsectors;
496: upaddr->updc = bn / lp->d_secpercyl;
497: upaddr->upda = (tn << 8) + sn;
498: switch (io->i_flgs & F_TYPEMASK) {
499:
500: case F_RDDATA:
501: upaddr->upcs1 = UP_RCOM|UP_GO;
502: break;
503:
504: case F_WRDATA:
505: upaddr->upcs1 = UP_WCOM|UP_GO;
506: break;
507:
508: #ifndef SMALL
509: case F_HDR|F_RDDATA:
510: upaddr->upcs1 = UP_RHDR|UP_GO;
511: break;
512:
513: case F_HDR|F_WRDATA:
514: upaddr->upcs1 = UP_WHDR|UP_GO;
515: break;
516:
517: case F_CHECK|F_WRDATA:
518: case F_CHECK|F_RDDATA:
519: upaddr->upcs1 = UP_WCDATA|UP_GO;
520: break;
521:
522: case F_HCHECK|F_WRDATA:
523: case F_HCHECK|F_RDDATA:
524: upaddr->upcs1 = UP_WCHDR|UP_GO;
525: break;
526: #endif
527:
528: default:
529: io->i_error = ECMD;
530: io->i_flgs &= ~F_TYPEMASK;
531: return (1);
532: }
533: return (0);
534: }
535:
536: #ifndef SMALL
537: /*ARGSUSED*/
538: upioctl(io, cmd, arg)
539: struct iob *io;
540: int cmd;
541: caddr_t arg;
542: {
543: register struct up_softc *sc;
544:
545: sc = &up_softc[io->i_adapt][io->i_ctlr][io->i_unit];
546: switch(cmd) {
547: case SAIODEBUG:
548: sc->debug = (int)arg;
549: break;
550: case SAIODEVDATA:
551: *(struct disklabel *)arg =
552: uplabel[io->i_adapt][io->i_ctlr][io->i_unit];
553: break;
554: case SAIOGBADINFO:
555: *(struct dkbad *)arg =
556: upbad[io->i_adapt][io->i_ctlr][io->i_unit];
557: break;
558: case SAIOECCLIM:
559: sc->ecclim = (int)arg;
560: break;
561: case SAIORETRIES:
562: sc->retries = (int)arg;
563: break;
564: default:
565: return (ECMD);
566: }
567: return (0);
568: }
569: #endif /* !SMALL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.