serial.c

/*
 * Copyright (c) 2002 Jon Atkins http://www.jonatkins.com/
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "config.h"

#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "systime.h"
#include <sys/ioctl.h>
#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/errno.h>

#ifdef ENABLE_GPIO
#include <poll.h>
#endif

#ifdef ENABLE_TIMEPPS
#include <sys/timepps.h>
#endif



#include "logger.h"

#include "serial.h"
#include "memory.h"


static serDevT* 	serDevHead;
static serLineT*	serLineHead;


int
serInit (void)
{
	serDevHead = NULL;
	serLineHead = NULL;

	return 0;
}

serLineT*
serAddLine ( char* dev, int line, int mode )
{
	char		fulldev[64];
	serDevT*	serdev;
	serLineT*	serline;

	//allow for either full paths or /dev relative paths...
	if ( dev[0] == '/' )
	{
		if ( strlen(dev) >= 64 )
		{
			loggerf ( LOGGER_NOTE, "serAddLine(): dev too long\n" );
			return NULL;
		}
		strcpy ( fulldev, dev );
	}
	else
	{
		strcpy ( fulldev, "/dev/" );
		if ( strlen(dev)+strlen(fulldev) >= 64 )
		{
			loggerf ( LOGGER_NOTE, "serAddLine(): dev too long\n" );
			return NULL;
		}
		strcat ( fulldev, dev );
	}

	//make sure only one line bit is set...
	if ( line & (line-1) )
	{
		loggerf ( LOGGER_NOTE, "serAddLine(): more than one line bit set\n" );
		return NULL;
	}

	//try and find an existing device in the list...
	serdev = serDevHead;
	while ( serdev != NULL )
	{
		if ( strcmp ( serdev->dev, fulldev ) == 0 )
			break;
		serdev = serdev->next;
	}
	if ( serdev == NULL )
	{
		//no existing device - create a new one..
		serdev = safe_mallocz ( sizeof(serDevT) );
		serdev->next = serDevHead;
		serDevHead = serdev;

		strcpy ( serdev->dev, fulldev );
		serdev->mode = mode;
		serdev->modemlines = 0;
		serdev->fd = -1;
	}

	//make sure we're using it in the same mode...
	if ( serdev->mode != mode )
	{
		loggerf ( LOGGER_NOTE, "serAddLine(): cannot add line for same device with different mode\n" );
		return NULL;
	}


	//make sure we're not already monitoring this line...
	if ( serdev->modemlines & line )
	{
		loggerf ( LOGGER_NOTE, "serAddLine(): cannot add modem status line more than once\n" );
		return NULL;
	}

	//ok - we've got a valid device/line/mode combo...

	serdev->modemlines |= line;

	//create a new line entry...
	serline = safe_mallocz ( sizeof(serLineT) );
	serline->next = serLineHead;
	serLineHead = serline;

	serline->dev = serdev;
	serline->line = line;

	return serline;

}



serDevT*
serGetDev ( serDevT* prev )
{
	if ( prev == NULL )
		return serDevHead;

	return prev->next;
}

serLineT*
serGetLine ( serLineT* prev )
{
	if ( prev == NULL )
		return serLineHead;

	return prev->next;
}


int
serOpenDev ( serDevT* dev )
{
#ifdef ENABLE_TIMEPPS
	pps_params_t	ppsparams;
	int		ppsmode;
#endif

	dev->fd = open ( dev->dev, O_RDONLY|O_NOCTTY );

	switch ( dev->mode )
	{
#ifdef ENABLE_TIMEPPS
	case SERPORT_MODE_TIMEPPS:
		if ( time_pps_create ( dev->fd, &dev->ppshandle ) == -1 )
			return -1;

		if ( time_pps_getparams ( dev->ppshandle, &ppsparams ) == -1 )
			return -1;

		ppsparams.mode |= PPS_TSFMT_TSPEC | PPS_CAPTUREBOTH;

		if ( time_pps_setparams ( dev->ppshandle, &ppsparams ) == -1 )
			return -1;

		if ( time_pps_getcap ( dev->ppshandle, &ppsmode ) == -1 )
			return -1;

		//NOTE: these should probably be error cases, but the code is still experimental and
		//the PPS support I've used also seems to have problems
		if ( ! (ppsmode | PPS_CAPTUREASSERT) )
			loggerf ( LOGGER_NOTE, "Warning: PPS_CAPTUREASSERT not supported\n" );
		if ( ! (ppsmode | PPS_CAPTURECLEAR) )
			loggerf ( LOGGER_NOTE, "Warning: PPS_CAPTURECLEAR not supported\n" );

//!!! no point using this - too many problems
//1. linux doesn't report PPS_CANWAIT, but can
//2. FreeBSD does report PPS_CANWAIT, but can't
//(unless its me reading the docs backwards?)
//		if ( ! (ppsmode | PPS_CANWAIT) )
//			loggerf ( LOGGER_NOTE, "Warning: PPS_CANWAIT not supported (linux lies)\n" );

#endif
	}

	return dev->fd;
}

int
serInitHardware ( serDevT* dev )
{
	if ( dev->fd < 0 )
		serOpenDev ( dev );

	if ( dev->fd < 0 )
		return -1;

	//add code to power on the device (set DTR high - maybe other options..?)

	//wait for the device to power up...
	sleep(3);

	return 0;
}


//static jmp_buf alrmjump;

#ifdef ENABLE_TIOCMIWAIT
static void
sigalrm ( int sig )
{
	//empty func - just used so that ioctl() aborts on an alarm()
}
#endif

int
serWaitForSerialChange ( serDevT* dev )
{
	struct timeval tv;
	time_f	timef;
	int	i,ret;
#ifdef ENABLE_TIMEPPS
	struct timespec timeout;
	pps_info_t	ppsinfo;
	int		ppslines;
#endif
#ifdef ENABLE_GPIO
	struct pollfd  pollfds[1];
#endif

	if ( dev->modemlines == 0 )
		return -1;

	switch ( dev->mode )
	{
	case SERPORT_MODE_POLL:

		for ( i=0; i<10*1000; i++ )
		{
			gettimeofday ( &tv, NULL );
			timeval2time_f ( &tv, timef );
			ret = serGetDevStatusLines ( dev, timef );
			if ( ret < 0 )
				return -1;
			if ( ret == 1 )
				return 0;

			usleep ( 1000 );
		}

		//timeout
		return -1;
		break;

#ifdef ENABLE_GPIO
	case SERPORT_MODE_GPIO:
		pollfds[0].fd = dev->fd;
		pollfds[0].events = POLLERR;

		i = poll(pollfds, 1, 10000); /* timeout 10 seconds */
		if (i != 1 && !(pollfds[0].revents & POLLERR) )
			return -1;

		gettimeofday ( &tv, NULL );
		timeval2time_f ( &tv, timef );

		if ( serGetDevStatusLines ( dev, timef ) < 0 )
			return -1;

		return 0;
		break;
