-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathNullAPI.c
185 lines (151 loc) · 7.01 KB
/
NullAPI.c
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/*
Copyright 2004-2005 Ronald S. Burkey <[email protected]>
This file is part of yaAGC.
yaAGC 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.
yaAGC 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 yaAGC; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
In addition, as a special exception, Ronald S. Burkey gives permission to
link the code of this program with the Orbiter SDK library (or with
modified versions of the Orbiter SDK library that use the same license as
the Orbiter SDK library), and distribute linked combinations including
the two. You must obey the GNU General Public License in all respects for
all of the code used other than the Orbiter SDK library. If you modify
this file, you may extend this exception to your version of the file,
but you are not obligated to do so. If you do not wish to do so, delete
this exception statement from your version.
Filename: NullAPI.c
Purpose: This is sort of a template that shows how to write functions
that customize the yaAGC-to-peripheral interface.
(I advise you not to, unless you are using yaAGC as
embedded firmware, but I show you how to do it
anyway.)
Compiler: GNU gcc.
Contact: Ron Burkey <[email protected]>
Reference: http://www.ibiblio.org/apollo/index.html
Mods: 08/18/04 RSB. Created.
02/27/05 RSB Added the license exception, as required by
the GPL, for linking to Orbiter SDK libraries.
05/14/05 RSB Corrected website references.
05/31/05 RSB Added ShiftToDeda.
*/
#ifdef WIN32
typedef unsigned short uint16_t;
#endif
#include "yaAGC.h"
#include "agc_engine.h"
//-----------------------------------------------------------------------------
// Any kind of setup needed by your i/o-channel model.
static int ChannelIsSetUp = 0;
static void
ChannelSetup (agc_t *State)
{
ChannelIsSetUp = 1;
// ... anything you like ...
}
//-----------------------------------------------------------------------------
// The simulated CPU in yaAGC calls this function whenever it wants to write
// output data to an "i/o channel", other than i/o channels 1 and 2, which are
// overlapped with the L and Q central registers. For example, in an embedded
// design, this would physically control the individual electrical signals
// comprising the i/o port. In my recommended reference design (see
// SocketAPI.c) data would be streamed out a socket connection from a port.
// In a customized version, FOR EXAMPLE, data might be written to a shared
// memory array, and other execution threads might be woken up to process the
// changed data.
void
ChannelOutput (agc_t * State, int Channel, int Value)
{
if (!ChannelIsSetUp)
ChannelSetup (State);
// ... anything you like ...
// You don't need to worry about channels 1 and 2 here.
// By the way, note that some output channels are latched by relays
// external to the CPU. For example, 4 bits of the Value of
// Channel 10 (octal) select one of 16 rows of latches. Therefore,
// the 15-bit channel 10 is effectively 16 separate 11-bit registers.
// You may need to account for this in your model.
}
//----------------------------------------------------------------------
// The simulated CPU in yaAGC calls this function to check for input data
// once for each call to agc_engin. This input data may be of two kinds:
// 1. Data available on an "i/o channel"; in this case, a value
// of 0 is returned; you can handle as much or as little data
// of this kind in any given invocation; or
// 2. A request for an "unprogrammed sequence" to automatically
// increment or decrement a counter. In this case a value of
// 1 is returned. The function must return immediately upon
// one of these requests, in order ot preserve system timing.
// The former type of data is supposed to be directly written to the
// array State->InputChannel[], while the latter is supposed to call the
// function UnprogrammedIncrement() to handle the actual incrementing.
// ChannelInput() has the responsibility of raising an interrupt-request
// flag (in the array State->InterruptRequests[]) if the i/o channel
// data is supposed to cause an interrupt. (An example would
// be if the input data represented a DSKY keystroke.) Interrupt-raising
// due to overflow of counters is handled automatically by the function
// UnprogrammedChannel() and doesn't need to be addressed directly.
//
// For example, in an embedded design, this input data would reflect the
// physical states of individual electrical signals.
// In my recommended reference design (see SocketAPI.c) the data would be
// taken from an incoming stream of a socket connection to a port.
// In a customized version, FOR EXAMPLE, data might indicate changes in a
// shared memory array partially controlled by other execution threads.
//
// Note: You are guaranteed that yaAGC processes at least one instruction
// between any two calls to ChannelInput.
int
ChannelInput (agc_t *State)
{
int RetVal = 0;
if (!ChannelIsSetUp)
ChannelSetup (State);
// If there are changes to the input channels, write the data
// directly to the array State->InputChannel[]. Don't forget to
// raise a flag in State->InterruptRequests if the incoming data
// is supposed to do that. (Mainly, DSKY keystrokes.)
// If the inputs request unprogrammed counter-increment sequences,
// then call the function UnprogrammedChannel(State,Counter,IncType)
// to process them. The different unprogrammed sequences are
// related to the IncTypes as follows:
// PINC 000
// PCDU 001
// MINC 002
// MCDU 003
// DINC 004
// SHINC 005
// SHANC 006
// (Refer to the developer page on www.ibiblio.org/apollo/index.html.)
// Only registers 32 (octal) through 60 (octal) may actually used as
// counters, and not all of them. (Refer to the AGC assembly-language
// manual at www.ibiblio.org/apollo/index.html.)
return (RetVal);
}
//----------------------------------------------------------------------
// A function for handling anything routinely needed (i.e., executed on
// a regular schedule) by the i/o channel model of ChannelInput and
// ChannelOutput. There are no good reasons that I know of why this
// would be needed, other than by my reference model (see SocketAPI.c),
// so you might just want to let this empty.
void
ChannelRoutine (agc_t *State)
{
if (!ChannelIsSetUp)
ChannelSetup (State);
// ... anything you like ...
}
//----------------------------------------------------------------------
// This function is useful only for debugging the socket interface, and
// so can be left as-is.
void
ShiftToDeda (agc_t *State, int Data)
{
}