[deliverable/binutils-gdb.git] / gdb / ser-base.c

/* Generic serial interface functions.

   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   2003, 2004, 2005 Free Software Foundation, Inc.

   This file is part of GDB.

   This program 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.

   This program 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 this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "serial.h"
#include "ser-unix.h"
#include "event-loop.h"

static timer_handler_func push_event;
static handler_func fd_event;

/* Event handling for ASYNC serial code.

   At any time the SERIAL device either: has an empty FIFO and is
   waiting on a FD event; or has a non-empty FIFO/error condition and
   is constantly scheduling timer events.

   ASYNC only stops pestering its client when it is de-async'ed or it
   is told to go away. */

/* Value of scb->async_state: */
enum {
  /* >= 0 (TIMER_SCHEDULED) */
  /* The ID of the currently scheduled timer event. This state is
     rarely encountered.  Timer events are one-off so as soon as the
     event is delivered the state is shanged to NOTHING_SCHEDULED. */
  FD_SCHEDULED = -1,
  /* The fd_event() handler is scheduled.  It is called when ever the
     file descriptor becomes ready. */
  NOTHING_SCHEDULED = -2
  /* Either no task is scheduled (just going into ASYNC mode) or a
     timer event has just gone off and the current state has been
     forced into nothing scheduled. */
};

/* Identify and schedule the next ASYNC task based on scb->async_state
   and scb->buf* (the input FIFO).  A state machine is used to avoid
   the need to make redundant calls into the event-loop - the next
   scheduled task is only changed when needed. */

void
reschedule (struct serial *scb)
{
  if (serial_is_async_p (scb))
    {
      int next_state;
      switch (scb->async_state)
	{
	case FD_SCHEDULED:
	  if (scb->bufcnt == 0)
	    next_state = FD_SCHEDULED;
	  else
	    {
	      delete_file_handler (scb->fd);
	      next_state = create_timer (0, push_event, scb);
	    }
	  break;
	case NOTHING_SCHEDULED:
	  if (scb->bufcnt == 0)
	    {
	      add_file_handler (scb->fd, fd_event, scb);
	      next_state = FD_SCHEDULED;
	    }
	  else
	    {
	      next_state = create_timer (0, push_event, scb);
	    }
	  break;
	default: /* TIMER SCHEDULED */
	  if (scb->bufcnt == 0)
	    {
	      delete_timer (scb->async_state);
	      add_file_handler (scb->fd, fd_event, scb);
	      next_state = FD_SCHEDULED;
	    }
	  else
	    next_state = scb->async_state;
	  break;
	}
      if (serial_debug_p (scb))
	{
	  switch (next_state)
	    {
	    case FD_SCHEDULED:
	      if (scb->async_state != FD_SCHEDULED)
		fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
				    scb->fd);
	      break;
	    default: /* TIMER SCHEDULED */
	      if (scb->async_state == FD_SCHEDULED)
		fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
				    scb->fd);
	      break;
	    }
	}
      scb->async_state = next_state;
    }
}

/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
   is no pending error).  As soon as data arrives, it is read into the
   input FIFO and the client notified.  The client should then drain
   the FIFO using readchar().  If the FIFO isn't immediatly emptied,
   push_event() is used to nag the client until it is. */

static void
fd_event (int error, void *context)
{
  struct serial *scb = context;
  if (error != 0)
    {
      scb->bufcnt = SERIAL_ERROR;
    }
  else if (scb->bufcnt == 0)
    {
      /* Prime the input FIFO.  The readchar() function is used to
         pull characters out of the buffer.  See also
         generic_readchar(). */
      int nr;
      do
	{
	  nr = read (scb->fd, scb->buf, BUFSIZ);
	}
      while (nr == -1 && errno == EINTR);
      if (nr == 0)
	{
	  scb->bufcnt = SERIAL_EOF;
	}
      else if (nr > 0)
	{
	  scb->bufcnt = nr;
	  scb->bufp = scb->buf;
	}
      else
	{
	  scb->bufcnt = SERIAL_ERROR;
	}
    }
  scb->async_handler (scb, scb->async_context);
  reschedule (scb);
}

