1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/* $Id$ */
/* @file
* User Console Interface
*/
#ifndef __CONSOLE_HH__
#define __CONSOLE_HH__
#include <iostream>
#include "base/circlebuf.hh"
#include "cpu/intr_control.hh"
#include "base/pollevent.hh"
#include "base/socket.hh"
#include "sim/sim_object.hh"
class ConsoleListener;
class SimConsole : public SimObject
{
protected:
class Event : public PollEvent
{
protected:
SimConsole *cons;
public:
Event(SimConsole *c, int fd, int e);
void process(int revent);
};
friend class Event;
Event *event;
protected:
int number;
int in_fd;
int out_fd;
protected:
ConsoleListener *listener;
public:
SimConsole(const std::string &name, const std::string &file, int num);
~SimConsole();
protected:
CircleBuf txbuf;
CircleBuf rxbuf;
std::ostream *outfile;
public:
///////////////////////
// Terminal Interface
void attach(int fd, ConsoleListener *l = NULL) { attach(fd, fd, l); }
void attach(int in, int out, ConsoleListener *l = NULL);
void detach();
void data();
void close();
void read(uint8_t &c) { read(&c, 1); }
size_t read(uint8_t *buf, size_t len);
void write(uint8_t c) { write(&c, 1); }
size_t write(const uint8_t *buf, size_t len);
void configTerm();
protected:
// interrupt status/enable
int intr_status;
int intr_enable;
// interrupt handle
IntrControl *intr;
public:
/////////////////
// OS interface
// Input a character from the console. Returns the character (if
// any) or -1 if there is no character pending on this console. If
// no further characters are pending, the (input) interrupt is
// cleared.
int in();
// Output a character to the console. This never fails, as this
// device doesn't model finite buffering capacity.
void out(char c);
void simple(char c);
enum {
TransmitInterrupt = 1,
ReceiveInterrupt = 2
};
// Read the current interrupt status of this console.
int intStatus();
// Set the interrupt enable bits.
int clearInt(int i);
void raiseInt(int i);
void initInt(IntrControl *i);
void setInt(int bits);
virtual void serialize();
virtual void unserialize(IniFile &db, const std::string &category,
ConfigNode *node);
};
class ConsoleListener : public SimObject
{
protected:
class Event : public PollEvent
{
protected:
ConsoleListener *listener;
public:
Event(ConsoleListener *l, int fd, int e)
: PollEvent(fd, e), listener(l) {}
void process(int revent);
};
friend class Event;
Event *event;
typedef std::list<SimConsole *> list_t;
typedef list_t::iterator iter_t;
list_t ConsoleList;
protected:
ListenSocket listener;
public:
ConsoleListener(const std::string &name);
~ConsoleListener();
void add(SimConsole *cons);
void accept();
void listen(int port);
};
#endif // __CONSOLE_HH__
|
