![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bda.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / io|
Return to bda.c CVS log | Up to [Research Unix] / researchv10no / sys / io |
1.1 root 1: /*
2: * DSA port driver for KDB50 (aka BDA)
3: * called by, e.g., ra.c
4: */
5:
6: #include "sys/param.h"
7: #include "sys/buf.h"
8: #include "sys/biic.h"
9: #include "sys/biaddr.h"
10: #include "sys/map.h"
11: #include "sys/bda.h"
12: #include "sys/mscp.h"
13: #include "sys/pte.h"
14:
15: #define hiword(x) (((long)(x)>>16)&0177777)
16: #define loword(x) ((long)(x)&0177777)
17:
18: extern struct biaddr bdaddr[];
19: extern struct bd bd[];
20: extern int bdcnt;
21: struct ctab {
22: int (*c_seql)();
23: int (*c_dg)();
24: int c_ctype;
25: } bdctab[MSMAXID];
26:
27: /*
28: * bd_flags
29: */
30:
31: #define UINIT 01 /* already did trivial init */
32: #define UIDONE 02 /* initialization all done */
33: #define UPWAIT 04 /* waiting for command packet */
34: #define UFIRST 010 /* let first packet go even if no credits */
35: #define UTIMER 020 /* timer will kick on next go */
36: #define UCWAIT 040 /* waiting for credits */
37: #define UPMWAIT 0100 /* waiting for map */
38:
39: #define NOBACK (-1)
40:
41: /*
42: * bd_cbusy
43: */
44:
45: #define FREE 0
46: #define NABBED 01
47: #define SENT 02
48: #define MAPPED 04
49:
50: /*
51: * bdip is really bigpr0 in struct biic
52: */
53:
54: struct device {
55: short bdxx; /* unused */
56: short bdip;
57: short bdsar;
58: short bdsaw;
59: };
60:
61: #define bdaregs(p) ((struct device *)&((p)->bigpr0))
62:
63: /*
64: * bits in bdsa (variously read and write half)
65: */
66:
67: #define ERR 0100000
68: #define STEP4 040000
69: #define STEP3 020000
70: #define STEP2 010000
71: #define STEP1 04000
72: #define STEPS (STEP1|STEP2|STEP3|STEP4)
73:
74: #define IE 0200 /* step1 interrupt enable */
75: #define PI 01 /* step2 purge intr enab */
76: #define GO 01 /* step4 ok */
77:
78: /*
79: * bda communication area
80: * ring sizes are chosen so that,
81: * with 4K byte buffers,
82: * one bdcomm + CSIZE-sized command packets will
83: * fit in one buffer;
84: * RSIZE-sized response packets
85: * will fit in another
86: *
87: * ring sizes must be powers of 2
88: * (they are passed as such to the port)
89: *
90: * a delicacy:
91: * command packets should not cross 64Kb boundaries.
92: * it is believed that the KDB50 gets it wrong if they do.
93: * hence, make CSIZE+4 evenly divide a page,
94: * and get it aligned sensibly in bdreset
95: */
96:
97: #define NCP2 5
98: #define NRP2 5
99: #define NCMD (1<<NCP2)
100: #define NRSP (1<<NRP2)
101:
102: struct bdcomm {
103: short bd__r0; /* reserved (ugh) */
104: char bd__r1;
105: char bd_bdp; /* path to purge */
106: short bd_cmdint; /* flag for command interrupt */
107: short bd_rspint; /* flag for response interrupt */
108: long bd_rsp[NRSP]; /* response pointer ring */
109: long bd_cmd[NCMD]; /* command pointer ring */
110: };
111:
112: /*
113: * bits in ring pointers
114: */
115:
116: #define DPOWN 0x80000000 /* port owns descriptor */
117: #define DIE 0x40000000 /* ring transition intr enab */
118:
119: #define BDAVIRT 0x80000000 /* in m_buff: mapped transfer */
120: #define V 0x80000000 /* valid bit in page map */
121:
122: #define CSIZE 60 /* max size of command packet */
123: #define RSIZE 60 /* max size of response packet */
124: #define HDRSIZE 4 /* size of the header */
125:
126: struct bdcmd {
127: short uc_len; /* length of message */
128: char uc_tc; /* type, credits */
129: char uc_cid; /* connection id */
130: char uc_data[CSIZE];
131: };
132:
133: struct bdrsp {
134: short ur_len; /* length of message */
135: char ur_tc; /* type, credits */
136: char ur_cid; /* connection id */
137: char ur_data[RSIZE];
138: };
139:
140: /*
141: * message types
142: */
143:
144: #define MTYPE 0xf0 /* where type lives */
145: #define MTSEQL 0x00 /* sequential message */
146: #define MTDG 0x10 /* datagram */
147: #define MTCR 0x20 /* credit notification */
148:
149: #define MTNC 0xf /* credits in tc */
150:
151: /*
152: * etc
153: */
154:
155: #define PRIINI (PZERO-3)
156: #define PRIPKT (PZERO-2)
157: #define PRICRED (PZERO-1)
158:
159: /*
160: * command packet to index
161: */
162: #define bdmptoi(up, mp) ((struct bdcmd *)((char *)(mp) - HDRSIZE) - (up)->bd_cpkt)
163:
164: #define TIMEOUT 10 /* time between checks */
165:
166: int bdinit(), bdsend(), bdmap(), bdunmap();
167: struct mscmd *bdgpkt();
168: struct msportsw bdport = {
169: bdinit, bdgpkt, bdmap, bdsend, bdunmap
170: };
171:
172: /*
173: * init the port
174: * called once only
175: * returns nonzero if probably ok
176: * allowed to sleep
177: */
178:
179: bdinit(dev, type, force, cid, seql, dg)
180: unsigned int dev;
181: unsigned int cid;
182: int force;
183: int (*seql)(), (*dg)();
184: {
185: register struct bd *up;
186: struct buf *geteblk();
187: extern bdtimer();
188:
189: if (dev >= bdcnt)
190: return (0);
191: if (cid >= MSMAXID)
192: return (0);
193: bdctab[cid].c_seql = seql;
194: bdctab[cid].c_dg = dg;
195: bdctab[cid].c_ctype = type;
196: up = &bd[dev];
197: if (up->bd_flags & UINIT && force == 0)
198: return (1);
199: if ((up->bd_addr = (struct biic *)biaddr(&bdaddr[dev])) == 0) {
200: printf("bd%d absent\n", dev);
201: return (0);
202: }
203: bdrundown(dev);
204: if ((up->bd_flags & UINIT) == 0) {
205: up->bd_cbuf = geteblk();
206: clrbuf(up->bd_cbuf);
207: up->bd_rbuf = geteblk();
208: clrbuf(up->bd_rbuf);
209: up->bd_mbuf = geteblk();
210: clrbuf(up->bd_mbuf);
211: up->bd_comm = (struct bdcomm *)up->bd_cbuf->b_un.b_addr;
212: #define BDCOFF (((sizeof(struct bdcomm)/sizeof(struct bdcmd))+1)*sizeof(struct bdcmd))
213: up->bd_cpkt = (struct bdcmd *)(up->bd_cbuf->b_un.b_addr + BDCOFF);
214: up->bd_rpkt = (struct bdrsp *)up->bd_rbuf->b_un.b_addr;
215: up->bd_pmap = (long *)up->bd_mbuf->b_un.b_addr;
216: up->bd_flags |= UINIT;
217: timeout(bdtimer, (caddr_t)dev, TIMEOUT * HZ);
218: }
219: bdreset(dev);
220: return (1);
221: }
222:
223: /*
224: * reset device
225: * initially or after error or power fail
226: *
227: * just kick the device here;
228: * ideally we would get an interrupt when self-test finishes
229: * (step 1 starts) but we don't, so let the timer routine catch it
230: */
231:
232: bdreset(dev)
233: register int dev;
234: {
235: register struct bd *up;
236:
237: up = &bd[dev];
238: up->bd_flags &=~ UIDONE;
239: up->bd_addr->bicsr |= BINRST; /* hard reset */
240: }
241:
242: /*
243: * finish up init, step by step
244: * called from interrupt code
245: */
246:
247: bdinintr(dev)
248: register int dev;
249: {
250: register struct bd *up;
251: register struct device *rp;
252: register struct biic *bi;
253:
254: up = &bd[dev];
255: rp = bdaregs(up->bd_addr);
256: if (up->bd_flags & UIDONE)
257: printf("bd%d: unexpected init: sa %o\n", dev, rp->bdsar);
258: switch (rp->bdsar & STEPS) {
259: case STEP1:
260: up->bd_cnext = 0;
261: up->bd_rnext = 0;
262: up->bd_credits = 0;
263: bi = up->bd_addr;
264: biinit(&bdaddr[dev], 0);
265: bi->biuir = bdaddr[dev].vec;
266: bi->bieir = (bdaddr[dev].vec + sizeof(long))|EIBR5;
267: rp->bdsaw = ERR | IE | (NCP2<<11) | (NRP2<<8);
268: return;
269:
270: case STEP2:
271: rp->bdsaw = PI | loword(physadr(up->bd_comm->bd_rsp));
272: return;
273:
274: case STEP3:
275: rp->bdsaw = hiword(physadr(up->bd_comm->bd_rsp));
276: return;
277:
278: case STEP4:
279: rp->bdsaw = GO;
280: for (dev = 0; dev < NCMD; dev++) {
281: up->bd_comm->bd_cmd[dev] = 0; /* unnecessary */
282: up->bd_cpkt[dev].uc_len = CSIZE;
283: up->bd_back[dev] = NOBACK;
284: }
285: for (dev = 0; dev < NRSP; dev++) {
286: up->bd_rpkt[dev].ur_len = RSIZE;
287: up->bd_comm->bd_rsp[dev] = physadr(up->bd_rpkt[dev].ur_data) | DIE | DPOWN;
288: }
289: up->bd_flags |= UIDONE | UFIRST;
290: rminit(up->bd_map, BDANMAP, (up->bd_mbuf->b_bcount/sizeof(long))-1, 1);
291: wakeup((caddr_t)up);
292: return;
293:
294: default:
295: printf("bd%d init bad: sar %o\n", dev, rp->bdsar);
296: return;
297: }
298: }
299:
300: /*
301: * tell the class drivers that the controller was reset
302: * so they can clean up
303: * called after controller is stopped (so it's safe to unmap things)
304: */
305: bdrundown(dev)
306: int dev;
307: {
308: static struct msend me;
309: register int i;
310:
311: me.m_sts = STRST; /* magic */
312: for (i = 0; i < MSMAXID; i++)
313: if (bdctab[i].c_seql)
314: (*bdctab[i].c_seql)(dev, bdctab[i].c_ctype, &me);
315: }
316:
317: /*
318: * allocate a packet
319: * and sufficient resources to send it
320: * eg credits
321: * may sleep
322: *
323: * somewhat silly assumption:
324: * class driver will allocate a packet, and send it right away or nearly so
325: */
326:
327: struct mscmd *
328: bdgpkt(dev)
329: int dev;
330: {
331: register struct bd *up;
332: register int i;
333: int s;
334:
335: up = &bd[dev];
336: s = spl6();
337: while ((up->bd_flags & UIDONE) == 0)
338: sleep((caddr_t)up, PRIINI);
339: while (up->bd_credits < 2 && (up->bd_flags & UFIRST) == 0) {
340: if (bdpkscan(dev, 1))
341: continue;
342: up->bd_flags |= UCWAIT;
343: sleep((caddr_t)&up->bd_credits, PRICRED);
344: }
345: if ((up->bd_flags & UFIRST) == 0)
346: up->bd_credits--;
347: for (;;) {
348: for (i = 0; i < NCMD; i++)
349: if (up->bd_cbusy[i] == FREE)
350: break;
351: if (i < NCMD)
352: break;
353: if (bdpkscan(dev, 1) == 0 && bdcmdscan(dev) == 0) { /* kludge for hung controller */
354: up->bd_flags |= UPWAIT;
355: sleep((caddr_t)up->bd_cbusy, PRIPKT);
356: }
357: }
358: up->bd_cbusy[i] = NABBED;
359: splx(s);
360: return ((struct mscmd *)up->bd_cpkt[i].uc_data);
361: }
362:
363: /*
364: * map a transfer if need be
365: * and record in the buffer descriptor of a packet
366: * may sleep
367: *
368: * BDA use of m_buff:
369: * first longword is buffer address;
370: * if BDAVIRT clear, physical addr, else virtual
371: * second longword is phys addr of base of page table if virtual
372: *
373: * subtlety: pretend we mapped it even if we didn't,
374: * so it won't be unmapped until someone calls bdunmap
375: * else they may be confused when they call it anyway
376: */
377:
378: bdmap(dev, mp, bp)
379: int dev;
380: struct mscmd *mp;
381: register struct buf *bp;
382: {
383: register int i;
384: register long *b;
385: register struct pte *pt;
386: int s;
387: int base;
388: register int size;
389: register struct bd *up;
390:
391: up = &bd[dev];
392: i = bdmptoi(up, mp);
393: up->bd_cbusy[i] |= MAPPED;
394: if ((bp->b_flags & (B_PHYS|B_UAREA|B_PAGET|B_DIRTY)) == 0) {
395: b = (long *)&mp->m_buff;
396: *b++ = (long)bp->b_un.b_addr|BDAVIRT;
397: *b++ = physadr(Sysmap);
398: *b = 0;
399: return;
400: }
401: size = btoc(bp->b_bcount);
402: if ((long)bp->b_un.b_addr & PGOFSET)
403: size++; /* unaligned */
404: s = spl6();
405: while ((base = rmalloc(up->bd_map, size)) == 0) {
406: up->bd_flags |= UPMWAIT;
407: sleep((caddr_t)up->bd_map, PRIPKT);
408: }
409: splx(s);
410: up->bd_mbase[i] = base;
411: up->bd_msize[i] = size;
412: b = &up->bd_pmap[base];
413: pt = btopte(bp);
414: while (--size >= 0)
415: *b++ = pt++->pg_pfnum | V;
416: b = (long *)&mp->m_buff;
417: *b++ = ctob(base)|((long)bp->b_un.b_addr&PGOFSET)|BDAVIRT;
418: *b++ = physadr(up->bd_pmap);
419: *b = 0;
420: }
421:
422: /*
423: * free a mapped packet
424: */
425:
426: bdunmap(dev, mp)
427: int dev;
428: struct mscmd *mp;
429: {
430: register struct bd *up;
431: register int i;
432:
433: up = &bd[dev];
434: i = bdmptoi(up, mp);
435: if (up->bd_cbusy[i] == FREE)
436: return; /* wasn't mapped, and already freed */
437: if (up->bd_msize[i]) {
438: rmfree(up->bd_map, up->bd_msize[i], up->bd_mbase[i]);
439: up->bd_msize[i] = 0;
440: if (up->bd_flags & UPMWAIT) {
441: up->bd_flags &=~ UPMWAIT;
442: wakeup((caddr_t)up->bd_map);
443: }
444: }
445: up->bd_cbusy[i] = FREE;
446: if (up->bd_flags & UPWAIT) {
447: up->bd_flags &=~ UPWAIT;
448: wakeup((caddr_t)up->bd_cbusy);
449: }
450: }
451:
452: /*
453: * send a packet
454: * may not sleep
455: * call at spl5
456: */
457:
458: bdsend(dev, cid, mp)
459: int dev;
460: int cid;
461: struct mscmd *mp;
462: {
463: register struct bd *up;
464: register int i;
465: register int j;
466:
467: up = &bd[dev];
468: up->bd_flags &=~ UFIRST;
469: i = bdmptoi(up, mp);
470: up->bd_cpkt[i].uc_cid = cid;
471: j = up->bd_cnext++;
472: if (up->bd_cnext >= NCMD)
473: up->bd_cnext = 0;
474: if (up->bd_comm->bd_cmd[j] & DPOWN)
475: panic("bdsend");
476: if (up->bd_back[j] >= 0) { /* ran for a while with no free */
477: bdcmdscan(dev);
478: if (up->bd_back[j] >= 0)
479: panic("bdsend");
480: }
481: up->bd_back[j] = i;
482: up->bd_comm->bd_cmd[j] = DPOWN | DIE | physadr(mp);
483: up->bd_cbusy[i] |= SENT;
484: up->bd_cbusy[i] &=~ NABBED;
485: i = bdaregs(up->bd_addr)->bdip; /* initiate polling */
486: }
487:
488: /*
489: * interrupt routine
490: */
491:
492: long bd_spur;
493: int bdspl;
494:
495: bd0int(dev)
496: int dev;
497: {
498: register struct bd *up;
499: register struct device *rp;
500:
501: bdspl = mfpr(0x12);
502: up = &bd[dev];
503: if (dev >= bdcnt || (up->bd_flags & UINIT) == 0) {
504: printf("bd%d: stray intr\n", dev);
505: return;
506: }
507: rp = bdaregs(up->bd_addr);
508: if (rp->bdsar & ERR) {
509: printf("bd%d: hard error %o\n", dev, rp->bdsar & 0177777);
510: bdreset(dev);
511: return;
512: }
513: if (rp->bdsar & STEPS) {
514: bdinintr(dev);
515: return;
516: }
517: if (up->bd_comm->bd_cmdint == 0
518: && up->bd_comm->bd_rspint == 0)
519: bd_spur++;
520: while (up->bd_comm->bd_cmdint) {
521: up->bd_comm->bd_cmdint = 0;
522: bdcmdscan(dev);
523: }
524: while (up->bd_comm->bd_rspint) {
525: up->bd_comm->bd_rspint = 0;
526: if (bdpkscan(dev, 0))
527: up->bd_flags &=~ UTIMER;
528: }
529: }
530:
531: bd1int(dev)
532: int dev;
533: {
534: printf("bd%d: error intr\n", dev);
535: }
536:
537: /*
538: * free packets which are completely sent
539: * (and which don't have associated map)
540: */
541:
542: bdcmdscan(dev)
543: int dev;
544: {
545: register struct bd *up;
546: register int i, j;
547: register int freed;
548: register struct bdcomm *bdc;
549:
550: up = &bd[dev];
551: bdc = up->bd_comm;
552: freed = 0;
553: for (j = 0; j < NCMD; j++)
554: if (up->bd_back[j] >= 0
555: && (bdc->bd_cmd[j] & DPOWN) == 0) {
556: i = up->bd_back[j];
557: if ((up->bd_cbusy[i] & (SENT|MAPPED)) == SENT) {
558: up->bd_cbusy[i] = FREE;
559: freed++;
560: }
561: up->bd_back[j] = NOBACK;
562: }
563: if (freed && up->bd_flags & UPWAIT)
564: wakeup((caddr_t)up->bd_cbusy);
565: return (freed);
566: }
567:
568: /*
569: * check for responses from the controller
570: * and deal with them
571: * return a count for debugging purposes
572: */
573:
574: int
575: bdpkscan(dev, doall)
576: int dev;
577: int doall;
578: {
579: register struct bd *up;
580: register int i;
581: int nf;
582: register struct bdrsp *pk;
583: register struct ctab *cp;
584: register struct bdcomm *bdc; /* speed */
585: int s;
586:
587: up = &bd[dev];
588: bdc = up->bd_comm;
589: nf = 0;
590: s = spl6();
591: for (i = up->bd_rnext; ; i < NRSP-1 ? i++ : (i = 0)) {
592: if (bdc->bd_rsp[i] & DPOWN) {
593: up->bd_rnext = i;
594: /* don't stop if doall? */
595: break;
596: }
597: nf++;
598: pk = &up->bd_rpkt[i];
599: up->bd_credits += pk->ur_tc & MTNC;
600: if (up->bd_flags & UCWAIT) {
601: wakeup((caddr_t)&up->bd_credits);
602: up->bd_flags &=~ UCWAIT;
603: }
604: if (pk->ur_cid > MSMAXID)
605: printf("bd%d msg id %d\n", dev, pk->ur_cid);
606: else {
607: cp = &bdctab[pk->ur_cid];
608: switch (pk->ur_tc & MTYPE) {
609: case MTSEQL:
610: if (cp->c_seql)
611: (*cp->c_seql)(dev, cp->c_ctype, (struct msend *)pk->ur_data);
612: break;
613:
614: case MTDG:
615: if (cp->c_dg)
616: (*cp->c_dg)(dev, cp->c_ctype, pk->ur_data);
617: break;
618:
619: /* default: ignore */
620: }
621: }
622: pk->ur_len = RSIZE;
623: bdc->bd_rsp[i] |= DPOWN | DIE;
624: }
625: splx(s);
626: return (nf);
627: }
628:
629: /*
630: * timeout routine
631: * return any waiting packets
632: * -- callout routines don't necessarily run at high priority.
633: * hence the spl6, so bdpkscan won't be reentered
634: */
635:
636: int bd_kicked;
637:
638: bdtimer(i)
639: int i;
640: {
641: register struct bd *up;
642: register int s;
643:
644: up = &bd[i];
645: if ((up->bd_flags & UINIT) == 0)
646: return;
647: if ((up->bd_flags & UIDONE) == 0) {
648: if ((bdaregs(up->bd_addr)->bdsar & STEPS) == STEP1)
649: bdinintr(i);
650: }
651: else if ((up->bd_flags & UTIMER) == 0)
652: up->bd_flags |= UTIMER;
653: else {
654: s = spl6();
655: if (bdpkscan(i, 1) && up->bd_flags & UPWAIT) {
656: wakeup((caddr_t)up->bd_cbusy);
657: bd_kicked++;
658: }
659: splx(s);
660: up->bd_flags &=~ UTIMER;
661: }
662: timeout(bdtimer, (caddr_t)i, TIMEOUT * HZ);
663: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.