From 838ae13dc4ab603f1efdf1da653e2ca1b7b009e1 Mon Sep 17 00:00:00 2001 From: Stan Shebs Date: Fri, 16 Apr 1999 01:33:56 +0000 Subject: Initial revision --- gdb/ser-mac.c | 362 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 gdb/ser-mac.c (limited to 'gdb/ser-mac.c') diff --git a/gdb/ser-mac.c b/gdb/ser-mac.c new file mode 100644 index 00000000000..df0040edbf2 --- /dev/null +++ b/gdb/ser-mac.c @@ -0,0 +1,362 @@ +/* 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 +#include +/* 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); +} -- cgit v1.2.1