OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [serial.h] - Blame information for rev 578

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/* Remote serial support interface definitions for GDB, the GNU Debugger.
2
   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
3
   Free Software Foundation, Inc.
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
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#ifndef SERIAL_H
23
#define SERIAL_H
24
 
25
/* For most routines, if a failure is indicated, then errno should be
26
   examined.  */
27
 
28
/* Terminal state pointer.  This is specific to each type of
29
   interface. */
30
 
31
typedef void *serial_ttystate;
32
struct _serial_t;
33
typedef struct _serial_t *serial_t;
34
 
35
/* Try to open NAME.  Returns a new serial_t on success, NULL on
36
   failure. */
37
 
38
extern serial_t serial_open (const char *name);
39
#define SERIAL_OPEN(NAME) serial_open(NAME)
40
 
41
/* Open a new serial stream using a file handle.  */
42
 
43
extern serial_t serial_fdopen (const int fd);
44
#define SERIAL_FDOPEN(FD) serial_fdopen(FD)
45
 
46
/* Push out all buffers, close the device and destroy SERIAL_T. */
47
 
48
extern void serial_close (serial_t);
49
#define SERIAL_CLOSE(SERIAL_T) serial_close ((SERIAL_T))
50
 
51
/* Push out all buffers and destroy SERIAL_T without closing the
52
   device.  */
53
 
54
extern void serial_un_fdopen (serial_t scb);
55
#define SERIAL_UN_FDOPEN(SERIAL_T) serial_un_fdopen ((SERIAL_T))
56
 
57
/* Read one char from the serial device with TIMEOUT seconds to wait
58
   or -1 to wait forever.  Use timeout of 0 to effect a poll.
59
   Infinite waits are not permitted. Returns unsigned char if ok, else
60
   one of the following codes.  Note that all error return-codes are
61
   guaranteed to be < 0. */
62
 
63
enum serial_rc {
64
  SERIAL_ERROR = -1,    /* General error. */
65
  SERIAL_TIMEOUT = -2,  /* Timeout or data-not-ready during read.
66
                           Unfortunately, through ui_loop_hook(), this
67
                           can also be a QUIT indication.  */
68
  SERIAL_EOF = -3       /* General end-of-file or remote target
69
                           connection closed, indication.  Includes
70
                           things like the line dropping dead. */
71
};
72
 
73
extern int serial_readchar (serial_t scb, int timeout);
74
#define SERIAL_READCHAR(SERIAL_T, TIMEOUT) serial_readchar ((SERIAL_T), (TIMEOUT))
75
 
76
/* Write LEN chars from STRING to the port SERIAL_T.  Returns 0 for
77
   success, non-zero for failure.  */
78
 
79
extern int serial_write (serial_t scb, const char *str, int len);
80
#define SERIAL_WRITE(SERIAL_T, STRING,LEN)  serial_write (SERIAL_T, STRING, LEN)
81
 
82
/* Write a printf style string onto the serial port. */
83
 
84
extern void serial_printf (serial_t desc, const char *,...) ATTR_FORMAT (printf, 2, 3);
85
 
86
/* Allow pending output to drain. */
87
 
88
extern int serial_drain_output (serial_t);
89
#define SERIAL_DRAIN_OUTPUT(SERIAL_T) serial_drain_output ((SERIAL_T))
90
 
91
/* Flush (discard) pending output.  Might also flush input (if this
92
   system can't flush only output).  */
93
 
94
extern int serial_flush_output (serial_t);
95
#define SERIAL_FLUSH_OUTPUT(SERIAL_T) serial_flush_output ((SERIAL_T))
96
 
97
/* Flush pending input.  Might also flush output (if this system can't
98
   flush only input).  */
99
 
100
extern int serial_flush_input (serial_t);
101
#define SERIAL_FLUSH_INPUT(SERIAL_T) serial_flush_input ((SERIAL_T))
102
 
103
/* Send a break between 0.25 and 0.5 seconds long.  */
104
 
105
extern int serial_send_break (serial_t scb);
106
#define SERIAL_SEND_BREAK(SERIAL_T) serial_send_break (SERIAL_T)
107
 