/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
   error).  Nag the client until all the data has been read.  In the
   case of errors, the client will need to close or de-async the
   device before naging stops. */

static void
push_event (void *context)
{
  struct serial *scb = context;
  scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
  scb->async_handler (scb, scb->async_context);
  /* re-schedule */
  reschedule (scb);
}

int
ser_base_write (struct serial *scb, const char *str, int len)
{
  int cc;

  while (len > 0)
    {
      cc = write (scb->fd, str, len);

      if (cc < 0)
	return 1;
      len -= cc;
      str += cc;
    }
  return 0;
}

int
ser_base_flush_output (struct serial *scb)
{
  return 0;
}

int
ser_base_flush_input (struct serial *scb)
{
  if (scb->bufcnt >= 0)
    {
      scb->bufcnt = 0;
      scb->bufp = scb->buf;
      return 0;
    }
  else
    return SERIAL_ERROR;
}

int
ser_base_send_break (struct serial *scb)
{
  return 0;
}

int
ser_base_drain_output (struct serial *scb)
{
  return 0;
}

void
ser_base_raw (struct serial *scb)
{
  return;			/* Always in raw mode */
}

serial_ttystate
ser_base_get_tty_state (struct serial *scb)
{
  /* allocate a dummy */
  return (serial_ttystate) XMALLOC (int);
}

int
ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
{
  return 0;
}

int
ser_base_noflush_set_tty_state (struct serial *scb,
				serial_ttystate new_ttystate,
				serial_ttystate old_ttystate)
{
  return 0;
}

void
ser_base_print_tty_state (struct serial *scb, 
			  serial_ttystate ttystate,
			  struct ui_file *stream)
{
  /* Nothing to print.  */
  return;
}

int
ser_base_setbaudrate (struct serial *scb, int rate)
{
  return 0;			/* Never fails! */
}

int
ser_base_setstopbits (struct serial *scb, int num)
{
  return 0;			/* Never fails! */
}

/* Put the SERIAL device into/out-of ASYNC mode.  */

