1: /*
2: * /src/NTP/ntp4-dev/libparse/parsesolaris.c,v 4.11 2005/04/16 17:32:10 kardel RELEASE_20050508_A
3: *
4: * parsesolaris.c,v 4.11 2005/04/16 17:32:10 kardel RELEASE_20050508_A
5: *
6: * STREAMS module for reference clocks
7: *
8: * Copyright (c) 1995-2005 by Frank Kardel <kardel <AT> ntp.org>
9: * Copyright (c) 1989-1994 by Frank Kardel, Friedrich-Alexander Universität Erlangen-Nürnberg, Germany
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. Neither the name of the author nor the names of its contributors
20: * may be used to endorse or promote products derived from this software
21: * without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33: * SUCH DAMAGE.
34: *
35: */
36:
37: #define _KERNEL /* it is a _KERNEL module */
38:
39: #ifndef lint
40: static char rcsid[] = "parsesolaris.c,v 4.11 2005/04/16 17:32:10 kardel RELEASE_20050508_A";
41: #endif
42:
43: #include <sys/types.h>
44: #include <sys/conf.h>
45: #include <sys/errno.h>
46: #include <sys/time.h>
47: #include <sys/termios.h>
48: #include <sys/stream.h>
49: #include <sys/strtty.h>
50: #include <sys/stropts.h>
51: #include <sys/modctl.h>
52: #include <sys/ddi.h>
53: #include <sys/sunddi.h>
54: #ifdef __GNUC__ /* makes it compile on Solaris 2.6 - acc doesn't like it -- GREAT! */
55: #include <stdarg.h>
56: #endif
57:
58: #include "ntp_fp.h"
59: #include "parse.h"
60: #include <sys/parsestreams.h>
61:
62: /*--------------- loadable driver section -----------------------------*/
63:
64: static struct streamtab parseinfo;
65:
66: static struct fmodsw fmod_templ =
67: {
68: "parse", /* module name */
69: &parseinfo, /* module information */
70: D_NEW|D_MP|D_MTQPAIR, /* exclusive for q pair */
71: /* lock ptr */
72: };
73:
74: extern struct mod_ops mod_strmodops;
75:
76: static struct modlstrmod modlstrmod =
77: {
78: &mod_strmodops, /* a STREAMS module */
79: "PARSE - NTP reference", /* name this baby - keep room for revision number */
80: &fmod_templ
81: };
82:
83: static struct modlinkage modlinkage =
84: {
85: MODREV_1,
86: {
87: &modlstrmod,
88: NULL
89: }
90: };
91:
92: /*
93: * module management routines
94: */
95: /*ARGSUSED*/
96: int
97: _init(
98: void
99: )
100: {
101: static char revision[] = "4.6";
102: char *s, *S;
103: char *t;
104:
105: #ifndef lint
106: t = rcsid;
107: #endif
108:
109: /*
110: * copy RCS revision into Drv_name
111: *
112: * are we forcing RCS here to do things it was not built for ?
113: */
114: s = revision;
115: if (*s == '$')
116: {
117: /*
118: * skip "$Revision: "
119: * if present. - not necessary on a -kv co (cvs export)
120: */
121: while (*s && (*s != ' '))
122: {
123: s++;
124: }
125: if (*s == ' ') s++;
126: }
127:
128: t = modlstrmod.strmod_linkinfo;
129: while (*t && (*t != ' '))
130: {
131: t++;
132: }
133: if (*t == ' ') t++;
134:
135: S = s;
136: while (*S && (((*S >= '0') && (*S <= '9')) || (*S == '.')))
137: {
138: S++;
139: }
140:
141: if (*s && *t && (S > s))
142: {
143: if (strlen(t) >= (S - s))
144: {
145: (void) strncpy(t, s, (unsigned)(S - s));
146: }
147: }
148: return (mod_install(&modlinkage));
149: }
150:
151: /*ARGSUSED*/
152: int
153: _info(
154: struct modinfo *modinfop
155: )
156: {
157: return (mod_info(&modlinkage, modinfop));
158: }
159:
160: /*ARGSUSED*/
161: int
162: _fini(
163: void
164: )
165: {
166: if (mod_remove(&modlinkage) != DDI_SUCCESS)
167: {
168: return EBUSY;
169: }
170: else
171: return DDI_SUCCESS;
172: }
173:
174: /*--------------- stream module definition ----------------------------*/
175:
176: static int parseopen (queue_t *, dev_t *, int, int, cred_t *);
177: static int parseclose (queue_t *, int);
178: static int parsewput (queue_t *, mblk_t *);
179: static int parserput (queue_t *, mblk_t *);
180: static int parsersvc (queue_t *);
181:
182: static struct module_info driverinfo =
183: {
184: 0, /* module ID number */
185: fmod_templ.f_name, /* module name - why repeated here ? compat ?*/
186: 0, /* minimum accepted packet size */
187: INFPSZ, /* maximum accepted packet size */
188: 1, /* high water mark - flow control */
189: 0 /* low water mark - flow control */
190: };
191:
192: static struct qinit rinit = /* read queue definition */
193: {
194: parserput, /* put procedure */
195: parsersvc, /* service procedure */
196: parseopen, /* open procedure */
197: parseclose, /* close procedure */
198: NULL, /* admin procedure - NOT USED FOR NOW */
199: &driverinfo, /* information structure */
200: NULL /* statistics */
201: };
202:
203: static struct qinit winit = /* write queue definition */
204: {
205: parsewput, /* put procedure */
206: NULL, /* service procedure */
207: NULL, /* open procedure */
208: NULL, /* close procedure */
209: NULL, /* admin procedure - NOT USED FOR NOW */
210: &driverinfo, /* information structure */
211: NULL /* statistics */
212: };
213:
214: static struct streamtab parseinfo = /* stream info element for parse driver */
215: {
216: &rinit, /* read queue */
217: &winit, /* write queue */
218: NULL, /* read mux */
219: NULL /* write mux */
220: };
221:
222: /*--------------- driver data structures ----------------------------*/
223:
224: /*
225: * we usually have an inverted signal - but you
226: * can change this to suit your needs
227: */
228: int cd_invert = 1; /* invert status of CD line - PPS support via CD input */
229:
230: #ifdef PARSEDEBUG
231: int parsedebug = ~0;
232: #else
233: int parsedebug = 0;
234: #endif
235:
236: /*--------------- module implementation -----------------------------*/
237:
238: #define TIMEVAL_USADD(_X_, _US_) do {\
239: (_X_)->tv_usec += (_US_);\
240: if ((_X_)->tv_usec >= 1000000)\
241: {\
242: (_X_)->tv_sec++;\
243: (_X_)->tv_usec -= 1000000;\
244: }\
245: } while (0)
246:
247: static int init_linemon (queue_t *);
248: static void close_linemon (queue_t *, queue_t *);
249:
250: #define M_PARSE 0x0001
251: #define M_NOPARSE 0x0002
252:
253: void
254: ntp_memset(
255: char *a,
256: int x,
257: int c
258: )
259: {
260: while (c-- > 0)
261: *a++ = x;
262: }
263:
264: static void
265: pprintf(
266: int lev,
267: char *form,
268: ...
269: )
270: {
271: va_list ap;
272:
273: va_start(ap, form);
274:
275: if (lev & parsedebug)
276: vcmn_err(CE_CONT, form, ap);
277:
278: va_end(ap);
279: }
280:
281: static int
282: setup_stream(
283: queue_t *q,
284: int mode
285: )
286: {
287: register mblk_t *mp;
288:
289: pprintf(DD_OPEN,"parse: SETUP_STREAM - setting up stream for q=%x\n", q);
290:
291: mp = allocb(sizeof(struct stroptions), BPRI_MED);
292: if (mp)
293: {
294: struct stroptions *str = (struct stroptions *)mp->b_wptr;
295:
296: str->so_flags = SO_READOPT|SO_HIWAT|SO_LOWAT|SO_ISNTTY;
297: str->so_readopt = (mode == M_PARSE) ? RMSGD : RNORM;
298: str->so_hiwat = (mode == M_PARSE) ? sizeof(parsetime_t) : 256;
299: str->so_lowat = 0;
300: mp->b_datap->db_type = M_SETOPTS;
301: mp->b_wptr += sizeof(struct stroptions);
302: if (!q)
303: panic("NULL q - strange");
304: putnext(q, mp);
305: return putctl1(WR(q)->q_next, M_CTL, (mode == M_PARSE) ? MC_SERVICEIMM :
306: MC_SERVICEDEF);
307: }
308: else
309: {
310: pprintf(DD_OPEN, "parse: setup_stream - FAILED - no MEMORY for allocb\n");
311: return 0;
312: }
313: }
314:
315: /*ARGSUSED*/
316: static int
317: parseopen(
318: queue_t *q,
319: dev_t *dev,
320: int flag,
321: int sflag,
322: cred_t *credp
323: )
324: {
325: register parsestream_t *parse;
326: static int notice = 0;
327:
328: pprintf(DD_OPEN, "parse: OPEN - q=%x\n", q);
329:
330: if (sflag != MODOPEN)
331: { /* open only for modules */
332: pprintf(DD_OPEN, "parse: OPEN - FAILED - not MODOPEN\n");
333: return EIO;
334: }
335:
336: if (q->q_ptr != (caddr_t)NULL)
337: {
338: pprintf(DD_OPEN, "parse: OPEN - FAILED - EXCLUSIVE ONLY\n");
339: return EBUSY;
340: }
341:
342: q->q_ptr = (caddr_t)kmem_alloc(sizeof(parsestream_t), KM_SLEEP);
343: if (q->q_ptr == (caddr_t)0)
344: {
345: return ENOMEM;
346: }
347:
348: pprintf(DD_OPEN, "parse: OPEN - parse area q=%x, q->q_ptr=%x\n", q, q->q_ptr);
349: WR(q)->q_ptr = q->q_ptr;
350: pprintf(DD_OPEN, "parse: OPEN - WQ parse area q=%x, q->q_ptr=%x\n", WR(q), WR(q)->q_ptr);
351:
352: parse = (parsestream_t *) q->q_ptr;
353: bzero((caddr_t)parse, sizeof(*parse));
354: parse->parse_queue = q;
355: parse->parse_status = PARSE_ENABLE;
356: parse->parse_ppsclockev.tv.tv_sec = 0;
357: parse->parse_ppsclockev.tv.tv_usec = 0;
358: parse->parse_ppsclockev.serial = 0;
359:
360: qprocson(q);
361:
362: pprintf(DD_OPEN, "parse: OPEN - initializing io subsystem q=%x\n", q);
363:
364: if (!parse_ioinit(&parse->parse_io))
365: {
366: /*
367: * ok guys - beat it
368: */
369: qprocsoff(q);
370:
371: kmem_free((caddr_t)parse, sizeof(parsestream_t));
372:
373: return EIO;
374: }
375:
376: pprintf(DD_OPEN, "parse: OPEN - initializing stream q=%x\n", q);
377:
378: if (setup_stream(q, M_PARSE))
379: {
380: (void) init_linemon(q); /* hook up PPS ISR routines if possible */
381: pprintf(DD_OPEN, "parse: OPEN - SUCCEEDED\n");
382:
383: /*
384: * I know that you know the delete key, but you didn't write this
385: * code, did you ? - So, keep the message in here.
386: */
387: if (!notice)
388: {
389: cmn_err(CE_CONT, "?%s: Copyright (c) 1993-2005, Frank Kardel\n", modlstrmod.strmod_linkinfo);
390: notice = 1;
391: }
392:
393: return 0;
394: }
395: else
396: {
397: qprocsoff(q);
398:
399: kmem_free((caddr_t)parse, sizeof(parsestream_t));
400:
401: return EIO;
402: }
403: }
404:
405: /*ARGSUSED*/
406: static int
407: parseclose(
408: queue_t *q,
409: int flags
410: )
411: {
412: register parsestream_t *parse = (parsestream_t *)q->q_ptr;
413: register unsigned long s;
414:
415: pprintf(DD_CLOSE, "parse: CLOSE\n");
416:
417: qprocsoff(q);
418:
419: s = splhigh();
420:
421: if (parse->parse_dqueue)
422: close_linemon(parse->parse_dqueue, q);
423: parse->parse_dqueue = (queue_t *)0;
424:
425: (void) splx(s);
426:
427: parse_ioend(&parse->parse_io);
428:
429: kmem_free((caddr_t)parse, sizeof(parsestream_t));
430:
431: q->q_ptr = (caddr_t)NULL;
432: WR(q)->q_ptr = (caddr_t)NULL;
433:
434: return 0;
435: }
436:
437: /*
438: * move unrecognized stuff upward
439: */
440: static int
441: parsersvc(
442: queue_t *q
443: )
444: {
445: mblk_t *mp;
446:
447: while ((mp = getq(q)))
448: {
449: if (canputnext(q) || (mp->b_datap->db_type > QPCTL))
450: {
451: putnext(q, mp);
452: pprintf(DD_RSVC, "parse: RSVC - putnext\n");
453: }
454: else
455: {
456: putbq(q, mp);
457: pprintf(DD_RSVC, "parse: RSVC - flow control wait\n");
458: break;
459: }
460: }
461: return 0;
462: }
463:
464: /*
465: * do ioctls and
466: * send stuff down - dont care about
467: * flow control
468: */
469: static int
470: parsewput(
471: queue_t *q,
472: mblk_t *mp
473: )
474: {
475: register int ok = 1;
476: register mblk_t *datap;
477: register struct iocblk *iocp;
478: parsestream_t *parse = (parsestream_t *)q->q_ptr;
479:
480: pprintf(DD_WPUT, "parse: parsewput\n");
481:
482: switch (mp->b_datap->db_type)
483: {
484: default:
485: putnext(q, mp);
486: break;
487:
488: case M_IOCTL:
489: iocp = (struct iocblk *)mp->b_rptr;
490: switch (iocp->ioc_cmd)
491: {
492: default:
493: pprintf(DD_WPUT, "parse: parsewput - forward M_IOCTL\n");
494: putnext(q, mp);
495: break;
496:
497: case CIOGETEV:
498: /*
499: * taken from Craig Leres ppsclock module (and modified)
500: */
501: datap = allocb(sizeof(struct ppsclockev), BPRI_MED);
502: if (datap == NULL || mp->b_cont)
503: {
504: mp->b_datap->db_type = M_IOCNAK;
505: iocp->ioc_error = (datap == NULL) ? ENOMEM : EINVAL;
506: if (datap != NULL)
507: freeb(datap);
508: qreply(q, mp);
509: break;
510: }
511:
512: mp->b_cont = datap;
513: *(struct ppsclockev *)datap->b_wptr = parse->parse_ppsclockev;
514: datap->b_wptr +=
515: sizeof(struct ppsclockev) / sizeof(*datap->b_wptr);
516: mp->b_datap->db_type = M_IOCACK;
517: iocp->ioc_count = sizeof(struct ppsclockev);
518: qreply(q, mp);
519: break;
520:
521: case PARSEIOC_ENABLE:
522: case PARSEIOC_DISABLE:
523: {
524: parse->parse_status = (parse->parse_status & (unsigned)~PARSE_ENABLE) |
525: (iocp->ioc_cmd == PARSEIOC_ENABLE) ?
526: PARSE_ENABLE : 0;
527: if (!setup_stream(RD(q), (parse->parse_status & PARSE_ENABLE) ?
528: M_PARSE : M_NOPARSE))
529: {
530: mp->b_datap->db_type = M_IOCNAK;
531: }
532: else
533: {
534: mp->b_datap->db_type = M_IOCACK;
535: }
536: qreply(q, mp);
537: break;
538: }
539:
540: case PARSEIOC_TIMECODE:
541: case PARSEIOC_SETFMT:
542: case PARSEIOC_GETFMT:
543: case PARSEIOC_SETCS:
544: if (iocp->ioc_count == sizeof(parsectl_t))
545: {
546: parsectl_t *dct = (parsectl_t *)mp->b_cont->b_rptr;
547:
548: switch (iocp->ioc_cmd)
549: {
550: case PARSEIOC_TIMECODE:
551: pprintf(DD_WPUT, "parse: parsewput - PARSEIOC_TIMECODE\n");
552: ok = parse_timecode(dct, &parse->parse_io);
553: break;
554:
555: case PARSEIOC_SETFMT:
556: pprintf(DD_WPUT, "parse: parsewput - PARSEIOC_SETFMT\n");
557: ok = parse_setfmt(dct, &parse->parse_io);
558: break;
559:
560: case PARSEIOC_GETFMT:
561: pprintf(DD_WPUT, "parse: parsewput - PARSEIOC_GETFMT\n");
562: ok = parse_getfmt(dct, &parse->parse_io);
563: break;
564:
565: case PARSEIOC_SETCS:
566: pprintf(DD_WPUT, "parse: parsewput - PARSEIOC_SETCS\n");
567: ok = parse_setcs(dct, &parse->parse_io);
568: break;
569: }
570: mp->b_datap->db_type = ok ? M_IOCACK : M_IOCNAK;
571: }
572: else
573: {
574: mp->b_datap->db_type = M_IOCNAK;
575: }
576: pprintf(DD_WPUT, "parse: parsewput qreply - %s\n", (mp->b_datap->db_type == M_IOCNAK) ? "M_IOCNAK" : "M_IOCACK");
577: qreply(q, mp);
578: break;
579: }
580: }
581: return 0;
582: }
583:
584: /*
585: * read characters from streams buffers
586: */
587: static unsigned long
588: rdchar(
589: mblk_t **mp
590: )
591: {
592: while (*mp != (mblk_t *)NULL)
593: {
594: if ((*mp)->b_wptr - (*mp)->b_rptr)
595: {
596: return (unsigned long)(*(unsigned char *)((*mp)->b_rptr++));
597: }
598: else
599: {
600: register mblk_t *mmp = *mp;
601:
602: *mp = (*mp)->b_cont;
603: freeb(mmp);
604: }
605: }
606: return (unsigned long)~0;
607: }
608:
609: /*
610: * convert incoming data
611: */
612: static int
613: parserput(
614: queue_t *q,
615: mblk_t *imp
616: )
617: {
618: register unsigned char type;
619: mblk_t *mp = imp;
620:
621: switch (type = mp->b_datap->db_type)
622: {
623: default:
624: /*
625: * anything we don't know will be put on queue
626: * the service routine will move it to the next one
627: */
628: pprintf(DD_RPUT, "parse: parserput - forward type 0x%x\n", type);
629:
630: if (canputnext(q) || (mp->b_datap->db_type > QPCTL))
631: {
632: putnext(q, mp);
633: }
634: else
635: putq(q, mp);
636: break;
637:
638: case M_BREAK:
639: case M_DATA:
640: {
641: register parsestream_t * parse = (parsestream_t *)q->q_ptr;
642: register mblk_t *nmp;
643: register unsigned long ch;
644: timestamp_t c_time;
645: timespec_t hres_time;
646:
647: /*
648: * get time on packet delivery
649: */
650: gethrestime(&hres_time);
651: c_time.tv.tv_sec = hres_time.tv_sec;
652: c_time.tv.tv_usec = hres_time.tv_nsec / 1000;
653:
654: if (!(parse->parse_status & PARSE_ENABLE))
655: {
656: pprintf(DD_RPUT, "parse: parserput - parser disabled - forward type 0x%x\n", type);
657: if (canputnext(q) || (mp->b_datap->db_type > QPCTL))
658: {
659: putnext(q, mp);
660: }
661: else
662: putq(q, mp);
663: }
664: else
665: {
666: pprintf(DD_RPUT, "parse: parserput - M_%s\n", (type == M_DATA) ? "DATA" : "BREAK");
667: if (type == M_DATA)
668: {
669: /*
670: * parse packet looking for start an end characters
671: */
672: while (mp != (mblk_t *)NULL)
673: {
674: ch = rdchar(&mp);
675: if (ch != ~0 && parse_ioread(&parse->parse_io, (unsigned int)ch, &c_time))
676: {
677: /*
678: * up up and away (hopefully ...)
679: * don't press it if resources are tight or nobody wants it
680: */
681: nmp = (mblk_t *)NULL;
682: if (canputnext(parse->parse_queue) && (nmp = allocb(sizeof(parsetime_t), BPRI_MED)))
683: {
684: bcopy((caddr_t)&parse->parse_io.parse_dtime, (caddr_t)nmp->b_rptr, sizeof(parsetime_t));
685: nmp->b_wptr += sizeof(parsetime_t);
686: putnext(parse->parse_queue, nmp);
687: }
688: else
689: if (nmp) freemsg(nmp);
690: parse_iodone(&parse->parse_io);
691: }
692: }
693: }
694: else
695: {
696: if (parse_ioread(&parse->parse_io, (unsigned int)0, &c_time))
697: {
698: /*
699: * up up and away (hopefully ...)
700: * don't press it if resources are tight or nobody wants it
701: */
702: nmp = (mblk_t *)NULL;
703: if (canputnext(parse->parse_queue) && (nmp = allocb(sizeof(parsetime_t), BPRI_MED)))
704: {
705: bcopy((caddr_t)&parse->parse_io.parse_dtime, (caddr_t)nmp->b_rptr, sizeof(parsetime_t));
706: nmp->b_wptr += sizeof(parsetime_t);
707: putnext(parse->parse_queue, nmp);
708: }
709: else
710: if (nmp) freemsg(nmp);
711: parse_iodone(&parse->parse_io);
712: }
713: freemsg(mp);
714: }
715: break;
716: }
717: }
718:
719: /*
720: * CD PPS support for non direct ISR hack
721: */
722: case M_HANGUP:
723: case M_UNHANGUP:
724: {
725: register parsestream_t * parse = (parsestream_t *)q->q_ptr;
726: timestamp_t c_time;
727: timespec_t hres_time;
728: register mblk_t *nmp;
729: register int status = cd_invert ^ (type == M_UNHANGUP);
730:
731: gethrestime(&hres_time);
732: c_time.tv.tv_sec = hres_time.tv_sec;
733: c_time.tv.tv_usec = hres_time.tv_nsec / 1000;
734:
735: pprintf(DD_RPUT, "parse: parserput - M_%sHANGUP\n", (type == M_HANGUP) ? "" : "UN");
736:
737: if ((parse->parse_status & PARSE_ENABLE) &&
738: parse_iopps(&parse->parse_io, status ? SYNC_ONE : SYNC_ZERO, &c_time))
739: {
740: nmp = (mblk_t *)NULL;
741: if (canputnext(parse->parse_queue) && (nmp = allocb(sizeof(parsetime_t), BPRI_MED)))
742: {
743: bcopy((caddr_t)&parse->parse_io.parse_dtime, (caddr_t)nmp->b_rptr, sizeof(parsetime_t));
744: nmp->b_wptr += sizeof(parsetime_t);
745: putnext(parse->parse_queue, nmp);
746: }
747: else
748: if (nmp) freemsg(nmp);
749: parse_iodone(&parse->parse_io);
750: freemsg(mp);
751: }
752: else
753: if (canputnext(q) || (mp->b_datap->db_type > QPCTL))
754: {
755: putnext(q, mp);
756: }
757: else
758: putq(q, mp);
759:
760: if (status)
761: {
762: parse->parse_ppsclockev.tv = c_time.tv;
763: ++(parse->parse_ppsclockev.serial);
764: }
765: }
766: }
767: return 0;
768: }
769:
770: static int init_zs_linemon (queue_t *, queue_t *); /* handle line monitor for "zs" driver */
771: static void close_zs_linemon (queue_t *, queue_t *);
772:
773: /*-------------------- CD isr status monitor ---------------*/
774:
775: static int
776: init_linemon(
777: queue_t *q
778: )
779: {
780: register queue_t *dq;
781:
782: dq = WR(q);
783: /*
784: * we ARE doing very bad things down here (basically stealing ISR
785: * hooks)
786: *
787: * so we chase down the STREAMS stack searching for the driver
788: * and if this is a known driver we insert our ISR routine for
789: * status changes in to the ExternalStatus handling hook
790: */
791: while (dq->q_next)
792: {
793: dq = dq->q_next; /* skip down to driver */
794: }
795:
796: /*
797: * find appropriate driver dependent routine
798: */
799: if (dq->q_qinfo && dq->q_qinfo->qi_minfo)
800: {
801: register char *dname = dq->q_qinfo->qi_minfo->mi_idname;
802:
803: pprintf(DD_INSTALL, "init_linemon: driver is \"%s\"\n", dname);
804:
805: #ifdef sun
806: if (dname && !strcmp(dname, "zs"))
807: {
808: return init_zs_linemon(dq, q);
809: }
810: else
811: #endif
812: {
813: pprintf(DD_INSTALL, "init_linemon: driver \"%s\" not suitable for CD monitoring\n", dname);
814: return 0;
815: }
816: }
817: pprintf(DD_INSTALL, "init_linemon: cannot find driver\n");
818: return 0;
819: }
820:
821: static void
822: close_linemon(
823: queue_t *q,
824: queue_t *my_q
825: )
826: {
827: /*
828: * find appropriate driver dependent routine
829: */
830: if (q->q_qinfo && q->q_qinfo->qi_minfo)
831: {
832: register char *dname = q->q_qinfo->qi_minfo->mi_idname;
833:
834: #ifdef sun
835: if (dname && !strcmp(dname, "zs"))
836: {
837: close_zs_linemon(q, my_q);
838: return;
839: }
840: pprintf(DD_INSTALL, "close_linemon: cannot find driver close routine for \"%s\"\n", dname);
841: #endif
842: }
843: pprintf(DD_INSTALL, "close_linemon: cannot find driver name\n");
844: }
845:
846: #ifdef sun
847: #include <sys/tty.h>
848: #include <sys/zsdev.h>
849: #include <sys/ser_async.h>
850: #include <sys/ser_zscc.h>
851:
852: static void zs_xsisr (struct zscom *); /* zs external status interupt handler */
853:
854: /*
855: * there should be some docs telling how to get to
856: * sz:zs_usec_delay and zs:initzsops()
857: */
858: #define zs_usec_delay 5
859:
860: struct savedzsops
861: {
862: struct zsops zsops;
863: struct zsops *oldzsops;
864: };
865:
866: static struct zsops *emergencyzs;
867:
868: static int
869: init_zs_linemon(
870: queue_t *q,
871: queue_t *my_q
872: )
873: {
874: register struct zscom *zs;
875: register struct savedzsops *szs;
876: register parsestream_t *parsestream = (parsestream_t *)my_q->q_ptr;
877: /*
878: * we expect the zsaline pointer in the q_data pointer
879: * from there on we insert our on EXTERNAL/STATUS ISR routine
880: * into the interrupt path, before the standard handler
881: */
882: zs = ((struct asyncline *)q->q_ptr)->za_common;
883: if (!zs)
884: {
885: /*
886: * well - not found on startup - just say no (shouldn't happen though)
887: */
888: return 0;
889: }
890: else
891: {
892: /*
893: * we do a direct replacement, in case others fiddle also
894: * if somebody else grabs our hook and we disconnect
895: * we are in DEEP trouble - panic is likely to be next, sorry
896: */
897: szs = (struct savedzsops *) kmem_alloc(sizeof(struct savedzsops), KM_SLEEP);
898:
899: if (szs == (struct savedzsops *)0)
900: {
901: pprintf(DD_INSTALL, "init_zs_linemon: CD monitor NOT installed - no memory\n");
902:
903: return 0;
904: }
905: else
906: {
907: parsestream->parse_data = (void *)szs;
908:
909: mutex_enter(zs->zs_excl);
910:
911: parsestream->parse_dqueue = q; /* remember driver */
912:
913: szs->zsops = *zs->zs_ops;
914: szs->zsops.zsop_xsint = (void (*) (struct zscom *))zs_xsisr; /* place our bastard */
915: szs->oldzsops = zs->zs_ops;
916: emergencyzs = zs->zs_ops;
917:
918: zs->zs_ops = &szs->zsops; /* hook it up */
919: /*
920: * XXX: this is usually done via zsopinit()
921: * - have yet to find a way to call that routine
922: */
923: zs->zs_xsint = (void (*) (struct zscom *))zs_xsisr;
924:
925: mutex_exit(zs->zs_excl);
926:
927: pprintf(DD_INSTALL, "init_zs_linemon: CD monitor installed\n");
928:
929: return 1;
930: }
931: }
932: }
933:
934: /*
935: * unregister our ISR routine - must call under splhigh() (or
936: * whatever block ZS status interrupts)
937: */
938: static void
939: close_zs_linemon(
940: queue_t *q,
941: queue_t *my_q
942: )
943: {
944: register struct zscom *zs;
945: register parsestream_t *parsestream = (parsestream_t *)my_q->q_ptr;
946:
947: zs = ((struct asyncline *)q->q_ptr)->za_common;
948: if (!zs)
949: {
950: /*
951: * well - not found on startup - just say no (shouldn't happen though)
952: */
953: return;
954: }
955: else
956: {
957: register struct savedzsops *szs = (struct savedzsops *)parsestream->parse_data;
958:
959: mutex_enter(zs->zs_excl);
960:
961: zs->zs_ops = szs->oldzsops; /* reset to previous handler functions */
962: /*
963: * XXX: revert xsint (usually done via zsopinit() - have still to find
964: * a way to call that bugger
965: */
966: zs->zs_xsint = zs->zs_ops->zsop_xsint;
967:
968: mutex_exit(zs->zs_excl);
969:
970: kmem_free((caddr_t)szs, sizeof (struct savedzsops));
971:
972: pprintf(DD_INSTALL, "close_zs_linemon: CD monitor deleted\n");
973: return;
974: }
975: }
976:
977: #define ZSRR0_IGNORE (ZSRR0_CD|ZSRR0_SYNC|ZSRR0_CTS)
978:
979: #define MAXDEPTH 50 /* maximum allowed stream crawl */
980:
981: /*
982: * take external status interrupt (only CD interests us)
983: */
984: static void
985: zs_xsisr(
986: struct zscom *zs
987: )
988: {
989: register struct asyncline *za = (struct asyncline *)zs->zs_priv;
990: register queue_t *q;
991: register unsigned char zsstatus;
992: register int loopcheck;
993: register unsigned char cdstate;
994: register const char *dname = "-UNKNOWN-";
995: timespec_t hres_time;
996:
997: /*
998: * pick up current state
999: */
1000: zsstatus = SCC_READ0();
1001:
1002: if (za->za_rr0 ^ (cdstate = zsstatus & ZSRR0_CD))
1003: {
1004: timestamp_t cdevent;
1005: register int status;
1006:
1007: /*
1008: * time stamp
1009: */
1010: gethrestime(&hres_time);
1011: cdevent.tv.tv_sec = hres_time.tv_sec;
1012: cdevent.tv.tv_usec = hres_time.tv_nsec / 1000;
1013:
1014: q = za->za_ttycommon.t_readq;
1015:
1016: /*
1017: * logical state
1018: */
1019: status = cd_invert ? cdstate == 0 : cdstate != 0;
1020:
1021: /*
1022: * ok - now the hard part - find ourself
1023: */
1024: loopcheck = MAXDEPTH;
1025:
1026: while (q)
1027: {
1028: if (q->q_qinfo && q->q_qinfo->qi_minfo)
1029: {
1030: dname = q->q_qinfo->qi_minfo->mi_idname;
1031:
1032: if (!strcmp(dname, parseinfo.st_rdinit->qi_minfo->mi_idname))
1033: {
1034: /*
1035: * back home - phew (hopping along stream queues might
1036: * prove dangerous to your health)
1037: */
1038:
1039: if ((((parsestream_t *)q->q_ptr)->parse_status & PARSE_ENABLE) &&
1040: parse_iopps(&((parsestream_t *)q->q_ptr)->parse_io, status ? SYNC_ONE : SYNC_ZERO, &cdevent))
1041: {
1042: /*
1043: * XXX - currently we do not pass up the message, as
1044: * we should.
1045: * for a correct behaviour wee need to block out
1046: * processing until parse_iodone has been posted via
1047: * a softcall-ed routine which does the message pass-up
1048: * right now PPS information relies on input being
1049: * received
1050: */
1051: parse_iodone(&((parsestream_t *)q->q_ptr)->parse_io);
1052: }
1053:
1054: if (status)
1055: {
1056: ((parsestream_t *)q->q_ptr)->parse_ppsclockev.tv = cdevent.tv;
1057: ++(((parsestream_t *)q->q_ptr)->parse_ppsclockev.serial);
1058: }
1059:
1060: pprintf(DD_ISR, "zs_xsisr: CD event %s has been posted for \"%s\"\n", status ? "ONE" : "ZERO", dname);
1061: break;
1062: }
1063: }
1064:
1065: q = q->q_next;
1066:
1067: if (!loopcheck--)
1068: {
1069: panic("zs_xsisr: STREAMS Queue corrupted - CD event");
1070: }
1071: }
1072:
1073: if (cdstate) /* fake CARRIER status - XXX currently not coordinated */
1074: za->za_flags |= ZAS_CARR_ON;
1075: else
1076: za->za_flags &= ~ZAS_CARR_ON;
1077:
1078: /*
1079: * only pretend that CD and ignored transistion (SYNC,CTS)
1080: * have been handled
1081: */
1082: za->za_rr0 = (za->za_rr0 & ~ZSRR0_IGNORE) | (zsstatus & ZSRR0_IGNORE);
1083:
1084: if (((za->za_rr0 ^ zsstatus) & ~ZSRR0_IGNORE) == 0)
1085: {
1086: /*
1087: * all done - kill status indication and return
1088: */
1089: SCC_WRITE0(ZSWR0_RESET_STATUS); /* might kill other conditions here */
1090: return;
1091: }
1092: }
1093:
1094: pprintf(DD_ISR, "zs_xsisr: non CD event 0x%x for \"%s\"\n",
1095: (za->za_rr0 ^ zsstatus) & ~ZSRR0_CD,dname);
1096: /*
1097: * we are now gathered here to process some unusual external status
1098: * interrupts.
1099: * any CD events have also been handled and shouldn't be processed
1100: * by the original routine (unless we have a VERY busy port pin)
1101: * some initializations are done here, which could have been done before for
1102: * both code paths but have been avioded for minimum path length to
1103: * the uniq_time routine
1104: */
1105: dname = (char *) 0;
1106: q = za->za_ttycommon.t_readq;
1107:
1108: loopcheck = MAXDEPTH;
1109:
1110: /*
1111: * the real thing for everything else ...
1112: */
1113: while (q)
1114: {
1115: if (q->q_qinfo && q->q_qinfo->qi_minfo)
1116: {
1117: dname = q->q_qinfo->qi_minfo->mi_idname;
1118: if (!strcmp(dname, parseinfo.st_rdinit->qi_minfo->mi_idname))
1119: {
1120: register void (*zsisr) (struct zscom *);
1121:
1122: /*
1123: * back home - phew (hopping along stream queues might
1124: * prove dangerous to your health)
1125: */
1126: if ((zsisr = ((struct savedzsops *)((parsestream_t *)q->q_ptr)->parse_data)->oldzsops->zsop_xsint))
1127: zsisr(zs);
1128: else
1129: panic("zs_xsisr: unable to locate original ISR");
1130:
1131: pprintf(DD_ISR, "zs_xsisr: non CD event was processed for \"%s\"\n", dname);
1132: /*
1133: * now back to our program ...
1134: */
1135: return;
1136: }
1137: }
1138:
1139: q = q->q_next;
1140:
1141: if (!loopcheck--)
1142: {
1143: panic("zs_xsisr: STREAMS Queue corrupted - non CD event");
1144: }
1145: }
1146:
1147: /*
1148: * last resort - shouldn't even come here as it indicates
1149: * corrupted TTY structures
1150: */
1151: printf("zs_zsisr: looking for \"%s\" - found \"%s\" - taking EMERGENCY path\n", parseinfo.st_rdinit->qi_minfo->mi_idname, dname ? dname : "-NIL-");
1152:
1153: if (emergencyzs && emergencyzs->zsop_xsint)
1154: emergencyzs->zsop_xsint(zs);
1155: else
1156: panic("zs_xsisr: no emergency ISR handler");
1157: }
1158: #endif /* sun */
1159:
1160: /*
1161: * History:
1162: *
1163: * parsesolaris.c,v
1164: * Revision 4.11 2005/04/16 17:32:10 kardel
1165: * update copyright
1166: *
1167: * Revision 4.10 2004/11/14 16:06:08 kardel
1168: * update Id tags
1169: *
1170: * Revision 4.9 2004/11/14 15:29:41 kardel
1171: * support PPSAPI, upgrade Copyright to Berkeley style
1172: *
1173: * Revision 4.6 1998/11/15 21:56:08 kardel
1174: * ntp_memset not necessary
1175: *
1176: * Revision 4.5 1998/11/15 21:23:37 kardel
1177: * ntp_memset() replicated in Sun kernel files
1178: *
1179: * Revision 4.4 1998/06/14 21:09:40 kardel
1180: * Sun acc cleanup
1181: *
1182: * Revision 4.3 1998/06/13 12:14:59 kardel
1183: * more prototypes
1184: * fix name clashes
1185: * allow for ansi2knr
1186: *
1187: * Revision 4.2 1998/06/12 15:23:08 kardel
1188: * fix prototypes
1189: * adjust for ansi2knr
1190: *
1191: * Revision 4.1 1998/05/24 09:38:46 kardel
1192: * streams initiated iopps calls (M_xHANGUP) are now consistent with the
1193: * respective calls from zs_xsisr()
1194: * simulation of CARRIER status to avoid unecessary M_xHANGUP messages
1195: *
1196: * Revision 4.0 1998/04/10 19:45:38 kardel
1197: * Start 4.0 release version numbering
1198: *
1199: * from V3 3.28 log info deleted 1998/04/11 kardel
1200: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parsesolaris.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libparse