108
/* Turn the port into raw mode. */
109
 
110
extern void serial_raw (serial_t scb);
111
#define SERIAL_RAW(SERIAL_T) serial_raw ((SERIAL_T))
112
 
113
/* Return a pointer to a newly malloc'd ttystate containing the state
114
   of the tty.  */
115
 
116
extern serial_ttystate serial_get_tty_state (serial_t scb);
117
#define SERIAL_GET_TTY_STATE(SERIAL_T) serial_get_tty_state ((SERIAL_T))
118
 
119
/* Set the state of the tty to TTYSTATE.  The change is immediate.
120
   When changing to or from raw mode, input might be discarded.
121
   Returns 0 for success, negative value for error (in which case
122
   errno contains the error).  */
123
 
124
extern int serial_set_tty_state (serial_t scb, serial_ttystate ttystate);
125
#define SERIAL_SET_TTY_STATE(SERIAL_T, TTYSTATE) serial_set_tty_state ((SERIAL_T), (TTYSTATE))
126
 
127
/* printf_filtered a user-comprehensible description of ttystate on
128
   the specified STREAM. FIXME: At present this sends output to the
129
   default stream - GDB_STDOUT. */
130
 
131
extern void serial_print_tty_state (serial_t scb, serial_ttystate ttystate, struct ui_file *);
132
#define SERIAL_PRINT_TTY_STATE(SERIAL_T, TTYSTATE, STREAM) serial_print_tty_state ((SERIAL_T), (TTYSTATE), (STREAM))
133
 
134
/* Set the tty state to NEW_TTYSTATE, where OLD_TTYSTATE is the
135
   current state (generally obtained from a recent call to
136
   SERIAL_GET_TTY_STATE), but be careful not to discard any input.
137
   This means that we never switch in or out of raw mode, even if
138
   NEW_TTYSTATE specifies a switch.  */
139
 
140
extern int serial_noflush_set_tty_state (serial_t scb, serial_ttystate new_ttystate, serial_ttystate old_ttystate);
141
#define SERIAL_NOFLUSH_SET_TTY_STATE(SERIAL_T, NEW_TTYSTATE, OLD_TTYSTATE) \
142
serial_noflush_set_tty_state ((SERIAL_T), (NEW_TTYSTATE), (OLD_TTYSTATE))
143
 
144
/* Set the baudrate to the decimal value supplied.  Returns 0 for
145
   success, -1 for failure.  */
146
 
147
extern int serial_setbaudrate (serial_t scb, int rate);
148
#define SERIAL_SETBAUDRATE(SERIAL_T, RATE) serial_setbaudrate ((SERIAL_T), (RATE))
149
 
150
/* Set the number of stop bits to the value specified.  Returns 0 for
151
   success, -1 for failure.  */
152
 
153
#define SERIAL_1_STOPBITS 1
154
#define SERIAL_1_AND_A_HALF_STOPBITS 2  /* 1.5 bits, snicker... */
155
#define SERIAL_2_STOPBITS 3
156
 
157
extern int serial_setstopbits (serial_t scb, int num);
158
#define SERIAL_SETSTOPBITS(SERIAL_T, NUM) serial_setstopbits ((SERIAL_T), (NUM))
159
 
160
/* Asynchronous serial interface: */
161
 
162
/* Can the serial device support asynchronous mode? */
163
 
164
extern int serial_can_async_p (serial_t scb);
165
#define SERIAL_CAN_ASYNC_P(SERIAL_T) serial_can_async_p ((SERIAL_T))
166
 
167
/* Has the serial device been put in asynchronous mode? */
168
 
169
extern int serial_is_async_p (serial_t scb);
170
#define SERIAL_IS_ASYNC_P(SERIAL_T) serial_is_async_p ((SERIAL_T))
171
 
172
/* For ASYNC enabled devices, register a callback and enable
173
   asynchronous mode.  To disable asynchronous mode, register a NULL
174
   callback. */
175
 
