Initial revision

[jog] / tx-serial-unix.c

/* -*-c-*-
 *
 * $Id: tx-serial-unix.c,v 1.1 2002/01/25 19:34:45 mdw Exp $
 *
 * Unix/POSIX serial transport
 *
 * (c) 2001 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Jog: Programming for a jogging machine.
 *
 * Jog is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Jog is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jog; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: tx-serial-unix.c,v $
 * Revision 1.1  2002/01/25 19:34:45  mdw
 * Initial revision
 *
 */

/*----- Header files ------------------------------------------------------*/

#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>

#include <mLib/darray.h>
#include <mLib/fdflags.h>
#include <mLib/sub.h>

#include "err.h"
#include "serial.h"
#include "txport.h"

#ifndef O_NOCTTY
#  define O_NOCTTY 0
#endif

/*----- Data structures ---------------------------------------------------*/

typedef struct txsu {
  txport tx;				/* Transport base */
  struct txsu *next, **prev;		/* Chain of serial transports */
  int fd;				/* File descriptor */
  struct termios old_ta;		/* Old terminal settings */
} txsu;

/*----- Static variables --------------------------------------------------*/

struct baudmap { unsigned long baud; unsigned long magic; };

static struct baudmap baudmap[] = {
#ifdef B50
  {	50,     B50 },
#endif
#ifdef B75
  {	75,     B75 },
#endif
#ifdef B110
  {    110,    B110 },
#endif
#ifdef B134
  {    134,    B134 },
#endif
#ifdef B150
  {    150,    B150 },
#endif
#ifdef B200
  {    200,    B200 },
#endif
#ifdef B300
  {    300,    B300 },
#endif
#ifdef B600
  {    600,    B600 },
#endif
#ifdef B1200
  {   1200,   B1200 },
#endif
#ifdef B1800
  {   1800,   B1800 },
#endif
#ifdef B2400
  {   2400,   B2400 },
#endif
#ifdef B4800
  {   4800,   B4800 },
#endif
#ifdef B9600
  {   9600,   B9600 },
#endif
#ifdef B19200
  {  19200,  B19200 },
#endif
#ifdef B38400
  {  38400,  B38400 },
#endif
#ifdef B57600
  {  57600,  B57600 },
#endif
#ifdef B115200
  { 115200, B115200 },
#endif
#ifdef B230400
  { 230400, B230400 },
#endif
  {      0,       0 }
};

static unsigned long csize[] = { CS5, CS6, CS7, CS8 };

static txsu *active = 0;

/*----- Main code ---------------------------------------------------------*/

/* --- @txsu_shutdown@ --- *
 *
 * Arguments:	---
 *
 * Returns:	---
 *
 * Use:		Restores terminal settings on exit.
 */

void txsu_shutdown(void)
{
  txsu *tx;

  for (tx = active; tx; tx = tx->next)
    tcsetattr(tx->fd, TCSAFLUSH, &tx->old_ta);
}

/* --- @txsu_create@ --- *
 *
 * Arguments:	@const char *file@ = filename for serial port
 *		@const char *config@ = configuration string
 *
 * Returns:	Pointer to created transport block.
 *
 * Use:		Creates a serial port transport.
 */

