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