![[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] / 41BSD / 4.0.upgrade / sys / dev|
Return to uda.c CVS log | Up to [CSRG BSD Unix] / 41BSD / 4.0.upgrade / sys / dev |
1.1 root 1: /* uda.c 1.2 81/10/27 */
2:
3: #include "ra.h"
4: #if NUDA > 0
5: /*
6: * UDA50/RAxx disk device driver
7: *
8: * Restrictions:
9: * Unit numbers must be less than 8.
10: *
11: * TO DO:
12: * write dump code
13: * test on 750
14: */
15:
16: #include "../h/param.h"
17: #include "../h/systm.h"
18: #include "../h/buf.h"
19: #include "../h/conf.h"
20: #include "../h/dir.h"
21: #include "../h/user.h"
22: #include "../h/pte.h"
23: #include "../h/map.h"
24: #include "../h/vm.h"
25: #include "../h/ubareg.h"
26: #include "../h/ubavar.h"
27: #include "../h/dk.h"
28: #include "../h/cpu.h"
29: #include "../h/cmap.h"
30:
31: int udadebug;
32: #define printd if(udadebug&1)printf
33:
34: /*
35: * Parameters for the communications area
36: */
37:
38: #define NRSPL2 3
39: #define NCMDL2 3
40: #define NRSP (1<<NRSPL2)
41: #define NCMD (1<<NCMDL2)
42:
43: #include "../h/udareg.h"
44: #include "../h/mscp.h"
45:
46: struct uda_softc {
47: short sc_state; /* state of controller */
48: short sc_mapped; /* Unibus map allocated for uda struct? */
49: int sc_ubainfo; /* Unibus mapping info */
50: struct uda *sc_uda; /* Unibus address of uda struct */
51: int sc_ivec; /* interrupt vector address */
52: short sc_credits; /* transfer credits */
53: short sc_lastcmd; /* pointer into command ring */
54: short sc_lastrsp; /* pointer into response ring */
55: } uda_softc[NUDA];
56:
57: /*
58: * Controller states
59: */
60: #define S_IDLE 0 /* hasn't been initialized */
61: #define S_STEP1 1 /* doing step 1 init */
62: #define S_STEP2 2 /* doing step 2 init */
63: #define S_STEP3 3 /* doing step 3 init */
64: #define S_SCHAR 4 /* doing "set controller characteristics" */
65: #define S_RUN 5 /* running */
66:
67: struct uda {
68: struct udaca uda_ca; /* communications area */
69: struct mscp uda_rsp[NRSP]; /* response packets */
70: struct mscp uda_cmd[NCMD]; /* command packets */
71: } uda[NUDA];
72:
73: /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */
74: struct size {
75: daddr_t nblocks;
76: daddr_t blkoff;
77: } ra_sizes[8] ={
78: 15884, 0, /* A=blk 0 thru 15883 */
79: 33440, 15884, /* B=blk 15884 thru 49323 */
80: -1, 0, /* C=blk 0 thru end */
81: 0, 0, /* D reserved for RA81 */
82: 0, 0, /* E reserved for RA81 */
83: 0, 0, /* F reserved for RA81 */
84: 82080, 49324, /* G=blk 49324 thru 131403 */
85: -1, 131404, /* H=blk 131404 thru end */
86: };
87: /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
88:
89: daddr_t radsize[NRA]; /* disk size, from ONLINE end packet */
90:
91: int udprobe(), udslave(), udattach(), udintr();
92: struct mscp *udgetcp();
93: struct uba_ctlr *udminfo[NUDA];
94: struct uba_device *uddinfo[NRA];
95: struct uba_device *udip[NUDA][8]; /* 8 == max number of drives */
96:
97: u_short udstd[] = { 0777550, 0 };
98: struct uba_driver udadriver =
99: { udprobe, udslave, udattach, 0, udstd, "ra", uddinfo, "uda", udminfo, 0 };
100: struct buf rudbuf[NRA];
101: struct buf udutab[NRA];
102: struct buf udwtab[NUDA]; /* I/O wait queue, per controller */
103:
104: #define b_qsize b_resid /* queue size per drive, in udutab */
105: #define b_ubinfo b_resid /* Unibus mapping info, per buffer */
106:
107: udprobe(reg, ctlr)
108: caddr_t reg;
109: int ctlr;
110: {
111: register int br, cvec;
112: register struct uda_softc *sc = &uda_softc[ctlr];
113:
114: #ifdef lint
115: br = 0; cvec = br; br = cvec;
116: #endif
117: /* SHOULD CHECK THAT IT REALLY IS A UDA */
118: br = 0x15;
119: cvec = sc->sc_ivec = (uba_hd[numuba].uh_lastiv -= 4);
120: return(1);
121: }
122:
123: udslave(ui, reg)
124: struct uba_device *ui;
125: caddr_t reg;
126: {
127: /*
128: * TOO HARD TO FIND OUT IF DISK IS THERE UNTIL
129: * INITIALIZED. WE'LL FIND OUT WHEN WE FIRST
130: * TRY TO ACCESS IT.
131: */
132: return(1);
133: }
134:
135: udattach(ui)
136: register struct uba_device *ui;
137: {
138:
139: if (ui->ui_dk > 0)
140: dk_mspw[ui->ui_dk] = 1.0 / (60 * 31 * 256); /* approx */
141: ui->ui_flags = 0;
142: udip[ui->ui_ctlr][ui->ui_slave] = ui;
143: radsize[ui->ui_unit] = (daddr_t)0xffffff; /* max possible size */
144: }
145:
146: /*
147: * Open a UDA. Initialize the device and
148: * set the unit online.
149: */
150: udopen(dev, flag)
151: dev_t dev;
152: int flag;
153: {
154: register int unit;
155: register struct uba_device *ui;
156: register struct uda_softc *sc;
157:
158: unit = minor(dev) >> 3;
159: if (unit >= NRA || (ui = uddinfo[unit]) == 0 || ui->ui_alive == 0) {
160: u.u_error = ENXIO;
161: return;
162: }
163: sc = &uda_softc[ui->ui_ctlr];
164: (void) spl5();
165: if (sc->sc_state != S_RUN) {
166: if (sc->sc_state == S_IDLE)
167: udinit(ui->ui_ctlr);
168: sleep(ui->ui_mi, 0); /* wait for initialization to complete */
169: if (sc->sc_state != S_RUN) {
170: u.u_error = EIO;
171: return;
172: }
173: }
174: (void) spl0();
175: /* SHOULD PROBABLY FORCE AN ONLINE ATTEMPT
176: TO SEE IF DISK IS REALLY THERE */
177: }
178:
179: /*
180: * Initialize a UDA. Set up UBA mapping registers,
181: * initialize data structures, and start hardware
182: * initialization sequence.
183: */
184: udinit(d)
185: int d;
186: {
187: register struct uda_softc *sc;
188: register struct uda *ud;
189: struct udadevice *udaddr;
190: struct uba_ctlr *um;
191:
192: sc = &uda_softc[d];
193: um = udminfo[d];
194: um->um_tab.b_active++;
195: ud = &uda[d];
196: udaddr = (struct udadevice *)um->um_addr;
197: if (sc->sc_mapped == 0) {
198: /*
199: * Map the communications area and command
200: * and response packets into Unibus address
201: * space.
202: */
203: sc->sc_ubainfo = uballoc(um->um_ubanum, (caddr_t)ud,
204: sizeof (struct uda), 0);
205: sc->sc_uda = (struct uda *)(sc->sc_ubainfo & 0x3ffff);
206: sc->sc_mapped = 1;
207: }
208:
209: /*
210: * Start the hardware initialization sequence.
211: */
212: udaddr->udaip = 0; /* start initialization */
213: while ((udaddr->udasa & UDA_STEP1) == 0)
214: ;
215: udaddr->udasa = UDA_ERR|(NCMDL2<<11)|(NRSPL2<<8)|UDA_IE|(sc->sc_ivec/4);
216: /*
217: * Initialization continues in interrupt routine.
218: */
219: sc->sc_state = S_STEP1;
220: sc->sc_credits = 0;
221: }
222:
223: udstrategy(bp)
224: register struct buf *bp;
225: {
226: register struct uba_device *ui;
227: register struct uba_ctlr *um;
228: register struct buf *dp;
229: register int unit;
230: int xunit = minor(bp->b_dev) & 07;
231: daddr_t sz, maxsz;
232:
233: sz = (bp->b_bcount+511) >> 9;
234: unit = dkunit(bp);
235: if (unit >= NRA)
236: goto bad;
237: ui = uddinfo[unit];
238: um = ui->ui_mi;
239: if (ui == 0 || ui->ui_alive == 0)
240: goto bad;
241: if ((maxsz = ra_sizes[xunit].nblocks) < 0)
242: maxsz = radsize[unit] - ra_sizes[xunit].blkoff;
243: if (bp->b_blkno < 0 || bp->b_blkno+sz > maxsz ||
244: ra_sizes[xunit].blkoff >= radsize[unit])
245: goto bad;
246: (void) spl5();
247: /*
248: * Link the buffer onto the drive queue
249: */
250: dp = &udutab[ui->ui_unit];
251: if (dp->b_actf == 0)
252: dp->b_actf = bp;
253: else
254: dp->b_actl->av_forw = bp;
255: dp->b_actl = bp;
256: bp->av_forw = 0;
257: /*
258: * Link the drive onto the controller queue
259: */
260: if (dp->b_active == 0) {
261: dp->b_forw = NULL;
262: if (um->um_tab.b_actf == NULL)
263: um->um_tab.b_actf = dp;
264: else
265: um->um_tab.b_actl->b_forw = dp;
266: um->um_tab.b_actl = dp;
267: dp->b_active = 1;
268: }
269: if (um->um_tab.b_active == 0) {
270: #if defined(VAX750)
271: if (cpu == VAX_750) {
272: if (um->um_ubinfo != 0)
273: printf("uda: ubinfo %x\n",um->um_ubinfo);
274: else
275: um->um_ubinfo =
276: uballoc(um->um_ubanum, 0, 0, UBA_NEEDBDP);
277: }
278: #endif
279: (void) udstart(um);
280: }
281: (void) spl0();
282: return;
283:
284: bad:
285: bp->b_flags |= B_ERROR;
286: iodone(bp);
287: return;
288: }
289:
290: udstart(um)
291: register struct uba_ctlr *um;
292: {
293: register struct buf *bp, *dp;
294: register struct mscp *mp;
295: register struct uda_softc *sc;
296: register struct uba_device *ui;
297: struct udadevice *udaddr;
298: int i;
299:
300: sc = &uda_softc[um->um_ctlr];
301:
302: loop:
303: if ((dp = um->um_tab.b_actf) == NULL) {
304: /*
305: * Release uneeded UBA resources and return
306: */
307: um->um_tab.b_active = 0;
308: #if defined(VAX750)
309: if (cpu == VAX_750) {
310: if (um->um_ubinfo == 0)
311: printf("uda: um_ubinfo == 0\n");
312: else
313: ubarelse(um->um_ubanum, &um->um_ubinfo);
314: }
315: #endif
316: return(0);
317: }
318: if ((bp = dp->b_actf) == NULL) {
319: /*
320: * No more requests for this drive, remove
321: * from controller queue and look at next drive.
322: * We know we're at the head of the controller queue.
323: */
324: dp->b_active = 0;
325: um->um_tab.b_actf = dp->b_forw;
326: goto loop;
327: }
328: um->um_tab.b_active++;
329: udaddr = (struct udadevice *)um->um_addr;
330: if ((udaddr->udasa&UDA_ERR) || sc->sc_state != S_RUN) {
331: harderr(bp, "ra");
332: printf("udasa %o, state %d\n", udaddr->udasa&0xffff, sc->sc_state);
333: udinit(um->um_ctlr);
334: /* SHOULD REQUEUE OUTSTANDING REQUESTS, LIKE UDRESET */
335: return;
336: }
337: ui = uddinfo[dkunit(bp)];
338: /*
339: * If no credits, can't issue any commands
340: * until some outstanding commands complete.
341: */
342: if (sc->sc_credits < 2)
343: return(0);
344: if ((mp = udgetcp(um)) == NULL)
345: return(0);
346: sc->sc_credits--; /* committed to issuing a command */
347: if (ui->ui_flags == 0) { /* not online */
348: mp->mscp_opcode = M_OP_ONLIN;
349: mp->mscp_unit = ui->ui_slave;
350: dp->b_active = 2;
351: um->um_tab.b_actf = dp->b_forw; /* remove from controller q */
352: printd("uda: bring unit %d online\n", ui->ui_slave);
353: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
354: i = udaddr->udaip;
355: goto loop;
356: }
357: switch (cpu) {
358: case VAX_780:
359: i = UBA_NEEDBDP|UBA_CANTWAIT;
360: break;
361:
362: case VAX_750:
363: i = um->um_ubinfo|UBA_HAVEBDP|UBA_CANTWAIT;
364: break;
365:
366: case VAX_7ZZ:
367: i = UBA_CANTWAIT;
368: break;
369: }
370: if ((i = ubasetup(um->um_ubanum, bp, i)) == 0) {
371: mp->mscp_opcode = M_OP_GTUNT;
372: mp->mscp_unit = ui->ui_slave;
373: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
374: i = udaddr->udaip; /* initiate polling */
375: return(1); /* wait for interrupt */
376: }
377: mp->mscp_cmdref = (long)bp; /* pointer to get back */
378: mp->mscp_opcode = bp->b_flags&B_READ ? M_OP_READ : M_OP_WRITE;
379: mp->mscp_unit = ui->ui_slave;
380: mp->mscp_lbn = bp->b_blkno + ra_sizes[minor(bp->b_dev)&7].blkoff;
381: mp->mscp_bytecnt = bp->b_bcount;
382: mp->mscp_buffer = (i & 0x3ffff) | (((i>>28)&0xf)<<24);
383: #if defined(VAX750)
384: if (cpu == VAX_750)
385: i &= 0xfffffff; /* mask off bdp */
386: #endif
387: bp->b_ubinfo = i; /* save mapping info */
388: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
389: i = udaddr->udaip; /* initiate polling */
390: if (ui->ui_dk >= 0) {
391: dk_busy |= 1<<ui->ui_dk;
392: dp->b_qsize++;
393: dk_xfer[ui->ui_dk]++;
394: dk_wds[ui->ui_dk] += bp->b_bcount>>6;
395: }
396:
397: /*
398: * Move drive to the end of the controller queue
399: */
400: if (dp->b_forw != NULL) {
401: um->um_tab.b_actf = dp->b_forw;
402: um->um_tab.b_actl->b_forw = dp;
403: um->um_tab.b_actl = dp;
404: dp->b_forw = NULL;
405: }
406: /*
407: * Move buffer to I/O wait queue
408: */
409: dp->b_actf = bp->av_forw;
410: dp = &udwtab[um->um_ctlr];
411: bp->av_forw = dp;
412: bp->av_back = dp->av_back;
413: dp->av_back->av_forw = bp;
414: dp->av_back = bp;
415: goto loop;
416: }
417:
418: /*
419: * UDA interrupt routine.
420: */
421: udintr(d)
422: int d;
423: {
424: register struct uba_ctlr *um = udminfo[d];
425: register struct udadevice *udaddr = (struct udadevice *)um->um_addr;
426: struct buf *bp;
427: register int i;
428: register struct uda_softc *sc = &uda_softc[d];
429: register struct uda *ud = &uda[d];
430: struct uda *uud;
431: struct mscp *mp;
432:
433: printd("udintr: state %d, udasa %o\n", sc->sc_state, udaddr->udasa);
434: switch (sc->sc_state) {
435: case S_IDLE:
436: printf("uda%d: random interrupt ignored\n", d);
437: return;
438:
439: case S_STEP1:
440: #define STEP1GOOD (UDA_STEP2|UDA_IE|(NCMDL2<<3)|NRSPL2)
441: if ((udaddr->udasa&(UDA_ERR|STEP1GOOD)) != STEP1GOOD) {
442: sc->sc_state = S_IDLE;
443: wakeup(um);
444: return;
445: }
446: udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)|
447: (cpu == VAX_780 ? UDA_PI : 0);
448: sc->sc_state = S_STEP2;
449: return;
450:
451: case S_STEP2:
452: #define STEP2GOOD (UDA_STEP3|UDA_IE|(sc->sc_ivec/4))
453: if ((udaddr->udasa&(UDA_ERR|STEP2GOOD)) != STEP2GOOD) {
454: sc->sc_state = S_IDLE;
455: wakeup(um);
456: return;
457: }
458: udaddr->udasa = ((int)&sc->sc_uda->uda_ca.ca_ringbase)>>16;
459: sc->sc_state = S_STEP3;
460: return;
461:
462: case S_STEP3:
463: #define STEP3GOOD UDA_STEP4
464: if ((udaddr->udasa&(UDA_ERR|STEP3GOOD)) != STEP3GOOD) {
465: sc->sc_state = S_IDLE;
466: wakeup(um);
467: return;
468: }
469: udaddr->udasa = UDA_GO;
470: sc->sc_state = S_SCHAR;
471:
472: /*
473: * Initialize the data structures.
474: */
475: uud = sc->sc_uda;
476: for (i = 0; i < NRSP; i++) {
477: ud->uda_ca.ca_rspdsc[i] = UDA_OWN|UDA_INT|
478: (long)&uud->uda_rsp[i].mscp_cmdref;
479: ud->uda_rsp[i].mscp_dscptr = &ud->uda_ca.ca_rspdsc[i];
480: ud->uda_rsp[i].mscp_header.uda_msglen = sizeof (struct mscp);
481: }
482: for (i = 0; i < NCMD; i++) {
483: ud->uda_ca.ca_cmddsc[i] = UDA_INT|
484: (long)&uud->uda_cmd[i].mscp_cmdref;
485: ud->uda_cmd[i].mscp_dscptr = &ud->uda_ca.ca_cmddsc[i];
486: ud->uda_cmd[i].mscp_header.uda_msglen = sizeof (struct mscp);
487: }
488: bp = &udwtab[d];
489: bp->av_forw = bp->av_back = bp;
490: sc->sc_lastcmd = 0;
491: sc->sc_lastrsp = 0;
492: if ((mp = udgetcp(um)) == NULL) {
493: sc->sc_state = S_IDLE;
494: wakeup(um);
495: return;
496: }
497: mp->mscp_opcode = M_OP_STCON;
498: mp->mscp_cntflgs = M_CF_ATTN|M_CF_MISC|M_CF_THIS;
499: *((long *)mp->mscp_dscptr) |= UDA_OWN|UDA_INT;
500: i = udaddr->udaip; /* initiate polling */
501: return;
502:
503: case S_SCHAR:
504: case S_RUN:
505: break;
506:
507: default:
508: printf("uda%d: interrupt in unknown state %d ignored\n",
509: d, sc->sc_state);
510: return;
511: }
512:
513: if (udaddr->udasa&UDA_ERR) {
514: printf("uda%d: fatal error (%o)\n", d, udaddr->udasa&0xffff);
515: udaddr->udaip = 0;
516: wakeup(um);
517: }
518:
519: /*
520: * Check for a buffer purge request.
521: */
522: if (ud->uda_ca.ca_bdp) {
523: /*
524: * THIS IS A KLUDGE.
525: * Maybe we should change the entire
526: * UBA interface structure.
527: */
528: int s = spl7();
529:
530: i = um->um_ubinfo;
531: printd("uda: purge bdp %d\n", ud->uda_ca.ca_bdp);
532: um->um_ubinfo = ud->uda_ca.ca_bdp<<28;
533: ubapurge(um);
534: um->um_ubinfo = i;
535: (void) splx(s);
536: ud->uda_ca.ca_bdp = 0;
537: udaddr->udasa = 0; /* signal purge complete */
538: }
539:
540: /*
541: * Check for response ring transition.
542: */
543: if (ud->uda_ca.ca_rspint) {
544: ud->uda_ca.ca_rspint = 0;
545: for (i = sc->sc_lastrsp;; i++) {
546: i %= NRSP;
547: if (ud->uda_ca.ca_rspdsc[i]&UDA_OWN)
548: break;
549: udrsp(um, ud, sc, i);
550: ud->uda_ca.ca_rspdsc[i] |= UDA_OWN;
551: }
552: sc->sc_lastrsp = i;
553: }
554:
555: /*
556: * Check for command ring transition.
557: */
558: if (ud->uda_ca.ca_cmdint) {
559: printd("uda: command ring transition\n");
560: ud->uda_ca.ca_cmdint = 0;
561: }
562: udstart(um);
563: }
564:
565: /*
566: * Process a response packet
567: */
568: udrsp(um, ud, sc, i)
569: register struct uba_ctlr *um;
570: register struct uda *ud;
571: register struct uda_softc *sc;
572: int i;
573: {
574: register struct mscp *mp;
575: struct uba_device *ui;
576: struct buf *dp, *bp;
577: int st;
578:
579: mp = &ud->uda_rsp[i];
580: mp->mscp_header.uda_msglen = sizeof (struct mscp);
581: sc->sc_credits += mp->mscp_header.uda_credits & 0xf;
582: if ((mp->mscp_header.uda_credits & 0xf0) > 0x10)
583: return;
584: /*
585: * If it's an error log message (datagram),
586: * pass it on for more extensive processing.
587: */
588: if ((mp->mscp_header.uda_credits & 0xf0) == 0x10) {
589: uderror(um, (struct mslg *)mp);
590: return;
591: }
592: if (mp->mscp_unit >= 8)
593: return;
594: if ((ui = udip[um->um_ctlr][mp->mscp_unit]) == 0)
595: return;
596: st = mp->mscp_status&M_ST_MASK;
597: switch (mp->mscp_opcode) {
598: case M_OP_STCON|M_OP_END:
599: if (st == M_ST_SUCC)
600: sc->sc_state = S_RUN;
601: else
602: sc->sc_state = S_IDLE;
603: um->um_tab.b_active = 0;
604: wakeup(um);
605: break;
606:
607: case M_OP_ONLIN|M_OP_END:
608: /*
609: * Link the drive onto the controller queue
610: */
611: dp = &udutab[ui->ui_unit];
612: dp->b_forw = NULL;
613: if (um->um_tab.b_actf == NULL)
614: um->um_tab.b_actf = dp;
615: else
616: um->um_tab.b_actl->b_forw = dp;
617: um->um_tab.b_actl = dp;
618: if (st == M_ST_SUCC) {
619: ui->ui_flags = 1; /* mark it online */
620: radsize[ui->ui_unit] = (daddr_t)mp->mscp_untsize;
621: printd("uda: unit %d online\n", mp->mscp_unit);
622: } else {
623: harderr(dp->b_actf, "ra");
624: printf("OFFLINE\n");
625: while (bp = dp->b_actf) {
626: dp->b_actf = bp->av_forw;
627: bp->b_flags |= B_ERROR;
628: iodone(bp);
629: }
630: }
631: dp->b_active = 1;
632: break;
633:
634: case M_OP_AVATN:
635: printd("uda: unit %d attention\n", mp->mscp_unit);
636: ui->ui_flags = 0; /* it went offline and we didn't notice */
637: break;
638:
639: case M_OP_READ|M_OP_END:
640: case M_OP_WRITE|M_OP_END:
641: bp = (struct buf *)mp->mscp_cmdref;
642: ubarelse(um->um_ubanum, &bp->b_resid);
643: /*
644: * Unlink buffer from I/O wait queue.
645: */
646: bp->av_back->av_forw = bp->av_forw;
647: bp->av_forw->av_back = bp->av_back;
648: dp = &udutab[ui->ui_unit];
649: if (ui->ui_dk >= 0)
650: if (--dp->b_qsize == 0)
651: dk_busy &= ~(1<<ui->ui_dk);
652: if (st == M_ST_OFFLN || st == M_ST_AVLBL) {
653: ui->ui_flags = 0; /* mark unit offline */
654: /*
655: * Link the buffer onto the front of the drive queue
656: */
657: if ((bp->av_forw = dp->b_actf) == 0)
658: dp->b_actl = bp;
659: dp->b_actf = bp;
660: /*
661: * Link the drive onto the controller queue
662: */
663: if (dp->b_active == 0) {
664: dp->b_forw = NULL;
665: if (um->um_tab.b_actf == NULL)
666: um->um_tab.b_actf = dp;
667: else
668: um->um_tab.b_actl->b_forw = dp;
669: um->um_tab.b_actl = dp;
670: dp->b_active = 1;
671: }
672: return;
673: }
674: if (st != M_ST_SUCC) {
675: harderr(bp, "ra");
676: printf("status %o\n", mp->mscp_status);
677: bp->b_flags |= B_ERROR;
678: }
679: bp->b_resid = bp->b_bcount - mp->mscp_bytecnt;
680: iodone(bp);
681: break;
682:
683: case M_OP_GTUNT|M_OP_END:
684: break;
685:
686: default:
687: printf("uda: unknown packet\n");
688: }
689: }
690:
691:
692: /*
693: * Process an error log message
694: *
695: * For now, just log the error on the console.
696: * Only minimal decoding is done, only "useful"
697: * information is printed. Eventually should
698: * send message to an error logger.
699: */
700: uderror(um, mp)
701: register struct uba_ctlr *um;
702: register struct mslg *mp;
703: {
704: printf("uda%d:%d: %s error, ", um->um_ctlr, mp->mslg_seqnum,
705: mp->mslg_flags&M_LF_SUCC ? "soft" : "hard");
706: switch (mp->mslg_format) {
707: case M_FM_CNTERR:
708: printf("controller error, event 0%o\n", mp->mslg_event);
709: break;
710:
711: case M_FM_BUSADDR:
712: printf("host memory access error, event 0%o, addr 0%o\n",
713: mp->mslg_event, *((long *)&mp->mslg_busaddr[0]));
714: break;
715:
716: case M_FM_DISKTRN:
717: printf("disk transfer error, unit %d, grp %d, cyl %d, sec %d, ",
718: mp->mslg_unit, mp->mslg_group, mp->mslg_cylinder,
719: mp->mslg_sector);
720: printf("trk %d, lbn %d, retry %d, level %d\n", mp->mslg_track,
721: mp->mslg_lbn, mp->mslg_retry, mp->mslg_level);
722: break;
723:
724: case M_FM_SDI:
725: printf("SDI error, unit %d, event 0%o, cyl %d\n", mp->mslg_unit,
726: mp->mslg_event, mp->mslg_cylinder);
727: break;
728:
729: case M_FM_SMLDSK:
730: printf("small disk error, unit %d, event 0%o, cyl %d\n",
731: mp->mslg_unit, mp->mslg_event, mp->mslg_sdecyl);
732: break;
733:
734: default:
735: printf("unknown error, unit %d, format 0%o, event 0%o\n",
736: mp->mslg_unit, mp->mslg_format, mp->mslg_event);
737: }
738: }
739:
740:
741: /*
742: * Find an unused command packet
743: */
744: struct mscp *
745: udgetcp(um)
746: struct uba_ctlr *um;
747: {
748: register struct mscp *mp;
749: register struct udaca *cp;
750: register struct uda_softc *sc;
751: register int i;
752:
753: cp = &uda[um->um_ctlr].uda_ca;
754: sc = &uda_softc[um->um_ctlr];
755: i = sc->sc_lastcmd;
756: if ((cp->ca_cmddsc[i] & (UDA_OWN|UDA_INT)) == UDA_INT) {
757: cp->ca_cmddsc[i] &= ~UDA_INT;
758: mp = &uda[um->um_ctlr].uda_cmd[i];
759: mp->mscp_unit = mp->mscp_modifier = 0;
760: mp->mscp_opcode = mp->mscp_flags = 0;
761: mp->mscp_bytecnt = mp->mscp_buffer = 0;
762: mp->mscp_errlgfl = mp->mscp_copyspd = 0;
763: sc->sc_lastcmd = (i + 1) % NCMD;
764: return(mp);
765: }
766: return(NULL);
767: }
768:
769: udread(dev)
770: dev_t dev;
771: {
772: register int unit = minor(dev) >> 3;
773:
774: if (unit >= NRA)
775: u.u_error = ENXIO;
776: else
777: physio(udstrategy, &rudbuf[unit], dev, B_READ, minphys);
778: }
779:
780: udwrite(dev)
781: dev_t dev;
782: {
783: register int unit = minor(dev) >> 3;
784:
785: if (unit >= NRA)
786: u.u_error = ENXIO;
787: else
788: physio(udstrategy, &rudbuf[unit], dev, B_WRITE, minphys);
789: }
790:
791: udreset(uban)
792: int uban;
793: {
794: register struct uba_ctlr *um;
795: register struct uba_device *ui;
796: register struct buf *bp, *dp;
797: register int unit;
798: struct buf *nbp;
799: int d;
800:
801: for (d = 0; d < NUDA; d++) {
802: if ((um = udminfo[d]) == 0 || um->um_ubanum != uban ||
803: um->um_alive == 0)
804: continue;
805: printf(" uda%d", d);
806: um->um_tab.b_active = 0;
807: um->um_tab.b_actf = um->um_tab.b_actl = 0;
808: uda_softc[d].sc_state = S_IDLE;
809: for (unit = 0; unit < NRA; unit++) {
810: if ((ui = uddinfo[unit]) == 0)
811: continue;
812: if (ui->ui_alive == 0 || ui->ui_mi != um)
813: continue;
814: udutab[unit].b_active = 0;
815: udutab[unit].b_qsize = 0;
816: }
817: for (bp = udwtab[d].av_forw; bp != &udwtab[d]; bp = nbp) {
818: nbp = bp->av_forw;
819: ubarelse(uban, &bp->b_ubinfo);
820: /*
821: * Link the buffer onto the drive queue
822: */
823: dp = &udutab[dkunit(bp)];
824: if (dp->b_actf == 0)
825: dp->b_actf = bp;
826: else
827: dp->b_actl->av_forw = bp;
828: dp->b_actl = bp;
829: bp->av_forw = 0;
830: /*
831: * Link the drive onto the controller queue
832: */
833: if (dp->b_active == 0) {
834: dp->b_forw = NULL;
835: if (um->um_tab.b_actf == NULL)
836: um->um_tab.b_actf = dp;
837: else
838: um->um_tab.b_actl->b_forw = dp;
839: um->um_tab.b_actl = dp;
840: dp->b_active = 1;
841: }
842: }
843: udinit(d);
844: }
845: }
846:
847: uddump()
848: {
849: return(ENXIO);
850: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.