![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand|
Return to hp.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxstand |
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: * @(#)hp.c 7.10 (Berkeley) 7/8/88
7: */
8:
9: /*
10: * RP??/RM?? disk driver with ECC handling and bad block forwarding.
11: * Also supports header io operations and commands to write check
12: * header and data.
13: */
14: #include "param.h"
15: #include "inode.h"
16: #include "fs.h"
17: #include "dkbad.h"
18: #include "disklabel.h"
19:
20: #include "../vax/pte.h"
21:
22: #include "../vaxmba/hpreg.h"
23: #include "../vaxmba/mbareg.h"
24:
25: #include "saio.h"
26: #include "savax.h"
27:
28: #define RETRIES 27
29:
30: #define MASKREG(reg) ((reg)&0xffff)
31:
32: #define MAXBADDESC 126
33: #define SECTSIZ 512 /* sector size in bytes */
34: #define HDRSIZ 4 /* number of bytes in sector header */
35:
36: char lbuf[SECTSIZ];
37:
38: #define RP06(type) ((type) == MBDT_RP06 || (type) == MBDT_RP05 \
39: || (type) == MBDT_RP04)
40: #define ML11(type) ((type) == MBDT_ML11A)
41: #define RM80(type) ((type) == MBDT_RM80)
42:
43: u_char hp_offset[16] = {
44: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
45: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
46: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
47: 0, 0, 0, 0,
48: };
49:
50: #define MAXUNIT 8
51: struct disklabel hplabel[MAXNMBA][MAXUNIT];
52: #ifndef SMALL
53: struct dkbad hpbad[MAXNMBA][MAXUNIT];
54: int sectsiz;
55: #endif
56:
57: struct hp_softc {
58: char type;
59: char gottype;
60: char ssect; /* 1 when on track w/skip sector */
61: char debug;
62: # define HPF_BSEDEBUG 01 /* debugging bad sector forwarding */
63: # define HPF_ECCDEBUG 02 /* debugging ecc correction */
64: int ecclim;
65: int retries;
66: } hp_softc[MAXNMBA][MAXUNIT];
67:
68: /*
69: * When awaiting command completion, don't hang on to the status register
70: * since this ties up some controllers.
71: */
72: #define HPWAIT(addr) \
73: while ((((addr)->hpds)&HPDS_DRY) == 0) \
74: DELAY(500);
75:
76: hpopen(io)
77: register struct iob *io;
78: {
79: register unit = io->i_unit;
80: register struct hp_softc *sc;
81: register struct disklabel *lp;
82: struct hpdevice *hpaddr;
83: struct disklabel *dlp;
84: int error = 0;
85:
86: /*
87: * Accept adaptor number as either controller or adaptor,
88: * but not both.
89: */
90: if (io->i_ctlr) {
91: if (io->i_adapt == 0)
92: io->i_adapt = io->i_ctlr;
93: else
94: return (ECTLR);
95: }
96: if ((u_int)io->i_adapt >= MAXNMBA || !mbainit(io->i_adapt))
97: return (EADAPT);
98: if ((u_int)unit >= MAXUNIT)
99: return (EUNIT);
100: hpaddr = (struct hpdevice *)mbadrv(io->i_adapt, unit);
101: sc = &hp_softc[io->i_adapt][unit];
102: lp = &hplabel[io->i_adapt][unit];
103: if (sc->gottype == 0) {
104: register int i;
105: struct iob tio;
106:
107: #ifndef SMALL
108: sc->retries = RETRIES;
109: sc->ecclim = 11;
110: sc->debug = 0;
111: #endif
112: hpaddr->hpcs1 = HP_DCLR|HP_GO; /* init drive */
113: hpaddr->hpcs1 = HP_PRESET|HP_GO;
114: #ifndef SMALL
115: if ((hpaddr->hpds & HPDS_DPR) == 0)
116: return (ENXIO);
117: sc->type = hpaddr->hpdt & MBDT_TYPE;
118: if (sc->type == MBDT_ML11B)
119: sc->type = MBDT_ML11A;
120: if (!ML11(sc->type))
121: #endif
122: hpaddr->hpof = HPOF_FMT22;
123: /*
124: * Read in the pack label.
125: */
126: lp->d_nsectors = 32;
127: lp->d_secpercyl = 20*32;
128: tio = *io;
129: tio.i_bn = LABELSECTOR;
130: tio.i_ma = lbuf;
131: tio.i_cc = SECTSIZ;
132: tio.i_flgs |= F_RDDATA;
133: if (hpstrategy(&tio, READ) != SECTSIZ)
134: error = ERDLAB;
135: dlp = (struct disklabel *)(lbuf + LABELOFFSET);
136: if (error == 0 && (dlp->d_magic != DISKMAGIC ||
137: dlp->d_magic2 != DISKMAGIC))
138: error = EUNLAB;
139: if (error == 0)
140: *lp = *dlp;
141: else
142: #ifdef COMPAT_42
143: if (hpmaptype(hpaddr, hpaddr->hpdt & MBDT_TYPE, unit, lp) == 0)
144: #endif
145: return (error);
146:
147: #ifndef SMALL
148: /*
149: * Read in the bad sector table.
150: */
151: tio.i_bn = lp->d_secpercyl * lp->d_ncylinders - lp->d_nsectors;
152: tio.i_ma = (char *)&hpbad[io->i_adapt][unit];
153: tio.i_cc = sizeof(struct dkbad);
154: for (i = 0; i < 5; i++) {
155: if (hpstrategy(&tio, READ) == sizeof(struct dkbad))
156: break;
157: tio.i_bn += 2;
158: }
159: if (i == 5) {
160: printf("hp: can't read bad sector table\n");
161: for (i = 0; i < MAXBADDESC; i++) {
162: hpbad[io->i_adapt][unit].bt_bad[i].bt_cyl = -1;
163: hpbad[io->i_adapt][unit].bt_bad[i].bt_trksec = -1;
164: }
165: }
166: #endif
167: sc->gottype = 1;
168: }
169: if (io->i_part >= lp->d_npartitions ||
170: lp->d_partitions[io->i_part].p_size == 0)
171: return (EPART);
172: io->i_boff = lp->d_partitions[io->i_part].p_offset;
173: return (0);
174: }
175:
176: hpstrategy(io, func)
177: register struct iob *io;
178: {
179: register int unit = io->i_unit;
180: register struct hp_softc *sc;
181: register struct disklabel *lp;
182: struct mba_regs *mba;
183: struct hpdevice *hpaddr;
184: daddr_t bn, startblock;
185: int cn, tn, sn, bytecnt, bytesleft, rv;
186: int er1, er2, hprecal;
187: char *membase;
188:
189: mba = mbamba(io->i_adapt);
190: hpaddr = (struct hpdevice *)mbadrv(io->i_adapt, unit);
191: sc = &hp_softc[io->i_adapt][unit];
192: lp = &hplabel[io->i_adapt][unit];
193: #ifndef SMALL
194: sectsiz = SECTSIZ;
195: if ((io->i_flgs & (F_HDR|F_HCHECK)) != 0)
196: sectsiz += HDRSIZ;
197: if ((hpaddr->hpds & HPDS_VV) == 0) {
198: hpaddr->hpcs1 = HP_DCLR|HP_GO;
199: hpaddr->hpcs1 = HP_PRESET|HP_GO;
200: if (!ML11(sc->type))
201: hpaddr->hpof = HPOF_FMT22;
202: }
203: io->i_errcnt = 0;
204: sc->ssect = 0;
205: rv = bytecnt = io->i_cc;
206: membase = io->i_ma;
207: startblock = io->i_bn;
208: hprecal = 0;
209: #endif
210:
211: restart:
212: bn = io->i_bn;
213: cn = bn / lp->d_secpercyl;
214: sn = bn % lp->d_secpercyl;
215: tn = sn / lp->d_nsectors;
216: sn = sn % lp->d_nsectors + sc->ssect;
217:
218: HPWAIT(hpaddr);
219: mba->mba_sr = -1;
220: if (ML11(sc->type))
221: hpaddr->hpda = bn;
222: else {
223: hpaddr->hpdc = cn;
224: hpaddr->hpda = (tn << 8) + sn;
225: }
226: #ifdef SMALL
227: mbastart(io, io->i_unit, func); /* start transfer */
228: HPWAIT(hpaddr);
229: if (hpaddr->hpds & HPDS_ERR) {
230: printf("hp error: sn [%d-%d) ds=%b er1=%b\n",
231: bn, bn + io->i_cc/SECTSIZ, MASKREG(hpaddr->hpds), HPDS_BITS,
232: MASKREG(hpaddr->hper1), HPER1_BITS);
233: return (-1);
234: }
235: return (io->i_cc);
236: #else
237: if (mbastart(io, io->i_unit, func) != 0) { /* start transfer */
238: rv = -1;
239: goto done;
240: }
241: HPWAIT(hpaddr);
242: /*
243: * Successful data transfer, return.
244: */
245: if ((hpaddr->hpds&HPDS_ERR) == 0 && (mba->mba_sr&MBSR_EBITS) == 0)
246: goto done;
247:
248: /*
249: * Error handling. Calculate location of error.
250: */
251: bytesleft = MASKREG(mba->mba_bcr);
252: if (bytesleft)
253: bytesleft |= 0xffff0000; /* sxt */
254: bn = io->i_bn + (io->i_cc + bytesleft) / sectsiz;
255: er1 = MASKREG(hpaddr->hper1);
256: er2 = MASKREG(hpaddr->hper2);
257: if (er1 & (HPER1_DCK|HPER1_ECH))
258: bn--; /* Error is in Prev block */
259: cn = bn/lp->d_secpercyl;
260: sn = bn%lp->d_secpercyl;
261: tn = sn/lp->d_nsectors;
262: sn = sn%lp->d_nsectors;
263: if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG)) {
264: printf("hp error: sn%d (cyl,trk,sec)=(%d,%d,%d) ds=%b\n",
265: bn, cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
266: printf("er1=%b er2=%b\n", er1, HPER1_BITS, er2, HPER2_BITS);
267: printf("bytes left: %d, of 0x%x, da 0x%x\n",-bytesleft,
268: hpaddr->hpof, hpaddr->hpda);
269: }
270: if (er1 & HPER1_HCRC) {
271: er1 &= ~(HPER1_HCE|HPER1_FER);
272: er2 &= ~HPER2_BSE;
273: if ((io->i_flgs&F_NBSF) == 0 && hpecc(io, BSE) == 0)
274: goto success;
275: }
276: /*
277: * Give up early if drive write locked.
278: */
279: if (er1&HPER1_WLE) {
280: printf("hp%d: write locked\n", unit);
281: rv = -1;
282: goto done;
283: }
284: /*
285: * Skip sector handling.
286: */
287: if (RM80(sc->type) && (er2 & HPER2_SSE)) {
288: (void) hpecc(io, SSE);
289: sc->ssect = 1;
290: goto restart;
291: }
292: /*
293: * Attempt to forward bad sectors on anything but an ML11.
294: * Interpret format error bit as a bad block on RP06's.
295: */
296: if (((er2 & HPER2_BSE) && !ML11(sc->type)) ||
297: (MASKREG(er1) == HPER1_FER && RP06(sc->type))) {
298: if (io->i_flgs & F_NBSF) {
299: io->i_error = EBSE;
300: goto hard;
301: }
302: if (hpecc(io, BSE) == 0)
303: goto success;
304: io->i_error = EBSE;
305: goto hard;
306: }
307: /*
308: * ECC correction?
309: */
310: if ((er1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK) {
311: if (hpecc(io, ECC) == 0)
312: goto success;
313: io->i_error = EECC;
314: goto hard;
315: }
316:
317: /*
318: * If a hard error, or maximum retry count
319: * exceeded, clear controller state and
320: * pass back error to caller.
321: */
322: if (++io->i_errcnt > sc->retries || (er1 & HPER1_HARD) ||
323: (!ML11(sc->type) && (er2 & HPER2_HARD)) ||
324: (ML11(sc->type) && (io->i_errcnt >= 16))) {
325: io->i_error = EHER;
326: if (mba->mba_sr & (MBSR_WCKUP|MBSR_WCKLWR))
327: io->i_error = EWCK;
328: hard:
329: io->i_errblk = bn + sc->ssect;
330: if (sc->debug & (HPF_BSEDEBUG|HPF_ECCDEBUG))
331: printf(" dc=%d, da=0x%x",MASKREG(hpaddr->hpdc),
332: MASKREG(hpaddr->hpda));
333: else {
334: printf("hp error: sn%d (cyl,trk,sec)=(%d,%d,%d) ds=%b \n",
335: bn, cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
336: printf("er1=%b er2=%b", er1, HPER1_BITS, er2, HPER2_BITS);
337: }
338: hpaddr->hpcs1 = HP_DCLR|HP_GO;
339: printf("\n");
340: rv = -1;
341: goto done;
342:
343: }
344: /* fall thru to retry */
345: hpaddr->hpcs1 = HP_DCLR|HP_GO;
346: HPWAIT(hpaddr);
347:
348: /*
349: * Every fourth retry recalibrate.
350: */
351: if (((io->i_errcnt & 07) == 4) ) {
352: hpaddr->hpcs1 = HP_RECAL|HP_GO;
353: HPWAIT(hpaddr);
354: hpaddr->hpdc = cn;
355: hpaddr->hpcs1 = HP_SEEK|HP_GO;
356: HPWAIT(hpaddr);
357: }
358:
359: if (io->i_errcnt >= 16 && (io->i_flgs & F_READ)) {
360: hpaddr->hpof = hp_offset[io->i_errcnt & 017]|HPOF_FMT22;
361: hpaddr->hpcs1 = HP_OFFSET|HP_GO;
362: HPWAIT(hpaddr);
363: }
364: if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG))
365: printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n",
366: io->i_bn, io->i_cc, io->i_ma, hprecal);
367: goto restart;
368:
369: success:
370: /*
371: * On successful error recovery, bump
372: * block number to advance to next portion
373: * of i/o transfer.
374: */
375: bn++;
376: if ((bn-startblock) * sectsiz < bytecnt) {
377: io->i_bn = bn;
378: io->i_ma = membase + (io->i_bn - startblock)*sectsiz;
379: io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz;
380: if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG))
381: printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n",
382: io->i_bn, io->i_cc, io->i_ma, hprecal);
383: goto restart;
384: }
385: done:
386: if (io->i_errcnt >= 16) {
387: hpaddr->hpcs1 = HP_RTC|HP_GO;
388: while (hpaddr->hpds & HPDS_PIP)
389: ;
390: }
391: io->i_bn = startblock; /*reset i_bn to original */
392: io->i_cc = bytecnt; /*reset i_cc to total count xfered*/
393: io->i_ma = membase; /*reset i_ma to original */
394: return (rv);
395: #endif
396: }
397:
398: #ifndef SMALL
399: hpecc(io, flag)
400: register struct iob *io;
401: int flag;
402: {
403: register int unit = io->i_unit;
404: register struct mba_regs *mbp;
405: register struct hpdevice *rp;
406: register struct hp_softc *sc;
407: register struct disklabel *lp;
408: int npf, bn, cn, tn, sn, bcr;
409:
410: mbp = mbamba(io->i_adapt);
411: rp = (struct hpdevice *)mbadrv(io->i_adapt, unit);
412: sc = &hp_softc[io->i_adapt][unit];
413: lp = &hplabel[io->i_adapt][unit];
414: bcr = MASKREG(mbp->mba_bcr);
415: if (bcr)
416: bcr |= 0xffff0000; /* sxt */
417: npf = (bcr + io->i_cc) / sectsiz; /* # sectors read */
418: if (flag == ECC)
419: npf--; /* Error is in prev block --ghg */
420: bn = io->i_bn + npf + sc->ssect; /* physical block #*/
421: if (sc->debug & HPF_ECCDEBUG)
422: printf("bcr=%d npf=%d ssect=%d sectsiz=%d i_cc=%d\n",
423: bcr, npf, sc->ssect, sectsiz, io->i_cc);
424: /*
425: * ECC correction logic.
426: */
427: if (flag == ECC) {
428: register int i;
429: caddr_t addr;
430: int bit, o, mask;
431:
432: printf("hp%d: soft ecc sn%d\n", unit, bn);
433: mask = MASKREG(rp->hpec2);
434: for (i = mask, bit = 0; i; i >>= 1)
435: if (i & 1)
436: bit++;
437: if (bit > sc->ecclim) {
438: printf("%d-bit error\n", bit);
439: return (1);
440: }
441: i = MASKREG(rp->hpec1) - 1; /* -1 makes 0 origin */
442: bit = i&07;
443: o = (i & ~07) >> 3;
444: rp->hpcs1 = HP_DCLR | HP_GO;
445: while (o <sectsiz && npf*sectsiz + o < io->i_cc && bit > -11) {
446: addr = io->i_ma + (npf*sectsiz) + o;
447: /*
448: * No data transfer occurs with a write check,
449: * so don't correct the resident copy of data.
450: */
451: if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) {
452: if (sc->debug & HPF_ECCDEBUG)
453: printf("addr=%x old=%x ", addr,
454: (*addr & 0xff));
455: *addr ^= (mask << bit);
456: if (sc->debug & HPF_ECCDEBUG)
457: printf("new=%x\n",(*addr & 0xff));
458: }
459: o++, bit -= 8;
460: }
461: return (0);
462: }
463:
464: /*
465: * Skip sector error.
466: * Set skip-sector-inhibit and
467: * read next sector
468: */
469: if (flag == SSE) {
470: rp->hpcs1 = HP_DCLR | HP_GO;
471: HPWAIT(rp);
472: rp->hpof |= HPOF_SSEI;
473: return (0);
474: }
475:
476: /*
477: * Bad block forwarding.
478: */
479: if (flag == BSE) {
480: int bbn;
481:
482: rp->hpcs1 = HP_DCLR | HP_GO;
483: if (sc->debug & HPF_BSEDEBUG)
484: printf("hpecc: BSE @ bn %d\n", bn);
485: cn = bn / lp->d_secpercyl;
486: sn = bn % lp->d_secpercyl;
487: tn = sn / lp->d_nsectors;
488: sn = sn % lp->d_nsectors;
489: bcr += sectsiz;
490: if ((bbn = isbad(&hpbad[io->i_adapt][unit], cn, tn, sn)) < 0)
491: return (1);
492: bbn = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors - 1
493: - bbn;
494: cn = bbn / lp->d_secpercyl;
495: sn = bbn % lp->d_secpercyl;
496: tn = sn / lp->d_nsectors;
497: sn = sn % lp->d_nsectors;
498: io->i_cc = sectsiz;
499: io->i_ma += npf * sectsiz;
500: if (sc->debug & HPF_BSEDEBUG)
501: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
502: rp->hpof &= ~HPOF_SSEI;
503: mbp->mba_sr = -1;
504: rp->hpdc = cn;
505: rp->hpda = (tn<<8) + sn;
506: mbastart(io, io->i_unit, io->i_flgs);
507: io->i_errcnt = 0;
508: HPWAIT(rp);
509: return (rp->hpds&HPDS_ERR);
510: }
511: printf("hpecc: flag=%d\n", flag);
512: return (1);
513: }
514:
515: /*ARGSUSED*/
516: hpioctl(io, cmd, arg)
517: struct iob *io;
518: int cmd;
519: caddr_t arg;
520: {
521: register unit = io->i_unit;
522: register struct hp_softc *sc = &hp_softc[io->i_adapt][unit];
523: register struct disklabel *lp = &hplabel[io->i_adapt][unit];
524: struct mba_drv *drv = mbadrv(io->i_adapt, unit);
525:
526: switch(cmd) {
527:
528: case SAIODEBUG:
529: sc->debug = (int)arg;
530: break;
531:
532: case SAIODEVDATA:
533: if (drv->mbd_dt&MBDT_TAP)
534: return (ECMD);
535: *(struct disklabel *)arg = *lp;
536: break;
537:
538: case SAIOGBADINFO:
539: if (drv->mbd_dt&MBDT_TAP)
540: return (ECMD);
541: *(struct dkbad *)arg = hpbad[io->i_adapt][unit];
542: break;
543:
544: case SAIOECCLIM:
545: sc->ecclim = (int)arg;
546: break;
547:
548: case SAIORETRIES:
549: sc->retries = (int)arg;
550: break;
551:
552: case SAIOSSI: /* skip-sector-inhibit */
553: if (drv->mbd_dt&MBDT_TAP)
554: return (ECMD);
555: if ((io->i_flgs&F_SSI) == 0) {
556: /* make sure this is done once only */
557: io->i_flgs |= F_SSI;
558: lp->d_nsectors++;
559: lp->d_secpercyl += lp->d_ntracks;
560: }
561: break;
562:
563: case SAIONOSSI: /* remove skip-sector-inhibit */
564: if (io->i_flgs & F_SSI) {
565: io->i_flgs &= ~F_SSI;
566: drv->mbd_of &= ~HPOF_SSEI;
567: lp->d_nsectors--;
568: lp->d_secpercyl -= lp->d_ntracks;
569: }
570: break;
571:
572: case SAIOSSDEV: /* drive have skip sector? */
573: return (RM80(sc->type) ? 0 : ECMD);
574:
575: default:
576: return (ECMD);
577: }
578: return (0);
579: }
580: #endif /* !SMALL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.