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