Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/dist/ntp/kernel/tty_chu_STREAMS.c

606 lines
13 KiB
C
Raw Blame History

/* $NetBSD: tty_chu_STREAMS.c,v 1.2 2003/12/04 16:23:36 drochner Exp $ */
/*
* CHU STREAMS module for SunOS
*
* Version 2.6
*
* Copyright 1991-1994, Nick Sayer
*
* Special thanks to Greg Onufer for his debug assists.
* Special thanks to Matthias Urlichs for the 4.1.x loadable driver support
* code.
* Special wet-noodle whippings to Sun for not properly documenting
* ANYTHING that makes this stuff at all possible.
*
* Should be PUSHed directly on top of a serial I/O channel.
* Provides complete chucode structures to user space.
*
* COMPILATION:
*
*
* To make a SunOS 4.1.x compatable loadable module (from the ntp kernel
* directory):
*
* % cc -c -I../include -DLOADABLE tty_chu_STREAMS.c
*
* The resulting .o file is the loadable module. Modload it
* thusly:
*
* % modload tty_chu_STREAMS.o -entry _chuinit
*
* When none of the instances are pushed in a STREAM, you can
* modunload the driver in the usual manner if you wish.
*
* As an alternative to loading it dynamically you can compile it
* directly into the kernel by hacking str_conf.c. See the README
* file for more details on doing it the old fashioned way.
*
*
* To make a Solaris 2.x compatable module (from the ntp kernel
* directory):
*
* % {gcc,cc} -c -I../include -DSOLARIS2 tty_chu_STREAMS.c
* % ld -r -o /usr/kernel/strmod/chu tty_chu_STREAMS.o
* % chmod 755 /usr/kernel/strmod/chu
*
* The OS will load it for you automagically when it is first pushed.
*
* If you get syntax errors from <sys/timer.h> (really references
* to types that weren't typedef'd in gcc's version of types.h),
* add -D_SYS_TIMER_H to blot out the miscreants.
*
* Under Solaris 2.2 and previous, do not attempt to modunload the
* module unless you're SURE it's not in use. I haven't tried it, but
* I've been told it won't do the right thing. Under Solaris 2.3 (and
* presumably future revs) an attempt to unload the module when it's in
* use will properly refuse with a "busy" message.
*
*
* HISTORY:
*
* v2.6 - Mutexed the per-instance chucode just to be safe.
* v2.5 - Fixed show-stopper bug in Solaris 2.x - qprocson().
* v2.4 - Added dynamic allocation support for Solaris 2.x.
* v2.3 - Added support for Solaris 2.x.
* v2.2 - Added SERVICE IMMEDIATE hack.
* v2.1 - Added 'sixth byte' heuristics.
* v2.0 - first version with an actual version number.
* Added support for new CHU 'second 31' data format.
* Deleted PEDANTIC and ANAL_RETENTIVE.
*
*/
#ifdef SOLARIS2
# ifndef NCHU
# define NCHU 1
# endif
# define _KERNEL
#elif defined(LOADABLE)
# ifndef NCHU
# define NCHU 3
# define KERNEL
# endif
#else
# include "chu.h"
#endif
#if NCHU > 0
/*
* Number of microseconds we allow between
* character arrivals. The speed is 300 baud
* so this should be somewhat more than 30 msec
*/
#define CHUMAXUSEC (60*1000) /* 60 msec */
#include <sys/types.h>
#include <sys/stream.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/errno.h>
#include <sys/user.h>
#include <syslog.h>
#include <sys/tty.h>
#include <sys/chudefs.h>
#ifdef SOLARIS2
#include <sys/ksynch.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/strtty.h>
#include <sys/modctl.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#endif
#ifdef LOADABLE
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/buf.h>
#include <sundev/mbvar.h>
#include <sun/autoconf.h>
#include <sun/vddrv.h>
#endif
static struct module_info rminfo = { 0, "chu", 0, INFPSZ, 0, 0 };
static struct module_info wminfo = { 0, "chu", 0, INFPSZ, 0, 0 };
static int chuopen(), churput(), chuwput(), chuclose();
static struct qinit rinit = { churput, NULL, chuopen, chuclose, NULL,
&rminfo, NULL };
static struct qinit winit = { chuwput, NULL, NULL, NULL, NULL,
&wminfo, NULL };
struct streamtab chuinfo = { &rinit, &winit, NULL, NULL };
/*
* Here's our private data type and structs
*/
struct priv_data
{
#ifdef SOLARIS2
kmutex_t chucode_mutex;
#else
char in_use;
#endif
struct chucode chu_struct;
};
#ifndef SOLARIS2
struct priv_data our_priv_data[NCHU];
#endif
#ifdef SOLARIS2
static struct fmodsw fsw =
{
"chu",
&chuinfo,
D_NEW | D_MP
};
extern struct mod_ops mod_strmodops;
static struct modlstrmod modlstrmod =
{
&mod_strmodops,
"CHU timecode decoder v2.6",
&fsw
};
static struct modlinkage modlinkage =
{
MODREV_1,
(void*) &modlstrmod,
NULL
};
int _init()
{
return mod_install(&modlinkage);
}
int _info(foo)
struct modinfo *foo;
{
return mod_info(&modlinkage,foo);
}
int _fini()
{
return mod_remove(&modlinkage);
}
#endif /* SOLARIS2 */
#ifdef LOADABLE
# ifdef sun
static struct vdldrv vd =
{
VDMAGIC_PSEUDO,
"chu",
NULL, NULL, NULL, 0, 0, NULL, NULL, 0, 0,
};
static struct fmodsw *chu_fmod;
/*ARGSUSED*/
chuinit (fc, vdp, vdi, vds)
unsigned int fc;
struct vddrv *vdp;
addr_t vdi;
struct vdstat *vds;
{
switch (fc) {
case VDLOAD:
{
int dev, i;
/* Find free entry in fmodsw */
for (dev = 0; dev < fmodcnt; dev++) {
if (fmodsw[dev].f_str == NULL)
break;
}
if (dev == fmodcnt)
return (ENODEV);
chu_fmod = &fmodsw[dev];
/* If you think a kernel would have strcpy() you're mistaken. */
for (i = 0; i <= FMNAMESZ; i++)
chu_fmod->f_name[i] = wminfo.mi_idname[i];
chu_fmod->f_str = &chuinfo;
}
vdp->vdd_vdtab = (struct vdlinkage *) & vd;
{
int i;
for (i=0; i<NCHU; i++)
our_priv_data[i].in_use=0;
}
return 0;
case VDUNLOAD:
{
int dev;
for (dev = 0; dev < NCHU; dev++)
if (our_priv_data[dev].in_use) {
/* One of the modules is still open */
return (EBUSY);
}
}
chu_fmod->f_name[0] = '\0';
chu_fmod->f_str = NULL;
return 0;
case VDSTAT:
return 0;
default:
return EIO;
}
}
# endif /* sun */
#endif /* LOADABLE */
#if !defined(LOADABLE) && !defined(SOLARIS2)
char chu_first_open=1;
#endif
/*ARGSUSED*/
static int chuopen(q, dev, flag, sflag)
queue_t *q;
dev_t dev;
int flag;
int sflag;
{
int i;
#if !defined(LOADABLE) && !defined(SOLARIS2)
if (chu_first_open)
{
chu_first_open=0;
for(i=0;i<NCHU;i++)
our_priv_data[i].in_use=0;
}
#endif
#ifdef SOLARIS2
/* According to the docs, calling with KM_SLEEP can never
fail */
q->q_ptr = kmem_alloc( sizeof(struct priv_data), KM_SLEEP );
((struct priv_data *) q->q_ptr)->chu_struct.ncodechars = 0;
mutex_init(&((struct priv_data *) q->q_ptr)->chucode_mutex,"Chucode Mutex",MUTEX_DRIVER,NULL);
qprocson(q);
if (!putnextctl1(WR(q), M_CTL, MC_SERVICEIMM))
{
qprocsoff(q);
mutex_destroy(&((struct priv_data *)q->q_ptr)->chucode_mutex);
kmem_free(q->q_ptr, sizeof(struct chucode) );
return (EFAULT);
}
return 0;
#else
for(i=0;i<NCHU;i++)
if (!our_priv_data[i].in_use)
{
((struct priv_data *) (q->q_ptr))=&(our_priv_data[i]);
our_priv_data[i].in_use++;
our_priv_data[i].chu_struct.ncodechars = 0;
if (!putctl1(WR(q)->q_next, M_CTL, MC_SERVICEIMM))
{
our_priv_data[i].in_use=0;
u.u_error = EFAULT;
return (OPENFAIL);
}
return 0;
}
u.u_error = EBUSY;
return (OPENFAIL);
#endif
}
/*ARGSUSED*/
static int chuclose(q, flag)
queue_t *q;
int flag;
{
#ifdef SOLARIS2
qprocsoff(q);
mutex_destroy(&((struct priv_data *)q->q_ptr)->chucode_mutex);
kmem_free(q->q_ptr, sizeof(struct chucode) );
#else
((struct priv_data *) (q->q_ptr))->in_use=0;
#endif
return (0);
}
/*
* Now the crux of the biscuit.
*
* We will be passed data from the man downstairs. If it's not a data
* packet, it must be important, so pass it along unmunged. If, however,
* it is a data packet, we're gonna do special stuff to it. We're going
* to pass each character we get to the old line discipline code we
* include below for just such an occasion. When the old ldisc code
* gets a full chucode struct, we'll hand it back upstairs.
*
* chuinput takes a single character and q (as quickly as possible).
* passback takes a pointer to a chucode struct and q and sends it upstream.
*/
void chuinput();
void passback();
static int churput(q, mp)
queue_t *q;
mblk_t *mp;
{
mblk_t *bp;
switch(mp->b_datap->db_type)
{
case M_DATA:
for(bp=mp; bp!=NULL; bp=bp->b_cont)
{
while(bp->b_rptr < bp->b_wptr)
chuinput( ((u_char)*(bp->b_rptr++)) , q );
}
freemsg(mp);
break;
default:
putnext(q,mp);
break;
}
}
/*
* Writing to a chu device doesn't make sense, but we'll pass them
* through in case they're important.
*/
static int chuwput(q, mp)
queue_t *q;
mblk_t *mp;
{
putnext(q,mp);
}
/*
* Take a pointer to a filled chucode struct and a queue and
* send the chucode stuff upstream
*/
void passback(outdata,q)
struct chucode *outdata;
queue_t *q;
{
mblk_t *mp;
int j;
mp=(mblk_t*) allocb(sizeof(struct chucode),BPRI_LO);
if (mp==NULL)
{
#ifdef SOLARIS2
cmn_err(CE_WARN,"chu module couldn't allocate message block");
#else
log(LOG_ERR,"chu: cannot allocate message");
#endif
return;
}
for(j=0;j<sizeof(struct chucode); j++)
*mp->b_wptr++ = *( ((char*)outdata) + j );
putnext(q,mp);
}
/*
* This routine was copied nearly verbatim from the old line discipline.
*/
void chuinput(c,q)
register u_char c;
queue_t *q;
{
register struct chucode *chuc;
register int i;
long sec, usec;
struct timeval tv;
/*
* Quick, Batman, get a timestamp! We need to do this
* right away. The time between the end of the stop bit
* and this point is critical, and should be as nearly
* constant and as short as possible. (Un)fortunately,
* the Sun's clock granularity is so big this isn't a
* major problem.
*
* uniqtime() is totally undocumented, but there you are.
*/
uniqtime(&tv);
#ifdef SOLARIS2
mutex_enter(&((struct priv_data *)q->q_ptr)->chucode_mutex);
#endif
/*
* Now, locate the chu struct once so we don't have to do it
* over and over.
*/
chuc=&(((struct priv_data *) (q->q_ptr))->chu_struct);
/*
* Compute the difference in this character's time stamp
* and the last. If it exceeds the margin, blow away all
* the characters currently in the buffer.
*/
i = (int)chuc->ncodechars;
if (i > 0)
{
sec = tv.tv_sec - chuc->codetimes[i-1].tv_sec;
usec = tv.tv_usec - chuc->codetimes[i-1].tv_usec;
if (usec < 0)
{
sec -= 1;
usec += 1000000;
}
if (sec != 0 || usec > CHUMAXUSEC)
{
i = 0;
chuc->ncodechars = 0;
}
}
/*
* Store the character.
*/
chuc->codechars[i] = (u_char)c;
chuc->codetimes[i] = tv;
/*
* Now we perform the 'sixth byte' heuristics.
*
* This is a long story.
*
* We used to be able to count on the first byte of the code
* having a '6' in the LSD. This prevented most code framing
* errors (garbage before the first byte wouldn't typically
* have a 6 in the LSD). That's no longer the case.
*
* We can get around this, however, by noting that the 6th byte
* must be either equal to or one's complement of the first.
* If we get a sixth byte that ISN'T like that, then it may
* well be that the first byte is garbage. The right thing
* to do is to left-shift the whole buffer one count and
* continue to wait for the sixth byte.
*/
if (i == NCHUCHARS/2)
{
register u_char temp_byte;
temp_byte=chuc->codechars[i] ^ chuc->codechars[0];
if ( (temp_byte) && (temp_byte!=0xff) )
{
register int t;
/*
* No match. Left-shift the buffer and try again
*/
for(t=0;t<=NCHUCHARS/2;t++)
{
chuc->codechars[t]=chuc->codechars[t+1];
chuc->codetimes[t]=chuc->codetimes[t+1];
}
i--; /* This is because of the ++i immediately following */
}
}
/*
* We done yet?
*/
if (++i < NCHUCHARS)
{
/*
* We're not done. Not much to do here. Save the count and wait
* for another character.
*/
chuc->ncodechars = (u_char)i;
}
else
{
/*
* We are done. Mark this buffer full and pass it along.
*/
chuc->ncodechars = NCHUCHARS;
/*
* Now we have a choice. Either the front half and back half
* have to match, or be one's complement of each other.
*
* So let's try the first byte and see
*/
if(chuc->codechars[0] == chuc->codechars[NCHUCHARS/2])
{
chuc->chutype = CHU_TIME;
for( i=0; i<(NCHUCHARS/2); i++)
if (chuc->codechars[i] != chuc->codechars[i+(NCHUCHARS/2)])
{
chuc->ncodechars = 0;
#ifdef SOLARIS2
mutex_exit(&((struct priv_data *)q->q_ptr)->chucode_mutex);
#endif
return;
}
}
else
{
chuc->chutype = CHU_YEAR;
for( i=0; i<(NCHUCHARS/2); i++)
if (((chuc->codechars[i] ^ chuc->codechars[i+(NCHUCHARS/2)]) & 0xff)
!= 0xff )
{
chuc->ncodechars = 0;
#ifdef SOLARIS2
mutex_exit(&((struct priv_data *)q->q_ptr)->chucode_mutex);
#endif
return;
}
}
passback(chuc,q); /* We're done! */
chuc->ncodechars = 0; /* Start all over again! */
}
#ifdef SOLARIS2
mutex_exit(&((struct priv_data *)q->q_ptr)->chucode_mutex);
#endif
}
#endif /* NCHU > 0 */
Reference in New Issue View Git Blame Copy Permalink