[binutils.git] / gdb / ser-mac.c

/* Remote serial interface for local (hardwired) serial ports for Macintosh.
   Copyright 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "serial.h"

#include <Types.h>
#include <Devices.h>
#include <Serial.h>

/* This is unused for now.  We just return a placeholder. */

struct mac_ttystate
  {
    int bogus;
  };

static int mac_open PARAMS ((serial_t scb, const char *name));
static void mac_raw PARAMS ((serial_t scb));
static int mac_readchar PARAMS ((serial_t scb, int timeout));
static int mac_setbaudrate PARAMS ((serial_t scb, int rate));
static int mac_write PARAMS ((serial_t scb, const char *str, int len));
static void mac_close PARAMS ((serial_t scb));
static serial_ttystate mac_get_tty_state PARAMS ((serial_t scb));
static int mac_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
static char *aptr PARAMS ((short p));

short input_refnum;
short output_refnum;

char *mac_input_buffer;
char *mac_output_buffer;

static int
mac_open (scb, name)
     serial_t scb;
     const char *name;
{
  OSErr err;

  /* Alloc buffer space first - that way any allocation failures are
     intercepted before the serial driver gets involved. */
  if (mac_input_buffer == NULL)
    mac_input_buffer = (char *) xmalloc (256);
  /* Match on a name and open a port. */
  if (strcmp (name, "modem") == 0)
    {
      err = OpenDriver ("\p.AIn", &input_refnum);
      if (err != 0)
	{
	  return (-1);
	}
      err = OpenDriver ("\p.AOut", &output_refnum);
      if (err != 0)
	{
	  CloseDriver (input_refnum);
	  return (-1);
	}
    }
  else if (strcmp (name, "printer") == 0)
    {
      err = OpenDriver ("\p.BIn", &input_refnum);
      if (err != 0)
	{
	  return (-1);
	}
      err = OpenDriver ("\p.BOut", &output_refnum);
      if (err != 0)
	{
	  CloseDriver (input_refnum);
	  return (-1);
	}
      /* fake */
      scb->fd = 1;
      return 0;
    }
  else
    {
      errno = ENOENT;
      return (-1);
    }
  /* We got something open. */
  if (1 /* using custom buffer */)
    SerSetBuf (input_refnum, mac_input_buffer, 256);
  /* Set to a GDB-preferred state. */
  SerReset (input_refnum,  stop10|noParity|data8|baud9600);
  SerReset (output_refnum, stop10|noParity|data8|baud9600);
  {
    CntrlParam cb;
    struct SerShk *handshake;

    cb.ioCRefNum = output_refnum;
    cb.csCode = 14;
    handshake = (struct SerShk *) &cb.csParam[0];
    handshake->fXOn = 0;
    handshake->fCTS = 0;
    handshake->xOn = 0;
    handshake->xOff = 0;
    handshake->errs = 0;
    handshake->evts = 0;
    handshake->fInX = 0;
    handshake->fDTR = 0;
    err = PBControl ((ParmBlkPtr) &cb, 0);
    if (err < 0)
      return (-1);
  }
  /* fake */
  scb->fd = 1;
  return 0;
}

static int
mac_noop (scb)
     serial_t scb;
{
  return 0;
}

static void
mac_raw (scb)
     serial_t scb;
{
  /* Always effectively in raw mode. */
}

/* Read a character with user-specified timeout.  TIMEOUT is number of seconds
   to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
   char if successful.  Returns -2 if timeout expired, EOF if line dropped
   dead, or -3 for any other error (see errno in that case). */

