sim/ppc/device_table.h

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