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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [sim/] [common/] [hw-ports.c] - Blame information for rev 225

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

Line No. Rev Author Line
1 24 jeremybenn 
/* Hardware ports.
2 
   Copyright (C) 1998, 2007, 2008 Free Software Foundation, Inc.
3 
   Contributed by Andrew Cagney and Cygnus Solutions.
4 
 
5 
This file is part of GDB, the GNU debugger.
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 3 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, see <http://www.gnu.org/licenses/>.  */
19 
 
20 
 
21 
#include "hw-main.h"
22 
#include "hw-base.h"
23 
 
24 
#ifdef HAVE_STDLIB_H
25 
#include <stdlib.h>
26 
#endif
27 
 
28 
#ifdef HAVE_STRING_H
29 
#include <string.h>
30 
#else
31 
#ifdef HAVE_STRINGS_H
32 
#include <strings.h>
33 
#endif
34 
#endif
35 
 
36 
#include <ctype.h>
37 
 
38 
#define TRACE(x,y)
39 
 
40 
 
41 
struct hw_port_edge {
42 
  int my_port;
43 
  struct hw *dest;
44 
  int dest_port;
45 
  struct hw_port_edge *next;
46 
  object_disposition disposition;
47 
};
48 
 
49 
struct hw_port_data {
50 
  hw_port_event_method *to_port_event;
51 
  const struct hw_port_descriptor *ports;
52 
  struct hw_port_edge *edges;
53 
};
54 
 
55 
const struct hw_port_descriptor empty_hw_ports[] = {
56 
  { NULL, },
57 
};
58 
 
59 
static void
60 
panic_hw_port_event (struct hw *me,
61 
                     int my_port,
62 
                     struct hw *source,
63 
                     int source_port,
64 
                     int level)
65 
{
66 
  hw_abort (me, "no port method");
67 
}
68 
 
69 
void
70 
create_hw_port_data (struct hw *me)
71 
{
72 
  me->ports_of_hw = HW_ZALLOC (me, struct hw_port_data);
73 
  set_hw_port_event (me, panic_hw_port_event);
74 
  set_hw_ports (me, empty_hw_ports);
75 
}
76 
 
77 
void
78 
delete_hw_port_data (struct hw *me)
79 
{
80 
  hw_free (me, me->ports_of_hw);
81 
  me->ports_of_hw = NULL;
82 
}
83 
 
84 
void
85 
set_hw_ports (struct hw *me,
86 
              const struct hw_port_descriptor ports[])
87 
{
88 
  me->ports_of_hw->ports = ports;
89 
}
90 
 
91 
void
92 
set_hw_port_event (struct hw *me,
93 
                   hw_port_event_method *port_event)
94 
{
95 
  me->ports_of_hw->to_port_event = port_event;
96 
}
97 
 
98 
 
99 
static void
100 
attach_hw_port_edge (struct hw *me,
101 
                     struct hw_port_edge **list,
102 
                     int my_port,
103 
                     struct hw *dest,
104 
                     int dest_port,
105 
                     object_disposition disposition)
106 
{
107 
  struct hw_port_edge *new_edge = HW_ZALLOC (me, struct hw_port_edge);
108 
  new_edge->my_port = my_port;
109 
  new_edge->dest = dest;
110 
  new_edge->dest_port = dest_port;
111 
  new_edge->next = *list;
112 
  new_edge->disposition = disposition;
113 
  *list = new_edge;
114 
}
115 
 
116 
 
117 
static void
118 
detach_hw_port_edge (struct hw *me,
119 
                     struct hw_port_edge **list,
120 
                     int my_port,
121 
                     struct hw *dest,
122 
                     int dest_port)
123 
{
124 
  while (*list != NULL)
125 
    {
126 
      struct hw_port_edge *old_edge = *list;
127 
      if (old_edge->dest == dest
128 
          && old_edge->dest_port == dest_port
129 
          && old_edge->my_port == my_port)
130 
        {
131 
          if (old_edge->disposition == permenant_object)
132 
            hw_abort (me, "attempt to delete permenant port edge");
133 
          *list = old_edge->next;
134 
          hw_free (me, old_edge);
135 
          return;
136 
        }
137 
    }
138 
  hw_abort (me, "attempt to delete unattached port");
139 
}
140 
 
141 
 
142 
#if 0
143 
static void
144 
clean_hw_port_edges (struct hw_port_edge **list)
145 
{
146 
  while (*list != NULL)
147 
    {
148 
      struct hw_port_edge *old_edge = *list;
149 
      switch (old_edge->disposition)
150 
        {
151 
        case permenant_object:
152 
          list = &old_edge->next;
153 
          break;
154 
        case temporary_object:
155 
          *list = old_edge->next;
156 
          hw_free (me, old_edge);
157 
          break;
158 
        }
159 
    }
160 
}
161 
#endif
162 
 
163 
 
164 
/* Ports: */
165 
 
166 
void
167 
hw_port_event (struct hw *me,
168 
               int my_port,
169 
               int level)
