![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scat_vddc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba|
Return to scat_vddc.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba |
1.1 root 1: #include "fsd.h"
2: #if NVD > 0
3: /*
4: ** VDDC Driver - Versabus to SMD direct interface version.
5: ** Written for TAHOE vmunix, CCI-WDC 9/1/83.
6: ** Modified June 1984 to use scatter/gather.
7: */
8:
9: #include "../h/param.h"
10: #include "../h/buf.h"
11: #include "../h/cmap.h"
12: #include "../h/conf.h"
13: #include "../h/dir.h"
14: #include "../h/dk.h"
15: #include "../h/map.h"
16: #include "../machine/mtpr.h"
17: #include "../machine/pte.h"
18: #include "../h/systm.h"
19: #include "../vba/vbavar.h"
20: #include "../h/user.h"
21: #include "../h/vmmac.h"
22: #include "../h/proc.h"
23: #include "../h/uio.h"
24: #include "../vba/vddc.h"
25:
26: int vddebug = 1; /* if = 1, error messages are printed on the console */
27: int vdintflg = 0; /* if = 1, interrupts are handled by the driver,
28: * otherwise they are just ignored. (during setup) */
29:
30: static struct size FSD[] = {
31: 9600, 0, /* minor 0/ 8/16/24 = fsd0a - fsd3a - cyl 0 - 59*/
32: 12000, 9600, /* minor 1/ 9/17/25 = fsd0b - fsd3b - cyl 60 - 134*/
33: 108480, 21600, /* minor 2/10/18/26 = fsd0c - fsd3c - cyl 135 - 812*/
34: 1600, 130080, /* minor 3/11/19/27 = fsd0d - fsd3d - cyl 813 - 822*/
35: 130080, 0, /* minor 4/12/20/28 = fsd0e - fsd3e - cyl 0 - 812*/
36: 131680, 0, /* minor 5/13/21/29 = fsd0f - fsd3f - cyl 0 - 822*/
37: 0, 0, /* Non existent minor device */
38: 0, 0, /* Non existent minor device */
39: 0, 0, /* Non existent minor device */
40: 0, 0, /* Non existent minor device */
41: 0, 0, /* Non existent minor device */
42: 0, 0, /* Non existent minor device */
43: 0, 0, /* Non existent minor device */
44: 0, 0, /* Non existent minor device */
45: 0, 0, /* Non existent minor device */
46: 0, 0, /* Non existent minor device */
47: };
48:
49: static struct size SMD[]= {
50: 20064, 0, /* minor 32/40/48/56 = smd0a - smd3a cyl 0- 65 */
51: 13680, 20064, /* minor 33/41/49/57 = smd0b - smd3b cyl 66- 110 */
52: 214928, 33744, /* minor 34/42/50/58 = smd0c - smd3c cyl 111-817 */
53: 1520, 248672, /* minor 35/43/51/59 = smd0d - smd3d cyl 818-822 */
54: 248672, 0, /* minor 36/44/52/60 = smd0e - smd3e cyl 0-817 */
55: 250192, 0, /* minor 37/45/53/61 = smd0f - smd3f cyl 0-822 */
56: 0, 0, /* minor 38/46/54/62 = smd0g - smd3g */
57: 0, 0, /* minor 39/47/55/63 = smd0h - smd3h */
58: 0, 0, /* Non existent minor device */
59: 0, 0, /* Non existent minor device */
60: 0, 0, /* Non existent minor device */
61: 0, 0, /* Non existent minor device */
62: 0, 0, /* Non existent minor device */
63: 0, 0, /* Non existent minor device */
64: 0, 0, /* Non existent minor device */
65: 0, 0, /* Non existent minor device */
66: };
67:
68: static struct size XFSD[] = {
69: 20352, 0, /* minor 64/72/80/88 = xfsd0a - xfsd3a cyl 0- 52 */
70: 20352, 20352, /* minor 65/73/81/89 = xfsd0b - xfsd3b cyl 53- 105 */
71: 230400, 40704, /* minor 66/74/82/90 = xfsd0c - xfsd3c cyl 106-705 */
72: 1920, 271104, /* minor 67/75/83/91 = xfsd0d - xfsd3d cyl 706-710 */
73: 271104, 0, /* minor 68/76/84/92 = xfsd0e - xfsd3e cyl 0-705 */
74: 273024, 0, /* minor 69/77/85/93 = xfsd0f - xfsd3f cyl 0-710 */
75: 0, 0, /* minor 70/78/86/94 = xfsd0g - xfsd3g */
76: 0, 0, /* minor 71/79/87/95 = xfsd0h - xfsd3h */
77: 0, 0, /* Non existent minor device */
78: 0, 0, /* Non existent minor device */
79: 0, 0, /* Non existent minor device */
80: 0, 0, /* Non existent minor device */
81: 0, 0, /* Non existent minor device */
82: 0, 0, /* Non existent minor device */
83: 0, 0, /* Non existent minor device */
84: 0, 0, /* Non existent minor device */
85: };
86:
87: /*
88: /*
89: /* Layout of major/minor number assignments for the VDDC devices.
90: /*
91: /* 1
92: /* 5 8 7 4 3 2 0
93: /* +----------------+------+---+-----+
94: /* | Major device # | TYPE | D | FLS |
95: /* +----------------+------+---+-----+
96: /* | | |_____ File system # ( 0-7 )
97: /* | |__________ Drive # (0-3)
98: /* |________________ Drive type ( 0-FSD, 1-SMD )
99: /* ( 2-XFSD ) (obsolete)
100: /*
101: /********************************************************/
102:
103: #define VDUNIT(x) ((minor(x) & 0x18) >> 3)
104: #define DRVTYPE(x) ((minor(x) & 0xe0) >> 5) (obsolete)
105: #define FLSYS(x) (minor(x) & 0x07)
106: #define PHYS(x) ( vtoph( &proc[2], (int) (x) ) )
107:
108:
109: /* Drive types should be in order of drive capacity for auto-configuration */
110: /* e.g: smallest capacity = drive type 0, highest capacity = type NXPDRV-1 */
111:
112: struct vdst {
113: short nsect;
114: short ntrak;
115: short nspc;
116: short ncyl;
117: struct size *sizes;
118: short dtype; /* type as in byte 5 (drive) of iopb */
119: char *name; /* drive name for autoconf */
120: } vdst[] = {
121:
122: 16, 10, 16*10, 823, FSD, 0, "160 Mb FSD " ,
123: 16, 19, 16*19, 823, SMD, 1, "300 Mb SMD " ,
124: 16, 24, 16*24, 711, XFSD, 2, "340 Mb FSD "
125: };
126:
127:
128: struct vba_ctlr *vdminfo[NVDDC];
129: struct vba_device *vddinfo[NUNIT];
130:
131: /*
132: ** Internal Functions
133: */
134: int vdopen();
135: int vdclose();
136: int vdprobe(); /* See if VDDC is really there */
137: int vd_setup(); /* Called from vdprobe */
138: int vdslave(); /* See if drive is really there */
139: int vdattach();
140: int vddgo();
141: int vdstrategy(); /* VDDC strategy routine */
142: int vdstart(); /* Top level interface to device queue */
143: int vdintr(); /* Top Level ISR */
144: int vdread(); /* raw i/o read routine */
145: int vdwrite(); /* raw i/o write routine */
146: int vddump(); /* dump routine */
147: int vdsize(); /* sizes for swapconfig */
148:
149: long vdstd[] = {
150: 0x0f2000 };
151:
152: struct vba_driver vddriver =
153: {
154: vdprobe, vdslave, vdattach, vddgo, vdstd,
155: "smd/fsd", vddinfo, "VSMD controller ", vdminfo
156: };
157:
158: struct buf vdutab[NUNIT];
159: struct buf rvdbuf[NUNIT];
160: char vdbuf[SECTSIZ*2];
161: extern char vdutl[];
162:
163: /*
164: ** Disk Address
165: */
166: struct dskadr {
167: char track; /* all 8 bits */
168: char sector; /* low order 5 bits */
169: short cylinder; /* low order 12 bits */
170: };
171:
172: /*
173: ** DCB Trailer Formats
174: **********************************/
175:
176: /*
177: ** Read / Write Trailer
178: */
179: struct trrw {
180: char *memadr; /* memory address */
181: long wcount; /* 16 bit word count */
182: struct dskadr disk; /* disk address */
183: long scat[MAXBPTE*2+1]; /* gather/scatter trailer */
184: };
185:
186: /*
187: ** Format Trailer
188: */
189: struct trfmt {
190: char *addr; /* data buffer to be filled on sector*/
191: long nsectors; /* # of sectors to be formatted */
192: struct dskadr disk;
193: struct dskadr hdr;
194: };
195:
196: /*
197: ** Reset / Configure Trailer
198: */
199: struct treset {
200: long ncyl; /* # cylinders */
201: long nsurfaces; /* # surfaces */
202: }; /* # of sectors is defined by VDDC */
203: /* to be 32/track of 512 data bytes each */
204:
205: /*
206: ** Seek Trailer
207: */
208: struct trseek {
209: struct dskadr disk;
210: };
211:
212: /*
213: ** DCB Format
214: */
215: struct fmt_dcb {
216: struct fmt_dcb *nxtdcb; /* next dcb in chain or End of Chain */
217: short intflg; /* interrupt settings and flags */
218: short opcode; /* DCB Command code etc... */
219: long operrsta; /* Error & Status info */
220: short fill; /* not used */
221: char devselect; /* Drive selection */
222: char trailcnt; /* Trailer Word Count */
223: long err_memadr; /* Error memory address */
224: short fill2;
225: short err_wcount; /* Error word count */
226: short err_track; /* Error track/sector */
227: short err_cyl; /* Error cylinder adr */
228: union {
229: struct trrw rwtrail; /* read/write trailer */
230: struct trfmt fmtrail; /* format trailer */
231: struct treset resetrail; /* reset/configure trailer */
232: struct trseek seektrail; /* seek trailer */
233: } trail;
234: };
235:
236: /*
237: ** MDCB Format
238: */
239: struct fmt_mdcb {
240: struct fmt_dcb *firstdcb; /* first dcb in chain */
241: struct fmt_dcb *procdcb; /* dcb being processed */
242: struct fmt_dcb *intdcb; /* dcb causing interrupt */
243: long vddcstat; /* VDDC status */
244: }mdcbx;
245:
246: /*
247: ** MDCB
248: */
249: struct fmt_mdcb *mdcb = &mdcbx;
250:
251: /*
252: ** DCB
253: */
254:
255: struct fmt_dcb dcbx[NVDDC];
256:
257: int vdtimeout;
258: #define POLLTILLDONE(x) { vdtimeout = 1000*(x); \
259: uncache((char *)&dcb->operrsta); \
260: while (! (dcb->operrsta & DCBCMP)) { \
261: DELAY(1000); \
262: vdtimeout--; \
263: uncache((char *)&dcb->operrsta); \
264: if (vdtimeout <=0) { \
265: printf("VDDC controller timeout\n"); \
266: return(0); \
267: } \
268: } \
269: }
270:
271: /*
272: ** See if the controller is really there.
273: ** if TRUE - initialize the controller.
274: */
275: vdprobe(cntrl_vaddr)
276: caddr_t cntrl_vaddr;
277: {
278: if ( badaddr(cntrl_vaddr,2) ) return(0); /* no controller */
279: else
280: if (vd_setup(cntrl_vaddr)) /* initialize the controller */
281: return(1);
282: else return(0); /* initialization error */
283: }
284:
285: vd_setup(cntrl_vaddr)
286: caddr_t cntrl_vaddr;
287: {
288: register struct fmt_dcb *dcb = &dcbx[0];
289: int j;
290:
291: VDDC_RESET(cntrl_vaddr); /* Reset the controller */
292: /* Burn some time ...... needed after accessing reset port */
293: for (j=0; j<20; j++)
294: DELAY(1000);
295:
296: /* setup & issue INIT to initialize VDDC */
297:
298: dcb->opcode = INIT;
299: dcb->nxtdcb = (struct fmt_dcb *)0;
300: dcb->intflg = NOINT;
301: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
302: dcb->operrsta = 0;
303: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
304: POLLTILLDONE(1) /* poll till done */
305: if (dcb->operrsta & HRDERR) {
306: if (vddebug)
307: printf("VDDC INIT error. Status = %x\n",dcb->operrsta);
308: return(0);
309: }
310: /* setup & issue DIAGNOSE */
311:
312: dcb->opcode = DIAG;
313: dcb->nxtdcb = (struct fmt_dcb *)0;
314: dcb->intflg = NOINT;
315: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
316: dcb->operrsta = 0;
317: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
318: POLLTILLDONE(1) /* poll till done */
319: if (dcb->operrsta & HRDERR) {
320: if (vddebug)
321: printf("VDDC DIAGNOSE error. Status = %x\n",dcb->operrsta);
322: return(0);
323: }
324: /* Start drives command */
325: /*
326: /* dcb->opcode = VDSTART;
327: /* dcb->nxtdcb = (struct fmt_dcb *)0;
328: /* dcb->intflg = NOINT;
329: /* mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
330: /* dcb->operrsta = 0;
331: /* VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
332: /* POLLTILLDONE(20) /* poll till done */
333: /* if (dcb->operrsta & HRDERR) {
334: /* if (vddebug)
335: /* printf("VDDC START DRIVES error. Status = %x\n",dcb->operrsta);
336: /* return(0);
337: /* }
338: /**/
339: return(1);
340: }
341:
342: /*
343: * See if a drive is really there
344: * Try to Reset/Configure the drive, then test its status.
345: */
346: vdslave(ui,cntrl_vaddr)
347: register struct vba_device *ui;
348: register caddr_t cntrl_vaddr;
349: {
350: register struct fmt_dcb *dcb = &dcbx[0];
351: register struct vdst *st;
352: int dsktype;
353:
354: /*
355: ** check drive status - see if drive exists.
356: */
357: dcb->opcode = VDSTATUS;
358: dcb->intflg = NOINT;
359: dcb->operrsta = 0;
360: dcb->devselect = (char)ui->ui_slave;
361: dcb->trailcnt = (char)0;
362: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
363: mdcb->vddcstat = 0;
364: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb)) /* do it */
365: POLLTILLDONE(5)
366: /*
367: if (dcb->operrsta & HRDERR) {
368: if (vddebug)
369: printf("VDDC STATUS error. Status = %x, drive %d\n",dcb->operrsta,ui->ui_slave);
370: return(0);
371: }
372: */
373: uncache((char *)&mdcb->vddcstat);
374: if (mdcb->vddcstat & DRVNRDY) return(0); /* not ready-> non existent */
375:
376: /*
377: * drive is alive, now get its type!
378: * Seek on all drive types starting from the largest one.
379: * a sucessful seek to the last sector/cylinder/track verifies
380: * the drive type connected to this port.
381: */
382: for (dsktype = NVDDRV-1; dsktype >= 0; dsktype--) {
383: st = &vdst[dsktype];
384: dcb->opcode = RSTCFG; /* configure drive command */
385: dcb->intflg = NOINT;
386: dcb->operrsta = 0;
387: dcb->trail.resetrail.ncyl = st->ncyl;
388: dcb->trail.resetrail.nsurfaces = st->ntrak;
389: dcb->devselect = (char)ui->ui_slave;
390: dcb->trailcnt = (char)2;
391: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
392: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
393: POLLTILLDONE(3)
394: if (dcb->operrsta & HRDERR) {
395: if (vddebug)
396: printf("VDDC RESET/CONFIGURE error. Status = %x\n",dcb->operrsta);
397: return(0);
398: }
399: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
400: dcb->intflg = NOINT;
401: dcb->opcode = RD;
402: dcb->operrsta = 0;
403: dcb->devselect = (char)ui->ui_slave;
404: dcb->trailcnt = (char)3;
405: dcb->trail.rwtrail.memadr = (char *)PHYS(vdbuf);
406: dcb->trail.rwtrail.wcount = SECTSIZ;
407: dcb->trail.rwtrail.disk.cylinder = st->ncyl -2;
408: dcb->trail.rwtrail.disk.track = st->ntrak -1;
409: dcb->trail.rwtrail.disk.sector = 0;
410: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
411: POLLTILLDONE(3)
412: if ( (dcb->operrsta & HRDERR) == 0)
413: /* found the drive type! */
414: break;
415: }
416: if (dsktype < 0) {
417: /* If reached here, a drive which is not defined in the
418: * 'vdst' tables is connected. Cannot set it's type.
419: */
420: printf("VDDC error, unrecognized drive type, drive %d\n",ui->ui_slave);
421: return(0);
422: }
423: ui->ui_type = dsktype;
424: vddriver.ud_dname = st->name;
425: return(1);
426: }
427:
428: vdattach(ui)
429: struct vba_device *ui;
430: {
431: }
432:
433: vddgo(um)
434: struct vba_ctlr *um;
435: {
436: }
437:
438: #define b_cylin b_resid
439:
440: vdstrategy(bp)
441: register struct buf *bp;
442: {
443: register struct vba_device *ui;
444: register struct vba_ctlr *um;
445: register int unit;
446: register struct buf *dp;
447: register struct size *sizep;
448: int index, blocks, s;
449:
450: vdintflg = 1; /* enable interrupts handling by the driver */
451: blocks = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
452: if (bp->b_bcount > NBPG*MAXBPTE) {
453: printf ("VDDC I/O length error: %d\n", bp->b_bcount);
454: goto bad1;
455: }
456: unit = VDUNIT(bp->b_dev);
457: ui = vddinfo[unit];
458: if (ui == 0 || ui->ui_alive == 0) goto bad1;
459: index = FLSYS(bp->b_dev); /* get file system index */
460: sizep = vdst[ui->ui_type].sizes;
461: if (bp->b_blkno < 0 ||
462: (dkblock(bp)+blocks > sizep[index].nblocks)) /* disk overflow */
463: goto bad1;
464: s = spl8();
465: dp = &vdutab[ui->ui_unit];
466: bp->b_resid = bp->b_blkno ; /* block # plays same role as
467: cylinder # for disksort, as long
468: as increasing blocks correspond to
469: increasing cylinders on disk */
470:
471: disksort(dp, bp);
472: if (dp->b_active == 0) { /* unit is on controller queue */
473: /* put the device on the controller queue */
474: dp->b_forw = NULL; /* end of queue indicator */
475: um = ui->ui_mi; /* get controller structure !! */
476: if (um->um_tab.b_actf == NULL) /* controller queue is empty */
477: um->um_tab.b_actf = dp;
478: else
479: um->um_tab.b_actl->b_forw = dp; /* add into queue */
480: um->um_tab.b_actl = dp; /* update queue tail */
481: dp->b_active ++;
482: }
483: bp = &ui->ui_mi->um_tab; /* controller structure addr */
484: if (bp->b_actf && /* cntrl queue not empty */
485: bp->b_active == 0) /* controller not active */
486: (void) vdstart(ui->ui_mi);/* go start I/O */
487: splx(s);
488: return;
489:
490: bad1:
491: bp->b_flags |= B_ERROR;
492: iodone(bp);
493: return;
494: }
495:
496:
497: /*
498: * Start up a transfer on a drive.
499: */
500: vdstart(um)
501: register struct vba_ctlr *um;
502: {
503: register struct buf *bp, *dp;
504: register struct fmt_dcb *dcb = &dcbx[um->um_ctlr];
505: struct size *sizep; /* Pointer to one of the tables */
506: register struct vdst *st;
507: register int index ; /* Index in the relevant table */
508: register int phadr; /* Buffer's physical address */
509: register caddr_t cntrl_vaddr = um->um_addr;
510: register struct proc *this_proc;
511: register long phaddr, vaddr, length, i;
512: register long *longp;
513: int sblock, unit;
514:
515: loop:
516: /*
517: * Pull a request off the controller queue
518: */
519: if ((dp = um->um_tab.b_actf) == NULL)
520: return ;
521: if ((bp = dp->b_actf) == NULL) {
522: dp->b_active = 0; /* device removed from ctlr queue */
523: um->um_tab.b_actf = dp->b_forw;
524: goto loop;
525: }
526: /*
527: * Mark controller busy, and
528: * prepare a command packet for the controller.
529: */
530: um->um_tab.b_active++;
531: unit = VDUNIT(bp->b_dev);
532: st = &vdst[vddinfo[unit]->ui_type];
533: index = FLSYS(bp->b_dev);
534: sizep = st->sizes;
535: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
536: dcb->intflg = INTDUN; /* interrupt on completion */
537:
538: dcb->operrsta = 0;
539: dcb->devselect = VDUNIT(bp->b_dev);
540: sblock = sizep[index].block0 + bp->b_blkno;
541: dcb->trail.rwtrail.disk.cylinder = (short)(sblock / st->nspc);
542: dcb->trail.rwtrail.disk.track=(char)((sblock % st->nspc) / st->nsect);
543: dcb->trail.rwtrail.disk.sector = (char)(sblock*2 % (st->nsect*2));
544: if (bp->b_flags & B_DIRTY || bp->b_proc==0) this_proc = &proc[2];
545: else this_proc = bp->b_proc;
546: phaddr = vtoph(this_proc, bp->b_un.b_addr); /* start addresses */
547: vaddr = (int)bp->b_un.b_addr;
548: length = (bp->b_bcount+1) & ~1; /* total # of bytes */
549: printf("\nvaddr=%x length=%x\n", vaddr, length);
550: dcb->trail.rwtrail.memadr = (char *)phaddr; /* default trailer */
551: printf("%x ", dcb->trail.rwtrail.memadr);
552: i = imin ( NBPG-(phaddr&PGOFSET),length); /* bytes in this page */
553: dcb->trail.rwtrail.wcount = i/2;
554: if (i != 0x400) printf("/%x ", i/2);
555: dcb->trailcnt = 3;
556: /*
557: * If all required bytes fit into one page frame, that's it.
558: * Otherwise we have to generate a scatter/gather trailer.
559: */
560: length -= i;
561: vaddr += i;
562: longp = dcb->trail.rwtrail.scat; /* 1'st pair address */
563: while (length > 0) {
564: i = imin ( NBPG-(phaddr&PGOFSET),length);
565: *longp++ = i/2;
566: *longp++ = vtoph (this_proc, vaddr);
567: vaddr += i;
568: length -= i;
569: dcb->trailcnt += 2;
570: }
571: *longp++ = 0; /* End of list */
572: *longp = 0; /* End of list */
573: /***********
574: dcb->trailcnt +=2 ;
575: ***********/
576: if (bp->b_flags & B_READ) { /* Read or read&scatter */
577: if (dcb->trailcnt == 3) dcb->opcode = RD;
578: else dcb->opcode = RAS;
579: } else { /* Write or gather&write */
580: if (dcb->trailcnt == 3) dcb->opcode = WD;
581: else dcb->opcode = GAW;
582: }
583: while (longp >= (long *)dcb)
584: printf("%x\n", *longp--);
585:
586: #ifdef VDDCPERF
587: scope_out(1);
588: #endif
589:
590: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb)) /* do it */
591: }
592:
593:
594: /*
595: * Handle a disk interrupt.
596: */
597: vdintr(vdnum)
598: register vdnum;
599: {
600: register struct buf *bp, *dp;
601: register struct vba_ctlr *um = vdminfo[vdnum];
602: register struct fmt_dcb *dcb = &dcbx[vdnum];
603: register int cnt;
604:
605: #ifdef VDDCPERF
606: scope_out(2);
607: #endif
608: printf("vddc 1\n");
609: if (intenable == 0 || vdintflg == 0) /* ignore all interrupts */
610: return;
611: if (um->um_tab.b_active == NULL) return;/* unexpected interrupt */
612: uncache((char *)&mdcb->intdcb);
613: uncache((char *)&dcb->operrsta);
614: if ( mdcb->intdcb != (struct fmt_dcb *)PHYS(dcb)) { /* dcb causing interrupt */
615: printf("VDDC error - dcb causing interrupt (%x) is different from expected dcb (%x) Interrupt ignored\n", mdcb->intdcb,dcb);
616: return;
617: }
618: if (! (dcb->operrsta & DCBCMP)) { /* unexpected interrupt */
619: printf("VDDC Unexpected interrupt, DCB completed not set. Status = %x\n",dcb->operrsta);
620: return;
621: }
622: dp = um->um_tab.b_actf; /* device queue head in ctlr queue */
623: bp = dp->b_actf; /* first buffer in device queue */
624: if (dcb->operrsta & HRDERR) {
625: printf("VDDC hard error - dcb status = %x\n",dcb->operrsta);
626: bp->b_flags |= B_ERROR;
627: }
628: else if (dcb->operrsta & SFTERR)
629: printf("Soft error on VDDC,status = %x, dev=%x, block # %d\n",
630: dcb->operrsta, bp->b_dev, bp->b_blkno);
631:
632: /*
633: * If this was a read, we have to purge the data cache for the
634: * rigth virtual pages. It could be nice to just change the
635: * relevant process's data key but this key is in PCB, in _u,
636: * which can be on the disk right now. And besides, what about
637: * reads into the system space? There's no key to change there.
638: */
639: if (bp->b_flags & B_READ) {
640: printf("vddc 2\n");
641: if (dcb->opcode == RAS) { /* Multiple pages read */
642: printf("vddc 3\n");
643: for (cnt=bp->b_bcount; cnt>=0; cnt -= NBPG)
644: mtpr ((caddr_t)bp->b_un.b_addr+cnt-1, P1DC);
645: if ( ((int)bp->b_un.b_addr & PGOFSET) != 0 )
646: mtpr ((caddr_t)bp->b_un.b_addr, P1DC);
647: } else { /* Only one page read */
648: mtpr ((caddr_t)bp->b_un.b_addr, P1DC);
649: printf("vddc 4\n");
650: }
651: }
652:
653: um->um_tab.b_active = 0;
654: um->um_tab.b_errcnt = 0;
655: if (dp->b_forw != NULL) { /* more than 1 unit on queue */
656: um->um_tab.b_actf = dp->b_forw; /* next device on ctlr queue */
657: dp->b_forw = um->um_tab.b_actl->b_forw; /* be last in queue */
658: um->um_tab.b_actl->b_forw = dp; /* last points now to dp */
659: um->um_tab.b_actl = dp; /* pointer in ctlr structure */
660: }
661: dp->b_errcnt = 0;
662: dp->b_actf = bp->av_forw; /* remove first from queue */
663: bp->b_resid = 0; /* All data read here */
664:
665: #ifdef VDDCPERF
666: scope_out(3);
667: #endif
668:
669: printf("vddc 5\n");
670: iodone(bp);
671: printf("vddc 6\n");
672: vdstart(um); /* start requests for next device on queue */
673: printf("vddc 7\n");
674: }
675:
676:
677: vdread(dev, uio)
678: dev_t dev;
679: struct uio *uio;
680: {
681: register int unit = VDUNIT(dev);
682: register int error;
683:
684: if (unit >= NUNIT) return ( ENXIO );
685: else return
686: (physio(vdstrategy, &rvdbuf[unit], dev, B_READ, minphys, uio));
687: }
688:
689: vdwrite(dev, uio)
690: dev_t dev;
691: struct uio *uio;
692: {
693: register int unit = VDUNIT(dev);
694: register int error;
695:
696: if (unit >= NUNIT) return (ENXIO);
697: else return
698: (physio(vdstrategy, &rvdbuf[unit], dev, B_WRITE,minphys, uio));
699: }
700:
701: #define DUMPSIZE 32 /* Up to 32k at a time - controller limit */
702:
703: vddump(dev)
704: dev_t dev;
705: /*
706: * Dump the main memory to the given device.
707: */
708: {
709: register struct vba_ctlr *um;
710: register struct fmt_dcb *dcb = &dcbx[0];
711: register struct vdst *st;
712: register int unit;
713: register caddr_t cntrl_vaddr ;
714: register struct size *sizep; /* Pointer to one of the tables */
715: int index,sblock,blkcount,thiscount;
716: int memaddr;
717:
718: unit = VDUNIT(dev);
719: um = (vddinfo[unit])->ui_mi;
720: st = &vdst[(vddinfo[unit])->ui_type];
721: dcb = &dcbx[um->um_ctlr];
722: cntrl_vaddr = um->um_addr;
723: memaddr = 0x0;
724: index = FLSYS(dev);
725: sizep = st->sizes;
726: blkcount = maxfree - 2; /* In 1k byte pages */
727: if (dumplo + blkcount > sizep[index].nblocks) return(EINVAL);
728: sblock = sizep[index].block0 + dumplo;
729: while (blkcount > 0) {
730: thiscount = MIN (blkcount, DUMPSIZE);
731: mdcb->firstdcb = (struct fmt_dcb *)PHYS(dcb);
732: dcb->intflg = NOINT;
733: dcb->opcode = WD;
734: dcb->operrsta = 0;
735: dcb->devselect = unit;
736: dcb->trailcnt = (char)3;
737: dcb->trail.rwtrail.memadr = (char *)memaddr;
738: dcb->trail.rwtrail.wcount = thiscount*512;
739: dcb->trail.rwtrail.disk.cylinder= (short)(sblock/st->nspc);
740: dcb->trail.rwtrail.disk.track = (char)((sblock % st->nspc)
741: / st->nsect);
742: dcb->trail.rwtrail.disk.sector = (char)(sblock*2 % (st->nsect*2));
743: VDDC_ATTENTION(cntrl_vaddr,PHYS(mdcb) ) /* do it */
744: POLLTILLDONE(5);
745: if (dcb->operrsta & HRDERR) {
746: if (vddebug)
747: printf("VDDC DUMP error. Status = %x\n",
748: dcb->operrsta);
749: return(EIO);
750: };
751: blkcount -= thiscount;
752: memaddr += thiscount*NBPG;
753: sblock += thiscount;
754: }
755: return(0);
756: }
757:
758: vdopen(dev, flag)
759: register dev_t dev;
760: int flag;
761: {
762: register struct vba_device *ui;
763: register unit = VDUNIT(dev);
764:
765: ui = vddinfo[unit];
766: if (ui == 0 || ui->ui_alive == 0 || ui->ui_type >= NVDDRV)
767: return ENXIO;
768: return 0;
769: }
770:
771: vdsize(dev)
772: register dev_t dev;
773: {
774: register struct vba_device *ui;
775: register unit = VDUNIT(dev);
776:
777: ui = vddinfo[unit];
778: if (ui == 0 || ui->ui_alive == 0 || ui->ui_type >= NVDDRV)
779: return -1;
780: return vdst[ui->ui_type].sizes[FLSYS(dev)].nblocks;
781: }
782: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.