![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lpa.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 lpa.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / vaxuba |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)lpa.c 7.4 (Berkeley) 4/3/90
7: */
8:
9: #include "lpa.h"
10: #if NLPA > 0
11:
12: #include "param.h"
13: #include "user.h"
14: #include "buf.h"
15: #include "proc.h"
16: #include "ioctl.h"
17: #include "uio.h"
18:
19: #include "ubavar.h"
20:
21: /*
22: * LPA driver for -- Asa Romberger
23: *
24: * open
25: * write microcode
26: * write dedicated mode dispatch table
27: * ioctl TIOCSETP to set parameters
28: * struct iocb {
29: * short *baddr; buffer address
30: * short rate; - 1,000,000 / frequency in Hz
31: * short wc; 15-13 = number of buffers - 1
32: * 12-0 = buffer size in words
33: * } iocb;
34: * read - 1 character indicating buffer index
35: * fill or empty buffer
36: * minor device number = DDCCCCCC where:
37: * DD = 00 for analog input
38: * = 01 for analog output
39: * CCCCCC = channel number
40: */
41: * define NOMCODE to eliminate the microcode download check
42: */
43: /* #define TRACELPA */
44: /* #define NOMCODE */
45:
46: #ifdef TRACELPA
47: # define TRACER(x) printf(x)
48: # define TRACERN(x, d) printf(x, d)
49: #else
50: # define TRACER(x)
51: # define TRACERN(x, d)
52: #endif
53:
54: /* PRIORITY AT WHICH PROGRAM SHOULD RUN */
55: /* THIS SHOULD EVENTUALLY TELL UNIX THIS IS A REAL-TIME DEVICE */
56:
57: #define NICE 0
58:
59: #define inc(v) (sc->v = ((sc->v + 1) % sc->sc_nbuf))
60:
61: #define LPAPRI (PZERO + 0)
62: #define LPAUNIT(dev) 0
63: #define LPADEVICE(dev) (((dev) >> 6) & 03)
64: #define LPACHANNEL(dev) ((dev) & 077)
65:
66: int lpaprobe(), lpaattach(), lpaiintr(), lpaointr();
67: u_short lpastd[] = {0170460, 0};
68: struct uba_device *lpadinfo[NLPA];
69: struct uba_driver lpadriver =
70: {lpaprobe, 0, lpaattach, 0, lpastd, "lpa", lpadinfo, 0, 0, 0 };
71:
72: struct lpa_softc {
73: int sc_flag; /* flags, as defined below */
74: int sc_device; /* device: 0 = analog in, 1 = analog out */
75: int sc_channel; /* device channel number */
76: struct buf sc_ubuffer; /* user buffer header */
77: int sc_ubabuf; /* uba allocation pointer for buffer */
78: int sc_ubufn; /* present buffer that user is accessing */
79: int sc_lbufn; /* present buffer that lpa is accessing */
80: int sc_lbufnx; /* next buffer for lpa (value in ustat) */
81: int sc_nbuf; /* number of buffers */
82: int sc_count; /* buffer size in words */
83: short sc_ustat; /* user status word */
84: struct buf sc_ustatbuf; /* dummy user status word buffer for ubasetup */
85: int sc_ubaustat; /* uba allocation pointer for ustat */
86: struct buf *sc_buffer; /* scratch buffer header */
87: int sc_start; /* 0 if lpa operation has been started */
88: } lpa_softc[NLPA];
89:
90: /* flags for sc_flag */
91: #define OPEN 01 /* device is open */
92: #define MCODE 02 /* microcode has been loaded */
93: #define DMDT 04 /* dedicated mode dispatch table loaded */
94: #define STTY 010 /* stty call and device initialized */
95: #define SLEEP 020 /* sleeping */
96:
97: /* bits for ustat */
98: #define DONE 0100000 /* done */
99: #define STOP 0040000 /* stop data transfer */
100: #define NBI 0003400 /* next buffer index */
101: #define LBI 0000003 /* last buffer index */
102:
103: struct lpadevice {
104: short lcim; /* control in and maintenance */
105: short lcos; /* control and status out */
106: short lrda; /* request description array address word */
107: short lms; /* maintenance status */
108: };
109:
110: /* control in and maintenance register bits */
111: #define READYI 0000200 /* ready in */
112: #define IIE 0000100 /* in interrupt enable */
113: #define RDAEXT 0000014 /* rda address extension */
114: #define RDAEXTOFFSET 2 /* offset of RDAEXT from right side */
115: #define GO 0000001 /* go */
116: #define RUN 0100000 /* run */
117: #define RESET 0040000 /* reset */
118: #define CWRITE 0020000 /* cram write */
119: #define EA 0004000 /* enable arbitration */
120: #define ROMO 0002000 /* rom O */
121: #define ROMI 0001000 /* rom I */
122: #define SMICRO 0000400 /* step microprocessor */
123:
124: /* control and status out register bits */
125: #define READYO 0200 /* ready out */
126: #define OIE 0100 /* out interrupt enable */
127: #define UINDEX 0007 /* user index */
128: #define ERROR 0100000 /* error */
129: #define ESTAT 0060000 /* error status */
130: #define ESCODE 0017400 /* error sub code */
131: #define ECODE 0077400 /* error status + error sub code */
132: #define OVERRUN 0243 /* overrun error */
133:
134: /* LPA COMMAND DESCRIPTION AREA */
135:
136: /* INIT COMMAND */
137: #define INIT 0 /* mode */
138: #define MCVERS 4 /* microcode version */
139: #define ACLOCKA 0170404 /* LPA bus addresses */
140: #define ACLOCKB 0170432
141: #define AAD1 0170400
142: #define AAD2 1 /* 0170440 - DOES NOT EXIST */
143: #define ADA 0170420
144: #define ADIO1 1 /* 0167770 - DOES NOT EXIST */
145: #define ADIO2 1 /* 0167760 - DOES NOT EXIST */
146: #define ADIO3 1 /* 0167750 - DOES NOT EXIST */
147: #define ADIO4 1 /* 0167740 - DOES NOT EXIST */
148: #define ADIO5 1 /* 0167730 - DOES NOT EXIST */
149:
150: /* CLOCK START COMMAND */
151: #define CLOCK 1 /* mode */
152: #define CLOCKA 0<<4 /* clock A */
153: /* clock status word */
154: #define ENACTR 1 /* enable counter */
155: #define R1M 1<<1 /* 1 MHz rate */
156: #define R100K 2<<1 /* 100 KHz rate */
157: #define R10K 3<<1 /* 10 KHz rate */
158: #define R1K 4<<1 /* 1 KHz rate */
159: #define R100 5<<1 /* 100 Hz rate */
160: #define REXT 6<<1 /* external rate (from st1 input) */
161: #define R60 7<<1 /* line frequency rate */
162: #define MFIE 0100 /* mode flag interrupt enable */
163: #define MSI 0<<8 /* single interval mode */
164: #define MRI 1<<8 /* repeat interval mode */
165: #define MEET 2<<8 /* external event time mode */
166: #define MEETZ 3<<8 /* external event time mode from zero base */
167: #define ST1EC 020000 /* st1 enable counter */
168: #define ST1IE 040000 /* st1 interrupt enable */
169:
170: /* DATA TRANSFER START COMMAND */
171: #define DTS 2 /* mode */
172: #define SCHAN 1<<8 /* single channel */
173:
174: lpaprobe(reg)
175: caddr_t reg;
176: {
177: register int br, cvec; /* value result */
178: register struct lpadevice *lpaaddr = (struct lpadevice *)reg;
179:
180: #ifdef lint
181: br = 0; cvec = br; br = cvec;
182: #endif
183: /* this should force an interrupt, stall, clear the lpa */
184: br = 0x15;
185: cvec = 0330;
186: TRACER("PROBE\n");
187: return (sizeof (struct lpadevice));
188: }
189:
190: lpaattach(ui)
191: register struct upa_device *ui;
192: {
193:
194: }
195:
196: lpaopen(dev, flag)
197: dev_t dev;
198: int flag;
199: {
200: register int unit = LPAUNIT(dev);
201: register struct lpa_softc *sc = &lpa_softc[unit];
202: register struct uba_device *ui = lpadinfo[unit];
203: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
204:
205: TRACER("OPEN\n");
206: if (unit >= NLPA || sc->sc_flag & OPEN || ui == 0 ||
207: ui->ui_alive == 0)
208: return (ENXIO);
209: (void) splhigh();
210: lpaaddr->lcim = RESET;
211: lpaaddr->lcim = 0;
212: (void) spl0();
213: lpaaddr->lcos = 0; /* clear the registers as a precaution */
214: lpaaddr->lrda = 0;
215: lpaaddr->lms = 0;
216: sc->sc_flag = OPEN;
217: sc->sc_device = LPADEVICE(dev);
218: sc->sc_channel = LPACHANNEL(dev);
219: sc->sc_buffer = geteblk();
220: sc->sc_buffer->b_error = 0;
221: sc->sc_buffer->b_proc = u.u_procp;
222: sc->sc_ubufn = -1;
223: /* THIS SHOULD EVENTUALLY SPECIFY "REAL-TIME" */
224: u.u_procp->p_nice = NICE;
225: return (0);
226: }
227:
228: lpaclose(dev, flag)
229: dev_t dev;
230: int flag;
231: {
232: register int unit = LPAUNIT(dev);
233: register struct lpa_softc *sc = &lpa_softc[unit];
234: register struct uba_device *ui = lpadinfo[unit];
235: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
236:
237: if (sc->sc_device && sc->sc_ubufn >= 0 && (sc->sc_flag & ERROR) == 0) {
238: if (sc->sc_start)
239: lpacmd(sc->sc_buffer, lpaaddr, sc, ui->ui_ubanum);
240: sc->sc_flag |= STOP;
241: (void) spl5();
242: while (sc->sc_flag & STOP) {
243: TRACER("SLEEP\n");
244: sc->sc_flag |= SLEEP;
245: sleep((caddr_t)sc, LPAPRI);
246: }
247: }
248: (void) splhigh();
249: lpaaddr->lcim = RESET;
250: lpaaddr->lcim = 0;
251: (void) spl0();
252: if (sc->sc_ubabuf) {
253: ubarelse(ui->ui_ubanum, &sc->sc_ubabuf);
254: sc->sc_ubabuf = 0;
255: (void) splclock();
256: vsunlock(sc->sc_ubuffer.b_un.b_addr, sc->sc_ubuffer.b_bcount,
257: (sc->sc_device)? B_READ : B_WRITE);
258: u.u_procp->p_flag &= ~SPHYSIO;
259: (void) spl0();
260: }
261: if (sc->sc_ubaustat) {
262: ubarelse(ui->ui_ubanum, &sc->sc_ubaustat);
263: sc->sc_ubaustat = 0;
264: }
265: if (sc->sc_buffer) {
266: brelse(sc->sc_buffer);
267: sc->sc_buffer = 0;
268: }
269: sc->sc_flag = 0;
270: TRACER("CLOSE\n");
271: return (0);
272: }
273:
274: lpawrite(dev, uio)
275: dev_t dev;
276: struct uio *uio;
277: {
278: register int unit = LPAUNIT(dev);
279: register struct lpa_softc *sc = &lpa_softc[unit];
280: register struct uba_device *ui = lpadinfo[unit];
281: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
282: register int f;
283:
284: TRACER("WRITE\n");
285: f = sc->sc_flag;
286: if ((f & OPEN) == 0)
287: return (ENXIO);
288: if ((f & MCODE) == 0) /* first write is the microcode */
289: return (lpamcode(lpaaddr, sc, uio));
290: if ((f & DMDT) == 0) /* second write is the dispatch table */
291: return (lpadmdt(lpaaddr, sc, ui->ui_ubanum, uio));
292: return (ENXIO);
293: }
294:
295: lpamcode(lpaaddr, sc, uio)
296: register struct lpadevice *lpaaddr;
297: register struct lpa_softc *sc;
298: struct uio *uio;
299: {
300: short v, r;
301: register int mcaddr;
302: int error;
303:
304: mcaddr = 0;
305: while (uio->uio_resid) {
306: error = uiomove(&v, 2, uio);
307: if (error)
308: break;
309: lpaaddr->lcim = 0; /* load microcode word */
310: lpaaddr->lrda = mcaddr;
311: lpaaddr->lms = v;
312: lpaaddr->lcim = ROMO;
313: lpaaddr->lcim |= CWRITE;
314: lpaaddr->lcim = 0; /* verify microcode word */
315: lpaaddr->lrda = mcaddr;
316: lpaaddr->lcim = ROMO;
317: if ((r = lpaaddr->lms) != v) {
318: /* download failure */
319: printf("LPA MICROCODE FAIL: exp:%o got:%o\n", v, r);
320: return (ENXIO);
321: }
322: mcaddr++;
323: }
324: lpaaddr->lcim = RUN | EA; /* turn it on */
325: sc->sc_flag |= MCODE;
326: lpaaddr->lcim |= IIE;
327: lpaaddr->lcos |= OIE;
328: return (error);
329: TRACER("MCODE\n");
330: }
331:
332: lpadmdt(lpaaddr, sc, ubanum, uio)
333: register struct lpadevice *lpaaddr;
334: register struct lpa_softc *sc;
335: register short ubanum;
336: struct uio *uio;
337: {
338: register short *p;
339: register int n;
340: int error;
341:
342: p = (short *) sc->sc_buffer->b_un.b_addr; /* INIT */
343: *p++ = (MCVERS << 8) | INIT; /* mode */
344: *p++ = ACLOCKA; /* LPA bus device addresses */
345: *p++ = ACLOCKB;
346: *p++ = AAD1;
347: *p++ = AAD2;
348: *p++ = ADA;
349: *p++ = ADIO1;
350: *p++ = ADIO2;
351: *p++ = ADIO3;
352: *p++ = ADIO4;
353: *p++ = ADIO5;
354: n = MIN(uio->uio_resid, 256); /* dedicated mode dispatch table */
355: error = uiomove((char *)p, n, uio);
356: if (error)
357: return (error);
358: n >>= 1;
359: p += n;
360: while (n++ < 128)
361: *p++ = 0;
362: lpacmd(sc->sc_buffer, lpaaddr, sc, ubanum);
363: sc->sc_flag |= DMDT;
364: return (0);
365: TRACER("DMDT\n");
366: }
367:
368: lpaioctl(dev, cmd, data, flag)
369: dev_t dev;
370: caddr_t data;
371: {
372: register int unit = LPAUNIT(dev);
373: register struct lpa_softc *sc = &lpa_softc[unit];
374: register struct uba_device *ui = lpadinfo[unit];
375: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
376: register short *p;
377: register int i;
378: register int v;
379: struct iocb {
380: short *baddr;
381: short rate;
382: short wc;
383: } *iocb;
384:
385: TRACER("IOCTL IN\n");
386: if (cmd != TIOCSETP || (sc->sc_flag & DMDT) == 0)
387: return (ENXIO);
388: iocb = (struct iocb *)data;
389: p = (short *) sc->sc_buffer->b_un.b_addr; /* CLOCK START */
390: *p++ = CLOCK | CLOCKA; /* mode */
391: *p++ = ENACTR | R1M | MFIE | MRI; /* clock status */
392: *p = iocb->rate; /* clock preset */
393: lpacmd(sc->sc_buffer, lpaaddr, sc, ui->ui_ubanum);
394: TRACER("CLOCK STARTED\n");
395: p = (short *) sc->sc_buffer->b_un.b_addr; /* DATA TRANSFER START*/
396: *p++ = (sc->sc_device << 7) | DTS | SCHAN; /* mode */
397: sc->sc_count = iocb->wc & 017777; /* word count per buffer */
398: *p++ = sc->sc_count;
399: /* user status word */
400: sc->sc_ustatbuf.b_un.b_addr = (caddr_t) &sc->sc_ustat;
401: sc->sc_ustatbuf.b_flags = 0;
402: sc->sc_ustatbuf.b_bcount = 2;
403: sc->sc_ustatbuf.b_proc = u.u_procp;
404: sc->sc_ubaustat = ubasetup(ui->ui_ubanum, &sc->sc_ustatbuf, 0);
405: v = sc->sc_ubaustat;
406: *p++ = v;
407: *p = (v >> 16) & 03; /* into low portion of word */
408: sc->sc_nbuf = (iocb->wc >> 13) & 07; /* number of buffers */
409: *p++ |= sc->sc_nbuf++ << 8; /* into high portion of word */
410: /* buffer addresses */
411: if (useracc(sc->sc_ubuffer.b_un.b_addr = (caddr_t) iocb->baddr,
412: sc->sc_ubuffer.b_bcount = sc->sc_count * sc->sc_nbuf * 2,
413: (i = (sc->sc_device)? B_READ : B_WRITE) ) == NULL) {
414: TRACER("USER BUFFER FAULT\n");
415: return (EFAULT);
416: }
417: sc->sc_ubuffer.b_flags = B_PHYS | B_BUSY | i;
418: sc->sc_ubuffer.b_proc = u.u_procp;
419: u.u_procp->p_flag |= SPHYSIO;
420: vslock(sc->sc_ubuffer.b_un.b_addr, sc->sc_ubuffer.b_bcount);
421: sc->sc_ubabuf = ubasetup(ui->ui_ubanum, &sc->sc_ubuffer, 0);
422: v = sc->sc_ubabuf;
423: for (i = 0; i < sc->sc_nbuf; i++) {
424: *p++ = v;
425: *p++ = (v >> 16) & 03;
426: v += sc->sc_count * 2;
427: }
428: for ( ; i <= 7; i++) {
429: *p++ = 0;
430: *p++ = 0;
431: }
432: *p++ = 0; *p++ = 0; /* random channel list address */
433: *p++ = 0; /* delay */
434: *p++ = sc->sc_channel; /* start channel, channel inc */
435: *p++ = 1; /* number of samples in a sequence */
436: *p++ = 0; /* dwell */
437: *p++ = 0; /* start word no., event mark word */
438: *p++ = 0; /* start word mask */
439: *p = 0; /* event mark mask */
440: sc->sc_ustat = 0;
441: sc->sc_start = (sc->sc_device)? sc->sc_nbuf+1 : 1;
442: sc->sc_lbufn = 0;
443: sc->sc_lbufnx = 0;
444: sc->sc_flag |= STTY;
445: TRACER("IOCTL OUT\n");
446: return (0);
447: }
448:
449: lparead(dev, uio)
450: dev_t dev;
451: struct uio *uio;
452: {
453: register int unit = LPAUNIT(dev);
454: register struct lpa_softc *sc = &lpa_softc[unit];
455: register struct uba_device *ui = lpadinfo[unit];
456: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
457:
458: TRACER("READ\n");
459: if ((sc->sc_flag & STTY) == 0)
460: return (ENXIO);
461: if (sc->sc_flag & ERROR)
462: return (ENXIO);
463: if (sc->sc_start)
464: if (--sc->sc_start == 0) {
465: lpacmd(sc->sc_buffer, lpaaddr, sc, ui->ui_ubanum);
466: TRACER("START\n");
467: }
468: inc(sc_ubufn);
469: if (sc->sc_start == 0) {
470: (void) spl5();
471: while (sc->sc_ubufn == sc->sc_lbufn) {
472: if (sc->sc_flag & ERROR)
473: return (ENXIO);
474: TRACER("SLEEP\n");
475: sc->sc_flag |= SLEEP;
476: sleep(sc, LPAPRI);
477: }
478: (void) spl0();
479: }
480: TRACERN("READ %d\n", sc->sc_ubufn);
481: return (uiomove(&sc->sc_ubufn, 1, uio));
482: }
483:
484: lpacmd(bp, lpaaddr, sc, ubanum)
485: register struct buf *bp;
486: register struct lpadevice *lpaaddr;
487: register struct lpa_softc *sc;
488: register short ubanum;
489: {
490: int ubareg;
491:
492: TRACER("CMD\n");
493: ubareg = ubasetup(ubanum, bp, UBA_NEEDBDP);
494: lpawait(lpaaddr, sc);
495: lpaaddr->lrda = ubareg;
496: lpaaddr->lcim &= ~RDAEXT;
497: lpaaddr->lcim |= ((ubareg >> (16-RDAEXTOFFSET)) & RDAEXT) | GO;
498: lpawait(lpaaddr, sc);
499: ubarelse(ubanum, &ubareg);
500: }
501:
502: lpawait(lpaaddr, sc)
503: register struct lpadevice *lpaaddr;
504: register struct lpa_softc *sc;
505: {
506:
507: (void) spl5();
508: while ((lpaaddr->lcim & READYI) == 0) {
509: TRACER("SLEEP\n");
510: sc->sc_flag |= SLEEP;
511: sleep((caddr_t)sc, LPAPRI);
512: }
513: (void) spl0();
514: }
515:
516: lpaiintr(unit)
517: int unit;
518: {
519: register struct lpa_softc *sc = &lpa_softc[unit];
520:
521: TRACER("{I");
522: if (sc->sc_flag & SLEEP) {
523: TRACER("<WAKEUP>");
524: wakeup((caddr_t)sc);
525: sc->sc_flag &= ~SLEEP;
526: }
527: TRACER("}");
528: }
529:
530: lpaointr(unit)
531: int unit;
532: {
533: register int c, m;
534: register struct lpa_softc *sc = &lpa_softc[unit];
535: register struct uba_device *ui = lpadinfo[unit];
536: register struct lpadevice *lpaaddr = (struct lpadevice *) ui->ui_addr;
537: int spx;
538:
539: TRACER("{O");
540: if (sc->sc_flag & SLEEP) {
541: TRACER("<WAKEUP>");
542: wakeup(sc);
543: sc->sc_flag &= ~SLEEP;
544: }
545: c = lpaaddr->lcos;
546: m = lpaaddr->lms;
547: lpaaddr->lcos &= ~READYO;
548: if (c & ERROR) {
549: TRACER("<ERROR>");
550: c = (c >> 8) & 0377;
551: if ((sc->sc_flag & STOP) == 0 || (c != OVERRUN)) {
552: printf("LPA ERROR %o %o\n", c, m&0177777);
553: sc->sc_flag |= ERROR;
554: }
555: sc->sc_flag &= ~STOP;
556: TRACER("}\n");
557: return;
558: }
559: TRACERN("<LPA %d>", sc->sc_lbufnx);
560: sc->sc_lbufn = sc->sc_lbufnx;
561: if (sc->sc_ubufn == sc->sc_lbufnx && c & ECODE) {
562: TRACER("<STOP?>");
563: if (sc->sc_flag & STOP)
564: return;
565: printf("LPA OVERRUN\n");
566: sc->sc_flag |= ERROR;
567: }
568: inc(sc_lbufnx);
569: TRACERN("<USTAT %o>", sc->sc_ustat);
570: spx = splhigh();
571: sc->sc_ustat &= ~NBI;
572: sc->sc_ustat |= sc->sc_lbufnx << 8;
573: sc->sc_ustat &= ~DONE;
574: splx(spx);
575: TRACERN("<LPAN %d>}", sc->sc_lbufnx);
576: }
577:
578: lpareset(uban)
579: int uban;
580: {
581: register struct uba_device *ui;
582: register struct lpadevice *lpaaddr;
583: register struct lpa_softc *sc;
584: register int unit;
585:
586: TRACER("LPA RESET\n");
587: for (unit = 0; unit < NLPA; unit++) {
588: if ((ui = lpadinfo[unit]) == 0 ||
589: ui->ui_ubanum != uban || ui->ui_alive == 0)
590: continue;
591: printf(" lpa%d", unit);
592: lpaaddr = (struct lpadevice *)ui->ui_addr;
593: sc = &lpa_softc[unit];
594: sc->sc_flag |= ERROR;
595: (void) splhigh();
596: lpaaddr->lcim = RESET;
597: lpaaddr->lcim = 0;
598: (void) spl0();
599: if (sc->sc_flag & SLEEP) {
600: wakeup((caddr_t)sc);
601: sc->sc_flag &= ~SLEEP;
602: }
603: }
604: }
605: #endif NLPA
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.