#endif


#ifdef ENABLE_TIOCMIWAIT
	case SERPORT_MODE_IWAIT:
		signal ( SIGALRM, sigalrm );
		alarm ( 10 );

		if ( ioctl ( dev->fd, TIOCMIWAIT, dev->modemlines) != 0 )
			return -1;
		gettimeofday ( &tv, NULL );
		timeval2time_f ( &tv, timef );

		signal ( SIGALRM, SIG_DFL );
		alarm ( 0 );

		if ( serGetDevStatusLines ( dev, timef ) < 0 )
			return -1;

		return 0;
		break;
#endif

#ifdef ENABLE_TIMEPPS
	case SERPORT_MODE_TIMEPPS:
		timeout.tv_sec = 0;
		timeout.tv_nsec = 0;

		for ( i=0; i<10*100; i++ )
		{
			if ( time_pps_fetch ( dev->ppshandle, PPS_TSFMT_TSPEC, &ppsinfo, &timeout ) == -1 )
			{
				loggerf ( LOGGER_NOTE, "ppsfetch failed: %d\n", errno );
				return -1;
			}

			if ( ppsinfo.assert_sequence != dev->ppslastassert )
			{
				timespec2time_f ( &ppsinfo.assert_timestamp, timef );
				ppslines = TIOCM_CD;	//NOTE: assuming that pps support is on the DCD line
				dev->ppslastassert = ppsinfo.assert_sequence;

				if ( serStoreDevStatusLines ( dev, ppslines, timef ) < 0 )
					return -1;
				return 0;
			}
			else if ( ppsinfo.clear_sequence != dev->ppslastclear )
			{
				timespec2time_f ( &ppsinfo.clear_timestamp, timef );
				ppslines = 0;
				dev->ppslastclear = ppsinfo.clear_sequence;

				if ( serStoreDevStatusLines ( dev, ppslines, timef ) < 0 )
					return -1;
				return 0;
			}

			usleep ( 10000 );
		}

		return -1;
		break;
#endif

	}

	loggerf ( LOGGER_NOTE, "Error: serWaitForSerialChange(): mode not supported\n" );

	//unknown serial port mode !!
	return -1;

}

int
serGetDevStatusLines ( serDevT* dev, time_f timef )
{
	int	lines;

#ifdef ENABLE_GPIO
	char    buf[8];
	if (dev->mode == SERPORT_MODE_GPIO) {
		if (lseek(dev->fd, SEEK_SET, 0) == -1)
			return -1;
		if (read(dev->fd, buf, sizeof(buf)) <= 0)
			return -1;

		if (buf[0] == '1')
			lines = TIOCM_CD;
		else
			lines = 0;

		return serStoreDevStatusLines ( dev, lines, timef );
	}
#endif

	if ( ioctl ( dev->fd, TIOCMGET, &lines ) != 0 )
		return -1;

	return serStoreDevStatusLines ( dev, lines, timef );
}

int
serStoreDevStatusLines ( serDevT* dev, int lines, time_f timef )
{

	time_f diff = timef - dev->eventtime;
	if (diff < 0.05) {
		loggerf ( LOGGER_DEBUG, "serStoreDevStatusLines: pulse too short %f, filtering!\n", diff);
		return 0;
	}
	if ( lines != dev->curlines )
	{
		dev->prevlines = dev->curlines;
		dev->curlines = lines;
		dev->eventtime = timef;

		return 1;
	}

	return 0;
}


int
serUpdateLinesForDevice ( serDevT* dev )
{
	serLineT* line;

	for ( line = serGetLine ( NULL );  line != NULL; line = serGetLine ( line ) )
	{
		//skip lines not on this device...
		if ( line->dev != dev )
			continue;

		if ( (dev->curlines & line->line) != (dev->prevlines & line->line) )
		{
			line->curstate = dev->curlines & line->line;
			line->eventtime = dev->eventtime;
		}
	}

	return 0;
}