![[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 [Research Unix] / researchv8dc / sys / dev|
Return to hp.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /* hp.c 4.47 82/02/18 */
2:
3: #ifdef HPDEBUG
4: int hpdebug;
5: #endif
6: #ifdef HPBDEBUG
7: int hpbdebug;
8: #endif
9:
10: #include "hp.h"
11: #if NHP > 0
12: /*
13: * HP disk driver for RP0x+RMxx+ML11
14: *
15: * TODO:
16: * check RM80 skip sector handling when ECC's occur later
17: * check offset recovery handling
18: * see if DCLR and/or RELEASE set attention status
19: * print bits of mr && mr2 symbolically
20: */
21:
22: #include "../h/param.h"
23: #include "../h/systm.h"
24: #include "../h/dk.h"
25: #include "../h/buf.h"
26: #include "../h/conf.h"
27: #include "../h/dir.h"
28: #include "../h/user.h"
29: #include "../h/map.h"
30: #include "../h/pte.h"
31: #include "../h/mbareg.h"
32: #include "../h/mbavar.h"
33: #include "../h/mtpr.h"
34: #include "../h/vm.h"
35: #include "../h/cmap.h"
36: #include "../h/dkbad.h"
37: #include "../h/dkio.h"
38:
39: #include "../h/hpreg.h"
40:
41: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
42: struct size {
43: daddr_t nblocks;
44: int cyloff;
45: } hp6_sizes[8] = {
46: 15884, 0, /* A=cyl 0 thru 37 */
47: 33440, 38, /* B=cyl 38 thru 117 */
48: 340670, 0, /* C=cyl 0 thru 814 */
49: 0, 0,
50: 0, 0,
51: 0, 0,
52: #ifndef NOBADSECT
53: 291280, 118, /* G=cyl 118 thru 814 */
54: #else
55: 291346, 118,
56: #endif
57: 0, 0,
58: }, rm3_sizes[8] = {
59: 15884, 0, /* A=cyl 0 thru 99 */
60: 33440, 100, /* B=cyl 100 thru 309 */
61: 131680, 0, /* C=cyl 0 thru 822 */
62: 0, 0,
63: 0, 0,
64: 0, 0,
65: #ifndef NOBADSECT
66: 81984, 310, /* G=cyl 310 thru 822 */
67: #else
68: 82080, 310,
69: #endif
70: 0, 0,
71: }, rm5_sizes[8] = {
72: 15884, 0, /* A=cyl 0 thru 26 */
73: 33440, 27, /* B=cyl 27 thru 81 */
74: 500384, 0, /* C=cyl 0 thru 822 */
75: 15884, 562, /* D=cyl 562 thru 588 */
76: 55936, 589, /* E=cyl 589 thru 680 */
77: #ifndef NOBADSECT
78: 86240, 681, /* F=cyl 681 thru 822 */
79: 158592, 562, /* G=cyl 562 thru 822 */
80: #else
81: 86636, 681,
82: 158688, 562,
83: #endif
84: 291346, 82, /* H=cyl 82 thru 561 */
85: }, rm80_sizes[8] = {
86: 15884, 0, /* A=cyl 0 thru 36 */
87: 33440, 37, /* B=cyl 37 thru 114 */
88: 242606, 0, /* C=cyl 0 thru 558 */
89: 0, 0,
90: 0, 0,
91: 192223, 115, /* F=cyl 115 thru 558 */
92: 82080, 115, /* G=cyl 115 thru 304 */
93: 110143, 305, /* H=cyl 305 thru 558 */
94: }, mfj_sizes[8] = {
95: 10240, 0, /* A=cyl 0 thru 31 */
96: 20480, 32, /* B=cyl 32 thru 95 */
97: 232640, 96, /* C=cyl 96 thru 822 */
98: 0, 0,
99: 0, 0,
100: 0, 0,
101: 0, 0,
102: 0, 0,
103: }, eagle_sizes[8] ={
104: 27520, 0, /* A=cyl 0 thru 31 */
105: 27520, 32, /* B=cyl 32 thru 63 */
106: 667360, 64, /* C=cyl 64 thru 839 */
107: 232640, 64, /* D=cyl 64 thru 340 (partial) */
108: 232640, 341, /* E=cyl 341 thru 617 (partial) */
109: 0, 0,
110: 0, 0,
111: 0, 0,
112: /* 48 sector Emulex Eagle */
113: }, eag48_sizes[8] = { /* cyl 841 used for bad sectors + info */
114:
115: 45*960, 0, /* A = cyl 0 thru 44 for /tmp */
116: 64*960, 45, /* B = cyl 45 thru 108 for swap */
117: 842*960, 0, /* C = all cyl 0 thru 841 for testing */
118: 244*960,109, /* D = cyl 109 thru 352 nearly 1/3 */
119: 244*960,353, /* E = cyl 353 thru 596 nearly 1/3 */
120: 244*960,597, /* F = cyl 597 thru 840 nearly 1/3 */
121: 0, 0, /* G = cyl 0 thru 402 nearly 1/2 */
122: 0, 0, /* H = cyl 438 thru 840 nearly 1/2 */
123: }, hp7_sizes[8] = {
124: 15884, 0, /* A=cyl 0 thru 9 */
125: 64000, 10, /* B=cyl 10 thru 49 */
126: 1008000,0, /* C=cyl 0 thru 629 */
127: 504000, 0, /* D=cyl 0 thru 314 */
128: 504000, 315, /* E=cyl 315 thru 629 */
129: 928000, 50, /* F=cyl 50 thru 629 */
130: 0, 0,
131: 0, 0,
132: };
133: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
134:
135: #ifndef JONES
136: #define _hpSDIST 2
137: #define _hpRDIST 3
138: #else JONES
139: /*
140: these constants were originally 2 and 3 respectively. they
141: have been changed to improve the performance of the eagle
142: drives with the emulex controller. to date, 8,9 is better than
143: 2,3. 12,13 did not do any better than 8,9. changing these
144: constants changes the lead for all drives using the hp driver
145: including the rm80. that's a mistake, but empirically,
146: changing these to 8,9 did not measurably change rm80
147: performance.
148: */
149: #define _hpSDIST 8
150: #define _hpRDIST 9
151: #endif JONES
152:
153: int hpSDIST = _hpSDIST;
154: int hpRDIST = _hpRDIST;
155:
156: short hptypes[] =
157: { MBDT_RM03, MBDT_RM05, MBDT_RP06, MBDT_RM80, MBDT_RP05, MBDT_RP07,
158: MBDT_FUJI, MBDT_FUJI, MBDT_FUJI, MBDT_ML11A, MBDT_ML11B, 0 };
159: struct mba_device *hpinfo[NHP];
160: int hpattach(),hpustart(),hpstart(),hpdtint();
161: struct mba_driver hpdriver =
162: { hpattach, 0, hpustart, hpstart, hpdtint, 0,
163: hptypes, "hp", 0, hpinfo };
164:
165: struct hpst {
166: short nsect;
167: short ntrak;
168: short nspc;
169: short ncyl;
170: struct size *sizes;
171: } hpst[] = {
172: 32, 5, 32*5, 823, rm3_sizes, /* RM03 */
173: 32, 19, 32*19, 823, rm5_sizes, /* RM05 */
174: 22, 19, 22*19, 815, hp6_sizes, /* RP06 */
175: 31, 14, 31*14, 559, rm80_sizes, /* RM80 */
176: 22, 19, 22*19, 411, hp6_sizes, /* RP05 */
177: 50, 32, 50*32, 630, hp7_sizes, /* RP07 */
178: /* the following three entries must be contiguous */
179: 32, 10, 32*10, 823, mfj_sizes, /* little fujitsu */
180: 43, 20, 43*20, 842, eagle_sizes, /* eagle */
181: 48, 20, 48*20, 842, eag48_sizes, /* eagle 48 sectors */
182: 1, 1, 1, 1, 0, /* ML11A */
183: 1, 1, 1, 1, 0, /* ML11B */
184: };
185:
186: u_char hp_offset[16] = {
187: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
188: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
189: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
190: 0, 0, 0, 0,
191: };
192:
193: struct buf rhpbuf[NHP];
194: #ifndef NOBADSECT
195: struct buf bhpbuf[NHP];
196: struct dkbad hpbad[NHP];
197: #endif
198: char hpinit[NHP];
199: char hprecal[NHP];
200: char hphdr[NHP];
201: daddr_t mlsize[NHP];
202:
203: #define b_cylin b_resid
204:
205: /* #define ML11 0 to remove ML11 support */
206: #define ML11 0
207: /*#define ML11 (hptypes[mi->mi_type] == MBDT_ML11A)*/
208: #define RP06 (hptypes[mi->mi_type] <= MBDT_RP06)
209: #define RM80 (hptypes[mi->mi_type] == MBDT_RM80)
210:
211: #ifdef INTRLVE
212: daddr_t dkblock();
213: #endif
214:
215: int hpseek;
216:
217: /*ARGSUSED*/
218: hpattach(mi, slave)
219: struct mba_device *mi;
220: {
221: register struct hpst *st = &hpst[mi->mi_type];
222:
223: if (hptypes[mi->mi_type] == MBDT_ML11B)
224: mi->mi_type--; /* A CHEAT - ML11B D.T. SHOULD == ML11A */
225: if (ML11) {
226: register struct hpdevice *hpaddr =
227: (struct hpdevice *)mi->mi_drv;
228: register int trt, sz;
229:
230: sz = hpaddr->hpmr & HPMR_SZ;
231: if ((hpaddr->hpmr & HPMR_ARRTYP) == 0)
232: sz >>= 2;
233: mlsize[mi->mi_unit] = sz;
234: if (mi->mi_dk >= 0) {
235: trt = (hpaddr->hpmr & HPMR_TRT) >> 8;
236: dk_mspw[mi->mi_dk] = 1.0 / (1<<(20-trt));
237: }
238: } else if (mi->mi_dk >= 0) {
239: register struct hpdevice *hp;
240: register int type;
241:
242: hp = (struct hpdevice *) mi->mi_drv;
243: type = hp->hpdt & MBDT_TYPE;
244: if (type == MBDT_FUJI) {
245: short maxtrk, maxsect;
246: /*
247: * we have some kind of disk on an Emulex SC750.
248: * We assume it's a little Fuji, and must now check
249: * if it's an Eagle.
250: */
251: hp->hphr = HPHR_MAXTRK;
252: maxtrk = hp->hphr;
253: if (maxtrk >= hpst[mi->mi_type].ntrak) {
254: mi->mi_type++;
255: /* it's an Eagle. now check # of sectors */
256: hp->hphr = HPHR_MAXSECT;
257: maxsect = hp->hphr;
258: if (maxsect > hpst[mi->mi_type].nsect) {
259: printf("%d sectors\n", maxsect);
260: mi->mi_type++;
261: }
262: }
263: }
264: st = &hpst[mi->mi_type];
265: dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256);
266: }
267: }
268:
269: hpstrategy(bp)
270: register struct buf *bp;
271: {
272: register struct mba_device *mi;
273: register struct hpst *st;
274: register int unit;
275: long sz, bn;
276: int xunit = minor(bp->b_dev) & 07;
277: int s;
278:
279: sz = bp->b_bcount;
280: sz = (sz+511) >> 9;
281: unit = dkunit(bp);
282: if (unit >= NHP)
283: goto bad;
284: mi = hpinfo[unit];
285: if (mi == 0 || mi->mi_alive == 0)
286: goto bad;
287: st = &hpst[mi->mi_type];
288: if (ML11) {
289: if (bp->b_blkno < 0 || dkblock(bp)+sz > mlsize[mi->mi_unit])
290: goto bad;
291: bp->b_cylin = 0;
292: } else {
293: if (bp->b_blkno < 0 ||
294: (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks)
295: goto bad;
296: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
297: }
298: s = spl5();
299: disksort(&mi->mi_tab, bp);
300: if (mi->mi_tab.b_active == 0)
301: mbustart(mi);
302: splx(s);
303: return;
304:
305: bad:
306: bp->b_flags |= B_ERROR;
307: iodone(bp);
308: return;
309: }
310:
311: hpustart(mi)
312: register struct mba_device *mi;
313: {
314: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
315: register struct buf *bp = mi->mi_tab.b_actf;
316: register struct hpst *st = &hpst[mi->mi_type];
317: daddr_t bn;
318: int sn, dist;
319:
320: hpaddr->hpcs1 = 0;
321: if ((hpaddr->hpcs1&HP_DVA) == 0)
322: return (MBU_BUSY);
323: if ((hpaddr->hpds & HPDS_VV) == 0 || hpinit[mi->mi_unit] == 0) {
324: #ifndef NOBADSECT
325: struct buf *bbp = &bhpbuf[mi->mi_unit];
326: #endif
327:
328: hpinit[mi->mi_unit] = 1;
329: hpaddr->hpcs1 = HP_DCLR|HP_GO;
330: if (mi->mi_mba->mba_drv[0].mbd_as & (1<<mi->mi_drive))
331: printf("DCLR attn\n");
332: hpaddr->hpcs1 = HP_PRESET|HP_GO;
333: if (!ML11)
334: hpaddr->hpof = HPOF_FMT22;
335: mbclrattn(mi);
336: #ifndef NOBADSECT
337: if (!ML11) {
338: bbp->b_flags = B_READ|B_BUSY;
339: bbp->b_dev = bp->b_dev;
340: bbp->b_bcount = 512;
341: bbp->b_un.b_addr = (caddr_t)&hpbad[mi->mi_unit];
342: bbp->b_blkno = st->ncyl*st->nspc - st->nsect;
343: bbp->b_cylin = st->ncyl - 1;
344: mi->mi_tab.b_actf = bbp;
345: bbp->av_forw = bp;
346: bp = bbp;
347: }
348: #endif
349: }
350: if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1)
351: return (MBU_DODATA);
352: if (ML11)
353: return (MBU_DODATA);
354: if ((hpaddr->hpds & HPDS_DREADY) != HPDS_DREADY)
355: return (MBU_DODATA);
356: bn = dkblock(bp);
357: sn = bn%st->nspc;
358: sn = (sn+st->nsect-hpSDIST)%st->nsect;
359: if (bp->b_cylin == (hpaddr->hpdc & 0xffff)) {
360: if (hpseek)
361: return (MBU_DODATA);
362: dist = ((hpaddr->hpla & 0xffff)>>6) - st->nsect + 1;
363: if (dist < 0)
364: dist += st->nsect;
365: if (dist > st->nsect - hpRDIST)
366: return (MBU_DODATA);
367: } else
368: hpaddr->hpdc = bp->b_cylin;
369: if (hpseek)
370: hpaddr->hpcs1 = HP_SEEK|HP_GO;
371: else {
372: hpaddr->hpda = sn;
373: hpaddr->hpcs1 = HP_SEARCH|HP_GO;
374: }
375: return (MBU_STARTED);
376: }
377:
378: hpstart(mi)
379: register struct mba_device *mi;
380: {
381: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
382: register struct buf *bp = mi->mi_tab.b_actf;
383: register struct hpst *st = &hpst[mi->mi_type];
384: daddr_t bn;
385: int sn, tn;
386:
387: bn = dkblock(bp);
388: if (ML11)
389: hpaddr->hpda = bn;
390: else {
391: sn = bn%st->nspc;
392: tn = sn/st->nsect;
393: sn %= st->nsect;
394: hpaddr->hpdc = bp->b_cylin;
395: hpaddr->hpda = (tn << 8) + sn;
396: }
397: if (hphdr[mi->mi_unit]) {
398: if (bp->b_flags & B_READ)
399: return (HP_RHDR|HP_GO);
400: else
401: return (HP_WHDR|HP_GO);
402: }
403: return (0);
404: }
405:
406: hpdtint(mi, mbsr)
407: register struct mba_device *mi;
408: int mbsr;
409: {
410: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
411: register struct buf *bp = mi->mi_tab.b_actf;
412: register int er1, er2;
413: int retry = 0;
414:
415: #ifndef NOBADSECT
416: if (bp->b_flags&B_BAD) {
417: if (hpecc(mi, CONT))
418: return(MBD_RESTARTED);
419: }
420: #endif
421: if (hpaddr->hpds&HPDS_ERR || mbsr&MBSR_EBITS) {
422: #ifdef HPDEBUG
423: if (hpdebug) {
424: int dc = hpaddr->hpdc, da = hpaddr->hpda;
425: struct hpst *st = &hpst[mi->mi_type];
426:
427: printf("hperr: bp %x cyl %d blk %d as %o ",
428: bp, bp->b_cylin, bp->b_blkno,
429: hpaddr->hpas&0xff);
430: printf("dc %x da %x\n",dc&0xffff, da&0xffff);
431: printf("errcnt %d ", mi->mi_tab.b_errcnt);
432: printf("mbsr=%b ", mbsr, mbsr_bits);
433: printf("er1=%b er2=%b\n",
434: hpaddr->hper1, HPER1_BITS,
435: hpaddr->hper2, HPER2_BITS);
436: DELAY(1000000);
437: }
438: #endif
439: er1 = hpaddr->hper1;
440: er2 = hpaddr->hper2;
441: if (er1 & HPER1_HCRC) {
442: er1 &= ~(HPER1_HCE|HPER1_FER);
443: er2 &= ~HPER2_BSE;
444: }
445: if (er1&HPER1_WLE) {
446: printf("hp%d: write locked\n", dkunit(bp));
447: bp->b_flags |= B_ERROR;
448: } else if ((er1&0xffff) == HPER1_FER && RP06 &&
449: hphdr[mi->mi_unit] == 0) {
450: #ifndef NOBADSECT
451: if (hpecc(mi, BSE))
452: {
453: #ifdef HPBDEBUG
454: if (hpdebug)
455: printf("MBD_RESTARTED\n");
456: #endif
457: return(MBD_RESTARTED);
458: }
459: else
460: #endif
461: goto hard;
462: } else if (++mi->mi_tab.b_errcnt > 27 ||
463: mbsr & MBSR_HARD ||
464: er1 & HPER1_HARD ||
465: hphdr[mi->mi_unit] ||
466: (!ML11 && (er2 & HPER2_HARD))) {
467: hard:
468: harderr(bp, "hp");
469: if (mbsr & (MBSR_EBITS &~ (MBSR_DTABT|MBSR_MBEXC)))
470: printf("mbsr=%b ", mbsr, mbsr_bits);
471: printf("er1=%b er2=%b",
472: hpaddr->hper1, HPER1_BITS,
473: hpaddr->hper2, HPER2_BITS);
474: if (hpaddr->hpmr)
475: printf(" mr=%o", hpaddr->hpmr&0xffff);
476: if (hpaddr->hpmr2)
477: printf(" mr2=%o", hpaddr->hpmr2&0xffff);
478: printf("\n");
479: bp->b_flags |= B_ERROR;
480: hprecal[mi->mi_unit] = 0;
481: } else if ((er2 & HPER2_BSE) && !ML11) {
482: #ifndef NOBADSECT
483: if (hpecc(mi, BSE))
484: return(MBD_RESTARTED);
485: else
486: #endif
487: goto hard;
488: } else if (RM80 && er2&HPER2_SSE) {
489: (void) hpecc(mi, SSE);
490: return (MBD_RESTARTED);
491: } else if ((er1&(HPER1_DCK|HPER1_ECH))==HPER1_DCK) {
492: if (hpecc(mi, ECC))
493: return (MBD_RESTARTED);
494: /* else done */
495: } else
496: retry = 1;
497: hpaddr->hpcs1 = HP_DCLR|HP_GO;
498: if (ML11) {
499: if (mi->mi_tab.b_errcnt >= 16)
500: goto hard;
501: } else if ((mi->mi_tab.b_errcnt&07) == 4) {
502: hpaddr->hpcs1 = HP_RECAL|HP_GO;
503: hprecal[mi->mi_unit] = 1;
504: return(MBD_RESTARTED);
505: }
506: if (retry)
507: return (MBD_RETRY);
508: }
509: #ifdef HPDEBUG
510: else
511: if (hpdebug && hprecal[mi->mi_unit]) {
512: printf("recal %d ", hprecal[mi->mi_unit]);
513: printf("errcnt %d\n", mi->mi_tab.b_errcnt);
514: printf("mbsr=%b ", mbsr, mbsr_bits);
515: printf("er1=%b er2=%b\n",
516: hpaddr->hper1, HPER1_BITS,
517: hpaddr->hper2, HPER2_BITS);
518: }
519: #endif
520: switch (hprecal[mi->mi_unit]) {
521:
522: case 1:
523: hpaddr->hpdc = bp->b_cylin;
524: hpaddr->hpcs1 = HP_SEEK|HP_GO;
525: hprecal[mi->mi_unit]++;
526: return (MBD_RESTARTED);
527: case 2:
528: if (mi->mi_tab.b_errcnt < 16 ||
529: (bp->b_flags & B_READ) == 0)
530: goto donerecal;
531: hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017]|HPOF_FMT22;
532: hpaddr->hpcs1 = HP_OFFSET|HP_GO;
533: hprecal[mi->mi_unit]++;
534: return (MBD_RESTARTED);
535: donerecal:
536: case 3:
537: hprecal[mi->mi_unit] = 0;
538: return (MBD_RETRY);
539: }
540: hphdr[mi->mi_unit] = 0;
541: bp->b_resid = -(mi->mi_mba->mba_bcr) & 0xffff;
542: if (mi->mi_tab.b_errcnt >= 16) {
543: /*
544: * This is fast and occurs rarely; we don't
545: * bother with interrupts.
546: */
547: hpaddr->hpcs1 = HP_RTC|HP_GO;
548: while (hpaddr->hpds & HPDS_PIP)
549: ;
550: mbclrattn(mi);
551: }
552: if (!ML11) {
553: hpaddr->hpof = HPOF_FMT22;
554: hpaddr->hpcs1 = HP_RELEASE|HP_GO;
555: }
556: return (MBD_DONE);
557: }
558:
559: hpread(dev)
560: dev_t dev;
561: {
562: register int unit = minor(dev) >> 3;
563:
564: if (unit >= NHP)
565: u.u_error = ENXIO;
566: else
567: physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys);
568: }
569:
570: hpwrite(dev)
571: dev_t dev;
572: {
573: register int unit = minor(dev) >> 3;
574:
575: if (unit >= NHP)
576: u.u_error = ENXIO;
577: else
578: physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys);
579: }
580:
581: /*ARGSUSED*/
582: hpioctl(dev, cmd, addr, flag)
583: dev_t dev;
584: int cmd;
585: caddr_t addr;
586: int flag;
587: {
588:
589: switch (cmd) {
590: case DKIOCHDR: /* do header read/write */
591: if (suser())
592: hphdr[minor(dev)>>3] = 1;
593: return;
594:
595: default:
596: u.u_error = ENXIO;
597: }
598: }
599:
600: hpecc(mi, flag)
601: register struct mba_device *mi;
602: int flag;
603: {
604: register struct mba_regs *mbp = mi->mi_mba;
605: register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv;
606: register struct buf *bp = mi->mi_tab.b_actf;
607: register struct hpst *st = &hpst[mi->mi_type];
608: int npf, o;
609: int bn, cn, tn, sn;
610: int bcr;
611: static nerr;
612:
613: bcr = mbp->mba_bcr & 0xffff;
614: if (bcr)
615: bcr |= 0xffff0000; /* sxt */
616: #ifndef NOBADSECT
617: if (flag == CONT)
618: npf = bp->b_error;
619: else
620: #endif
621: npf = btop(bcr + bp->b_bcount);
622: o = (int)bp->b_un.b_addr & PGOFSET;
623: bn = dkblock(bp);
624: #ifdef HPBDEBUG
625: if (hpbdebug)
626: printf("hpecc: mbp->mba_bcr %x bcr %x bp->b_bcount %x bp->b_error %x bn %x npf %x\n",
627: mbp->mba_bcr, bcr, bp->b_bcount, bp->b_error, bn, npf);
628: if (hpbdebug)
629: printf("ber npf: %x\n", ((rp->hpdc & 0xffff) * (st->nspc))
630: + ((((rp->hpda) >> 8) & 0xff) * st->nsect)
631: + ((rp->hpda) & 0xff)
632: - (((st->sizes[minor(bp->b_dev)&07].cyloff) * st->nspc)
633: + 1 + bn));
634: #endif
635: cn = bp->b_cylin;
636: sn = bn%(st->nspc) + npf;
637: tn = sn/st->nsect;
638: sn %= st->nsect;
639: cn += tn/st->ntrak;
640: tn %= st->ntrak;
641: switch (flag) {
642: case ECC:
643: {
644: register int i;
645: caddr_t addr;
646: struct pte mpte;
647: int bit, byte, mask;
648:
649: npf--; /* because block in error is previous block */
650: printf("hp%d%c: soft ecc sn%d\n", dkunit(bp),
651: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
652: nerr++;
653: if ((nerr%100)==0)
654: printf("%d soft errors\n", nerr);
655: mask = rp->hpec2&0xffff;
656: i = (rp->hpec1&0xffff) - 1; /* -1 makes 0 origin */
657: bit = i&07;
658: i = (i&~07)>>3;
659: byte = i + o;
660: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
661: mpte = mbp->mba_map[npf+btop(byte)];
662: addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET);
663: putmemc(addr, getmemc(addr)^(mask<<bit));
664: byte++;
665: i++;
666: bit -= 8;
667: }
668: if (bcr == 0)
669: return (0);
670: npf++;
671: break;
672: }
673:
674: case SSE:
675: #ifdef HPBDEBUG
676: if (hpbdebug)
677: printf("hpeccSSE\n");
678: #endif
679: rp->hpof |= HPOF_SSEI;
680: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf));
681: break;
682:
683: #ifndef NOBADSECT
684: case BSE:
685: #ifdef HPBDEBUG
686: if (hpbdebug)
687: printf("hpeccBSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn);
688: #endif
689: if ((bn = isbad(&hpbad[mi->mi_unit], cn, tn, sn)) < 0)
690: return(0);
691: bp->b_flags |= B_BAD;
692: bp->b_error = npf + 1;
693: bn = st->ncyl*st->nspc - st->nsect - 1 - bn;
694: cn = bn/st->nspc;
695: sn = bn%st->nspc;
696: tn = sn/st->nsect;
697: sn %= st->nsect;
698: mbp->mba_bcr = -512;
699: #ifdef HPBDEBUG
700: if (hpbdebug)
701: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
702: #endif
703: break;
704:
705: case CONT:
706: #ifdef HPBDEBUG
707: if (hpbdebug)
708: printf("hpecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn);
709: #endif
710: npf = bp->b_error;
711: bp->b_flags &= ~B_BAD;
712: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf));
713: if ((mbp->mba_bcr & 0xffff) == 0)
714: return(0);
715: break;
716: #endif
717: }
718: #ifdef HPBDEBUG
719: if (hpbdebug)
720: printf("hpecc, endcase: bn %d\n",bn);
721: #endif
722: rp->hpcs1 = HP_DCLR|HP_GO;
723: if (rp->hpof&HPOF_SSEI)
724: sn++;
725: rp->hpdc = cn;
726: rp->hpda = (tn<<8) + sn;
727: mbp->mba_sr = -1;
728: mbp->mba_var = (int)ptob(npf) + o;
729: rp->hpcs1 = bp->b_flags&B_READ ? HP_RCOM|HP_GO : HP_WCOM|HP_GO;
730: mi->mi_tab.b_errcnt = 0; /* error has been corrected */
731: return (1);
732: }
733:
734: #define DBSIZE 20
735:
736: hpdump(dev)
737: dev_t dev;
738: {
739: register struct mba_device *mi;
740: register struct mba_regs *mba;
741: struct hpdevice *hpaddr;
742: char *start;
743: int num, unit;
744: register struct hpst *st;
745:
746: num = maxfree;
747: start = 0;
748: unit = minor(dev) >> 3;
749: if (unit >= NHP)
750: return (ENXIO);
751: #define phys(a,b) ((b)((int)(a)&0x7fffffff))
752: mi = phys(hpinfo[unit],struct mba_device *);
753: if (mi == 0 || mi->mi_alive == 0)
754: return (ENXIO);
755: mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
756: mba->mba_cr = MBCR_INIT;
757: hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive];
758: if ((hpaddr->hpds & HPDS_VV) == 0) {
759: hpaddr->hpcs1 = HP_DCLR|HP_GO;
760: hpaddr->hpcs1 = HP_PRESET|HP_GO;
761: hpaddr->hpof = HPOF_FMT22;
762: }
763: st = &hpst[mi->mi_type];
764: if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks)
765: return (EINVAL);
766: while (num > 0) {
767: register struct pte *hpte = mba->mba_map;
768: register int i;
769: int blk, cn, sn, tn;
770: daddr_t bn;
771:
772: blk = num > DBSIZE ? DBSIZE : num;
773: bn = dumplo + btop(start);
774: cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff;
775: sn = bn%st->nspc;
776: tn = sn/st->nsect;
777: sn = sn%st->nsect;
778: hpaddr->hpdc = cn;
779: hpaddr->hpda = (tn << 8) + sn;
780: for (i = 0; i < blk; i++)
781: *(int *)hpte++ = (btop(start)+i) | PG_V;
782: mba->mba_sr = -1;
783: mba->mba_bcr = -(blk*NBPG);
784: mba->mba_var = 0;
785: hpaddr->hpcs1 = HP_WCOM | HP_GO;
786: while ((hpaddr->hpds & HPDS_DRY) == 0)
787: ;
788: if (hpaddr->hpds&HPDS_ERR)
789: return (EIO);
790: start += blk*NBPG;
791: num -= blk;
792: }
793: return (0);
794: }
795: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.