170 
{
171 
  int found_an_edge = 0;
172 
  struct hw_port_edge *edge;
173 
  /* device's lines directly connected */
174 
  for (edge = me->ports_of_hw->edges;
175 
       edge != NULL;
176 
       edge = edge->next)
177 
    {
178 
      if (edge->my_port == my_port)
179 
        {
180 
          edge->dest->ports_of_hw->to_port_event (edge->dest,
181 
                                                  edge->dest_port,
182 
                                                  me,
183 
                                                  my_port,
184 
                                                  level);
185 
          found_an_edge = 1;
186 
        }
187 
    }
188 
  if (!found_an_edge)
189 
    hw_abort (me, "No edge for port %d", my_port);
190 
}
191 
 
192 
 
193 
void
194 
hw_port_attach (struct hw *me,
195 
                int my_port,
196 
                struct hw *dest,
197 
                int dest_port,
198 
                object_disposition disposition)
199 
{
200 
  attach_hw_port_edge (me,
201 
                       &me->ports_of_hw->edges,
202 
                       my_port,
203 
                       dest,
204 
                       dest_port,
205 
                       disposition);
206 
}
207 
 
208 
 
209 
void
210 
hw_port_detach (struct hw *me,
211 
                int my_port,
212 
                struct hw *dest,
213 
                int dest_port)
214 
{
215 
  detach_hw_port_edge (me,
216 
                       &me->ports_of_hw->edges,
217 
                       my_port,
218 
                       dest,
219 
                       dest_port);
220 
}
221 
 
222 
 
223 
void
224 
hw_port_traverse (struct hw *me,
225 
                  hw_port_traverse_function *handler,
226 
                  void *data)
227 
{
228 
  struct hw_port_edge *port_edge;
229 
  for (port_edge = me->ports_of_hw->edges;
230 
       port_edge != NULL;
231 
       port_edge = port_edge->next)
232 
    {
233 
      handler (me, port_edge->my_port,
234 
               port_edge->dest, port_edge->dest_port,
235 
               data);
236 
    }
237 
}
238 
 
239 
 
240 
int
241 
hw_port_decode (struct hw *me,
242 
                const char *port_name,
243 
                port_direction direction)
244 
{
245 
  if (port_name == NULL || port_name[0] == '\0')
246 
    return 0;
247 
  if (isdigit(port_name[0]))
248 
    {
249 
      return strtoul (port_name, NULL, 0);
250 
    }
251 
  else
252 
    {
253 
      const struct hw_port_descriptor *ports =
254 
        me->ports_of_hw->ports;
255 
      if (ports != NULL)
256 
        {
257 
          while (ports->name != NULL)
258 
            {
259 
              if (ports->direction == bidirect_port
260 
                  || ports->direction == direction)
261 
                {
262 
                  if (ports->nr_ports > 0)
263 
                    {
264 
                      int len = strlen (ports->name);
265 
                      if (strncmp (port_name, ports->name, len) == 0)
266 
                        {
267 
                          if (port_name[len] == '\0')
268 
                            return ports->number;
269 
                          else if(isdigit (port_name[len]))
270 
                            {
271 
                              int port = (ports->number
272 
                                          + strtoul (&port_name[len], NULL, 0));
273 
                              if (port >= ports->number + ports->nr_ports)
274 
                                hw_abort (me,
275 
                                          "Port %s out of range",
276 
                                          port_name);
277 
                              return port;
278 
                            }
279 
                        }
280 
                    }
281 
                  else if (strcmp (port_name, ports->name) == 0)
282 
                    return ports->number;
283 
                }
284 
              ports++;
285 
            }
286 
        }
287 
    }
288 
  hw_abort (me, "Unreconized port %s", port_name);
289 
  return 0;
290 
}
291 
 
292 
 
293 
int
294 
hw_port_encode (struct hw *me,
295 
                int port_number,
296 
                char *buf,
297 
                int sizeof_buf,
298 
                port_direction direction)
299 
{
300 
  const struct hw_port_descriptor *ports = NULL;
301 
  ports = me->ports_of_hw->ports;
302 
  if (ports != NULL) {
303 
    while (ports->name != NULL)
304 
      {
305 
        if (ports->direction == bidirect_port
306 
            || ports->direction == direction)
307 
          {
308 
            if (ports->nr_ports > 0)
309 
              {
310 
                if (port_number >= ports->number
311 
                    && port_number < ports->number + ports->nr_ports)
312 
                  {
313 
                    strcpy (buf, ports->name);
314 
                    sprintf (buf + strlen(buf), "%d", port_number - ports->number);
315 
                    if (strlen (buf) >= sizeof_buf)
316 
                      hw_abort (me, "hw_port_encode: buffer overflow");
317 
                    return strlen (buf);
318 
                  }
319 
              }
320 
            else
321 
              {
322 
                if (ports->number == port_number)
323 
                  {
324 
                    if (strlen(ports->name) >= sizeof_buf)
325 
                      hw_abort (me, "hw_port_encode: buffer overflow");
326 
                    strcpy(buf, ports->name);
327 
                    return strlen(buf);
328 
                  }
329 
              }
330 
          }
331 
        ports++;
332 
      }
333 
  }
334 
  sprintf (buf, "%d", port_number);
335 
  if (strlen(buf) >= sizeof_buf)
336 
    hw_abort (me, "hw_port_encode: buffer overflow");
337 
  return strlen(buf);
338 
}

powered by: WebSVN 2.1.0

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