![[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 [Research Unix] / researchv10no / sys / io|
Return to up.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: /*
2: * UNIBUS SMD disk driver
3: *
4: * undone:
5: * Add bad sector forwarding code
6: * Check that offset recovery code works
7: * unibus mapping is suboptimal; if the queue gets long,
8: * buffered data paths will be underused
9: */
10:
11: #include "sys/param.h"
12: #include "sys/buf.h"
13: #include "sys/conf.h"
14: #include "sys/user.h"
15: #include "sys/up.h"
16: #include "sys/ubaddr.h"
17: #include "sys/subaddr.h"
18: #include "sys/diskio.h"
19: #include "sys/file.h"
20:
21: #define NOUPSEEK 1 /* because emulex doesn't do it right */
22:
23: /*
24: * hardware registers
25: */
26:
27: struct updevice
28: {
29: unsigned short upcs1; /* control and status register 1 */
30: short upwc; /* word count register */
31: unsigned short upba; /* UNIBUS address register */
32: unsigned short upda; /* desired address register */
33: unsigned short upcs2; /* control and status register 2 */
34: unsigned short upds; /* drive status */
35: unsigned short uper1; /* error register 1 */
36: unsigned short upas; /* attention summary */
37: unsigned short upla; /* look ahead */
38: unsigned short updb; /* data buffer */
39: unsigned short upmr; /* maintenance */
40: unsigned short updt; /* drive type */
41: unsigned short upsn; /* serial number */
42: unsigned short upof; /* offset register */
43: unsigned short updc; /* desired cylinder address register */
44: unsigned short uphr; /* holding register */
45: unsigned short upmr2; /* maintenance register 2 */
46: unsigned short uper2; /* error register 2 */
47: unsigned short upec1; /* burst error bit position */
48: unsigned short upec2; /* burst error bit pattern */
49: };
50:
51: /*
52: * upcs1
53: */
54:
55: #define UP_SC 0100000 /* special condition */
56: #define UP_TRE 0040000 /* transfer error */
57: #define UP_IE 0000100 /* interrupt enable */
58: #define UP_GO 0000001
59:
60: #define UP_SEEK 004 /* seek */
61: #define UP_RECAL 006 /* recalibrate */
62: #define UP_DCLR 010 /* drive clear */
63: #define UP_OFFSET 014 /* offset */
64: #define UP_RTC 016 /* return to center-line */
65: #define UP_PRESET 020 /* read-in preset */
66: #define UP_SEARCH 030 /* search */
67: #define UP_WCOM 060 /* write */
68: #define UP_RCOM 070 /* read data */
69:
70: /*
71: * upcs2
72: */
73: #define UPCS2_NED 0010000 /* nonexistent drive */
74: #define UPCS2_CLR 0000040 /* controller clear */
75: #define UPCS2_SEL 0000007 /* unit select */
76:
77: /*
78: * upds
79: */
80: #define UPDS_ERR 0040000 /* composite drive error */
81: #define UPDS_PIP 0020000 /* positioning in progress */
82: #define UPDS_MOL 0010000 /* medium on line */
83: #define UPDS_DPR 0000400 /* drive present */
84: #define UPDS_DRY 0000200 /* drive ready */
85: #define UPDS_VV 0000100 /* volume valid */
86: #define UPDS_DREADY (UPDS_DPR|UPDS_DRY|UPDS_MOL|UPDS_VV)
87:
88: /*
89: * uper1
90: */
91: #define UPER1_DCK 0100000 /* data check */
92: #define UPER1_WLE 0004000 /* write lock error */
93: #define UPER1_ECH 0000100 /* ecc hard error */
94:
95: /*
96: * uphr: emulex hack
97: */
98: #define UPHR_MAXCYL 0100027 /* max cyl address */
99: #define UPHR_MAXTRAK 0100030 /* max track address */
100: #define UPHR_MAXSECT 0100031 /* max sector address */
101:
102: /*
103: * upof
104: */
105: #define UPOF_FMT22 0010000 /* 16 bit format */
106: /* THE SC21 ACTUALLY JUST IMPLEMENTS ADVANCE/RETARD... */
107: #define UPOF_P400 0020 /* +400 uinches */
108: #define UPOF_M400 0220 /* -400 uinches */
109: #define UPOF_P800 0040 /* +800 uinches */
110: #define UPOF_M800 0240 /* -800 uinches */
111: #define UPOF_P1200 0060 /* +1200 uinches */
112: #define UPOF_M1200 0260 /* -1200 uinches */
113:
114: #define SECTOR 512 /* size of a hardware sector */
115:
116: /*
117: * monstrous size tables
118: * one per type of drive
119: */
120: struct size
121: {
122: daddr_t nblocks;
123: daddr_t blkoff;
124: } up_sizes[NUPPART] = {
125: 15884, 0*608, /* A=cyl 0 thru 26 */
126: 33440, 27*608, /* B=cyl 27 thru 81 */
127: 495520, 0*608, /* C=cyl 0 thru 814 */
128: 15884, 562*608, /* D=cyl 562 thru 588 */
129: 55936, 589*608, /* E=cyl 589 thru 680 */
130: #ifndef NOBADSECT
131: 81376, 681*608, /* F=cyl 681 thru 814 */
132: 153728, 562*608, /* G=cyl 562 thru 814 */
133: #else
134: 81472, 681*608,
135: 153824, 562*608,
136: #endif
137: 291346, 82*608, /* H=cyl 82 thru 561 */
138: }, fj_sizes[8] = {
139: 10240, 0*320, /* A=cyl 0 thru 31 */
140: 20480, 32*320, /* B=cyl 32 thru 95 */
141: 232640, 96*320, /* C=cyl 96 thru 822 */
142: 0, 0*320,
143: 0, 0*320,
144: 0, 0*320,
145: 0, 0*320,
146: #ifndef NOBADSECT
147: 0, 0*320, /* H=cyl 155 thru 822 */
148: #else
149: 0, 0*320,
150: #endif
151: }, fj3_sizes[8] = {
152: 10240, 0*512, /* A=cyl 0 thru 19 */
153: 20480, 20*512, /* B=cyl 20 thru 59 */
154: 246784, 60*512, /* C=cyl 60 thru 541 */
155: 246784, 542*512, /* D=cyl 542 thru 1024 */
156: 0, 0*512,
157: 0, 0*512,
158: 0, 0*512,
159: #ifndef NOBADSECT
160: 0, 0*512, /* H=cyl 155 thru 822 */
161: #else
162: 0, 0*512,
163: #endif
164: }, cd_sizes[8] = {
165: 10240, 0*160, /* A=cyl 0 thru 63 */
166: 20480, 64*160, /* B=cyl 64 thru 191 */
167: 100960, 192*160, /* C=cyl 192 thru 822 */
168: 0, 0*160,
169: 0, 0*160,
170: 0, 0*160,
171: 0, 0*160,
172: #ifndef NOBADSECT
173: 100960, 0*160, /* H=cyl 0 thru 630 */
174: #else
175: 100960, 0*160,
176: #endif
177: }, fj1_sizes[8] = {
178: 1024, 0*256, /* cyl 0 through 3 */
179: 0, 0*256,
180: 0, 0*256,
181: 0, 0*256,
182: 0, 0*256,
183: 0, 0*256,
184: 0, 0*256,
185: 0, 0*256,
186: };
187:
188: /*
189: * tables of per-drive info, mostly sizes of things
190: * indexed by magic numbers; see uputype
191: */
192: struct upst upst[] = {
193: 32, 19, 3, 4, 32*19, 823, up_sizes, /* 9300/cdc */
194: /* 9300 actually has 815 cylinders... */
195: 32, 10, 3, 4, 32*10, 823, fj_sizes, /* fujitsu 160m */
196: 32, 5, 3, 4, 32*5, 631, cd_sizes, /* CDC 76 MB */
197: 32, 8, 3, 4, 32*8, 4, fj1_sizes, /* Fixed part of FJ */
198: 32, 16, 3, 4, 32*16, 1024, fj3_sizes, /* fujitsu 330m */
199: };
200:
201: unsigned char up_offset[16] = {
202: UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400,
203: UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800,
204: UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200,
205: 0, 0, 0, 0
206: };
207:
208: /*
209: * things from config
210: */
211: extern int upcnt, sccnt;
212: extern struct ubaddr scaddr[];
213: extern struct subaddr upaddr[];
214: extern struct scctl scctl[];
215: extern struct updisk updisk[];
216: extern struct buf upbuf[];
217:
218: /*
219: * controller flags, scctl.flags
220: */
221:
222: #define CACTIVE 01 /* xfer in progress */
223: #define CWAITING 02 /* xfering and timer has ticked */
224:
225: /*
226: * unit flags, updisk.flags
227: */
228:
229: #define UACTIVE 01 /* working on this xfer */
230: #define URXFR 02 /* done with any seeking; ready to roll */
231: #define UWOL 04 /* waiting for offline drive */
232: #define UWAITOL 010 /* waiting and timer has ticked */
233:
234: /*
235: * device number
236: * 0100 in the minor device is (temporarily?)
237: * usurped to indicate bitmapped file systems
238: * quietly ignore it for now
239: * when things improve, change the UNIT mask to 037
240: */
241:
242: #define UNIT(d) ((minor(d)>>3) & 027)
243: #define PART(d) (minor(d) & 07)
244:
245: /*
246: * abuse of spare bits of struct buf
247: */
248: #define b_cylin b_resid /* for disksort */
249: #define b_ubm av_back /* this buffer's map */
250:
251: int upwstart, upwatch(); /* Have started guardian */
252: int upwaitdry;
253:
254: int upopen(), upstrategy(), upread(), upwrite(), upioctl();
255:
256: struct cdevsw upcdev = cdinit(upopen, nulldev, upread, upwrite, upioctl);
257:
258: struct bdevsw upbdev = bdinit(upopen, nulldev, upstrategy, 0);
259:
260: upopen(dev, flag)
261: int dev, flag;
262: {
263: register struct updisk *up;
264: register struct upst *st;
265: register int p;
266:
267: if (upuinit(UNIT(dev)) == 0) {
268: u.u_error = ENXIO;
269: return;
270: }
271: up = &updisk[UNIT(dev)];
272: st = &upst[up->type];
273: p = PART(dev);
274: if ((up->pinit & (1<<p)) == 0) {
275: up->nblocks[p] = st->sizes[p].nblocks;
276: up->blkoff[p] = st->sizes[p].blkoff;
277: if ((up->blkoff[p] % st->nspc) != 0) {
278: printf("up minor %d bad blkoff\n", minor(dev));
279: u.u_error = EINVAL;
280: return;
281: }
282: up->pinit |= (1<<p);
283: }
284: }
285:
286: upuinit(unit)
287: register int unit;
288: {
289: register struct updevice *reg;
290: register struct updisk *up;
291: register struct subaddr *ua;
292:
293: if (unit < 0 || unit > upcnt)
294: return (0);
295: ua = &upaddr[unit];
296: if (ua->ctl < 0)
297: return (0);
298: up = &updisk[unit];
299: if (up->ctl)
300: return (1);
301: if (upcinit(ua->ctl) == 0)
302: return (0);
303: reg = scctl[ua->ctl].addr;
304: if ((up->type = uputype(reg, ua->unit)) < 0) {
305: printf("up%d absent or bad type\n", unit);
306: return (0);
307: }
308: up->unit = ua->unit;
309: up->ctl = &scctl[ua->ctl];
310: up->ctl->drives[ua->unit] = up;
311: return (1);
312: }
313:
314:
315: /*
316: * determine drive type
317: * very emulex dependent; should look at drive type register too.
318: * perhaps there should be a way to change it?
319: * this is called by updump too;
320: * be prepared to run without memory management
321: * unit is the hardware unit
322: * return is an index into upst
323: */
324: int
325: uputype(reg, unit)
326: register struct updevice *reg;
327: int unit;
328: {
329:
330: reg->upcs1 = 0; /* conservative */
331: reg->upcs2 = unit;
332: if (reg->upcs2&UPCS2_NED) {
333: reg->upcs1 = UP_DCLR|UP_GO;
334: return (-1);
335: }
336: reg->uphr = UPHR_MAXTRAK;
337: switch (reg->uphr) {
338: default:
339: reg->upcs1 = UP_DCLR|UP_GO;
340: return (-1);
341: case 9:
342: return (unit >= 4 ? 3 : 1); /* fujitsu hack */
343: case 4:
344: return (2); /* CDC 76MB hack */
345: case 7:
346: return (3); /* Fixed Fujitsu hack */
347: case 15:
348: return (4); /* fuji 330m hack */
349: case 19:
350: return (0); /* CDC 300 MB hack */
351: }
352: }
353:
354: upcinit(ctl)
355: int ctl;
356: {
357: register struct scctl *sc;
358: register struct updevice *reg;
359:
360: if (ctl < 0 || ctl >= sccnt)
361: return (0);
362: sc = &scctl[ctl];
363: if (sc->addr)
364: return (1);
365: if ((reg = (struct updevice *)ubaddr(&scaddr[ctl])) == 0
366: || ubbadaddr(scaddr[ctl].ubno, ®->upcs1, sizeof(short))) {
367: printf("sc%d absent\n", ctl);
368: return (0);
369: }
370: reg->upcs2 = UPCS2_CLR;
371: sc->addr = reg;
372: sc->ubno = scaddr[ctl].ubno;
373: if (upwstart == 0) {
374: timeout(upwatch, (caddr_t)0, HZ);
375: upwstart++;
376: }
377: return (1);
378: }
379:
380: upstrategy(bp)
381: register struct buf *bp;
382: {
383: register struct updisk *up;
384: register struct upst *st;
385: register int unit;
386: register int part;
387: long sz;
388: int s;
389:
390: sz = (bp->b_bcount+SECTOR-1)/SECTOR;
391: unit = UNIT(bp->b_dev);
392: up = &updisk[unit];
393: if (up->ctl == 0) {
394: bp->b_flags |= B_ERROR;
395: iodone(bp);
396: return;
397: }
398: st = &upst[up->type];
399: part = PART(bp->b_dev);
400: if (bp->b_blkno < 0 || bp->b_blkno+sz > up->nblocks[part]) {
401: if (bp->b_blkno == up->nblocks[part])
402: bp->b_resid = bp->b_bcount;
403: else { /* partial read too hard for now */
404: bp->b_error = ENXIO;
405: bp->b_flags |= B_ERROR;
406: }
407: iodone(bp);
408: return;
409: }
410: bp->b_cylin = (bp->b_blkno + up->blkoff[part])/st->nspc;
411: bp->b_ubm = (struct buf *)ubmbuf(up->ctl->ubno, bp, USLP);
412: s = spl6();
413: disksort(&up->actf, &up->actl, bp);
414: if ((up->flags & UACTIVE) == 0) {
415: upustart(up);
416: if (up->ctl->actf && (up->ctl->flags & CACTIVE) == 0)
417: upstart(up->ctl);
418: }
419: splx(s);
420: }
421:
422: /*
423: * unit start:
424: * if there's a block for this drive, start seeking there
425: *
426: * up->upcs = UP_IE cancels a pending command in the SC21
427: * why not up->cs |= UP_IE?
428: */
429: upustart(up)
430: register struct updisk *up;
431: {
432: register struct buf *bp;
433: register struct updevice *reg;
434: register struct scctl *sc;
435: register struct upst *st;
436: int sn, csn;
437: int didie = 0;
438:
439: sc = up->ctl;
440: if ((bp = up->actf) == NULL)
441: return (0);
442: #ifndef NOUPSEEK
443: if (sc->flags & CACTIVE) { /* can't start seek till xfer done */
444: sc->softas |= 1<<up->unit;
445: return (0);
446: }
447: #endif
448: reg = sc->addr;
449: reg->upcs2 = up->unit;
450: if ((reg->upds & UPDS_VV) == 0) {
451: reg->upcs1 = UP_IE|UP_DCLR|UP_GO;
452: reg->upcs1 = UP_IE|UP_PRESET|UP_GO;
453: reg->upof = UPOF_FMT22;
454: didie = 1;
455: }
456: if ((reg->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) {
457: up->flags |= UWOL;
458: return (didie);
459: }
460: if ((up->flags & UACTIVE) == 0) { /* start seek if didn't already */
461: up->flags |= UACTIVE;
462: #ifndef NOUPSEEK
463: st = &upst[up->type];
464: sn = bp->b_blkno%st->nspc;
465: sn = (sn + st->nsect - st->sdist) % st->nsect; /* sector to seek to */
466: csn = sn - (reg->upla>>6);
467: if (csn < 0)
468: csn += st->nsect;
469: if (bp->b_cylin != reg->updc /* seek if off cylinder */
470: || csn > st->rdist) { /* or not close enough */
471: reg->updc = bp->b_cylin;
472: reg->upda = sn;
473: reg->upcs1 = UP_IE|UP_SEARCH|UP_GO;
474: return (1);
475: }
476: #endif
477: }
478: if ((up->flags & URXFR) == 0) { /* seek done, put on ctl queue */
479: up->next = NULL;
480: if (sc->actf == NULL)
481: sc->actf = up;
482: else
483: sc->actl->next = up;
484: sc->actl = up;
485: up->flags |= URXFR;
486: }
487: return (didie);
488: }
489:
490: /*
491: * Start up a transfer on a drive.
492: */
493: upstart(sc)
494: register struct scctl *sc;
495: {
496: register struct buf *bp;
497: register struct updisk *up;
498: register struct updevice *reg;
499: register struct upst *st;
500: register c;
501: uaddr_t uad;
502: int sn, tn;
503:
504: loop:
505: if ((up = sc->actf) == NULL)
506: return (0);
507: if ((bp = up->actf) == NULL) {
508: sc->actf = up->next;
509: goto loop;
510: }
511: sc->flags |= CACTIVE;
512: st = &upst[up->type];
513: sn = bp->b_blkno%st->nspc;
514: tn = sn/st->nsect;
515: sn %= st->nsect;
516: reg = sc->addr;
517: reg->upcs2 = up->unit;
518: c = 0;
519: while ((reg->upds&UPDS_DRY) == 0) {
520: if (++c > 512)
521: break;
522: upwaitdry++;
523: }
524: if ((reg->upds & UPDS_DREADY) != UPDS_DREADY) {
525: printf("up%d: not ready", UNIT(bp->b_dev));
526: if ((reg->upds & UPDS_DREADY) != UPDS_DREADY) {
527: printf("\n");
528: sc->flags &=~ (CACTIVE|CWAITING);
529: sc->errcnt = 0;
530: up->actf = bp->av_forw;
531: up->flags &=~ (UACTIVE|URXFR);
532: bp->b_flags |= B_ERROR;
533: iodone(bp);
534: goto loop;
535: }
536: printf(" (flakey)\n"); /* inscrutable */
537: }
538: reg->updc = bp->b_cylin;
539: reg->upda = (tn << 8) + sn;
540: reg->upwc = -bp->b_bcount / sizeof(short);
541: if (bp->b_flags & B_READ)
542: c = UP_IE|UP_RCOM|UP_GO;
543: else
544: c = UP_IE|UP_WCOM|UP_GO;
545: bp->b_ubm = (struct buf *)ubinspath(ubmapath(sc->ubno), (ubm_t)bp->b_ubm);
546: uad = ubadbuf(sc->ubno, bp, (ubm_t)bp->b_ubm);
547: reg->upba = uad;
548: reg->upcs1 = c|((uad>>8)&0x300);
549: return (1);
550: }
551:
552: /*
553: * Handle a disk interrupt.
554: */
555: sc0int(ctl)
556: int ctl;
557: {
558: register struct updevice *reg;
559: register struct scctl *sc;
560: register struct updisk *up;
561: register struct buf *bp;
562: register int unit, i, as;
563: int needie;
564:
565: if (ctl < 0 || ctl >= sccnt) {
566: printf("sc%d bad intr\n");
567: return;
568: }
569: sc = &scctl[ctl];
570: if ((reg = sc->addr) == 0) {
571: printf("sc%d: stray intr\n");
572: return;
573: }
574: needie = 1;
575: as = (reg->upas & 0377) | sc->softas;
576: sc->softas = 0;
577: if ((sc->flags & CACTIVE) == 0) { /* must be a seek */
578: if (reg->upcs1 & UP_TRE)
579: reg->upcs1 = UP_TRE;
580: goto doattn;
581: }
582: up = sc->actf;
583: bp = up->actf;
584: reg->upcs2 = up->unit;
585: if ((reg->upds&UPDS_ERR) || (reg->upcs1&UP_TRE)) {
586: i = 0;
587: while ((reg->upds & UPDS_DRY) == 0) {
588: if (++i > 512)
589: break;
590: upwaitdry++;
591: }
592: if (reg->uper1&UPER1_WLE) {
593: printf("up%d: write locked\n", UNIT(bp->b_dev));
594: bp->b_flags |= B_ERROR;
595: } else if (++sc->errcnt > 27) {
596: harderr(bp, "up");
597: printf("cs2=%o er1=%o er2=%o\n",
598: reg->upcs2&0177777, reg->uper1&0177777, reg->uper2&0177777);
599: bp->b_flags |= B_ERROR;
600: } else {
601: /*
602: * soft ecc, try to correct
603: */
604: sc->flags &=~ (CACTIVE|CWAITING); /* force retry */
605: if ((reg->uper1&(UPER1_DCK|UPER1_ECH))==UPER1_DCK)
606: if (upecc(up))
607: return; /* probably wrong */
608: }
609: /*
610: * `hard' error. clear and try again
611: */
612: reg->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
613: needie = 0;
614: if ((sc->errcnt&07) == 4 && (sc->flags & CACTIVE) == 0) {
615: reg->upcs1 = UP_RECAL|UP_IE|UP_GO;
616: sc->recal = 0;
617: goto nextrecal;
618: }
619: }
620: /*
621: * Advance recalibration finite state machine
622: * if recalibrate in progress, through
623: * RECAL
624: * SEEK
625: * OFFSET (optional)
626: * RETRY
627: */
628: switch (sc->recal) {
629: case 1:
630: reg->updc = bp->b_cylin;
631: reg->upcs1 = UP_SEEK|UP_IE|UP_GO;
632: goto nextrecal;
633: case 2:
634: if (sc->errcnt < 16 || (bp->b_flags&B_READ) == 0)
635: goto donerecal;
636: reg->upof = up_offset[sc->errcnt & 017] | UPOF_FMT22;
637: reg->upcs1 = UP_IE|UP_OFFSET|UP_GO;
638: nextrecal:
639: sc->recal++;
640: sc->flags |= CACTIVE;
641: return;
642:
643: donerecal:
644: case 3:
645: sc->recal = 0;
646: sc->flags &=~ CACTIVE;
647: break;
648: }
649: if (sc->flags & CACTIVE) { /* `active' means we're done */
650: if (sc->errcnt >= 16) {
651: reg->upof = UPOF_FMT22;
652: reg->upcs1 = UP_RTC|UP_GO|UP_IE;
653: while (reg->upds & UPDS_PIP)
654: DELAY(25);
655: needie = 0;
656: }
657: sc->flags &=~ (CACTIVE|CWAITING);
658: sc->errcnt = 0;
659: sc->actf = up->next;
660: up->flags &=~ (UACTIVE|URXFR);
661: up->actf = bp->av_forw;
662: bp->b_resid = (-reg->upwc * sizeof(short));
663: ubmfree(sc->ubno, (ubm_t)bp->b_ubm);
664: iodone(bp);
665: if (up->actf)
666: if (upustart(up))
667: needie = 0;
668: }
669: as |= reg->upas;
670: as &= ~(1<<up->unit);
671: doattn:
672: /*
673: * Process other units which need attention.
674: */
675: for (unit = 0, i = 1; unit < NSCUP && as; i <<= 1, unit++) {
676: if ((as & i) == 0)
677: continue;
678: as &= ~i;
679: reg->upas = i;
680: if ((up = sc->drives[unit]) != NULL && upustart(up))
681: needie = 0;
682: }
683: if (sc->actf && (sc->flags & CACTIVE) == 0)
684: if (upstart(sc))
685: needie = 0;
686: if (needie)
687: reg->upcs1 = UP_IE; /* why bother? */
688: }
689:
690: upread(dev)
691: dev_t dev;
692: {
693: physio(upstrategy, &upbuf[UNIT(dev)], dev, B_READ, minphys);
694: }
695:
696: upwrite(dev)
697: dev_t dev;
698: {
699: physio(upstrategy, &upbuf[UNIT(dev)], dev, B_WRITE, minphys);
700: }
701:
702: upioctl(dev, cmd, addr, flag)
703: dev_t dev;
704: int cmd;
705: caddr_t addr;
706: int flag;
707: {
708: register struct updisk *up;
709: long parts[2];
710:
711: up = &updisk[UNIT(dev)];
712: switch (cmd) {
713: case DIOSSIZ:
714: if ((flag & FWRITE) == 0) {
715: u.u_error = EBADF;
716: return;
717: }
718: if (copyin(addr, (caddr_t)parts, sizeof(parts)) < 0) {
719: u.u_error = EFAULT;
720: return;
721: }
722: /*
723: * why test this? see comments above upstrategy
724: */
725: if ((parts[0] % upst[up->type].nspc) != 0) {
726: u.u_error = EINVAL;
727: return;
728: }
729: up->blkoff[PART(dev)] = parts[0];
730: up->nblocks[PART(dev)] = parts[1];
731: return;
732:
733: case DIOGSIZ:
734: parts[0] = up->blkoff[PART(dev)];
735: parts[1] = up->nblocks[PART(dev)];
736: if (copyout((caddr_t)parts, addr, sizeof(parts)) < 0)
737: u.u_error = EFAULT;
738: return;
739:
740: default:
741: u.u_error = ENOTTY;
742: return;
743: }
744: }
745:
746: /*
747: * correct an ECC error and restart the transfer
748: * the error is (upec1-1) bits into the current sector;
749: * at that point, the bits set in upec2 are wrong.
750: *
751: * should be able just to set the GO bit and proceed,
752: * but emulex insists we do DCLR first, or so the book says,
753: * because DCK sets ERR in upds
754: */
755: upecc(up)
756: register struct updisk *up;
757: {
758: register struct updevice *reg;
759: register struct scctl *sc;
760: register struct buf *bp;
761: register int i;
762: int nxf;
763: unsigned int mask;
764: uaddr_t uad, lastua;
765: int xc, xa;
766:
767: if ((bp = up->actf) == NULL || (sc = up->ctl) == NULL)
768: panic("upecc");
769: reg = sc->addr;
770: ubmflush(sc->ubno, ubmpath((ubm_t)bp->b_ubm));
771: lastua = reg->upba + ((reg->upcs1&0x300)<<8);
772: nxf = bp->b_bcount + (reg->upwc * sizeof(short));
773: i = reg->upec1 - 1; /* -1 makes 0 origin */
774: uad = lastua - (nxf > SECTOR ? SECTOR : nxf) + ((i&~07)>>3);
775: mask = reg->upec2;
776: mask <<= i&07;
777: for (; uad < lastua && mask; mask >>= 8, uad++)
778: ubputc(sc->ubno, uad, ubgetc(sc->ubno, uad)^mask);
779: printf("up%d%o: soft ecc sec %ld\n", UNIT(bp->b_dev), PART(bp->b_dev),
780: bp->b_blkno + nxf/SECTOR - 1);
781: sc->flags |= CACTIVE; /* either complete or continuing */
782: if (reg->upwc == 0)
783: return (0);
784: #ifdef notdef
785: reg->uper1 = 0;
786: reg->upcs1 |= UP_GO;
787: #else /* clear wretched emulex error */
788: xc = reg->updc;
789: xa = reg->upda;
790: /* ba, wc undisturbed by DCLR */
791: reg->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
792: reg->updc = xc;
793: reg->upda = xa;
794: reg->upba = lastua;
795: i = (lastua >> 8) & 0x300;
796: i |= UP_IE|UP_GO|UP_RCOM;
797: reg->upcs1 = i;
798: #endif
799: return (1);
800: }
801:
802: /*
803: * check for offline drives and hung controllers
804: */
805:
806: upwatch()
807: {
808: register struct scctl *sc;
809: register struct updisk *up;
810: register struct updevice *reg;
811: register struct buf *bp;
812: register int ounit;
813: register int s;
814:
815: s = spl6();
816: timeout(upwatch, (caddr_t)0, 15*HZ);
817: for (up = &updisk[upcnt-1]; up >= updisk; up--) {
818: if ((up->flags & UWOL) == 0)
819: continue;
820: reg = up->ctl->addr;
821: ounit = reg->upcs2 & UPCS2_SEL;
822: reg->upcs2 = up->unit;
823: if ((reg->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL)) {
824: if ((up->flags & UWAITOL) == 0) {
825: up->flags |= UWAITOL;
826: reg->upcs2 = ounit;
827: continue;
828: }
829: printf("up%d offline\n", up - updisk);
830: while ((bp = up->actf) != NULL) {
831: bp->b_flags |= B_ERROR;
832: up->actf = bp->av_forw;
833: ubmfree(up->ctl->ubno, (ubm_t)bp->b_ubm);
834: iodone(bp);
835: }
836: }
837: up->flags &=~ (UWAITOL|UWOL);
838: upustart(up);
839: reg->upcs2 = ounit;
840: }
841: for (sc = &scctl[sccnt-1]; sc >= scctl; sc--) {
842: if (sc->flags & CACTIVE) {
843: if ((sc->flags & CWAITING) == 0)
844: sc->flags |= CWAITING;
845: else {
846: sc->addr->upcs2 = UPCS2_CLR;
847: printf("sc%d hung, kicked\n", sc - scctl);
848: sc->flags &=~ (CWAITING|CACTIVE);
849: }
850: }
851: if (sc->actf && (sc->flags & CACTIVE) == 0)
852: upstart(sc);
853: }
854: splx(s);
855: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.