1 /*  This file is part of the program psim.
2 
3     Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
4 
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9 
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14 
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19     */
20 
21 
22 #ifndef _DEVICE_TABLE_H_
23 #define _DEVICE_TABLE_H_
24 
25 #include "basics.h"
26 #include "device.h"
27 #include "tree.h"
28 
29 #ifdef HAVE_STRING_H
30 #include <string.h>
31 #else
32 #ifdef HAVE_STRINGS_H
33 #include <strings.h>
34 #endif
35 #endif
36 
37 
38 typedef struct _device_callbacks device_callbacks;
39 
40 
41 /* The creator, returns a pointer to any data that should be allocated
42    once during (multiple) simulation runs */
43 
44 typedef void *(device_creator)
45      (const char *name,
46       const device_unit *unit_address,
47       const char *args);
48 
49 
50 /* two stages of initialization */
51 
52 typedef void (device_init_callback)
53      (device *me);
54 
55 typedef struct _device_init_callbacks {
56   device_init_callback *address; /* NULL - ignore */
57   device_init_callback *data; /* NULL - ignore */
58 } device_init_callbacks;
59 
60 
61 /* attaching/detaching a devices address space to its parent */
62 
63 typedef void (device_address_callback)
64      (device *me,
65       attach_type attach,
66       int space,
67       unsigned_word addr,
68       unsigned nr_bytes,
69       access_type access,
70       device *client); /*callback/default*/
71 
72 typedef struct _device_address_callbacks {
73   device_address_callback *attach;
74   device_address_callback *detach;
75 } device_address_callbacks;
76 
77 
78 /* I/O operations - from parent */
79 
80 typedef unsigned (device_io_read_buffer_callback)
81      (device *me,
82       void *dest,
83       int space,
84       unsigned_word addr,
85       unsigned nr_bytes,
86       cpu *processor,
87       unsigned_word cia);
88 
89 typedef unsigned (device_io_write_buffer_callback)
90      (device *me,
91       const void *source,
92       int space,
93       unsigned_word addr,
94       unsigned nr_bytes,
95       cpu *processor,
96       unsigned_word cia);
97 
98 typedef struct _device_io_callbacks { /* NULL - error */
99   device_io_read_buffer_callback *read_buffer;
100   device_io_write_buffer_callback *write_buffer;
101 } device_io_callbacks;
102 
103 
104 /* DMA transfers by a device via its parent */
105 
106 typedef unsigned (device_dma_read_buffer_callback)
107      (device *me,
108       void *dest,
109       int space,
110       unsigned_word addr,
111       unsigned nr_bytes);
112 
113 typedef unsigned (device_dma_write_buffer_callback)
114      (device *me,
115       const void *source,
116       int space,
117       unsigned_word addr,
118       unsigned nr_bytes,
119       int violate_read_only_section);
120 
121 typedef struct _device_dma_callbacks { /* NULL - error */
122   device_dma_read_buffer_callback *read_buffer;
123   device_dma_write_buffer_callback *write_buffer;
124 } device_dma_callbacks;
125 
126 
127 /* Interrupts */
128 
129 typedef void (device_interrupt_event_callback)
130      (device *me,
131       int my_port,
132       device *source,
133       int source_port,
134       int level,
135       cpu *processor,
136       unsigned_word cia);
137 
138 typedef void (device_child_interrupt_event_callback)
139      (device *me,
140       device *parent,
141       device *source,
142       int source_port,
143       int level,
144       cpu *processor,
145       unsigned_word cia);
146 
147 typedef struct _device_interrupt_port_descriptor {
148   const char *name;
149   int number;
150   int nr_ports;
151   port_direction direction;
152 } device_interrupt_port_descriptor;
153 
154 typedef struct _device_interrupt_callbacks {
155   device_interrupt_event_callback *event;
156   device_child_interrupt_event_callback *child_event;
157   const device_interrupt_port_descriptor *ports;
158 } device_interrupt_callbacks;
159 
160 
161 /* symbolic value decoding */
162 
163 typedef int (device_unit_decode_callback)
164      (device *bus,
165       const char *unit,
166       device_unit *address);
167 
168 typedef int (device_unit_encode_callback)
169      (device *bus,
170       const device_unit *unit_address,
171       char *buf,
172       int sizeof_buf);
173 
174 typedef int (device_address_to_attach_address_callback)
175      (device *bus,
176       const device_unit *address,
177       int *attach_space,
178       unsigned_word *attach_address,
179       device *client);
180 
181 typedef int (device_size_to_attach_size_callback)
182      (device *bus,
183       const device_unit *size,
184       unsigned *nr_bytes,
185       device *client);
186 
187 typedef struct _device_convert_callbacks {
188   device_unit_decode_callback *decode_unit;
189   device_unit_encode_callback *encode_unit;
190   device_address_to_attach_address_callback *address_to_attach_address;
191   device_size_to_attach_size_callback *size_to_attach_size;
192 } device_convert_callbacks;
193 
194 
195 /* instances */
196 
197 typedef void (device_instance_delete_callback)
198      (device_instance *instance);
199 
200 typedef int (device_instance_read_callback)
201      (device_instance *instance,
202       void *buf,
203       unsigned_word len);
204 
205 typedef int (device_instance_write_callback)
206      (device_instance *instance,
207       const void *buf,
208       unsigned_word len);
209 
210 typedef int (device_instance_seek_callback)
211      (device_instance *instance,
212       unsigned_word pos_hi,
213       unsigned_word pos_lo);
214 
215 typedef int (device_instance_method)
216      (device_instance *instance,
217       int n_stack_args,
218       unsigned_cell stack_args[/*n_stack_args*/],
219       int n_stack_returns,
220       unsigned_cell stack_returns[/*n_stack_returns*/]);
221 
222 typedef struct _device_instance_methods {
223   const char *name;
224   device_instance_method *method;
225 } device_instance_methods;
226 
227 struct _device_instance_callbacks { /* NULL - error */
228   device_instance_delete_callback *delete;
229   device_instance_read_callback *read;
230   device_instance_write_callback *write;
231   device_instance_seek_callback *seek;
232   const device_instance_methods *methods;
233 };
234 
235 typedef device_instance *(device_create_instance_callback)
236      (device *me,
237       const char *full_path,
238       const char *args);
239 
240 typedef device_instance *(package_create_instance_callback)
241      (device_instance *parent,
242       const char *args);
243 
244 
245 /* all else fails */
246 
247 typedef int (device_ioctl_callback)
248      (device *me,
249       cpu *processor,
250       unsigned_word cia,
251       device_ioctl_request request,
252       va_list ap);
253 
254 typedef void (device_usage_callback)
255      (int verbose);
256 
257 
258 /* the callbacks */
259 
260 struct _device_callbacks {
261 
262   /* initialization */
263   device_init_callbacks init;
264 
265   /* address/data config - from child */
266   device_address_callbacks address;
267 
268   /* address/data transfer - from parent */
269   device_io_callbacks io;
270 
271   /* address/data transfer - from child */
272   device_dma_callbacks dma;
273 
274   /* interrupt signalling */
275   device_interrupt_callbacks interrupt;
276 
277   /* bus address decoding */
278   device_convert_callbacks convert;
279 
280   /* instances */
281   device_create_instance_callback *instance_create;
282 
283   /* back door to anything we've forgot */
284   device_ioctl_callback *ioctl;
285   device_usage_callback *usage;
286 };
287 
288 
289 /* Table of all the devices and a function to lookup/create a device
290    from its name */
291 
292 typedef struct _device_descriptor device_descriptor;
293 struct _device_descriptor {
294   const char *name;
295   device_creator *creator;
296   const device_callbacks *callbacks;
297 };
298 
299 extern const device_descriptor *const device_table[];
300 #include "hw.h"
301 
302 
303 /* Pass through, ignore and generic callback functions.  A call going
304    towards the root device are passed on up, local calls are ignored
305    and call downs abort */
306 
307 extern device_address_callback passthrough_device_address_attach;
308 extern device_address_callback passthrough_device_address_detach;
309 extern device_dma_read_buffer_callback passthrough_device_dma_read_buffer;
310 extern device_dma_write_buffer_callback passthrough_device_dma_write_buffer;
311 
312 extern device_unit_decode_callback ignore_device_unit_decode;
313 
314 extern device_init_callback generic_device_init_address;
315 extern device_unit_decode_callback generic_device_unit_decode;
316 extern device_unit_encode_callback generic_device_unit_encode;
317 extern device_address_to_attach_address_callback generic_device_address_to_attach_address;
318 extern device_size_to_attach_size_callback generic_device_size_to_attach_size;
319 
320 
321 extern const device_callbacks passthrough_device_callbacks;
322 
323 #endif /* _DEVICE_TABLE_H_ */
324