Initial revision

1 files changed, 323 insertions, 0 deletions

diff --git a/sim/ppc/device_table.h b/sim/ppc/device_table.h
new file mode 100644
index 00000000000..af6c28d697d
--- /dev/null
+++ b/sim/ppc/device_table.h
@@ -0,0 +1,323 @@
+/*  This file is part of the program psim.
+
+    Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
+
+    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 2 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, write to the Free Software
+    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ 
+    */
+
+
+#ifndef _DEVICE_TABLE_H_
+#define _DEVICE_TABLE_H_
+
+#include "basics.h"
+#include "device.h"
+#include "tree.h"
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
+
+typedef struct _device_callbacks device_callbacks;
+
+
+/* The creator, returns a pointer to any data that should be allocated
+   once during (multiple) simulation runs */
+
+typedef void *(device_creator)
+     (const char *name,
+      const device_unit *unit_address,
+      const char *args);
+
+
+/* two stages of initialization */
+
+typedef void (device_init_callback)
+     (device *me);
+     
+typedef struct _device_init_callbacks {
+  device_init_callback *address; /* NULL - ignore */
+  device_init_callback *data; /* NULL - ignore */
+} device_init_callbacks;
+
+
+/* attaching/detaching a devices address space to its parent */
+
+typedef void (device_address_callback)
+     (device *me,
+      attach_type attach,
+      int space,
+      unsigned_word addr,
+      unsigned nr_bytes,
+      access_type access,
+      device *client); /*callback/default*/
+
+typedef struct _device_address_callbacks {
+  device_address_callback *attach;
+  device_address_callback *detach;
+} device_address_callbacks;
+
+
+/* I/O operations - from parent */
+
+typedef unsigned (device_io_read_buffer_callback)
+     (device *me,
+      void *dest,
+      int space,
+      unsigned_word addr,
+      unsigned nr_bytes,
+      cpu *processor,
+      unsigned_word cia);
+
+typedef unsigned (device_io_write_buffer_callback)
+     (device *me,
+      const void *source,
+      int space,
+      unsigned_word addr,
+      unsigned nr_bytes,
+      cpu *processor,
+      unsigned_word cia);
+
+typedef struct _device_io_callbacks { /* NULL - error */
+  device_io_read_buffer_callback *read_buffer;
+  device_io_write_buffer_callback *write_buffer;
+} device_io_callbacks;
+
+
+/* DMA transfers by a device via its parent */
+
+typedef unsigned (device_dma_read_buffer_callback)
+     (device *me,
+      void *dest,
+      int space,
+      unsigned_word addr,
+      unsigned nr_bytes);
+
+typedef unsigned (device_dma_write_buffer_callback)
+     (device *me,
+      const void *source,
+      int space,
+      unsigned_word addr,
+      unsigned nr_bytes,
+      int violate_read_only_section);
+
+typedef struct _device_dma_callbacks { /* NULL - error */
+  device_dma_read_buffer_callback *read_buffer;
+  device_dma_write_buffer_callback *write_buffer;
+} device_dma_callbacks;
+
+
+/* Interrupts */
+
+typedef void (device_interrupt_event_callback)
+     (device *me,
+      int my_port,
+      device *source,
+      int source_port,
+      int level,
+      cpu *processor,
+      unsigned_word cia);
+
+typedef void (device_child_interrupt_event_callback)
+     (device *me,
+      device *parent,
+      device *source,
+      int source_port,
+      int level,
+      cpu *processor,
+      unsigned_word cia);
+      
+typedef struct _device_interrupt_port_descriptor {
+  const char *name;
+  int number; 
+  int nr_ports;
+  port_direction direction;
+} device_interrupt_port_descriptor;
+
+typedef struct _device_interrupt_callbacks {
+  device_interrupt_event_callback *event;
+  device_child_interrupt_event_callback *child_event;
+  const device_interrupt_port_descriptor *ports;
+} device_interrupt_callbacks;
+
+
+/* symbolic value decoding */
+
+typedef int (device_unit_decode_callback)
+     (device *bus,
+      const char *unit,
+      device_unit *address);
+
+typedef int (device_unit_encode_callback)
+     (device *bus,
+      const device_unit *unit_address,
+      char *buf,
+      int sizeof_buf);
+
+typedef int (device_address_to_attach_address_callback)
+     (device *bus,
+      const device_unit *address,
+      int *attach_space,
+      unsigned_word *attach_address,
+      device *client);
+
+typedef int (device_size_to_attach_size_callback)
+     (device *bus,
+      const device_unit *size,
+      unsigned *nr_bytes,
+      device *client);
+
+typedef struct _device_convert_callbacks {
+  device_unit_decode_callback *decode_unit;
+  device_unit_encode_callback *encode_unit;
+  device_address_to_attach_address_callback *address_to_attach_address;
+  device_size_to_attach_size_callback *size_to_attach_size;
+} device_convert_callbacks;
+
+
+/* instances */
+
+typedef void (device_instance_delete_callback)
+     (device_instance *instance);
+
+typedef int (device_instance_read_callback)
+     (device_instance *instance,
+      void *buf,
+      unsigned_word len);
+
+typedef int (device_instance_write_callback)
+     (device_instance *instance,
+      const void *buf,
+      unsigned_word len);
+
+typedef int (device_instance_seek_callback)
+     (device_instance *instance,
+      unsigned_word pos_hi,
+      unsigned_word pos_lo);
+
+typedef int (device_instance_method)
+     (device_instance *instance,
+      int n_stack_args,
+      unsigned_cell stack_args[/*n_stack_args*/],
+      int n_stack_returns,
+      unsigned_cell stack_returns[/*n_stack_returns*/]);
+
+typedef struct _device_instance_methods {
+  const char *name;
+  device_instance_method *method;
+} device_instance_methods;
+
+struct _device_instance_callbacks { /* NULL - error */
+  device_instance_delete_callback *delete;
+  device_instance_read_callback *read;
+  device_instance_write_callback *write;
+  device_instance_seek_callback *seek;
+  const device_instance_methods *methods;
+};
+
+typedef device_instance *(device_create_instance_callback)
+     (device *me,
+      const char *full_path,
+      const char *args);
+
+typedef device_instance *(package_create_instance_callback)
+     (device_instance *parent,
+      const char *args);
+
+
+/* all else fails */
+
+typedef int (device_ioctl_callback)
+     (device *me,
+      cpu *processor,
+      unsigned_word cia,
+      device_ioctl_request request,
+      va_list ap);
+
+typedef void (device_usage_callback)
+     (int verbose);
+
+
+/* the callbacks */
+
+struct _device_callbacks {
+
+  /* initialization */
+  device_init_callbacks init;
+
+  /* address/data config - from child */
+  device_address_callbacks address;
+
+  /* address/data transfer - from parent */
+  device_io_callbacks io;
+
+  /* address/data transfer - from child */
+  device_dma_callbacks dma;
+
+  /* interrupt signalling */
+  device_interrupt_callbacks interrupt;
+
+  /* bus address decoding */
+  device_convert_callbacks convert;
+
+  /* instances */
+  device_create_instance_callback *instance_create;
+
+  /* back door to anything we've forgot */
+  device_ioctl_callback *ioctl;
+  device_usage_callback *usage;
+};
+
+
+/* Table of all the devices and a function to lookup/create a device
+   from its name */
+
+typedef struct _device_descriptor device_descriptor;
+struct _device_descriptor {
+  const char *name;
+  device_creator *creator;
+  const device_callbacks *callbacks;
+};
+
+extern const device_descriptor *const device_table[];
+#include "hw.h"
+
+
+/* Pass through, ignore and generic callback functions.  A call going
+   towards the root device are passed on up, local calls are ignored
+   and call downs abort */
+
+extern device_address_callback passthrough_device_address_attach;
+extern device_address_callback passthrough_device_address_detach;
+extern device_dma_read_buffer_callback passthrough_device_dma_read_buffer;
+extern device_dma_write_buffer_callback passthrough_device_dma_write_buffer;
+
+extern device_unit_decode_callback ignore_device_unit_decode;
+
+extern device_init_callback generic_device_init_address;
+extern device_unit_decode_callback generic_device_unit_decode;
+extern device_unit_encode_callback generic_device_unit_encode;
+extern device_address_to_attach_address_callback generic_device_address_to_attach_address;
+extern device_size_to_attach_size_callback generic_device_size_to_attach_size;
+
+
+extern const device_callbacks passthrough_device_callbacks;
+
+#endif /* _DEVICE_TABLE_H_ */