176
typedef void (serial_event_ftype) (serial_t scb, void *context);
177
extern void serial_async (serial_t scb, serial_event_ftype *handler, void *context);
178
#define SERIAL_ASYNC(SERIAL_T, HANDLER, CONTEXT) serial_async ((SERIAL_T), (HANDLER), (CONTEXT)) 
179
 
180
/* Provide direct access to the underlying FD (if any) used to
181
   implement the serial device.  This interface is clearly
182
   deprecated. Will call internal_error() if the operation isn't
183
   applicable to the current serial device. */
184
 
185
extern int deprecated_serial_fd (serial_t scb);
186
#define DEPRECATED_SERIAL_FD(SERIAL_T) deprecated_serial_fd ((SERIAL_T))
187
 
188
/* Trace/debug mechanism.
189
 
190
   SERIAL_DEBUG() enables/disables internal debugging.
191
   SERIAL_DEBUG_P() indicates the current debug state. */
192
 
193
extern void serial_debug (serial_t scb, int debug_p);
194
#define SERIAL_DEBUG(SERIAL_T, DEBUG_P) serial_debug ((SERIAL_T), (DEBUG_P))
195
 
196
extern int serial_debug_p (serial_t scb);
197
#define SERIAL_DEBUG_P(SERIAL_T) serial_debug_p ((SERIAL_T))
198
 
199
 
200
/* Details of an instance of a serial object */
201
 
202
struct _serial_t
203
  {
204
    int fd;                     /* File descriptor */
205
    struct serial_ops *ops;     /* Function vector */
206
    void *state;                /* Local context info for open FD */
207
    serial_ttystate ttystate;   /* Not used (yet) */
208
    int bufcnt;                 /* Amount of data remaining in receive
209
                                   buffer.  -ve for sticky errors. */
210
    unsigned char *bufp;        /* Current byte */
211
    unsigned char buf[BUFSIZ];  /* Da buffer itself */
212
    int current_timeout;        /* (ser-unix.c termio{,s} only), last
213
                                   value of VTIME */
214
    int timeout_remaining;      /* (ser-unix.c termio{,s} only), we
215
                                   still need to wait for this many
216
                                   more seconds.  */
217
    char *name;                 /* The name of the device or host */
218
    struct _serial_t *next;     /* Pointer to the next serial_t */
219
    int refcnt;                 /* Number of pointers to this block */
220
    int debug_p;                /* Trace this serial devices operation. */
221
    int async_state;            /* Async internal state. */
222
    void *async_context;        /* Async event thread's context */
223
    serial_event_ftype *async_handler;/* Async event handler */
224
  };
225
 
226
struct serial_ops
227
  {
228
    char *name;
229
    struct serial_ops *next;
230
    int (*open) (serial_t, const char *name);
231
    void (*close) (serial_t);
232
    int (*readchar) (serial_t, int timeout);
233
    int (*write) (serial_t, const char *str, int len);
234
    /* Discard pending output */
235
    int (*flush_output) (serial_t);
236
    /* Discard pending input */
237
    int (*flush_input) (serial_t);
238
    int (*send_break) (serial_t);
239
    void (*go_raw) (serial_t);
240
    serial_ttystate (*get_tty_state) (serial_t);
241
    int (*set_tty_state) (serial_t, serial_ttystate);
242
    void (*print_tty_state) (serial_t, serial_ttystate, struct ui_file *);
243
    int (*noflush_set_tty_state) (serial_t, serial_ttystate, serial_ttystate);
244
    int (*setbaudrate) (serial_t, int rate);
245
    int (*setstopbits) (serial_t, int num);
246
    /* Wait for output to drain */
247
    int (*drain_output) (serial_t);
248
    /* Change the serial device into/out of asynchronous mode, call
249
       the specified function when ever there is something
250
       interesting. */
251
    void (*async) (serial_t scb, int async_p);
252
  };
253
 
254
/* Add a new serial interface to the interface list */
255
 
256
extern void serial_add_interface (struct serial_ops * optable);
257
 
258
/* File in which to record the remote debugging session */
259
 
260
extern void serial_log_command (const char *);
261
 
262
#endif /* SERIAL_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.