![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uda.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba|
Return to uda.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vaxuba |
1.1 root 1: /*
2: * @(#)uda.c 7.1 (Berkeley) 6/5/86
3: */
4:
5: /************************************************************************
6: * *
7: * Copyright (c) 1983 by *
8: * Digital Equipment Corporation, Maynard, MA *
9: * All rights reserved. *
10: * *
11: ************************************************************************/
12: /*
13: * uda.c - UDA50A Driver
14: *
15: * decvax!rich
16: */
17:
18: #define DEBUG
19: #define UDADEVNUM (9) /* entry in bdevsw */
20: #include "ra.h"
21: #if NUDA > 0
22: /*
23: * UDA50/RAxx disk device driver
24: *
25: * Restrictions:
26: * Unit numbers must be less than 8.
27: */
28: #include "../machine/pte.h"
29:
30: #include "param.h"
31: #include "systm.h"
32: #include "buf.h"
33: #include "conf.h"
34: #include "dir.h"
35: #include "user.h"
36: #include "map.h"
37: #include "vm.h"
38: #include "dk.h"
39: #include "cmap.h"
40: #include "uio.h"
41:
42: #include "../vax/cpu.h"
43: #include "ubareg.h"
44: #include "ubavar.h"
45: #include "../vax/mtpr.h"
46:
47: #define TENSEC (1000)
48:
49: #define NRSPL2 3 /* log2 number of response packets */
50: #define NCMDL2 3 /* log2 number of command packets */
51: #define NRSP (1<<NRSPL2)
52: #define NCMD (1<<NCMDL2)
53: #define UDABURST 4 /* default for DMA burst size */
54:
55: #include "../vaxuba/udareg.h"
56: #include "../vax/mscp.h"
57:
58:
59: struct uda_softc {
60: short sc_state; /* state of controller */
61: short sc_mapped; /* Unibus map allocated for uda struct? */
62: int sc_ubainfo; /* Unibus mapping info */
63: struct uda *sc_uda; /* Unibus address of uda struct */
64: int sc_ivec; /* interrupt vector address */
65: short sc_credits; /* transfer credits */
66: short sc_lastcmd; /* pointer into command ring */
67: short sc_lastrsp; /* pointer into response ring */
68: } uda_softc[NUDA];
69: struct uda {
70: struct udaca uda_ca; /* communications area */
71: struct mscp uda_rsp[NRSP]; /* response packets */
72: struct mscp uda_cmd[NCMD]; /* command packets */
73: } uda[NUDA];
74:
75: #define udunit(dev) (minor(dev) >> 3)
76:
77: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
78: struct size {
79: daddr_t nblocks;
80: daddr_t blkoff;
81: } ra25_sizes[8] = {
82: 15884, 0, /* A=blk 0 thru 15883 */
83: 10032, 15884, /* B=blk 15884 thru 49323 */
84: -1, 0, /* C=blk 0 thru end */
85: 0, 0, /* D=blk 340670 thru 356553 */
86: 0, 0, /* E=blk 356554 thru 412489 */
87: 0, 0, /* F=blk 412490 thru end */
88: -1, 25916, /* G=blk 49324 thru 131403 */
89: 0, 0, /* H=blk 131404 thru end */
90: }, rd52_sizes[8] = {
91: 15884, 0, /* A=blk 0 thru 15883 */
92: 9766, 15884, /* B=blk 15884 thru 25649 */
93: -1, 0, /* C=blk 0 thru end */
94: 0, 0, /* D=unused */
95: 0, 0, /* E=unused */
96: 0, 0, /* F=unused */
97: -1, 25650, /* G=blk 25650 thru end */
98: 0, 0, /* H=unused */
99: }, rd53_sizes[8] = {
100: 15884, 0, /* A=blk 0 thru 15883 */
101: 33440, 15884, /* B=blk 15884 thru 49323 */
102: -1, 0, /* C=blk 0 thru end */
103: 0, 0, /* D=unused */
104: 33440, 0, /* E=blk 0 thru 33439 */
105: -1, 33440, /* F=blk 33440 thru end */
106: -1, 49324, /* G=blk 49324 thru end */
107: -1, 15884, /* H=blk 15884 thru end */
108: }, ra60_sizes[8] = {
109: 15884, 0, /* A=sectors 0 thru 15883 */
110: 33440, 15884, /* B=sectors 15884 thru 49323 */
111: 400176, 0, /* C=sectors 0 thru 400175 */
112: 82080, 49324, /* 4.2 G => D=sectors 49324 thru 131403 */
113: 268772, 131404, /* 4.2 H => E=sectors 131404 thru 400175 */
114: 350852, 49324, /* F=sectors 49324 thru 400175 */
115: 157570, 242606, /* UCB G => G=sectors 242606 thru 400175 */
116: 193282, 49324, /* UCB H => H=sectors 49324 thru 242605 */
117: }, ra80_sizes[8] = {
118: 15884, 0, /* A=sectors 0 thru 15883 */
119: 33440, 15884, /* B=sectors 15884 thru 49323 */
120: 242606, 0, /* C=sectors 0 thru 242605 */
121: 0, 0, /* D=unused */
122: 193282, 49324, /* UCB H => E=sectors 49324 thru 242605 */
123: 82080, 49324, /* 4.2 G => F=sectors 49324 thru 131403 */
124: 192696, 49910, /* G=sectors 49910 thru 242605 */
125: 111202, 131404, /* 4.2 H => H=sectors 131404 thru 242605 */
126: }, ra81_sizes[8] ={
127: /*
128: * These are the new standard partition sizes for ra81's.
129: * An RA_COMPAT system is compiled with D, E, and F corresponding
130: * to the 4.2 partitions for G, H, and F respectively.
131: */
132: #ifndef UCBRA
133: 15884, 0, /* A=sectors 0 thru 15883 */
134: 66880, 16422, /* B=sectors 16422 thru 83301 */
135: 891072, 0, /* C=sectors 0 thru 891071 */
136: #ifdef RA_COMPAT
137: 82080, 49324, /* 4.2 G => D=sectors 49324 thru 131403 */
138: 759668, 131404, /* 4.2 H => E=sectors 131404 thru 891071 */
139: 478582, 412490, /* 4.2 F => F=sectors 412490 thru 891071 */
140: #else
141: 15884, 375564, /* D=sectors 375564 thru 391447 */
142: 307200, 391986, /* E=sectors 391986 thru 699185 */
143: 191352, 699720, /* F=sectors 699720 thru 891071 */
144: #endif RA_COMPAT
145: 515508, 375564, /* G=sectors 375564 thru 891071 */
146: 291346, 83538, /* H=sectors 83538 thru 374883 */
147:
148: /*
149: * These partitions correspond to the sizes used by sites at Berkeley,
150: * and by those sites that have received copies of the Berkeley driver
151: * with deltas 6.2 or greater (11/15/83).
152: */
153: #else UCBRA
154:
155: 15884, 0, /* A=sectors 0 thru 15883 */
156: 33440, 15884, /* B=sectors 15884 thru 49323 */
157: 891072, 0, /* C=sectors 0 thru 891071 */
158: 15884, 242606, /* D=sectors 242606 thru 258489 */
159: 307200, 258490, /* E=sectors 258490 thru 565689 */
160: 325382, 565690, /* F=sectors 565690 thru 891071 */
161: 648466, 242606, /* G=sectors 242606 thru 891071 */
162: 193282, 49324, /* H=sectors 49324 thru 242605 */
163:
164: #endif UCBRA
165: };
166:
167: struct ra_info {
168: struct size *ra_sizes; /* Partion tables for drive */
169: daddr_t radsize; /* Max user size form online pkt */
170: unsigned ratype; /* Drive type int field */
171: unsigned rastatus; /* Command status from */
172: /* last onlin or GTUNT */
173: } ra_info[NRA];
174:
175:
176: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
177: struct uba_ctlr *udminfo[NUDA];
178: struct uba_device *uddinfo[NRA];
179: struct uba_device *udip[NUDA][8]; /* 8 == max number of drives */
180: struct buf rudbuf[NRA];
181: struct buf udutab[NRA];
182: struct buf udwtab[NUDA]; /* I/O wait queue, per controller */
183:
184:
185: int udamicro[NUDA]; /* to store microcode level */
186: int udaburst[NUDA] = { 0 }; /* DMA burst size, 0 is default */
187:
188:
189: /*
190: * Controller states
191: */
192: #define S_IDLE 0 /* hasn't been initialized */
193: #define S_STEP1 1 /* doing step 1 init */
194: #define S_STEP2 2 /* doing step 2 init */
195: #define S_STEP3 3 /* doing step 3 init */
196: #define S_SCHAR 4 /* doing "set controller characteristics" */
197: #define S_RUN 5 /* running */
198:
199:
200: int udaerror = 0; /* causes hex dump of packets */
201: int udadebug = 0;
202: int uda_cp_wait = 0; /* Something to wait on for command */
203: /* packets and or credits. */
204: int wakeup();
205: extern int hz; /* Should find the right include */
206: #ifdef DEBUG
207: #define printd if (udadebug) printf
208: #define printd10 if(udadebug >= 10) printf
209: #endif
210: #define mprintf printf /* temporary JG hack until Rich fixes*/
211:
212: int udprobe(), udslave(), udattach(), udintr();
213: struct mscp *udgetcp();
214:
215: u_short udstd[] = { 0772150, 0772550, 0777550, 0 };
216: struct uba_driver udadriver =
217: { udprobe, udslave, udattach, 0, udstd, "ra", uddinfo, "uda", udminfo, 0 };
218:
219: #define b_qsize b_resid /* queue size per drive, in udutab */
220: #define b_ubinfo b_resid /* Unibus mapping info, per buffer */
221:
222: udprobe(reg, ctlr)
223: caddr_t reg;
224: int ctlr;
225: {
226: register int br, cvec;
227: register struct uda_softc *sc = &uda_softc[ctlr];
228: struct udadevice *udaddr;
229:
230: int cur_time;
231:
232: #ifdef lint
233: br = 0; cvec = br; br = cvec;
234: udreset(0); udintr(0);
235: #endif
236: udaddr = (struct udadevice *) reg;
237:
238: sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4);
239: #if VAX630
240: if (cpu == VAX_630) {
241: br = 0x15;
242: cvec = sc->sc_ivec;
243: return(sizeof (struct udadevice));
244: }
245: #endif
246: udaddr->udaip = 0; /* start initialization */
247:
248: cur_time = mfpr(TODR); /* Time of day */
249: while(cur_time + TENSEC > mfpr(TODR)){ /* wait for at most 10 secs */
250: if((udaddr->udasa & UDA_STEP1) != 0)
251: break;
252: }
253: if(cur_time + TENSEC <= mfpr(TODR))
254: return(0); /* Not a uda or it won't init as it */
255: /* should within ten seconds. */
256: udaddr->udasa=UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4);
257: while((udaddr->udasa&UDA_STEP2)==0)
258: DELAY(1000); /* intr should have */
259: /* have happened by now */
260:
261: return(sizeof (struct udadevice));
262: }
263:
264: /* ARGSUSED */
265: udslave(ui, reg)
266: struct uba_device *ui;
267: caddr_t reg;
268: {
269: register struct uba_ctlr *um = udminfo[ui->ui_ctlr];
270: register struct uda_softc *sc = &uda_softc[ui->ui_ctlr];
271: struct udadevice *udaddr;
272: struct mscp *mp;
273: int i; /* Something to write into to start */
274: /* the uda polling */
275:
276:
277: udaddr = (struct udadevice *)um->um_addr;
278: if(sc->sc_state != S_RUN){
279: if(!udinit(ui->ui_ctlr))
280: return(0);
281: }
282: /* Here we will wait for the controller */
283: /* to come into the run state or go idle. If we go idle we are in */
284: /* touble and I don't yet know what to do so I will punt */
285: while(sc->sc_state != S_RUN && sc->sc_state != S_IDLE); /* spin */
286: if(sc->sc_state == S_IDLE){ /* The Uda failed to initialize */
287: printf("UDA failed to init\n");
288: return(0);
289: }
290: /* The controller is up so let see if the drive is there! */
291: if(0 == (mp = udgetcp(um))){ /* ditto */
292: printf("UDA can't get command packet\n");
293: return(0);
294: }
295: mp->mscp_opcode = M_OP_GTUNT; /* This should give us the drive type*/
296: mp->mscp_unit = ui->ui_slave;
297: mp->mscp_cmdref = (long) ui->ui_slave;
298: #ifdef DEBUG
299: printd("uda%d Get unit status slave %d\n",ui->ui_ctlr,ui->ui_slave);
300: #endif
301: ra_info[ui->ui_unit].rastatus = 0; /* set to zero */
302: udip[ui->ui_ctlr][ui->ui_slave] = ui;
303: *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT;/* maybe we should poll*/
304: i = udaddr->udaip;
305: #ifdef lint
306: i = i;
307: #endif
308: while(!ra_info[ui->ui_unit].rastatus); /* Wait for some status */
309: udip[ui->ui_ctlr][ui->ui_slave] = 0;
310: if(!ra_info[ui->ui_unit].ratype) /* packet from a GTUNT */
311: return(0); /* Failed No such drive */
312: else
313: return(1); /* Got it and it is there */
314: }
315:
316: udattach(ui)
317: register struct uba_device *ui;
318: {
319: register struct uba_ctlr *um = ui->ui_mi ;
320: struct udadevice *udaddr = (struct udadevice *) um->um_addr;
321: struct mscp *mp;
322: int i; /* Something to write into to start */
323: /* the uda polling */
324: if (ui->ui_dk >= 0)
325: dk_mspw[ui->ui_dk] = 1.0 / (60 * 31 * 256); /* approx */
326: ui->ui_flags = 0;
327: udip[ui->ui_ctlr][ui->ui_slave] = ui;
328: /* check to see if the drive is a available if it is bring it online */
329: /* if not then just return. open will try an online later */
330: if(ra_info[ui->ui_unit].rastatus != M_ST_AVLBL)
331: return; /* status was set by a GTUNT */
332: if(0 == (mp = udgetcp(um))){ /* ditto */
333: printf("UDA can't get command packet\n");
334: return;
335: }
336: mp->mscp_opcode = M_OP_ONLIN;
337: mp->mscp_unit = ui->ui_slave;
338: mp->mscp_cmdref = (long) ui->ui_slave;
339: #ifdef DEBUG
340: printd("uda%d ONLIN slave %d\n",ui->ui_ctlr,ui->ui_slave);
341: #endif
342: *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT;
343: i = udaddr->udaip;
344: #ifdef lint
345: i = i;
346: #endif
347: while(ui->ui_flags == 0 && ra_info[ui->ui_unit].ratype != 0);
348: }
349:
350: /*
351: * Open a UDA. Initialize the device and
352: * set the unit online.
353: */
354: /* ARGSUSED */
355: udopen(dev, flag)
356: dev_t dev;
357: int flag;
358: {
359: register int unit;
360: register struct uba_device *ui;
361: register struct uda_softc *sc;
362: register struct mscp *mp;
363: register struct uba_ctlr *um;
364: struct udadevice *udaddr;
365: int s,i;
366:
367: unit = udunit(dev);
368: if (unit >= NRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0)
369: return (ENXIO);
370: sc = &uda_softc[ui->ui_ctlr];
371: s = spl5();
372: if (sc->sc_state != S_RUN) {
373: if (sc->sc_state == S_IDLE)
374: if(!udinit(ui->ui_ctlr)){
375: printf("uda: Controller failed to init\n");
376: (void) splx(s);
377: return(ENXIO);
378: }
379: /* wait for initialization to complete */
380: timeout(wakeup,(caddr_t)ui->ui_mi,11*hz); /* to be sure*/
381: sleep((caddr_t)ui->ui_mi, 0);
382: if (sc->sc_state != S_RUN)
383: {
384: (void) splx(s); /* added by Rich */
385: return (EIO);
386: }
387: }
388: /* check to see if the device is really there. */
389: /* this code was taken from Fred Canters 11 driver */
390: um = ui->ui_mi;
391: udaddr = (struct udadevice *) um->um_addr;
392: (void) splx(s);
393: if(ui->ui_flags == 0){
394: s = spl5();
395: while(0 ==(mp = udgetcp(um))){
396: uda_cp_wait++;
397: sleep((caddr_t)&uda_cp_wait,PSWP+1);
398: uda_cp_wait--;
399: }
400: mp->mscp_opcode = M_OP_ONLIN;
401: mp->mscp_unit = ui->ui_slave;
402: mp->mscp_cmdref = (long) & ra_info[ui->ui_unit].ratype;
403: /* need to sleep on something */
404: #ifdef DEBUG
405: printd("uda: bring unit %d online\n",ui->ui_unit);
406: #endif
407: *((long *) mp->mscp_dscptr ) |= UDA_OWN | UDA_INT ;
408: i = udaddr->udaip;
409: #ifdef lint
410: i = i;
411: #endif
412: timeout(wakeup,(caddr_t) mp->mscp_cmdref,10 * hz);
413: /* make sure we wake up */
414: sleep((caddr_t) mp->mscp_cmdref,PSWP+1); /*wakeup in udrsp() */
415: (void) splx(s);
416: }
417: if(ui->ui_flags == 0){
418: return(ENXIO); /* Didn't go online */
419: }
420: return (0);
421: }
422:
423: /*
424: * Initialize a UDA. Set up UBA mapping registers,
425: * initialize data structures, and start hardware
426: * initialization sequence.
427: */
428: udinit(d)
429: int d;
430: {
431: register struct uda_softc *sc;
432: register struct uda *ud;
433: struct udadevice *udaddr;
434: struct uba_ctlr *um;
435:
436: sc = &uda_softc[d];
437: um = udminfo[d];
438: um->um_tab.b_active++;
439: ud = &uda[d];
440: udaddr = (struct udadevice *)um->um_addr;
441: if (sc->sc_mapped == 0) {
442: /*
443: * Map the communications area and command
444: * and response packets into Unibus address
445: * space.
446: */
447: sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)ud,
448: sizeof (struct uda), 0);
449: sc->sc_uda = (struct uda *)(sc->sc_ubainfo & 0x3ffff);
450: sc->sc_mapped = 1;
451: }
452:
453: /*
454: * Start the hardware initialization sequence.
455: */
456:
457: if (udaburst[d] == 0)
458: udaburst[d] = UDABURST;
459: udaddr->udaip = 0; /* start initialization */
460:
461: while((udaddr->udasa & UDA_STEP1) == 0){
462: if(udaddr->udasa & UDA_ERR)
463: return(0); /* CHECK */
464: }
465: udaddr->udasa=UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4);
466: /*
467: * Initialization continues in interrupt routine.
468: */
469: sc->sc_state = S_STEP1;
470: sc->sc_credits = 0;
471: return(1);
472: }
473:
474: udstrategy(bp)
475: register struct buf *bp;
476: {
477: register struct uba_device *ui;
478: register struct uba_ctlr *um;
479: register struct buf *dp;
480: register int unit;
481: register struct size *rasizes;
482: int xunit = minor(bp->b_dev) & 07;
483: daddr_t sz, maxsz;
484: int s;
485:
486: sz = (bp->b_bcount+511) >> 9;
487: unit = udunit(bp->b_dev);
488: if (unit >= NRA) {
489: bp->b_error = ENXIO;
490: goto bad;
491: }
492: rasizes = ra_info[unit].ra_sizes;
493: ui = uddinfo[unit];
494: um = ui->ui_mi;
495: if (ui == 0 || ui->ui_alive == 0) {
496: bp->b_error = ENXIO;
497: goto bad;
498: }
499: if ((maxsz = rasizes[xunit].nblocks) < 0)
500: maxsz = ra_info[unit].radsize - rasizes[xunit].blkoff;
501: if (bp->b_blkno < 0 || bp->b_blkno+sz > maxsz ||
502: rasizes[xunit].blkoff >= ra_info[unit].radsize) {
503: if (bp->b_blkno == maxsz) {
504: bp->b_resid = bp->b_bcount;
505: goto done;
506: }
507: bp->b_error = EINVAL;
508: goto bad;
509: }
510: s = spl5();
511: /*
512: * Link the buffer onto the drive queue
513: */
514: dp = &udutab[ui->ui_unit];
515: if (dp->b_actf == 0)
516: dp->b_actf = bp;
517: else
518: dp->b_actl->av_forw = bp;
519: dp->b_actl = bp;
520: bp->av_forw = 0;
521: /*
522: * Link the drive onto the controller queue
523: */
524: if (dp->b_active == 0) {
525: dp->b_forw = NULL;
526: if (um->um_tab.b_actf == NULL)
527: um->um_tab.b_actf = dp;
528: else
529: um->um_tab.b_actl->b_forw = dp;
530: um->um_tab.b_actl = dp;
531: dp->b_active = 1;
532: }
533: if (um->um_tab.b_active == 0) {
534: #if defined(VAX750)
535: if (cpu == VAX_750
536: && udwtab[um->um_ctlr].av_forw == &udwtab[um->um_ctlr]) {
537: if (um->um_ubinfo != 0) {
538: printd("udastrat: ubinfo 0x%x\n",um->um_ubinfo);
539: } else
540: um->um_ubinfo =
541: uballoc(um->um_ubanum, (caddr_t)0, 0,
542: UBA_NEEDBDP);
543: }
544: #endif
545: (void) udstart(um);
546: }
547: splx(s);
548: return;
549:
550: bad:
551: bp->b_flags |= B_ERROR;
552: done:
553: iodone(bp);
554: return;
555: }
556:
557: udstart(um)
558: register struct uba_ctlr *um;
559: {
560: register struct buf *bp, *dp;
561: register struct mscp *mp;
562: register struct uda_softc *sc;
563: register struct uba_device *ui;
564: struct size *rasizes;
565: struct udadevice *udaddr;
566: struct uda *ud = &uda[um->um_ctlr];
567: int i;
568:
569: sc = &uda_softc[um->um_ctlr];
570:
571: loop:
572: if ((dp = um->um_tab.b_actf) == NULL) {
573: /*
574: * Release uneeded UBA resources and return
575: */
576: um->um_tab.b_active = 0;
577: /* Check for response ring transitions lost in the
578: * Race condition
579: */
580: for (i = sc->sc_lastrsp;; i++) {
581: i %= NRSP;
582: if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN)
583: break;
584: udrsp(um, ud, sc, i);
585: ud->uda_ca.ca_rspdsc[i] |= UDA_OWN;
586: }
587: sc->sc_lastrsp = i;
588: return (0);
589: }
590: if ((bp = dp->b_actf) == NULL) {
591: /*
592: * No more requests for this drive, remove
593: * from controller queue and look at next drive.
594: * We know we're at the head of the controller queue.
595: */
596: dp->b_active = 0;
597: um->um_tab.b_actf = dp->b_forw;
598: goto loop; /* Need to check for loop */
599: }
600: um->um_tab.b_active++;
601: udaddr = (struct udadevice *)um->um_addr;
602: if ((udaddr->udasa&UDA_ERR) || sc->sc_state != S_RUN) {
603: harderr(bp, "ra");
604: mprintf("Uda%d udasa %o, state %d\n",um->um_ctlr , udaddr->udasa&0xffff, sc->sc_state);
605: (void)udinit(um->um_ctlr);
606: /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE UDRESET */
607: return (0);
608: }
609: ui = uddinfo[udunit(bp->b_dev)];
610: rasizes = ra_info[ui->ui_unit].ra_sizes;
611: if (ui->ui_flags == 0) { /* not online */
612: if ((mp = udgetcp(um)) == NULL){
613: return (0);
614: }
615: mp->mscp_opcode = M_OP_ONLIN;
616: mp->mscp_unit = ui->ui_slave;
617: dp->b_active = 2;
618: um->um_tab.b_actf = dp->b_forw; /* remove from controller q */
619: #ifdef DEBUG
620: printd("uda: bring unit %d online\n", ui->ui_slave);
621: #endif
622: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
623: if (udaddr->udasa&UDA_ERR)
624: printf("Uda (%d) Error (%x)\n",um->um_ctlr , udaddr->udasa&0xffff);
625: i = udaddr->udaip;
626: goto loop;
627: }
628: switch (cpu) {
629: case VAX_8600:
630: case VAX_780:
631: i = UBA_NEEDBDP|UBA_CANTWAIT;
632: break;
633:
634: case VAX_750:
635: i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT;
636: break;
637:
638: case VAX_730:
639: case VAX_630:
640: i = UBA_CANTWAIT;
641: break;
642: }
643: if ((i = ubasetup(um->um_ubanum, bp, i)) == 0)
644: return(1);
645: if ((mp = udgetcp(um)) == NULL) {
646: #if defined(VAX750)
647: if (cpu == VAX_750)
648: i &= 0xfffffff; /* mask off bdp */
649: #endif
650: ubarelse(um->um_ubanum,&i);
651: return(0);
652: }
653: mp->mscp_cmdref = (long)bp; /* pointer to get back */
654: mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE;
655: mp->mscp_unit = ui->ui_slave;
656: mp->mscp_lbn = bp->b_blkno + rasizes[minor(bp->b_dev)&7].blkoff;
657: mp->mscp_bytecnt = bp->b_bcount;
658: mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24);
659: #if defined(VAX750)
660: if (cpu == VAX_750)
661: i &= 0xfffffff; /* mask off bdp */
662: #endif
663: bp->b_ubinfo = i; /* save mapping info */
664: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
665: if (udaddr->udasa&UDA_ERR)
666: printf("Uda(%d) udasa (%x)\n",um->um_ctlr , udaddr->udasa&0xffff);
667: i = udaddr->udaip; /* initiate polling */
668: dp->b_qsize++;
669: if (ui->ui_dk >= 0) {
670: dk_busy |= 1<<ui->ui_dk;
671: dk_xfer[ui->ui_dk]++;
672: dk_wds[ui->ui_dk] += bp->b_bcount>>6;
673: }
674:
675: /*
676: * Move drive to the end of the controller queue
677: */
678: if (dp->b_forw != NULL) {
679: um->um_tab.b_actf = dp->b_forw;
680: um->um_tab.b_actl->b_forw = dp;
681: um->um_tab.b_actl = dp;
682: dp->b_forw = NULL;
683: }
684: /*
685: * Move buffer to I/O wait queue
686: */
687: dp->b_actf = bp->av_forw;
688: dp = &udwtab[um->um_ctlr];
689: bp->av_forw = dp;
690: bp->av_back = dp->av_back;
691: dp->av_back->av_forw = bp;
692: dp->av_back = bp;
693: goto loop;
694: }
695:
696: /*
697: * UDA interrupt routine.
698: */
699: udintr(d)
700: int d;
701: {
702: register struct uba_ctlr *um = udminfo[d];
703: register struct udadevice *udaddr = (struct udadevice *)um->um_addr;
704: struct buf *bp;
705: register int i;
706: register struct uda_softc *sc = &uda_softc[d];
707: register struct uda *ud = &uda[d];
708: struct uda *uud;
709: struct mscp *mp;
710:
711: #ifdef DEBUG
712: printd10("udintr: state %d, udasa %o\n", sc->sc_state, udaddr->udasa);
713: #endif
714: #ifdef VAX630
715: (void) spl5();
716: #endif
717: switch (sc->sc_state) {
718: case S_IDLE:
719: printf("uda%d: random interrupt ignored\n", d);
720: return;
721:
722: case S_STEP1:
723: #define STEP1MASK 0174377
724: #define STEP1GOOD (UDA_STEP2|UDA_IE|(NCMDL2<<3)|NRSPL2)
725: if ((udaddr->udasa&STEP1MASK) != STEP1GOOD) {
726: sc->sc_state = S_IDLE;
727: wakeup((caddr_t)um);
728: return;
729: }
730: udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)|
731: ((cpu == VAX_780) || (cpu == VAX_8600) ? UDA_PI : 0);
732: sc->sc_state = S_STEP2;
733: return;
734:
735: case S_STEP2:
736: #define STEP2MASK 0174377
737: #define STEP2GOOD (UDA_STEP3|UDA_IE|(sc->sc_ivec/4))
738: if ((udaddr->udasa&STEP2MASK) != STEP2GOOD) {
739: sc->sc_state = S_IDLE;
740: wakeup((caddr_t)um);
741: return;
742: }
743: udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)>>16;
744: sc->sc_state = S_STEP3;
745: return;
746:
747: case S_STEP3:
748: #define STEP3MASK 0174000
749: #define STEP3GOOD UDA_STEP4
750: if ((udaddr->udasa&STEP3MASK) != STEP3GOOD) {
751: sc->sc_state = S_IDLE;
752: wakeup((caddr_t)um);
753: return;
754: }
755: udamicro[d] = udaddr->udasa;
756: #ifdef DEBUG
757: printd("Uda%d Version %d model %d\n",d,udamicro[d]&0xF,
758: (udamicro[d]>>4) & 0xF);
759: #endif
760: /*
761: * Requesting the error status (|= 2)
762: * may hang older controllers.
763: */
764: i = UDA_GO | (udaerror? 2 : 0);
765: if (udaburst[d])
766: i |= (udaburst[d] - 1) << 2;
767: udaddr->udasa = i;
768: udaddr->udasa = UDA_GO;
769: sc->sc_state = S_SCHAR;
770:
771: /*
772: * Initialize the data structures.
773: */
774: uud = sc->sc_uda;
775: for (i = 0; i < NRSP; i++) {
776: ud->uda_ca.ca_rspdsc[i] = UDA_OWN|UDA_INT|
777: (long)&uud->uda_rsp[i].mscp_cmdref;
778: ud->uda_rsp[i].mscp_dscptr = &ud->uda_ca.ca_rspdsc[i];
779: ud->uda_rsp[i].mscp_header.uda_msglen = mscp_msglen;
780: }
781: for (i = 0; i < NCMD; i++) {
782: ud->uda_ca.ca_cmddsc[i] = UDA_INT|
783: (long)&uud->uda_cmd[i].mscp_cmdref;
784: ud->uda_cmd[i].mscp_dscptr = &ud->uda_ca.ca_cmddsc[i];
785: ud->uda_cmd[i].mscp_header.uda_msglen = mscp_msglen;
786: }
787: bp = &udwtab[d];
788: bp->av_forw = bp->av_back = bp;
789: sc->sc_lastcmd = 1;
790: sc->sc_lastrsp = 0;
791: mp = &uda[um->um_ctlr].uda_cmd[0];
792: mp->mscp_unit = mp->mscp_modifier = 0;
793: mp->mscp_flags = 0;
794: mp->mscp_bytecnt = mp->mscp_buffer = 0;
795: mp->mscp_errlgfl = mp->mscp_copyspd = 0;
796: mp->mscp_opcode = M_OP_STCON;
797: mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS;
798: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
799: i = udaddr->udaip; /* initiate polling */
800: return;
801:
802: case S_SCHAR:
803: case S_RUN:
804: break;
805:
806: default:
807: printf("uda%d: interrupt in unknown state %d ignored\n",
808: d, sc->sc_state);
809: return;
810: }
811:
812: if (udaddr->udasa&UDA_ERR) {
813: printf("uda(%d): fatal error (%o)\n", d, udaddr->udasa&0xffff);
814: udaddr->udaip = 0;
815: wakeup((caddr_t)um);
816: }
817:
818: /*
819: * Check for a buffer purge request.
820: */
821: if (ud->uda_ca.ca_bdp) {
822: #ifdef DEBUG
823: printd("uda: purge bdp %d\n", ud->uda_ca.ca_bdp);
824: #endif
825: UBAPURGE(um->um_hd->uh_uba, ud->uda_ca.ca_bdp);
826: ud->uda_ca.ca_bdp = 0;
827: udaddr->udasa = 0; /* signal purge complete */
828: }
829:
830: /*
831: * Check for response ring transition.
832: */
833: if (ud->uda_ca.ca_rspint) {
834: ud->uda_ca.ca_rspint = 0;
835: for (i = sc->sc_lastrsp;; i++) {
836: i %= NRSP;
837: if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN)
838: break;
839: udrsp(um, ud, sc, i);
840: ud->uda_ca.ca_rspdsc[i] |= UDA_OWN;
841: }
842: sc->sc_lastrsp = i;
843: }
844:
845: /*
846: * Check for command ring transition.
847: */
848: if (ud->uda_ca.ca_cmdint) {
849: #ifdef DEBUG
850: printd("uda: command ring transition\n");
851: #endif
852: ud->uda_ca.ca_cmdint = 0;
853: }
854: if(uda_cp_wait)
855: wakeup((caddr_t)&uda_cp_wait);
856: (void) udstart(um);
857: }
858:
859: /*
860: * Process a response packet
861: */
862: udrsp(um, ud, sc, i)
863: register struct uba_ctlr *um;
864: register struct uda *ud;
865: register struct uda_softc *sc;
866: int i;
867: {
868: register struct mscp *mp;
869: struct uba_device *ui;
870: struct buf *dp, *bp,nullbp;
871: int st;
872:
873: mp = &ud->uda_rsp[i];
874: mp->mscp_header.uda_msglen = mscp_msglen;
875: sc->sc_credits += mp->mscp_header.uda_credits & 0xf; /* just 4 bits?*/
876: if ((mp->mscp_header.uda_credits & 0xf0) > 0x10) /* Check */
877: return;
878: #ifdef DEBUG
879: printd10("udarsp, opcode 0x%x status 0x%x\n",mp->mscp_opcode,mp->mscp_status);
880: #endif
881: /*
882: * If it's an error log message (datagram),
883: * pass it on for more extensive processing.
884: */
885: if ((mp->mscp_header.uda_credits & 0xf0) == 0x10) { /* check */
886: uderror(um, (struct mslg *)mp);
887: return;
888: }
889: st = mp->mscp_status&M_ST_MASK;
890: /* The controller interrupts as drive 0 */
891: /* this means that you must check for controller interrupts */
892: /* before you check to see if there is a drive 0 */
893: if((M_OP_STCON|M_OP_END) == mp->mscp_opcode){
894: if (st == M_ST_SUCC)
895: sc->sc_state = S_RUN;
896: else
897: sc->sc_state = S_IDLE;
898: um->um_tab.b_active = 0;
899: wakeup((caddr_t)um);
900: return;
901: }
902: if (mp->mscp_unit >= 8)
903: return;
904: if ((ui = udip[um->um_ctlr][mp->mscp_unit]) == 0)
905: return;
906: switch (mp->mscp_opcode) {
907:
908: case M_OP_ONLIN|M_OP_END:
909: ra_info[ui->ui_unit].rastatus = st;
910: ra_info[ui->ui_unit].ratype = mp->mscp_mediaid;
911: dp = &udutab[ui->ui_unit];
912: if (st == M_ST_SUCC) {
913: /*
914: * Link the drive onto the controller queue
915: */
916: dp->b_forw = NULL;
917: if (um->um_tab.b_actf == NULL)
918: um->um_tab.b_actf = dp;
919: else
920: um->um_tab.b_actl->b_forw = dp;
921: um->um_tab.b_actl = dp;
922: ui->ui_flags = 1; /* mark it online */
923: ra_info[ui->ui_unit].radsize=(daddr_t)mp->mscp_untsize;
924: #ifdef DEBUG
925: printd("uda: unit %d online\n", mp->mscp_unit);
926: #endif
927: #define F_to_C(x,i) ( ((x)->mscp_mediaid) >> (i*5+7) & 0x1f ? ( ( (((x)->mscp_mediaid) >>( i*5 + 7)) & 0x1f) + 'A' - 1): ' ')
928: /* this mess decodes the Media type identifier */
929: #ifdef DEBUG
930: printd("uda: unit %d online %x %c%c %c%c%c%d\n"
931: ,mp->mscp_unit, mp->mscp_mediaid
932: ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2)
933: ,F_to_C(mp,1),F_to_C(mp,0)
934: ,mp->mscp_mediaid & 0x7f);
935: #endif
936: switch((int)(mp->mscp_mediaid & 0x7f)){
937: case 25:
938: ra_info[ui->ui_unit].ra_sizes = ra25_sizes;
939: break;
940: case 52:
941: ra_info[ui->ui_unit].ra_sizes = rd52_sizes;
942: break;
943: case 53:
944: ra_info[ui->ui_unit].ra_sizes = rd53_sizes;
945: break;
946: case 60:
947: ra_info[ui->ui_unit].ra_sizes = ra60_sizes;
948: break;
949: case 80:
950: ra_info[ui->ui_unit].ra_sizes = ra80_sizes;
951: break;
952: case 81:
953: ra_info[ui->ui_unit].ra_sizes = ra81_sizes;
954: break;
955: default:
956: ui->ui_flags = 0; /* mark it offline */
957: ra_info[ui->ui_unit].ratype = 0;
958: printf("Don't have a parition table for ");
959: printf("a %c%c %c%c%c%d\n"
960: ,F_to_C(mp,4),F_to_C(mp,3),F_to_C(mp,2)
961: ,F_to_C(mp,1),F_to_C(mp,0)
962: ,mp->mscp_mediaid & 0x7f);
963: while (bp = dp->b_actf) {
964: dp->b_actf = bp->av_forw;
965: bp->b_flags |= B_ERROR;
966: iodone(bp);
967: }
968: }
969: dp->b_active = 1;
970: } else {
971: if(dp->b_actf){
972: harderr(dp->b_actf,"ra");
973: } else {
974: nullbp.b_blkno = 0;
975: nullbp.b_dev = makedev(UDADEVNUM,ui->ui_unit);
976: harderr(&nullbp, "ra");
977: }
978: printf("OFFLINE\n");
979: while (bp = dp->b_actf) {
980: dp->b_actf = bp->av_forw;
981: bp->b_flags |= B_ERROR;
982: iodone(bp);
983: }
984: }
985: if(mp->mscp_cmdref!=NULL){/* Seems to get lost sometimes */
986: wakeup((caddr_t)mp->mscp_cmdref);
987: }
988: break;
989:
990: /*
991: * The AVAILABLE ATTENTION messages occurs when the
992: * unit becomes available after spinup,
993: * marking the unit offline will force an online command
994: * prior to using the unit.
995: */
996: case M_OP_AVATN:
997: #ifdef DEBUG
998: printd("uda: unit %d attention\n", mp->mscp_unit);
999: #endif
1000: ui->ui_flags = 0; /* it went offline and we didn't notice */
1001: ra_info[ui->ui_unit].ratype = mp->mscp_mediaid;
1002: break;
1003:
1004: case M_OP_END:
1005: /*
1006: * An endcode without an opcode (0200) is an invalid command.
1007: * The mscp specification states that this would be a protocol
1008: * type error, such as illegal opcodes. The mscp spec. also
1009: * states that parameter error type of invalid commands should
1010: * return the normal end message for the command. This does not appear
1011: * to be the case. An invalid logical block number returned an endcode
1012: * of 0200 instead of the 0241 (read) that was expected.
1013: */
1014:
1015: printf("endcd=%o, stat=%o\n", mp->mscp_opcode, mp->mscp_status);
1016: break;
1017: case M_OP_READ|M_OP_END:
1018: case M_OP_WRITE|M_OP_END:
1019: bp = (struct buf *)mp->mscp_cmdref;
1020: ubarelse(um->um_ubanum, (int *)&bp->b_ubinfo);
1021: /*
1022: * Unlink buffer from I/O wait queue.
1023: */
1024: bp->av_back->av_forw = bp->av_forw;
1025: bp->av_forw->av_back = bp->av_back;
1026: #if defined(VAX750)
1027: if (cpu == VAX_750 && um->um_tab.b_active == 0
1028: && udwtab[um->um_ctlr].av_forw == &udwtab[um->um_ctlr]) {
1029: if (um->um_ubinfo == 0)
1030: printf("udintr: um_ubinfo == 0\n");
1031: else
1032: ubarelse(um->um_ubanum, &um->um_ubinfo);
1033: }
1034: #endif
1035: dp = &udutab[ui->ui_unit];
1036: dp->b_qsize--;
1037: if (ui->ui_dk >= 0)
1038: if (dp->b_qsize == 0)
1039: dk_busy &= ~(1<<ui->ui_dk);
1040: if (st == M_ST_OFFLN || st == M_ST_AVLBL) {
1041: ui->ui_flags = 0; /* mark unit offline */
1042: /*
1043: * Link the buffer onto the front of the drive queue
1044: */
1045: if ((bp->av_forw = dp->b_actf) == 0)
1046: dp->b_actl = bp;
1047: dp->b_actf = bp;
1048: /*
1049: * Link the drive onto the controller queue
1050: */
1051: if (dp->b_active == 0) {
1052: dp->b_forw = NULL;
1053: if (um->um_tab.b_actf == NULL)
1054: um->um_tab.b_actf = dp;
1055: else
1056: um->um_tab.b_actl->b_forw = dp;
1057: um->um_tab.b_actl = dp;
1058: dp->b_active = 1;
1059: }
1060: #if defined(VAX750)
1061: if (cpu == VAX750 && um->um_ubinfo == 0)
1062: um->um_ubinfo =
1063: uballoc(um->um_ubanum, (caddr_t)0, 0,
1064: UBA_NEEDBDP);
1065: #endif
1066: return;
1067: }
1068: if (st != M_ST_SUCC) {
1069: harderr(bp, "ra");
1070: #ifdef DEBUG
1071: printd("status %o\n", mp->mscp_status);
1072: #endif
1073: bp->b_flags |= B_ERROR;
1074: }
1075: bp->b_resid = bp->b_bcount - mp->mscp_bytecnt;
1076: iodone(bp);
1077: break;
1078:
1079: case M_OP_GTUNT|M_OP_END:
1080: #ifdef DEBUG
1081: printd("GTUNT end packet status = 0x%x media id 0x%x\n"
1082: ,st,mp->mscp_mediaid);
1083: #endif
1084: ra_info[ui->ui_unit].rastatus = st;
1085: ra_info[ui->ui_unit].ratype = mp->mscp_mediaid;
1086: break;
1087:
1088: default:
1089: printf("uda: unknown packet\n");
1090: uderror(um, (struct mslg *)mp);
1091: }
1092: }
1093:
1094:
1095: /*
1096: * Process an error log message
1097: *
1098: * For now, just log the error on the console.
1099: * Only minimal decoding is done, only "useful"
1100: * information is printed. Eventually should
1101: * send message to an error logger.
1102: */
1103: uderror(um, mp)
1104: register struct uba_ctlr *um;
1105: register struct mslg *mp;
1106: {
1107: register i;
1108:
1109:
1110: if(!(mp->mslg_flags & (M_LF_SUCC | M_LF_CONT)))
1111: printf("uda%d: hard error\n");
1112:
1113: mprintf("uda%d: %s error, ", um->um_ctlr,
1114: mp->mslg_flags & ( M_LF_SUCC | M_LF_CONT ) ? "soft" : "hard");
1115: switch (mp->mslg_format) {
1116: case M_FM_CNTERR:
1117: mprintf("controller error, event 0%o\n", mp->mslg_event);
1118: break;
1119:
1120: case M_FM_BUSADDR:
1121: mprintf("host memory access error, event 0%o, addr 0%o\n",
1122: mp->mslg_event, mp->mslg_busaddr);
1123: break;
1124:
1125: case M_FM_DISKTRN:
1126: mprintf("disk transfer error, unit %d, grp 0x%x, hdr 0x%x, event 0%o\n",
1127: mp->mslg_unit, mp->mslg_group, mp->mslg_hdr,
1128: mp->mslg_event);
1129: break;
1130:
1131: case M_FM_SDI:
1132: mprintf("SDI error, unit %d, event 0%o, hdr 0x%x\n",
1133: mp->mslg_unit, mp->mslg_event, mp->mslg_hdr);
1134: for(i = 0; i < 12;i++)
1135: mprintf("\t0x%x",mp->mslg_sdistat[i] & 0xff);
1136: mprintf("\n");
1137: break;
1138:
1139: case M_FM_SMLDSK:
1140: mprintf("small disk error, unit %d, event 0%o, cyl %d\n",
1141: mp->mslg_unit, mp->mslg_event, mp->mslg_sdecyl);
1142: break;
1143:
1144: default:
1145: mprintf("unknown error, unit %d, format 0%o, event 0%o\n",
1146: mp->mslg_unit, mp->mslg_format, mp->mslg_event);
1147: }
1148:
1149: if (udaerror) {
1150: register long *p = (long *)mp;
1151:
1152: for (i = 0; i < mp->mslg_header.uda_msglen; i += sizeof(*p))
1153: printf("%x ", *p++);
1154: printf("\n");
1155: }
1156: }
1157:
1158:
1159: /*
1160: * Find an unused command packet
1161: */
1162: struct mscp *
1163: udgetcp(um)
1164: struct uba_ctlr *um;
1165: {
1166: register struct mscp *mp;
1167: register struct udaca *cp;
1168: register struct uda_softc *sc;
1169: register int i;
1170: int s;
1171:
1172: s = spl5();
1173: cp = &uda[um->um_ctlr].uda_ca;
1174: sc = &uda_softc[um->um_ctlr];
1175: /*
1176: * If no credits, can't issue any commands
1177: * until some outstanding commands complete.
1178: */
1179: i = sc->sc_lastcmd;
1180: if(((cp->ca_cmddsc[i]&(UDA_OWN|UDA_INT))==UDA_INT)&&
1181: (sc->sc_credits >= 2)) {
1182: sc->sc_credits--; /* committed to issuing a command */
1183: cp->ca_cmddsc[i] &= ~UDA_INT;
1184: mp = &uda[um->um_ctlr].uda_cmd[i];
1185: mp->mscp_unit = mp->mscp_modifier = 0;
1186: mp->mscp_opcode = mp->mscp_flags = 0;
1187: mp->mscp_bytecnt = mp->mscp_buffer = 0;
1188: mp->mscp_errlgfl = mp->mscp_copyspd = 0;
1189: sc->sc_lastcmd = (i + 1) % NCMD;
1190: (void) splx(s);
1191: return(mp);
1192: }
1193: (void) splx(s);
1194: return(NULL);
1195: }
1196:
1197: udread(dev, uio)
1198: dev_t dev;
1199: struct uio *uio;
1200: {
1201: register int unit = udunit(dev);
1202:
1203: if (unit >= NRA)
1204: return (ENXIO);
1205: return (physio(udstrategy, &rudbuf[unit], dev, B_READ, minphys, uio));
1206: }
1207:
1208: udwrite(dev, uio)
1209: dev_t dev;
1210: struct uio *uio;
1211: {
1212: register int unit = udunit(dev);
1213:
1214: if (unit >= NRA)
1215: return (ENXIO);
1216: return (physio(udstrategy, &rudbuf[unit], dev, B_WRITE, minphys, uio));
1217: }
1218:
1219: udreset(uban)
1220: int uban;
1221: {
1222: register struct uba_ctlr *um;
1223: register struct uba_device *ui;
1224: register struct buf *bp, *dp;
1225: register int unit;
1226: struct buf *nbp;
1227: int d;
1228:
1229: for (d = 0; d < NUDA; d++) {
1230: if ((um = udminfo[d]) == 0 || um->um_ubanum != uban ||
1231: um->um_alive == 0)
1232: continue;
1233: printf(" uda%d", d);
1234: um->um_tab.b_active = 0;
1235: um->um_tab.b_actf = um->um_tab.b_actl = 0;
1236: uda_softc[d].sc_state = S_IDLE;
1237: uda_softc[d].sc_mapped = 0; /* Rich */
1238: for (unit = 0; unit < NRA; unit++) {
1239: if ((ui = uddinfo[unit]) == 0)
1240: continue;
1241: if (ui->ui_alive == 0 || ui->ui_mi != um)
1242: continue;
1243: udutab[unit].b_active = 0;
1244: udutab[unit].b_qsize = 0;
1245: }
1246: for (bp = udwtab[d].av_forw; bp != &udwtab[d]; bp = nbp) {
1247: nbp = bp->av_forw;
1248: bp->b_ubinfo = 0;
1249: /*
1250: * Link the buffer onto the drive queue
1251: */
1252: dp = &udutab[udunit(bp->b_dev)];
1253: if (dp->b_actf == 0)
1254: dp->b_actf = bp;
1255: else
1256: dp->b_actl->av_forw = bp;
1257: dp->b_actl = bp;
1258: bp->av_forw = 0;
1259: /*
1260: * Link the drive onto the controller queue
1261: */
1262: if (dp->b_active == 0) {
1263: dp->b_forw = NULL;
1264: if (um->um_tab.b_actf == NULL)
1265: um->um_tab.b_actf = dp;
1266: else
1267: um->um_tab.b_actl->b_forw = dp;
1268: um->um_tab.b_actl = dp;
1269: dp->b_active = 1;
1270: }
1271: }
1272: (void)udinit(d);
1273: }
1274: }
1275:
1276: #define DBSIZE 32
1277:
1278: #define ca_Rspdsc ca_rspdsc[0]
1279: #define ca_Cmddsc ca_rspdsc[1]
1280: #define uda_Rsp uda_rsp[0]
1281: #define uda_Cmd uda_cmd[0]
1282:
1283: struct uda udad[NUDA];
1284:
1285: uddump(dev)
1286: dev_t dev;
1287: {
1288: struct udadevice *udaddr;
1289: struct uda *ud_ubaddr;
1290: char *start;
1291: int num, blk, unit;
1292: int maxsz;
1293: int blkoff;
1294: register struct uba_regs *uba;
1295: register struct uba_device *ui;
1296: register struct uda *udp;
1297: register struct pte *io;
1298: register int i;
1299: struct size *rasizes;
1300: unit = udunit(dev);
1301: if (unit >= NRA)
1302: return (ENXIO);
1303: #define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
1304: ui = phys(struct uba_device *, uddinfo[unit]);
1305: if (ui->ui_alive == 0)
1306: return (ENXIO);
1307: uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
1308: ubainit(uba);
1309: udaddr = (struct udadevice *)ui->ui_physaddr;
1310: DELAY(2000000);
1311: udp = phys(struct uda *, &udad[ui->ui_ctlr]);
1312:
1313: num = btoc(sizeof(struct uda)) + 1;
1314: io = &uba->uba_map[NUBMREG-num];
1315: for(i = 0; i<num; i++)
1316: *(int *)io++ = UBAMR_MRV|(btop(udp)+i);
1317: ud_ubaddr = (struct uda *)(((int)udp & PGOFSET)|((NUBMREG-num)<<9));
1318:
1319: udaddr->udaip = 0;
1320: while ((udaddr->udasa & UDA_STEP1) == 0)
1321: if(udaddr->udasa & UDA_ERR) return(EFAULT);
1322: udaddr->udasa = UDA_ERR;
1323: while ((udaddr->udasa & UDA_STEP2) == 0)
1324: if(udaddr->udasa & UDA_ERR) return(EFAULT);
1325: udaddr->udasa = (short)&ud_ubaddr->uda_ca.ca_ringbase;
1326: while ((udaddr->udasa & UDA_STEP3) == 0)
1327: if(udaddr->udasa & UDA_ERR) return(EFAULT);
1328: udaddr->udasa = (short)(((int)&ud_ubaddr->uda_ca.ca_ringbase) >> 16);
1329: while ((udaddr->udasa & UDA_STEP4) == 0)
1330: if(udaddr->udasa & UDA_ERR) return(EFAULT);
1331: udaddr->udasa = UDA_GO;
1332: udp->uda_ca.ca_Rspdsc = (long)&ud_ubaddr->uda_Rsp.mscp_cmdref;
1333: udp->uda_ca.ca_Cmddsc = (long)&ud_ubaddr->uda_Cmd.mscp_cmdref;
1334: udp->uda_Cmd.mscp_cntflgs = 0;
1335: udp->uda_Cmd.mscp_version = 0;
1336: if (udcmd(M_OP_STCON, udp, udaddr) == 0) {
1337: return(EFAULT);
1338: }
1339: udp->uda_Cmd.mscp_unit = ui->ui_slave;
1340: if (udcmd(M_OP_ONLIN, udp, udaddr) == 0) {
1341: return(EFAULT);
1342: }
1343:
1344: num = maxfree;
1345: start = 0;
1346: rasizes = ra_info[ui->ui_unit].ra_sizes;
1347: maxsz = rasizes[minor(dev)&07].nblocks;
1348: blkoff = rasizes[minor(dev)&07].blkoff;
1349: if(maxsz < 0)
1350: maxsz = ra_info[unit].radsize-blkoff;
1351: if (dumplo < 0)
1352: return (EINVAL);
1353: if (dumplo + num >= maxsz)
1354: num = maxsz - dumplo;
1355: blkoff += dumplo;
1356: while (num > 0) {
1357: blk = num > DBSIZE ? DBSIZE : num;
1358: io = uba->uba_map;
1359: for (i = 0; i < blk; i++)
1360: *(int *)io++ = (btop(start)+i) | UBAMR_MRV;
1361: *(int *)io = 0;
1362: udp->uda_Cmd.mscp_lbn = btop(start) + blkoff;
1363: udp->uda_Cmd.mscp_unit = ui->ui_slave;
1364: udp->uda_Cmd.mscp_bytecnt = blk*NBPG;
1365: udp->uda_Cmd.mscp_buffer = 0;
1366: if (udcmd(M_OP_WRITE, udp, udaddr) == 0) {
1367: return(EIO);
1368: }
1369: start += blk*NBPG;
1370: num -= blk;
1371: }
1372: return (0);
1373: }
1374:
1375:
1376: udcmd(op, udp, udaddr)
1377: int op;
1378: register struct uda *udp;
1379: struct udadevice *udaddr;
1380: {
1381: int i;
1382:
1383: udp->uda_Cmd.mscp_opcode = op;
1384: udp->uda_Rsp.mscp_header.uda_msglen = mscp_msglen;
1385: udp->uda_Cmd.mscp_header.uda_msglen = mscp_msglen;
1386: udp->uda_ca.ca_Rspdsc |= UDA_OWN|UDA_INT;
1387: udp->uda_ca.ca_Cmddsc |= UDA_OWN|UDA_INT;
1388: if (udaddr->udasa&UDA_ERR)
1389: printf("Udaerror udasa (%x)\n", udaddr->udasa&0xffff);
1390: i = udaddr->udaip;
1391: #ifdef lint
1392: i = i;
1393: #endif
1394: for (;;) {
1395: if (udp->uda_ca.ca_cmdint)
1396: udp->uda_ca.ca_cmdint = 0;
1397: if (udp->uda_ca.ca_rspint)
1398: break;
1399: }
1400: udp->uda_ca.ca_rspint = 0;
1401: if (udp->uda_Rsp.mscp_opcode != (op|M_OP_END) ||
1402: (udp->uda_Rsp.mscp_status&M_ST_MASK) != M_ST_SUCC) {
1403: printf("error: com %d opc 0x%x stat 0x%x\ndump ",
1404: op,
1405: udp->uda_Rsp.mscp_opcode,
1406: udp->uda_Rsp.mscp_status);
1407: return(0);
1408: }
1409: return(1);
1410: }
1411:
1412: udsize(dev)
1413: dev_t dev;
1414: {
1415: int unit = udunit(dev);
1416: struct uba_device *ui;
1417: struct size *rasizes;
1418:
1419: if (unit >= NRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0
1420: || ui->ui_flags == 0)
1421: return (-1);
1422: rasizes = ra_info[ui->ui_unit].ra_sizes;
1423: return (rasizes[minor(dev) & 07].nblocks);
1424: }
1425:
1426: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.