![[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 [Research Unix] / researchv10dc / lsys / io|
Return to uda.c CVS log | Up to [Research Unix] / researchv10dc / lsys / io |
1.1 root 1: /*
2: * DSA port driver for uda50
3: *
4: * this just passes packets around;
5: * it makes calls to the routines in ra.c
6: * to get the packets filled in
7: */
8:
9: #include "sys/param.h"
10: #include "sys/buf.h"
11: #include "sys/ubaddr.h"
12: #include "sys/uda.h"
13: #include "sys/mscp.h"
14:
15: /*
16: * ONEPATH tries to use only one data path per controller;
17: * a nice idea, but a disaster on the DW780 --
18: * the UDA50 will cheerfully run transfers in parallel from
19: * two drives on the same data path, which confuses the
20: * DW780 and mixes up the data
21: */
22: /* #define ONEPATH 1 /* don't */
23:
24: #define hiword(x) (((long)(x)>>16)&0177777)
25: #define loword(x) ((long)(x)&0177777)
26:
27: extern struct ubaddr udaddr[];
28: extern struct ud ud[];
29: extern int udcnt;
30:
31: struct ctab {
32: int (*c_seql)();
33: int (*c_dg)();
34: int c_ctype;
35: } udctab[MSMAXID];
36:
37: struct device {
38: short udip;
39: short udsa;
40: };
41:
42: /*
43: * bits in udsa
44: */
45:
46: #define ERR 0100000
47: #define STEP4 040000
48: #define STEP3 020000
49: #define STEP2 010000
50: #define STEP1 04000
51: #define STEPS (STEP1|STEP2|STEP3|STEP4)
52:
53: #define IE 0200 /* step1 interrupt enable */
54: #define PI 01 /* step2 purge intr enab */
55: #define GO 01 /* step4 ok */
56:
57: /*
58: * uda communication area
59: * ring sizes are chosen so that,
60: * with 4K byte buffers,
61: * one udcomm + CSIZE-sized command packets will
62: * fit in one buffer;
63: * RSIZE-sized response packets
64: * will fit in another
65: *
66: * ring sizes must be powers of 2
67: * (they are passed as such to the port)
68: *
69: * a delicacy:
70: * command packets should not cross 64Kb boundaries.
71: * it is believed that the KDB50 gets it wrong if they do.
72: * hence, make CSIZE+4 evenly divide a page,
73: * and get it aligned sensibly in bdreset
74: */
75:
76: #define NCP2 5
77: #define NRP2 5
78: #define NCMD (1<<NCP2)
79: #define NRSP (1<<NRP2)
80:
81: struct udcomm {
82: short ud__r0; /* reserved (ugh) */
83: char ud__r1;
84: char ud_bdp; /* path to purge */
85: short ud_cmdint; /* flag for command interrupt */
86: short ud_rspint; /* flag for response interrupt */
87: long ud_rsp[NRSP]; /* response pointer ring */
88: long ud_cmd[NCMD]; /* command pointer ring */
89: };
90:
91: /*
92: * bits in ring pointers
93: */
94:
95: #define DPOWN 0x80000000 /* port owns descriptor */
96: #define DIE 0x40000000 /* ring transition intr enab */
97:
98: #define CSIZE 60 /* max size of command packet */
99: #define RSIZE 60 /* max size of response packet */
100: #define HDRSIZE 4 /* size of the header */
101:
102: struct udcmd {
103: short uc_len; /* length of message */
104: char uc_tc; /* type, credits */
105: char uc_cid; /* connection id */
106: char uc_data[CSIZE];
107: };
108:
109: struct udrsp {
110: short ur_len; /* length of message */
111: char ur_tc; /* type, credits */
112: char ur_cid; /* connection id */
113: char ur_data[RSIZE];
114: };
115:
116: /*
117: * message types
118: */
119:
120: #define MTYPE 0xf0 /* where type lives */
121: #define MTSEQL 0x00 /* sequential message */
122: #define MTDG 0x10 /* datagram */
123: #define MTCR 0x20 /* credit notification */
124:
125: #define MTNC 0xf /* credits in tc */
126:
127: /*
128: * etc
129: */
130:
131: #define PRIINI (PZERO-3)
132: #define PRIPKT (PZERO-2)
133: #define PRICRED (PZERO-1)
134:
135: /*
136: * command packet to index
137: */
138: #define udmptoi(up, mp) ((struct udcmd *)((char *)(mp) - HDRSIZE) - (up)->ud_cpkt)
139:
140: #define TIMEOUT 15 /* time between checks */
141:
142: int udinit(), udsend(), udmap(), udunmap();
143: struct mscmd *udgpkt();
144: struct msportsw udport = {
145: udinit, udgpkt, udmap, udsend, udunmap
146: };
147:
148: /*
149: * init the port
150: * returns nonzero if probably ok
151: * allowed to sleep
152: */
153:
154: #define UDCOFF (((sizeof(struct udcomm)/sizeof(struct udcmd))+1)*sizeof(struct udcmd))
155:
156: udinit(dev, type, force, cid, seql, dg)
157: unsigned int dev;
158: unsigned int cid;
159: int force;
160: int (*seql)(), (*dg)();
161: {
162: register struct ud *up;
163: register int ubno;
164: struct buf *geteblk();
165: extern udtimer();
166:
167: if (dev >= udcnt)
168: return (0);
169: if (cid >= MSMAXID)
170: return (0);
171: udctab[cid].c_seql = seql;
172: udctab[cid].c_dg = dg;
173: udctab[cid].c_ctype = type;
174: up = &ud[dev];
175: ubno = udaddr[dev].ubno;
176: if (up->ud_flags & UISTART && force == 0)
177: return (1);
178: if ((up->ud_addr = (struct device *)ubaddr(&udaddr[dev])) == 0)
179: return (0);
180: if (ubbadaddr(ubno, &up->ud_addr->udsa, sizeof(short))) {
181: printf("ud%d not present\n", dev);
182: return (0);
183: }
184: udrundown(dev);
185: if ((up->ud_flags & UINIT) == 0) {
186: up->ud_cbuf = geteblk();
187: clrbuf(up->ud_cbuf);
188: up->ud_rbuf = geteblk();
189: clrbuf(up->ud_rbuf);
190: up->ud_cbm = ubmbuf(ubno, up->ud_cbuf, 0);
191: up->ud_rbm = ubmbuf(ubno, up->ud_cbuf, 0);
192: #if ONEPATH
193: up->ud_bdpno = ubmapath(ubno);
194: #endif
195: up->ud_comm = (struct udcomm *)up->ud_cbuf->b_un.b_addr;
196: up->ud_cpkt = (struct udcmd *)(up->ud_cbuf->b_un.b_addr + UDCOFF);
197: up->ud_rpkt = (struct udrsp *)up->ud_rbuf->b_un.b_addr;
198: up->ud_flags |= UINIT;
199: timeout(udtimer, (caddr_t)dev, TIMEOUT * HZ);
200: }
201: return (udreset(dev));
202: }
203:
204: /*
205: * reset device
206: * initially or after error or power fail
207: */
208:
209: #define INITSTALL 100000 /* >>600us */
210:
211: udreset(dev)
212: int dev;
213: {
214: register struct ud *up;
215: register struct device *rp;
216: register uaddr_t pa;
217: register int i;
218:
219: up = &ud[dev];
220: rp = up->ud_addr;
221: up->ud_flags &=~ UIDONE;
222: up->ud_flags |= UISTART;
223: rp->udip = 0; /* hard reset */
224: pa = ubadbuf(udaddr[dev].ubno, up->ud_cbuf, up->ud_cbm);
225: up->ud_pcomm = pa + (4 * sizeof(short)); /* -> ud_rsp */
226: up->ud_pcpkt = pa + UDCOFF;
227: up->ud_cnext = 0;
228: up->ud_rnext = 0;
229: up->ud_credits = 0;
230: for (i = 0; (rp->udsa & STEP1) == 0 && i < INITSTALL; i++)
231: ;
232: if ((rp->udsa & STEP1) == 0) {
233: up->ud_flags &=~ UISTART;
234: printf("ud%d won't init\n", dev);
235: return (0);
236: }
237: rp->udsa = ERR | IE | (NCP2<<11) | (NRP2<<8) | (udaddr[dev].vec>>2);
238: return (1);
239: }
240:
241: /*
242: * finish up init, step by step
243: * called from interrupt code
244: */
245:
246: udinintr(dev)
247: int dev;
248: {
249: register struct ud *up;
250: register struct device *rp;
251: register int i;
252: register uaddr_t pa;
253:
254: up = &ud[dev];
255: rp = up->ud_addr;
256: if (up->ud_flags & UIDONE) {
257: printf("ud%d: unexpected init: sa %o\n", dev, rp->udsa);
258: return;
259: }
260: switch (rp->udsa & STEPS) {
261: case STEP1:
262: udreset(dev);
263: return;
264:
265: case STEP2:
266: rp->udsa = PI | loword(up->ud_pcomm);
267: return;
268:
269: case STEP3:
270: rp->udsa = hiword(up->ud_pcomm);
271: return;
272:
273: case STEP4:
274: rp->udsa = GO;
275: for (i = 0; i < NCMD; i++) {
276: up->ud_comm->ud_cmd[i] = 0; /* unnecessary */
277: up->ud_cpkt[i].uc_len = CSIZE;
278: up->ud_cbusy[i] = FREE;
279: up->ud_back[i] = NOBACK;
280: }
281: pa = ubadbuf(udaddr[dev].ubno, up->ud_rbuf, up->ud_rbm);
282: pa += 2 * sizeof(short);
283: for (i = 0; i < NRSP; i++, pa += sizeof(struct udrsp)) {
284: up->ud_comm->ud_rsp[i] = pa | DIE | DPOWN;
285: up->ud_rpkt[i].ur_len = RSIZE;
286: }
287: up->ud_flags |= UIDONE | UFIRST;
288: wakeup((caddr_t)up);
289: return;
290:
291: default:
292: printf("ud%d init bad: sa %o\n", dev, rp->udsa);
293: return;
294: }
295: }
296:
297: /*
298: * tell the class drivers that the controller was reset
299: * so they can clean up
300: * called after controller is stopped (so it's safe to unmap things)
301: */
302: udrundown(dev)
303: int dev;
304: {
305: static struct msend me;
306: register int i;
307:
308: me.m_sts = STRST; /* magic */
309: for (i = 0; i < MSMAXID; i++)
310: if (udctab[i].c_seql)
311: (*udctab[i].c_seql)(dev, udctab[i].c_ctype, &me);
312: }
313:
314: /*
315: * allocate a packet
316: * and sufficient resources to send it
317: * eg credits
318: * may sleep
319: *
320: * somewhat silly assumption:
321: * class driver will allocate a packet, and send it right away or nearly so
322: */
323:
324: struct mscmd *
325: udgpkt(dev)
326: int dev;
327: {
328: register struct ud *up;
329: register int i;
330: int s;
331:
332: up = &ud[dev];
333: if (up->ud_addr->udsa & STEP1) /* was reset somehow */
334: udreset(dev);
335: s = spl6();
336: while ((up->ud_flags & UIDONE) == 0)
337: sleep((caddr_t)up, PRIINI);
338: while (up->ud_credits < 2 && (up->ud_flags & UFIRST) == 0) {
339: if (udpkscan(dev, 1))
340: continue;
341: up->ud_flags |= UCWAIT;
342: sleep((caddr_t)&up->ud_credits, PRICRED);
343: }
344: if ((up->ud_flags & UFIRST) == 0)
345: up->ud_credits--;
346: for (;;) {
347: for (i = 0; i < NCMD; i++)
348: if (up->ud_cbusy[i] == FREE)
349: break;
350: if (i < NCMD)
351: break;
352: if (udpkscan(dev, 1) == 0 && udcmdscan(dev) == 0) { /* kludge for hung controller */
353: up->ud_flags |= UPWAIT;
354: sleep((caddr_t)up->ud_cbusy, PRIPKT);
355: }
356: }
357: up->ud_cbusy[i] = NABBED;
358: splx(s);
359: return ((struct mscmd *)up->ud_cpkt[i].uc_data);
360: }
361:
362: /*
363: * map a transfer into unibus space
364: * and record in the buffer descriptor of a packet
365: * may sleep
366: */
367:
368: udmap(dev, mp, bp)
369: int dev;
370: struct mscmd *mp;
371: register struct buf *bp;
372: {
373: register struct ud *up;
374: register int i;
375:
376: up = &ud[dev];
377: i = udmptoi(up, mp);
378: #if ONEPATH
379: if (up->ud_cmap[i] == 0)
380: up->ud_cmap[i] = ubmbuf(udaddr[dev].ubno, bp, USLP);
381: up->ud_cmap[i] = ubinspath(up->ud_bdpno, up->ud_cmap[i]);
382: #else
383: if (up->ud_cmap[i] == 0)
384: up->ud_cmap[i] = ubmbuf(udaddr[dev].ubno, bp, UBDP|USLP);
385: #endif
386: up->ud_cbusy[i] |= MAPPED;
387: *(long *)&mp->m_buff = ubadbuf(udaddr[dev].ubno, bp, up->ud_cmap[i]);
388: #if ONEPATH
389: *(long *)&mp->m_buff |= up->ud_bdpno << 24;
390: #else
391: *(long *)&mp->m_buff |= ubmpath(up->ud_cmap[i]) << 24;
392: #endif
393: }
394:
395: /*
396: * free a mapped packet
397: * flush the bdp;
398: * change the path in the map to the DDP before freeing (ugh)
399: * so we won't free our reserved BDP too
400: * it is OK to free an already freed packet, mostly to help reset code
401: */
402:
403: udunmap(dev, mp)
404: int dev;
405: struct mscmd *mp;
406: {
407: register struct ud *up;
408: register int i;
409:
410: up = &ud[dev];
411: i = udmptoi(up, mp);
412: if (up->ud_cmap[i]) {
413: #if ONEPATH
414: ubmflush(udaddr[dev].ubno, ubmpath(up->ud_cmap[i]));
415: ubmfree(udaddr[dev].ubno, ubinspath(0, up->ud_cmap[i]));
416: #else
417: ubmfree(udaddr[dev].ubno, up->ud_cmap[i]);
418: #endif
419: up->ud_cmap[i] = 0;
420: }
421: up->ud_cbusy[i] = FREE;
422: if (up->ud_flags & UPWAIT) {
423: up->ud_flags &=~ UPWAIT;
424: wakeup((caddr_t)up->ud_cbusy);
425: }
426: }
427:
428:
429: /*
430: * send a packet
431: * may not sleep
432: * call at spl5
433: */
434: udsend(dev, cid, mp)
435: int dev;
436: int cid;
437: struct mscmd *mp;
438: {
439: register struct ud *up;
440: register int i;
441: register int j;
442: register struct device *rp;
443:
444: up = &ud[dev];
445: up->ud_flags &=~ UFIRST;
446: i = udmptoi(up, mp);
447: up->ud_cpkt[i].uc_cid = cid;
448: j = up->ud_cnext++;
449: if (up->ud_cnext >= NCMD)
450: up->ud_cnext = 0;
451: if (up->ud_comm->ud_cmd[j] & DPOWN)
452: panic("udsend");
453: if (up->ud_back[j] >= 0) { /* ran for a while with no free */
454: udcmdscan(dev);
455: if (up->ud_back[j] >= 0)
456: panic("udsend");
457: }
458: rp = up->ud_addr;
459: if (rp->udsa & ERR) { /* and now we lose a packet */
460: printf("ud%d: hard error %o\n", dev, rp->udsa & 0177777);
461: udreset(dev);
462: return;
463: }
464: up->ud_back[j] = i;
465: up->ud_comm->ud_cmd[j] = DPOWN | DIE |
466: up->ud_pcpkt + (i * sizeof(struct udcmd)) + (2 * sizeof(short));
467: up->ud_cbusy[i] |= SENT;
468: up->ud_cbusy[i] &=~ NABBED;
469: i = rp->udip; /* initiate polling */
470: }
471:
472: /*
473: * interrupt routine
474: */
475:
476: long ud_spur;
477: long ud_npr;
478: #define INIRETRY 5 /* TQK50 botch -- needs time to settle */
479:
480: ud0int(dev)
481: int dev;
482: {
483: register struct ud *up;
484: register struct device *rp;
485: register int i;
486:
487: up = &ud[dev];
488: if (dev >= udcnt || (up->ud_flags & UINIT) == 0) {
489: printf("ud%d: stray intr\n", dev);
490: return;
491: }
492: rp = up->ud_addr;
493: if ((up->ud_flags & UIDONE) == 0) {
494: for (i = 0; i < INIRETRY; i++)
495: if (rp->udsa & (STEPS|ERR))
496: break;
497: if ((rp->udsa & (STEPS|ERR)) == 0) {
498: printf("ud%d: init lost; sa 0%o\n", dev, rp->udsa);
499: return;
500: }
501: }
502: if (rp->udsa & ERR) {
503: printf("ud%d: hard error %o\n", dev, rp->udsa & 0177777);
504: udreset(dev);
505: return;
506: }
507: if (rp->udsa & STEPS) {
508: udinintr(dev);
509: return;
510: }
511: if (up->ud_comm->ud_bdp == 0
512: && up->ud_comm->ud_cmdint == 0
513: && up->ud_comm->ud_rspint == 0)
514: ud_spur++;
515: if (up->ud_comm->ud_bdp) {
516: ubmflush(udaddr[dev].ubno, up->ud_comm->ud_bdp);
517: up->ud_comm->ud_bdp = 0;
518: rp->udsa = 0; /* ack purge */
519: ud_npr++;
520: }
521: while (up->ud_comm->ud_cmdint) {
522: up->ud_comm->ud_cmdint = 0;
523: udcmdscan(dev);
524: }
525: while (up->ud_comm->ud_rspint) {
526: up->ud_comm->ud_rspint = 0;
527: if (udpkscan(dev, 0))
528: up->ud_flags &=~ UTIMER;
529: }
530: }
531:
532: /*
533: * free packets which are completely sent
534: * (and which don't have associated map)
535: */
536:
537: udcmdscan(dev)
538: int dev;
539: {
540: register struct ud *up;
541: register int i, j;
542: register int freed;
543: register struct udcomm *udc;
544:
545: up = &ud[dev];
546: udc = up->ud_comm;
547: freed = 0;
548: for (j = 0; j < NCMD; j++)
549: if (up->ud_back[j] >= 0
550: && (udc->ud_cmd[j] & DPOWN) == 0) {
551: i = up->ud_back[j];
552: if ((up->ud_cbusy[i] & (SENT|MAPPED)) == SENT) {
553: up->ud_cbusy[i] = FREE;
554: freed++;
555: }
556: up->ud_back[j] = NOBACK;
557: }
558: if (freed && up->ud_flags & UPWAIT)
559: wakeup((caddr_t)up->ud_cbusy);
560: return (freed);
561: }
562:
563: /*
564: * check for responses from the controller
565: * and deal with them
566: * return a count for debugging purposes
567: * called at spl6 (because of udtimer)
568: */
569:
570: int
571: udpkscan(dev, doall)
572: int dev;
573: int doall;
574: {
575: register struct ud *up;
576: register int i;
577: int nf;
578: register struct udrsp *pk;
579: register struct ctab *cp;
580: register struct udcomm *udc; /* speed */
581:
582: up = &ud[dev];
583: udc = up->ud_comm;
584: nf = 0;
585: for (i = up->ud_rnext; ; i < NRSP-1 ? i++ : (i=0)) {
586: if (udc->ud_rsp[i] & DPOWN) {
587: up->ud_rnext = i;
588: /* don't stop if doall? */
589: break;
590: }
591: nf++;
592: pk = &up->ud_rpkt[i];
593: up->ud_credits += pk->ur_tc & MTNC;
594: if (up->ud_flags & UCWAIT) {
595: wakeup((caddr_t)&up->ud_credits);
596: up->ud_flags &=~ UCWAIT;
597: }
598: if (pk->ur_cid > MSMAXID)
599: printf("ud%d msg id %d\n", dev, pk->ur_cid);
600: else {
601: cp = &udctab[pk->ur_cid];
602: switch (pk->ur_tc & MTYPE) {
603: case MTSEQL:
604: if (cp->c_seql)
605: (*cp->c_seql)(dev, cp->c_ctype, (struct msend *)pk->ur_data);
606: break;
607:
608: case MTDG:
609: if (cp->c_dg)
610: (*cp->c_dg)(dev, cp->c_ctype, pk->ur_data);
611: break;
612:
613: /* default: ignore */
614: }
615: }
616: pk->ur_len = RSIZE;
617: udc->ud_rsp[i] |= DPOWN | DIE;
618: }
619: return (nf);
620: }
621:
622: /*
623: * timeout routine
624: * return any waiting packets
625: * -- callout routines don't necessarily run at high priority.
626: * hence the spl6, so udpkscan won't be reentered
627: */
628:
629: int ud_kicked;
630:
631: udtimer(i)
632: int i;
633: {
634: register struct ud *up;
635: register int s;
636:
637: up = &ud[i];
638: if ((up->ud_flags & UINIT) == 0)
639: return;
640: if (up->ud_flags & UIDONE) {
641: if ((up->ud_flags & UTIMER) == 0)
642: up->ud_flags |= UTIMER;
643: else {
644: s = spl6();
645: if (udpkscan(i, 1) && up->ud_flags & UPWAIT) {
646: wakeup((caddr_t)up->ud_cbusy);
647: ud_kicked++;
648: }
649: splx(s);
650: up->ud_flags &=~ UTIMER;
651: }
652: }
653: timeout(udtimer, (caddr_t)i, TIMEOUT * HZ);
654: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.