static int
mac_readchar (scb, timeout)
     serial_t scb;
     int timeout;
{
  int status, n;
  /* time_t */ unsigned long starttime, now;
  OSErr err;
  CntrlParam cb;
  IOParam pb;

  if (scb->bufcnt-- > 0)
    return *scb->bufp++;

  time (&starttime);

  while (1)
    {
      cb.ioCRefNum = input_refnum;
      cb.csCode = 2;
      err = PBStatus ((ParmBlkPtr) &cb, 0);
      if (err < 0)
	return SERIAL_ERROR;
      n = *((long *) &cb.csParam[0]);
      if (n > 0)
	{
	  pb.ioRefNum = input_refnum;
	  pb.ioBuffer = (Ptr) (scb->buf);
	  pb.ioReqCount = (n > 64 ? 64 : n);
	  err = PBRead ((ParmBlkPtr) &pb, 0);
	  if (err < 0)
	    return SERIAL_ERROR;
	  scb->bufcnt = pb.ioReqCount;
	  scb->bufcnt--;
	  scb->bufp = scb->buf;
	  return *scb->bufp++;
	}
      else if (timeout == 0)
	return SERIAL_TIMEOUT;
      else if (timeout == -1)
	;
      else
	{
	  time (&now);
	  if (now > starttime + timeout) {
	    printf_unfiltered ("start %u, now %u, timeout %d\n", starttime, now, timeout);
	    return SERIAL_TIMEOUT;
	  }
	}
    }
}

/* mac_{get set}_tty_state() are both dummys to fill out the function
   vector.  Someday, they may do something real... */

static serial_ttystate
mac_get_tty_state (scb)
     serial_t scb;
{
  struct mac_ttystate *state;

  state = (struct mac_ttystate *) xmalloc (sizeof *state);

  return (serial_ttystate) state;
}

static int
mac_set_tty_state (scb, ttystate)
     serial_t scb;
     serial_ttystate ttystate;
{
  return 0;
}

static int
mac_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
     serial_t scb;
     serial_ttystate new_ttystate;
     serial_ttystate old_ttystate;
{
  return 0;
}

static void
mac_print_tty_state (scb, ttystate)
     serial_t scb;
     serial_ttystate ttystate;
{
  /* Nothing to print.  */
  return;
}

static int
mac_set_baud_rate (scb, rate)
     serial_t scb;
     int rate;
{
  return 0;
}

static int
mac_write (scb, str, len)
     serial_t scb;
     const char *str;
     int len;
{
  OSErr err;
  IOParam pb;

  pb.ioRefNum = output_refnum;
  pb.ioBuffer = (Ptr) str;
  pb.ioReqCount = len;
  err = PBWrite ((ParmBlkPtr) &pb, 0);
  if (err < 0)
    {
      return 1;
    }
  return 0;
}

static void
mac_close (scb)
     serial_t scb;
{
  if (input_refnum)
    {
      if (1 /* custom buffer */)
	SerSetBuf (input_refnum, mac_input_buffer, 0);
      CloseDriver (input_refnum);
      input_refnum = 0;
    }
  if (output_refnum)
    {
      if (0 /* custom buffer */)
	SetSetBuf (input_refnum, mac_output_buffer, 0);
      CloseDriver (output_refnum);
      output_refnum = 0;
    }
}

static struct serial_ops mac_ops =
{
  "hardwire",
  0,
  mac_open,
  mac_close,
  mac_readchar,
  mac_write,
  mac_noop,			/* flush output */
  mac_noop,			/* flush input */
  mac_noop,			/* send break -- currently only for nindy */
  mac_raw,
  mac_get_tty_state,
  mac_set_tty_state,
  mac_print_tty_state,
  mac_noflush_set_tty_state,
  mac_set_baud_rate,
};

