![[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] / 42BSD / sys / vaxmba|
Return to hp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / vaxmba |
1.1 root 1: /* hp.c 6.2 83/09/25 */
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: #include "../machine/pte.h"
22:
23: #include "../h/param.h"
24: #include "../h/systm.h"
25: #include "../h/dk.h"
26: #include "../h/buf.h"
27: #include "../h/conf.h"
28: #include "../h/dir.h"
29: #include "../h/user.h"
30: #include "../h/map.h"
31: #include "../vax/mtpr.h"
32: #include "../h/vm.h"
33: #include "../h/cmap.h"
34: #include "../h/dkbad.h"
35: #include "../h/ioctl.h"
36: #include "../h/uio.h"
37:
38: #include "../vax/dkio.h"
39: #include "../vaxmba/mbareg.h"
40: #include "../vaxmba/mbavar.h"
41: #include "../vaxmba/hpreg.h"
42:
43: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
44: struct size {
45: daddr_t nblocks;
46: int cyloff;
47: } rp06_sizes[8] = {
48: 15884, 0, /* A=cyl 0 thru 37 */
49: 33440, 38, /* B=cyl 38 thru 117 */
50: 340670, 0, /* C=cyl 0 thru 814 */
51: 15884, 118, /* D=cyl 118 thru 155 */
52: 55936, 156, /* E=cyl 156 thru 289 */
53: 219384, 290, /* F=cyl 290 thru 814 */
54: 291280, 118, /* G=cyl 118 thru 814 */
55: 0, 0,
56: }, rp05_sizes[8] = {
57: 15884, 0, /* A=cyl 0 thru 37 */
58: 33440, 38, /* B=cyl 38 thru 117 */
59: 171798, 0, /* C=cyl 0 thru 410 */
60: 15884, 118, /* D=cyl 118 thru 155 */
61: 55936, 156, /* E=cyl 156 thru 289 */
62: 50512, 290, /* F=cyl 290 thru 410 */
63: 122408, 118, /* G=cyl 118 thru 410 */
64: 0, 0,
65: }, rm03_sizes[8] = {
66: 15884, 0, /* A=cyl 0 thru 99 */
67: 33440, 100, /* B=cyl 100 thru 308 */
68: 131680, 0, /* C=cyl 0 thru 822 */
69: 15884, 309, /* D=cyl 309 thru 408 */
70: 55936, 409, /* E=cyl 409 thru 758 */
71: 10144, 759, /* F=cyl 759 thru 822 */
72: 82144, 309, /* G=cyl 309 thru 822 */
73: 0, 0,
74: }, rm05_sizes[8] = {
75: 15884, 0, /* A=cyl 0 thru 26 */
76: 33440, 27, /* B=cyl 27 thru 81 */
77: 500384, 0, /* C=cyl 0 thru 822 */
78: 15884, 562, /* D=cyl 562 thru 588 */
79: 55936, 589, /* E=cyl 589 thru 680 */
80: 86240, 681, /* F=cyl 681 thru 822 */
81: 158592, 562, /* G=cyl 562 thru 822 */
82: 291346, 82, /* H=cyl 82 thru 561 */
83: }, rm80_sizes[8] = {
84: 15884, 0, /* A=cyl 0 thru 36 */
85: 33440, 37, /* B=cyl 37 thru 114 */
86: 242606, 0, /* C=cyl 0 thru 558 */
87: 15884, 115, /* D=cyl 115 thru 151 */
88: 55936, 152, /* E=cyl 152 thru 280 */
89: 120559, 281, /* F=cyl 281 thru 558 */
90: 192603, 115, /* G=cyl 115 thru 558 */
91: 0, 0,
92: }, rp07_sizes[8] = {
93: 15884, 0, /* A=cyl 0 thru 9 */
94: 66880, 10, /* B=cyl 10 thru 51 */
95: 1008000, 0, /* C=cyl 0 thru 629 */
96: 15884, 235, /* D=cyl 235 thru 244 */
97: 307200, 245, /* E=cyl 245 thru 436 */
98: 308650, 437, /* F=cyl 437 thru 629 */
99: 631850, 235, /* G=cyl 235 thru 629 */
100: 291346, 52, /* H=cyl 52 thru 234 */
101: }, cdc9775_sizes[8] = {
102: 15884, 0, /* A=cyl 0 thru 12 */
103: 66880, 13, /* B=cyl 13 thru 65 */
104: 1077760, 0, /* C=cyl 0 thru 841 */
105: 15884, 294, /* D=cyl 294 thru 306 */
106: 307200, 307, /* E=cyl 307 thru 546 */
107: 377440, 547, /* F=cyl 547 thru 841 */
108: 701280, 294, /* G=cyl 294 thru 841 */
109: 291346, 66, /* H=cyl 66 thru 293 */
110: }, cdc9730_sizes[8] = {
111: 15884, 0, /* A=cyl 0 thru 49 */
112: 33440, 50, /* B=cyl 50 thru 154 */
113: 263360, 0, /* C=cyl 0 thru 822 */
114: 15884, 155, /* D=cyl 155 thru 204 */
115: 55936, 205, /* E=cyl 205 thru 379 */
116: 141664, 380, /* F=cyl 380 thru 822 */
117: 213664, 155, /* G=cyl 155 thru 822 */
118: 0, 0,
119: }, capricorn_sizes[8] = {
120: 15884, 0, /* A=cyl 0 thru 31 */
121: 33440, 32, /* B=cyl 32 thru 97 */
122: 524288, 0, /* C=cyl 0 thru 1023 */
123: 15884, 668, /* D=cyl 668 thru 699 */
124: 55936, 700, /* E=cyl 700 thru 809 */
125: 109472, 810, /* F=cyl 810 thru 1023 */
126: 182176, 668, /* G=cyl 668 thru 1023 */
127: 291346, 98, /* H=cyl 98 thru 667 */
128: }, eagle_sizes[8] = {
129: 15884, 0, /* A=cyl 0 thru 16 */
130: 66880, 17, /* B=cyl 17 thru 86 */
131: 808320, 0, /* C=cyl 0 thru 841 */
132: 15884, 391, /* D=cyl 391 thru 407 */
133: 307200, 408, /* E=cyl 408 thru 727 */
134: 109296, 728, /* F=cyl 728 thru 841 */
135: 432816, 391, /* G=cyl 391 thru 841 */
136: 291346, 87, /* H=cyl 87 thru 390 */
137: }, ampex_sizes[8] = {
138: 15884, 0, /* A=cyl 0 thru 26 */
139: 33440, 27, /* B=cyl 27 thru 81 */
140: 495520, 0, /* C=cyl 0 thru 814 */
141: 15884, 562, /* D=cyl 562 thru 588 */
142: 55936, 589, /* E=cyl 589 thru 680 */
143: 81312, 681, /* F=cyl 681 thru 814 */
144: 153664, 562, /* G=cyl 562 thru 814 */
145: 291346, 82, /* H=cyl 82 thru 561 */
146: };
147: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
148:
149: /*
150: * Table for converting Massbus drive types into
151: * indices into the partition tables. Slots are
152: * left for those drives devined from other means
153: * (e.g. SI, AMPEX, etc.).
154: */
155: short hptypes[] = {
156: #define HPDT_RM03 0
157: MBDT_RM03,
158: #define HPDT_RM05 1
159: MBDT_RM05,
160: #define HPDT_RP06 2
161: MBDT_RP06,
162: #define HPDT_RM80 3
163: MBDT_RM80,
164: #define HPDT_RP04 4
165: MBDT_RP04,
166: #define HPDT_RP05 5
167: MBDT_RP05,
168: #define HPDT_RP07 6
169: MBDT_RP07,
170: #define HPDT_ML11A 7
171: MBDT_ML11A,
172: #define HPDT_ML11B 8
173: MBDT_ML11B,
174: #define HPDT_9775 9
175: -1,
176: #define HPDT_9730 10
177: -1,
178: #define HPDT_CAPRICORN 11
179: -1,
180: #define HPDT_EAGLE 12
181: -1,
182: #define HPDT_9300 13
183: -1,
184: #define HPDT_RM02 14
185: MBDT_RM02, /* beware, actually capricorn or eagle */
186: 0
187: };
188: struct mba_device *hpinfo[NHP];
189: int hpattach(),hpustart(),hpstart(),hpdtint();
190: struct mba_driver hpdriver =
191: { hpattach, 0, hpustart, hpstart, hpdtint, 0,
192: hptypes, "hp", 0, hpinfo };
193:
194: /*
195: * Beware, sdist and rdist are not well tuned
196: * for many of the drives listed in this table.
197: * Try patching things with something i/o intensive
198: * running and watch iostat.
199: */
200: struct hpst {
201: short nsect; /* # sectors/track */
202: short ntrak; /* # tracks/cylinder */
203: short nspc; /* # sector/cylinders */
204: short ncyl; /* # cylinders */
205: struct size *sizes; /* partition tables */
206: short sdist; /* seek distance metric */
207: short rdist; /* rotational distance metric */
208: } hpst[] = {
209: { 32, 5, 32*5, 823, rm03_sizes, 3, 4 }, /* RM03 */
210: { 32, 19, 32*19, 823, rm05_sizes, 3, 4 }, /* RM05 */
211: { 22, 19, 22*19, 815, rp06_sizes, 3, 4 }, /* RP06 */
212: { 31, 14, 31*14, 559, rm80_sizes, 3, 4 }, /* RM80 */
213: { 22, 19, 22*19, 411, rp05_sizes, 3, 4 }, /* RP04 */
214: { 22, 19, 22*19, 411, rp05_sizes, 3, 4 }, /* RP05 */
215: { 50, 32, 50*32, 630, rp07_sizes, 7, 8 }, /* RP07 */
216: { 1, 1, 1, 1, 0, 0, 0 }, /* ML11A */
217: { 1, 1, 1, 1, 0, 0, 0 }, /* ML11B */
218: { 32, 40, 32*40, 843, cdc9775_sizes, 3, 4 }, /* 9775 */
219: { 32, 10, 32*10, 823, cdc9730_sizes, 3, 4 }, /* 9730 */
220: { 32, 16, 32*16, 1024, capricorn_sizes,7, 8 }, /* Capricorn */
221: { 48, 20, 48*20, 842, eagle_sizes, 7, 8 }, /* EAGLE */
222: { 32, 19, 32*19, 815, ampex_sizes, 3, 4 }, /* 9300 */
223: };
224:
225: u_char hp_offset[16] = {
226: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
227: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
228: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
229: 0, 0, 0, 0,
230: };
231:
232: struct buf rhpbuf[NHP];
233: struct buf bhpbuf[NHP];
234: struct dkbad hpbad[NHP];
235:
236: struct hpsoftc {
237: u_char sc_hpinit; /* drive initialized */
238: u_char sc_recal; /* recalibrate state */
239: u_char sc_hdr; /* next i/o includes header */
240: u_char sc_doseeks; /* perform explicit seeks */
241: daddr_t sc_mlsize; /* ML11 size */
242: } hpsoftc[NHP];
243:
244: #define b_cylin b_resid
245:
246: /* #define ML11 0 to remove ML11 support */
247: #define ML11 (hptypes[mi->mi_type] == MBDT_ML11A)
248: #define RP06 (hptypes[mi->mi_type] <= MBDT_RP06)
249: #define RM80 (hptypes[mi->mi_type] == MBDT_RM80)
250:
251: #define MASKREG(reg) ((reg)&0xffff)
252:
253: #ifdef INTRLVE
254: daddr_t dkblock();
255: #endif
256:
257: /*ARGSUSED*/
258: hpattach(mi, slave)
259: register struct mba_device *mi;
260: {
261:
262: mi->mi_type = hpmaptype(mi);
263: if (!ML11 && mi->mi_dk >= 0) {
264: struct hpst *st = &hpst[mi->mi_type];
265:
266: dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256);
267: }
268: }
269:
270: /*
271: * Map apparent MASSBUS drive type into manufacturer
272: * specific configuration. For SI controllers this is done
273: * based on codes in the serial number register. For
274: * EMULEX controllers, the track and sector attributes are
275: * used when the drive type is an RM02 (not supported by DEC).
276: */
277: hpmaptype(mi)
278: register struct mba_device *mi;
279: {
280: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
281: register int type = mi->mi_type;
282:
283: /*
284: * Model-byte processing for SI controllers.
285: * NB: Only deals with RM03 and RM05 emulations.
286: */
287: if (type == HPDT_RM03 || type == HPDT_RM05) {
288: int hpsn = hpaddr->hpsn;
289:
290: if ((hpsn & SIMB_LU) != mi->mi_drive)
291: return (type);
292: switch ((hpsn & SIMB_MB) & ~(SIMB_S6|SIRM03|SIRM05)) {
293:
294: case SI9775D:
295: printf("hp%d: 9775 (direct)\n", mi->mi_unit);
296: type = HPDT_9775;
297: break;
298:
299: case SI9730D:
300: printf("hp%d: 9730 (direct)\n", mi->mi_unit);
301: type = HPDT_9730;
302: break;
303:
304: /*
305: * Beware, since the only SI controller we
306: * have has a 9300 instead of a 9766, we map the
307: * drive type into the 9300. This means that
308: * on a 9766 you lose the last 8 cylinders (argh).
309: */
310: case SI9766:
311: printf("hp%d: 9300\n", mi->mi_unit);
312: type = HPDT_9300;
313: break;
314:
315: case SI9762:
316: printf("hp%d: 9762\n", mi->mi_unit);
317: type = HPDT_RM03;
318: break;
319:
320: case SICAPD:
321: printf("hp%d: capricorn\n", mi->mi_unit);
322: type = HPDT_CAPRICORN;
323: break;
324:
325: case SI9751D:
326: printf("hp%d: eagle\n", mi->mi_unit);
327: type = HPDT_EAGLE;
328: break;
329: }
330: return (type);
331: }
332:
333: /*
334: * EMULEX SC750 or SC780. Poke the holding register.
335: */
336: if (type == HPDT_RM02) {
337: int ntracks, nsectors;
338:
339: hpaddr->hpof = HPOF_FMT22;
340: mbclrattn(mi);
341: hpaddr->hpcs1 = HP_NOP;
342: hpaddr->hphr = HPHR_MAXTRAK;
343: ntracks = MASKREG(hpaddr->hphr) + 1;
344: if (ntracks == 16) {
345: printf("hp%d: capricorn\n", mi->mi_unit);
346: type = HPDT_CAPRICORN;
347: goto done;
348: }
349: if (ntracks == 19) {
350: printf("hp%d: 9300\n", mi->mi_unit);
351: type = HPDT_9300;
352: goto done;
353: }
354: hpaddr->hpcs1 = HP_NOP;
355: hpaddr->hphr = HPHR_MAXSECT;
356: nsectors = MASKREG(hpaddr->hphr) + 1;
357: if (ntracks == 20 && nsectors == 48) {
358: type = HPDT_EAGLE;
359: printf("hp%d: eagle\n", mi->mi_unit);
360: goto done;
361: }
362: printf("hp%d: ntracks %d, nsectors %d: unknown device\n",
363: mi->mi_unit, ntracks, nsectors);
364: done:
365: hpaddr->hpcs1 = HP_DCLR|HP_GO;
366: mbclrattn(mi); /* conservative */
367: return (type);
368: }
369:
370: /*
371: * Map all ML11's to the same type. Also calculate
372: * transfer rates based on device characteristics.
373: */
374: if (type == HPDT_ML11A || type == HPDT_ML11B) {
375: register struct hpsoftc *sc = &hpsoftc[mi->mi_unit];
376: register int trt;
377:
378: sc->sc_mlsize = hpaddr->hpmr & HPMR_SZ;
379: if ((hpaddr->hpmr & HPMR_ARRTYP) == 0)
380: sc->sc_mlsize >>= 2;
381: if (mi->mi_dk >= 0) {
382: trt = (hpaddr->hpmr & HPMR_TRT) >> 8;
383: dk_mspw[mi->mi_dk] = 1.0 / (1<<(20-trt));
384: }
385: type = HPDT_ML11A;
386: }
387: return (type);
388: }
389:
390: hpopen(dev)
391: dev_t dev;
392: {
393: register int unit = minor(dev) >> 3;
394: register struct mba_device *mi;
395:
396: if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0)
397: return (ENXIO);
398: return (0);
399: }
400:
401: hpstrategy(bp)
402: register struct buf *bp;
403: {
404: register struct mba_device *mi;
405: register struct hpst *st;
406: register int unit;
407: long sz, bn;
408: int xunit = minor(bp->b_dev) & 07;
409: int s;
410:
411: sz = bp->b_bcount;
412: sz = (sz+511) >> 9;
413: unit = dkunit(bp);
414: if (unit >= NHP)
415: goto bad;
416: mi = hpinfo[unit];
417: if (mi == 0 || mi->mi_alive == 0)
418: goto bad;
419: st = &hpst[mi->mi_type];
420: if (ML11) {
421: struct hpsoftc *sc = &hpsoftc[unit];
422:
423: if (bp->b_blkno < 0 ||
424: dkblock(bp)+sz > sc->sc_mlsize)
425: goto bad;
426: bp->b_cylin = 0;
427: } else {
428: if (bp->b_blkno < 0 ||
429: (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks)
430: goto bad;
431: bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff;
432: }
433: s = spl5();
434: disksort(&mi->mi_tab, bp);
435: if (mi->mi_tab.b_active == 0)
436: mbustart(mi);
437: splx(s);
438: return;
439:
440: bad:
441: bp->b_flags |= B_ERROR;
442: iodone(bp);
443: return;
444: }
445:
446: hpustart(mi)
447: register struct mba_device *mi;
448: {
449: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
450: register struct buf *bp = mi->mi_tab.b_actf;
451: register struct hpst *st;
452: struct hpsoftc *sc = &hpsoftc[mi->mi_unit];
453: daddr_t bn;
454: int sn, dist;
455:
456: st = &hpst[mi->mi_type];
457: hpaddr->hpcs1 = 0;
458: if ((hpaddr->hpcs1&HP_DVA) == 0)
459: return (MBU_BUSY);
460: if ((hpaddr->hpds & HPDS_VV) == 0 || !sc->sc_hpinit) {
461: struct buf *bbp = &bhpbuf[mi->mi_unit];
462:
463: sc->sc_hpinit = 1;
464: hpaddr->hpcs1 = HP_DCLR|HP_GO;
465: if (mi->mi_mba->mba_drv[0].mbd_as & (1<<mi->mi_drive))
466: printf("DCLR attn\n");
467: hpaddr->hpcs1 = HP_PRESET|HP_GO;
468: if (!ML11)
469: hpaddr->hpof = HPOF_FMT22;
470: mbclrattn(mi);
471: if (!ML11) {
472: bbp->b_flags = B_READ|B_BUSY;
473: bbp->b_dev = bp->b_dev;
474: bbp->b_bcount = 512;
475: bbp->b_un.b_addr = (caddr_t)&hpbad[mi->mi_unit];
476: bbp->b_blkno = st->ncyl*st->nspc - st->nsect;
477: bbp->b_cylin = st->ncyl - 1;
478: mi->mi_tab.b_actf = bbp;
479: bbp->av_forw = bp;
480: bp = bbp;
481: }
482: }
483: if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1)
484: return (MBU_DODATA);
485: if (ML11)
486: return (MBU_DODATA);
487: if ((hpaddr->hpds & HPDS_DREADY) != HPDS_DREADY)
488: return (MBU_DODATA);
489: bn = dkblock(bp);
490: sn = bn%st->nspc;
491: sn = (sn + st->nsect - st->sdist) % st->nsect;
492: if (bp->b_cylin == MASKREG(hpaddr->hpdc)) {
493: if (sc->sc_doseeks)
494: return (MBU_DODATA);
495: dist = (MASKREG(hpaddr->hpla) >> 6) - st->nsect + 1;
496: if (dist < 0)
497: dist += st->nsect;
498: if (dist > st->nsect - st->rdist)
499: return (MBU_DODATA);
500: } else
501: hpaddr->hpdc = bp->b_cylin;
502: if (sc->sc_doseeks)
503: hpaddr->hpcs1 = HP_SEEK|HP_GO;
504: else {
505: hpaddr->hpda = sn;
506: hpaddr->hpcs1 = HP_SEARCH|HP_GO;
507: }
508: return (MBU_STARTED);
509: }
510:
511: hpstart(mi)
512: register struct mba_device *mi;
513: {
514: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
515: register struct buf *bp = mi->mi_tab.b_actf;
516: register struct hpst *st = &hpst[mi->mi_type];
517: struct hpsoftc *sc = &hpsoftc[mi->mi_unit];
518: daddr_t bn;
519: int sn, tn;
520:
521: bn = dkblock(bp);
522: if (ML11)
523: hpaddr->hpda = bn;
524: else {
525: sn = bn%st->nspc;
526: tn = sn/st->nsect;
527: sn %= st->nsect;
528: hpaddr->hpdc = bp->b_cylin;
529: hpaddr->hpda = (tn << 8) + sn;
530: }
531: if (sc->sc_hdr) {
532: if (bp->b_flags & B_READ)
533: return (HP_RHDR|HP_GO);
534: else
535: return (HP_WHDR|HP_GO);
536: }
537: return (0);
538: }
539:
540: hpdtint(mi, mbsr)
541: register struct mba_device *mi;
542: int mbsr;
543: {
544: register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;
545: register struct buf *bp = mi->mi_tab.b_actf;
546: register struct hpst *st;
547: register int er1, er2;
548: struct hpsoftc *sc = &hpsoftc[mi->mi_unit];
549: int retry = 0;
550:
551: st = &hpst[mi->mi_type];
552: if (bp->b_flags&B_BAD && hpecc(mi, CONT))
553: return (MBD_RESTARTED);
554: if (hpaddr->hpds&HPDS_ERR || mbsr&MBSR_EBITS) {
555: er1 = hpaddr->hper1;
556: er2 = hpaddr->hper2;
557: #ifdef HPDEBUG
558: if (hpdebug) {
559: int dc = hpaddr->hpdc, da = hpaddr->hpda;
560:
561: printf("hperr: bp %x cyl %d blk %d as %o ",
562: bp, bp->b_cylin, bp->b_blkno,
563: hpaddr->hpas&0xff);
564: printf("dc %x da %x\n",MASKREG(dc), MASKREG(da));
565: printf("errcnt %d ", mi->mi_tab.b_errcnt);
566: printf("mbsr=%b ", mbsr, mbsr_bits);
567: printf("er1=%b er2=%b\n", MASKREG(er1), HPER1_BITS,
568: MASKREG(er2), HPER2_BITS);
569: DELAY(1000000);
570: }
571: #endif
572: if (er1 & HPER1_HCRC) {
573: er1 &= ~(HPER1_HCE|HPER1_FER);
574: er2 &= ~HPER2_BSE;
575: }
576: if (er1&HPER1_WLE) {
577: printf("hp%d: write locked\n", dkunit(bp));
578: bp->b_flags |= B_ERROR;
579: } else if (MASKREG(er1) == HPER1_FER && RP06 && !sc->sc_hdr) {
580: if (hpecc(mi, BSE))
581: return (MBD_RESTARTED);
582: goto hard;
583: } else if (++mi->mi_tab.b_errcnt > 27 ||
584: mbsr & MBSR_HARD ||
585: er1 & HPER1_HARD ||
586: sc->sc_hdr ||
587: (!ML11 && (er2 & HPER2_HARD))) {
588: /*
589: * HCRC means the header is screwed up and the sector
590: * might well exist in the bad sector table,
591: * better check....
592: */
593: if ((er1&HPER1_HCRC) &&
594: !ML11 && !sc->sc_hdr && hpecc(mi, BSE))
595: return (MBD_RESTARTED);
596: hard:
597: if (ML11)
598: bp->b_blkno = MASKREG(hpaddr->hpda);
599: else
600: bp->b_blkno = MASKREG(hpaddr->hpdc) * st->nspc +
601: (MASKREG(hpaddr->hpda) >> 8) * st->nsect +
602: (hpaddr->hpda&0xff);
603: /*
604: * If we have a data check error or a hard
605: * ecc error the bad sector has been read/written,
606: * and the controller registers are pointing to
607: * the next sector...
608: */
609: if (er1&(HPER1_DCK|HPER1_ECH) || sc->sc_hdr)
610: bp->b_blkno--;
611: harderr(bp, "hp");
612: if (mbsr & (MBSR_EBITS &~ (MBSR_DTABT|MBSR_MBEXC)))
613: printf("mbsr=%b ", mbsr, mbsr_bits);
614: printf("er1=%b er2=%b",
615: MASKREG(hpaddr->hper1), HPER1_BITS,
616: MASKREG(hpaddr->hper2), HPER2_BITS);
617: if (hpaddr->hpmr)
618: printf(" mr=%o", MASKREG(hpaddr->hpmr));
619: if (hpaddr->hpmr2)
620: printf(" mr2=%o", MASKREG(hpaddr->hpmr2));
621: if (sc->sc_hdr)
622: printf(" (hdr i/o)");
623: printf("\n");
624: bp->b_flags |= B_ERROR;
625: retry = 0;
626: sc->sc_recal = 0;
627: } else if ((er2 & HPER2_BSE) && !ML11) {
628: if (hpecc(mi, BSE))
629: return (MBD_RESTARTED);
630: goto hard;
631: } else if (RM80 && er2&HPER2_SSE) {
632: (void) hpecc(mi, SSE);
633: return (MBD_RESTARTED);
634: } else if ((er1&(HPER1_DCK|HPER1_ECH))==HPER1_DCK) {
635: if (hpecc(mi, ECC))
636: return (MBD_RESTARTED);
637: /* else done */
638: } else
639: retry = 1;
640: hpaddr->hpcs1 = HP_DCLR|HP_GO;
641: if (ML11) {
642: if (mi->mi_tab.b_errcnt >= 16)
643: goto hard;
644: } else if ((mi->mi_tab.b_errcnt&07) == 4) {
645: hpaddr->hpcs1 = HP_RECAL|HP_GO;
646: sc->sc_recal = 1;
647: return (MBD_RESTARTED);
648: }
649: if (retry)
650: return (MBD_RETRY);
651: }
652: #ifdef HPDEBUG
653: else
654: if (hpdebug && sc->sc_recal) {
655: printf("recal %d ", sc->sc_recal);
656: printf("errcnt %d\n", mi->mi_tab.b_errcnt);
657: printf("mbsr=%b ", mbsr, mbsr_bits);
658: printf("er1=%b er2=%b\n",
659: hpaddr->hper1, HPER1_BITS,
660: hpaddr->hper2, HPER2_BITS);
661: }
662: #endif
663: switch (sc->sc_recal) {
664:
665: case 1:
666: hpaddr->hpdc = bp->b_cylin;
667: hpaddr->hpcs1 = HP_SEEK|HP_GO;
668: sc->sc_recal++;
669: return (MBD_RESTARTED);
670: case 2:
671: if (mi->mi_tab.b_errcnt < 16 ||
672: (bp->b_flags & B_READ) == 0)
673: goto donerecal;
674: hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017]|HPOF_FMT22;
675: hpaddr->hpcs1 = HP_OFFSET|HP_GO;
676: sc->sc_recal++;
677: return (MBD_RESTARTED);
678: donerecal:
679: case 3:
680: sc->sc_recal = 0;
681: return (MBD_RETRY);
682: }
683: sc->sc_hdr = 0;
684: bp->b_resid = MASKREG(-mi->mi_mba->mba_bcr);
685: if (mi->mi_tab.b_errcnt >= 16) {
686: /*
687: * This is fast and occurs rarely; we don't
688: * bother with interrupts.
689: */
690: hpaddr->hpcs1 = HP_RTC|HP_GO;
691: while (hpaddr->hpds & HPDS_PIP)
692: ;
693: mbclrattn(mi);
694: }
695: if (!ML11) {
696: hpaddr->hpof = HPOF_FMT22;
697: hpaddr->hpcs1 = HP_RELEASE|HP_GO;
698: }
699: return (MBD_DONE);
700: }
701:
702: hpread(dev, uio)
703: dev_t dev;
704: struct uio *uio;
705: {
706: register int unit = minor(dev) >> 3;
707:
708: if (unit >= NHP)
709: return (ENXIO);
710: return (physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys, uio));
711: }
712:
713: hpwrite(dev, uio)
714: dev_t dev;
715: struct uio *uio;
716: {
717: register int unit = minor(dev) >> 3;
718:
719: if (unit >= NHP)
720: return (ENXIO);
721: return (physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys, uio));
722: }
723:
724: /*ARGSUSED*/
725: hpioctl(dev, cmd, data, flag)
726: dev_t dev;
727: int cmd;
728: caddr_t data;
729: int flag;
730: {
731:
732: switch (cmd) {
733:
734: case DKIOCHDR: /* do header read/write */
735: hpsoftc[minor(dev) >> 3].sc_hdr = 1;
736: return (0);
737:
738: default:
739: return (ENXIO);
740: }
741: }
742:
743: hpecc(mi, flag)
744: register struct mba_device *mi;
745: int flag;
746: {
747: register struct mba_regs *mbp = mi->mi_mba;
748: register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv;
749: register struct buf *bp = mi->mi_tab.b_actf;
750: register struct hpst *st = &hpst[mi->mi_type];
751: int npf, o;
752: int bn, cn, tn, sn;
753: int bcr;
754:
755: bcr = MASKREG(mbp->mba_bcr);
756: if (bcr)
757: bcr |= 0xffff0000; /* sxt */
758: if (flag == CONT)
759: npf = bp->b_error;
760: else
761: npf = btop(bcr + bp->b_bcount);
762: o = (int)bp->b_un.b_addr & PGOFSET;
763: bn = dkblock(bp);
764: cn = bp->b_cylin;
765: sn = bn%(st->nspc) + npf;
766: tn = sn/st->nsect;
767: sn %= st->nsect;
768: cn += tn/st->ntrak;
769: tn %= st->ntrak;
770: switch (flag) {
771: case ECC: {
772: register int i;
773: caddr_t addr;
774: struct pte mpte;
775: int bit, byte, mask;
776:
777: npf--; /* because block in error is previous block */
778: printf("hp%d%c: soft ecc sn%d\n", dkunit(bp),
779: 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
780: mask = MASKREG(rp->hpec2);
781: i = MASKREG(rp->hpec1) - 1; /* -1 makes 0 origin */
782: bit = i&07;
783: i = (i&~07)>>3;
784: byte = i + o;
785: while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
786: mpte = mbp->mba_map[npf+btop(byte)];
787: addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET);
788: putmemc(addr, getmemc(addr)^(mask<<bit));
789: byte++;
790: i++;
791: bit -= 8;
792: }
793: if (bcr == 0)
794: return (0);
795: npf++;
796: break;
797: }
798:
799: case SSE:
800: rp->hpof |= HPOF_SSEI;
801: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf));
802: break;
803:
804: case BSE:
805: #ifdef HPBDEBUG
806: if (hpbdebug)
807: printf("hpecc, BSE: bn %d cn %d tn %d sn %d\n", bn, cn, tn, sn);
808: #endif
809: if (rp->hpof&HPOF_SSEI)
810: sn++;
811: if ((bn = isbad(&hpbad[mi->mi_unit], cn, tn, sn)) < 0)
812: return (0);
813: bp->b_flags |= B_BAD;
814: bp->b_error = npf + 1;
815: bn = st->ncyl*st->nspc - st->nsect - 1 - bn;
816: cn = bn/st->nspc;
817: sn = bn%st->nspc;
818: tn = sn/st->nsect;
819: sn %= st->nsect;
820: mbp->mba_bcr = -512;
821: rp->hpof &= ~HPOF_SSEI;
822: #ifdef HPBDEBUG
823: if (hpbdebug)
824: printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
825: #endif
826: break;
827:
828: case CONT:
829: #ifdef HPBDEBUG
830: if (hpbdebug)
831: printf("hpecc, CONT: bn %d cn %d tn %d sn %d\n", bn,cn,tn,sn);
832: #endif
833: npf = bp->b_error;
834: bp->b_flags &= ~B_BAD;
835: mbp->mba_bcr = -(bp->b_bcount - (int)ptob(npf));
836: if (MASKREG(mbp->mba_bcr) == 0)
837: return (0);
838: break;
839: }
840: rp->hpcs1 = HP_DCLR|HP_GO;
841: if (rp->hpof&HPOF_SSEI)
842: sn++;
843: rp->hpdc = cn;
844: rp->hpda = (tn<<8) + sn;
845: mbp->mba_sr = -1;
846: mbp->mba_var = (int)ptob(npf) + o;
847: rp->hpcs1 = bp->b_flags&B_READ ? HP_RCOM|HP_GO : HP_WCOM|HP_GO;
848: mi->mi_tab.b_errcnt = 0; /* error has been corrected */
849: return (1);
850: }
851:
852: #define DBSIZE 20
853:
854: hpdump(dev)
855: dev_t dev;
856: {
857: register struct mba_device *mi;
858: register struct mba_regs *mba;
859: struct hpdevice *hpaddr;
860: char *start;
861: int num, unit;
862: register struct hpst *st;
863:
864: num = maxfree;
865: start = 0;
866: unit = minor(dev) >> 3;
867: if (unit >= NHP)
868: return (ENXIO);
869: #define phys(a,b) ((b)((int)(a)&0x7fffffff))
870: mi = phys(hpinfo[unit],struct mba_device *);
871: if (mi == 0 || mi->mi_alive == 0)
872: return (ENXIO);
873: mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
874: mba->mba_cr = MBCR_INIT;
875: hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive];
876: if ((hpaddr->hpds & HPDS_VV) == 0) {
877: hpaddr->hpcs1 = HP_DCLR|HP_GO;
878: hpaddr->hpcs1 = HP_PRESET|HP_GO;
879: hpaddr->hpof = HPOF_FMT22;
880: }
881: st = &hpst[mi->mi_type];
882: if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks)
883: return (EINVAL);
884: while (num > 0) {
885: register struct pte *hpte = mba->mba_map;
886: register int i;
887: int blk, cn, sn, tn;
888: daddr_t bn;
889:
890: blk = num > DBSIZE ? DBSIZE : num;
891: bn = dumplo + btop(start);
892: cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff;
893: sn = bn%st->nspc;
894: tn = sn/st->nsect;
895: sn = sn%st->nsect;
896: hpaddr->hpdc = cn;
897: hpaddr->hpda = (tn << 8) + sn;
898: for (i = 0; i < blk; i++)
899: *(int *)hpte++ = (btop(start)+i) | PG_V;
900: mba->mba_sr = -1;
901: mba->mba_bcr = -(blk*NBPG);
902: mba->mba_var = 0;
903: hpaddr->hpcs1 = HP_WCOM | HP_GO;
904: while ((hpaddr->hpds & HPDS_DRY) == 0)
905: ;
906: if (hpaddr->hpds&HPDS_ERR)
907: return (EIO);
908: start += blk*NBPG;
909: num -= blk;
910: }
911: return (0);
912: }
913:
914: hpsize(dev)
915: dev_t dev;
916: {
917: int unit = minor(dev) >> 3;
918: struct mba_device *mi;
919: struct hpst *st;
920:
921: if (unit >= NHP || (mi = hpinfo[unit]) == 0 || mi->mi_alive == 0)
922: return (-1);
923: st = &hpst[mi->mi_type];
924: return ((int)st->sizes[minor(dev) & 07].nblocks);
925: }
926: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.