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