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

/* Remote serial interface for local (hardwired) serial ports for Macintosh.
   Copyright 1994 Free Software Foundation, Inc.
   Contributed by Cygnus Support.  Written by Stan Shebs.

   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 <Types.h>
#include <Devices.h>
/* This is the regular Mac Serial.h, but copied to a different name
   so as not to get confused with the GDB serial.h above.  */
#include "MacSerial.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 (4096);
  /* 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
    {
      error ("You must specify a valid serial port name; your choices are `modem' or `printer'.");
      errno = ENOENT;
      return (-1);
    }
  /* We got something open. */
  if (1 /* using custom buffer */)
    SerSetBuf (input_refnum, mac_input_buffer, 4096);
  /* 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 start_time, now;
  OSErr err;
  CntrlParam cb;
  IOParam pb;

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

  time (&start_time);

  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 > start_time + timeout)
	    return SERIAL_TIMEOUT;
	}
      PROGRESS (1);
    }
}

/* 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;
}

/* If there is a tricky formula to relate real baud rates
   to what the serial driver wants, we should use it.  Until
   we get one, this table will have to do.  */

static struct {
  int real_rate;
  int bits;
} mac_baud_rate_table[] = {
  { 57600, baud57600 },
  { 38400, 1 },
  { 19200, baud19200 },
  { 9600, baud9600 },
  { 7200, baud7200 },
  { 4800, baud4800 },
  { 3600, baud3600 },
  { 2400, baud2400 },
  { 1800, baud1800 },
  { 1200, baud1200 },
  { 600, baud600 },
  { 300, baud300 },
  { 0, 0 }
};

static int
mac_set_baud_rate (scb, rate)
     serial_t scb;
     int rate;
{
  int i, bits;

  for (i = 0; mac_baud_rate_table[i].real_rate != 0; ++i)
    {
      if (mac_baud_rate_table[i].real_rate == rate)
	{
	  bits = mac_baud_rate_table[i].bits;
	  break;
	}
    }
  SerReset (input_refnum,  stop10|noParity|data8|bits);
  SerReset (output_refnum, stop10|noParity|data8|bits);
}

static int
mac_set_stop_bits (scb, num)
     serial_t scb;
     int num;
{
  return 0;
}

int first_mac_write = 0;

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

  if (first_mac_write++ < 4)
    {
      sleep (1);
    }
  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 (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 */)
	SerSetBuf (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,
  mac_set_stop_bits,
  mac_noop,			/* wait for output to drain */
};

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.
8dc3e3d7 SS	2	Copyright 1994 Free Software Foundation, Inc.
58c0b523	3	Contributed by Cygnus Support. Written by Stan Shebs.
8dc3e3d7 SS	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
6c9638b4	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
8dc3e3d7 SS	20
	21	#include "defs.h"
	22	#include "serial.h"
	23
	24	#include <Types.h>
	25	#include <Devices.h>
7f6572f5 SS	26	/* This is the regular Mac Serial.h, but copied to a different name
	27	so as not to get confused with the GDB serial.h above. */
	28	#include "MacSerial.h"
