![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to np.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba|
Return to np.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / sys / vaxuba |
1.1 root 1: /*
2: * Copyright (c) 1986 MICOM-Interlan, Inc., Boxborough Mass
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)np.c 7.3 (Berkeley) 4/16/87
7: *
8: * From:
9: * np.c version 1.5
10: *
11: * This version retrieved: 8/18/86 @ 18:58:54
12: * This delta created: 8/18/86 @ 18:19:24
13: *
14: * static char *SCCSID = "@(#)np.c 1.5";
15: *
16: */
17:
18: /******************************************
19: * *
20: * NPDRIVER *
21: * *
22: ******************************************/
23:
24: /*
25: * The NP Driver is used to route requests, independent of protocol type,
26: * to the NP series Intelligent Board. The facilities it provides are
27: * used for board maintainance by the superuser and by protocol pseudo-drivers,
28: * such as WN, for sending requests to a board. The board maintainance and
29: * control functions are accessed via npioctl() by the NP support utilities.
30: */
31:
32: /*
33: * Modification History:
34: * 4/9/86 DDW Removed pseudo-driver initialization flag resets from NpReset
35: * 5/28/86 CJM Changed iodone() to wakeup() in NpProcQueue().
36: *
37: */
38:
39: /*
40: * Include Files
41: */
42:
43: #include "np.h"
44: #if NNP > 0
45: #include "../h/param.h"
46: #include "../h/buf.h"
47: #include "../vaxuba/ubavar.h"
48: #include "../h/signal.h"
49: #include "../h/systm.h"
50: #include "../h/dir.h"
51: #include "../h/user.h"
52: #include "../h/proc.h"
53: #include "../h/uio.h"
54: #include "../h/errno.h"
55:
56: #include "../vaxuba/npreg.h"
57:
58: #define b_uio b_forw
59: #define b_rp av_back
60: /*
61: * Global variables for pseudo-drivers.
62: */
63:
64: int WnInitFlag = 0;
65: int IsInitFlag = 0;
66: int (*IxAttach)();
67: int (*IxReset)();
68:
69: /*
70: * Debugging level.
71: */
72:
73: int NpDebug = 0;
74:
75: /* Driver Wide State used by the ICP */
76:
77: int NpState = NPCLEAR;
78:
79:
80: /*
81: * Master structure, one per board, contains request queue header,
82: * shared memory address, and memory mapping information.
83: */
84:
85: struct npmaster npmasters[NNP];
86:
87: /* Structure of the shared memory area */
88:
89: static struct npspace npspaces[NNP];
90:
91: /* Panic Message data structures */
92:
93: static int panicmap; /* Mapping information */
94: static char NpPbuf[PANLEN] = 0; /* Panic message buffer */
95: static caddr_t pstring; /* Panic string address on board, absolute */
96: static unsign16 panaddr[2]; /* Panic string address on board (seg/offset) */
97:
98: /* Driver Wide Connection Table */
99:
100: static struct npconn npcnxtab[NNP][NNPCNN];
101:
102: /* Head of the request queue, one per board */
103:
104: static struct npreq reqhdr[NNP];
105:
106: /* Require for diagnostic packages */
107:
108: typedef struct npreq *reqptr;
109: reqptr np_mapreq[NNP];
110:
111: /* The request structures, one pool per board */
112:
113: static struct npreq npreqs[NNP][NUMCQE];
114:
115:
116: /*
117: * Data structures needed for BSD 4.2 Device Drivers
118: */
119:
120: int npprobe(), npattach(), npintr();
121: struct uba_device *npdinfo[NNP];
122:
123: /* UNIBUS address of Network Processors */
124:
125: u_short npstd[] = { 0166000, 0166020, 0 };
126:
127: /* Interrupt vectors used by the Network Processors */
128:
129: static unsign16 npvectors[NNP];
130:
131: struct uba_driver npdriver =
132: { npprobe, 0, npattach, 0, npstd, "np", npdinfo };
133: struct buf np_tab[NNP];
134: static unsigned long np_icount[NNP];
135:
136:
137: /*
138: * External function and data structure declarations.
139: */
140:
141: struct npreq * NpGetReq();
142: struct npmaster *NpBoardChange();
143: int NpTimer();
144: struct CQE * NpRemCQE();
145:
146: extern struct user u;
147:
148: /*
149: * Np_init() is responsible for hardware initializiation and the software
150: * initialization of the connection table and driver software data structures.
151: */
152:
153: npinit(unit)
154: int unit;
155: {
156: register int j;
157:
158:
159: /* Software Initialization */
160:
161: npmasters[unit].flags = NPCLEAR;
162:
163: NpSWinit(unit);
164:
165: /* Hardware Initialization */
166:
167: NpHWinit(unit);
168:
169: /* Connection Table Initialization */
170:
171: for(j=0;j<NNPCNN;j++) {
172: npcnxtab[unit][j].protocol = NPCLCONN;
173: npcnxtab[unit][j].unit = &npmasters[unit];
174: }
175: }
176:
177: /*
178: * Np_open establishes a connection to the NP Driver using the minor
179: * device number as an identifier. A default protocol, NPMAINT, is assigned
180: * with the specified unit. Protocol and unit may be changed using the
181: * NpProtChange and NpBoardChange functions.
182: * Since the maintainance protocol does not need a working I-Board, entries
183: * are always made in the Connection Table, npcnxtab, if the board exists.
184: */
185:
186: /*ARGSUSED*/
187: npopen(dev,flag)
188: dev_t dev;
189: int flag;
190: {
191: int unit;
192: unsign16 conn;
193: struct npmaster *mp;
194: int error;
195:
196: if(NpDebug & DEBENTRY)
197: printf("npopen\n");
198:
199: /* Clear error */
200:
201: error = 0;
202:
203: /* Make sure it's the superuser */
204:
205: if(u.u_uid)
206: return(EPERM);
207:
208: /* Get the connection identifier */
209:
210: if(((conn = NPCONN(dev)) >= NNPCNN) ||
211: ((unit = NPUNIT(dev)) >= NNP))
212: return(ENODEV);
213:
214:
215: if(NpDebug & DEBOPEN)
216: printf("conn = %x unit = %d\n",conn,unit);
217:
218: /* Get the board for the specified unit */
219:
220: mp = NpBoardChange(NPMAINT,unit);
221:
222: if(mp != (struct npmaster *) 0) {
223: npcnxtab[unit][conn].unit = mp;
224: npcnxtab[unit][conn].protocol = NPMAINT;
225: }
226: else error = ENXIO;
227:
228: if(NpDebug & DEBENTRY)
229: printf("npopen...\n");
230:
231: return(error);
232: }
233:
234: /*
235: * Np_close is responsible updating the connection table for
236: * that connection by marking it closed.
237: */
238:
239: npclose(dev)
240: dev_t dev;
241: {
242:
243: if(NpDebug & DEBENTRY)
244: printf("npclose\n");
245:
246: /* Get the connection identifier */
247:
248: npcnxtab[NPUNIT(dev)][NPCONN(dev)].protocol = NPCLCONN;
249:
250: if(NpDebug & DEBENTRY)
251: printf("npclose...\n");
252:
253: return(0);
254:
255: }
256:
257: /*
258: * Npioctl is the main conduit of commands between the I-Board and the
259: * NP support utilities. Relevant information for the request is found in the
260: * cmd and addr parameters. Cmd specifies the function to perform, addr is
261: * command specific. Npioctl returns 0 if successful, or an error number
262: * (which winds up in errno).
263: */
264:
265: /*ARGSUSED*/
266: npioctl(dev,cmd,addr,flag)
267: dev_t dev;
268: int cmd;
269: caddr_t *addr;
270: int flag;
271: {
272: unsign16 protocol;
273: unsign16 conn;
274: unsign16 unit;
275: int error;
276:
277: register struct npmaster *mp;
278: register struct npreq *rp;
279: unsigned usrarg;
280:
281: if(NpDebug & DEBENTRY)
282: printf("npioctl\n");
283:
284: /* Clear error */
285:
286: error = 0;
287:
288: /* Strip off IOC_VOID bit */
289:
290: cmd &= CMDMASK;
291:
292: /* Get connection identifier */
293:
294: conn = NPCONN(dev);
295: unit = NPUNIT(dev);
296:
297: /* Master pointer for this unit */
298:
299: mp = npcnxtab[unit][conn].unit;
300:
301: protocol = npcnxtab[unit][conn].protocol;
302:
303: /* Get a request structure from the pool and initialize it */
304:
305: while((rp = NpGetReq(mp->reqtab)) == NULL) {
306: mp->reqtab->flags |= WANTREQ;
307: sleep((caddr_t)(mp->reqtab),PZERO -1);
308: }
309:
310: if(NpDebug & DEBREQ)
311: printf("NP Reqp is %x\n",rp);
312:
313: /* Initializations of request structure */
314:
315: rp->intr = (int (*)())0; /* Do not call interrupt routine */
316: rp->bufoffset = 0; /* Offset into data buffer */
317: rp->procp = u.u_procp; /* Process structure for this user */
318:
319: /* Copy in user's argument to ioctl() call */
320:
321: if(error = copyin(*addr,&usrarg,sizeof(usrarg)))
322: return(error);
323:
324:
325: if(NpDebug & DEBIOCTL)
326: printf("arg = %x\n",usrarg);
327:
328: /* Execute the specified command */
329:
330: switch(cmd) {
331:
332: case NPSETPROT:
333: if((error = NpProtChange(usrarg,mp->unit)) == 0)
334: npcnxtab[unit][conn].protocol = usrarg;
335: break;
336: case NPSETBOARD:
337: if(mp = NpBoardChange(protocol,usrarg))
338: npcnxtab[unit][conn].unit = mp;
339: else {
340: mp = npcnxtab[unit][conn].unit;
341: error = ENXIO;
342: }
343: break;
344: case NPRESET:
345: error = NpReset(mp,rp);
346: break;
347: case NPSETNPDEB:
348: NpDebug = usrarg;
349: break;
350: case NPINIT:
351: error = NpSWinit(mp->unit);
352: break;
353: case NPSTART:
354:
355: #ifdef OLDROM
356: /*
357: * Kludge to work around I-Board boot from Host. Read two bytes
358: * from the board into the Device Configuration Word
359: * in Shared Memory.
360: */
361:
362: NPIO(mp,(paddr_t)0x500,(paddr_t)(&mp->shmemp->statblock.sb_dcw),2,B_READ);
363:
364: mp->shmemp->statblock.sb_drw = 0;
365: #endif
366:
367: /* Set the Address at which to begin On-Board execution */
368:
369: error = NpSetXeqAddr(mp,(caddr_t)usrarg);
370: break;
371: case NPSTATS:
372: error = NpStats();
373: break;
374: case NPGPANIC:
375: error = copyout((caddr_t)NpPbuf,*addr,PANLEN);
376:
377: /* Clear panic request flag and leave */
378:
379: mp->flags &= ~PANICREQ;
380: break;
381: case NPPOLL:
382: error = NpPoll(mp,*addr);
383: break;
384: case NPKILL:
385: error = NpKill(mp,rp);
386: break;
387: case NPSETADDR:
388: error = NpSetMemAddr(mp,*addr);
389: break;
390: case NPRCSR0:
391: usrarg = RCSR0(mp->iobase);
392: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
393: break;
394: case NPRCSR1:
395: usrarg = RCSR1(mp->iobase);
396: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
397: break;
398: case NPRCSR2:
399: usrarg = RCSR2(mp->iobase);
400: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
401: break;
402: case NPRCSR3:
403: usrarg = RCSR3(mp->iobase);
404: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
405: break;
406: case NPWCSR0:
407: WCSR0(mp->iobase,usrarg);
408: break;
409: case NPWCSR1:
410: WCSR1(mp->iobase,usrarg);
411: break;
412: case NPWCSR2:
413: WCSR2(mp->iobase,usrarg);
414: break;
415: case NPWCSR3:
416: WCSR3(mp->iobase,usrarg);
417: break;
418: case NPNETBOOT:
419: error = NpSetIntLevel(mp,mp->vector);
420: if(error) break;
421: error = NpSetXeqAddr(mp,(caddr_t)INETBOOT);
422: break;
423: case NPSETLAST:
424: if (usrarg)
425: mp->flags &= ~LSTCMD;
426: else
427: mp->flags |= LSTCMD;
428: break;
429: case NPCLRICNT:
430: np_icount[unit] = NPCLEAR;
431: break;
432: case NPGETICNT:
433: usrarg = np_icount[unit];
434: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
435: break;
436: case NPGETIVEC:
437: usrarg = mp->vector;
438: error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
439: break;
440: case NPMAPMEM:
441: error = NpMem(mp, rp, *addr);
442: break;
443: default:
444: printf("Bad Maintenance command: %d!\n",cmd);
445: error = EIO;
446: break;
447: }
448: if((cmd != NPRESET) && (cmd != NPINIT) && (cmd != NPMAPMEM))
449: NpFreeReq(mp->reqtab,rp);
450:
451: if(NpDebug & DEBENTRY)
452: printf("npioctl...\n");
453:
454: return(error);
455: }
456:
457: /*
458: * np_start - start io activity
459: */
460: npstart(mp)
461: register struct npmaster *mp;
462: {
463:
464: register struct uio *uio;
465: register struct buf *bp;
466: register struct npreq *rp;
467:
468: int error; /* Return from NPIO call */
469:
470: if(NpDebug & DEBENTRY)
471: printf("npstart\n");
472:
473: if((bp = np_tab[mp->unit].b_actf) == (struct buf *)0) {
474: np_tab[mp->unit].b_active = 0;
475: return;
476: }
477: if((rp = (struct npreq *)(bp->b_rp)) == (struct npreq *)0) {
478: bp->b_flags = B_ERROR;
479: iodone(bp);
480: return;
481: }
482: if ((uio = (struct uio *)bp->b_uio) == (struct uio *)0) {
483: bp->b_flags = B_ERROR;
484: iodone(bp);
485: return;
486: }
487: np_tab[mp->unit].b_active = 1;
488:
489: if(NpDebug & DEBIO)
490: printf("NP IO src %x dst = %x cnt = %x\n", bp->b_un.b_addr,
491: uio->uio_offset, bp->b_bcount);
492:
493: /* Send the request to the board via the CSR0 command interface */
494:
495: if(bp->b_flags & B_READ)
496: error = NPIO(mp, (paddr_t)uio->uio_offset, (paddr_t)rp->bufaddr,
497: bp->b_bcount, (bp->b_flags & B_READ));
498: else
499: error = NPIO(mp, (paddr_t)rp->bufaddr, (paddr_t)uio->uio_offset,
500: bp->b_bcount, (bp->b_flags & B_READ));
501:
502:
503: /* Check return from I/O */
504:
505: if(error) {
506: bp->b_flags |= B_ERROR;
507: np_tab[mp->unit].b_actf = bp->av_forw;
508: if(NpDebug & DEBIO)
509: printf("NPIO return error: b_flags is %x \n",bp->b_flags);
510: iodone(bp);
511: }
512:
513: if(NpDebug & DEBENTRY)
514: printf("npstart...\n");
515:
516: }
517: /*
518: * npstrategy - the strategy routine
519: */
520:
521: npstrategy(bp)
522: register struct buf *bp;
523: {
524:
525: register struct buf *ip; /* quick pointer */
526: register struct npmaster *mp; /* master structure for this device */
527: register struct npreq *rp; /* reqest struct pointer */
528: int s; /* priority to return to */
529:
530: if(NpDebug & DEBENTRY)
531: printf("npstrategy\n");
532: if(NpDebug & DEBIO)
533: printf("flag = %x count = %x paddr = %x %x blkno = %x %x\n",
534: bp->b_flags, bp->b_bcount, bp->b_un.b_addr, bp->b_un.b_addr,
535: bp->b_blkno,bp->b_blkno);
536:
537: /* get master structure */
538:
539: mp = npcnxtab[NPUNIT(bp->b_dev)][NPCONN(bp->b_dev)].unit;
540:
541: /* make sure the boards ok */
542:
543: if (mp->flags & BADBOARD) {
544: bp->b_flags |= B_ERROR;
545:
546: if(NpDebug & DEBMEM)
547: printf("Bad Board %x bp %x\n",mp->flags,bp->b_flags);
548:
549: np_tab[mp->unit].b_actf = bp->av_forw;
550: iodone(bp);
551: return;
552: }
553:
554: /* Initializations of request structure */
555:
556: while((rp = NpGetReq(mp->reqtab)) == NULL) {
557: mp->reqtab->flags |= WANTREQ;
558: sleep((caddr_t)(mp->reqtab),PZERO -1);
559: }
560:
561: rp->bufoffset = 0; /* This is the start of the buffer */
562: ip = &np_tab[mp->unit];
563: bp->b_rp = (struct buf *)rp;
564:
565: rp->flags |= KERNREQ; /* Mark it as kernel so not to map */
566:
567: rp->mapbase = ubasetup(mp->devp->ui_ubanum,bp,0);
568: rp->bufaddr = (caddr_t)((int)(rp->mapbase) & UBADDRMASK);
569:
570: s = spl5();
571: if(ip->b_actf ==(struct buf *)0)
572: ip->b_actf = bp;
573: else {
574: if(ip->b_actf->av_forw)
575: printf("Panic NP100 bad buffer chain\n");
576: ip->b_actf->av_forw = bp;
577: }
578: ip->b_actl = bp;
579:
580: NpAddReq(mp->reqtab,rp); /* Queue onto active list */
581:
582: if(ip->b_active == 0) {
583:
584: if(NpDebug & DEBIO)
585: printf("calling npstart %x\n",mp);
586:
587: npstart(mp);
588: }
589: splx(s);
590:
591: if(NpDebug & DEBIO)
592: printf("back from npstart\n");
593:
594: /* Await completion of I/O */
595:
596: iowait(bp);
597:
598: if(NpDebug & DEBIO)
599: printf("after iowait in npstrategy\n");
600:
601: /* Remove request from queue */
602:
603: NpRemReq(rp);
604:
605: /* Release mapping registers */
606:
607: ubarelse(mp->devp->ui_ubanum,&rp->mapbase);
608:
609: /* Free up request structure */
610:
611: NpFreeReq(mp->reqtab,rp);
612:
613: if(NpDebug & DEBENTRY)
614: printf("Leaving npstrategy flags is %x\n",bp->b_flags);
615: }
616:
617: unsigned
618: nptrim(bp)
619: register struct buf *bp;
620: {
621:
622: if(bp->b_bcount > NPMAXXFR)
623: bp->b_bcount = NPMAXXFR;
624: }
625:
626: /*
627: * Npread dumps data from the board to the user's buffer
628: */
629: npread(dev,uio)
630: dev_t dev;
631: struct uio *uio;
632: {
633: struct buf *bp;
634: bp = &npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_rbuf;
635:
636: if(NpDebug & DEBENTRY)
637: printf("in npread\n");
638:
639: bp->b_uio = (struct buf *)uio;
640: return(physio(npstrategy,bp,dev,B_READ ,nptrim,uio));
641: }
642:
643: /*
644: * Npwrite loads the np100 board from the user's buffer
645: */
646:
647: npwrite(dev,uio)
648: dev_t dev;
649: struct uio *uio;
650: {
651: struct buf *bp;
652: bp = &npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_wbuf;
653:
654: if(NpDebug & DEBENTRY)
655: printf("in npwrite \n");
656:
657: bp->b_uio = (struct buf *)uio;
658: return(physio(npstrategy,bp,dev,B_WRITE ,nptrim,uio));
659: }
660:
661: /*
662: * npreset - called as result of a UNIBUS reset.
663: */
664:
665: npreset(uban)
666: int uban;
667: {
668:
669: register struct npmaster *mp;
670: register struct npreq *rp;
671: register struct uba_device *ui;
672: int i;
673:
674: if(NpDebug & DEBENTRY)
675: printf("npreset(ubareset)\n");
676: for(i = 0; i < NNP; i++) {
677:
678: if(((ui = npdinfo[i]) == (struct uba_device *)NULL) ||
679: (ui->ui_ubanum != uban))
680: continue;
681:
682: mp = &npmasters[i];
683:
684: /* Get a Request structure */
685:
686: while((rp = NpGetReq(mp->reqtab)) == NULL) {
687: mp->reqtab->flags |= WANTREQ;
688: sleep((caddr_t)(mp->reqtab),PZERO -1);
689: }
690:
691: NpReset(mp,rp);
692: }
693: if(NpDebug & DEBENTRY)
694: printf("npreset(ubareset)...\n");
695: }
696:
697:
698: /*
699: * Nppoll looks for work by polling each board. He goes to sleep if there are
700: * no outstanding requests for him but reminds the board that he's there when
701: * needed.
702: */
703:
704: NpPoll(mp,addr)
705: struct npmaster *mp;
706: caddr_t addr;
707: {
708: int error;
709:
710: struct {
711: unsign16 request;
712: unsign16 unit;
713: }icpreq;
714:
715: if(NpDebug & DEBMAINT)
716: printf("NpPoll: flags is %x.\n",mp->flags);
717:
718: while(TRUE) {
719:
720: for(mp = npmasters; mp; mp = mp->next) {
721:
722: if(mp->flags & BOARDREQ) {
723:
724: /* Get request type from master structure */
725:
726: if(mp->flags & BRDRESET) {
727: icpreq.request = ICPPOLL;
728: mp->reqtab->reqcnt--;
729:
730: if(NpDebug & DEBMAINT)
731: printf("Waking NpResetter!\n");
732:
733: wakeup((caddr_t)(&mp->reqtab));
734: }
735: else if(mp->flags & PANICREQ)
736: icpreq.request = ICPPANIC;
737: else if(mp->flags & DUMPREQ)
738: icpreq.request = ICPDUMP;
739: else if(mp->flags & LOADREQ)
740: icpreq.request = ICPLOAD;
741: else {
742: mp->flags &= ~BOARDREQ;
743: continue;
744: }
745:
746: if(NpDebug & DEBMAINT)
747: printf("ProcICP servicing %d \n",icpreq.request );
748:
749: /* Request and unit number to be sent */
750:
751: icpreq.unit = mp->unit;
752:
753: /* Copy service request to calling process */
754:
755: error = copyout(&icpreq,addr,sizeof(icpreq));
756:
757: /* Mark Poller as being unavailable */
758:
759: NpState &= ~ICPAVAIL;
760:
761: return(error);
762: }
763: }
764:
765: /* Mark Poller as being available */
766:
767: NpState |= ICPAVAIL;
768:
769: sleep((caddr_t)&NpState, PZERO + 1);
770:
771: if(NpDebug & DEBMAINT)
772: printf("wakeup in NpPoll\n");
773:
774: }
775: }
776:
777: /*
778: * Software initialization of Driver data structures for the specified unit.
779: */
780:
781: NpSWinit(unit)
782: int unit;
783: {
784:
785: register int j;
786: register struct npmaster *mp;
787: register struct npspace *npsp;
788: register struct CmdQue *cqp;
789: int offset;
790:
791: if(NpDebug & DEBINIT)
792: printf("SW reset on unit %d.\n",unit);
793:
794: np_icount[unit] = NPCLEAR;
795: np_mapreq[unit] = (struct npreq *) NPCLEAR;
796:
797: /* Initialize master structure pointer for this unit */
798:
799: mp = &npmasters[unit];
800:
801: /* Initialize unit buffer headers */
802:
803: np_tab[unit].b_active = 0;
804: np_tab[unit].b_actf = 0;
805:
806: /* UBA device structure for this unit */
807:
808: mp->devp = npdinfo[unit];
809:
810: /* Interrupt vector for this unit */
811:
812: mp->vector = npvectors[unit];
813:
814: if(unit == (NNP -1))
815: mp->next = (struct npmaster *)NULL;
816: else mp->next = &npmasters[unit + 1];
817:
818: /*
819: * Guarantee alignment of shared memory area on a
820: * 16 byte boundary as required by I-Board
821: */
822:
823: mp->shmemp = &npspaces[unit];
824: mp->shmemp = (struct npspace *)ROUND16((int)(mp->shmemp));
825:
826: /* Base address of this controller */
827:
828: mp->iobase = (struct NPREG *)(mp->devp->ui_addr);
829:
830: if(NpDebug & DEBMEM) {
831: printf("Npspaces starts at %x.\n",npspaces);
832: printf("Shared memory starts at %x.\n",mp->shmemp);
833: printf("End of shared memory is %x.\n",&npspaces[unit + 1]);
834: printf("Iobase is %x.\n",mp->iobase);
835: printf("Npmasters start at %x\n",npmasters);
836: printf("Reqhdr start at %x\n",reqhdr);
837: printf("Npreqs start at %x\n",npreqs);
838: }
839:
840: /* Initialize the request header */
841:
842: mp->reqtab = &reqhdr[unit];
843:
844: /* Unit initialization */
845:
846: mp->unit = unit;
847:
848: /* Initialize Status Block */
849:
850: npsp = mp->shmemp;
851: offset = (int) (mp->shmemp);
852:
853: npsp->statblock.sb_drw = 0;
854: npsp->statblock.sb_hcw = HOSTCONF;
855: npsp->statblock.sb_dcw = 0;
856: npsp->statblock.sb_dpm = 0;
857:
858: npsp->statblock.sb_dcq = (unsign16)((int)(&npsp->devcq))-offset;
859:
860: npsp->statblock.sb_hcq = (unsign16)((int)(&npsp->hostcq))-offset;
861:
862: /* Initialize Device Command Queue */
863:
864: cqp = (struct CmdQue *) &npsp->devcq;
865:
866: if(NpDebug & DEBCQ)
867: printf("Device CQ at %x\n",cqp);
868:
869: cqp->scanflag = NPCLEAR;
870: cqp->chngflag = NPCLEAR;
871:
872: cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
873: cqp->cq_rem = cqp->cq_add;
874:
875: cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;
876:
877: for(j = 0; j < NUMCQE; j++)
878: cqp->cq_cqe[j] = (unsign16)NULL;
879:
880: /* Initialize Host Command Queue */
881:
882: cqp = (struct CmdQue *) &npsp->hostcq;
883:
884: if(NpDebug & DEBCQ)
885: printf("HOST CQ at %x\n",cqp);
886:
887: cqp->scanflag = NPCLEAR;
888: cqp->chngflag = NPCLEAR;
889:
890: cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
891: cqp->cq_rem = cqp->cq_add;
892:
893: cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;
894:
895: for(j = 0; j < NUMCQE; j++)
896: cqp->cq_cqe[j] = (unsign16)NULL;
897:
898: /*
899: * Initialize the reqid of the elements to the address
900: * of the corresponding Npreq structure. These don't change.
901: */
902:
903: for(j = 0; j < NUMCQE; j++)
904: npsp->elements[j].cqe_reqid = &npreqs[unit][j];
905:
906: /*
907: * Initialize the Request Header (reqhdr), free list of
908: * npreqs, and pointers to CQEs.
909: */
910:
911: reqhdr[unit].forw = reqhdr[unit].back = &reqhdr[unit];
912: reqhdr[unit].free = &npreqs[unit][0];
913:
914: for(j = 0; j < NUMCQE; j++) {
915: npreqs[unit][j].free = &npreqs[unit][j + 1];
916: npreqs[unit][j].element = &npsp->elements[j];
917: npreqs[unit][j].forw = npreqs[unit][j].back = (struct npreq *)NULL;
918: npreqs[unit][j].flags = NPCLEAR;
919: }
920: npreqs[unit][--j].free = &reqhdr[unit];
921:
922: /*
923: * Set up the UNIBUS I/O Map Registers for the
924: * Shared memory area.
925: */
926:
927: mp->iomapbase = uballoc(mp->devp->ui_ubanum,(caddr_t)(mp->shmemp),sizeof(struct npspace),0);
928:
929:
930: if(NpDebug & DEBENTRY)
931: printf("SW_Init...\n");
932: return(0);
933: }
934:
935: /*
936: * NpHWinit() issues a hardware reset to the specified board and waits
937: * for on-board diagnostics to complete. It returns 0 if the board is
938: * present and passed diagnostics, an error value otherwise.
939: */
940:
941: NpHWinit(unit)
942: int unit;
943: {
944: register struct npmaster *mp;
945: struct NPREG *REG;
946: unsign16 status;
947: int dflag;
948:
949: if(unit >= NNP)
950: return(ENXIO);
951:
952: mp = &npmasters[unit];
953:
954: if(NpDebug & DEBENTRY)
955: printf("NpHWinit\n");
956:
957: /* See if the board is out there */
958:
959: REG = (struct NPREG *)mp->iobase;
960:
961: if(NpDebug & DEBINIT)
962: printf("REG in HWinit is %x.\n",mp->iobase);
963:
964: if(!(mp->flags & BRDRESET))
965:
966: if(badaddr(REG,2)) {
967: mp->flags |= BADBOARD;
968: printf("\nNP100 unit %d not found!\n",unit);
969: return(ENXIO);
970: }
971:
972:
973: #ifdef mc500
974: if(setjmp(u.u_tsav) == 0) {
975: u.u_nofault = TRUE;
976: status = RCSR1(mp->iobase);
977: u.u_nofault = FALSE;
978: }
979: else {
980: np__addr[unit] = 0;
981: mp->flags |= BADBOARD;
982: u.u_error = ENXIO;
983: printf("\nNP100 Unit %x not here!\n",unit);
984: return(0);
985: }
986: #endif
987:
988: if(NpDebug & DEBENTRY)
989: printf("Resetting the NP100 Board at %x\n",mp->iobase);
990:
991: /* Reset the Board */
992:
993: RESET(mp);
994:
995: dflag = NPCLEAR;
996:
997: timeout(NpTimer,&dflag,DIAGTIME);
998:
999: /* Wait for Enable and Read Data Ready to go high */
1000:
1001: while(! ((RCSR1(mp->iobase) & NPENB) && (RCSR1(mp->iobase) & NPRDR))) {
1002: if(dflag)
1003: break;
1004:
1005: }
1006:
1007: untimeout(NpTimer,&dflag);
1008:
1009: if(NpDebug & DEBINIT)
1010: printf("np reset %d \n",dflag);
1011:
1012: if(dflag) {
1013: mp->flags |= BADBOARD;
1014: printf("NP100 Unit %d timed out!\n",unit);
1015: return(EIO);
1016: }
1017:
1018: status = RCSR0(mp->iobase);
1019:
1020: /* Check for Hardware OK */
1021:
1022: if(!(RCSR1(mp->iobase) & NPHOK)) {
1023: mp->flags |= BADBOARD;
1024: u.u_error = EIO;
1025: printf("NP100 Unit %d Failed diagnostics!\n",unit);
1026: printf("Status from CSR0: %x.\n",status);
1027: return(EIO);
1028: }
1029:
1030: if(NpDebug & DEBENTRY)
1031: printf("HWinit...\n");
1032:
1033: return(0);
1034: }
1035:
1036: /*
1037: * NP Driver Interrupt Handler
1038: */
1039:
1040: npintr(unit)
1041: int unit;
1042: {
1043: register struct npmaster *mp;
1044: register struct buf *bp;
1045:
1046: if(NpDebug & DEBENTRY)
1047: printf("npintr on unit %d!\n",unit);
1048:
1049: mp = &npmasters[unit];
1050: np_icount[unit]++;
1051:
1052: if(NpDebug & DEBINTR)
1053: printf("npintr mp->flags = %x interupt count = %x\n",
1054: mp->flags, np_icount[unit]);
1055:
1056: /* Wake up anyone sleeping on a CSR0 Command */
1057:
1058: if(mp->flags & CSRPEND) {
1059:
1060: mp->flags &= ~CSRPEND;
1061: if(np_tab[mp->unit].b_active) {
1062: np_tab[mp->unit].b_active = 0;
1063: bp = np_tab[mp->unit].b_actf;
1064: np_tab[mp->unit].b_actf = bp->av_forw;
1065:
1066: if(NpDebug & DEBINTR)
1067: printf("bp = %x resid = %d forw = %x\n",bp,
1068: bp->b_resid,bp->av_forw);
1069:
1070: bp->b_resid = 0;
1071: iodone(bp);
1072: }
1073: if(mp->flags & PANIC3) {
1074: mp->flags &= ~PANIC3;
1075: mp->flags = AVAILABLE;
1076: ubarelse(mp->devp->ui_ubanum,&panicmap);
1077: }
1078: if(mp->flags & PANIC2) {
1079: mp->flags &= ~PANIC2;
1080: printf("Panic Message: %s",NpPbuf);
1081: mp->flags |= PANIC3;
1082: NpPbuf[0] = 0;
1083: NPIO(mp,(paddr_t)((int) panicmap & UBADDRMASK),(paddr_t)pstring,sizeof(NpPbuf),B_WRITE);
1084: }
1085: if(mp->flags & PANIC1) {
1086: mp->flags &= ~PANIC1;
1087: mp->flags |= PANIC2;
1088: ubarelse(mp->devp->ui_ubanum,&panicmap);
1089: panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)NpPbuf,sizeof(NpPbuf),0);
1090: pstring = (caddr_t)((panaddr[1] << 4) + panaddr[0]);
1091: NPIO(mp,(paddr_t)pstring,(paddr_t)((int) panicmap & UBADDRMASK),sizeof(NpPbuf),B_READ);
1092: }
1093:
1094: wakeup((caddr_t)mp);
1095: goto out;
1096: }
1097:
1098: /* Mark unit as being available if Device Protocol Mask set */
1099:
1100: if(!(mp->flags & AVAILABLE)) {
1101:
1102: if((mp->shmemp->statblock.sb_dpm) && (!(mp->flags & BRDRESET))){
1103:
1104: mp->flags = AVAILABLE;
1105: printf("\nNP100 unit #%d available!\n",mp->unit);
1106: }
1107: }
1108:
1109: /* Honor service requests from the device */
1110:
1111: switch(mp->shmemp->statblock.sb_drw) {
1112:
1113: case NOREQ:
1114: break;
1115:
1116: case NPPANIC:
1117:
1118: printf("\nPanic from NP100 unit %d!\n",mp->unit);
1119: mp->flags &= ~AVAILABLE;
1120: mp->flags |= PANIC1;
1121:
1122: /* Clear device request word */
1123:
1124: mp->shmemp->statblock.sb_drw = 0;
1125:
1126: panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)panaddr,sizeof(panaddr),0);
1127: NPIO(mp,(paddr_t)NPPSADDR,(paddr_t)((int)panicmap & UBADDRMASK),sizeof(panaddr),B_READ);
1128: goto out;
1129: break;
1130:
1131: case NPDUMP:
1132: mp->flags |= (DUMPREQ | BOARDREQ);
1133:
1134: /* Clear device request word */
1135:
1136: mp->shmemp->statblock.sb_drw = 0;
1137:
1138: if(NpState & ICPAVAIL)
1139: wakeup((caddr_t)&NpState);
1140: break;
1141:
1142: case NPLOAD:
1143: mp->flags |= (LOADREQ | BOARDREQ);
1144:
1145: /* Clear device request word */
1146:
1147: mp->shmemp->statblock.sb_drw = 0;
1148:
1149: if(NpState & ICPAVAIL)
1150: wakeup((caddr_t)&NpState);
1151: break;
1152:
1153: default:
1154: printf("Bad Req: %x.\n",mp->shmemp->statblock.sb_drw);
1155: goto out;
1156:
1157: }
1158:
1159: /* Process the Host Command Queue for this device */
1160:
1161: NpProcQueue(mp);
1162:
1163: out:
1164: CLEARINT(mp); /* Clear the interrupt */
1165:
1166: if(NpDebug & DEBENTRY)
1167: printf("npintr...\n");
1168:
1169: return(1); /* Interrupt serviced */
1170:
1171: }
1172:
1173: /*
1174: * This routine, called from the interrupt handler, is used to process the
1175: * Host Command Queue for the specified device.
1176: */
1177:
1178: NpProcQueue(mp)
1179: struct npmaster *mp;
1180: {
1181: register struct CmdQue *cqp;
1182: register struct CQE *ep;
1183: register struct npreq *rp;
1184: register int base;
1185: int s;
1186:
1187: if(NpDebug & DEBENTRY)
1188: printf("NpProcQueue\n");
1189:
1190: cqp = &mp->shmemp->hostcq; /* Command Queue pointer */
1191:
1192: s = spl5();
1193: if(mp->flags & SCANNING) {
1194: splx(s);
1195: return;
1196: }
1197: mp->flags |= SCANNING;
1198: splx(s);
1199:
1200: cqp->scanflag | = ON;
1201:
1202: base = (int)mp->shmemp; /* Shared memory base address */
1203:
1204: while(1) {
1205:
1206: cqp->scanflag |= ON;
1207: cqp->chngflag &= ~ON;
1208: while(ep = NpRemCQE(cqp,base)) {
1209:
1210: rp = ep->cqe_reqid;
1211:
1212: if(NpDebug & DEBCQE)
1213: printf("cqe_sts is %x ep = %x\n",ep->cqe_sts,ep);
1214:
1215: switch (ep->cqe_sts) {
1216:
1217: case NPDONE:
1218: rp->flags |= REQDONE; /* Normal completion */
1219: break;
1220: case NPIFC: /* IFC Request */
1221: rp->flags |= IOIFC;
1222: break;
1223: case NPPERR: /* Protocol Error */
1224: rp->flags |= (NPPERR | REQDONE);
1225: break;
1226: case NPMERR: /* Memory allocation */
1227: rp->flags |= (NPMERR | REQDONE);
1228: break;
1229: default: /* Error on Board */
1230: rp->flags |= (IOERR | REQDONE);
1231: break;
1232:
1233: }
1234:
1235: if(NpDebug & DEBCQE) {
1236: printf("flag is %x reqid = %x\n",rp->flags,ep->cqe_reqid);
1237: printf("wakeup in procqueue\n");
1238: }
1239:
1240: if(rp->intr) {
1241:
1242: if(NpDebug & DEBINTR)
1243: printf("calling usr intr at %x\n",
1244: rp->intr);
1245:
1246: /* Call interrupt routine */
1247:
1248: (*rp->intr)(mp,rp);
1249: }
1250: else {
1251:
1252: if(NpDebug & DEBINTR)
1253: printf("waking up %x\n",rp);
1254:
1255: /* if(rp->flags & NPUIO)
1256: iodone(&rp->buf);
1257: else wakeup((caddr_t) (rp)); /* Awaken */
1258:
1259: wakeup((caddr_t)(rp)); /* Awaken */
1260: if(NpDebug & DEBINTR)
1261: printf("AWAKE\n");
1262: }
1263: }
1264:
1265: cqp->scanflag &= ~ON;
1266: if(!(cqp->chngflag & ON))
1267: break;
1268:
1269: }
1270:
1271: mp->flags &= ~SCANNING;
1272: if(NpDebug & DEBENTRY)
1273: printf("NpProcQueue...\n");
1274: }
1275:
1276: /*
1277: * NpIFC - processes an IFC (Internal Fuction Call) request
1278: * NOTE: this function must be called from the user context
1279: * on all virtual pageing systems
1280: *
1281: */
1282: NpIFC(mp,rp)
1283: register struct npmaster *mp;
1284: register struct npreq *rp;
1285: {
1286: register struct CQE *ep;
1287:
1288: if(NpDebug & DEBENTRY)
1289: printf("NpIFC\n");
1290:
1291: ep = rp->element;
1292: rp->flags &= ~IOIFC;
1293: switch(ep->cqe_func) {
1294:
1295: case NPUNLOCK: /* Unlock process, free up mapping registers */
1296:
1297: if(NpDebug & DEBIFC)
1298: printf("NPUNLOCK\n");
1299:
1300: if(rp->mapbase)
1301: NpUnMapMem(mp,rp);
1302: break;
1303:
1304: case NPLOCK: /* Lock process, get mapping registers */
1305:
1306: if(NpDebug & DEBIFC)
1307: printf("NPLOCK\n");
1308: NpMapMem(mp,rp,rp->virtmem,rp->bytecnt);
1309: ep->cqe_dma[0] = LOWORD(rp->bufaddr);
1310: ep->cqe_dma[1] = HIWORD(rp->bufaddr);
1311: break;
1312:
1313: case NPREMAP:
1314:
1315: if(NpDebug & DEBIFC)
1316: printf("NPREMAP\n");
1317:
1318: /* Remap user buffer and update buffer offset */
1319: #ifdef USG
1320: np_remapmem(rp,rp->virtmem);
1321: ep->cqe_dma[0] = LOWORD(rp->bufaddr);
1322: ep->cqe_dma[1] = HIWORD(rp->bufaddr);
1323: break;
1324: #endif
1325:
1326: default:
1327: if(NpDebug & DEBIFC)
1328: printf("Bad case %x in IFC\n", ep->cqe_func);
1329:
1330: rp->flags |= (REQDONE | IOERR);
1331: break;
1332: }
1333: }
1334:
1335: /*
1336: * The following contains various routines for allocating and deallocating
1337: * structures used by the NP Driver. Routines are also here for addding
1338: * and removing Command Queue Elements from a Command Queue.
1339: */
1340:
1341: /*
1342: * Get a free NP Request structure from the list pointed to by head. Returns
1343: * a pointer to a npreq or NULL if none left.
1344: */
1345:
1346: struct npreq *
1347: NpGetReq(head)
1348: struct npreq *head;
1349: {
1350:
1351: register struct npreq *p;
1352:
1353: p = head->free;
1354: head->free = p->free;
1355: if (p->flags & REQALOC)
1356: printf("GetReq: Req %x already allocated\n", p);
1357: p->flags &= WANTREQ;
1358: if (p != head)
1359: p->flags |= REQALOC;
1360: return(p==head ? (struct npreq *)NULL : p);
1361: }
1362:
1363: /*
1364: * Return a NP Request structure to the free list pointed to by head.
1365: */
1366:
1367: NpFreeReq(head,nprp)
1368: register struct npreq *head, *nprp;
1369: {
1370: int s;
1371:
1372: if(NpDebug & DEBREQ)
1373: printf("NpFreeReq, head is %x rp is %x\n",head,nprp);
1374:
1375: if (nprp == NULL) {
1376: printf("FREEREQ: attempt to free null pointer\n");
1377: return;
1378: }
1379: if (!(nprp->flags & REQALOC)) {
1380: printf("FREEREQ: attempt to free unallocated request %x\n",
1381: nprp);
1382: return;
1383: }
1384: if (nprp->flags & REQUSE)
1385: printf("FREEREQ: freeing unremoved request %x\n", nprp);
1386:
1387: s = spl5();
1388: nprp->forw = nprp->back = (struct npreq *)NULL;
1389: nprp->free = head->free;
1390: head->free = nprp;
1391: nprp->flags &= ~REQALOC;
1392: splx(s);
1393:
1394: /* Wake up any processes waiting for a request structure */
1395:
1396: if(head->flags & WANTREQ) {
1397: head->flags &= ~WANTREQ;
1398: wakeup((caddr_t)head);
1399: }
1400:
1401: if(NpDebug & DEBENTRY)
1402: printf("NpFreeReq...\n");
1403: }
1404:
1405: /*
1406: * Add a Command Queue Element onto the specified Command Queue and
1407: * update its Add offset.
1408: */
1409:
1410: NpAddCQE(ep,cqp,mp)
1411: struct CQE *ep;
1412: struct CmdQue *cqp;
1413: struct npmaster *mp;
1414: {
1415:
1416: register unsign16 *temp;
1417: register unsign16 cqe_offset;
1418: register int base;
1419:
1420: base = (int)mp->shmemp; /* Shared memory base address */
1421:
1422: temp = (unsign16 *)(base + cqp->cq_add); /* Offset to add element */
1423:
1424: cqe_offset = (unsign16)((int)ep - base);
1425:
1426: if(*temp) { /* Should never happen */
1427:
1428: printf("No more room on Command Queue!\n");
1429: u.u_error = EIO;
1430: return;
1431: }
1432: else *temp = cqe_offset; /* Enter this request's offset */
1433:
1434: /* Update cqe_add where next request is to be added */
1435:
1436: cqp->cq_add += sizeof(unsign16);
1437:
1438: if(cqp->cq_add == cqp->cq_wrap) /* Wrap if necessary */
1439: cqp->cq_add = (unsign16)((int)cqp->cq_cqe - base);
1440:
1441: cqp->chngflag |= ON; /* Set change flag unconditionally */
1442:
1443: /* Interrupt the Board if his scan flag isn't on */
1444:
1445: if(!(cqp->scanflag & ON))
1446:
1447: INTNI(mp); /* Interrupt the Board */
1448:
1449: }
1450:
1451: /*
1452: * The NpRemCQE routine is used to remove the next CQE from the Command Queue
1453: * specified by cqp. The common offset of shared memory used by the device
1454: * is specified by base. NpRemCQE returns a pointer to the next CQE or
1455: * NULL if there are none left. This routine will also update the cqe_rem
1456: * offset which specifies where the next element to be removed from the
1457: * queue is located.
1458: */
1459:
1460: struct CQE *
1461: NpRemCQE(cqp,base)
1462: struct CmdQue *cqp;
1463: int base;
1464: {
1465:
1466: register unsign16 *temp;
1467: register unsign16 cqe_offset;
1468:
1469: cqp->chngflag &= ~ON; /* Turn off unconditionally */
1470:
1471: /* Get address of element to remove */
1472:
1473: temp = (unsign16 *)(base +cqp->cq_rem);
1474:
1475: if(*temp == NULL) /* If none left, go home */
1476: return((struct CQE *) NULL);
1477:
1478: else cqe_offset = *temp; /* Offset of CQE to remove */
1479:
1480: /* Update the Command Queue's cqe_rem offset */
1481:
1482: *temp = NULL; /* Clear out this entry */
1483:
1484: cqp->cq_rem += sizeof(unsign16); /* Bump offset */
1485:
1486: if(cqp->cq_rem == cqp->cq_wrap) /* Wrap if necessary */
1487: cqp->cq_rem = (unsign16)((int)cqp->cq_cqe - base);
1488:
1489: temp = (unsign16 *)(base + cqe_offset); /* CQE address */
1490: return((struct CQE *)temp); /* is returned */
1491: }
1492:
1493: /*
1494: * NpAddReq will add the specified npreq structure to the queue controlled
1495: * by head.
1496: */
1497:
1498: NpAddReq(head,rp)
1499: register struct npreq *head, *rp;
1500: {
1501: int s;
1502:
1503: if (NpDebug & (DEBENTRY|DEBREQ))
1504: printf("NpAddReq: %x\n",rp);
1505:
1506: if (rp->flags & REQUSE)
1507: printf("ADDREQ: Request %x allready in use\n", rp);
1508:
1509: s = spl7();
1510: rp->forw = head->forw;
1511: rp->forw->back = rp;
1512: rp->back = head;
1513: head->forw = rp;
1514: rp->flags |= REQUSE;
1515: splx(s);
1516:
1517: if(NpDebug & DEBENTRY)
1518: printf("NpAddReq...\n");
1519: }
1520:
1521: /*
1522: * NpRemReq is used to remove a npreq structure from the queue specified by
1523: * head.
1524: */
1525:
1526: NpRemReq(rp)
1527: register struct npreq *rp;
1528: {
1529: int s;
1530:
1531: if (NpDebug & (DEBENTRY|DEBREQ))
1532: printf("NpRemReq: %x\n",rp);
1533:
1534: if (rp == NULL) {
1535: printf("REMREQ: null pointer removal requested\n");
1536: return;
1537: }
1538: if (!(rp->flags & REQUSE)) {
1539: printf("REMREQ: trying to rem unused req %x\n", rp);
1540: return;
1541: }
1542: if (!(rp->flags & REQALOC)) {
1543: printf("REMREQ: trying to rem unallocated req %x\n", rp);
1544: return;
1545: }
1546:
1547: s = spl7();
1548: rp->back->forw = rp->forw;
1549: rp->forw->back = rp->back;
1550: rp->flags &= ~REQUSE;
1551: splx(s);
1552:
1553: if(NpDebug & DEBENTRY)
1554: printf("NpRemReq...\n");
1555: }
1556:
1557:
1558: /*
1559: * The following routines are used to communicate with the
1560: * NI Hardware via the CSR0 commands. These commands are issued during
1561: * the hardware initializtion process and may also be used subsequently
1562: * by privileged processes who wish to communicate in this way. The
1563: * convention for passing data as a Command Block is discussed in detail
1564: * in the NI1510 UNIBUS Compatible Ethernet Communications Processor
1565: * Hardware Specification.
1566: */
1567:
1568: NpSendCSR0(iobase,src,bcount)
1569: struct NPREG *iobase;
1570: register unsign16 *src;
1571: int bcount;
1572: {
1573: register int wcount;
1574: int i;
1575: int csrflag;
1576: unsign16 tmp;
1577:
1578: if(NpDebug & DEBENTRY)
1579: printf("NpSendCSR0\n");
1580:
1581: /* Jolt the board into CSR0 command mode if necessary */
1582:
1583: if(!(RCSR1(iobase) & NPENB)){
1584: tmp = NPCLEAR; /* MC68000 clr reads before writing */
1585: WCSR0(iobase,tmp);
1586: }
1587:
1588: wcount = (bcount +1) >> 1; /* Convert byte count to word count */
1589:
1590: /* Clear timer flag before beginning the timer */
1591:
1592: csrflag = NPCLEAR;
1593: timeout(NpTimer,&csrflag,DIAGTIME);
1594:
1595: for(i = 0; (i < wcount) & (csrflag == NPCLEAR); i++) {
1596: while(! ((RCSR1(iobase) & NPENB) && (RCSR1(iobase) & NPRDY)))
1597: if(csrflag) break;
1598: WCSR0(iobase,*src);
1599: src++; /* Better do this WCSR is a macro */
1600: }
1601:
1602: /* Clear the timer entry */
1603:
1604: untimeout(NpTimer,&csrflag);
1605:
1606: /* Error if timer went off */
1607:
1608: if(csrflag)
1609: return(EIO);
1610:
1611: if(NpDebug & DEBENTRY)
1612: printf("NpSendCSR0...\n");
1613: return(0);
1614: }
1615:
1616: /*
1617: * NpSetIntLev sets the UNIBUS interrupt vector to be used by the NP board when
1618: * interupting the host. The board is specified by mp.
1619: */
1620:
1621: NpSetIntLevel(mp,level)
1622: struct npmaster *mp;
1623: int level;
1624: {
1625:
1626: struct {
1627: unsign16 cmd_word;
1628: unsign16 int_level;
1629: }cmd_block;
1630:
1631: cmd_block.cmd_word = NPCBI | CBICNT;
1632: cmd_block.int_level = level;
1633:
1634: return(NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block)));
1635: }
1636:
1637: /*
1638: * NpSetMemAddr is used to declare the shared memory area address to be used
1639: * for communication between the driver and the device. This address is used
1640: * to access data structures by acting as a base from which defined offsets
1641: * locate data. The board is specified by mp.
1642: */
1643:
1644: NpSetMemAddr(mp,addr)
1645: struct npmaster *mp;
1646: caddr_t addr;
1647: {
1648:
1649: caddr_t shmaddr;
1650: int error;
1651:
1652: struct {
1653: unsign16 cmd_word;
1654: unsign16 hi_addr;
1655: unsign16 lo_addr;
1656: } cmd_block;
1657:
1658: if(NpDebug & DEBENTRY)
1659: printf("NpSetMemAddr\n");
1660:
1661: shmaddr = addr;
1662:
1663: if(NpDebug & DEBMEM)
1664: printf("NpSetMemAddr, addr is %x shmaddr is %x.\n",addr,shmaddr);
1665:
1666: cmd_block.cmd_word = NPCMD | CMDCNT;
1667: cmd_block.hi_addr = HIWORD(shmaddr);
1668: cmd_block.lo_addr = LOWORD(shmaddr);
1669:
1670: error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
1671:
1672: if(NpDebug & DEBENTRY)
1673: printf("NpSetMemAddr...\n");
1674:
1675: return(error);
1676: }
1677:
1678:
1679: /*
1680: * NpSetXeqAddr specifies the address at which the board should begin
1681: * execution of its on-board software. It also indicates the shared memory
1682: * address to be used. The board is specified by mp.
1683: */
1684:
1685: NpSetXeqAddr(mp,addr)
1686: struct npmaster *mp;
1687: caddr_t addr;
1688: {
1689: caddr_t shmaddr;
1690: int error;
1691:
1692: struct {
1693: unsign16 cmd_word;
1694: unsign16 hi_addr;
1695: unsign16 lo_addr;
1696: unsign16 mhi_addr;
1697: unsign16 mlo_addr;
1698: } cmd_block;
1699:
1700: if(NpDebug & DEBENTRY)
1701: printf("NpSetXeqAddr\n");
1702:
1703: shmaddr = (caddr_t)((int)mp->iomapbase & UBADDRMASK);
1704:
1705: cmd_block.cmd_word = NPBGN | NPCMD | NPLST | (BGNCNT + CMDCNT);
1706: cmd_block.hi_addr = HIWORD(addr);
1707: cmd_block.lo_addr = LOWORD(addr);
1708: cmd_block.mhi_addr = HIWORD(shmaddr);
1709: cmd_block.mlo_addr = LOWORD(shmaddr);
1710:
1711: if(NpDebug & DEBINIT) {
1712: printf("NpSetXeqAdddr: hi: %x lo: %x\n",HIWORD(addr), LOWORD(addr));
1713: printf("NpSetXeqAdddr: mhi: %x mlo: %x\n",HIWORD(shmaddr),LOWORD(shmaddr));
1714: }
1715:
1716: error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
1717:
1718: if(NpDebug & DEBENTRY)
1719: printf("NpSetXeqAddr...\n");
1720:
1721: return(error);
1722: }
1723:
1724: /*
1725: * NPIO issues a CSR0 load or dump request to the I-Board after packaging a
1726: * CSR0 Command Block.
1727: */
1728:
1729: NPIO(mp,src,dest,count,dir)
1730: struct npmaster *mp;
1731: paddr_t dest;
1732: paddr_t src;
1733: unsign16 count;
1734: int dir; /* Direction READ/WRITE */
1735: {
1736:
1737: int error;
1738:
1739: struct {
1740: unsign16 cmd_word; /* Command Word */
1741: unsign16 shi_addr; /* High word of Source Address */
1742: unsign16 slo_addr; /* Low word of Source Address */
1743: unsign16 dhi_addr; /* High word of Destination Address */
1744: unsign16 dlo_addr; /* Low word of Destination Address */
1745: unsign16 count; /* Byte count */
1746: unsign16 intlevel; /* Interrupt level to host */
1747: } cmd_block;
1748:
1749: if(NpDebug & DEBENTRY)
1750: printf("NPIO\n");
1751: if(NpDebug & DEBMAINT) {
1752: printf("I/O src addr = %x, dest addr = %x \n",src,dest);
1753: printf("I/O count = %d \n",count);
1754: }
1755:
1756: cmd_block.cmd_word = NPCBI | (CBICNT + IOCNT);
1757: cmd_block.intlevel = mp->vector;
1758: cmd_block.shi_addr = HIWORD(src);
1759: cmd_block.slo_addr = LOWORD(src);
1760: cmd_block.dhi_addr = HIWORD(dest);
1761: cmd_block.dlo_addr = LOWORD(dest);
1762: cmd_block.count = count;
1763: if ((mp->flags & LSTCMD) == 0)
1764: cmd_block.cmd_word |= NPLST;
1765: if(dir == B_READ)
1766: cmd_block.cmd_word |= NPDMP;
1767: else
1768: cmd_block.cmd_word |= NPLD;
1769:
1770:
1771: if(NpDebug & DEBIO) {
1772: printf("cmd: %x int: %o shi: %x slo: %x dhi: %x dlo: %x cnt: %x\n",
1773: cmd_block.cmd_word,cmd_block.intlevel,cmd_block.shi_addr,cmd_block.slo_addr,
1774: cmd_block.dhi_addr,cmd_block.dlo_addr,cmd_block.count);
1775: }
1776:
1777: mp->flags |= CSRPEND; /* CSR0 command pending */
1778:
1779: error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
1780: if(NpDebug & DEBENTRY)
1781: printf("NPIO...\n");
1782:
1783: return(error);
1784: }
1785:
1786:
1787: /*
1788: * NpKill will terminate all outstanding requests for the specified board.
1789: */
1790:
1791: NpKill(mp,curr_rp)
1792: struct npmaster *mp;
1793: struct npreq *curr_rp;
1794: {
1795: struct npreq *rp;
1796: int s;
1797:
1798: if(NpDebug & DEBENTRY)
1799: printf("NpKill\n");
1800:
1801: mp->reqtab->reqcnt = 0; /* Init request count */
1802:
1803: s = spl5(); /* Disable interrupts */
1804:
1805: /* Mark each active request as having an error and wake him up */
1806:
1807: for(rp = mp->reqtab->forw;rp != mp->reqtab;rp = rp->forw) {
1808:
1809: if(rp == curr_rp) continue;
1810:
1811: rp->flags |= (IOABORT | REQDONE);
1812: mp->reqtab->reqcnt++;
1813: /* if(rp->flags & NPUIO)
1814: iodone(&rp->buf);
1815: else */
1816: wakeup((caddr_t)rp);
1817: }
1818:
1819: if(NpDebug & DEBMAINT)
1820: printf("NpKill, req count is %d\n",mp->reqtab->reqcnt);
1821:
1822: splx(s);
1823:
1824: if(NpDebug & DEBENTRY)
1825: printf("NpKill...\n");
1826:
1827: return(0);
1828:
1829: }
1830:
1831: /* Hardware and Software Initializations for the specified unit */
1832:
1833: NpReset(mp,rp)
1834: register struct npmaster *mp;
1835: struct npreq *rp;
1836: {
1837: int error;
1838:
1839: if(NpDebug & DEBENTRY)
1840: printf("NpReset!\n");
1841:
1842: /* Mark board as being reset and make unavailable */
1843:
1844: mp->flags = BRDRESET;
1845:
1846: /* Abort outstanding requests for this board */
1847:
1848: mp->reqtab->reqcnt = 0; /* Init request count */
1849:
1850: /* Wakeup Poller if available and wait until he's gone */
1851:
1852: if(NpState & ICPAVAIL) {
1853:
1854: mp->flags |= BOARDREQ;
1855: mp->reqtab->reqcnt++;
1856:
1857: if(NpDebug & DEBMAINT)
1858: printf("Waking ICP in reset!\n");
1859:
1860: wakeup((caddr_t)&NpState);
1861:
1862: while(mp->reqtab->reqcnt)
1863: sleep((caddr_t)(&mp->reqtab),PZERO +1);
1864:
1865: if(NpDebug & DEBMAINT)
1866: printf("Reset:awoken by ICP senior!\n");
1867:
1868: }
1869:
1870: /* Abort outstanding requests and wait till they're gone */
1871:
1872: NpKill(mp,rp);
1873:
1874: while(mp->reqtab->reqcnt) {
1875:
1876: if(NpDebug & DEBMAINT) {
1877: printf("Sleeping in NpReset on reqtab!\n");
1878: printf("Reqcnt is %d.\n",mp->reqtab->reqcnt);
1879: }
1880:
1881: sleep((caddr_t)(&mp->reqtab),PZERO +1);
1882:
1883: }
1884:
1885: /* Free up I/O Map registers if any allocated */
1886:
1887: if(mp->iomapbase) {
1888:
1889: if(NpDebug & DEBMEM)
1890: printf("freeing shared memory map.\n");
1891:
1892: ubarelse(mp->devp->ui_ubanum,&mp->iomapbase);
1893: mp->iomapbase = 0;
1894: }
1895:
1896: /* Initialize S/W data structures in NP Driver */
1897:
1898: NpSWinit(mp->unit); /* Software initialization */
1899:
1900: /* Hardware initialization of the board */
1901:
1902: error = NpHWinit(mp->unit); /* Hardware initialization */
1903:
1904: mp->flags &= ~BRDRESET; /* Initialization complete */
1905:
1906: /* Initialize Pseudo-Drivers */
1907:
1908: if (IxReset)
1909: (*IxReset)(mp->unit, mp->devp->ui_ubanum, rp);
1910:
1911: /* Clear Poller's State Flag */
1912:
1913: NpState = NPCLEAR;
1914:
1915: if(NpDebug & DEBENTRY)
1916: printf("NpReset...\n");
1917:
1918: return(error);
1919: }
1920:
1921: /*
1922: * General purpose timeout function which sets the flag passed to it
1923: * as argument.
1924: */
1925:
1926: NpTimer(flagp)
1927: int *flagp;
1928: {
1929: *flagp = NPSET;
1930: }
1931:
1932: NpStats()
1933: {
1934: if(NpDebug & DEBENTRY)
1935: printf("npstats\n");
1936: return(0);
1937: }
1938:
1939: /*
1940: * NpCloseConn is called to issue a close connection command to the I-Board.
1941: */
1942:
1943: NpCloseConn(mp,protocol)
1944: struct npmaster *mp;
1945: unsign16 protocol;
1946: {
1947:
1948: register struct npreq *rp;
1949: register struct CQE *ep;
1950: int pri;
1951:
1952: if(NpDebug & DEBENTRY)
1953: printf("NpCloseConn\n");
1954:
1955: /*
1956: * Don't issue the Close Connection command if the Board
1957: * isn't up.
1958: */
1959:
1960: if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol))) {
1961: return;
1962: }
1963:
1964: /* Get a Request structure */
1965:
1966: while((rp = NpGetReq(mp->reqtab)) == NULL) {
1967: mp->reqtab->flags |= WANTREQ;
1968: sleep((caddr_t)(mp->reqtab),PZERO -1);
1969: }
1970:
1971: rp->intr = (int (*)())0; /* Do not call interrupt routine */
1972: rp->mapbase = 0; /* Clear mapping information */
1973:
1974: ep = rp->element; /* Handy pointer */
1975:
1976: /* Fill in CQE */
1977:
1978: ep->cqe_wind = 0; /* Entire buffer mapped */
1979: ep->cqe_nbuf = 1; /* Must be 1, no buffer chaining */
1980: ep->cqe_char = 0; /* Set to 0 for now */
1981:
1982: ep->cqe_func = NPSTOP; /* OS_STP to I-Board */
1983:
1984: ep->cqe_prot = protocol; /* Protocol of this connection */
1985: ep->cqe_lenrpb = 0; /* Parameter block length */
1986:
1987: ep->cqe_ust0 = ep->cqe_ust1 = NPCLEAR; /* Clear status flags */
1988:
1989: ep->cqe_famid = (unsign32)u.u_procp->p_pid; /* Process ID */
1990:
1991: NpAddReq(mp->reqtab,rp); /* Queue onto active list */
1992:
1993: pri = spl5(); /* Mask our interrupts */
1994:
1995: NpAddCQE(ep,&mp->shmemp->devcq,mp); /* Add CQE to device's queue */
1996:
1997: /* Wait for command to complete */
1998:
1999: while(!(rp->flags & REQDONE))
2000: sleep((caddr_t)rp,PZERO - 1);
2001:
2002: splx(pri);
2003:
2004: NpRemReq(rp); /* Remove request from active list */
2005:
2006: NpFreeReq(mp->reqtab,rp); /* Deallocate request structure */
2007:
2008: if(NpDebug & DEBENTRY)
2009: printf("NpCloseConn...\n");
2010:
2011: }
2012:
2013: /*
2014: * This function allows the protocol to be changed for a given connection.
2015: * It returns 0 for success, error code otherwise.
2016: */
2017:
2018: NpProtChange(protocol,unit)
2019: register unsign16 protocol;
2020: register int unit;
2021: {
2022:
2023: register struct npmaster *mp;
2024:
2025: /* Privileged users only for Maintenance Protocol */
2026:
2027: if((protocol == NPMAINT) && (u.u_uid != 0))
2028: return(EPERM);
2029:
2030: if(NpDebug & DEBMAINT)
2031: printf("NpProtChange = %x\n",protocol);
2032:
2033: if(protocol != NPMAINT) {
2034:
2035: /* Make sure the I-Board supports the protocol */
2036:
2037: mp = &npmasters[unit];
2038:
2039: if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
2040: return(ENXIO);
2041: }
2042:
2043: return(0);
2044: }
2045:
2046: /*
2047: * This function allows for the changing of the unit for a given connection.
2048: */
2049:
2050: struct npmaster *
2051: NpBoardChange(protocol,unit)
2052: register unsign16 protocol;
2053: register int unit; /* Unit number */
2054: {
2055: register struct npmaster *mp;
2056:
2057:
2058: if(unit > NNP)
2059: return((struct npmaster *)0);
2060:
2061: if(protocol != NPMAINT) {
2062:
2063: /*
2064: * Loop through the master structures finding a board which
2065: * supports the requested protocol.
2066: */
2067:
2068: for(mp = npmasters; mp ; mp = mp->next) {
2069:
2070: if(mp->flags & BADBOARD)
2071: continue;
2072:
2073: if(((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
2074: return(mp);
2075: }
2076: return((struct npmaster *)0);
2077: }
2078: return(&npmasters[unit]);
2079: }
2080:
2081: /*
2082: * NpMapMem - maps the user's memory updating the fields in the npreq
2083: * structure and returning the mapped address in rp->buffaddr.
2084: */
2085: NpMapMem(mp,rp,addr,count)
2086: register struct npmaster *mp;
2087: register struct npreq *rp;
2088: caddr_t addr;
2089: int count;
2090: {
2091:
2092: if(NpDebug & DEBENTRY)
2093: printf("NpMapMem\n");
2094: if(NpDebug & DEBIO)
2095: printf("mp %x rp %x addr %x count %x\n",mp,rp,addr,count);
2096:
2097: rp->virtmem = addr;
2098: rp->bytecnt = count;
2099:
2100: rp->buf.b_un.b_addr = addr;
2101: rp->buf.b_flags = B_PHYS | B_BUSY;
2102: rp->buf.b_bcount = count;
2103: rp->buf.b_proc = rp->procp;
2104:
2105: rp->procp->p_flag |= SPHYSIO;
2106: if(NpDebug & DEBENTRY)
2107: printf("vslock\n");
2108: vslock(addr,count);
2109: if(NpDebug & DEBENTRY)
2110: printf("vslock...\n");
2111:
2112: rp->mapbase = ubasetup(mp->devp->ui_ubanum,&rp->buf,0);
2113:
2114: rp->bufaddr = (caddr_t)(rp->mapbase & UBADDRMASK);
2115:
2116: if(NpDebug & DEBENTRY)
2117: printf("NpMapMem...\n");
2118: }
2119:
2120: /*
2121: * Unmap the user's memory and free up mapping registers
2122: */
2123:
2124: NpUnMapMem(mp,rp)
2125: struct npmaster *mp;
2126: struct npreq *rp;
2127: {
2128: if(NpDebug & DEBENTRY)
2129: printf("NpUnMapMem\n");
2130:
2131: ubarelse(mp->devp->ui_ubanum,&rp->mapbase);
2132: rp->mapbase = 0;
2133: vsunlock(rp->virtmem,rp->bytecnt,B_READ);
2134: rp->procp->p_flag &= ~SPHYSIO;
2135:
2136: if(NpDebug & DEBENTRY)
2137: printf("NpUnMapMem...\n");
2138: }
2139:
2140: npprobe(reg, ui)
2141: caddr_t reg;
2142: struct uba_device *ui;
2143: {
2144: register int br,cvec;
2145: u_short csraddr;
2146: int i;
2147:
2148: #ifdef lint
2149: br = 0; cvec = br; br = cvec;
2150: #endif
2151:
2152: if(NpDebug & DEBINIT)
2153: printf("In npprobe, regaddr is %x!\n",reg);
2154:
2155: cvec = (uba_hd[numuba].uh_lastiv -= 4);
2156:
2157: #ifdef OLDBSD
2158: /* Find unit number from npstd[] by matching the csr address */
2159:
2160: csraddr = (u_short)((int)reg & 0x0FFFF);
2161:
2162: for(i = 0; i < NNP; i++) {
2163:
2164: if(csraddr == npstd[i]) {
2165: npvectors[i] = cvec;
2166: break;
2167: }
2168: }
2169: if(i == NNP)
2170: printf("Couldn't find device in npstd[]!\n");
2171:
2172: #else
2173: npvectors[ui->ui_unit] = cvec;
2174: #endif
2175: br = 0x15;
2176:
2177: if(NpDebug & DEBINIT)
2178: printf("npprobe...\n");
2179:
2180: return(sizeof(struct NPREG)); /* CSR Registers */
2181:
2182: }
2183:
2184: npattach(ui)
2185: register struct uba_device *ui;
2186: {
2187:
2188: if(NpDebug & DEBINIT)
2189: printf("In npattach, ui is %x.\n",ui);
2190:
2191: npinit(ui->ui_unit);
2192: if (IxAttach)
2193: (*IxAttach)(ui);
2194:
2195: if(NpDebug & DEBINIT)
2196: printf("npattach...\n");
2197: }
2198:
2199:
2200: NpMem(mp, rp, uaddr)
2201: struct npmaster *mp;
2202: struct npreq *rp;
2203: unsigned long uaddr;
2204: {
2205: struct np_mem mem;
2206: register int error = 0;
2207:
2208: if(NpDebug & DEBENTRY)
2209: printf("npmem\n");
2210:
2211: if (error = copyin(uaddr, &mem, sizeof(mem)))
2212: return (error);
2213:
2214: if (mem.mem_type == NP_SET) {
2215: if (np_mapreq[mp->unit] != (struct npreq *)NPCLEAR)
2216: error = EBUSY;
2217: else {
2218: error = NpMapMem(mp, rp, mem.mem_addr, mem.mem_count);
2219: if (error != 0) {
2220: np_mapreq[mp->unit] = rp;
2221: mem.mem_addr = rp->bufaddr;
2222: }
2223: }
2224: } else if (mem.mem_type == NP_USET) {
2225: error = NpUnMapMem(mp, np_mapreq[mp->unit]);
2226: NpFreeReq(mp->reqtab, rp);
2227: NpFreeReq(mp->reqtab, np_mapreq[mp->unit]);
2228: np_mapreq[mp->unit] = (struct npreq *)NPCLEAR;
2229: } else
2230: error = EIO;
2231:
2232: if (error != 0)
2233: error = copyout(&mem, uaddr, sizeof(mem));
2234:
2235: if(NpDebug & DEBENTRY)
2236: printf("npmem...\n");
2237: return (error);
2238: }
2239: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.