void
ser_base_async (struct serial *scb,
		int async_p)
{
  if (async_p)
    {
      /* Force a re-schedule. */
      scb->async_state = NOTHING_SCHEDULED;
      if (serial_debug_p (scb))
	fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
			    scb->fd);
      reschedule (scb);
    }
  else
    {
      if (serial_debug_p (scb))
	fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
			    scb->fd);
      /* De-schedule whatever tasks are currently scheduled. */
      switch (scb->async_state)
	{
	case FD_SCHEDULED:
	  delete_file_handler (scb->fd);
	  break;
	case NOTHING_SCHEDULED:
	  break;
	default: /* TIMER SCHEDULED */
	  delete_timer (scb->async_state);
	  break;
	}
    }
}
Commit	Line	Data
3eb25fda MM	1	/* Generic serial interface functions.
	2
	3	Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
	4	2003, 2004, 2005 Free Software Foundation, Inc.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
	23	#include "defs.h"
	24	#include "serial.h"
	25	#include "ser-unix.h"
	26	#include "event-loop.h"
	27
	28	static timer_handler_func push_event;
	29	static handler_func fd_event;
	30
	31	/* Event handling for ASYNC serial code.
	32
	33	At any time the SERIAL device either: has an empty FIFO and is
	34	waiting on a FD event; or has a non-empty FIFO/error condition and
	35	is constantly scheduling timer events.
	36
	37	ASYNC only stops pestering its client when it is de-async'ed or it
	38	is told to go away. */
	39
	40	/* Value of scb->async_state: */
	41	enum {
	42	/* >= 0 (TIMER_SCHEDULED) */
	43	/* The ID of the currently scheduled timer event. This state is
	44	rarely encountered. Timer events are one-off so as soon as the
	45	event is delivered the state is shanged to NOTHING_SCHEDULED. */
	46	FD_SCHEDULED = -1,
	47	/* The fd_event() handler is scheduled. It is called when ever the
	48	file descriptor becomes ready. */
	49	NOTHING_SCHEDULED = -2
	50	/* Either no task is scheduled (just going into ASYNC mode) or a
	51	timer event has just gone off and the current state has been
	52	forced into nothing scheduled. */
	53	};
	54
	55	/* Identify and schedule the next ASYNC task based on scb->async_state
	56	and scb->buf* (the input FIFO). A state machine is used to avoid
	57	the need to make redundant calls into the event-loop - the next
	58	scheduled task is only changed when needed. */
	59
	60	void
	61	reschedule (struct serial *scb)
	62	{
	63	if (serial_is_async_p (scb))
	64	{
65	int next_state;
66	switch (scb->async_state)
67	{
68	case FD_SCHEDULED:
69	if (scb->bufcnt == 0)
70	next_state = FD_SCHEDULED;
71	else
72	{
73	delete_file_handler (scb->fd);
74	next_state = create_timer (0, push_event, scb);
75	}
76	break;
77	case NOTHING_SCHEDULED:
78	if (scb->bufcnt == 0)
79	{
80	add_file_handler (scb->fd, fd_event, scb);
81	next_state = FD_SCHEDULED;
82	}
83	else
84	{
85	next_state = create_timer (0, push_event, scb);
86	}
87	break;
88	default: /* TIMER SCHEDULED */
89	if (scb->bufcnt == 0)
90	{
91	delete_timer (scb->async_state);
92	add_file_handler (scb->fd, fd_event, scb);
93	next_state = FD_SCHEDULED;
94	}
95	else
96	next_state = scb->async_state;
97	break;
98	}
99	if (serial_debug_p (scb))
100	{
101	switch (next_state)
102	{
103	case FD_SCHEDULED:
104	if (scb->async_state != FD_SCHEDULED)
105	fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
106	scb->fd);
107	break;
108	default: /* TIMER SCHEDULED */
109	if (scb->async_state == FD_SCHEDULED)
110	fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
111	scb->fd);
112	break;
113	}
114	}
115	scb->async_state = next_state;
116	}
117	}
118
119	/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
120	is no pending error). As soon as data arrives, it is read into the
121	input FIFO and the client notified. The client should then drain
122	the FIFO using readchar(). If the FIFO isn't immediatly emptied,
123	push_event() is used to nag the client until it is. */
124
125	static void
126	fd_event (int error, void *context)
127	{
128	struct serial *scb = context;
129	if (error != 0)
130	{
131	scb->bufcnt = SERIAL_ERROR;
132	}
133	else if (scb->bufcnt == 0)
134	{
135	/* Prime the input FIFO. The readchar() function is used to
136	pull characters out of the buffer. See also
137	generic_readchar(). */
138	int nr;
139	do
140	{
141	nr = read (scb->fd, scb->buf, BUFSIZ);
142	}
143	while (nr == -1 && errno == EINTR);
144	if (nr == 0)
145	{
146	scb->bufcnt = SERIAL_EOF;
147	}
148	else if (nr > 0)
149	{
150	scb->bufcnt = nr;
151	scb->bufp = scb->buf;
152	}
153	else
154	{
155	scb->bufcnt = SERIAL_ERROR;
156	}
157	}
158	scb->async_handler (scb, scb->async_context);
159	reschedule (scb);
160	}
161
162	/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
163	error). Nag the client until all the data has been read. In the
164	case of errors, the client will need to close or de-async the
165	device before naging stops. */
166
167	static void
168	push_event (void *context)
169	{
170	struct serial *scb = context;
171	scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
172	scb->async_handler (scb, scb->async_context);
173	/* re-schedule */
174	reschedule (scb);
175	}
176
177	int
dd5da072	178	ser_base_write (struct serial scb, const char str, int len)
3eb25fda MM	179	{
	180	int cc;
	181
	182	while (len > 0)
	183	{
	184	cc = write (scb->fd, str, len);
	185
	186	if (cc < 0)
	187	return 1;
	188	len -= cc;
	189	str += cc;
	190	}
	191	return 0;
	192	}
	193
	194	int
