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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [sim/] [common/] [hw-instances.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom
/*  This file is part of the program psim.
2
 
3
    Copyright (C) 1994-1998, 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
#include "hw-main.h"
23
#include "hw-base.h"
24
 
25
#include "sim-io.h"
26
#include "sim-assert.h"
27
 
28
struct hw_instance_data {
29
  hw_finish_instance_method *to_finish;
30
  struct hw_instance *instances;
31
};
32
 
33
static hw_finish_instance_method abort_hw_finish_instance;
34
 
35
void
36
create_hw_instance_data (struct hw *me)
37
{
38
  me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
39
  set_hw_finish_instance (me, abort_hw_finish_instance);
40
}
41
 
42
void
43
delete_hw_instance_data (struct hw *me)
44
{
45
  /* NOP */
46
}
47
 
48
 
49
static void
50
abort_hw_finish_instance (struct hw *hw,
51
                          struct hw_instance *instance)
52
{
53
  hw_abort (hw, "no instance finish method");
54
}
55
 
56
void
57
set_hw_finish_instance (struct hw *me,
58
                        hw_finish_instance_method *finish)
59
{
60
  me->instances_of_hw->to_finish = finish;
61
}
62
 
63
 
64
#if 0
65
void
66
clean_hw_instances (struct hw *me)
67
{
68
  struct hw_instance **instance = &me->instances;
69
  while (*instance != NULL)
70
    {
71
      struct hw_instance *old_instance = *instance;
72
      hw_instance_delete (old_instance);
73
      instance = &me->instances;
74
    }
75
}
76
#endif
77
 
78
 
79
void
80
hw_instance_delete (struct hw_instance *instance)
81
{
82
#if 1
83
  hw_abort (hw_instance_hw (instance), "not implemented");
84
#else
85
  struct hw *me = hw_instance_hw (instance);
86
  if (instance->to_instance_delete == NULL)
87
    hw_abort (me, "no delete method");
88
  instance->method->delete(instance);
89
  if (instance->args != NULL)
90
    zfree (instance->args);
91
  if (instance->path != NULL)
92
    zfree (instance->path);
93
  if (instance->child == NULL)
94
    {
95
      /* only remove leaf nodes */
96
      struct hw_instance **curr = &me->instances;
97
      while (*curr != instance)
98
        {
99
          ASSERT (*curr != NULL);
100
          curr = &(*curr)->next;
101
        }
102
      *curr = instance->next;
103
    }
104
  else
105
    {
106
      /* check it isn't in the instance list */
107
      struct hw_instance *curr = me->instances;
108
      while (curr != NULL)
109
        {
110
          ASSERT(curr != instance);
111
          curr = curr->next;
112
        }
113
      /* unlink the child */
114
      ASSERT (instance->child->parent == instance);
115
      instance->child->parent = NULL;
116
    }
117
  cap_remove (me->ihandles, instance);
118
  zfree (instance);
119
#endif
120
}
121
 
122
 
123
static int
124
panic_hw_instance_read (struct hw_instance *instance,
125
                        void *addr,
126
                        unsigned_word len)
127
{
128
  hw_abort (hw_instance_hw (instance), "no read method");
129
  return -1;
130
}
131
 
132
 
133
 
134
static int
135
panic_hw_instance_write (struct hw_instance *instance,
136
                         const void *addr,
137
                         unsigned_word len)
138
{
139
  hw_abort (hw_instance_hw (instance), "no write method");
140
  return -1;
141
}
142
 
143
 
144
static int
145
panic_hw_instance_seek (struct hw_instance *instance,
146
                        unsigned_word pos_hi,
147
                        unsigned_word pos_lo)
148
{
149
  hw_abort (hw_instance_hw (instance), "no seek method");
150
  return -1;
151
}
152
 
153
 
154
int
155
hw_instance_call_method (struct hw_instance *instance,
156
                         const char *method_name,
157
                         int n_stack_args,
158
                         unsigned_cell stack_args[/*n_stack_args*/],
159
                         int n_stack_returns,
160
                         unsigned_cell stack_returns[/*n_stack_args*/])