void
_initialize_ser_mac ()
{
  serial_add_interface (&mac_ops);
}
Commit	Line	Data
8dc3e3d7 SS	1	/* Remote serial interface for local (hardwired) serial ports for Macintosh.
	2	Copyright 1994 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "defs.h"
	21	#include "serial.h"
	22
	23	#include <Types.h>
	24	#include <Devices.h>
	25	#include <Serial.h>
	26
	27	/* This is unused for now. We just return a placeholder. */
	28
	29	struct mac_ttystate
	30	{
	31	int bogus;
	32	};
	33
	34	static int mac_open PARAMS ((serial_t scb, const char *name));
	35	static void mac_raw PARAMS ((serial_t scb));
	36	static int mac_readchar PARAMS ((serial_t scb, int timeout));
	37	static int mac_setbaudrate PARAMS ((serial_t scb, int rate));
	38	static int mac_write PARAMS ((serial_t scb, const char *str, int len));
	39	static void mac_close PARAMS ((serial_t scb));
	40	static serial_ttystate mac_get_tty_state PARAMS ((serial_t scb));
	41	static int mac_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
	42	static char *aptr PARAMS ((short p));
	43
	44	short input_refnum;
	45	short output_refnum;
	46
	47	char *mac_input_buffer;
	48	char *mac_output_buffer;
	49
	50	static int
	51	mac_open (scb, name)
	52	serial_t scb;
	53	const char *name;
	54	{
	55	OSErr err;
	56
	57	/* Alloc buffer space first - that way any allocation failures are
	58	intercepted before the serial driver gets involved. */
	59	if (mac_input_buffer == NULL)
	60	mac_input_buffer = (char *) xmalloc (256);
	61	/* Match on a name and open a port. */
	62	if (strcmp (name, "modem") == 0)
	63	{
	64	err = OpenDriver ("\p.AIn", &input_refnum);
65	if (err != 0)
66	{
67	return (-1);
68	}
69	err = OpenDriver ("\p.AOut", &output_refnum);
70	if (err != 0)
71	{
72	CloseDriver (input_refnum);
73	return (-1);
74	}
75	}
76	else if (strcmp (name, "printer") == 0)
77	{
78	err = OpenDriver ("\p.BIn", &input_refnum);
79	if (err != 0)
80	{
81	return (-1);
82	}
83	err = OpenDriver ("\p.BOut", &output_refnum);
84	if (err != 0)
85	{
86	CloseDriver (input_refnum);
87	return (-1);
88	}
89	/* fake */
90	scb->fd = 1;
91	return 0;
92	}
93	else
94	{
95	errno = ENOENT;
96	return (-1);
97	}
98	/* We got something open. */
99	if (1 /* using custom buffer */)
100	SerSetBuf (input_refnum, mac_input_buffer, 256);
101	/* Set to a GDB-preferred state. */
102	SerReset (input_refnum, stop10\|noParity\|data8\|baud9600);
103	SerReset (output_refnum, stop10\|noParity\|data8\|baud9600);
104	{
105	CntrlParam cb;
106	struct SerShk *handshake;
107
108	cb.ioCRefNum = output_refnum;
109	cb.csCode = 14;
110	handshake = (struct SerShk *) &cb.csParam[0];
111	handshake->fXOn = 0;
112	handshake->fCTS = 0;
113	handshake->xOn = 0;
114	handshake->xOff = 0;
115	handshake->errs = 0;
116	handshake->evts = 0;
117	handshake->fInX = 0;
118	handshake->fDTR = 0;
119	err = PBControl ((ParmBlkPtr) &cb, 0);
120	if (err < 0)
121	return (-1);
122	}
123	/* fake */
124	scb->fd = 1;
125	return 0;
126	}
127
128	static int
129	mac_noop (scb)
130	serial_t scb;
131	{
132	return 0;
133	}
134
135	static void
136	mac_raw (scb)
137	serial_t scb;
138	{
139	/* Always effectively in raw mode. */
140	}
141
142	/* Read a character with user-specified timeout. TIMEOUT is number of seconds
143	to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
144	char if successful. Returns -2 if timeout expired, EOF if line dropped
145	dead, or -3 for any other error (see errno in that case). */
146
147	static int
148	mac_readchar (scb, timeout)
149	serial_t scb;
150	int timeout;
151	{
152	int status, n;
153	/* time_t */ unsigned long starttime, now;
154	OSErr err;
155	CntrlParam cb;
156	IOParam pb;
157
158	if (scb->bufcnt-- > 0)
159	return *scb->bufp++;
160
161	time (&starttime);
162
163	while (1)
164	{
165	cb.ioCRefNum = input_refnum;
166	cb.csCode = 2;
167	err = PBStatus ((ParmBlkPtr) &cb, 0);
168	if (err < 0)
169	return SERIAL_ERROR;
170	n = ((long ) &cb.csParam[0]);
171	if (n > 0)
172	{
173	pb.ioRefNum = input_refnum;
174	pb.ioBuffer = (Ptr) (scb->buf);
175	pb.ioReqCount = (n > 64 ? 64 : n);
176	err = PBRead ((ParmBlkPtr) &pb, 0);
177	if (err < 0)
178	return SERIAL_ERROR;
179	scb->bufcnt = pb.ioReqCount;
180	scb->bufcnt--;
181	scb->bufp = scb->buf;
182	return *scb->bufp++;
183	}
184	else if (timeout == 0)
185	return SERIAL_TIMEOUT;
186	else if (timeout == -1)
187	;
188	else
189	{
190	time (&now);
191	if (now > starttime + timeout) {
192	printf_unfiltered ("start %u, now %u, timeout %d\n", starttime, now, timeout);
193	return SERIAL_TIMEOUT;
194	}
195	}
196	}
197	}
198
199	/* mac_{get set}_tty_state() are both dummys to fill out the function
200	vector. Someday, they may do something real... */
201
202	static serial_ttystate
203	mac_get_tty_state (scb)
204	serial_t scb;
205	{
206	struct mac_ttystate *state;
207
208	state = (struct mac_ttystate ) xmalloc (sizeof state);
209
210	return (serial_ttystate) state;
211	}
212
213	static int
214	mac_set_tty_state (scb, ttystate)
215	serial_t scb;
216	serial_ttystate ttystate;
217	{
218	return 0;
219	}
220
221	static int
222	mac_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
223	serial_t scb;
224	serial_ttystate new_ttystate;
225	serial_ttystate old_ttystate;
226	{
227	return 0;
228	}
229
230	static void
231	mac_print_tty_state (scb, ttystate)
232	serial_t scb;
233	serial_ttystate ttystate;
234	{
235	/* Nothing to print. */
236	return;
237	}
238
239	static int
240	mac_set_baud_rate (scb, rate)
241	serial_t scb;
242	int rate;
243	{
244	return 0;
245	}
246
247	static int
248	mac_write (scb, str, len)
249	serial_t scb;
250	const char *str;
251	int len;
252	{
253	OSErr err;
254	IOParam pb;
255
256	pb.ioRefNum = output_refnum;
257	pb.ioBuffer = (Ptr) str;
258	pb.ioReqCount = len;
259	err = PBWrite ((ParmBlkPtr) &pb, 0);
260	if (err < 0)
261	{
262	return 1;
263	}
264	return 0;
265	}
266
267	static void
268	mac_close (scb)
269	serial_t scb;
270	{
271	if (input_refnum)
272	{
273	if (1 /* custom buffer */)
274	SerSetBuf (input_refnum, mac_input_buffer, 0);
275	CloseDriver (input_refnum);
276	input_refnum = 0;
277	}
278	if (output_refnum)
279	{
280	if (0 /* custom buffer */)
281	SetSetBuf (input_refnum, mac_output_buffer, 0);
282	CloseDriver (output_refnum);
283	output_refnum = 0;
284	}
285	}
286
287	static struct serial_ops mac_ops =
288	{
289	"hardwire",
290	0,
291	mac_open,
292	mac_close,
293	mac_readchar,
294	mac_write,
295	mac_noop, /* flush output */
296	mac_noop, /* flush input */
297	mac_noop, /* send break -- currently only for nindy */
298	mac_raw,
299	mac_get_tty_state,
300	mac_set_tty_state,
301	mac_print_tty_state,
302	mac_noflush_set_tty_state,
303	mac_set_baud_rate,
304	};
305
306	void
307	_initialize_ser_mac ()
308	{
309	serial_add_interface (&mac_ops);
310	}