dd5da072	195	ser_base_flush_output (struct serial *scb)
3eb25fda MM	196	{
	197	return 0;
	198	}
	199
	200	int
dd5da072	201	ser_base_flush_input (struct serial *scb)
3eb25fda MM	202	{
	203	if (scb->bufcnt >= 0)
	204	{
	205	scb->bufcnt = 0;
	206	scb->bufp = scb->buf;
	207	return 0;
	208	}
	209	else
	210	return SERIAL_ERROR;
	211	}
	212
	213	int
dd5da072	214	ser_base_send_break (struct serial *scb)
3eb25fda MM	215	{
	216	return 0;
	217	}
	218
	219	int
dd5da072	220	ser_base_drain_output (struct serial *scb)
3eb25fda MM	221	{
	222	return 0;
	223	}
	224
	225	void
dd5da072	226	ser_base_raw (struct serial *scb)
3eb25fda MM	227	{
	228	return; /* Always in raw mode */
	229	}
	230
	231	serial_ttystate
dd5da072	232	ser_base_get_tty_state (struct serial *scb)
3eb25fda MM	233	{
	234	/* allocate a dummy */
	235	return (serial_ttystate) XMALLOC (int);
	236	}
	237
	238	int
dd5da072	239	ser_base_set_tty_state (struct serial *scb, serial_ttystate ttystate)
3eb25fda MM	240	{
	241	return 0;
	242	}
	243
	244	int
dd5da072 MM	245	ser_base_noflush_set_tty_state (struct serial *scb,
	246	serial_ttystate new_ttystate,
	247	serial_ttystate old_ttystate)
3eb25fda MM	248	{
	249	return 0;
	250	}
	251
	252	void
dd5da072 MM	253	ser_base_print_tty_state (struct serial *scb,
	254	serial_ttystate ttystate,
	255	struct ui_file *stream)
3eb25fda MM	256	{
	257	/* Nothing to print. */
	258	return;
	259	}
	260
	261	int
dd5da072	262	ser_base_setbaudrate (struct serial *scb, int rate)
3eb25fda MM	263	{
	264	return 0; /* Never fails! */
	265	}
	266
	267	int
dd5da072	268	ser_base_setstopbits (struct serial *scb, int num)
3eb25fda MM	269	{
	270	return 0; /* Never fails! */
	271	}
	272
	273	/* Put the SERIAL device into/out-of ASYNC mode. */
	274
	275	void
dd5da072	276	ser_base_async (struct serial *scb,
3eb25fda MM	277	int async_p)
	278	{
	279	if (async_p)
	280	{
	281	/* Force a re-schedule. */
	282	scb->async_state = NOTHING_SCHEDULED;
	283	if (serial_debug_p (scb))
	284	fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
	285	scb->fd);
	286	reschedule (scb);
	287	}
	288	else
	289	{
	290	if (serial_debug_p (scb))
	291	fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
	292	scb->fd);
	293	/* De-schedule whatever tasks are currently scheduled. */
	294	switch (scb->async_state)
	295	{
	296	case FD_SCHEDULED:
	297	delete_file_handler (scb->fd);
	298	break;
	299	case NOTHING_SCHEDULED:
	300	break;
	301	default: /* TIMER SCHEDULED */
	302	delete_timer (scb->async_state);
	303	break;
	304	}
	305	}
	306	}