![[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] / researchv10dc / lsys / io|
Return to hp.c CVS log | Up to [Research Unix] / researchv10dc / lsys / io |
1.1 root 1: /*
2: * MASSBUS SMD disk driver
3: */
4:
5: #include "sys/param.h"
6: #include "sys/buf.h"
7: #include "sys/conf.h"
8: #include "sys/dir.h"
9: #include "sys/user.h"
10: #include "sys/hp.h"
11: #include "sys/mbaddr.h"
12: #include "sys/mbsts.h"
13: #include "sys/bad144.h"
14:
15: /*
16: * hardware registers
17: */
18:
19: struct hpdevice {
20: int hpcs1; /* control and status register 1 */
21: int hpds; /* drive status */
22: int hper1; /* error register 1 */
23: int hpmr; /* maintenance */
24: int hpas; /* attention summary */
25: int hpda; /* desired address register */
26: int hpdt; /* drive type */
27: int hpla; /* look ahead */
28: int hpsn; /* serial number */
29: int hpof; /* offset register */
30: int hpdc; /* desired cylinder address register */
31: int hpcc; /* current cylinder */
32: /* on an rp drive, mr2 is called er2 and er2 is called er3 */
33: /* we use rm terminology here */
34: int hpmr2; /* maintenance register 2 */
35: int hper2; /* error register 2 */
36: int hpec1; /* burst error bit position */
37: int hpec2; /* burst error bit pattern */
38: };
39:
40: /*
41: * hpcs1
42: */
43:
44: #define HP_GO 0000001
45:
46: #define HP_SEEK 004 /* seek */
47: #define HP_RECAL 006 /* recalibrate */
48: #define HP_DCLR 010 /* drive clear */
49: #define HP_OFFSET 014 /* offset */
50: #define HP_RTC 016 /* return to center-line */
51: #define HP_PRESET 020 /* read-in preset */
52: #define HP_SEARCH 030 /* search */
53: #define HP_WCOM 060 /* write */
54: #define HP_RCOM 070 /* read data */
55:
56: /*
57: * hpds
58: */
59: #define HPDS_ERR 0040000 /* composite drive error */
60: #define HPDS_PIP 0020000 /* positioning in progress */
61: #define HPDS_MOL 0010000 /* medium on line */
62: #define HPDS_DPR 0000400 /* drive present */
63: #define HPDS_DRY 0000200 /* drive ready */
64: #define HPDS_VV 0000100 /* volume valid */
65: #define HPDS_DREADY (HPDS_DPR|HPDS_DRY|HPDS_MOL|HPDS_VV)
66:
67: /*
68: * hper1
69: */
70: #define HPER1_DCK 0100000 /* data check */
71: #define HPER1_WLE 0004000 /* write lock error */
72: #define HPER1_ECH 0000100 /* ecc hard error */
73: #define HPER1_FER 0000020 /* format error */
74:
75: /*
76: * hpdt
77: */
78: #define HPDT_TYPE 0x1ff
79: #define HPDT_RP05 021
80: #define HPDT_RP06 022
81: #define HPDT_RP07 042
82: #define HPDT_RM03 024
83: #define HPDT_RM05 027
84: #define HPDT_FUJI 025
85:
86: /*
87: * hpcc: emulex hack
88: */
89: #define HPHR_MAXCYL 0100027 /* max cyl address */
90: #define HPHR_MAXTRAK 0100030 /* max track address */
91: #define HPHR_MAXSECT 0100031 /* max sector address */
92:
93: /*
94: * hpof
95: */
96: #define HPOF_FMT22 0010000 /* 16 bit format */
97: #define HPOF_P400 0020 /* +400 uinches */
98: #define HPOF_M400 0220 /* -400 uinches */
99: #define HPOF_P800 0040 /* +800 uinches */
100: #define HPOF_M800 0240 /* -800 uinches */
101: #define HPOF_P1200 0060 /* +1200 uinches */
102: #define HPOF_M1200 0260 /* -1200 uinches */
103:
104: /*
105: * hper2
106: */
107: #define HPER2_BSE 0100000 /* bad sector */
108:
109: #define SECTOR 512 /* size of a hardware sector */
110:
111: /*
112: * monstrous size tables
113: * one per type of drive
114: */
115: struct size
116: {
117: daddr_t nblocks;
118: int cyloff;
119: };
120: struct size hp6_sizes[8] = {
121: 15884, 0, /* A=cyl 0 thru 37 */
122: 33440, 38, /* B=cyl 38 thru 117 */
123: 340670, 0, /* C=cyl 0 thru 814 */
124: 0, 0,
125: 0, 0,
126: 0, 0,
127: #ifndef NOBADSECT
128: 291280, 118, /* G=cyl 118 thru 814 */
129: #else
130: 291346, 118,
131: #endif
132: 0, 0,
133: };
134: struct size rm3_sizes[8] = {
135: 15884, 0, /* A=cyl 0 thru 99 */
136: 33440, 100, /* B=cyl 100 thru 309 */
137: 131680, 0, /* C=cyl 0 thru 822 */
138: 0, 0,
139: 0, 0,
140: 0, 0,
141: #ifndef NOBADSECT
142: 81984, 310, /* G=cyl 310 thru 822 */
143: #else
144: 82080, 310,
145: #endif
146: 113280, 115, /* H=cyl 115 thru 708 -- ex 32v */
147: };
148: struct size rm5_sizes[8] = {
149: 15884, 0, /* A=cyl 0 thru 26 */
150: 33440, 27, /* B=cyl 27 thru 81 */
151: 500384, 0, /* C=cyl 0 thru 822 */
152: 15884, 562, /* D=cyl 562 thru 588 */
153: 55936, 589, /* E=cyl 589 thru 680 */
154: #ifndef NOBADSECT
155: 86240, 681, /* F=cyl 681 thru 822 */
156: 158592, 562, /* G=cyl 562 thru 822 */
157: #else
158: 86636, 681,
159: 158688, 562,
160: #endif
161: 291346, 82, /* H=cyl 82 thru 561 */
162: };
163: struct size mfj_sizes[8] = {
164: 10240, 0, /* A=cyl 0 thru 31 */
165: 20480, 32, /* B=cyl 32 thru 95 */
166: 232640, 96, /* C=cyl 96 thru 822 */
167: 0, 0,
168: 0, 0,
169: 0, 0,
170: 0, 0,
171: 0, 0,
172: };
173: struct size eagle_sizes[8] ={
174: 27520, 0, /* A=cyl 0 thru 31 */
175: 27520, 32, /* B=cyl 32 thru 63 */
176: 667360, 64, /* C=cyl 64 thru 839 */
177: 232640, 64, /* D=cyl 64 thru 340 (partial) */
178: 232640, 341, /* E=cyl 341 thru 617 (partial) */
179: 0, 0,
180: 0, 0,
181: 0, 0,
182: };
183: /* 48 sector Emulex Eagle */
184: struct size eag48_sizes[8] = { /* cyl 841 used for bad sectors + info */
185: #ifndef OLDPART
186: 11*960, 0, /* A = cyl 0 thru 10 for / */
187: 22*960, 11, /* B = cyl 11 thru 32 for swap */
188: 842*960, 0, /* C = all cyl 0 thru 841 for testing */
189: 16*960, 33, /* D = cyl 33 thru 48 for /usr/guest */
190: 66*960, 49, /* E = cyl 49 thru 114 for /usr/src */
191: 242*960,115, /* F = cyl 115 thru 356 nearly 1/3 */
192: 242*960,357, /* G = cyl 357 thru 598 nearly 1/3 */
193: 242*960,599, /* H = cyl 599 thru 840 nearly 1/3 */
194: #else /* old jones partitions */
195: 45*960, 0, /* A = cyl 0 thru 44 for /tmp */
196: 64*960, 45, /* B = cyl 45 thru 108 for swap */
197: 842*960, 0, /* C = all cyl 0 thru 841 for testing */
198: 244*960,109, /* D = cyl 109 thru 352 nearly 1/3 */
199: 244*960,353, /* E = cyl 353 thru 596 nearly 1/3 */
200: 244*960,597, /* F = cyl 597 thru 840 nearly 1/3 */
201: 0, 0, /* G = cyl 0 thru 402 nearly 1/2 */
202: 0, 0, /* H = cyl 438 thru 840 nearly 1/2 */
203: #endif
204: };
205: struct size hp7_sizes[8] = {
206: 15884, 0, /* A=cyl 0 thru 9 */
207: 64000, 10, /* B=cyl 10 thru 49 */
208: 1008000,0, /* C=cyl 0 thru 629 */
209: 504000, 0, /* D=cyl 0 thru 314 */
210: 504000, 315, /* E=cyl 315 thru 629 */
211: 928000, 50, /* F=cyl 50 thru 629 */
212: 0, 0,
213: 0, 0,
214: };
215:
216: /*
217: * tables of per-drive info, mostly sizes of things
218: * indexed by numbers in hptypes
219: */
220:
221: struct hptype hptype[] = {
222: HPDT_RM03, 32, 5, 3, 4, 32*5, 823, rm3_sizes, /* RM03 */
223: HPDT_RM05, 32, 19, 2, 3, 32*19, 823, rm5_sizes, /* RM05 */
224: HPDT_RP06, 22, 19, 2, 3, 22*19, 815, hp6_sizes, /* RP06 */
225: HPDT_RP05, 22, 19, 2, 3, 22*19, 411, hp6_sizes, /* RP05 */
226: HPDT_RP07, 50, 32, 2, 3, 50*32, 630, hp7_sizes, /* RP07 */
227: /* HPDT_FUJI (emulex) entries must be contiguous and last */
228: HPDT_FUJI, 32, 10, 2, 3, 32*10, 823, mfj_sizes, /* little fujitsu */
229: HPDT_FUJI, 43, 20, 8, 9, 43*20, 842, eagle_sizes, /* eagle */
230: HPDT_FUJI, 48, 20, 8, 9, 48*20, 842, eag48_sizes, /* eagle 48 sectors */
231: 0
232: };
233:
234: #define NOFFS 16
235: unsigned char hp_offset[NOFFS] = {
236: HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
237: HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
238: HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
239: 0, 0, 0, 0
240: };
241:
242: /*
243: * things from config
244: */
245: extern int hpcnt;
246: extern struct mbaddr hpaddr[];
247: extern struct hpdisk hpdisk[];
248: extern struct buf hpbuf[];
249: extern struct buf hpbadbuf[];
250: extern struct bad144 hpbad[];
251:
252: /*
253: * unit flags, hpdisk.flags
254: */
255:
256: #define UACTIVE 01 /* started seek */
257: #define UXFER 02 /* done with any seeking; ready to transfer */
258: #define UWOL 04 /* waiting for offline drive */
259: #define UWAITOL 010 /* waiting and timer has ticked */
260: #define UHAVBAD 020 /* have read bad block table */
261: #define UREVEC 040 /* halfway through reading revectored sector */
262:
263: /*
264: * device number
265: */
266:
267: #define UNIT(d) ((minor(d)>>3) & 07)
268: #define PART(d) (minor(d) & 07)
269:
270: /*
271: * abuse of spare bits of struct buf
272: */
273: #define b_cylin b_resid /* for disksort */
274:
275: int hpwstart;
276: int hpwatch();
277: int hpwaitdry;
278:
279: int hpopen(), hpstrategy(), hpread(), hpwrite();
280: struct cdevsw hpcdev = cdinit(hpopen, nulldev, hpread, hpwrite, nodev);
281: struct bdevsw hpbdev = bdinit(hpopen, nulldev, hpstrategy, 0);
282:
283: hpopen(dev, flag)
284: int dev, flag;
285: {
286: if (hpuinit(UNIT(dev)) == 0)
287: u.u_error = ENXIO;
288: }
289:
290: static char hponce;
291:
292: hpuinit(unit)
293: register int unit;
294: {
295: register struct hpdevice *reg;
296: register struct hpdisk *hp;
297:
298: if (unit < 0 || unit > hpcnt)
299: return (0);
300: hp = &hpdisk[unit];
301: if (hp->addr)
302: return (1);
303: if ((reg = (struct hpdevice *)mbaddr(&hpaddr[unit])) == NULL
304: || badaddr(®->hpcs1, sizeof(long))
305: || (reg->hpds & HPDS_DPR) == 0) {
306: printf("hp%d absent\n", unit);
307: return (0);
308: }
309: if ((hp->type = hputype(reg)) < 0) {
310: printf("hp%d absent or bad type\n", unit);
311: return (0);
312: }
313: hp->addr = reg;
314: if (hponce == 0) {
315: hponce++;
316: hpwatch();
317: }
318: return (1);
319: }
320:
321: /*
322: * determine drive type
323: * this is called by hpdump too;
324: * be prepared to run without memory management
325: * return is an index into hpst
326: */
327: int
328: hputype(reg)
329: register struct hpdevice *reg;
330: {
331: register int t, i;
332: register int nsect, ntrak;
333:
334: t = reg->hpdt & HPDT_TYPE;
335: for (i = 0; hptype[i].type; i++)
336: if (hptype[i].type == t)
337: break;
338: if (hptype[i].type == 0) {
339: printf("hp type 0%o unknown\n", t);
340: return (-1);
341: }
342: if (hptype[i].type != HPDT_FUJI)
343: return (i);
344: /*
345: * special hackery for emulex
346: */
347: reg->hpcc = HPHR_MAXTRAK;
348: DELAY(2); /* hack */
349: ntrak = reg->hpcc + 1;
350: ntrak &= 0xffff;
351: reg->hpcc = HPHR_MAXSECT;
352: DELAY(2); /* hack */
353: nsect = reg->hpcc + 1;
354: nsect &= 0xffff;
355: for (; hptype[i].type; i++)
356: if (ntrak == hptype[i].ntrak && nsect == hptype[i].nsect)
357: return (i);
358: /*
359: * 48-sector eagle known to be last,
360: * so the following broken-hardware test might work
361: */
362: if (nsect == 46) {
363: printf("hp said ntrak %d nsect %d, eag48 assumed\n", ntrak, nsect);
364: return (i - 1);
365: }
366: printf("hp fuji ntrak %d nsect %d unknown\n", ntrak, nsect);
367: return (-1);
368: }
369:
370: /*
371: * a subtlety:
372: * b_cylin = cylinder number;
373: * later, when computing disk address,
374: * we use b_cylin, and take b_blkno % cylindersize
375: * i.e. there's an embedded assumption that every disk partition
376: * begins on a cylinder boundary
377: */
378: hpstrategy(bp)
379: register struct buf *bp;
380: {
381: register struct hpdisk *hp;
382: register struct hptype *st;
383: register int unit;
384: register int part;
385: long sz;
386: int s;
387:
388: sz = (bp->b_bcount+SECTOR-1)/SECTOR;
389: unit = UNIT(bp->b_dev);
390: hp = &hpdisk[unit];
391: if (hp->addr == NULL) { /* safety check */
392: bp->b_flags |= B_ERROR;
393: iodone(bp);
394: return;
395: }
396: st = &hptype[hp->type];
397: part = PART(bp->b_dev);
398: if (bp->b_blkno < 0 || bp->b_blkno+sz > st->sizes[part].nblocks) {
399: if (bp->b_blkno == st->sizes[part].nblocks)
400: bp->b_resid = bp->b_bcount;
401: else { /* partial read too hard for now */
402: bp->b_error = ENXIO;
403: bp->b_flags |= B_ERROR;
404: }
405: iodone(bp);
406: return;
407: }
408: bp->b_cylin = bp->b_blkno/st->nspc + st->sizes[part].cyloff;
409: s = spl6();
410: disksort(&hp->actf, &hp->actl, bp);
411: if ((hp->flags & UACTIVE) == 0)
412: hpustart(hp);
413: splx(s);
414: }
415:
416: /*
417: * unit start:
418: * if there's a block for this drive, start seeking there
419: */
420: int hpxfer();
421:
422: hpustart(hp)
423: register struct hpdisk *hp;
424: {
425: register struct buf *bp;
426: register struct hpdevice *reg;
427: register struct hptype *st;
428: int sn, csn;
429:
430: if ((bp = hp->actf) == NULL)
431: return;
432: reg = hp->addr;
433: if ((reg->hpds & HPDS_VV) == 0) {
434: reg->hpcs1 = HP_DCLR|HP_GO;
435: reg->hpcs1 = HP_PRESET|HP_GO;
436: reg->hpof = HPOF_FMT22;
437: hp->flags &=~ UHAVBAD;
438: }
439: if ((hp->flags & UHAVBAD) == 0) {
440: hprbad(hp);
441: bp = hp->actf;
442: hp->flags |= UHAVBAD;
443: }
444: if ((reg->hpds & (HPDS_DPR|HPDS_MOL)) != (HPDS_DPR|HPDS_MOL)) {
445: hp->flags |= UWOL;
446: return;
447: }
448: if ((hp->flags & UACTIVE) == 0) { /* start seek if didn't already */
449: hp->flags |= UACTIVE;
450: st = &hptype[hp->type];
451: sn = bp->b_blkno%st->nsect - st->sdist; /* seek here before io */
452: if (sn < 0)
453: sn += st->nsect;
454: csn = sn - (reg->hpla>>6);
455: if (csn < 0)
456: csn += st->nsect;
457: if (bp->b_cylin != reg->hpdc /* seek if off cylinder */
458: || csn > st->rdist) { /* or not close enough */
459: reg->hpdc = bp->b_cylin;
460: reg->hpda = sn;
461: reg->hpcs1 = HP_SEARCH|HP_GO;
462: return;
463: }
464: }
465: if ((hp->flags & UXFER) == 0) { /* seek done, time for transfer */
466: hp->flags |= UXFER;
467: mbstart(&hpaddr[UNIT(bp->b_dev)], bp, hpxfer);
468: }
469: }
470:
471: /*
472: * start transfer
473: */
474: hpxfer(bp)
475: register struct buf *bp;
476: {
477: register struct hpdisk *hp;
478: register struct hpdevice *reg;
479: register struct hptype *st;
480: int sn, tn;
481:
482: hp = &hpdisk[UNIT(bp->b_dev)];
483: st = &hptype[hp->type];
484: sn = bp->b_blkno%st->nspc;
485: tn = sn/st->nsect;
486: sn %= st->nsect;
487: reg = hp->addr;
488: if ((reg->hpds & HPDS_DREADY) != HPDS_DREADY) {
489: printf("hp%d: not ready\n", UNIT(bp->b_dev));
490: hp->errcnt = 0;
491: hp->actf = bp->av_forw;
492: hp->flags &=~ (UACTIVE|UXFER);
493: bp->b_flags |= B_ERROR;
494: iodone(bp);
495: return;
496: }
497: reg->hpdc = bp->b_cylin;
498: reg->hpda = (tn << 8) + sn;
499: if (bp->b_flags & B_READ)
500: reg->hpcs1 = HP_RCOM|HP_GO;
501: else
502: reg->hpcs1 = HP_WCOM|HP_GO;
503: }
504:
505: /*
506: * interrupt, passed from MBA code
507: */
508: hp0int(unit, mbsr, mbbc, attn)
509: int unit, mbsr, mbbc, attn;
510: {
511: register struct hpdisk *hp;
512:
513: hp = &hpdisk[unit];
514: if (hp->addr == 0) {
515: if (hpuinit(unit) == 0) {
516: printf("hp%d: hopeless interrupt\n", unit);
517: return; /* but ATTN wasn't cleared; will recur */
518: }
519: /* init ok, so addr nonzero, so can clear it */
520: }
521: hp->addr->hpas = attn;
522: if (hp->flags & UXFER)
523: hpxdone(hp, mbsr, mbbc);
524: if ((hp->flags & UXFER) == 0)
525: hpustart(hp);
526: }
527:
528: /*
529: * transfer stopped:
530: * because it's done, or because of an error
531: * common convention in error-sniffing routines:
532: * return 1 if the error was recovered
533: * and the device has been restarted
534: * return 0 if this transfer has been abandoned
535: * leave flags & UXFER set if we're all done;
536: * clear UXFER if the transfer should be retried
537: */
538:
539: #define ERRCMIN 16 /* after this many errors, try offsets */
540: #define ERRCAL(e) (((e)%8)==4) /* try recal this often */
541: #define ERRMAX 28 /* after this many errors, give up on transfer */
542:
543: hpxdone(hp, mbsr, mbbc)
544: register struct hpdisk *hp;
545: int mbsr, mbbc;
546: {
547: register struct hpdevice *reg;
548: register struct buf *bp;
549:
550: reg = hp->addr;
551: bp = hp->actf;
552: if ((reg->hpds&HPDS_ERR) || (mbsr&MBSR_EBITS)) {
553: if (hpwhaterr(hp, mbsr, mbbc))
554: return;
555: reg->hpcs1 = HP_DCLR|HP_GO;
556: }
557: if (hp->recal && hpmorecal(hp))
558: return;
559: if (hp->flags & UREVEC && hpbadcont(hp))
560: return;
561: if (hp->flags & UXFER) { /* `active' means we're done */
562: if (hp->errcnt >= ERRCMIN) {
563: reg->hpof = HPOF_FMT22;
564: reg->hpcs1 = HP_RTC|HP_GO;
565: while (reg->hpds & HPDS_PIP)
566: DELAY(25);
567: }
568: hp->errcnt = 0;
569: hp->flags &=~ (UACTIVE|UXFER);
570: hp->actf = bp->av_forw;
571: bp->b_resid = mbbc;
572: iodone(bp);
573: }
574: }
575:
576: /*
577: * sort out errors
578: */
579:
580: hpwhaterr(hp, mbsr, mbbc)
581: register struct hpdisk *hp;
582: int mbsr, mbbc;
583: {
584: register struct hpdevice *reg;
585: register struct buf *bp;
586: register int i;
587:
588: reg = hp->addr;
589: bp = hp->actf;
590: /*
591: * let registers settle
592: */
593: i = 0;
594: while ((reg->hpds & HPDS_DRY) == 0) {
595: if (++i > 512)
596: break;
597: hpwaitdry++;
598: }
599: if (reg->hper1 & HPER1_WLE) {
600: printf("hp%d: write locked\n", UNIT(bp->b_dev));
601: bp->b_flags |= B_ERROR;
602: return (0); /* finished */
603: }
604: if ((reg->hper2 & HPER2_BSE || reg->hper1 & HPER1_FER)
605: && hpbadrep(hp, mbbc))
606: return (1); /* restarted, reading replacement */
607: if (++hp->errcnt > ERRMAX) {
608: harderr(bp, "hp");
609: printf("mbsr %o er1 %o er2 %o\n",
610: mbsr, reg->hper1&0177777, reg->hper2&0177777);
611: bp->b_flags |= B_ERROR;
612: return (0); /* finished */
613: }
614: if (bp->b_flags & B_READ
615: && (reg->hper1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK)
616: return (hpecc(hp, mbbc)); /* restart or finish */
617: /*
618: * hard error: clear and try again,
619: * perhaps with recal
620: */
621: if (ERRCAL(hp->errcnt)) {
622: hpstrecal(hp);
623: return (1); /* restarted */
624: }
625: hp->flags &=~ UXFER;
626: return (0); /* please restart me */
627: }
628:
629: /*
630: * recalibration state machine
631: * walks through the sequence
632: * RECAL
633: * SEEK back to the cylinder we wanted
634: * perhaps offset the heads slightly
635: * and try the operation again
636: */
637:
638: hpstrecal(hp)
639: register struct hpdisk *hp;
640: {
641:
642: hp->addr->hpcs1 = HP_DCLR|HP_GO;
643: hp->addr->hpcs1 = HP_RECAL|HP_GO;
644: hp->recal = 1;
645: }
646:
647: hpmorecal(hp)
648: register struct hpdisk *hp;
649: {
650: register struct hpdevice *reg;
651:
652: reg = hp->addr;
653: switch (hp->recal) {
654: case 1: /* did RECAL, time to seek */
655: reg->hpdc = hp->actf->b_cylin;
656: reg->hpcs1 = HP_SEEK|HP_GO;
657: hp->recal++;
658: return (1);
659:
660: case 2: /* did seek, time for offset */
661: if (hp->errcnt > ERRCMIN && hp->actf->b_flags & B_READ) {
662: reg->hpof = hp_offset[hp->errcnt%NOFFS]|HPOF_FMT22;
663: reg->hpcs1 = HP_OFFSET|HP_GO;
664: hp->recal++;
665: return (1);
666: }
667: /* too soon or a write, fall through */
668: default: /* time to restart the transfer */
669: hp->recal = 0;
670: hp->flags &=~ UXFER;
671: return (0);
672: }
673: }
674:
675: /*
676: * read the bad144 bad block table:
677: * call on first access to drive,
678: * or when VV was down
679: */
680:
681: hprbad(hp)
682: register struct hpdisk *hp;
683: {
684: register struct buf *xbp, *bp;
685: register struct hptype *st;
686:
687: st = &hptype[hp->type];
688: xbp = hp->actf;
689: bp = &hpbadbuf[UNIT(xbp->b_dev)];
690: if (xbp == bp)
691: return; /* cheap reentry protection */
692: bp->b_flags = B_BUSY|B_READ;
693: bp->b_dev = xbp->b_dev;
694: bp->b_un.b_addr = (caddr_t)&hpbad[UNIT(xbp->b_dev)];
695: bp->b_bcount = sizeof(struct bad144);
696: bp->b_resid = 0;
697: bp->b_blkno = st->ncyl * st->nspc - st->nsect; /* fake-ish */
698: bp->b_cylin = st->ncyl - 1;
699: bp->av_forw = xbp;
700: hp->actf = bp;
701: bzero(bp->b_un.b_addr, sizeof(struct bad144));
702: }
703:
704: /*
705: * here when a bad block is detected:
706: * find the replacement block, and restart transfer for it
707: */
708: hpbadrep(hp, mbbc)
709: register struct hpdisk *hp;
710: int mbbc;
711: {
712: register daddr_t bno;
713: register struct hptype *st;
714: struct buf *bp;
715: register int i;
716:
717: if (hp->flags & UREVEC)
718: return (0);
719: st = &hptype[hp->type];
720: bp = hp->actf;
721: hp->badsec = (bp->b_bcount - mbbc) / SECTOR;
722: bno = bp->b_cylin * st->nspc + bp->b_blkno % st->nspc; /* true lbn */
723: bno += hp->badsec;
724: i = bno / st->nspc;
725: bno %= st->nspc;
726: i = bad144rep(&hpbad[UNIT(bp->b_dev)], i, (int)bno/st->nsect, (int)bno%st->nsect);
727: if (i < 0)
728: return (0);
729: bno = st->ncyl*st->nspc - st->nsect - 1 - i;
730: hp->addr->hpcs1 = HP_DCLR|HP_GO;
731: if (mbbc > SECTOR)
732: mbbc = SECTOR;
733: hpcontin(hp, bno, hp->badsec*SECTOR, mbbc);
734: hp->flags |= UREVEC;
735: return (1);
736: }
737:
738: /*
739: * here after replacing the bad block:
740: * now do the rest of the original transfer
741: */
742: hpbadcont(hp)
743: register struct hpdisk *hp;
744: {
745: register struct buf *bp;
746: int next, resid;
747: daddr_t bno;
748: int nspc;
749:
750: hp->flags &=~ UREVEC;
751: bp = hp->actf;
752: next = (hp->badsec + 1) * SECTOR;
753: resid = bp->b_bcount - next;
754: if (resid <= 0)
755: return (0);
756: nspc = hptype[hp->type].nspc;
757: bno = bp->b_cylin*nspc + bp->b_blkno%nspc;
758: bno += hp->badsec + 1;
759: hpcontin(hp, bno, next, resid);
760: return (1);
761: }
762:
763: /*
764: * correct an ECC error and restart the transfer
765: * the error is (hpec1-1) bits into the current sector;
766: * at that point, the bits set in hpec2 are wrong.
767: */
768: hpecc(hp, bc)
769: register struct hpdisk *hp;
770: int bc;
771: {
772: register struct hpdevice *reg;
773: register struct buf *bp;
774: register int i;
775: int nxf;
776: unsigned int mask;
777: long a, lasta;
778: struct mbaddr *ap;
779: register daddr_t bno;
780: register struct hptype *st;
781:
782: if ((bp = hp->actf) == NULL)
783: panic("hpecc");
784: reg = hp->addr;
785: ap = &hpaddr[UNIT(bp->b_dev)];
786: lasta = mbcuraddr(ap);
787: nxf = bp->b_bcount - bc;
788: i = reg->hpec1 - 1; /* -1 makes 0 origin */
789: a = lasta - (nxf > SECTOR ? SECTOR : nxf) + ((i&~07)>>3);
790: mask = reg->hpec2;
791: mask <<= i&07;
792: for (; a < lasta && mask; mask >>= 8, a++)
793: mbputc(ap, a, mbgetc(ap, a)^mask);
794: st = &hptype[hp->type];
795: bno = bp->b_cylin*st->nspc + bp->b_blkno%st->nspc + nxf/SECTOR;
796: printf("hp%d: soft ecc sec %ld\n", UNIT(bp->b_dev), bno - 1);
797: if (bc == 0)
798: return (0);
799: reg->hpcs1 = HP_DCLR|HP_GO;
800: hpcontin(hp, bno, bp->b_bcount - bc, bc);
801: return (1);
802: }
803:
804: /*
805: * continue the current transfer,
806: * which was interrupted:
807: * move size bytes to or from the current buffer at offset off,
808: * starting with disk sector bno
809: * used for bad sector replacement,
810: * and to continue after bad sectors or ECC correction
811: */
812: hpcontin(hp, bno, off, size)
813: register struct hpdisk *hp;
814: daddr_t bno;
815: int off, size;
816: {
817: register struct hpdevice *reg;
818: struct mbaddr *ap;
819: register struct buf *bp;
820: register struct hptype *st;
821:
822: reg = hp->addr;
823: bp = hp->actf;
824: ap = &hpaddr[UNIT(bp->b_dev)];
825: st = &hptype[hp->type];
826: mbadj(ap, off, size);
827: reg->hpdc = bno / st->nspc;
828: bno %= st->nspc;
829: reg->hpda = ((bno/st->nsect)<<8) | (bno%st->nsect);
830: mbcontin(ap);
831: if (bp->b_flags & B_READ)
832: reg->hpcs1 = HP_RCOM|HP_GO;
833: else
834: reg->hpcs1 = HP_WCOM|HP_GO;
835: }
836:
837: hpread(dev)
838: dev_t dev;
839: {
840: physio(hpstrategy, &hpbuf[UNIT(dev)], dev, B_READ, minphys);
841: }
842:
843: hpwrite(dev)
844: dev_t dev;
845: {
846: physio(hpstrategy, &hpbuf[UNIT(dev)], dev, B_WRITE, minphys);
847: }
848:
849: /*
850: * check for offline drives and hung controllers
851: */
852:
853: hpwatch()
854: {
855: register struct hpdisk *hp;
856: register struct hpdevice *reg;
857: register struct buf *bp;
858: register int s;
859:
860: s = spl6();
861: timeout(hpwatch, (caddr_t)0, 15*HZ);
862: for (hp = &hpdisk[hpcnt-1]; hp >= hpdisk; hp--) {
863: if ((hp->flags & UWOL) == 0 || (reg = hp->addr) == 0)
864: continue;
865: if ((reg->hpds & (HPDS_DPR|HPDS_MOL)) != (HPDS_DPR|HPDS_MOL)) {
866: if ((hp->flags & UWAITOL) == 0) {
867: hp->flags |= UWAITOL;
868: continue;
869: }
870: printf("hp%d offline\n", hp - hpdisk);
871: while ((bp = hp->actf) != NULL) {
872: bp->b_flags |= B_ERROR;
873: hp->actf = bp->av_forw;
874: iodone(bp);
875: }
876: }
877: hp->flags &=~ (UWAITOL|UWOL);
878: hpustart(hp);
879: }
880: splx(s);
881: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.