txport *txsu_create(const char *file, const char *config)
{
  txsu *tx;
  serial_config sc = SERIAL_INIT;
  struct termios ta, old_ta;
  struct baudmap *b;
  int fd;

  /* --- Parse the configuration and check it --- */

  if (config && *config && serial_parse(config, &sc))
    goto conferr;

  for (b = baudmap; b->baud && b->baud != sc.baud; b++)
    ;
  if (!b->baud || 
      sc.wordlen < 5 || sc.wordlen > 8 ||
      sc.stopbits < 1 || sc.stopbits > 2)
    goto conferr;

  /* --- Open the serial port and fetch attributes --- */

  if ((fd = open(file, O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "couldn't open device `%s': %s", file, strerror(errno));
    goto fail_0;
  }
  if (fdflags(fd, O_NONBLOCK, 0, 0, 0)) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "fcntl(clear O_NONBLOCK): %s", file, strerror(errno));
    goto fail_1;
  }    

  if (tcgetattr(fd, &ta)) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "couldn't get terminal attributes: %s", strerror(errno));
    goto fail_1;
  }
  old_ta = ta;

  /* --- Fix the attributes --- */

  ta.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
  ta.c_oflag &= ~OPOST;
  ta.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
  ta.c_cflag &= ~(CRTSCTS);
  ta.c_cc[VMIN] = 1;
  ta.c_cc[VTIME] = 0;

  cfsetospeed(&ta, b->magic);
  cfsetispeed(&ta, b->magic);
  ta.c_cflag = (ta.c_cflag & ~CSIZE) | csize[sc.wordlen - 5];
  switch (sc.parity) {
    case PARITY_NONE: ta.c_cflag &= ~PARENB; break;
    case PARITY_ODD:  ta.c_cflag |= PARENB | PARODD; break;
    case PARITY_EVEN: ta.c_cflag |= PARENB; ta.c_cflag &= ~PARODD; break;
  }
  switch (sc.stopbits) {
    case 1: ta.c_cflag &= ~CSTOPB; break;
    case 2: ta.c_cflag |= CSTOPB; break;
  }

  /* --- Set attributes --- */

  if (tcsetattr(fd, TCSAFLUSH, &ta)) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "couldn't set terminal attributes: %s", strerror(errno));
    goto fail_1;
  }

  /* --- Done --- */

  tx = CREATE(txsu);
  tx->fd = fd;
  tx->old_ta = old_ta;
  tx->next = active;
  tx->prev = &active;
  active = tx;
  return (&tx->tx);

  /* --- Tidy up because it all went horribly wrong --- */

fail_1:
  close(fd);
fail_0:
  return (0);

conferr:
  err_report(ERR_TXPORT, ERRTX_CONFIG, 0,
	     "bad configuration for serial port transport");
  goto fail_0;
}

/* --- @txsu_write@ --- *
 *
 * Arguments:	@txport *txg@ = pointer to transport context
 *		@const void *p@ = pointer to buffer
 *		@size_t sz@ = size of the buffer
 *
 * Returns:	Number of bytes written, or @-1@ on error.
 *
 * Use:		Writes data to a transport.
 */

ssize_t txsu_write(txport *txg, const void *p, size_t sz)
{
  txsu *tx = (txsu *)txg;

  return (write(tx->fd, p, sz));
}

/* --- @txsu_fetch@ --- *
 *
 * Arguments:	@void *txv@ = pointer to transport context
 *
 * Returns:	Nothing of interest.
 *
 * Use:		Thread to fetch data from a serial port.
 */

void *txsu_fetch(void *txv)
{
  txsu *tx = txv;
  unsigned char buf[BUFSIZ];
  ssize_t n;
  int e;

  /* --- Read data while it arrives --- */

  for (;;) {
    n = read(tx->fd, buf, sizeof(buf));
    if (n < 0) {
      err_report(ERR_TXPORT, ERRTX_READ, errno,
		 "error reading from serial port: %s", strerror(errno));
      break;
    }
#ifdef TERMINAL_EOF
    if (!n) break;
#else
    if (!n) continue;
#endif
    if ((e = pthread_mutex_lock(&tx->tx.mx)) != 0) {
      err_report(ERR_TXPORT, ERRTX_READ, e,
		 "error locking mutex: %s", strerror(e));
      break;
    }
    DA_ENSURE(&tx->tx.buf, n);
    memcpy(DA(&tx->tx.buf) + DA_LEN(&tx->tx.buf), buf, n);
    DA_EXTEND(&tx->tx.buf, n);
    pthread_cond_signal(&tx->tx.cv);
    pthread_mutex_unlock(&tx->tx.mx);
  }

  /* --- Deal with crapness --- */

  e = pthread_mutex_lock(&tx->tx.mx);
  tx->tx.s = TX_CLOSE;
  pthread_cond_signal(&tx->tx.cv);
  pthread_mutex_unlock(&tx->tx.mx);
  return (0);
}

/* --- @txsu_destroy@ --- *
 *
 * Arguments:	@txport *txg@ = pointer to transport context
 *
 * Returns:	---
 *
 * Use:		Destroys a serial port transport.
 */

void txsu_destroy(txport *txg)
{
  txsu *tx = (txsu *)txg;

  tcsetattr(tx->fd, TCSAFLUSH, &tx->old_ta);
  close(tx->fd);
  *tx->prev = tx->next;
  if (tx->next)
    tx->next->prev = tx->prev;
  DESTROY(tx);
}

/*----- That's all, folks -------------------------------------------------*/