![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raicarus.chp 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 raicarus.chp CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: /*
2: * DSA disk class driver
3: * drives RA-class disks
4: * hooked up through an MSCP port
5: */
6:
7: #include "sys/param.h"
8: #include "sys/buf.h"
9: #include "sys/udaioc.h"
10: #include "sys/diskio.h"
11: #include "sys/ra.h"
12: #include "sys/mscp.h"
13: #include "sys/user.h"
14: #include "sys/file.h"
15: #include "sys/conf.h"
16:
17: extern struct msaddr raaddr[];
18: extern struct radisk radisk[];
19: extern int racnt;
20: static long rarefno; /* ref seq num */
21: extern struct buf rabuf[];
22: static struct buf rctbuf; /* for reading replacement table */
23:
24: static rareplace(), raonline(), rasonl(), racinit();
25:
26: int raopen(), raread(), rawrite(), raioctl(), rastrategy(), raclose();
27: struct bdevsw rabdev = bdinit(raopen, raclose, rastrategy, 0);
28: struct cdevsw racdev = cdinit(raopen, raclose, raread, rawrite, raioctl);
29:
30: /*
31: * UNIT(d) == logical unit number;
32: * the physical unit number is in raaddr[UNIT(d)].unit
33: *
34: * 0100 in the minor device is (temporarily?)
35: * usurped to indicate bitmapped file systems
36: * quietly ignore it for now
37: * when things improve, change the UNIT mask to 037
38: */
39: #define UNIT(dev) (((dev)>>3) & 027)
40: #define PART(dev) ((dev)&07)
41: #define HUGE 0x7fffffff /* very large 32-bit number */
42:
43: /*
44: * default partition sizes
45: */
46: static struct size {
47: daddr_t nblocks;
48: daddr_t blkoff;
49:
50: } ra_sizes[NRAPART] = {
51: 11*960, 0*960, /* 0 = cyl 0 thru 10
52: 21*960, 11*960, /* 1 = cyl 11 thru 31
53: 242*960 32*960, /* 2 = cyl 32 thru 273
54: 242*960 274*960, /* 3 = cyl 274 thru 515
55: 242*960 516*960, /* 4 = cyl 516 thru 757
56: 84*960 758*960, /* 5 = cyl 758 thru 841
57: 842*960 0*960, /* 6 = all cyl 0 thru 841
58: };
59:
60: /*
61: *} ra_sizes[NRAPART] = {
62: * 11*960, 0*960, /* A = cyl 0 thru 10 for / */
63: * 22*960, 11*960, /* B = cyl 11 thru 32 for swap */
64: * 842*960, 0*960, /* C = all cyl 0 thru 841 for testing */
65: * 16*960, 33*960, /* D = cyl 33 thru 48 for /usr/guest */
66: * 66*960, 49*960, /* E = cyl 49 thru 114 for /usr/src */
67: * 242*960,115*960, /* F = cyl 115 thru 356 nearly 1/3 */
68: * 242*960,357*960, /* G = cyl 357 thru 598 nearly 1/3 */
69: * 242*960,599*960, /* H = cyl 599 thru 840 nearly 1/3 */
70: *};
71: */
72:
73: /*
74: * reused bits of buf/iobuf struct
75: */
76:
77: #define b_next av_forw /* next buffer in queue */
78: #define b_pkt av_back /* pointer to mscp command */
79: #define b_crf b_resid /* saved refno for pending command */
80:
81: /*
82: * flags in radisk.flags
83: */
84:
85: #define ONLINE 01 /* drive is online */
86: #define WONLINE 02 /* waiting for online */
87: #define GOTDI 04 /* got unit info */
88: #define RPLOCK 010 /* replacement in progress */
89: #define RPWANT 020 /* want RPLOCK */
90: #define RPDONE 040 /* replacement done */
91: #define SPDOWN 0100 /* spin down on last close */
92:
93: /*
94: * random numbers
95: */
96:
97: #define PRIONL (PZERO-1)
98: #define SECTOR 512 /* size of an MSCP sector */
99: #define IDRA 0 /* connection ID for MSCP */
100:
101: /*
102: * open a drive, if necessary
103: */
104:
105: int raseql(), radg();
106:
107: raopen(dev, flag)
108: dev_t dev;
109: {
110: register int unit;
111: register struct radisk *ra;
112: register struct msaddr *rp;
113: register int part;
114:
115: unit = UNIT(dev);
116: if (unit >= racnt) {
117: u.u_error = ENXIO;
118: return;
119: }
120: ra = &radisk[unit];
121: rp = &raaddr[unit];
122: if (ra->open == 0) {
123: if (rp->ctype < 0 || rp->ctype >= nmsport
124: || (ra->port = msportsw[rp->ctype]) == NULL) {
125: u.u_error = ENXIO;
126: return;
127: }
128: ra->di.radsize = HUGE;
129: if ((*ra->port->mp_init)(rp->ctl, rp->ctype, 0, IDRA, raseql, radg) == 0) {
130: u.u_error = ENXIO;
131: return;
132: }
133: racinit(ra, rp);
134: }
135: part = PART(dev);
136: if ((ra->pinit & (1<<part)) == 0) {
137: ra->nblocks[part] = ra_sizes[part].nblocks;
138: ra->blkoff[part] = ra_sizes[part].blkoff;
139: ra->pinit |= (1<<part);
140: }
141: ra->open |= 1<<part;
142: spl6();
143: if ((ra->flags & ONLINE) == 0)
144: raonline(ra, rp);
145: spl0();
146: if ((ra->flags & ONLINE) == 0)
147: u.u_error = ENXIO;
148: }
149:
150: raclose(dev)
151: {
152: register struct radisk *ra;
153: register struct msaddr *rp;
154: register struct mscmd *mp;
155:
156: ra = &radisk[UNIT(dev)];
157: rp = &raaddr[UNIT(dev)];
158: ra->open &=~ (1<<PART(dev));
159: if (ra->open || (ra->flags & ONLINE) == 0)
160: return;
161: mp = (*ra->port->mp_get)(rp->ctl);
162: mp->m_crf = ++rarefno;
163: mp->m_unit = rp->unit;
164: mp->m_opcd = OPAVL; /* put it offline */
165: if ((ra->flags & SPDOWN) == 0)
166: mp->m_mod = 0;
167: else {
168: mp->m_mod = MDSPD;
169: ra->flags &=~ SPDOWN;
170: }
171: mp->m_unfl = 0;
172: mp->m_dvpm = 0; /* ? */
173: ra->flags &=~ ONLINE;
174: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
175: }
176:
177: int rastrategy();
178:
179: raread(dev)
180: {
181: physio(rastrategy, &rabuf[UNIT(dev)], dev, B_READ, minphys);
182: }
183:
184: rawrite(dev)
185: {
186: physio(rastrategy, &rabuf[UNIT(dev)], dev, B_WRITE, minphys);
187: }
188:
189: /*
190: * strategy routine;
191: * used as strategy by all port drivers
192: * send the packet right away
193: */
194:
195: rastrategy(bp)
196: register struct buf *bp;
197: {
198: register struct radisk *ra;
199: register struct mscmd *mp;
200: register int unit;
201: register int part;
202: register struct msaddr *rp;
203: int count;
204: daddr_t limit;
205:
206: unit = UNIT(minor(bp->b_dev));
207: part = PART(minor(bp->b_dev));
208: ra = &radisk[unit];
209: rp = &raaddr[unit];
210: limit = ra->di.radsize - ra->blkoff[part];
211: if (limit > ra->nblocks[part])
212: limit = ra->nblocks[part];
213: if (bp->b_blkno >= limit && bp != &rctbuf) {
214: if (bp->b_blkno == ra->nblocks[part])
215: bp->b_resid = bp->b_bcount;
216: else {
217: bp->b_error = ENOSPC;
218: bp->b_flags |= B_ERROR;
219: }
220: iodone(bp);
221: return;
222: }
223: count = bp->b_bcount;
224: if (count/SECTOR + bp->b_blkno > limit && bp != &rctbuf)
225: count = (limit - bp->b_blkno) * SECTOR;
226: spl6();
227: if ((ra->flags & ONLINE) == 0 && raonline(ra, rp) == 0) {
228: bp->b_flags |= B_ERROR;
229: iodone(bp);
230: spl0();
231: return;
232: }
233: mp = (*ra->port->mp_get)(rp->ctl);
234: mp->m_crf = ++rarefno;
235: mp->m_unit = rp->unit;
236: mp->m_opcd = (bp->b_flags & B_READ) ? OPRD : OPWR;
237: mp->m_mod = 0;
238: mp->m_bcnt = count;
239: mp->m_lbn = bp->b_blkno + ra->blkoff[part];
240: (*ra->port->mp_map)(rp->ctl, mp, bp);
241: bp->b_pkt = (struct buf *)mp;
242: bp->b_crf = mp->m_crf;
243: bp->b_next = NULL;
244: if (ra->actf)
245: ra->actl->b_next = bp;
246: else
247: ra->actf = bp;
248: ra->actl = bp;
249: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
250: spl0();
251: }
252:
253: /*
254: * ioctl
255: * principally for bad block replacement
256: */
257:
258: raioctl(dev, cmd, addr, flag)
259: dev_t dev;
260: caddr_t addr;
261: {
262: register union arg {
263: struct ud_rctbuf r;
264: struct ud_repl b;
265: } *uap;
266: register struct radisk *ra;
267: register int i;
268: long parts[2];
269:
270: ra = &radisk[UNIT(dev)];
271: if ((ra->flags & (ONLINE|GOTDI)) != (ONLINE|GOTDI)) {
272: /* should bring it online here */
273: u.u_error = EIO;
274: return;
275: }
276: uap = (union arg *)addr;
277: switch(cmd) {
278: default:
279: u.u_error = ENOTTY;
280: return;
281:
282: case DIOSSIZ:
283: if ((flag & FWRITE) == 0) {
284: u.u_error = EBADF;
285: return;
286: }
287: if (copyin(addr, (caddr_t)parts, sizeof(parts)) < 0) {
288: u.u_error = EFAULT;
289: return;
290: }
291: ra->blkoff[PART(dev)] = parts[0];
292: ra->nblocks[PART(dev)] = parts[1];
293: return;
294:
295: case DIOGSIZ:
296: parts[0] = ra->blkoff[PART(dev)];
297: parts[1] = ra->nblocks[PART(dev)];
298: if (copyout((caddr_t)parts, addr, sizeof(parts)) < 0)
299: u.u_error = EFAULT;
300: return;
301:
302: case UIOCHAR:
303: if (copyout((caddr_t)&ra->di, addr, sizeof(struct ud_unit)))
304: u.u_error = EFAULT;
305: return;
306:
307: case UIORRCT:
308: if(uap->r.lbn < 0 || uap->r.lbn > ra->di.rctsize) {
309: u.u_error = EIO;
310: return;
311: }
312: /*
313: * try different copies until one works
314: */
315: for (i = 0; i < ra->di.copies; i++) {
316: u.u_count = SECTOR; /* block size on disk */
317: u.u_offset = ltoL((uap->r.lbn + ra->di.radsize) * SECTOR);
318: u.u_offset = Lladd(u.u_offset,i * ra->di.rctsize * SECTOR);
319: u.u_base = uap->r.buf;
320: u.u_segflg = SEGUDATA;
321: u.u_error = 0;
322: physio(rastrategy, &rctbuf, dev, B_READ, minphys);
323: if (u.u_error == 0)
324: break;
325: }
326: return;
327:
328: case UIOWRCT:
329: if ((flag & FWRITE) == 0) {
330: u.u_error = EBADF;
331: return;
332: }
333: if(uap->r.lbn < 0 || uap->r.lbn > ra->di.rctsize) {
334: u.u_error = EIO;
335: return;
336: }
337: /*
338: * write every copy we can
339: * should do read-after-write
340: */
341: for (i = 0; i < ra->di.copies; i++) {
342: u.u_count = SECTOR; /* block size on disk */
343: u.u_offset = ltoL((uap->r.lbn + ra->di.radsize) * SECTOR);
344: u.u_offset = Lladd(u.u_offset, i * ra->di.rctsize * SECTOR);
345: u.u_base = uap->r.buf;
346: u.u_segflg = SEGUDATA;
347: physio(rastrategy, &rctbuf, dev, B_WRITE, minphys);
348: u.u_error = 0;
349: }
350: return;
351:
352: case UIOREPL:
353: if ((flag & FWRITE) == 0) {
354: u.u_error = EBADF;
355: return;
356: }
357: rareplace(dev, uap->b.lbn, uap->b.replbn, uap->b.prim);
358: return;
359:
360: case UIOSPDW:
361: ra->flags |= SPDOWN;
362: return;
363:
364: case UIORST:
365: (*ra->port->mp_init)(raaddr[UNIT(dev)].ctl, raaddr[UNIT(dev)].ctype, 1, IDRA, raseql, radg);
366: return;
367: }
368:
369: }
370:
371: static
372: rareplace(dev, badlbn, replbn, prim)
373: int dev;
374: daddr_t badlbn;
375: daddr_t replbn;
376: int prim;
377: {
378: register struct mscmd *mp;
379: register struct radisk *ra;
380: register struct msaddr *rp;
381: register int unit;
382:
383: unit = UNIT(minor(dev));
384: ra = &radisk[unit];
385: rp = &raaddr[unit];
386: spl6();
387: while (ra->flags & RPLOCK) {
388: ra->flags |= RPWANT;
389: sleep((caddr_t)&ra->flags, PZERO + 1);
390: }
391: ra->flags |= RPLOCK;
392: printf("ra%d replace %D with %D\n", unit, badlbn, replbn);
393: mp = (*ra->port->mp_get)(rp->ctl);
394: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */
395: mp->m_crf = ++rarefno;
396: mp->m_unit = rp->unit;
397: mp->m_opcd = OPRPL;
398: mp->m_rbn = replbn;
399: mp->m_lbn = badlbn;
400: mp->m_mod = prim ? MDPRI : 0;
401: ra->cmdcrf = mp->m_crf;
402: ra->cmdopc = OPRPL;
403: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
404: while ((ra->flags & RPDONE) == 0)
405: sleep((caddr_t)&ra->rplret, PZERO);
406: u.u_error = ra->rplret;
407: if (ra->flags & RPWANT)
408: wakeup((caddr_t)&ra->flags);
409: ra->flags &=~ (RPWANT|RPLOCK|RPDONE);
410: spl0();
411:
412: }
413:
414: /*
415: * here when the port gets a sequential message
416: */
417: raseql(ctl, type, ep)
418: int ctl, type;
419: register struct msend *ep;
420: {
421: register struct buf *bp;
422: register struct radisk *ra;
423: register int unit;
424: register struct buf *obp;
425: int sts;
426:
427: if (ep->m_opcd == 0 && ep->m_sts == STRST) {
428: rareset(ctl);
429: return;
430: }
431: for (unit = 0; unit < racnt; unit++)
432: if (raaddr[unit].ctl == ctl
433: && raaddr[unit].ctype == type
434: && raaddr[unit].unit == ep->m_unit)
435: break;
436: if (unit >= racnt) {
437: printf("ra%d ctl%d typ%d: stray mscp packet sts x%x opcode %o\n",
438: ep->m_unit, ctl, type, ep->m_sts, ep->m_opcd);
439: return;
440: }
441: ra = &radisk[unit];
442: sts = ep->m_sts & STMSK;
443: if (sts == STAVL || sts == STOFL)
444: ra->flags &=~ ONLINE; /* help! */
445: illcmd:
446: switch (ep->m_opcd & 0377) {
447: case OPEND: /* eg invalid command */
448: if (ep->m_crf == ra->cmdcrf) {
449: ep->m_opcd = ra->cmdopc | OPEND;
450: goto illcmd;
451: }
452: /* else check for pending read or write */
453: case OPRD|OPEND:
454: case OPWR|OPEND:
455: for (bp = ra->actf, obp = NULL; bp; obp = bp, bp = bp->b_next)
456: if (ep->m_crf == bp->b_crf)
457: break;
458: if (bp == NULL) {
459: printf("ra%d stray end: crf %d sts x%x opcode 0%o\n",
460: unit, ep->m_crf, ep->m_sts, ep->m_opcd & 0377);
461: return;
462: }
463: if (((struct mscmd *)(bp->b_pkt))->m_crf != ep->m_crf)
464: printf("ra%d sent %d got %d crf; flg %x dev %x\n",
465: unit, ((struct mscmd *)(bp->b_pkt))->m_crf,
466: ep->m_crf, bp->b_flags, bp->b_dev);
467: if (obp)
468: obp->b_next = bp->b_next;
469: else
470: ra->actf = bp->b_next;
471: if (bp == ra->actl)
472: ra->actl = obp;
473: bp->b_resid = bp->b_bcount - ep->m_bcnt;
474: if (sts != STSUC) {
475: bp->b_flags |= B_ERROR;
476: if (ep->m_sts == STBCK || ep->m_sts == STBK2) /* optical disk blank check */
477: bp->b_error = ENXIO;
478: else
479: printf("err on ra%d block %D: sts x%x\n", unit, bp->b_blkno, ep->m_sts);
480: }
481: (*ra->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt);
482: iodone(bp);
483: return;
484:
485: case OPONL|OPEND:
486: rasonl(ra, ep);
487: return;
488:
489: case OPAVL|OPEND:
490: ra->flags &=~ ONLINE;
491: return;
492:
493: case OPGUS|OPEND:
494: if (sts != STSUC) {
495: printf("ra%d: can't get unit sts x%x\n", unit, ep->m_sts);
496: return;
497: }
498: ra->di.medium = ep->m_medi;
499: ra->di.tracksz = ep->m_trck;
500: ra->di.groupsz = ep->m_grp;
501: ra->di.cylsz = ep->m_cyl;
502: ra->di.rctsize = ep->m_rcts;
503: ra->di.rbns = ep->m_rbns;
504: ra->di.copies = ep->m_rctc;
505: ra->flags |= GOTDI;
506: return;
507:
508: case OPSCC|OPEND:
509: if (sts != STSUC)
510: printf("ra ctl%d typ%d: bad init\n", ctl, type);
511: return;
512:
513: case OPRPL|OPEND:
514: ra->rplret = 0;
515: if (sts != STSUC) {
516: printf("ra%d: rpl sts x%x\n", unit, ep->m_sts);
517: ra->rplret = EIO;
518: }
519: ra->flags |= RPDONE;
520: wakeup((caddr_t)&ra->rplret);
521: return;
522:
523: default:
524: printf("ra%d ctl%d typ%d: stray mscp msg opcd 0%o sts x%x\n",
525: ep->m_unit, ctl, type, ep->m_opcd&0377, ep->m_sts);
526: return;
527: }
528: }
529:
530: /*
531: * controller was reset
532: * discard all pending io,
533: * awake all sleepers,
534: * mark everything offline
535: */
536:
537: rareset(ctl)
538: int ctl;
539: {
540: register int unit;
541: register struct radisk *ra;
542: register struct buf *bp, *nbp;
543:
544: for (unit = 0; unit < racnt; unit++) {
545: if (raaddr[unit].ctl != ctl)
546: continue;
547: ra = &radisk[unit];
548: for (bp = ra->actf; bp; bp = nbp) {
549: nbp = bp->b_next;
550: (*ra->port->mp_unmap)(ctl, (struct mscmd *)bp->b_pkt);
551: bp->b_flags |= B_ERROR;
552: iodone(bp);
553: }
554: ra->actf = ra->actl = NULL;
555: ra->flags &=~ (ONLINE|WONLINE);
556: wakeup((caddr_t)ra);
557: }
558: }
559:
560: /*
561: * here with a datagram message
562: * explanations really shouldn't be in the driver
563: *
564: * the hack for event 8 ignores error packets from
565: * the US Design optical disk controller
566: * that really mean `read a blank spot on the disk
567: */
568:
569: static char *raevents[] = {
570: "ok",
571: "inv cmd",
572: "op aborted",
573: "offline",
574: "available",
575: "med fmt",
576: "write prot",
577: "comp err",
578: "data err",
579: "host buf access err",
580: "cntl err",
581: "drive err",
582: };
583: #define MAXEVT 0xb
584:
585: radg(ctl, type, ep)
586: int ctl, type;
587: register struct mserl *ep;
588: {
589: register u_short *sp; /* for sdi crap */
590: register int i; /* for useless design crap */
591: register unsigned char *cp; /* for useless design crap */
592:
593: if (ep->l_fmt == FMDSK && ep->l_evnt == STBCK && ep->l_flgs == 0)
594: return;
595: printf("ra%d ctl%d typ%d seq %d: %s err; fmt x%x ev x%x fl x%x\n",
596: ep->l_unit, ctl, type, ep->l_seq, /* phys unit, not log */
597: ep->l_flgs&(LFSUC|LFCON) ? "soft" : "hard",
598: ep->l_fmt, ep->l_evnt, ep->l_flgs&0377);
599: if ((ep->l_evnt & STMSK) <= MAXEVT)
600: printf("%s; ", raevents[ep->l_evnt & STMSK]);
601: switch (ep->l_fmt) {
602: case FMCNT:
603: /* now the thing should be marked disastrously bad */
604: printf("oops\n");
605: break;
606:
607: case FMBAD:
608: printf("host mem access; addr x%x\n", ep->l_badr);
609: break;
610:
611: case FMDSK:
612: printf("%sbn %d; lev x%x, retry x%x\n",
613: (ep->l_hdcd & 0xf0000000) == 0 ? "l" : "r",
614: ep->l_hdcd & 0x0fffffff, ep->l_lvl, ep->l_rtry);
615: break;
616:
617: case FMSDI:
618: printf("%sbn %d;",
619: (ep->l_hdcd & 0xf0000000) == 0 ? "l" : "r",
620: ep->l_hdcd & 0x0fffffff);
621: /*
622: * print the bytes in the same order used
623: * by the dec diagnostics
624: */
625: sp = (u_short *)&ep->l_sdi[3];
626: while (sp > (u_short *)ep->l_sdi)
627: printf(" %x", *--sp);
628: printf(" xx\n");
629: break;
630:
631: case FMSMD:
632: printf("cyl %d\n", ep->l_sdi[1]);
633: break;
634:
635: case 0x40: /* hack for useless design */
636: printf("scsi:");
637: cp = (unsigned char *)ep->l_sdi;
638: for(i = 0; i < 10; i++)
639: printf(" %x", *cp++);
640: printf(" [%x %x]\n", cp[0], cp[1]);
641: break;
642:
643: default:
644: printf("\n");
645: break;
646: }
647: }
648:
649: /*
650: * unit is believed offline
651: * try to bring it on
652: */
653:
654: static
655: raonline(ra, rp)
656: register struct radisk *ra;
657: register struct msaddr *rp;
658: {
659: register struct mscmd *mp;
660: int s;
661:
662: s = spl6();
663: if ((ra->flags & WONLINE) == 0) {
664: ra->flags &=~ GOTDI;
665: mp = (*ra->port->mp_get)(rp->ctl);
666: bzero((caddr_t)mp, sizeof(struct mscmd)); /* clear reserved fields */
667: mp->m_crf = ++rarefno;
668: mp->m_unit = rp->unit;
669: mp->m_opcd = OPONL;
670: ra->cmdcrf = mp->m_crf;
671: ra->cmdopc = OPONL;
672: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
673: ra->flags |= WONLINE;
674: }
675: while (ra->flags & WONLINE)
676: tsleep((caddr_t)ra, PRIONL, 60);
677: if ((ra->flags & ONLINE) == 0)
678: return (0);
679: if ((ra->flags & GOTDI) == 0) {
680: mp = (*ra->port->mp_get)(rp->ctl);
681: mp->m_crf = ++rarefno;
682: mp->m_unit = rp->unit;
683: mp->m_opcd = OPGUS;
684: mp->m_mod = 0;
685: mp->m_unfl = 0;
686: mp->m_dvpm = 0; /* ? */
687: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
688: }
689: splx(s);
690: return (1);
691: }
692:
693: static
694: rasonl(ra, ep)
695: register struct radisk *ra;
696: register struct msend *ep;
697: {
698:
699: if (ra->flags & WONLINE) {
700: ra->flags &=~ WONLINE;
701: wakeup((caddr_t)ra);
702: }
703: if ((ep->m_sts & STMSK) != STSUC)
704: return;
705: ra->flags |= ONLINE;
706: if (ra->di.radsize != HUGE && ra->di.radsize != ep->m_unsz)
707: printf("ra%d: changed size %d to %d\n", ra-radisk, ra->di.radsize, ep->m_unsz);
708: ra->di.radsize = ep->m_unsz;
709: }
710:
711: /*
712: * controller init
713: * set characteristics to turn off host timeouts
714: */
715:
716: static
717: racinit(ra, rp)
718: struct radisk *ra;
719: struct msaddr *rp;
720: {
721: register struct mscmd *mp;
722: register int s;
723:
724: mp = (*ra->port->mp_get)(rp->ctl);
725: mp->m_crf = ++rarefno;
726: mp->m_unit = rp->unit;
727: mp->m_opcd = OPSCC;
728: mp->m_mod = 0;
729: mp->m_cntf = CFMSC | CFTHS;
730: mp->m_vrsn = MSCPVER;
731: mp->m_htmo = 0; /* no timeout */
732: mp->m_time[0] = mp->m_time[1] = 0L;
733: s = spl6();
734: (*ra->port->mp_send)(rp->ctl, IDRA, mp);
735: splx(s);
736: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.