Subversion Repositories scarts

/* Hardware event manager.

   Copyright (C) 1998, 2007, 2008 Free Software Foundation, Inc.

   Contributed by Cygnus Support.

This file is part of GDB, the GNU debugger.

This program 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 3 of the License, or

(at your option) any later version.

This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "hw-main.h"

#include "hw-base.h"

#include "sim-events.h"

/* The hw-events object is implemented using sim-events */

struct hw_event {

  void *data;

  struct hw *me;

  hw_event_callback *callback;

  sim_event *real;

  struct hw_event_data *entry;

};

struct hw_event_data {

  struct hw_event event;

  struct hw_event_data *next;

};

void

create_hw_event_data (struct hw *me)

{

  if (me->events_of_hw != NULL)

    hw_abort (me, "stray events");

  /* NOP */

}

void

delete_hw_event_data (struct hw *me)

{

  /* Remove the scheduled event.  */

  while (me->events_of_hw)

    hw_event_queue_deschedule (me, &me->events_of_hw->event);

}

/* Pass the H/W event onto the real callback */

static void

bounce_hw_event (SIM_DESC sd,

                 void *data)

{

  /* save the data */

  struct hw_event_data *entry = (struct hw_event_data *) data;

  struct hw *me = entry->event.me;

  void *event_data = entry->event.data;

  hw_event_callback *callback = entry->event.callback;

  struct hw_event_data **prev = &me->events_of_hw;

  while ((*prev) != entry)

    prev = &(*prev)->next;

  (*prev) = entry->next;

  hw_free (me, entry);

  callback (me, event_data); /* may not return */

}

/* Map onto the event functions */

struct hw_event *

hw_event_queue_schedule (struct hw *me,

                         signed64 delta_time,

                         hw_event_callback *callback,

                         void *data)

{

  struct hw_event *event;

  va_list dummy;

  memset (&dummy, 0, sizeof dummy);

  event = hw_event_queue_schedule_vtracef (me, delta_time, callback, data,

                                           NULL, dummy);

  return event;

}

struct hw_event *

hw_event_queue_schedule_tracef (struct hw *me,

                                signed64 delta_time,

                                hw_event_callback *callback,

                                void *data,

                                const char *fmt,

                                ...)

{

  struct hw_event *event;

  va_list ap;

  va_start (ap, fmt);

  event = hw_event_queue_schedule_vtracef (me, delta_time, callback, data, fmt, ap);

  va_end (ap);

  return event;

}

struct hw_event *

hw_event_queue_schedule_vtracef (struct hw *me,

                                 signed64 delta_time,

                                 hw_event_callback *callback,

                                 void *data,

                                 const char *fmt,

                                 va_list ap)

{

  struct hw_event_data *entry = HW_ZALLOC (me, struct hw_event_data);

  entry->next = me->events_of_hw;

  me->events_of_hw = entry;

  /* fill it in */

  entry->event.entry = entry;

  entry->event.data = data;

  entry->event.callback = callback;

  entry->event.me = me;

  entry->event.real = sim_events_schedule_vtracef (hw_system (me),

                                                   delta_time,

                                                   bounce_hw_event,

                                                   entry,

                                                   fmt, ap);

  return &entry->event;

}

void

hw_event_queue_deschedule (struct hw *me,

                           struct hw_event *event_to_remove)

{

/* ZAP the event but only if it is still in the event queue.  Note

   that event_to_remove is only de-referenced after its validity has

   been confirmed.  */

  struct hw_event_data **prev;

  for (prev = &me->events_of_hw;

       (*prev) != NULL;

       prev = &(*prev)->next)

    {

      struct hw_event_data *entry = (*prev);

      if (&entry->event == event_to_remove)

        {

          sim_events_deschedule (hw_system (me),

                                 entry->event.real);

          (*prev) = entry->next;

          hw_free (me, entry);

          return;

        }

    }

}

signed64

hw_event_queue_time (struct hw *me)

{

  return sim_events_time (hw_system (me));

}

/* Returns the time that remains before the event is raised. */

signed64

hw_event_remain_time (struct hw *me, struct hw_event *event)

{

  signed64 t;

  t = sim_events_remain_time (hw_system (me), event->real);

  return t;

}

/* Only worry about this compling on ANSI systems.

   Build with `make test-hw-events' in sim/<cpu> directory*/

#if defined (MAIN)

#include "sim-main.h"

#include <string.h>

#include <stdio.h>

static void

test_handler (struct hw *me,

              void *data)

{

  int *n = data;

  if (*n != hw_event_queue_time (me))

    abort ();

  *n = -(*n);

}

int

main (int argc,

      char **argv)

{

  host_callback *cb = ZALLOC (host_callback);

  struct sim_state *sd = sim_state_alloc (0, cb);

  struct hw *me = ZALLOC (struct hw);

  sim_pre_argv_init (sd, "test-hw-events");

  sim_post_argv_init (sd);

  me->system_of_hw = sd;

  printf ("Create hw-event-data\n");

  {

    create_hw_alloc_data (me);

    create_hw_event_data (me);

    delete_hw_event_data (me);

    delete_hw_alloc_data (me);

  }

  printf ("Create hw-events\n");

  {

    struct hw_event *a;

    struct hw_event *b;

    struct hw_event *c;

    struct hw_event *d;

    create_hw_alloc_data (me);

    create_hw_event_data (me);

    a = hw_event_queue_schedule (me, 0, NULL, NULL);

    b = hw_event_queue_schedule (me, 1, NULL, NULL);

    c = hw_event_queue_schedule (me, 2, NULL, NULL);

    d = hw_event_queue_schedule (me, 1, NULL, NULL);

    hw_event_queue_deschedule (me, c);

    hw_event_queue_deschedule (me, b);

    hw_event_queue_deschedule (me, a);

    hw_event_queue_deschedule (me, d);

    c = HW_ZALLOC (me, struct hw_event);

    hw_event_queue_deschedule (me, b); /* OOPS! */

    hw_free (me, c);

    delete_hw_event_data (me);

    delete_hw_alloc_data (me);

  }

  printf ("Schedule hw-events\n");

  {

    struct hw_event **e;

    int *n;

    int i;

    int nr = 4;

    e = HW_NZALLOC (me, struct hw_event *, nr);

    n = HW_NZALLOC (me, int, nr);

    create_hw_alloc_data (me);

    create_hw_event_data (me);

    for (i = 0; i < nr; i++)

      {

        n[i] = i;

        e[i] = hw_event_queue_schedule (me, i, test_handler, &n[i]);

      }

    sim_events_preprocess (sd, 1, 1);

    for (i = 0; i < nr; i++)

      {

        if (sim_events_tick (sd))

          sim_events_process (sd);

      }

    for (i = 0; i < nr; i++)

      {

        if (n[i] != -i)

          abort ();

        hw_event_queue_deschedule (me, e[i]);

      }

    hw_free (me, n);

    hw_free (me, e);

    delete_hw_event_data (me);

    delete_hw_alloc_data (me);

  }

  return 0;

}

#endif