161
{
162
#if 1
163
  hw_abort (hw_instance_hw (instance), "not implemented");
164
  return -1;
165
#else
166
  struct hw *me = instance->owner;
167
  const hw_instance_methods *method = instance->method->methods;
168
  if (method == NULL)
169
    {
170
      hw_abort (me, "no methods (want %s)", method_name);
171
    }
172
  while (method->name != NULL)
173
    {
174
      if (strcmp(method->name, method_name) == 0)
175
        {
176
          return method->method (instance,
177
                                 n_stack_args, stack_args,
178
                                 n_stack_returns, stack_returns);
179
        }
180
      method++;
181
    }
182
  hw_abort (me, "no %s method", method_name);
183
  return 0;
184
#endif
185
}
186
 
187
 
188
#define set_hw_instance_read(instance, method)\
189
((instance)->to_instance_read = (method))
190
 
191
#define set_hw_instance_write(instance, method)\
192
((instance)->to_instance_write = (method))
193
 
194
#define set_hw_instance_seek(instance, method)\
195
((instance)->to_instance_seek = (method))
196
 
197
 
198
#if 0
199
static void
200
set_hw_instance_finish (struct hw *me,
201
                        hw_instance_finish_method *method)
202
{
203
  if (me->instances_of_hw == NULL)
204
    me->instances_of_hw = HW_ZALLOC (me, struct hw_instance_data);
205
  me->instances_of_hw->to_finish = method;
206
}
207
#endif
208
 
209
 
210
struct hw_instance *
211
hw_instance_create (struct hw *me,
212
                    struct hw_instance *parent,
213
                    const char *path,
214
                    const char *args)
215
{
216
  struct hw_instance *instance = ZALLOC (struct hw_instance);
217
  /*instance->unit*/
218
  /* link this instance into the devices list */
219
  instance->hw_of_instance = me;
220
  instance->parent_of_instance = NULL;
221
  /* link this instance into the front of the devices instance list */
222
  instance->sibling_of_instance = me->instances_of_hw->instances;
223
  me->instances_of_hw->instances = instance;
224
  if (parent != NULL)
225
    {
226
      ASSERT (parent->child_of_instance == NULL);
227
      parent->child_of_instance = instance;
228
      instance->parent_of_instance = parent;
229
    }
230
  instance->args_of_instance = hw_strdup (me, args);
231
  instance->path_of_instance = hw_strdup (me, path);
232
  set_hw_instance_read (instance, panic_hw_instance_read);
233
  set_hw_instance_write (instance, panic_hw_instance_write);
234
  set_hw_instance_seek (instance, panic_hw_instance_seek);
235
  hw_handle_add_ihandle (me, instance);
236
  me->instances_of_hw->to_finish (me, instance);
237
  return instance;
238
}
239
 
240
 
241
struct hw_instance *
242
hw_instance_interceed (struct hw_instance *parent,
243
                       const char *path,
244
                       const char *args)
245
{
246
#if 1
247
  return NULL;
248
#else
249
  struct hw_instance *instance = ZALLOC (struct hw_instance);
250
  /*instance->unit*/
251
  /* link this instance into the devices list */
252
  if (me != NULL)
253
    {
254
      ASSERT (parent == NULL);
255
      instance->hw_of_instance = me;
256
      instance->parent_of_instance = NULL;
257
      /* link this instance into the front of the devices instance list */
258
      instance->sibling_of_instance = me->instances_of_hw->instances;
259
      me->instances_of_hw->instances = instance;
260
    }
261
  if (parent != NULL)
262
    {
263
      struct hw_instance **previous;
264
      ASSERT (parent->child_of_instance == NULL);
265
      parent->child_of_instance = instance;
266
      instance->owner = parent->owner;
267
      instance->parent_of_instance = parent;
268
      /* in the devices instance list replace the parent instance with
269
         this one */
270
      instance->next = parent->next;
271
      /* replace parent with this new node */
272
      previous = &instance->owner->instances;
273
      while (*previous != parent)
274
        {
275
          ASSERT (*previous != NULL);
276
          previous = &(*previous)->next;
277
        }
278
      *previous = instance;
279
    }
280
  instance->data = data;
281
  instance->args = (args == NULL ? NULL : (char *) strdup(args));
282
  instance->path = (path == NULL ? NULL : (char *) strdup(path));
283
  cap_add (instance->owner->ihandles, instance);
284
  return instance;
285
#endif
286
}

powered by: WebSVN 2.1.0

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