8dc3e3d7 SS	29
	30	/* This is unused for now. We just return a placeholder. */
	31
	32	struct mac_ttystate
	33	{
	34	int bogus;
	35	};
	36
	37	static int mac_open PARAMS ((serial_t scb, const char *name));
	38	static void mac_raw PARAMS ((serial_t scb));
	39	static int mac_readchar PARAMS ((serial_t scb, int timeout));
	40	static int mac_setbaudrate PARAMS ((serial_t scb, int rate));
	41	static int mac_write PARAMS ((serial_t scb, const char *str, int len));
	42	static void mac_close PARAMS ((serial_t scb));
	43	static serial_ttystate mac_get_tty_state PARAMS ((serial_t scb));
	44	static int mac_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
	45	static char *aptr PARAMS ((short p));
	46
	47	short input_refnum;
	48	short output_refnum;
	49
	50	char *mac_input_buffer;
	51	char *mac_output_buffer;
	52
	53	static int
	54	mac_open (scb, name)
	55	serial_t scb;
	56	const char *name;
	57	{
	58	OSErr err;
	59
	60	/* Alloc buffer space first - that way any allocation failures are
	61	intercepted before the serial driver gets involved. */
	62	if (mac_input_buffer == NULL)
1f233758	63	mac_input_buffer = (char *) xmalloc (4096);
8dc3e3d7 SS	64	/* Match on a name and open a port. */
	65	if (strcmp (name, "modem") == 0)
	66	{
	67	err = OpenDriver ("\p.AIn", &input_refnum);
	68	if (err != 0)
	69	{
	70	return (-1);
	71	}
	72	err = OpenDriver ("\p.AOut", &output_refnum);
	73	if (err != 0)
	74	{
	75	CloseDriver (input_refnum);
	76	return (-1);
	77	}
	78	}
	79	else if (strcmp (name, "printer") == 0)
	80	{
	81	err = OpenDriver ("\p.BIn", &input_refnum);
	82	if (err != 0)
	83	{
	84	return (-1);
	85	}
	86	err = OpenDriver ("\p.BOut", &output_refnum);
	87	if (err != 0)
	88	{
	89	CloseDriver (input_refnum);
	90	return (-1);
	91	}
	92	/* fake */
	93	scb->fd = 1;
	94	return 0;
	95	}
	96	else
	97	{
e70a10c3	98	error ("You must specify a valid serial port name; your choices are `modem' or `printer'.");
8dc3e3d7 SS	99	errno = ENOENT;
	100	return (-1);
	101	}
	102	/* We got something open. */
	103	if (1 /* using custom buffer */)
1f233758	104	SerSetBuf (input_refnum, mac_input_buffer, 4096);
8dc3e3d7 SS	105	/* Set to a GDB-preferred state. */
	106	SerReset (input_refnum, stop10\|noParity\|data8\|baud9600);
	107	SerReset (output_refnum, stop10\|noParity\|data8\|baud9600);
	108	{
	109	CntrlParam cb;
	110	struct SerShk *handshake;
	111
	112	cb.ioCRefNum = output_refnum;
	113	cb.csCode = 14;
	114	handshake = (struct SerShk *) &cb.csParam[0];
	115	handshake->fXOn = 0;
	116	handshake->fCTS = 0;
	117	handshake->xOn = 0;
	118	handshake->xOff = 0;
	119	handshake->errs = 0;
	120	handshake->evts = 0;
	121	handshake->fInX = 0;
	122	handshake->fDTR = 0;
	123	err = PBControl ((ParmBlkPtr) &cb, 0);
	124	if (err < 0)
	125	return (-1);
	126	}
	127	/* fake */
	128	scb->fd = 1;
	129	return 0;
	130	}
	131
	132	static int
	133	mac_noop (scb)
	134	serial_t scb;
	135	{
	136	return 0;
	137	}
	138
	139	static void
	140	mac_raw (scb)
	141	serial_t scb;
	142	{
	143	/* Always effectively in raw mode. */
	144	}
	145
	146	/* Read a character with user-specified timeout. TIMEOUT is number of seconds
	147	to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
	148	char if successful. Returns -2 if timeout expired, EOF if line dropped
	149	dead, or -3 for any other error (see errno in that case). */
	150
	151	static int
	152	mac_readchar (scb, timeout)
	153	serial_t scb;
	154	int timeout;
	155	{
	156	int status, n;
b8ec8d4a	157	/* time_t */ unsigned long start_time, now;
8dc3e3d7 SS	158	OSErr err;
	159	CntrlParam cb;
	160	IOParam pb;
	161
	162	if (scb->bufcnt-- > 0)
	163	return *scb->bufp++;
	164
b8ec8d4a	165	time (&start_time);
8dc3e3d7 SS	166
	167	while (1)
	168	{
	169	cb.ioCRefNum = input_refnum;
	170	cb.csCode = 2;
	171	err = PBStatus ((ParmBlkPtr) &cb, 0);
	172	if (err < 0)
	173	return SERIAL_ERROR;
	174	n = ((long ) &cb.csParam[0]);
	175	if (n > 0)
	176	{
	177	pb.ioRefNum = input_refnum;
	178	pb.ioBuffer = (Ptr) (scb->buf);
	179	pb.ioReqCount = (n > 64 ? 64 : n);
	180	err = PBRead ((ParmBlkPtr) &pb, 0);
	181	if (err < 0)
	182	return SERIAL_ERROR;
	183	scb->bufcnt = pb.ioReqCount;
	184	scb->bufcnt--;
	185	scb->bufp = scb->buf;
	186	return *scb->bufp++;
	187	}
	188	else if (timeout == 0)
	189	return SERIAL_TIMEOUT;
	190	else if (timeout == -1)
	191	;
	192	else
	193	{
	194	time (&now);
b8ec8d4a	195	if (now > start_time + timeout)
8dc3e3d7	196	return SERIAL_TIMEOUT;
8dc3e3d7	197	}
e70a10c3	198	PROGRESS (1);
8dc3e3d7 SS	199	}
	200	}
	201
	202	/* mac_{get set}_tty_state() are both dummys to fill out the function
	203	vector. Someday, they may do something real... */
	204
	205	static serial_ttystate
	206	mac_get_tty_state (scb)
	207	serial_t scb;
	208	{
	209	struct mac_ttystate *state;
	210
	211	state = (struct mac_ttystate ) xmalloc (sizeof state);
	212
	213	return (serial_ttystate) state;
	214	}
	215
	216	static int
	217	mac_set_tty_state (scb, ttystate)
	218	serial_t scb;
	219	serial_ttystate ttystate;
	220	{
	221	return 0;
	222	}
	223
	224	static int
	225	mac_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
	226	serial_t scb;
	227	serial_ttystate new_ttystate;
	228	serial_ttystate old_ttystate;
	229	{
	230	return 0;
	231	}
	232
	233	static void
	234	mac_print_tty_state (scb, ttystate)
	235	serial_t scb;
	236	serial_ttystate ttystate;
	237	{
	238	/* Nothing to print. */
	239	return;
	240	}
	241
