xref: /freebsd/contrib/ntp/ntpd/refclock_as2201.c (revision 641a6cfb86023499caafe26a4d821a0b885cf00b)
1 /*
2  * refclock_as2201 - clock driver for the Austron 2201A GPS
3  *	Timing Receiver
4  */
5 #ifdef HAVE_CONFIG_H
6 #include <config.h>
7 #endif
8 
9 #if defined(REFCLOCK) && defined(CLOCK_AS2201)
10 
11 #include "ntpd.h"
12 #include "ntp_io.h"
13 #include "ntp_refclock.h"
14 #include "ntp_unixtime.h"
15 #include "ntp_stdlib.h"
16 
17 #include <stdio.h>
18 #include <ctype.h>
19 
20 /*
21  * This driver supports the Austron 2200A/2201A GPS Receiver with
22  * Buffered RS-232-C Interface Module. Note that the original 2200/2201
23  * receivers will not work reliably with this driver, since the older
24  * design cannot accept input commands at any reasonable data rate.
25  *
26  * The program sends a "*toc\r" to the radio and expects a response of
27  * the form "yy:ddd:hh:mm:ss.mmm\r" where yy = year of century, ddd =
28  * day of year, hh:mm:ss = second of day and mmm = millisecond of
29  * second. Then, it sends statistics commands to the radio and expects
30  * a multi-line reply showing the corresponding statistics or other
31  * selected data. Statistics commands are sent in order as determined by
32  * a vector of commands; these might have to be changed with different
33  * radio options. If flag4 of the fudge configuration command is set to
34  * 1, the statistics data are written to the clockstats file for later
35  * processing.
36  *
37  * In order for this code to work, the radio must be placed in non-
38  * interactive mode using the "off" command and with a single <cr>
39  * response using the "term cr" command. The setting of the "echo"
40  * and "df" commands does not matter. The radio should select UTC
41  * timescale using the "ts utc" command.
42  *
43  * There are two modes of operation for this driver. The first with
44  * default configuration is used with stock kernels and serial-line
45  * drivers and works with almost any machine. In this mode the driver
46  * assumes the radio captures a timestamp upon receipt of the "*" that
47  * begins the driver query. Accuracies in this mode are in the order of
48  * a millisecond or two and the receiver can be connected to only one
49  * host.
50  *
51  * The second mode of operation can be used for SunOS kernels that have
52  * been modified with the ppsclock streams module included in this
53  * distribution. The mode is enabled if flag3 of the fudge configuration
54  * command has been set to 1. In this mode a precise timestamp is
55  * available using a gadget box and 1-pps signal from the receiver. This
56  * improves the accuracy to the order of a few tens of microseconds. In
57  * addition, the serial output and 1-pps signal can be bussed to more
58  * than one hosts, but only one of them should be connected to the
59  * radio input data line.
60  */
61 
62 /*
63  * GPS Definitions
64  */
65 #define SMAX		200	/* statistics buffer length */
66 #define	DEVICE		"/dev/gps%d" /* device name and unit */
67 #define	SPEED232	B9600	/* uart speed (9600 baud) */
68 #define	PRECISION	(-20)	/* precision assumed (about 1 us) */
69 #define	REFID		"GPS\0"	/* reference ID */
70 #define	DESCRIPTION	"Austron 2201A GPS Receiver" /* WRU */
71 
72 #define	LENTOC		19	/* yy:ddd:hh:mm:ss.mmm timecode lngth */
73 
74 /*
75  * AS2201 unit control structure.
76  */
77 struct as2201unit {
78 	char	*lastptr;	/* statistics buffer pointer */
79 	char	stats[SMAX];	/* statistics buffer */
80 	int	linect;		/* count of lines remaining */
81 	int	index;		/* current statistics command */
82 };
83 
84 /*
85  * Radio commands to extract statitistics
86  *
87  * A command consists of an ASCII string terminated by a <cr> (\r). The
88  * command list consist of a sequence of commands terminated by a null
89  * string ("\0"). One command from the list is sent immediately
90  * following each received timecode (*toc\r command) and the ASCII
91  * strings received from the radio are saved along with the timecode in
92  * the clockstats file. Subsequent commands are sent at each timecode,
93  * with the last one in the list followed by the first one. The data
94  * received from the radio consist of ASCII strings, each terminated by
95  * a <cr> (\r) character. The number of strings for each command is
96  * specified as the first line of output as an ASCII-encode number. Note
97  * that the ETF command requires the Input Buffer Module and the LORAN
98  * commands require the LORAN Assist Module. However, if these modules
99  * are not installed, the radio and this driver will continue to operate
100  * successfuly, but no data will be captured for these commands.
101  */
102 static char stat_command[][30] = {
103 	"ITF\r",		/* internal time/frequency */
104 	"ETF\r",		/* external time/frequency */
105 	"LORAN ENSEMBLE\r",	/* GPS/LORAN ensemble statistics */
106 	"LORAN TDATA\r",	/* LORAN signal data */
107 	"ID;OPT;VER\r",		/* model; options; software version */
108 
109 	"ITF\r",		/* internal time/frequency */
110 	"ETF\r",		/* external time/frequency */
111 	"LORAN ENSEMBLE\r",	/* GPS/LORAN ensemble statistics */
112 	"TRSTAT\r",		/* satellite tracking status */
113 	"POS;PPS;PPSOFF\r",	/* position, pps source, offsets */
114 
115 	"ITF\r",		/* internal time/frequency */
116 	"ETF\r",		/* external time/frequency */
117 	"LORAN ENSEMBLE\r",	/* GPS/LORAN ensemble statistics */
118 	"LORAN TDATA\r",	/* LORAN signal data */
119 	"UTC\r",			/* UTC leap info */
120 
121 	"ITF\r",		/* internal time/frequency */
122 	"ETF\r",		/* external time/frequency */
123 	"LORAN ENSEMBLE\r",	/* GPS/LORAN ensemble statistics */
124 	"TRSTAT\r",		/* satellite tracking status */
125 	"OSC;ET;TEMP\r",	/* osc type; tune volts; oven temp */
126 	"\0"			/* end of table */
127 };
128 
129 /*
130  * Function prototypes
131  */
132 static	int	as2201_start	P((int, struct peer *));
133 static	void	as2201_shutdown	P((int, struct peer *));
134 static	void	as2201_receive	P((struct recvbuf *));
135 static	void	as2201_poll	P((int, struct peer *));
136 
137 /*
138  * Transfer vector
139  */
140 struct	refclock refclock_as2201 = {
141 	as2201_start,		/* start up driver */
142 	as2201_shutdown,	/* shut down driver */
143 	as2201_poll,		/* transmit poll message */
144 	noentry,		/* not used (old as2201_control) */
145 	noentry,		/* initialize driver (not used) */
146 	noentry,		/* not used (old as2201_buginfo) */
147 	NOFLAGS			/* not used */
148 };
149 
150 
151 /*
152  * as2201_start - open the devices and initialize data for processing
153  */
154 static int
155 as2201_start(
156 	int unit,
157 	struct peer *peer
158 	)
159 {
160 	register struct as2201unit *up;
161 	struct refclockproc *pp;
162 	int fd;
163 	char gpsdev[20];
164 
165 	/*
166 	 * Open serial port. Use CLK line discipline, if available.
167 	 */
168 	(void)sprintf(gpsdev, DEVICE, unit);
169 	if (!(fd = refclock_open(gpsdev, SPEED232, LDISC_CLK)))
170 		return (0);
171 
172 	/*
173 	 * Allocate and initialize unit structure
174 	 */
175 	if (!(up = (struct as2201unit *)
176 	      emalloc(sizeof(struct as2201unit)))) {
177 		(void) close(fd);
178 		return (0);
179 	}
180 	memset((char *)up, 0, sizeof(struct as2201unit));
181 	pp = peer->procptr;
182 	pp->io.clock_recv = as2201_receive;
183 	pp->io.srcclock = (caddr_t)peer;
184 	pp->io.datalen = 0;
185 	pp->io.fd = fd;
186 	if (!io_addclock(&pp->io)) {
187 		(void) close(fd);
188 		free(up);
189 		return (0);
190 	}
191 	pp->unitptr = (caddr_t)up;
192 
193 	/*
194 	 * Initialize miscellaneous variables
195 	 */
196 	peer->precision = PRECISION;
197 	peer->burst = NSTAGE;
198 	pp->clockdesc = DESCRIPTION;
199 	memcpy((char *)&pp->refid, REFID, 4);
200 	up->lastptr = up->stats;
201 	up->index = 0;
202 	return (1);
203 }
204 
205 
206 /*
207  * as2201_shutdown - shut down the clock
208  */
209 static void
210 as2201_shutdown(
211 	int unit,
212 	struct peer *peer
213 	)
214 {
215 	register struct as2201unit *up;
216 	struct refclockproc *pp;
217 
218 	pp = peer->procptr;
219 	up = (struct as2201unit *)pp->unitptr;
220 	io_closeclock(&pp->io);
221 	free(up);
222 }
223 
224 
225 /*
226  * as2201__receive - receive data from the serial interface
227  */
228 static void
229 as2201_receive(
230 	struct recvbuf *rbufp
231 	)
232 {
233 	register struct as2201unit *up;
234 	struct refclockproc *pp;
235 	struct peer *peer;
236 	l_fp trtmp;
237 
238 	/*
239 	 * Initialize pointers and read the timecode and timestamp.
240 	 */
241 	peer = (struct peer *)rbufp->recv_srcclock;
242 	pp = peer->procptr;
243 	up = (struct as2201unit *)pp->unitptr;
244 	pp->lencode = refclock_gtlin(rbufp, pp->a_lastcode, BMAX, &trtmp);
245 #ifdef DEBUG
246 	if (debug)
247 	    printf("gps: timecode %d %d %s\n",
248 		   up->linect, pp->lencode, pp->a_lastcode);
249 #endif
250 	if (pp->lencode == 0)
251 	    return;
252 
253 	/*
254 	 * If linect is greater than zero, we must be in the middle of a
255 	 * statistics operation, so simply tack the received data at the
256 	 * end of the statistics string. If not, we could either have
257 	 * just received the timecode itself or a decimal number
258 	 * indicating the number of following lines of the statistics
259 	 * reply. In the former case, write the accumulated statistics
260 	 * data to the clockstats file and continue onward to process
261 	 * the timecode; in the later case, save the number of lines and
262 	 * quietly return.
263 	 */
264 	if (pp->sloppyclockflag & CLK_FLAG2)
265 		pp->lastrec = trtmp;
266 	if (up->linect > 0) {
267 		up->linect--;
268 		if ((int)(up->lastptr - up->stats + pp->lencode) > SMAX - 2)
269 		    return;
270 		*up->lastptr++ = ' ';
271 		(void)strcpy(up->lastptr, pp->a_lastcode);
272 		up->lastptr += pp->lencode;
273 		return;
274 	} else {
275 		if (pp->lencode == 1) {
276 			up->linect = atoi(pp->a_lastcode);
277 			return;
278 		} else {
279 			record_clock_stats(&peer->srcadr, up->stats);
280 #ifdef DEBUG
281 			if (debug)
282 			    printf("gps: stat %s\n", up->stats);
283 #endif
284 		}
285 	}
286 	up->lastptr = up->stats;
287 	*up->lastptr = '\0';
288 
289 	/*
290 	 * We get down to business, check the timecode format and decode
291 	 * its contents. If the timecode has invalid length or is not in
292 	 * proper format, we declare bad format and exit.
293 	 */
294 	if (pp->lencode < LENTOC) {
295 		refclock_report(peer, CEVNT_BADREPLY);
296 		return;
297 	}
298 
299 	/*
300 	 * Timecode format: "yy:ddd:hh:mm:ss.mmm"
301 	 */
302 	if (sscanf(pp->a_lastcode, "%2d:%3d:%2d:%2d:%2d.%3ld", &pp->year,
303 		   &pp->day, &pp->hour, &pp->minute, &pp->second, &pp->nsec)
304 	    != 6) {
305 		refclock_report(peer, CEVNT_BADREPLY);
306 		return;
307 	}
308 	pp->nsec *= 1000000;
309 
310 	/*
311 	 * Test for synchronization (this is a temporary crock).
312 	 */
313 	if (pp->a_lastcode[2] != ':')
314 		pp->leap = LEAP_NOTINSYNC;
315 	else
316 		pp->leap = LEAP_NOWARNING;
317 
318 	/*
319 	 * Process the new sample in the median filter and determine the
320 	 * timecode timestamp.
321 	 */
322 	if (!refclock_process(pp)) {
323 		refclock_report(peer, CEVNT_BADTIME);
324 		return;
325 	}
326 
327 	/*
328 	 * If CLK_FLAG4 is set, initialize the statistics buffer and
329 	 * send the next command. If not, simply write the timecode to
330 	 * the clockstats file.
331 	 */
332 	(void)strcpy(up->lastptr, pp->a_lastcode);
333 	up->lastptr += pp->lencode;
334 	if (pp->sloppyclockflag & CLK_FLAG4) {
335 		*up->lastptr++ = ' ';
336 		(void)strcpy(up->lastptr, stat_command[up->index]);
337 		up->lastptr += strlen(stat_command[up->index]);
338 		up->lastptr--;
339 		*up->lastptr = '\0';
340 		(void)write(pp->io.fd, stat_command[up->index],
341 		    strlen(stat_command[up->index]));
342 		up->index++;
343 		if (*stat_command[up->index] == '\0')
344 			up->index = 0;
345 	}
346 }
347 
348 
349 /*
350  * as2201_poll - called by the transmit procedure
351  *
352  * We go to great pains to avoid changing state here, since there may be
353  * more than one eavesdropper receiving the same timecode.
354  */
355 static void
356 as2201_poll(
357 	int unit,
358 	struct peer *peer
359 	)
360 {
361 	struct refclockproc *pp;
362 
363 	/*
364 	 * Send a "\r*toc\r" to get things going. We go to great pains
365 	 * to avoid changing state, since there may be more than one
366 	 * eavesdropper watching the radio.
367 	 */
368 	pp = peer->procptr;
369 	if (write(pp->io.fd, "\r*toc\r", 6) != 6) {
370 		refclock_report(peer, CEVNT_FAULT);
371 	} else {
372 		pp->polls++;
373 		if (!(pp->sloppyclockflag & CLK_FLAG2))
374 			get_systime(&pp->lastrec);
375 	}
376 	if (peer->burst > 0)
377                 return;
378         if (pp->coderecv == pp->codeproc) {
379                 refclock_report(peer, CEVNT_TIMEOUT);
380                 return;
381         }
382         refclock_receive(peer);
383 	peer->burst = NSTAGE;
384 }
385 
386 #else
387 int refclock_as2201_bs;
388 #endif /* REFCLOCK */
389