1 /* Remote serial interface for local (hardwired) serial ports for Macintosh.
2 Copyright 1994, 2000 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Stan Shebs.
5 This file is part of GDB.
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.
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.
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
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
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"
31 /* This is unused for now. We just return a placeholder. */
38 static int mac_open (serial_t scb, const char *name);
39 static void mac_raw (serial_t scb);
40 static int mac_readchar (serial_t scb, int timeout);
41 static int mac_setbaudrate (serial_t scb, int rate);
42 static int mac_write (serial_t scb, const char *str, int len);
43 static void mac_close (serial_t scb);
44 static serial_ttystate mac_get_tty_state (serial_t scb);
45 static int mac_set_tty_state (serial_t scb, serial_ttystate state);
46 static char *aptr (short p);
51 char *mac_input_buffer;
52 char *mac_output_buffer;
55 mac_open (serial_t scb, const char *name)
59 /* Alloc buffer space first - that way any allocation failures are
60 intercepted before the serial driver gets involved. */
61 if (mac_input_buffer == NULL)
62 mac_input_buffer = (char *) xmalloc (4096);
63 /* Match on a name and open a port. */
64 if (strcmp (name, "modem") == 0)
66 err = OpenDriver ("\p.AIn", &input_refnum);
71 err = OpenDriver ("\p.AOut", &output_refnum);
74 CloseDriver (input_refnum);
78 else if (strcmp (name, "printer") == 0)
80 err = OpenDriver ("\p.BIn", &input_refnum);
85 err = OpenDriver ("\p.BOut", &output_refnum);
88 CloseDriver (input_refnum);
97 error ("You must specify a valid serial port name; your choices are `modem' or `printer'.");
101 /* We got something open. */
102 if (1 /* using custom buffer */ )
103 SerSetBuf (input_refnum, mac_input_buffer, 4096);
104 /* Set to a GDB-preferred state. */
105 SerReset (input_refnum, stop10 | noParity | data8 | baud9600);
106 SerReset (output_refnum, stop10 | noParity | data8 | baud9600);
109 struct SerShk *handshake;
111 cb.ioCRefNum = output_refnum;
113 handshake = (struct SerShk *) &cb.csParam[0];
122 err = PBControl ((ParmBlkPtr) & cb, 0);
132 mac_noop (serial_t scb)
138 mac_raw (serial_t scb)
140 /* Always effectively in raw mode. */
143 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
144 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
145 char if successful. Returns -2 if timeout expired, EOF if line dropped
146 dead, or -3 for any other error (see errno in that case). */
149 mac_readchar (serial_t scb, int timeout)
152 /* time_t */ unsigned long start_time, now;
157 if (scb->bufcnt-- > 0)
164 cb.ioCRefNum = input_refnum;
166 err = PBStatus ((ParmBlkPtr) & cb, 0);
169 n = *((long *) &cb.csParam[0]);
172 pb.ioRefNum = input_refnum;
173 pb.ioBuffer = (Ptr) (scb->buf);
174 pb.ioReqCount = (n > 64 ? 64 : n);
175 err = PBRead ((ParmBlkPtr) & pb, 0);
178 scb->bufcnt = pb.ioReqCount;
180 scb->bufp = scb->buf;
183 else if (timeout == 0)
184 return SERIAL_TIMEOUT;
185 else if (timeout == -1)
190 if (now > start_time + timeout)
191 return SERIAL_TIMEOUT;
197 /* mac_{get set}_tty_state() are both dummys to fill out the function
198 vector. Someday, they may do something real... */
200 static serial_ttystate
201 mac_get_tty_state (serial_t scb)
203 struct mac_ttystate *state;
205 state = (struct mac_ttystate *) xmalloc (sizeof *state);
207 return (serial_ttystate) state;
211 mac_set_tty_state (serial_t scb, serial_ttystate ttystate)
217 mac_noflush_set_tty_state (serial_t scb, serial_ttystate new_ttystate,
218 serial_ttystate old_ttystate)
224 mac_print_tty_state (serial_t scb,
225 serial_ttystate ttystate,
226 struct ui_file *stream)
228 /* Nothing to print. */
232 /* If there is a tricky formula to relate real baud rates
233 to what the serial driver wants, we should use it. Until
234 we get one, this table will have to do. */
241 mac_baud_rate_table[] =
297 mac_set_baud_rate (serial_t scb, int rate)
301 for (i = 0; mac_baud_rate_table[i].real_rate != 0; ++i)
303 if (mac_baud_rate_table[i].real_rate == rate)
305 bits = mac_baud_rate_table[i].bits;
309 SerReset (input_refnum, stop10 | noParity | data8 | bits);
310 SerReset (output_refnum, stop10 | noParity | data8 | bits);
314 mac_set_stop_bits (serial_t scb, int num)
319 int first_mac_write = 0;
322 mac_write (serial_t scb, const char *str, int len)
327 if (first_mac_write++ < 4)
331 pb.ioRefNum = output_refnum;
332 pb.ioBuffer = (Ptr) str;
334 err = PBWrite ((ParmBlkPtr) & pb, 0);
343 mac_close (serial_t scb)
347 if (1 /* custom buffer */ )
348 SerSetBuf (input_refnum, mac_input_buffer, 0);
349 CloseDriver (input_refnum);
354 if (0 /* custom buffer */ )
355 SerSetBuf (input_refnum, mac_output_buffer, 0);
356 CloseDriver (output_refnum);
361 static struct serial_ops mac_ops =
369 mac_noop, /* flush output */
370 mac_noop, /* flush input */
371 mac_noop, /* send break -- currently only for nindy */
376 mac_noflush_set_tty_state,
379 mac_noop, /* wait for output to drain */
383 _initialize_ser_mac (void)
385 serial_add_interface (&mac_ops);