8befb594 SS	242	/* If there is a tricky formula to relate real baud rates
	243	to what the serial driver wants, we should use it. Until
	244	we get one, this table will have to do. */
	245
	246	static struct {
	247	int real_rate;
	248	int bits;
	249	} mac_baud_rate_table[] = {
	250	{ 57600, baud57600 },
e33c359d	251	{ 38400, 1 },
8befb594 SS	252	{ 19200, baud19200 },
	253	{ 9600, baud9600 },
	254	{ 7200, baud7200 },
	255	{ 4800, baud4800 },
	256	{ 3600, baud3600 },
	257	{ 2400, baud2400 },
	258	{ 1800, baud1800 },
	259	{ 1200, baud1200 },
	260	{ 600, baud600 },
	261	{ 300, baud300 },
	262	{ 0, 0 }
	263	};
	264
8dc3e3d7 SS	265	static int
	266	mac_set_baud_rate (scb, rate)
	267	serial_t scb;
	268	int rate;
	269	{
8befb594 SS	270	int i, bits;
	271
	272	for (i = 0; mac_baud_rate_table[i].real_rate != 0; ++i)
	273	{
	274	if (mac_baud_rate_table[i].real_rate == rate)
	275	{
	276	bits = mac_baud_rate_table[i].bits;
	277	break;
	278	}
	279	}
	280	SerReset (input_refnum, stop10\|noParity\|data8\|bits);
	281	SerReset (output_refnum, stop10\|noParity\|data8\|bits);
8dc3e3d7 SS	282	}
8dc3e3d7 SS	283
85c8b135 SG	284	static int
	285	mac_set_stop_bits (scb, num)
	286	serial_t scb;
	287	int num;
	288	{
	289	return 0;
	290	}
	291
58c0b523 SS	292	int first_mac_write = 0;
58c0b523 SS	293
8dc3e3d7 SS	294	static int
	295	mac_write (scb, str, len)
	296	serial_t scb;
	297	const char *str;
	298	int len;
	299	{
	300	OSErr err;
	301	IOParam pb;
	302
b8ec8d4a	303	if (first_mac_write++ < 4)
58c0b523	304	{
e70a10c3	305	sleep (1);
58c0b523	306	}
8dc3e3d7 SS	307	pb.ioRefNum = output_refnum;
	308	pb.ioBuffer = (Ptr) str;
	309	pb.ioReqCount = len;
	310	err = PBWrite ((ParmBlkPtr) &pb, 0);
	311	if (err < 0)
	312	{
	313	return 1;
	314	}
	315	return 0;
	316	}
	317
	318	static void
b8ec8d4a	319	mac_close (serial_t scb)
8dc3e3d7 SS	320	{
	321	if (input_refnum)
	322	{
	323	if (1 /* custom buffer */)
	324	SerSetBuf (input_refnum, mac_input_buffer, 0);
	325	CloseDriver (input_refnum);
	326	input_refnum = 0;
	327	}
	328	if (output_refnum)
	329	{
	330	if (0 /* custom buffer */)
15aec61c	331	SerSetBuf (input_refnum, mac_output_buffer, 0);
8dc3e3d7 SS	332	CloseDriver (output_refnum);
	333	output_refnum = 0;
	334	}
	335	}
	336
	337	static struct serial_ops mac_ops =
	338	{
	339	"hardwire",
	340	0,
	341	mac_open,
	342	mac_close,
	343	mac_readchar,
	344	mac_write,
	345	mac_noop, /* flush output */
	346	mac_noop, /* flush input */
	347	mac_noop, /* send break -- currently only for nindy */
	348	mac_raw,
	349	mac_get_tty_state,
	350	mac_set_tty_state,
	351	mac_print_tty_state,
	352	mac_noflush_set_tty_state,
	353	mac_set_baud_rate,
85c8b135	354	mac_set_stop_bits,
3ffbdf15	355	mac_noop, /* wait for output to drain */
8dc3e3d7 SS	356	};
	357
	358	void
	359	_initialize_ser_mac ()
	360	{
	361	serial_add_interface (&mac_ops);
	362	}